fix(sea): patch process.dlopen in worker threads (#297)

Native addons failed to load from SEA worker threads with
ERR_DLOPEN_FAILED on the raw C:\snapshot path.

Each worker thread gets its own `process` object, so the
`shared.patchDlopen()` call in sea-bootstrap-core only covers the main
thread. sea-worker-entry already reapplies `patchIntlSegmenter` for the
same reason but was missing `patchDlopen`, so workers never got the
extract-to-cache step that makes addons loadable. Classic (non-SEA) pkg
is unaffected: bootstrap.js runs in every thread and patches there.

test-90-sea-worker-threads now loads a `.node` from the snapshot inside
the worker and asserts it was extracted to the native cache. The fake
addon is not a real shared library so dlopen throws either way — the
extraction is what distinguishes patched from unpatched.

Closes #293

Claude-Session: https://claude.ai/code/session_01PUj6PfkgQHcCg2bfXucBzk

Author: robertsLando

prelude/sea-worker-entry.js

@@ -26,3 +26,8 @@ shared.setupProcessPkg(
 // Worker threads get their own Intl, so the main-thread patch does not
 // carry over — see patchIntlSegmenter in bootstrap-shared.
 shared.patchIntlSegmenter();
+
+// Same story for process.dlopen: each worker thread gets its own `process`,
+// so native addons would be handed the raw C:\snapshot path and fail with
+// ERR_DLOPEN_FAILED — see patchDlopen in bootstrap-shared.
+shared.patchDlopen(vfs.insideSnapshot);

test/test-90-sea-worker-threads/index.js

@@ -1,8 +1,18 @@
 'use strict';
 
 const { Worker } = require('worker_threads');
+const os = require('os');
 const path = require('path');
 
+// Redirect the native addon cache so the worker's dlopen check writes to a
+// throwaway directory instead of the real ~/.cache. Must be set before the
+// Worker is created — the worker copies process.env at spawn time and its
+// bootstrap reads this while patching dlopen.
+process.env.PKG_NATIVE_CACHE_PATH = path.join(
+  os.tmpdir(),
+  'pkg-test-90-native-cache',
+);
+
 function runWorker() {
   return new Promise((resolve, reject) => {
     const worker = new Worker(path.join(__dirname, 'worker.js'), {
@@ -42,6 +52,7 @@ async function main() {
     console.log('hasDirname:' + result.hasDirname);
     console.log('hasProcessPkg:' + result.hasProcessPkg);
     console.log('helperResult:' + result.helperResult);
+    console.log('addonExtracted:' + result.addonExtracted);
   } catch (e) {
     console.log('worker-error:' + e.message);
   }

test/test-90-sea-worker-threads/lib/fake.node

@@ -0,0 +1 @@
+not-a-real-shared-library

test/test-90-sea-worker-threads/main.js

@@ -3,6 +3,9 @@
 'use strict';
 
 const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const utils = require('../utils.js');
 
 // Worker thread support in SEA requires Node.js >= 22
@@ -15,6 +18,10 @@ assert(__dirname === process.cwd());
 const input = './package.json';
 const testName = 'test-90-sea-worker-threads';
 
+// Kept in sync with index.js — the worker asserts the addon landed here.
+const nativeCache = path.join(os.tmpdir(), 'pkg-test-90-native-cache');
+fs.rmSync(nativeCache, { recursive: true, force: true });
+
 const newcomers = utils.seaHostOutputs(testName);
 
 const before = utils.filesBefore(newcomers);
@@ -26,8 +33,11 @@ const expected =
   'hasFilename:true\n' +
   'hasDirname:true\n' +
   'hasProcessPkg:true\n' +
-  'helperResult:hello world\n';
+  'helperResult:hello world\n' +
+  'addonExtracted:true\n';
 
 utils.assertSeaOutput(testName, expected);
 
 utils.filesAfter(before, newcomers, { tolerateWindowsEbusy: true });
+
+fs.rmSync(nativeCache, { recursive: true, force: true });

test/test-90-sea-worker-threads/package.json

@@ -6,6 +6,9 @@
   "pkg": {
     "scripts": [
       "worker.js"
+    ],
+    "assets": [
+      "lib/fake.node"
     ]
   }
 }

test/test-90-sea-worker-threads/worker.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const { parentPort, workerData } = require('worker_threads');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
 
 // Verify we can access __filename and __dirname
 const hasFilename = typeof __filename === 'string' && __filename.length > 0;
@@ -25,10 +28,38 @@ try {
   helperResult = 'ERROR:' + e.message;
 }
 
+// Native addons can only be dlopen'd from a real filesystem path, so pkg
+// patches process.dlopen to extract them from the snapshot first. Each
+// worker thread gets its own `process`, so the main-thread patch does not
+// carry over and has to be reapplied per thread.
+//
+// fake.node is not a loadable shared library, so dlopen throws either way.
+// What distinguishes patched from unpatched is whether the addon was
+// extracted to the native cache before dlopen was called.
+let addonExtracted;
+try {
+  const addon = path.join(__dirname, 'lib', 'fake.node');
+  try {
+    require(addon);
+  } catch (_e) {
+    // expected — see above
+  }
+  const hash = crypto
+    .createHash('sha256')
+    .update(fs.readFileSync(addon))
+    .digest('hex');
+  addonExtracted = fs.existsSync(
+    path.join(process.env.PKG_NATIVE_CACHE_PATH, 'pkg', hash, 'fake.node'),
+  );
+} catch (e) {
+  addonExtracted = 'ERROR:' + e.message;
+}
+
 parentPort.postMessage({
   echo: workerData.message,
   hasFilename,
   hasDirname,
   hasProcessPkg,
   helperResult,
+  addonExtracted,
 });