From 333d9f8de326dcc47f705cd43d3de54da4e3ae43 Mon Sep 17 00:00:00 2001
From: Carlos Espa <carlos.espa@nearform.com>
Date: Sat, 4 Jan 2025 13:45:10 +0100
Subject: [PATCH 1/7] src,worker: add isInternalWorker

---
 doc/api/worker_threads.md                     | 21 ++++++++++++++++++
 lib/internal/worker.js                        |  2 ++
 lib/worker_threads.js                         |  2 ++
 src/node_worker.cc                            | 19 +++++++++++++---
 src/node_worker.h                             |  5 ++++-
 .../test-loaders-is-internal-thread.mjs       | 22 +++++++++++++++++++
 test/fixtures/loader-is-internal-worker.js    |  3 +++
 7 files changed, 70 insertions(+), 4 deletions(-)
 create mode 100644 test/es-module/test-loaders-is-internal-thread.mjs
 create mode 100644 test/fixtures/loader-is-internal-worker.js

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index c1ac8fdfc7717c..c93a6a4e6987bd 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -100,6 +100,27 @@ if (isMainThread) {
 }
 ```
 
+## `worker.isInternalWorker`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+Is `true` if this code is running inside of an internal [`Worker`][] thread (e.g a loader thread).
+
+```js
+// loader.js
+const { isInternalWorker } = require('node:worker_threads');
+
+console.log(isInternalWorker);  // Prints 'true'.
+```
+
+```bash
+node --no-warnings --experimental-loader ./loader.js --eval ""
+```
+
 ## `worker.isMainThread`
 
 <!-- YAML
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 84ae104d4b9588..b679f56de64776 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -67,6 +67,7 @@ const {
 const {
   ownsProcessState,
   isMainThread,
+  isInternalWorker,
   resourceLimits: resourceLimitsRaw,
   threadId,
   Worker: WorkerImpl,
@@ -538,6 +539,7 @@ module.exports = {
   ownsProcessState,
   kIsOnline,
   isMainThread,
+  isInternalWorker,
   SHARE_ENV,
   resourceLimits:
     !isMainThread ? makeResourceLimits(resourceLimitsRaw) : {},
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index e874671ea12221..6b50c5dd9ea9d2 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -2,6 +2,7 @@
 
 const {
   isMainThread,
+  isInternalWorker,
   SHARE_ENV,
   resourceLimits,
   setEnvironmentData,
@@ -30,6 +31,7 @@ const {
 
 module.exports = {
   isMainThread,
+  isInternalWorker,
   MessagePort,
   MessageChannel,
   markAsUncloneable,
diff --git a/src/node_worker.cc b/src/node_worker.cc
index f64609cf045441..48310b02284606 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -54,7 +54,8 @@ Worker::Worker(Environment* env,
                std::shared_ptr<PerIsolateOptions> per_isolate_opts,
                std::vector<std::string>&& exec_argv,
                std::shared_ptr<KVStore> env_vars,
-               const SnapshotData* snapshot_data)
+               const SnapshotData* snapshot_data,
+               const bool is_internal)
     : AsyncWrap(env, wrap, AsyncWrap::PROVIDER_WORKER),
       per_isolate_opts_(per_isolate_opts),
       exec_argv_(exec_argv),
@@ -63,7 +64,8 @@ Worker::Worker(Environment* env,
       name_(name),
       env_vars_(env_vars),
       embedder_preload_(env->embedder_preload()),
-      snapshot_data_(snapshot_data) {
+      snapshot_data_(snapshot_data),
+      is_internal_(is_internal) {
   Debug(this, "Creating new worker instance with thread id %llu",
         thread_id_.id);
 
@@ -687,7 +689,8 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
                               per_isolate_opts,
                               std::move(exec_argv_out),
                               env_vars,
-                              snapshot_data);
+                              snapshot_data,
+                              is_internal);
 
   CHECK(args[3]->IsFloat64Array());
   Local<Float64Array> limit_info = args[3].As<Float64Array>();
@@ -1030,6 +1033,16 @@ void CreateWorkerPerContextProperties(Local<Object> target,
             Boolean::New(isolate, env->is_main_thread()))
       .Check();
 
+  Worker* worker = env->isolate_data()->worker_context();
+  bool is_internal = worker != nullptr && worker->is_internal();
+
+  // Set the is_internal property
+  target
+      ->Set(env->context(),
+            FIXED_ONE_BYTE_STRING(isolate, "isInternalWorker"),
+            Boolean::New(isolate, is_internal))
+      .Check();
+
   target
       ->Set(env->context(),
             FIXED_ONE_BYTE_STRING(isolate, "ownsProcessState"),
diff --git a/src/node_worker.h b/src/node_worker.h
index 07fd7b460654e1..c1d8619d28a908 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -34,7 +34,8 @@ class Worker : public AsyncWrap {
          std::shared_ptr<PerIsolateOptions> per_isolate_opts,
          std::vector<std::string>&& exec_argv,
          std::shared_ptr<KVStore> env_vars,
-         const SnapshotData* snapshot_data);
+         const SnapshotData* snapshot_data,
+         const bool is_internal);
   ~Worker() override;
 
   // Run the worker. This is only called from the worker thread.
@@ -60,6 +61,7 @@ class Worker : public AsyncWrap {
 
   bool is_stopped() const;
   const SnapshotData* snapshot_data() const { return snapshot_data_; }
+  bool is_internal() const { return is_internal_; }
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CloneParentEnvVars(
@@ -132,6 +134,7 @@ class Worker : public AsyncWrap {
   Environment* env_ = nullptr;
 
   const SnapshotData* snapshot_data_ = nullptr;
+  const bool is_internal_;
   friend class WorkerThreadData;
 };
 
diff --git a/test/es-module/test-loaders-is-internal-thread.mjs b/test/es-module/test-loaders-is-internal-thread.mjs
new file mode 100644
index 00000000000000..d07b4eda6005df
--- /dev/null
+++ b/test/es-module/test-loaders-is-internal-thread.mjs
@@ -0,0 +1,22 @@
+import { spawnPromisified } from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import assert from 'node:assert';
+import { execPath } from 'node:process';
+import { describe, it } from 'node:test';
+
+describe('Worker threads do not spawn infinitely', { concurrency: !process.env.TEST_PARALLEL }, () => {
+  it('should not trigger an infinite loop when using a loader exports no recognized hooks', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--experimental-loader',
+      fixtures.fileURL('loader-is-internal-worker.js'),
+      '--eval',
+      'setTimeout(() => {},99)',
+    ]);
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^true\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+});
diff --git a/test/fixtures/loader-is-internal-worker.js b/test/fixtures/loader-is-internal-worker.js
new file mode 100644
index 00000000000000..d6dd032dc1c63a
--- /dev/null
+++ b/test/fixtures/loader-is-internal-worker.js
@@ -0,0 +1,3 @@
+const { isInternalWorker } = require('node:worker_threads');
+
+console.log(isInternalWorker);
\ No newline at end of file

From 110da20e2329ea4bbf7bfcae23e3245f9f69efa8 Mon Sep 17 00:00:00 2001
From: Carlos Espa <43477095+Ceres6@users.noreply.github.com>
Date: Sun, 5 Jan 2025 10:15:48 +0100
Subject: [PATCH 2/7] Update doc/api/worker_threads.md

Co-authored-by: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
---
 doc/api/worker_threads.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index c93a6a4e6987bd..eb2927e59a6fb7 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -108,7 +108,7 @@ added: REPLACEME
 
 * {boolean}
 
-Is `true` if this code is running inside of an internal [`Worker`][] thread (e.g a loader thread).
+Is `true` if this code is running inside of an internal [`Worker`][] thread (e.g the loader thread).
 
 ```js
 // loader.js

