From b3d78d89f81f92a2b1467bec72107f8632e4eac9 Mon Sep 17 00:00:00 2001
From: avivkeller <me@aviv.sh>
Date: Mon, 27 Jul 2026 23:36:56 -0700
Subject: [PATCH 1/2] process: add `process.entrypoint`

Signed-off-by: avivkeller <me@aviv.sh>
---
 doc/api/process.md                          |  11 ++
 lib/internal/main/worker_thread.js          |   7 +-
 lib/internal/modules/esm/hooks.js           |   1 +
 lib/internal/process/pre_execution.js       |  22 ++++
 test/fixtures/entrypoint/check-commonjs.cjs |   5 +
 test/fixtures/entrypoint/check-module.mjs   |   4 +
 test/fixtures/entrypoint/commonjs.cjs       |   1 +
 test/fixtures/entrypoint/loader.mjs         |   4 +
 test/fixtures/entrypoint/module.mjs         |   1 +
 test/parallel/test-process-entrypoint.js    | 105 ++++++++++++++++++++
 10 files changed, 160 insertions(+), 1 deletion(-)
 create mode 100644 test/fixtures/entrypoint/check-commonjs.cjs
 create mode 100644 test/fixtures/entrypoint/check-module.mjs
 create mode 100644 test/fixtures/entrypoint/commonjs.cjs
 create mode 100644 test/fixtures/entrypoint/loader.mjs
 create mode 100644 test/fixtures/entrypoint/module.mjs
 create mode 100644 test/parallel/test-process-entrypoint.js

