src,worker: add isInternalWorker

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

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

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,

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"),

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

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

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

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