@volter/tabnode 0.5.8 → 0.5.10

package/dist/assets/{runtime-worker-Cl9uKRen.js → runtime-worker-CQv8H3sj.js}

@@ -6771,6 +6771,11 @@ function __recordRun(token, run) {
     if (runs.get(token) === run) runs.delete(token);
   };
 }
+const terminations = /* @__PURE__ */ new Map();
+function __recordTermination(process2, signal) {
+  const token = tokensByProcess.get(process2);
+  if (token !== void 0) terminations.set(token, signal);
+}
 function __runFor(token) {
   return runs.get(token);
 }
@@ -17616,17 +17621,10 @@ var implementation$1 = function bind2(that) {
 var implementation = implementation$1;
 var functionBind = Function.prototype.bind || implementation;
 var functionCall = Function.prototype.call;
-var functionApply;
-var hasRequiredFunctionApply;
-function requireFunctionApply() {
-  if (hasRequiredFunctionApply) return functionApply;
-  hasRequiredFunctionApply = 1;
-  functionApply = Function.prototype.apply;
-  return functionApply;
-}
+var functionApply = Function.prototype.apply;
 var reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
 var bind$2 = functionBind;
-var $apply$1 = requireFunctionApply();
+var $apply$1 = functionApply;
 var $call$2 = functionCall;
 var $reflectApply = reflectApply;
 var actualApply = $reflectApply || bind$2.call($call$2, $apply$1);
@@ -17746,7 +17744,7 @@ var hasSymbols = requireHasSymbols()();
 var getProto = requireGetProto();
 var $ObjectGPO = requireObject_getPrototypeOf();
 var $ReflectGPO = requireReflect_getPrototypeOf();
-var $apply = requireFunctionApply();
+var $apply = functionApply;
 var $call = functionCall;
 var needsEval = {};
 var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
@@ -18387,7 +18385,7 @@ function requireApplyBind() {
   if (hasRequiredApplyBind) return applyBind;
   hasRequiredApplyBind = 1;
   var bind3 = functionBind;
-  var $apply2 = requireFunctionApply();
+  var $apply2 = functionApply;
   var actualApply$1 = actualApply;
   applyBind = function applyBind2() {
     return actualApply$1(bind3, $apply2, arguments);
@@ -26656,11 +26654,13 @@ function createProcessStream(isWritable, writeImpl) {
       return stream;
     },
     // Default write implementation (no-op for readable streams)
-    write(_data, _encoding, callback) {
+    write(_data, ...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return true;
     },
-    end(_data, callback) {
+    end(...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
     },
     pipe(destination) {
@@ -26676,14 +26676,31 @@ function createProcessStream(isWritable, writeImpl) {
     }
   };
   if (writeImpl) {
-    stream.write = (data2, _encoding, callback) => {
-      const result = writeImpl(typeof data2 === "string" ? data2 : data2.toString());
+    stream.write = (data2, ...rest) => {
+      const result = writeImpl(textOf(data2));
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return result;
     };
+    stream.end = (...args) => {
+      const data2 = args[0];
+      if (typeof data2 === "string" || data2 instanceof Uint8Array) writeImpl(textOf(data2));
+      const callback = trailingCallback(args);
+      if (callback) queueMicrotask(callback);
+    };
   }
   return stream;
 }
+function textOf(data2) {
+  return typeof data2 === "string" ? data2 : new TextDecoder().decode(data2);
+}
+function trailingCallback(args) {
+  for (let index2 = args.length - 1; index2 >= 0; index2 -= 1) {
+    const value = args[index2];
+    if (typeof value === "function") return value;
+  }
+  return void 0;
+}
 const __substrateSignals = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGILL: 4, SIGTRAP: 5, SIGABRT: 6, SIGBUS: 7, SIGFPE: 8, SIGKILL: 9, SIGUSR1: 10, SIGSEGV: 11, SIGUSR2: 12, SIGPIPE: 13, SIGALRM: 14, SIGTERM: 15, SIGCHLD: 17, SIGCONT: 18, SIGSTOP: 19, SIGTSTP: 20, SIGTTIN: 21, SIGTTOU: 22, SIGURG: 23, SIGWINCH: 28 };
 const __substrateSignalNames = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));
 const __substrateBindingWarned = /* @__PURE__ */ new WeakSet();
@@ -26825,6 +26842,7 @@ function createProcess(options) {
         return true;
       }
       if (__substrateIgnoredSignals.has(name)) return true;
+      __recordTermination(proc, name);
       proc.exit(128 + __substrateSignals[name]);
       return true;
     },
@@ -70835,6 +70853,7 @@ function startChildRun(request) {
   let finished = false;
   let started = false;
   let killedBy = null;
+  let hosted = false;
   const initialStdin = [];
   let flushingInput;
   const flushStdin = () => {
@@ -70915,6 +70934,7 @@ function startChildRun(request) {
       let outcome;
       try {
         const processHost = admittedNode ? nodeProcessHostFor(token) : void 0;
+        hosted = processHost !== void 0;
         const env = { ...request.env };
         delete env[PROCESS_TOKEN_ENV];
         outcome = processHost ? await runHostedNode(processHost, {
@@ -70943,7 +70963,7 @@ function startChildRun(request) {
       }
       if (outcome.stdout.length > streamedOut) (_a4 = request.stdout) == null ? void 0 : _a4.call(request, outcome.stdout.slice(streamedOut));
       if (outcome.stderr.length > streamedErr) (_b3 = request.stderr) == null ? void 0 : _b3.call(request, outcome.stderr.slice(streamedErr));
-      end(outcome.exitCode, null);
+      end(outcome.exitCode, outcome.signal ?? null);
     })();
   };
   _activeForkedChildren += 1;
@@ -70954,6 +70974,7 @@ function startChildRun(request) {
     pid,
     kill(signal) {
       if (finished) return UV_ESRCH;
+      if (hosted && signal !== "SIGKILL" && signal !== "SIGSTOP" && signalPid(pid, signal)) return 0;
       killedBy = signal;
       controller.abort(signal);
       __releaseOwnedServers(token, false);

package/dist/http-client-transport.d.ts

@@ -15,5 +15,13 @@ export interface HttpClientExchangeResponse {
 export type HttpClientExchange = (request: HttpClientExchangeRequest) => Promise<HttpClientExchangeResponse>;
 /** Capture process attribution synchronously when the connection is requested. */
 export type HttpClientTransportFactory = () => HttpClientExchange;
+export interface HttpClientTransportOptions {
+    /**
+     * Loopback ports the host itself serves (a service of the page, not a
+     * guest's listener). Plain HTTP to one of them goes through the host
+     * exchange; every other loopback port stays the engine's own network.
+     */
+    hostPorts?: () => ReadonlySet<number>;
+}
 /** Host-only installation; guest modules receive Node's normal exports. */
-export declare function installHttpClientTransport(factory: HttpClientTransportFactory): () => void;
+export declare function installHttpClientTransport(factory: HttpClientTransportFactory, transportOptions?: HttpClientTransportOptions): () => void;

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export { createProcess } from './shims/process';
 export type { Process, ProcessEnv } from './shims/process';
 export * as path from './shims/path';
 export { httpModule as http, httpsModule as https } from './node-lib/http-module';
-export { installHttpClientTransport } from './http-client-transport';
+export { installHttpClientTransport, type HttpClientTransportOptions } from './http-client-transport';
 export type { HttpClientExchange, HttpClientExchangeRequest, HttpClientExchangeResponse, HttpClientTransportFactory } from './http-client-transport';
 export { netModule as net } from './node-lib/net-module';
 export { eventsModule as events } from './node-lib/events-module';
@@ -57,6 +57,8 @@ export interface RunResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    /** The signal whose default action ended the run's guest, as Node reports a process a signal ended. */
+    signal?: string;
 }
 export interface RunOptions {
     cwd?: string;

package/dist/index.mjs

@@ -6480,6 +6480,16 @@ function __recordRun(token, run) {
     if (runs.get(token) === run) runs.delete(token);
   };
 }
+const terminations = /* @__PURE__ */ new Map();
+function __recordTermination(process2, signal) {
+  const token = tokensByProcess.get(process2);
+  if (token !== void 0) terminations.set(token, signal);
+}
+function __takeTermination(token) {
+  const signal = terminations.get(token);
+  terminations.delete(token);
+  return signal;
+}
 function __tokenForProcess(process2) {
   return tokensByProcess.get(process2) ?? null;
 }
@@ -26839,11 +26849,13 @@ function createProcessStream(isWritable, writeImpl) {
       return stream;
     },
     // Default write implementation (no-op for readable streams)
-    write(_data, _encoding, callback) {
+    write(_data, ...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return true;
     },
-    end(_data, callback) {
+    end(...rest) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
     },
     pipe(destination) {
@@ -26859,14 +26871,31 @@ function createProcessStream(isWritable, writeImpl) {
     }
   };
   if (writeImpl) {
-    stream.write = (data2, _encoding, callback) => {
-      const result = writeImpl(typeof data2 === "string" ? data2 : data2.toString());
+    stream.write = (data2, ...rest) => {
+      const result = writeImpl(textOf(data2));
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return result;
     };
+    stream.end = (...args) => {
+      const data2 = args[0];
+      if (typeof data2 === "string" || data2 instanceof Uint8Array) writeImpl(textOf(data2));
+      const callback = trailingCallback(args);
+      if (callback) queueMicrotask(callback);
+    };
   }
   return stream;
 }
+function textOf(data2) {
+  return typeof data2 === "string" ? data2 : new TextDecoder().decode(data2);
+}
+function trailingCallback(args) {
+  for (let index2 = args.length - 1; index2 >= 0; index2 -= 1) {
+    const value = args[index2];
+    if (typeof value === "function") return value;
+  }
+  return void 0;
+}
 const __substrateSignals = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGILL: 4, SIGTRAP: 5, SIGABRT: 6, SIGBUS: 7, SIGFPE: 8, SIGKILL: 9, SIGUSR1: 10, SIGSEGV: 11, SIGUSR2: 12, SIGPIPE: 13, SIGALRM: 14, SIGTERM: 15, SIGCHLD: 17, SIGCONT: 18, SIGSTOP: 19, SIGTSTP: 20, SIGTTIN: 21, SIGTTOU: 22, SIGURG: 23, SIGWINCH: 28 };
 const __substrateSignalNames = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));
 const __substrateBindingWarned = /* @__PURE__ */ new WeakSet();
@@ -27008,6 +27037,7 @@ function createProcess(options) {
         return true;
       }
       if (__substrateIgnoredSignals.has(name)) return true;
+      __recordTermination(proc, name);
       proc.exit(128 + __substrateSignals[name]);
       return true;
     },
@@ -30527,6 +30557,7 @@ function startChildRun(request) {
   let finished = false;
   let started2 = false;
   let killedBy = null;
+  let hosted = false;
   const initialStdin = [];
   let flushingInput;
   const flushStdin = () => {
@@ -30607,6 +30638,7 @@ function startChildRun(request) {
       let outcome;
       try {
         const processHost = admittedNode ? nodeProcessHostFor(token) : void 0;
+        hosted = processHost !== void 0;
         const env = { ...request.env };
         delete env[PROCESS_TOKEN_ENV];
         outcome = processHost ? await runHostedNode(processHost, {
@@ -30635,7 +30667,7 @@ function startChildRun(request) {
       }
       if (outcome.stdout.length > streamedOut) (_a3 = request.stdout) == null ? void 0 : _a3.call(request, outcome.stdout.slice(streamedOut));
       if (outcome.stderr.length > streamedErr) (_b2 = request.stderr) == null ? void 0 : _b2.call(request, outcome.stderr.slice(streamedErr));
-      end(outcome.exitCode, null);
+      end(outcome.exitCode, outcome.signal ?? null);
     })();
   };
   _activeForkedChildren += 1;
@@ -30646,6 +30678,7 @@ function startChildRun(request) {
     pid,
     kill(signal) {
       if (finished) return UV_ESRCH;
+      if (hosted && signal !== "SIGKILL" && signal !== "SIGSTOP" && signalPid(pid, signal)) return 0;
       killedBy = signal;
       controller.abort(signal);
       __releaseOwnedServers(token, false);
@@ -35695,7 +35728,7 @@ class WorkerRuntime {
     this.worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "/assets/runtime-worker-Cl9uKRen.js",
+        "/assets/runtime-worker-CQv8H3sj.js",
         import.meta.url
       ),
       { type: "module" }
@@ -35913,7 +35946,7 @@ class DuplexStreamHandle extends LibuvStreamWrap {
 const unsupported = (detail) => Object.assign(new Error(`HTTP transport does not support ${detail}.`), { code: "ERR_HTTP_TRANSPORT_UNSUPPORTED" });
 const local = (host2) => host2 === "localhost" || host2 === "::1" || host2 === "[::1]" || /^127\./u.test(host2);
 const tlsOptions = ["ca", "cert", "key", "pfx", "passphrase", "ciphers", "secureContext", "checkServerIdentity", "minVersion", "maxVersion", "secureProtocol", "secureOptions", "session", "ALPNProtocols", "pskCallback"];
-function installHttpClientTransport(factory) {
+function installHttpClientTransport(factory, transportOptions = {}) {
   const installed2 = /* @__PURE__ */ new WeakMap();
   const live = /* @__PURE__ */ new Set();
   const collected = new FinalizationRegistry((ref2) => live.delete(ref2));
@@ -35922,8 +35955,11 @@ function installHttpClientTransport(factory) {
     if (installed2.has(prototype)) return;
     const original = prototype.createConnection;
     const connect2 = function(options, callback) {
+      var _a2;
       const host2 = String(options.hostname ?? options.host ?? "localhost").toLowerCase();
-      if (protocol === "http:" && (local(host2) || options.socketPath)) return original.call(this, options, callback);
+      if (protocol === "http:" && (local(host2) || options.socketPath) && !(local(host2) && !options.socketPath && ((_a2 = transportOptions.hostPorts) == null ? void 0 : _a2.call(transportOptions).has(Number(options.port ?? 80))))) {
+        return original.call(this, options, callback);
+      }
       try {
         if (options.socketPath || options.localAddress || options.localPort || options.lookup || options.family) throw unsupported("custom socket routing");
         if (tlsOptions.some((key) => options[key] !== void 0) || options.rejectUnauthorized === false || options.servername !== void 0 && options.servername !== host2) throw unsupported("custom TLS options");
@@ -38401,10 +38437,12 @@ function createContainer(options) {
         runCommand(command, { cwd: runOptions == null ? void 0 : runOptions.cwd, env: runOptions == null ? void 0 : runOptions.env, stdin: typeof (runOptions == null ? void 0 : runOptions.stdin) === "string" ? runOptions.stdin : void 0, processToken, vfs: vfs2 }, (error, stdout, stderr) => {
           var _a3;
           releaseRunStreams(processToken);
+          const terminatedBy = __takeTermination(processToken);
           resolve2({
             stdout: String(stdout),
             stderr: String(stderr),
-            exitCode: ((_a3 = runOptions == null ? void 0 : runOptions.signal) == null ? void 0 : _a3.aborted) ? 143 : error ? error.code ?? 1 : 0
+            exitCode: ((_a3 = runOptions == null ? void 0 : runOptions.signal) == null ? void 0 : _a3.aborted) ? 143 : error ? error.code ?? 1 : 0,
+            ...terminatedBy ? { signal: terminatedBy } : {}
           });
         });
       });

package/dist/node-process-host.d.ts

@@ -21,10 +21,12 @@ export interface NodeProcessLaunch {
     }[];
 }
 export interface NodeProcessHost {
+    /** `signal` names the signal whose default action ended the process, as Node's exit event does. */
     run(launch: NodeProcessLaunch): Promise<{
         stdout: string;
         stderr: string;
         exitCode: number;
+        signal?: string;
     }>;
 }
 export declare function nodeProcessHostInstalled(): boolean;

package/dist/process-tokens.d.ts

@@ -44,6 +44,8 @@ export declare function enterRun<T>(token: ProcessToken, fn: () => T): T;
  * releasing twice is harmless, as a run ends once.
  */
 export declare function __recordRun(token: ProcessToken, run: OwnedRun): () => void;
+export declare function __recordTermination(process: Process, signal: string): void;
+export declare function __takeTermination(token: ProcessToken): string | undefined;
 /** Bound guest globals retain their actual process across native await turns. */
 export declare function __tokenForProcess(process: Process): ProcessToken | null;
 /** The run recorded under this name, while it lasts. */

package/dist/shims/process.d.ts

@@ -42,8 +42,8 @@ interface ProcessStream {
     getColorDepth: () => number;
 }
 interface ProcessWritableStream extends ProcessStream {
-    write: (data: string | Buffer, encoding?: string, callback?: () => void) => boolean;
-    end?: (data?: string, callback?: () => void) => void;
+    write: (data: string | Buffer, ...rest: unknown[]) => boolean;
+    end?: (...args: unknown[]) => void;
 }
 /**
  * `process.stdin` is a readable stream on Node -- a `net.Socket` when fd 0 is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/tabnode",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "Node's own library, in a browser tab.",
   "type": "module",
   "license": "MIT",

package/src/http-client-transport.ts

@@ -33,8 +33,17 @@ const unsupported = (detail: string): Error => Object.assign(new Error(`HTTP tra
 const local = (host: string): boolean => host === 'localhost' || host === '::1' || host === '[::1]' || /^127\./u.test(host);
 const tlsOptions = ['ca', 'cert', 'key', 'pfx', 'passphrase', 'ciphers', 'secureContext', 'checkServerIdentity', 'minVersion', 'maxVersion', 'secureProtocol', 'secureOptions', 'session', 'ALPNProtocols', 'pskCallback'];
 
+export interface HttpClientTransportOptions {
+  /**
+   * Loopback ports the host itself serves (a service of the page, not a
+   * guest's listener). Plain HTTP to one of them goes through the host
+   * exchange; every other loopback port stays the engine's own network.
+   */
+  hostPorts?: () => ReadonlySet<number>;
+}
+
 /** Host-only installation; guest modules receive Node's normal exports. */
-export function installHttpClientTransport(factory: HttpClientTransportFactory): () => void {
+export function installHttpClientTransport(factory: HttpClientTransportFactory, transportOptions: HttpClientTransportOptions = {}): () => void {
   type AgentPrototype = { createConnection: (...args: any[]) => any };
   const installed = new WeakMap<AgentPrototype, { original: AgentPrototype['createConnection']; connect: AgentPrototype['createConnection'] }>();
   const live = new Set<WeakRef<AgentPrototype>>();
@@ -45,8 +54,11 @@ export function installHttpClientTransport(factory: HttpClientTransportFactory):
     const original = prototype.createConnection;
     const connect = function(this: unknown, options: Record<string, any>, callback: (error: Error | null, socket?: unknown) => void): unknown {
       const host = String(options.hostname ?? options.host ?? 'localhost').toLowerCase();
-      // Plain local HTTP is the engine's existing virtual network.
-      if (protocol === 'http:' && (local(host) || options.socketPath)) return original.call(this, options, callback);
+      // Plain local HTTP is the engine's existing virtual network, except a port the host serves itself.
+      if (protocol === 'http:' && (local(host) || options.socketPath)
+        && !(local(host) && !options.socketPath && transportOptions.hostPorts?.().has(Number(options.port ?? 80)))) {
+        return original.call(this, options, callback);
+      }
       try {
         if (options.socketPath || options.localAddress || options.localPort || options.lookup || options.family) throw unsupported('custom socket routing');
         if (tlsOptions.some(key => options[key] !== undefined) || options.rejectUnauthorized === false

package/src/index.ts

@@ -24,7 +24,7 @@ export { createProcess } from './shims/process';
 export type { Process, ProcessEnv } from './shims/process';
 export * as path from './shims/path';
 export { httpModule as http, httpsModule as https } from './node-lib/http-module';
-export { installHttpClientTransport } from './http-client-transport';
+export { installHttpClientTransport, type HttpClientTransportOptions } from './http-client-transport';
 export type { HttpClientExchange, HttpClientExchangeRequest, HttpClientExchangeResponse, HttpClientTransportFactory } from './http-client-transport';
 import { __releaseOwnedServers, __ownedServerPorts } from './node-lib/net-module';
 export { netModule as net } from './node-lib/net-module';
@@ -58,7 +58,7 @@ import { __adoptHandle, ownerOf, type OwnedHandle } from './node-lib/binding/han
 import { listenerOnPort } from './node-lib/binding/tcp_wrap';
 import { nativeStreamOwnerPid } from './native-stream-owner';
 
-import { __currentProcessToken, __runFor, __signalOwnedProcess, __stopOwnedProcess, runPid, processByPid } from './process-tokens';
+import { __currentProcessToken, __runFor, __signalOwnedProcess, __takeTermination, __stopOwnedProcess, runPid, processByPid } from './process-tokens';
 export { runPid, processByPid };
 export { createProcessRegistryScope, installProcessRegistry, ownerProcessRegistryScope, ownerProcessTable } from './process-tokens';
 export { installNodeProcessHost, nodeProcessHostInstalled } from './node-process-host';
@@ -72,6 +72,8 @@ export interface RunResult {
   stdout: string;
   stderr: string;
   exitCode: number;
+  /** The signal whose default action ended the run's guest, as Node reports a process a signal ended. */
+  signal?: string;
 }
 
 export interface RunOptions {
@@ -198,10 +200,12 @@ export function createContainer(options?: ContainerOptions): {
         // piped, as it does in a Node shell.
         runCommand(command, { cwd: runOptions?.cwd, env: runOptions?.env, stdin: typeof runOptions?.stdin === 'string' ? runOptions.stdin : undefined, processToken, vfs }, (error, stdout, stderr) => {
           releaseRunStreams(processToken);
+          const terminatedBy = __takeTermination(processToken);
           resolve({
             stdout: String(stdout),
             stderr: String(stderr),
             exitCode: runOptions?.signal?.aborted ? 143 : error ? (error.code ?? 1) : 0,
+            ...(terminatedBy ? { signal: terminatedBy } : {}),
           });
         });
       });

package/src/node-process-host.ts

@@ -20,7 +20,8 @@ export interface NodeProcessLaunch {
 }
 
 export interface NodeProcessHost {
-  run(launch: NodeProcessLaunch): Promise<{ stdout: string; stderr: string; exitCode: number }>;
+  /** `signal` names the signal whose default action ended the process, as Node's exit event does. */
+  run(launch: NodeProcessLaunch): Promise<{ stdout: string; stderr: string; exitCode: number; signal?: string }>;
 }
 
 let host: NodeProcessHost | undefined;

package/src/process-tokens.ts

@@ -78,6 +78,22 @@ export function __recordRun(token: ProcessToken, run: OwnedRun): () => void {
   };
 }
 
+/**
+ * The signal whose default action ended a run's guest, kept under the run's
+ * name until the run reports its result: Node reports such a process as ended
+ * by that signal, not by the exit code its default action implies.
+ */
+const terminations = new Map<ProcessToken, string>();
+export function __recordTermination(process: Process, signal: string): void {
+  const token = tokensByProcess.get(process);
+  if (token !== undefined) terminations.set(token, signal);
+}
+export function __takeTermination(token: ProcessToken): string | undefined {
+  const signal = terminations.get(token);
+  terminations.delete(token);
+  return signal;
+}
+
 /** Bound guest globals retain their actual process across native await turns. */
 export function __tokenForProcess(process: Process): ProcessToken | null {
   return tokensByProcess.get(process) ?? null;

package/src/shims/child_process.ts

@@ -60,7 +60,7 @@ import { __substrateExecPath, __substrateProgramName, __substrateLineFor, __subs
 
 import { __substrateChildren, __onUncaughtException, __reportUncaughtException } from './process';
 
-import { PROCESS_TOKEN_ENV, __recordRun, __runFor, __currentProcessToken, __lastLaunchedToken, __setLastLaunchedToken, __stopOwnedProcess, enterRun, mintPid, setRunPid, runPid, forgetRunPid, type ProcessToken } from '../process-tokens';
+import { PROCESS_TOKEN_ENV, __recordRun, __runFor, __currentProcessToken, __lastLaunchedToken, __setLastLaunchedToken, __stopOwnedProcess, enterRun, mintPid, setRunPid, runPid, forgetRunPid, signalPid, type ProcessToken } from '../process-tokens';
 /** The host's own `process`, where it has one that emits, taken as the shim loads and before any guest's takes the global name. */
 const __hostProcess: { on(event: string, listener: (reason: unknown) => void): unknown; off(event: string, listener: (reason: unknown) => void): unknown } | null =
   typeof process !== 'undefined' && process !== null && typeof (process as { on?: unknown }).on === 'function' && typeof (process as { off?: unknown }).off === 'function'
@@ -1399,6 +1399,7 @@ interface CommandOutcome {
   stdout: string;
   stderr: string;
   exitCode: number;
+  signal?: string;
 }
 
 /** What a caller gives one run of a command line. */
@@ -1726,6 +1727,8 @@ function startChildRun(request: RunRequest): StartedRun {
   let finished = false;
   let started = false;
   let killedBy: string | null = null;
+  // Whether the child runs on the process host, in a realm of its own.
+  let hosted = false;
   /** What the parent wrote to the child's fd 0 before the command began. */
   const initialStdin: Uint8Array[] = [];
 
@@ -1812,6 +1815,7 @@ function startChildRun(request: RunRequest): StartedRun {
       let outcome: CommandOutcome;
       try {
         const processHost = admittedNode ? nodeProcessHostFor(token) : undefined;
+        hosted = processHost !== undefined;
         const env = { ...request.env };
         delete env[PROCESS_TOKEN_ENV];
         outcome = processHost ? await runHostedNode(processHost, {
@@ -1837,7 +1841,7 @@ function startChildRun(request: RunRequest): StartedRun {
       // its own as it went, and only what it has not already sent is left.
       if (outcome.stdout.length > streamedOut) request.stdout?.(outcome.stdout.slice(streamedOut));
       if (outcome.stderr.length > streamedErr) request.stderr?.(outcome.stderr.slice(streamedErr));
-      end(outcome.exitCode, null);
+      end(outcome.exitCode, outcome.signal ?? null);
     })();
   };
 
@@ -1850,6 +1854,11 @@ function startChildRun(request: RunRequest): StartedRun {
     pid,
     kill(signal: string): number {
       if (finished) return UV_ESRCH;
+      // A child in a realm of its own takes a catchable signal as a machine's
+      // process does: its listeners run, else its default action ends it, and
+      // it ends by its own outcome. Only when nothing there receives it does
+      // the parent end it here.
+      if (hosted && signal !== 'SIGKILL' && signal !== 'SIGSTOP' && signalPid(pid, signal)) return 0;
       killedBy = signal;
       controller.abort(signal);
       __releaseOwnedServers(token, false);

package/src/shims/process.ts

@@ -10,7 +10,7 @@ import { Readable } from '../node-lib/stream-module';
 import { loadNodeLibFor } from '../node-lib/load';
 import { constantsBinding } from './constants';
 import ttyWrapBinding from '../node-lib/binding/tty_wrap';
-import { mintPid, pidIsLive, signalPid } from '../process-tokens';
+import { mintPid, pidIsLive, signalPid, __recordTermination } from '../process-tokens';
 import { NODE_LTS_VERSION, nodeVersions } from '../node-lib/node-versions';
 import { freemem as osFreemem } from './os';
 
@@ -60,8 +60,8 @@ interface ProcessStream {
 }
 
 interface ProcessWritableStream extends ProcessStream {
-  write: (data: string | Buffer, encoding?: string, callback?: () => void) => boolean;
-  end?: (data?: string, callback?: () => void) => void;
+  write: (data: string | Buffer, ...rest: unknown[]) => boolean;
+  end?: (...args: unknown[]) => void;
 }
 
 /**
@@ -302,11 +302,13 @@ function createProcessStream(
       return stream;
     },
     // Default write implementation (no-op for readable streams)
-    write(_data: string | Buffer, _encoding?: string, callback?: () => void) {
+    write(_data: string | Buffer, ...rest: unknown[]) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return true;
     },
-    end(_data?: string, callback?: () => void) {
+    end(...rest: unknown[]) {
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
     },
     pipe(destination: unknown) {
@@ -324,16 +326,42 @@ function createProcessStream(
 
   // Override write for actual writable streams
   if (isWritable && writeImpl) {
-    stream.write = (data: string | Buffer, _encoding?: string, callback?: () => void) => {
-      const result = writeImpl(typeof data === 'string' ? data : data.toString());
+    stream.write = (data: string | Buffer, ...rest: unknown[]) => {
+      const result = writeImpl(textOf(data));
+      const callback = trailingCallback(rest);
       if (callback) queueMicrotask(callback);
       return result;
     };
+    stream.end = (...args: unknown[]) => {
+      const data = args[0];
+      if (typeof data === 'string' || data instanceof Uint8Array) writeImpl(textOf(data));
+      const callback = trailingCallback(args);
+      if (callback) queueMicrotask(callback);
+    };
   }
 
   return stream;
 }
 
+/** A chunk's text: bytes, a Buffer's or a plain Uint8Array's, are UTF-8. */
+function textOf(data: string | Uint8Array): string {
+  return typeof data === 'string' ? data : new TextDecoder().decode(data);
+}
+
+/**
+ * Node's `write(chunk[, encoding][, callback])` and `end([chunk][, encoding][, callback])`:
+ * the callback is whichever argument is a function. `stdout.write('', done)`
+ * is how a program waits for its output to be flushed before it exits, and a
+ * callback read only from the third place never ran.
+ */
+function trailingCallback(args: readonly unknown[]): (() => void) | undefined {
+  for (let index = args.length - 1; index >= 0; index -= 1) {
+    const value = args[index];
+    if (typeof value === 'function') return value as () => void;
+  }
+  return undefined;
+}
+
 /** The signal numbers a guest sees, and the signals a tab must ignore. */
 const __substrateSignals: Record<string, number> = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGILL: 4, SIGTRAP: 5, SIGABRT: 6, SIGBUS: 7, SIGFPE: 8, SIGKILL: 9, SIGUSR1: 10, SIGSEGV: 11, SIGUSR2: 12, SIGPIPE: 13, SIGALRM: 14, SIGTERM: 15, SIGCHLD: 17, SIGCONT: 18, SIGSTOP: 19, SIGTSTP: 20, SIGTTIN: 21, SIGTTOU: 22, SIGURG: 23, SIGWINCH: 28 };
 const __substrateSignalNames: Record<number, string> = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));
@@ -584,6 +612,7 @@ export function createProcess(options?: {
         return true;
       }
       if (__substrateIgnoredSignals.has(name)) return true;
+      __recordTermination(proc as never, name);
       proc.exit(128 + __substrateSignals[name]);
       return true;
     },