src,worker: add isInternalWorker

doc/api/worker_threads.md

@@ -100,25 +100,42 @@ if (isMainThread) {
 }
 ```
 
-## `worker.isInternalWorker`
+## `worker.isInternalThread`
 
 <!-- YAML
 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
+```bash
+node --experimental-loader ./loader.js main.js
+```
+
+```cjs
 // loader.js
-const { isInternalWorker } = require('node:worker_threads');
+const { isInternalThread } = require('node:worker_threads');
+console.log(isInternalThread);  // true
+```
 
-console.log(isInternalWorker);  // Prints 'true'.
+```mjs
+// loader.js
+import { isInternalThread } from 'node:worker_threads';
+console.log(isInternalThread);  // true
 ```
 
-```bash
-node --no-warnings --experimental-loader ./loader.js --eval ""
+```cjs
+// main.js
+const { isInternalThread } = require('node:worker_threads');
+console.log(isInternalThread);  // false
+```
+
+```mjs
+// main.js
+import { isInternalThread } from 'node:worker_threads';
+console.log(isInternalThread);  // false
 ```
 
 ## `worker.isMainThread`

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) : {},

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,

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();
 

test/fixtures/loader-is-internal-thread.js

@@ -0,0 +1,3 @@
+const { isInternalThread } = require('node:worker_threads');
+
+console.log(isInternalThread);

test/fixtures/worker-is-internal-thread.js

@@ -0,0 +1,3 @@
+const { isInternalThread, parentPort } = require('node:worker_threads');
+
+parentPort.postMessage(isInternalThread);

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);
+    }));
+  });
+});