fix(sea): set process.pkg in worker threads (#270)

Classic (non-SEA) pkg sets process.pkg on every thread because
bootstrap.js runs end-to-end in both main and worker threads. In SEA
mode the worker entry only mounted the VFS and skipped setupProcessPkg,
so userland helpers that gate on 'pkg' in process (a common pattern for
picking process.cwd() vs __dirname when resolving runtime paths) saw
undefined inside workers and routed writes into the read-only snapshot.

A concrete symptom: a pino transport running in a worker thread whose
target resolves a log directory through such a check would try to open
a file under /snapshot/... and hang forever on the 'open' event; the
main thread then surfaced the misleading "the worker has exited" error
from thread-stream.writes with no real cause.

Mirror the main-thread call in sea-worker-entry.js so process.pkg
is populated consistently across threads, and extend the existing
worker-threads SEA test to assert process.pkg.entrypoint is set inside
the worker so this can't silently regress.

Co-authored-by: Claude Opus 4.7 (1M context) <[email protected]>

Author: robertsLando

prelude/sea-worker-entry.js

@@ -8,4 +8,17 @@
 // TODO: Remove the node_modules/@roberts_lando/vfs patches once
 // https://github.com/platformatic/vfs/pull/9 is merged and released.
 
-require('./sea-vfs-setup');
+var vfs = require('./sea-vfs-setup');
+var shared = require('./bootstrap-shared');
+
+// Mirror the main-thread setup for process.pkg so userland checks like
+// `'pkg' in process` / `process.pkg.entrypoint` behave consistently across
+// threads. In classic (non-SEA) pkg the worker bootstrap runs the same code
+// path as the main thread and sets this up; without it, libraries that gate
+// packaged-vs-filesystem logic on `process.pkg` misbehave in workers (e.g.,
+// a pino transport that resolves paths through such a check writes into the
+// read-only snapshot and hangs waiting for `open`).
+shared.setupProcessPkg(
+  vfs.toPlatformPath(vfs.manifest.entrypoint),
+  vfs.manifest.entrypoint,
+);

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

@@ -40,6 +40,7 @@ async function main() {
     console.log('echo:' + result.echo);
     console.log('hasFilename:' + result.hasFilename);
     console.log('hasDirname:' + result.hasDirname);
+    console.log('hasProcessPkg:' + result.hasProcessPkg);
     console.log('helperResult:' + result.helperResult);
   } catch (e) {
     console.log('worker-error:' + e.message);

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

@@ -25,6 +25,7 @@ const expected =
   'echo:ping\n' +
   'hasFilename:true\n' +
   'hasDirname:true\n' +
+  'hasProcessPkg:true\n' +
   'helperResult:hello world\n';
 
 utils.assertSeaOutput(testName, expected);

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

@@ -6,6 +6,16 @@ const { parentPort, workerData } = require('worker_threads');
 const hasFilename = typeof __filename === 'string' && __filename.length > 0;
 const hasDirname = typeof __dirname === 'string' && __dirname.length > 0;
 
+// Mirrors the main-thread compatibility contract: classic pkg sets
+// `process.pkg` in every thread, so any userland library that gates
+// behavior on `'pkg' in process` (a common pattern for picking cwd vs
+// __dirname when resolving runtime paths) expects this in workers too.
+const hasProcessPkg =
+  typeof process.pkg === 'object' &&
+  process.pkg !== null &&
+  typeof process.pkg.entrypoint === 'string' &&
+  process.pkg.entrypoint.length > 0;
+
 // Verify we can require a relative module from within the worker
 let helperResult;
 try {
@@ -19,5 +29,6 @@ parentPort.postMessage({
   echo: workerData.message,
   hasFilename,
   hasDirname,
+  hasProcessPkg,
   helperResult,
 });