diff --git a/doc/api/process.md b/doc/api/process.md
index 0a7f85700ae85a..d006aea7fb3f6a 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1513,6 +1513,17 @@ emitMyWarning();
 // Emits nothing
 ```
 
+## `process.entrypoint`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {URL | undefined}
+
+The entrypoint that node was instantiated with, or {undefined} if node
+was instantiated without one (e.g., in the REPL).
+
 ## `process.env`
 
 <!-- YAML
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 8a58dc0cba0f49..85f8a45d3ca570 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -14,6 +14,7 @@ const {
 } = primordials;
 
 const {
+  defineEntrypoint,
   prepareWorkerThreadExecution,
   initializeModuleLoaders,
   markBootstrapComplete,
@@ -133,7 +134,11 @@ port.on('message', (message) => {
     workerIo.sharedCwdCounter = cwdCounter;
 
     const isLoaderHookWorker = (filename === 'internal/modules/esm/worker' && doEval === 'internal');
-    if (!isLoaderHookWorker) {
+    if (isLoaderHookWorker) {
+      const { URL } = require('internal/url');
+      defineEntrypoint(workerData.entrypoint === undefined ?
+        undefined : new URL(workerData.entrypoint));
+    } else {
       // If we are in the loader hook worker, delay the module loader initializations until
       // initializeAsyncLoaderHooksOnLoaderHookWorker() which needs to run preloads
       // after the asynchronous loader hooks are registered.
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 4ced5521aca203..2c7566cde213db 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -530,6 +530,7 @@ class AsyncLoaderHookWorker {
       stdout: false,
       trackUnmanagedFds: false,
       workerData: {
+        entrypoint: process.entrypoint?.href,
         lock,
       },
     });
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 804d588b62ba19..b09ff3d3169e3f 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -27,6 +27,7 @@ const {
   setupCoverageHooks,
   emitExperimentalWarning,
   deprecate,
+  getCWDURL,
 } = require('internal/util');
 
 const {
@@ -254,6 +255,16 @@ function refreshRuntimeOptions() {
   refreshOptions();
 }
 
+function defineEntrypoint(entrypoint) {
+  ObjectDefineProperty(process, 'entrypoint', {
+    __proto__: null,
+    writable: false,
+    enumerable: true,
+    configurable: true,
+    value: entrypoint,
+  });
+}
+
 /**
  * Patch the process object with legacy properties and normalizations.
  * Replace `process.argv[0]` with `process.execPath`, preserving the original `argv[0]` value as `process.argv0`.
@@ -294,6 +305,16 @@ function patchProcessObject(expandArgv1) {
     }
   }
 
+  let entrypoint;
+  if (mainEntry !== undefined) {
+    const { pathToFileURL } = require('internal/url');
+    entrypoint = pathToFileURL(mainEntry);
+  } else if (getOptionValue('--entry-url') && process.argv[1]) {
+    const { URL } = require('internal/url');
+    entrypoint = new URL(process.argv[1], getCWDURL());
+  }
+  defineEntrypoint(entrypoint);
+
   // We need to initialize the global console here again with process.stdout
   // and friends for snapshot deserialization.
   const globalConsole = require('internal/console/global');
@@ -824,6 +845,7 @@ function getHeapSnapshotFilename(diagnosticDir) {
 }
 
 module.exports = {
+  defineEntrypoint,
   initializeModuleLoaders,
   prepareMainThreadExecution,
   prepareWorkerThreadExecution,
diff --git a/test/fixtures/entrypoint/check-commonjs.cjs b/test/fixtures/entrypoint/check-commonjs.cjs
new file mode 100644
index 00000000000000..9e11d41631d79f
--- /dev/null
+++ b/test/fixtures/entrypoint/check-commonjs.cjs
@@ -0,0 +1,5 @@
+'use strict';
+
+const assert = require('node:assert');
+
+assert.strictEqual(process.entrypoint.href, process.env.NODE_TEST_ENTRYPOINT);
diff --git a/test/fixtures/entrypoint/check-module.mjs b/test/fixtures/entrypoint/check-module.mjs
new file mode 100644
index 00000000000000..07f18768647c57
--- /dev/null
+++ b/test/fixtures/entrypoint/check-module.mjs
@@ -0,0 +1,4 @@
+import assert from 'node:assert';
+import { entrypoint } from 'node:process';
+
+assert.strictEqual(entrypoint.href, process.env.NODE_TEST_ENTRYPOINT);
diff --git a/test/fixtures/entrypoint/commonjs.cjs b/test/fixtures/entrypoint/commonjs.cjs
new file mode 100644
index 00000000000000..f1c28fad08aea1
--- /dev/null
+++ b/test/fixtures/entrypoint/commonjs.cjs
@@ -0,0 +1 @@
+console.log(process.entrypoint.href);
diff --git a/test/fixtures/entrypoint/loader.mjs b/test/fixtures/entrypoint/loader.mjs
new file mode 100644
index 00000000000000..07f18768647c57
--- /dev/null
+++ b/test/fixtures/entrypoint/loader.mjs
@@ -0,0 +1,4 @@
+import assert from 'node:assert';
+import { entrypoint } from 'node:process';
+
+assert.strictEqual(entrypoint.href, process.env.NODE_TEST_ENTRYPOINT);
diff --git a/test/fixtures/entrypoint/module.mjs b/test/fixtures/entrypoint/module.mjs
new file mode 100644
index 00000000000000..f1c28fad08aea1
--- /dev/null
+++ b/test/fixtures/entrypoint/module.mjs
@@ -0,0 +1 @@
+console.log(process.entrypoint.href);
diff --git a/test/parallel/test-process-entrypoint.js b/test/parallel/test-process-entrypoint.js
new file mode 100644
index 00000000000000..22be9d1ad86c5a
--- /dev/null
+++ b/test/parallel/test-process-entrypoint.js
@@ -0,0 +1,105 @@
+'use strict';
+
+const { spawnPromisified } = require('../common');
+const fixtures = require('../common/fixtures');
+
+const assert = require('node:assert');
+const { execPath } = require('node:process');
+const { describe, it } = require('node:test');
+
+const cjsFixture = fixtures.path('entrypoint', 'commonjs.cjs');
+const cjsFixtureURL = fixtures.fileURL('entrypoint', 'commonjs.cjs').href;
+
+const mjsFixture = fixtures.path('entrypoint', 'module.mjs');
+const mjsFixtureURL = fixtures.fileURL('entrypoint', 'module.mjs').href;
+
+const cjsPreload = fixtures.path('entrypoint', 'check-commonjs.cjs');
+const esmPreload = fixtures.fileURL('entrypoint', 'check-module.mjs').href;
+const loader = fixtures.fileURL('entrypoint', 'loader.mjs').href;
+
+const printEntrypoint = 'console.log(process.entrypoint?.href)';
+
+async function getEntrypoint(args, options, expected) {
+  const { code, signal, stderr, stdout } = await spawnPromisified(
+    execPath,
+    args,
+    {
+      ...options,
+      env: {
+        ...process.env,
+        NODE_TEST_ENTRYPOINT: expected,
+      },
+    },
+  );
+  assert.strictEqual(code, 0, stderr);
+  assert.strictEqual(signal, null);
+
+  return stdout.trim();
+}
+
+const testCases = [
+  {
+    name: 'is the file URL of a CommonJS entry point',
+    args: [cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'is the file URL of an ES module entry point',
+    args: [mjsFixture],
+    expected: mjsFixtureURL,
+  },
+  {
+    name: 'is absolute when passed a relative path',
+    args: ['./commonjs.cjs'],
+    options: { cwd: fixtures.path('entrypoint') },
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --require',
+    args: ['--require', cjsPreload, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --import',
+    args: ['--import', esmPreload, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when using --loader',
+    args: ['--loader', loader, cjsFixture],
+    expected: cjsFixtureURL,
+  },
+  {
+    name: 'stays correct when combining preloads and loaders',
+    args: [
+      '--require', cjsPreload,
+      '--import', esmPreload,
+      '--loader', loader,
+      mjsFixture,
+    ],
+    expected: mjsFixtureURL,
+  },
+  {
+    name: 'supports non-file --entry-url entry points',
+    args: ['--entry-url', `data:text/javascript,${printEntrypoint}`],
+    expected: `data:text/javascript,${printEntrypoint}`,
+  },
+  {
+    name: 'is undefined when evaluating CommonJS without an entry point',
+    args: ['--eval', printEntrypoint],
+    expected: 'undefined',
+  },
+  {
+    name: 'is undefined when evaluating an ES module without an entry point',
+    args: ['--input-type=module', '--eval', printEntrypoint],
+    expected: 'undefined',
+  },
+];
+
+describe('process.entrypoint', { concurrency: true }, () => {
+  for (const { name, args, options, expected } of testCases) {
+    it(name, async () => {
+      assert.strictEqual(await getEntrypoint(args, options, expected), expected);
+    });
+  }
+});

From 992b11aa78c8d4e0a968a26e7b53f1542055fdf7 Mon Sep 17 00:00:00 2001
From: avivkeller <me@aviv.sh>
Date: Tue, 28 Jul 2026 08:30:14 -0700
Subject: [PATCH 2/2] fixup!

---
 doc/api/process.md                       |  5 +++--
 lib/internal/main/worker_thread.js       | 11 ++++++-----
 lib/internal/modules/esm/hooks.js        |  1 -
 lib/internal/worker.js                   |  1 +
 test/fixtures/entrypoint/worker.cjs      |  9 +++++++++
 test/parallel/test-process-entrypoint.js | 13 +++++++++++++
 6 files changed, 32 insertions(+), 8 deletions(-)
 create mode 100644 test/fixtures/entrypoint/worker.cjs

diff --git a/doc/api/process.md b/doc/api/process.md
index d006aea7fb3f6a..f447aa66914ca4 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -1521,8 +1521,9 @@ added: REPLACEME
 
 * Type: {URL | undefined}
 
-The entrypoint that node was instantiated with, or {undefined} if node
-was instantiated without one (e.g., in the REPL).
+The entry point that Node.js was started with. Worker threads inherit this
+value. If Node.js was started without an entry point, such as in the REPL, the
+value is {undefined}.
 
 ## `process.env`
 
diff --git a/lib/internal/main/worker_thread.js b/lib/internal/main/worker_thread.js
index 85f8a45d3ca570..42bf1ee805fe2e 100644
--- a/lib/internal/main/worker_thread.js
+++ b/lib/internal/main/worker_thread.js
@@ -96,6 +96,7 @@ port.on('message', (message) => {
       argv,
       cwdCounter,
       doEval,
+      entrypoint,
       environmentData,
       filename,
       hasStdin,
@@ -104,6 +105,10 @@ port.on('message', (message) => {
       mainThreadPort,
     } = message;
 
+    const { URL } = require('internal/url');
+    defineEntrypoint(entrypoint === undefined ?
+      undefined : new URL(entrypoint));
+
     if (doEval !== 'internal') {
       if (argv !== undefined) {
         ArrayPrototypePushApply(process.argv, argv);
@@ -134,11 +139,7 @@ port.on('message', (message) => {
     workerIo.sharedCwdCounter = cwdCounter;
 
     const isLoaderHookWorker = (filename === 'internal/modules/esm/worker' && doEval === 'internal');
-    if (isLoaderHookWorker) {
-      const { URL } = require('internal/url');
-      defineEntrypoint(workerData.entrypoint === undefined ?
-        undefined : new URL(workerData.entrypoint));
-    } else {
+    if (!isLoaderHookWorker) {
       // If we are in the loader hook worker, delay the module loader initializations until
       // initializeAsyncLoaderHooksOnLoaderHookWorker() which needs to run preloads
       // after the asynchronous loader hooks are registered.
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 2c7566cde213db..4ced5521aca203 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -530,7 +530,6 @@ class AsyncLoaderHookWorker {
       stdout: false,
       trackUnmanagedFds: false,
       workerData: {
-        entrypoint: process.entrypoint?.href,
         lock,
       },
     });
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 3afd2180d705f6..d7bd9feb5e7afe 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -362,6 +362,7 @@ class Worker extends EventEmitter {
 
     this[kPort].postMessage({
       argv,
+      entrypoint: process.entrypoint?.href,
       type: messageTypes.LOAD_SCRIPT,
       filename,
       doEval,
diff --git a/test/fixtures/entrypoint/worker.cjs b/test/fixtures/entrypoint/worker.cjs
new file mode 100644
index 00000000000000..9ace1cf2a8d805
--- /dev/null
+++ b/test/fixtures/entrypoint/worker.cjs
@@ -0,0 +1,9 @@
+'use strict';
+
+const { isMainThread, workerData, Worker } = require('node:worker_threads');
+
+if (isMainThread || workerData === 'nested') {
+  new Worker(__filename, { workerData: isMainThread ? 'nested' : 'leaf' });
+} else {
+  console.log(process.entrypoint.href);
+}
diff --git a/test/parallel/test-process-entrypoint.js b/test/parallel/test-process-entrypoint.js
index 22be9d1ad86c5a..ed054ac50898eb 100644
--- a/test/parallel/test-process-entrypoint.js
+++ b/test/parallel/test-process-entrypoint.js
@@ -13,6 +13,9 @@ const cjsFixtureURL = fixtures.fileURL('entrypoint', 'commonjs.cjs').href;
 const mjsFixture = fixtures.path('entrypoint', 'module.mjs');
 const mjsFixtureURL = fixtures.fileURL('entrypoint', 'module.mjs').href;
 
+const workerFixture = fixtures.path('entrypoint', 'worker.cjs');
+const workerFixtureURL = fixtures.fileURL('entrypoint', 'worker.cjs').href;
+
 const cjsPreload = fixtures.path('entrypoint', 'check-commonjs.cjs');
 const esmPreload = fixtures.fileURL('entrypoint', 'check-module.mjs').href;
 const loader = fixtures.fileURL('entrypoint', 'loader.mjs').href;
@@ -79,6 +82,16 @@ const testCases = [
     ],
     expected: mjsFixtureURL,
   },
+  {
+    name: 'is inherited by worker threads and their preloads and loaders',
+    args: [
+      '--require', cjsPreload,
+      '--import', esmPreload,
+      '--loader', loader,
+      workerFixture,
+    ],
+    expected: workerFixtureURL,
+  },
   {
     name: 'supports non-file --entry-url entry points',
     args: ['--entry-url', `data:text/javascript,${printEntrypoint}`],