@volter/tabnode 0.5.16 → 0.5.18

package/src/node-lib/internals/amaro.ts

@@ -0,0 +1,51 @@
+/**
+ * `internal/deps/amaro/dist/index`: the type stripper Node carries.
+ *
+ * Node v22.18.0 runs a `.ts`, `.mts` or `.cts` file by erasing its types with
+ * amaro 1.1.0 (swc's stripper, built to WebAssembly), vendored under
+ * `deps/amaro`, and its own `lib/internal/modules/typescript.js` (vendored
+ * here unmodified) is what calls it. amaro is not native: it is JavaScript and
+ * WebAssembly, and this engine takes the same release as a dependency rather
+ * than writing a stripper of its own. esbuild, which the engine also carries,
+ * is not a substitute: it reprints the program (a stack's line and column move)
+ * and it transforms `enum`, `namespace` and parameter properties where Node, in
+ * strip-only mode, refuses them.
+ *
+ * amaro's glue loads its WebAssembly synchronously from bytes inlined in the
+ * package and reads `util` and `buffer`, so it is loaded through the host's own
+ * `require` where the host is Node. A browser realm has no such door: there the
+ * page supplies its stripper as `globalThis.__substrateStripTypes`, which the
+ * module loader asks first, and this answers absent.
+ */
+type AmaroTransform = (source: string, options: Record<string, unknown>) => { code: string; map?: string };
+interface Amaro { transformSync: AmaroTransform }
+
+/** The host's `process`, taken before a guest's takes the global name. */
+const hostProcess = typeof process !== 'undefined' && process !== null
+  ? (process as unknown as { getBuiltinModule?: (name: string) => unknown })
+  : null;
+
+let loaded: Amaro | null | undefined;
+
+/** amaro, loaded once from beside this engine, or null where the realm cannot load it. */
+export function hostAmaro(): Amaro | null {
+  if (loaded !== undefined) return loaded;
+  loaded = null;
+  try {
+    const moduleBuiltin = typeof hostProcess?.getBuiltinModule === 'function'
+      ? hostProcess.getBuiltinModule('module') as { createRequire?: (from: string) => (id: string) => unknown } | undefined
+      : undefined;
+    if (moduleBuiltin && typeof moduleBuiltin.createRequire === 'function') {
+      const amaro = moduleBuiltin.createRequire(import.meta.url)('amaro') as Amaro;
+      if (typeof amaro?.transformSync === 'function') loaded = amaro;
+    }
+  } catch { /* no host require, or amaro not installed beside the engine */ }
+  return loaded;
+}
+
+/** The module Node's `typescript.js` requires; absent, the error Node raises when built without amaro. */
+export function internalAmaro(): Amaro {
+  const amaro = hostAmaro();
+  if (amaro) return amaro;
+  throw Object.assign(new Error('Node.js is not compiled with TypeScript support'), { code: 'ERR_NO_TYPESCRIPT' });
+}

package/src/node-lib/internals/index.ts

@@ -26,6 +26,7 @@ import {
   internalAbortController, internalBlob, internalFile, internalWebStreamsAdapters, createWebStreamsAdapters,
 } from './buffer-and-streams';
 import { internalBootstrapRealm, internalUrl, internalEncoding } from './modules';
+import { internalAmaro } from './amaro';
 
 /** Built on the first ask, for the reason `./binding/index.ts` gives. */
 // eslint-disable-next-line no-var, vars-on-top
@@ -69,6 +70,7 @@ export function nodeLibInternal(name: string, require?: (name: string) => any, p
   'internal/process/warning': () => internalProcessWarning,
   'internal/source_map/source_map_cache': () => internalSourceMapCache,
   'internal/deps/undici/undici': () => internalUndici,
+  'internal/deps/amaro/dist/index': () => internalAmaro(),
   'internal/readline/interface': () => internalReadlineInterface,
   'internal/worker/js_transferable': () => internalJsTransferable,
 };;

package/src/node-lib/internals/runtime.ts