From c933aaa117f12e1b5e01075ed2588c768b4a2126 Mon Sep 17 00:00:00 2001
From: Carlos Espa <carlos.espa@nearform.com>
Date: Sun, 5 Jan 2025 10:29:36 +0100
Subject: [PATCH 3/7] fixup! Update doc/api/worker_threads.md

---
 doc/api/worker_threads.md                     |  6 ++--
 lib/internal/worker.js                        |  4 +--
 lib/worker_threads.js                         |  4 +--
 src/node_worker.cc                            |  2 +-
 .../test-loaders-is-internal-thread.mjs       | 22 ------------
 test/fixtures/loader-is-internal-thread.js    |  3 ++
 test/fixtures/loader-is-internal-worker.js    |  3 --
 test/fixtures/worker-is-internal-thread.js    |  3 ++
 test/parallel/test-is-internal-thread.mjs     | 36 +++++++++++++++++++
 9 files changed, 50 insertions(+), 33 deletions(-)
 delete mode 100644 test/es-module/test-loaders-is-internal-thread.mjs
 create mode 100644 test/fixtures/loader-is-internal-thread.js
 delete mode 100644 test/fixtures/loader-is-internal-worker.js
 create mode 100644 test/fixtures/worker-is-internal-thread.js
 create mode 100644 test/parallel/test-is-internal-thread.mjs

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index eb2927e59a6fb7..6adb989cc57d3f 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -100,7 +100,7 @@ if (isMainThread) {
 }
 ```
 
-## `worker.isInternalWorker`
+## `worker.isInternalThread`
 
 <!-- YAML
 added: REPLACEME
@@ -112,9 +112,9 @@ Is `true` if this code is running inside of an internal [`Worker`][] thread (e.g
 
 ```js
 // loader.js