@@ -219,8 +219,9 @@ export const internalEventTarget = {
 };
 
 /**
- * `internal/options`: the command-line options Node's `net` reads. The engine
- * takes no command line of its own, so each is Node's own default.
+ * `internal/options`: the command-line options Node's `net`, `http` and
+ * `util` read. The engine takes no command line of its own, so each is
+ * Node's own default.
  */
 const optionValues: Record<string, unknown> = {
   '--network-family-autoselection': true,
@@ -231,10 +232,28 @@ const optionValues: Record<string, unknown> = {
   '--pending-deprecation': false,
   '--report-uncaught-exception': false,
   '--experimental-print-required-tla': false,
+  '--max-http-header-size': 16 * 1024,
+  '--insecure-http-parser': false,
+  '--enable-source-maps': false,
+  '--experimental-transform-types': false,
 };
 
+/**
+ * Options one run was started with, answered only while a call made for that
+ * run is on the stack. Node reads an option of its own process; the engine
+ * holds many processes in one realm, so a caller that knows whose call it is
+ * (the module loader stripping a `.ts` file for a run started with
+ * `--experimental-transform-types`) says so for the length of that call.
+ */
+let optionOverrides: Record<string, unknown> | null = null;
+export function withOptionValues<T>(overrides: Record<string, unknown>, fn: () => T): T {
+  const previous = optionOverrides;
+  optionOverrides = { ...(previous ?? {}), ...overrides };
+  try { return fn(); } finally { optionOverrides = previous; }
+}
+
 export const internalOptions = {
-  getOptionValue: (name: string): unknown => optionValues[name],
+  getOptionValue: (name: string): unknown => (optionOverrides !== null && name in optionOverrides ? optionOverrides[name] : optionValues[name]),
   getEmbedderOptions: () => ({ shouldNotRegisterESMLoader: false, noGlobalSearchPaths: false, noBrowserGlobals: false }),
 };
 

package/src/node-lib/node-versions.ts

@@ -25,10 +25,13 @@ export function nodeVersions(node: string = NODE_LTS_VERSION): {
   uv: string;
   webcontainer: string;
   openssl: string;
+  amaro: string;
 } {
   // `https.js` calls `assertCrypto()`, which is `!process.versions.openssl`.
   // The engine has crypto (the noble-hashes binding); Node reports openssl
   // whenever it does. A worker compiles `internal/util` against this table
   // before any guest process exists, so the name has to live here.
-  return { node, v8: "11.3.244.8", uv: "1.44.2", webcontainer: "1", openssl: "3.0.15" };
+  // `amaro` is the type stripper a `.ts` file runs through, the release Node
+  // v22.18.0 carries; `internal/util` reads it for `assertTypeScript()`.
+  return { node, v8: "11.3.244.8", uv: "1.44.2", webcontainer: "1", openssl: "3.0.15", amaro: "1.1.0" };
 }

package/src/node-lib/sources.ts

@@ -43,6 +43,7 @@ import INTERNAL_VALIDATORS from './internal/validators.js?raw';
 import INTERNAL_ABORT_LISTENER from './internal/events/abort_listener.js?raw';
 import INTERNAL_CHILD_PROCESS_SERIALIZATION from './internal/child_process/serialization.js?raw';
 import INTERNAL_MODULES_CUSTOMIZATION_HOOKS from './internal/modules/customization_hooks.js?raw';
+import INTERNAL_MODULES_TYPESCRIPT from './internal/modules/typescript.js?raw';
 import EVENTS from './events.js?raw';
 import INTERNAL_CONSTANTS from './internal/constants.js?raw';
 import INTERNAL_MIME from './internal/mime.js?raw';
@@ -142,6 +143,7 @@ export const NODE_LIB_SOURCES: Record<string, string> = {
   'internal/events/abort_listener': INTERNAL_ABORT_LISTENER,
   'internal/child_process/serialization': INTERNAL_CHILD_PROCESS_SERIALIZATION,
   'internal/modules/customization_hooks': INTERNAL_MODULES_CUSTOMIZATION_HOOKS,
+  'internal/modules/typescript': INTERNAL_MODULES_TYPESCRIPT,
   'events': EVENTS,
   'internal/constants': INTERNAL_CONSTANTS,
   'internal/mime': INTERNAL_MIME,

package/src/node-lib/typescript-module.ts

@@ -0,0 +1,50 @@
+/**
+ * A `.ts`, `.mts` or `.cts` module's types erased the way Node's loader erases
+ * them: `Module.prototype._compile` hands the source to
+ * `stripTypeScriptModuleTypes` of Node's own `internal/modules/typescript.js`
+ * (vendored, unmodified), which runs amaro in strip-only mode -- types become
+ * whitespace, so every line and column stays where the file has it -- refuses
+ * `enum`, `namespace` with values, parameter properties and the rest with
+ * `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX`, and refuses any file under
+ * `node_modules` with `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`.
+ *
+ * The file is the process's own, from the process's builtin graph: Node reads
+ * `--experimental-transform-types` once per process (`getLazy`) and emits its
+ * experimental warning on that process, which `--no-warnings` silences. The
+ * options a run was started with are answered for the length of the call;
+ * `--experimental-transform-types` implies `--enable-source-maps`, as Node's
+ * option table says.
+ */
+import { loadNodeLibFor } from './load';
+import { withOptionValues } from './internals/runtime';
+import { hostAmaro } from './internals/amaro';
+
+interface TypeScriptModule { stripTypeScriptModuleTypes(source: string, filename: string): string }
+type RunProcess = { execArgv?: readonly string[]; env?: Record<string, string | undefined> };
+
+/** Whether this realm can erase types itself: amaro is loadable here. */
+export function canStripTypes(): boolean {
+  return hostAmaro() !== null;
+}
+
+/** Whether a process was started with an option, on its command line or in `NODE_OPTIONS` (both options here are allowed there). */
+function startedWith(process: RunProcess, option: string): boolean {
+  if (Array.isArray(process.execArgv) && process.execArgv.includes(option)) return true;
+  const nodeOptions = process.env?.NODE_OPTIONS;
+  return typeof nodeOptions === 'string' && nodeOptions.split(/\s+/u).includes(option);
+}
+
+/** Whether a process transforms TypeScript-only syntax rather than refusing it. */
+export function transformsTypes(process: RunProcess): boolean {
+  return startedWith(process, '--experimental-transform-types');
+}
+
+/** The module's source with its types erased (or, under `--experimental-transform-types`, transformed), for this process. */
+export function stripModuleTypes(source: string, filename: string, process: object): string {
+  const typescript = loadNodeLibFor(process, 'internal/modules/typescript') as TypeScriptModule;
+  const transform = transformsTypes(process as RunProcess);
+  return withOptionValues({
+    '--experimental-transform-types': transform,
+    '--enable-source-maps': transform || startedWith(process as RunProcess, '--enable-source-maps'),
+  }, () => typescript.stripTypeScriptModuleTypes(source, filename));
+}

package/src/process-tokens.ts

@@ -237,6 +237,12 @@ export function forgetRunPid(token: ProcessToken): void {
   pidsOfRuns.delete(token);
 }
 
+/** The named run a pid belongs to in this realm, for a signal sent by number (the shell's `kill`). */
+export function tokenOfPid(pid: number): ProcessToken | null {
+  for (const [token, numbers] of pidsOfRuns) if (numbers.pid === pid) return token;
+  return null;
+}
+
 /** Whether a live run carries this number, which is what `kill(pid, 0)` asks. */
 export function pidIsLive(pid: number): boolean {
   return processRegistry.lookup(pid) !== undefined;

package/src/runtime.ts

@@ -66,8 +66,9 @@ import * as domainShim from './shims/domain';
 import { createWasiModule, type WasiHostFs, type WasiModule } from './shims/wasi';
 
 import { resolve as resolveExports, imports as resolveImports } from 'resolve.exports';
-import { transformEsmToCjsSimple, setNodeLowering, __cjsExports, __substrateHasEsmSyntax } from './code-transforms';
+import { transformEsmToCjsSimple, setNodeLowering, __cjsExports, __cjsObject, __substrateHasEsmSyntax } from './code-transforms';
 import { applySourceEdits } from './source-edits';
+import { canStripTypes, stripModuleTypes, transformsTypes } from './node-lib/typescript-module';
 import * as acorn from 'acorn';
 
 /**
@@ -114,6 +115,31 @@ function __substrateGuestConstructor(Constructor: unknown, process: Process): un
     return __substrateFunctionScope(__substrateGuestGlobal(process), String(compiled));
   } });
 }
+/**
+ * A `.ts`, `.mts` or `.cts` file runs with its types stripped, as Node runs
+ * one since 22.18, before the module's imports are read -- the entry a `node`
+ * command names and every module it loads alike. A page that loaded a
+ * stripper into the realm supplies it; elsewhere the engine erases the types
+ * itself, through Node's own `typescript.js` over amaro
+ * (`node-lib/typescript-module.ts`): strip-only, positions kept, the syntax
+ * Node refuses refused with Node's error. Before this, a realm with no stripper
+ * registered -- the engine under Node -- ran the file as JavaScript and died on
+ * its first type (`Unexpected identifier 'SlackReply'`), and an entry was never
+ * stripped anywhere. A realm that can load neither runs the file as it is.
+ *
+ * `format` is what a load hook named, and it decides instead of the extension
+ * where a hook gave one.
+ */
+function __substrateModuleTypes(code: string, resolvedPath: string, format: string | undefined, process: unknown): string {
+  const typescript = format === undefined
+    ? /[.](?:ts|mts|cts)$/u.test(resolvedPath) && !resolvedPath.endsWith('.d.ts')
+    : format === 'typescript' || format === 'commonjs-typescript' || format === 'module-typescript';
+  if (!typescript) return code;
+  const registered = (globalThis as { __substrateStripTypes?: (code: string, filename: string) => string }).__substrateStripTypes;
+  if (typeof registered === 'function') return registered(code, resolvedPath);
+  if (!canStripTypes()) return code;
+  return stripModuleTypes(code, resolvedPath, process as object);
+}
 /**
  * The name the script of a module's body carries.
  *
@@ -263,7 +289,12 @@ function __substrateGuestGlobal(process: Process): Record<string, unknown> {
       if (key === "fetch") { fetch = value; return true; }
       if (key === "Buffer") { buffer = value; return true; }
       if (shadowed(target, key)) return Reflect.set(target, key, value, target);
-      return Reflect.set(host, key, value, host);
+      if (Reflect.set(host, key, value, host)) return true;
+      // A global the host holds read-only (a confined realm's \`WebSocket\`) is
+      // still the guest's to replace, as Node's globals are: undici's
+      // \`install()\` assigns \`globalThis.WebSocket\` and Pi died on the refusal.
+      // The value becomes the guest's own binding; the host's is untouched.
+      return Reflect.defineProperty(target, key, { value, writable: true, configurable: true, enumerable: true });
     },
     has(target, key) { return isLocalGlobal(key) ? Reflect.has(target, key) : key === "global" || shadowed(target, key) || key in host; },
     ownKeys(target) {
@@ -448,7 +479,7 @@ function transformEsmToCjsAst(code: string, filename: string): string {
     transformed = transformEsmToCjsSimple(transformed);
 
     if (hasExportDecl) {
-      transformed = `Object.defineProperty(${__cjsExports()}, "__esModule", { value: true });\n` + transformed;
+      transformed = `${__cjsObject()}.defineProperty(${__cjsExports()}, "__esModule", { value: true });\n` + transformed;
     }
   }
 
@@ -476,7 +507,7 @@ function transformEsmToCjsRegexFallback(code: string, filename: string): string
   if (hasImport || hasExport) {
     transformed = transformEsmToCjsSimple(transformed);
     if (hasExport) {
-      transformed = `Object.defineProperty(${__cjsExports()}, "__esModule", { value: true });\n` + transformed;
+      transformed = `${__cjsObject()}.defineProperty(${__cjsExports()}, "__esModule", { value: true });\n` + transformed;
     }
   }
 
@@ -1770,7 +1801,7 @@ function createRequire(
   const prepareModuleCode = (rawCode: string, resolvedPath: string, format?: string): string => {
     // Check processed code cache (useful for HMR when module cache is cleared but code hasn't changed)
     // Use a simple hash of the content for cache key to handle content changes
-    const codeCacheKey = `${resolvedPath}|${format ?? ''}|${simpleHash(rawCode)}`;
+    const codeCacheKey = `${resolvedPath}|${format ?? ''}|${transformsTypes(process as { execArgv?: string[]; env?: Record<string, string> }) ? 'transform-types|' : ''}${simpleHash(rawCode)}`;
     let code = processedCodeCache?.get(codeCacheKey);
 
     if (!code) {
@@ -1781,16 +1812,7 @@ function createRequire(
         code = code.slice(code.indexOf('\n') + 1);
       }
 
-      // A `.ts`, `.mts` or `.cts` file runs with its types stripped, as Node
-      // runs one since 22.18: the source goes to the type stripper the realm
-      // loaded, amaro, before the module's imports are read. A realm without one
-      // runs the file as it is.
-      const __typescript = format === undefined
-        ? /[.](?:ts|mts|cts)$/u.test(resolvedPath) && !resolvedPath.endsWith('.d.ts')
-        : format === 'typescript' || format === 'commonjs-typescript' || format === 'module-typescript';
-      if (__typescript && typeof (globalThis as any).__substrateStripTypes === 'function') {
-        code = (globalThis as any).__substrateStripTypes(code, resolvedPath) as string;
-      }
+      code = __substrateModuleTypes(code, resolvedPath, format, process);
 
       // Transform ESM to CJS if needed (for .mjs files or ESM that wasn't pre-transformed)
       // transformEsmToCjs uses AST to handle import/export, import.meta, and dynamic imports
@@ -1799,12 +1821,15 @@ function createRequire(
         ? true
         : format === 'module' || format === 'module-typescript'
           ? false
-          : resolvedPath.endsWith('.cjs');
+          : resolvedPath.endsWith('.cjs') || resolvedPath.endsWith('.cts');
       if (!__commonjs) {
         // An ES module is strict wherever it runs; the mark says so to the
         // compile below, which is otherwise sloppy as a CommonJS body is.
+        // The directive shares the body's first line, as Node's one-line
+        // wrapper does, so a frame of an ES module counts the file's own lines;
+        // on a line of its own it put every frame one line below the file's.
         const lowered = transformEsmToCjs(code, resolvedPath);
-        code = lowered === code ? code : `${__substrateModuleMarker}"use strict";\n${lowered}`;
+        code = lowered === code ? code : `${__substrateModuleMarker}"use strict";${lowered}`;
       } else {
         // A `.cjs` module skips the ESM transform, and with it the rewrite of
         // `import(...)` to the engine's dynamic import, so its
@@ -2369,10 +2394,13 @@ export class Runtime {
       code = code.slice(code.indexOf('\n') + 1);
     }
 
+    code = __substrateModuleTypes(code, filename, undefined, this.process);
+
     // Transform ESM to CJS if needed (AST-based, handles import.meta and dynamic imports too)
-    if (!filename.endsWith('.cjs')) {
+    if (!filename.endsWith('.cjs') && !filename.endsWith('.cts')) {
       const lowered = transformEsmToCjs(code, filename);
-      code = lowered === code ? code : `${__substrateModuleMarker}"use strict";\n${lowered}`;
+      // The directive shares the body's first line, as `prepareModuleCode`'s does.
+      code = lowered === code ? code : `${__substrateModuleMarker}"use strict";${lowered}`;
     } else {
       // A `.cjs` module skips the ESM transform, and with it the rewrite of
       // `import(...)` to the engine's dynamic import, so its
@@ -2680,6 +2708,56 @@ forGuestRealm(() => {
   }
 });
 
+forGuestRealm(() => {
+  // Node's `stream.finished()` on a web stream waits on a promise Node's own
+  // web streams carry (`nodejs.webstream.isClosedPromise`), settled when the
+  // stream closes or errors, and undici's fetch finalizes every response that
+  // way. The worker's streams are the browser's and carry none, so a stream a
+  // guest constructs is given one, settled by its own controller. The
+  // constructor stays the browser's (a proxy of it), so a stream the platform
+  // made is still `instanceof ReadableStream`.
+  const kIsClosedPromise = Symbol.for('nodejs.webstream.isClosedPromise');
+  const Native = globalThis.ReadableStream;
+  if (typeof Native !== 'function' || (Native as unknown as { __substrateClosedPromise?: boolean }).__substrateClosedPromise) return;
+  type Source = { start?: (controller: unknown) => unknown; pull?: (controller: unknown) => unknown; cancel?: (reason: unknown) => unknown };
+  const Tracked: typeof ReadableStream = new Proxy(Native, {
+    construct(target, args, newTarget): object {
+      let resolve!: () => void;
+      let reject!: (error: unknown) => void;
+      const promise = new Promise<void>((yes, no) => { resolve = yes; reject = no; });
+      promise.then(undefined, () => {});
+      const source = args[0] as Source | null | undefined;
+      const track = (controller: { close?: (...rest: unknown[]) => unknown; error?: (...rest: unknown[]) => unknown }): void => {
+        const close = controller.close;
+        const error = controller.error;
+        if (typeof close === 'function') controller.close = function (this: unknown, ...rest: unknown[]) { const result = close.apply(this, rest); resolve(); return result; };
+        if (typeof error === 'function') controller.error = function (this: unknown, ...rest: unknown[]) { reject(rest[0]); return error.apply(this, rest); };
+      };
+      const failed = (cause: unknown): never => { reject(cause); throw cause; };
+      const wrapped: Source = Object.create(source ?? null);
+      wrapped.start = (controller) => {
+        track(controller as Parameters<typeof track>[0]);
+        try { return source?.start?.call(source, controller); } catch (cause) { return failed(cause); }
+      };
+      if (typeof source?.pull === 'function') {
+        const pull = source.pull;
+        wrapped.pull = (controller) => {
+          try { return Promise.resolve(pull.call(source, controller)).catch(failed); } catch (cause) { return failed(cause); }
+        };
+      }
+      wrapped.cancel = (reason) => {
+        resolve();
+        return source?.cancel?.call(source, reason);
+      };
+      const stream: object = Reflect.construct(target, [wrapped, ...args.slice(1)], newTarget === Tracked ? target : newTarget);
+      Object.defineProperty(stream, kIsClosedPromise, { value: { promise, resolve, reject }, configurable: true });
+      return stream;
+    },
+  });
+  Object.defineProperty(Tracked, '__substrateClosedPromise', { value: true });
+  takeFromHost(globalThis, 'ReadableStream', Tracked);
+});
+
 // Polyfill Error.captureStackTrace/prepareStackTrace for Safari/WebKit
 // (V8-specific API used by Express's depd and other npm packages)
 forGuestRealm(__substrateStackTracePolyfill);

package/src/shims/child_process.ts

@@ -70,6 +70,8 @@ import { Runtime, pendingGuestTimers, stopGuestTimers, __substratePendingOf } fr
 import { __nodeResolverFor } from '../node-resolver';
 import { resolve as __resolvePath } from './path';
 import { setSyncChildVfs, warmSyncChild } from './sync-child';
+import { installShellJobs } from './shell-jobs';
+import { unstreamedOutput } from './streamed-output';
 import type { PackageJson } from '../types/package-json';
 
 // Capture host capabilities before the guest's authority is restricted. These
@@ -936,8 +938,10 @@ export function initChildProcess(vfs: VirtualFS): void {
         // engine's own registries. A run that still holds a handle or a timer
         // is not that -- Node's loop runs while one is open, for as long as it
         // is open -- and cutting it at a minute ended a forked child that was
-        // a server, which is every extension host and every pty host.
-        if (!isLongRunning && !stillWorking() && Date.now() - startTime >= MAX_TOTAL_MS) break;
+        // a server, which is every extension host and every pty host. Work the
+        // host holds for it (a build, a pre-bundle) is seen work too: a dev
+        // server whose start passed a minute mid pre-bundle was cut with exit 0.
+        if (!isLongRunning && !stillWorking() && heldWork().count === 0 && Date.now() - startTime >= MAX_TOTAL_MS) break;
       }
 
       return { stdout, stderr, exitCode: exitCalled ? exitCode : (typeof proc !== 'undefined' && typeof proc.exitCode === 'number' ? proc.exitCode : 0) };
@@ -1034,6 +1038,9 @@ export function initChildProcess(vfs: VirtualFS): void {
     },
     customCommands: [nodeCommand, npmCommand],
   });
+  // A statement ending in `&` runs in the background, with `$!`, `wait` and
+  // `kill` over the engine's process table (`shell-jobs.ts` says how).
+  installShellJobs(bashInstance, { runTokenOf, runStreamsFor, registerRunStreams, releaseRunStreams });
   shells.set(tree, { bash: bashInstance, adapter: vfsAdapter });
 
   if (processRunnerInstalled) return;
@@ -1755,6 +1762,15 @@ function startChildRun(request: RunRequest): StartedRun {
   const admittedNode = nodeProcessHostInstalled() && engineProgramFor(request.file, request.cwd) === 'node';
   const hostTerminal = request.terminal !== undefined && hostExecutor() !== null && !admittedNode;
   let wakeInput: (() => void) | undefined;
+  /**
+   * A piped fd 0 that stays open for a program the host runs (a program pack,
+   * not a builtin of the engine's shell): what the parent writes reaches it
+   * as it is written, through the same live stream a terminal gets. A
+   * builtin reads its input once, before it runs; a server that speaks
+   * JSON-RPC over stdio (`supercode harness serve`) read that one string,
+   * saw EOF and exited before its client's first request.
+   */
+  let liveInput = false;
   const hostInput: AsyncIterable<Uint8Array> = {
     async *[Symbol.asyncIterator]() {
       while (!finished && !controller.signal.aborted) {
@@ -1794,11 +1810,11 @@ function startChildRun(request: RunRequest): StartedRun {
     }
   };
 
-  let streamedOut = 0;
-  let streamedErr = 0;
+  const streamedOut: string[] = [];
+  const streamedErr: string[] = [];
   const streams: RunStreams = {
-    onStdout: (data: string) => { streamedOut += data.length; request.stdout?.(data); },
-    onStderr: (data: string) => { streamedErr += data.length; request.stderr?.(data); },
+    onStdout: (data: string) => { streamedOut.push(data); request.stdout?.(data); },
+    onStderr: (data: string) => { streamedErr.push(data); request.stderr?.(data); },
     signal: controller.signal,
     held: false,
     stdinOpen: request.stdinIsPipe,
@@ -1854,6 +1870,12 @@ function startChildRun(request: RunRequest): StartedRun {
   const begin = (): void => {
     if (started || finished) return;
     started = true;
+    const engineFirst = !hostTerminal && programExists(request.file, request.cwd, request.env);
+    liveInput = !hostTerminal && !admittedNode && request.stdinIsPipe && !engineFirst;
+    if (liveInput) {
+      pendingStdin.unshift(...initialStdin);
+      initialStdin.length = 0;
+    }
     const stdin = initialStdin.length > 0 ? Buffer.concat(initialStdin).toString('utf8') : undefined;
     void (async () => {
       let outcome: CommandOutcome;
@@ -1867,11 +1889,11 @@ function startChildRun(request: RunRequest): StartedRun {
           filesystem: currentVfs!, env, streams, ...(stdin !== undefined ? { stdin } : {}),
         }) : await enterRun(token, () => routeCommand({
           command: __substrateLineFor(request.file, request.args, request.cwd),
-          engineFirst: !hostTerminal && programExists(request.file, request.cwd, request.env),
+          engineFirst,
           cwd: request.cwd,
           env: { ...request.env, [PROCESS_TOKEN_ENV]: token },
           stdin,
-          ...(hostTerminal ? { stdinStream: hostInput, terminal: request.terminal } : {}),
+          ...(hostTerminal ? { stdinStream: hostInput, terminal: request.terminal } : liveInput ? { stdinStream: hostInput } : {}),
           signal: controller.signal,
           onStdout: streams.onStdout,
           onStderr: streams.onStderr,
@@ -1882,9 +1904,12 @@ function startChildRun(request: RunRequest): StartedRun {
       }
       // A command the engine's shell ran to the end and did not stream --
       // every builtin -- delivers its output here; the `node` command streamed
-      // 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));
+      // its own as it went, and only what it has not already sent is left
+      // (`streamed-output.ts` says why that is not a cut at a length).
+      const restOut = unstreamedOutput(outcome.stdout, streamedOut);
+      const restErr = unstreamedOutput(outcome.stderr, streamedErr);
+      if (restOut) request.stdout?.(restOut);
+      if (restErr) request.stderr?.(restErr);
       end(outcome.exitCode, outcome.signal ?? null);
     })();
   };
@@ -1912,18 +1937,20 @@ function startChildRun(request: RunRequest): StartedRun {
       return 0;
     },
     writeStdin(bytes: Uint8Array): void | Promise<void> {
-      if (hostTerminal) { pendingStdin.push(bytes); wakeInput?.(); wakeInput = undefined; return; }
+      if (hostTerminal || liveInput) { pendingStdin.push(bytes); wakeInput?.(); wakeInput = undefined; return; }
       if (!started) { initialStdin.push(bytes); return; }
       pendingStdin.push(bytes);
       return flushStdin();
     },
     endStdin(): void {
-      if (hostTerminal) { pendingStdin.push(null); wakeInput?.(); wakeInput = undefined; return; }
+      if (hostTerminal || liveInput) { pendingStdin.push(null); wakeInput?.(); wakeInput = undefined; return; }
       if (!started) {
         // The writer closed before the command began: the run's fd 0 is the
         // string already collected and nothing more, so it is not held open.
         streams.stdinOpen = false;
         begin();
+        // A live pipe closed before it began still ends where it was closed.
+        if (liveInput) { pendingStdin.push(null); wakeInput?.(); wakeInput = undefined; }
         return;
       }
       pendingStdin.push(null);
@@ -1951,3 +1978,4 @@ export default {
   runCommand,
   sendStdin,
 };
+

package/src/shims/esbuild.ts

@@ -398,6 +398,16 @@ export interface EsbuildHost {
 }
 let currentHost: EsbuildHost | null = null;
 
+/**
+ * esbuild-wasm starts its compiler on a Worker unless told not to. A realm
+ * that runs guests may withhold `Worker` (the execution worker confines its
+ * guests that way), and there the compiler runs on the calling thread, which
+ * is esbuild's own `worker: false`.
+ */
+function realmCanStartWorker(): boolean {
+  return typeof (globalThis as { Worker?: unknown }).Worker === 'function';
+}
+
 let inlineEsbuild: Promise<typeof import('esbuild-wasm')> | null = null;
 function ownEsbuild(): Promise<typeof import('esbuild-wasm')> {
   // A build that brings plugins of its own, a bundler such as tsup does,
@@ -408,7 +418,7 @@ function ownEsbuild(): Promise<typeof import('esbuild-wasm')> {
     /* @vite-ignore */
     esbuildModuleURL
   ).then(async (esbuild) => {
-    await esbuild.initialize({ wasmURL });
+    await esbuild.initialize({ wasmURL, worker: realmCanStartWorker() });
     return esbuild;
   }).catch((cause) => {
     // A load that failed, a page whose server was away for a moment, is not kept: the next build tries again.
@@ -527,6 +537,7 @@ export async function initialize(options?: { wasmURL?: string }): Promise<void>
 
       await esbuild.initialize({
         wasmURL: options?.wasmURL || wasmURL,
+        worker: realmCanStartWorker(),
       });
 
       esbuildInstance = esbuild;

package/src/shims/perf_hooks.ts

@@ -2,6 +2,7 @@
  * perf_hooks shim - Performance measurement APIs
  * Wraps browser Performance API
  */
+import { forGuestRealm } from '../host-globals';
 
 export const performance = globalThis.performance || {
   now: () => Date.now(),
@@ -16,6 +17,23 @@ export const performance = globalThis.performance || {
   clearResourceTimings: () => {},
 };
 
+/**
+ * Node's `performance.markResourceTiming`, which a browser's `performance`
+ * does not have. undici's fetch reads it off the global `performance` at load
+ * and calls it after every response, so each fetch through an undici a
+ * program installed (Pi's does) threw once the body was read. Node records a
+ * PerformanceResourceTiming entry there; this engine keeps no resource
+ * timeline for a guest's own HTTP, so the call records nothing.
+ */
+forGuestRealm(() => {
+  const own = globalThis.performance as (Performance & { markResourceTiming?: unknown }) | undefined;
+  if (own && typeof own.markResourceTiming !== 'function') {
+    try {
+      Object.defineProperty(own, 'markResourceTiming', { value: () => undefined, writable: true, configurable: true, enumerable: false });
+    } catch { /* a performance object that refuses the name keeps its own shape */ }
+  }
+});
+
 export class PerformanceObserver {
   private callback: (list: PerformanceObserverEntryList) => void;
   private entryTypes: string[] = [];

package/src/shims/process.ts

@@ -363,8 +363,8 @@ function trailingCallback(args: readonly unknown[]): (() => void) | 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]));
+export 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 };
+export const __substrateSignalNames: Record<number, string> = Object.fromEntries(Object.entries(__substrateSignals).map(([name, number]) => [number, name]));
 // Node prints the `process.binding` deprecation once per process; the engine
 // runs many guests in one realm, so the record is per guest, not per load.
 const __substrateBindingWarned = new WeakSet<object>();