-const { isInternalWorker } = require('node:worker_threads');
+const { isInternalThread } = require('node:worker_threads');
 
-console.log(isInternalWorker);  // Prints 'true'.
+console.log(isInternalThread);  // Prints 'true'.
 ```
 
 ```bash
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index b679f56de64776..dcc9651802c4e4 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -67,7 +67,7 @@ const {
 const {
   ownsProcessState,
   isMainThread,
-  isInternalWorker,
+  isInternalThread,
   resourceLimits: resourceLimitsRaw,
   threadId,
   Worker: WorkerImpl,
@@ -539,7 +539,7 @@ module.exports = {
   ownsProcessState,
   kIsOnline,
   isMainThread,
-  isInternalWorker,
+  isInternalThread,
   SHARE_ENV,
   resourceLimits:
     !isMainThread ? makeResourceLimits(resourceLimitsRaw) : {},
diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index 6b50c5dd9ea9d2..ab0c422270a35d 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -2,7 +2,7 @@
 
 const {
   isMainThread,
-  isInternalWorker,
+  isInternalThread,
   SHARE_ENV,
   resourceLimits,
   setEnvironmentData,
@@ -31,7 +31,7 @@ const {
 
 module.exports = {
   isMainThread,
-  isInternalWorker,
+  isInternalThread,
   MessagePort,
   MessageChannel,
   markAsUncloneable,
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 48310b02284606..e89f60afc3984c 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -1039,7 +1039,7 @@ void CreateWorkerPerContextProperties(Local<Object> target,
   // Set the is_internal property
   target
       ->Set(env->context(),
-            FIXED_ONE_BYTE_STRING(isolate, "isInternalWorker"),
+            FIXED_ONE_BYTE_STRING(isolate, "isInternalThread"),
             Boolean::New(isolate, is_internal))
       .Check();
 
diff --git a/test/es-module/test-loaders-is-internal-thread.mjs b/test/es-module/test-loaders-is-internal-thread.mjs
deleted file mode 100644
index d07b4eda6005df..00000000000000
--- a/test/es-module/test-loaders-is-internal-thread.mjs
+++ /dev/null
@@ -1,22 +0,0 @@
-import { spawnPromisified } from '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
-import assert from 'node:assert';
-import { execPath } from 'node:process';
-import { describe, it } from 'node:test';
-
-describe('Worker threads do not spawn infinitely', { concurrency: !process.env.TEST_PARALLEL }, () => {
-  it('should not trigger an infinite loop when using a loader exports no recognized hooks', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
-      '--no-warnings',
-      '--experimental-loader',
-      fixtures.fileURL('loader-is-internal-worker.js'),
-      '--eval',
-      'setTimeout(() => {},99)',
-    ]);
-
-    assert.strictEqual(stderr, '');
-    assert.match(stdout, /^true\r?\n$/);
-    assert.strictEqual(code, 0);
-    assert.strictEqual(signal, null);
-  });
-});
diff --git a/test/fixtures/loader-is-internal-thread.js b/test/fixtures/loader-is-internal-thread.js
new file mode 100644
index 00000000000000..c5aef675f44f35
--- /dev/null
+++ b/test/fixtures/loader-is-internal-thread.js
@@ -0,0 +1,3 @@
+const { isInternalThread } = require('node:worker_threads');
+
+console.log(isInternalThread);
\ No newline at end of file
diff --git a/test/fixtures/loader-is-internal-worker.js b/test/fixtures/loader-is-internal-worker.js
deleted file mode 100644
index d6dd032dc1c63a..00000000000000
--- a/test/fixtures/loader-is-internal-worker.js
+++ /dev/null
@@ -1,3 +0,0 @@
-const { isInternalWorker } = require('node:worker_threads');
-
-console.log(isInternalWorker);
\ No newline at end of file
diff --git a/test/fixtures/worker-is-internal-thread.js b/test/fixtures/worker-is-internal-thread.js
new file mode 100644
index 00000000000000..e588bb150cefda
--- /dev/null
+++ b/test/fixtures/worker-is-internal-thread.js
@@ -0,0 +1,3 @@
+const { isInternalThread, parentPort } = require('node:worker_threads');
+
+parentPort.postMessage(isInternalThread);
\ No newline at end of file
diff --git a/test/parallel/test-is-internal-thread.mjs b/test/parallel/test-is-internal-thread.mjs
new file mode 100644
index 00000000000000..686df8d77128df
--- /dev/null
+++ b/test/parallel/test-is-internal-thread.mjs
@@ -0,0 +1,36 @@
+import { spawnPromisified } from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import assert from 'node:assert';
+import { execPath } from 'node:process';
+import { describe, it } from 'node:test';
+import { isInternalThread, Worker } from 'node:worker_threads';
+import * as common from '../common/index.mjs';
+
+describe('isInternalThread is only true on InternalWorker', { concurrency: !process.env.TEST_PARALLEL }, () => {
+  it('should be true inside the loader thread', async () => {
+    const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
+      '--no-warnings',
+      '--experimental-loader',
+      fixtures.fileURL('loader-is-internal-thread.js'),
+      '--eval',
+      'setTimeout(() => {},99)',
+    ]);
+
+    assert.strictEqual(stderr, '');
+    assert.match(stdout, /^true\r?\n$/);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  it('should be false inside the main thread', async () => {
+    assert.ok(!isInternalThread);
+  });
+
+  it('should be false inside a regular worker thread', async () => {
+    const worker = new Worker(fixtures.path('worker-is-internal-thread.js'));
+
+    worker.on('message', common.mustCall((isInternalThread) => {
+      assert.ok(!isInternalThread);
+    }));
+  });
+});

From 8944cc0633965ac06b792f706e2cc2af9ffa51f1 Mon Sep 17 00:00:00 2001
From: Carlos Espa <carlos.espa@nearform.com>
Date: Sun, 5 Jan 2025 13:04:40 +0100
Subject: [PATCH 4/7] fixup! Update doc/api/worker_threads.md

---
 doc/api/worker_threads.md | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 6adb989cc57d3f..91e8b6d49f1482 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -110,15 +110,32 @@ added: REPLACEME
 
 Is `true` if this code is running inside of an internal [`Worker`][] thread (e.g the loader thread).
 
-```js
+```bash
+node --experimental-loader ./loader.js main.js
+```
+
+```cjs
 // loader.js
 const { isInternalThread } = require('node:worker_threads');
+console.log(isInternalThread);  // true
+```
+
+```mjs
+// loader.js
+import { isInternalThread } from 'node:worker_threads';
+console.log(isInternalThread);  // true
+```
 
-console.log(isInternalThread);  // Prints 'true'.
+```cjs
+// main.js
+const { isInternalThread } = require('node:worker_threads');
+console.log(isInternalThread);  // false
 ```
 
-```bash
-node --no-warnings --experimental-loader ./loader.js --eval ""
+```mjs
+// main.js
+import { isInternalThread } from 'node:worker_threads';
+console.log(isInternalThread);  // false
 ```
 
 ## `worker.isMainThread`

From 90f880bfb2dbf2596e677c093e1ceb1008f671d3 Mon Sep 17 00:00:00 2001
From: Carlos Espa <43477095+Ceres6@users.noreply.github.com>
Date: Mon, 6 Jan 2025 00:33:17 +0100
Subject: [PATCH 5/7] Apply suggestions from code review

Co-authored-by: Jacob Smith <3012099+JakobJingleheimer@users.noreply.github.com>
---
 test/fixtures/worker-is-internal-thread.js | 2 +-
 test/parallel/test-is-internal-thread.mjs  | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/fixtures/worker-is-internal-thread.js b/test/fixtures/worker-is-internal-thread.js
index e588bb150cefda..7e3f1f413830ca 100644
--- a/test/fixtures/worker-is-internal-thread.js
+++ b/test/fixtures/worker-is-internal-thread.js
@@ -1,3 +1,3 @@
 const { isInternalThread, parentPort } = require('node:worker_threads');
 
-parentPort.postMessage(isInternalThread);
\ No newline at end of file
+parentPort.postMessage(`isInternalThread: ${isInternalThread}`);
\ No newline at end of file
diff --git a/test/parallel/test-is-internal-thread.mjs b/test/parallel/test-is-internal-thread.mjs
index 686df8d77128df..dcdb00fa6ad448 100644
--- a/test/parallel/test-is-internal-thread.mjs
+++ b/test/parallel/test-is-internal-thread.mjs
@@ -6,7 +6,7 @@ import { describe, it } from 'node:test';
 import { isInternalThread, Worker } from 'node:worker_threads';
 import * as common from '../common/index.mjs';
 
-describe('isInternalThread is only true on InternalWorker', { concurrency: !process.env.TEST_PARALLEL }, () => {
+describe('worker_threads.isInternalThread', { concurrency: !process.env.TEST_PARALLEL }, () => {
   it('should be true inside the loader thread', async () => {
     const { code, signal, stdout, stderr } = await spawnPromisified(execPath, [
       '--no-warnings',
@@ -17,20 +17,20 @@ describe('isInternalThread is only true on InternalWorker', { concurrency: !proc
     ]);
 
     assert.strictEqual(stderr, '');
-    assert.match(stdout, /^true\r?\n$/);
+    assert.match(stdout, /isInternalThread: true/);
     assert.strictEqual(code, 0);
     assert.strictEqual(signal, null);
   });
 
   it('should be false inside the main thread', async () => {
-    assert.ok(!isInternalThread);
+    assert.strictEqual(isInternalThread, false);
   });
 
   it('should be false inside a regular worker thread', async () => {
     const worker = new Worker(fixtures.path('worker-is-internal-thread.js'));
 
     worker.on('message', common.mustCall((isInternalThread) => {
-      assert.ok(!isInternalThread);
+      assert.strictEqual(isInternalThread, false);
     }));
   });
 });

From eba9d06731adc4f52c96d3cc57776779e133eb00 Mon Sep 17 00:00:00 2001
From: Carlos Espa <carlos.espa@nearform.com>
Date: Mon, 6 Jan 2025 00:34:03 +0100
Subject: [PATCH 6/7] fixup! src,worker: add isInternalWorker

---
 lib/worker_threads.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/worker_threads.js b/lib/worker_threads.js
index ab0c422270a35d..1e7a175fc8638e 100644
--- a/lib/worker_threads.js
+++ b/lib/worker_threads.js
@@ -1,8 +1,8 @@
 'use strict';
 
 const {
-  isMainThread,
   isInternalThread,
+  isMainThread,
   SHARE_ENV,
   resourceLimits,
   setEnvironmentData,
@@ -30,8 +30,8 @@ const {
 } = require('internal/buffer');
 
 module.exports = {
-  isMainThread,
   isInternalThread,
+  isMainThread,
   MessagePort,
   MessageChannel,
   markAsUncloneable,

From 10cbd4a51848d49e22c0b34ba913f1458da25d9f Mon Sep 17 00:00:00 2001
From: Carlos Espa <carlos.espa@nearform.com>
Date: Mon, 6 Jan 2025 00:36:56 +0100
Subject: [PATCH 7/7] fixup! Apply suggestions from code review

---
 test/fixtures/loader-is-internal-thread.js | 2 +-
 test/parallel/test-is-internal-thread.mjs  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/fixtures/loader-is-internal-thread.js b/test/fixtures/loader-is-internal-thread.js
index c5aef675f44f35..d97328bc2075ac 100644
--- a/test/fixtures/loader-is-internal-thread.js
+++ b/test/fixtures/loader-is-internal-thread.js
@@ -1,3 +1,3 @@
 const { isInternalThread } = require('node:worker_threads');
 
-console.log(isInternalThread);
\ No newline at end of file
+console.log(`isInternalThread: ${isInternalThread}`);
\ No newline at end of file
diff --git a/test/parallel/test-is-internal-thread.mjs b/test/parallel/test-is-internal-thread.mjs
index dcdb00fa6ad448..dd8af897c219ba 100644
--- a/test/parallel/test-is-internal-thread.mjs
+++ b/test/parallel/test-is-internal-thread.mjs
@@ -29,8 +29,8 @@ describe('worker_threads.isInternalThread', { concurrency: !process.env.TEST_PAR
   it('should be false inside a regular worker thread', async () => {
     const worker = new Worker(fixtures.path('worker-is-internal-thread.js'));
 
-    worker.on('message', common.mustCall((isInternalThread) => {
-      assert.strictEqual(isInternalThread, false);
+    worker.on('message', common.mustCall((message) => {
+      assert.strictEqual(message, 'isInternalThread: false');
     }));
   });
 });