@volter/tabnode 0.4.1 → 0.5.0

package/src/runtime.ts

@@ -6,6 +6,8 @@
  */
 
 import { VirtualFS } from './virtual-fs';
+import { guestPromise, intrinsicPromise } from './promise-ownership';
+import { guestFetch, rememberRequestBodySource } from './fetch-transport';
 import { forGuestRealm, installGuestRealm, takeFromHost, defineOnHost, heldWork } from './host-globals';
 import type { IRuntime, IExecuteResult, IRuntimeOptions } from './runtime-interface';
 import type { PackageJson } from './types/package-json';
@@ -13,21 +15,23 @@ import { simpleHash } from './utils/hash';
 import { uint8ToBase64, uint8ToHex } from './utils/binary-encoding';
 import { createFsShim, FsShim } from './shims/fs';
 import * as pathShim from './shims/path';
-import { createProcess, Process, __reportUncaughtException } from './shims/process';
+import { createProcess, Process } from './shims/process';
 import {
   httpModule, httpsModule, httpCommonModule, httpIncomingModule, httpOutgoingModule,
   httpServerModule, httpClientModule, httpAgentModule,
 } from './node-lib/http-module';
 import { netModule as netShim } from './node-lib/net-module';
 import { errname as __uvErrname } from './node-lib/binding/uv';
-import { nodeTimeout, timerHandleOf } from './node-lib/timers';
+import { createTimersModule } from './node-lib/timers';
+import { guestTimerFunctions } from './guest-timers';
+export { pendingGuestTimers, stopGuestTimers } from './guest-timers';
 import eventsShim from './node-lib/events-module';
 import { streamModule as streamShim, streamPromisesModule as streamPromises } from './node-lib/stream-module';
 import * as urlShim from './shims/url';
 import utilShim from './node-lib/util-module';
 import * as cryptoShim from './shims/crypto';
 import * as stringDecoderShim from './shims/string_decoder';
-import * as dnsShim from './shims/dns';
+import { createDnsModule } from './shims/dns';
 import { bufferModule as bufferShim } from './node-lib/buffer-module';
 import { initChildProcess } from './shims/child_process';
 import { childProcessModule as childProcessShim } from './node-lib/child-process-module';
@@ -35,7 +39,7 @@ import { getServerBridge } from './server-bridge';
 import * as moduleShim from './shims/module';
 import { RunModuleHooks, CJS_CONDITIONS } from './node-lib/module-hooks';
 import { kRunFilesystem } from './node-lib/binding/fs';
-import { esmNamespaceOf, syncBuiltinESMExports } from './node-lib/load';
+import { esmNamespaceOf, syncBuiltinESMExports, loadNodeLibFor, hasNodeLibModule, nativeModuleFor } from './node-lib/load';
 import { fsModule, fsModuleFor } from './node-lib/fs-module';
 import {
   assertModule, querystringModule, punycodeModule, constantsModule,
@@ -62,6 +66,7 @@ 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 { applySourceEdits } from './source-edits';
 import * as acorn from 'acorn';
 
 /**
@@ -98,95 +103,10 @@ function walkAst(node: any, callback: (node: any) => void): void {
  * answers for them.
  */
 const __substrateGuestGlobals = new WeakMap<Process, Record<string, unknown>>();
-/**
- * The timers a guest process has pending: what Node's loop counts to decide
- * a program is done. A timer the guest sets through its global view is
- * held here until it fires, is cleared, or is unref'd, and the `node`
- * command's end-of-program rule asks how many remain.
- */
-const __substratePendingTimers = new WeakMap<Process, Set<unknown>>();
-export function pendingGuestTimers(process: Process): number {
-  return __substratePendingTimers.get(process)?.size ?? 0;
-}
-/**
- * Clear every timer a guest still holds, as ending a Node process clears the
- * ones its loop was waiting on. The ids were made by the host's own
- * `setTimeout`/`setInterval` through the guest's global view, so the host's
- * own clears end them; a `Timeout` is cleared by either in Node, and either
- * refusing an id of the other kind is not an error here.
- */
-export function stopGuestTimers(process: Process): void {
-  const held = __substratePendingTimers.get(process);
-  if (!held) return;
-  const host = globalThis as unknown as Record<string, unknown>;
-  const clearOnce = host.clearTimeout as ((id: unknown) => void) | undefined;
-  const clearRepeating = host.clearInterval as ((id: unknown) => void) | undefined;
-  for (const id of [...held]) {
-    try { clearOnce?.call(host, id); } catch {}
-    try { clearRepeating?.call(host, id); } catch {}
-  }
-  held.clear();
-}
-function __substrateTimerFunctions(process: Process, host: Record<string, unknown>): Record<string, unknown> {
-  let pending = __substratePendingTimers.get(process);
-  if (!pending) { pending = new Set(); __substratePendingTimers.set(process, pending); }
-  const held = pending;
-  const hostSetTimeout = host.setTimeout as (fn: (...a: unknown[]) => void, ms?: number, ...rest: unknown[]) => unknown;
-  const hostSetInterval = host.setInterval as (fn: (...a: unknown[]) => void, ms?: number, ...rest: unknown[]) => unknown;
-  const hostClearTimeout = host.clearTimeout as (id: unknown) => void;
-  const hostClearInterval = host.clearInterval as (id: unknown) => void;
-  // Node's timers answer a `Timeout`: an object with `ref`, `unref`,
-  // `hasRef` and `refresh`, which vitest and many packages call. A browser's
-  // answer a number. The engine used to correct this by replacing the realm's
-  // `setTimeout`, which in a Node host replaced the host's own; the
-  // correction belongs to the guest that reads Node's shape, so it is made
-  // here, on the guest's timer, and a host that already answers a `Timeout`
-  // keeps its own. The shape itself is `src/node-lib/timers.ts`: Node's own
-  // files take their timers from `require('timers')` rather than from the
-  // realm, and a timer made through one is cleared through the other.
-  const handleOf = timerHandleOf;
-  // An exception a timer callback throws is that program's uncaught
-  // exception: Node gives it to the process's `uncaughtException` listeners,
-  // else prints the stack to that process's stderr and exits it 1, and every
-  // other process is untouched. The engine's timers are the realm's own, so
-  // an uncaught throw left the guest's frames and reached the realm's global
-  // `error` event — in the tab the worker's, which the substrate's container
-  // reads as a dead host and disposes, killing openvscode-server's extension
-  // host and every other program in the tab along with the one that threw.
-  // A callback with no owning program (the engine imported as a library) is
-  // rethrown, so the host reports it as it always did.
-  const inProcess = (fn: (...a: unknown[]) => void) => (...args: unknown[]): void => {
-    try { fn(...args); }
-    catch (error) { if (!__reportUncaughtException(process, error)) throw error; }
-  };
-  const track = (id: unknown): unknown => {
-    held.add(id);
-    if (id && typeof id === "object" && typeof (id as { unref?: unknown }).unref === "function") {
-      const handle = id as { unref: () => unknown; ref: () => unknown };
-      const unref = handle.unref.bind(handle);
-      const ref = handle.ref.bind(handle);
-      handle.unref = () => { held.delete(id); return unref(); };
-      handle.ref = () => { held.add(id); return ref(); };
-    }
-    return id;
-  };
-  return {
-    setTimeout(fn: (...a: unknown[]) => void, ms?: number, ...rest: unknown[]) {
-      let id: unknown;
-      const call = inProcess(fn);
-      id = nodeTimeout(hostSetTimeout.call(host, (...args: unknown[]) => { held.delete(id); call(...args); }, ms, ...rest));
-      return track(id);
-    },
-    setInterval(fn: (...a: unknown[]) => void, ms?: number, ...rest: unknown[]) {
-      return track(nodeTimeout(hostSetInterval.call(host, inProcess(fn), ms, ...rest)));
-    },
-    clearTimeout(id: unknown) { held.delete(id); return hostClearTimeout.call(host, handleOf(id)); },
-    clearInterval(id: unknown) { held.delete(id); return hostClearInterval.call(host, handleOf(id)); },
-  };
-}
 const __substrateAsyncFunction = (async function() {}).constructor;
 const __substrateFunctionScope = Function("__substrateFunctionGlobals", "__substrateFunctionSource", "with (__substrateFunctionGlobals) { return eval('(' + __substrateFunctionSource + ')'); }");
 function __substrateGuestConstructor(Constructor: unknown, process: Process): unknown {
+  if (Constructor === intrinsicPromise) return guestPromise(process);
   if (Constructor !== Function && Constructor !== __substrateAsyncFunction) return Constructor;
   return new Proxy(Constructor as object, { construct(target, args) {
     const compiled = Reflect.construct(target as new (...args: unknown[]) => unknown, args);
@@ -214,17 +134,21 @@ function __substrateSourceURL(resolvedPath: string): string {
   }
   return /[\n\r]/u.test(name) ? '' : `\n//# sourceURL=${name}`;
 }
-function __substrateScopeConstructors(code: string): string {
-  if (!/\bnew\s/u.test(code)) return code;
+function __substrateScopeGlobalCalls(code: string): string {
+  if (!/\b(?:new|fetch|Promise)\b/u.test(code)) return code;
   let ast;
   try { ast = acorn.parse(code, { ecmaVersion: "latest", sourceType: "module", allowReturnOutsideFunction: true }); }
   catch { return code; }
-  const positions: Array<[number, number]> = [];
+  const positions: Array<[number, number, string]> = [];
   walkAst(ast, node => {
-    if (node.type === "NewExpression" && node.callee.type === "Identifier") positions.push([node.callee.start, node.callee.end]);
+    if (node.type === "NewExpression" && node.callee.type === "Identifier") positions.push([node.callee.start, node.callee.end, "(__substrateGuestConstructor(" + code.slice(node.callee.start, node.callee.end) + ",$process))"]);
+    // The narrow with-scope below keeps global replacements dynamic.
+    // Remove its object receiver for ordinary calls (including local
+    // bindings, whose bare-call receiver was already undefined).
+    const called = node.type === "CallExpression" ? node.callee : node.type === "TaggedTemplateExpression" ? node.tag : undefined;
+    if (called?.type === "Identifier" && (called.name === "fetch" || called.name === "Promise")) positions.push([called.start, called.end, "(0," + code.slice(called.start, called.end) + ")"]);
   });
-  for (const [start, end] of positions.sort((a,b) => b[0] - a[0])) code = code.slice(0,start) + "(__substrateGuestConstructor(" + code.slice(start,end) + ",$process))" + code.slice(end);
-  return code;
+  return applySourceEdits(code, positions.sort((a,b) => b[0] - a[0]));
 }
 /**
  * Work the host is doing for a guest, counted while it is outstanding.
@@ -262,7 +186,7 @@ function __substrateGuestGlobal(process: Process): Record<string, unknown> {
   let guest = __substrateGuestGlobals.get(process);
   if (guest) return guest;
   const host = globalThis as unknown as Record<string, unknown>;
-  let fetch = host.fetch;
+  let fetch = typeof host.fetch === 'function' ? guestFetch(process, host.fetch as typeof globalThis.fetch) : host.fetch;
   // The guest's `Buffer` is the one `require('buffer')` answers with, read
   // when the guest asks rather than when this closure is made: the name in
   // this file stands for the class until the loader has built it, and a guest
@@ -273,20 +197,34 @@ function __substrateGuestGlobal(process: Process): Record<string, unknown> {
   // holds non-configurable, `navigator` under a worker's authority) lives on
   // the proxy's own target, and is this guest's from then on.
   const shadowed = (target: object, key: string | symbol): boolean => Reflect.getOwnPropertyDescriptor(target, key) !== undefined;
-  guest = new Proxy(Object.create(null), {
+  const localGlobals = Object.create(null);
+  Object.defineProperty(localGlobals, "Promise", { value: intrinsicPromise, writable: true, configurable: true, enumerable: false });
+  // Node's own navigator, scoped to this process; never expose WorkerNavigator.
+  Object.defineProperties(localGlobals, {
+    navigator: { configurable: true, enumerable: true,
+      get: () => loadNodeLibFor(process, 'internal/navigator').navigator },
+    Navigator: { configurable: true, enumerable: false,
+      get: () => loadNodeLibFor(process, 'internal/navigator').Navigator,
+      set: value => Object.defineProperty(localGlobals, 'Navigator', {
+        value, writable: true, configurable: true, enumerable: false,
+      }) },
+  });
+  const isLocalGlobal = (key: string | symbol) => key === 'Promise' || key === 'navigator' || key === 'Navigator';
+  guest = new Proxy(localGlobals, {
     get(target, key) {
       if (["document", "window", "location", "self"].includes(key as string)) return undefined;
       if (key === "fetch") return fetch;
-      if (key === "Buffer") return buffer ?? bufferShim.Buffer;
+      if (key === "Buffer") return buffer ?? loadNodeLibFor(process, 'buffer').Buffer;
       if (key === "process") return process;
+      if (isLocalGlobal(key)) return Reflect.get(target, key, guest);
       if (key === "globalThis" || key === "global") return guest;
       if (shadowed(target, key)) return Reflect.get(target, key, guest);
       const value = Reflect.get(host, key, host);
       if (["setTimeout", "clearTimeout", "setInterval", "clearInterval"].includes(key as string) && typeof value === "function") {
         // The guest's timers, counted for it; rebuilt if the host's own change.
         if (boundGlobals.get(key)?.original !== value) {
-          const timers = __substrateTimerFunctions(process, host);
-          for (const name of ["setTimeout", "clearTimeout", "setInterval", "clearInterval"]) boundGlobals.set(name, { original: Reflect.get(host, name, host), bound: timers[name] });
+          const timers = guestTimerFunctions(process, host);
+          for (const name of ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] as const) boundGlobals.set(name, { original: Reflect.get(host, name, host), bound: timers[name] });
         }
         return boundGlobals.get(key)!.bound;
       }
@@ -314,20 +252,22 @@ function __substrateGuestGlobal(process: Process): Record<string, unknown> {
       return value;
     },
     set(target, key, value) {
+      if (isLocalGlobal(key)) return Reflect.set(target, key, value, target);
       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);
     },
-    has(target, key) { return key === "global" || shadowed(target, key) || key in host; },
+    has(target, key) { return isLocalGlobal(key) ? Reflect.has(target, key) : key === "global" || shadowed(target, key) || key in host; },
     ownKeys(target) {
       const keys = Reflect.ownKeys(target);
-      for (const key of Reflect.ownKeys(host)) if (!keys.includes(key)) keys.push(key);
+      for (const key of Reflect.ownKeys(host)) if (!isLocalGlobal(key) && !keys.includes(key)) keys.push(key);
       return keys;
     },
     getOwnPropertyDescriptor(target, key) {
+      if (isLocalGlobal(key)) return Reflect.getOwnPropertyDescriptor(target, key);
       if (key === "fetch") return { value: fetch, writable: true, configurable: true, enumerable: true };
-      if (key === "Buffer") return { value: buffer ?? bufferShim.Buffer, writable: true, configurable: true, enumerable: true };
+      if (key === "Buffer") return { value: buffer ?? loadNodeLibFor(process, 'buffer').Buffer, writable: true, configurable: true, enumerable: true };
       // A key the guest defined non-configurable lives on the proxy's own
       // target as well, and is reported from there, as the proxy's
       // invariants require.
@@ -337,6 +277,7 @@ function __substrateGuestGlobal(process: Process): Record<string, unknown> {
       return descriptor ? { ...descriptor, configurable: true } : undefined;
     },
     defineProperty(target, key, descriptor) {
+      if (isLocalGlobal(key)) return Reflect.defineProperty(target, key, descriptor);
       if (key === "fetch") { if (!("value" in descriptor)) return false; fetch = descriptor.value; return true; }
       if (key === "Buffer") { if (!("value" in descriptor)) return false; buffer = descriptor.value; return true; }
       // A non-configurable define, undici's of its global dispatcher symbol,
@@ -662,7 +603,7 @@ async function __substrateImportChain(
   return doors.__loadFromURL(resolved.url, loaded.format ?? resolved.format, loaded.source ?? void 0);
 }
 
-function createDynamicImport(moduleRequire: RequireFunction, parentURL?: string): (specifier: unknown) => Promise<unknown> {
+function createDynamicImport(moduleRequire: RequireFunction, process: Process, parentURL?: string): (specifier: unknown) => Promise<unknown> {
   return async (specifier: unknown): Promise<unknown> => {
     try {
       // The specifier of `import()` undergoes ToString, as Node's does. ESLint's
@@ -693,7 +634,7 @@ function createDynamicImport(moduleRequire: RequireFunction, parentURL?: string)
       if (mod && typeof mod === 'object' && '__esModule' in (mod as object)) {
         return mod;
       }
-      return esmNamespaceOf(mod);
+      return esmNamespaceOf(mod, process);
     } catch (error) {
       // Re-throw as a rejected promise (which is what dynamic import does)
       throw error;
@@ -735,43 +676,6 @@ export interface RequireFunction {
   cache: Record<string, Module>;
 }
 
-/**
- * Create a basic timers module
- */
-function createTimersModule() {
-  // Node's legacy timer list API, deprecated (DEP0095) and still exported:
-  // an object with `_onTimeout` is enrolled for a duration, made active to
-  // start or restart its countdown, and unenrolled to stop it.
-  type Enrolled = { _onTimeout?: () => void; _idleTimeout?: number; _idleTimeoutId?: ReturnType<typeof setTimeout> | null };
-  const unenroll = (item: Enrolled): void => {
-    if (item._idleTimeoutId) globalThis.clearTimeout(item._idleTimeoutId);
-    item._idleTimeoutId = null;
-    item._idleTimeout = -1;
-  };
-  const enroll = (item: Enrolled, msecs: number): void => {
-    if (item._idleTimeoutId) globalThis.clearTimeout(item._idleTimeoutId);
-    item._idleTimeoutId = null;
-    item._idleTimeout = msecs;
-  };
-  const active = (item: Enrolled): void => {
-    const msecs = item._idleTimeout;
-    if (typeof msecs !== 'number' || msecs < 0) return;
-    if (item._idleTimeoutId) globalThis.clearTimeout(item._idleTimeoutId);
-    item._idleTimeoutId = globalThis.setTimeout(() => { item._idleTimeoutId = null; if (typeof item._onTimeout === 'function') item._onTimeout(); }, msecs);
-  };
-  return {
-    setTimeout: globalThis.setTimeout,
-    setInterval: globalThis.setInterval,
-    setImmediate: (fn: () => void) => setTimeout(fn, 0),
-    clearTimeout: globalThis.clearTimeout,
-    clearInterval: globalThis.clearInterval,
-    clearImmediate: globalThis.clearTimeout,
-    active,
-    enroll,
-    unenroll,
-  };
-}
-
 /**
  * Minimal prettier shim - just returns input unchanged
  * This is needed because prettier uses createRequire which conflicts with our runtime
@@ -890,7 +794,7 @@ const builtinModules: Record<string, unknown> = {
   os: osModule,
   crypto: cryptoShim,
   zlib: zlibModule,
-  dns: dnsShim,
+  dns: createDnsModule(),
   child_process: childProcessShim,
   assert: assertModule,
   string_decoder: stringDecoderShim,
@@ -981,13 +885,7 @@ const builtinModules: Record<string, unknown> = {
   // path.win32 name (Node's test-path-posix-exists.js asserts that identity).
   'path/posix': pathShim.posix,
   'path/win32': pathShim.win32,
-  // timers subpaths
-  'timers/promises': {
-    setTimeout: (ms: number) => new Promise(resolve => setTimeout(resolve, ms)),
-    setInterval: globalThis.setInterval,
-    setImmediate: (value?: unknown) => new Promise(resolve => setTimeout(() => resolve(value), 0)),
-    scheduler: { wait: (ms: number) => new Promise(resolve => setTimeout(resolve, ms)) },
-  },
+
 };
 // Node's `assert/strict` is the module's own `strict` property, read when
 // a guest asks rather than when this table is built -- `assert` is a lazy
@@ -1088,37 +986,7 @@ function __browserRuntimeFillModules(table: Record<string, any>) {
   // is Node's own code; `errorNames` above stays, because the engine's own
   // parts still name an errno.
 
-  // timers/promises.setInterval was the global setInterval, which answers a
-  // handle rather than the async generator Node does, so "for await" over it
-  // never yielded; setTimeout dropped the value it was given, and neither took
-  // a signal.
-  const timersPromises = {
-    setTimeout: (delay: any, value: any, options: any) => new Promise((resolve, reject) => {
-      const signal = options && options.signal;
-      if (signal && signal.aborted) { reject(abortError()); return; }
-      const onAbort = () => { clearTimeout(handle); reject(abortError()); };
-      const handle = setTimeout(() => {
-        if (signal) signal.removeEventListener("abort", onAbort);
-        resolve(value);
-      }, delay);
-      if (signal) signal.addEventListener("abort", onAbort, { once: true });
-    }),
-    setImmediate: (value: any, options: any) => timersPromises.setTimeout(0, value, options),
-    setInterval: async function* setInterval(delay: any, value: any, options: any) {
-      const signal = options && options.signal;
-      for (;;) {
-        await timersPromises.setTimeout(delay, void 0, options);
-        if (signal && signal.aborted) return;
-        yield value;
-      }
-    },
-    scheduler: {
-      wait: (delay: any, options: any) => timersPromises.setTimeout(delay, void 0, options),
-      yield: () => timersPromises.setTimeout(0, void 0, void 0)
-    }
-  };
-  table["timers/promises"] = timersPromises;
-  table.timers.promises = timersPromises;
+  table["timers/promises"] = table.timers.promises;
 
   // Node's punycode decoder, RFC 3492, so domainToUnicode answers the name a
   // person reads rather than the xn-- label: the engine dropped the punycode
@@ -1247,21 +1115,7 @@ function __browserRuntimeFillModules(table: Record<string, any>) {
     availableParallelism: () => (typeof navigator === "object" && navigator && Number(navigator.hardwareConcurrency)) || 1
   });
 
-  // dns's error codes are the names a guest compares err.code against; the
-  // engine had none of them, and dns/promises was not a module at all.
-  const dnsCodes = {
-    NODATA: "ENODATA", FORMERR: "EFORMERR", SERVFAIL: "ESERVFAIL", NOTFOUND: "ENOTFOUND",
-    NOTIMP: "ENOTIMP", REFUSED: "EREFUSED", BADQUERY: "EBADQUERY", BADNAME: "EBADNAME",
-    BADFAMILY: "EBADFAMILY", BADRESP: "EBADRESP", CONNREFUSED: "ECONNREFUSED", TIMEOUT: "ETIMEOUT",
-    EOF: "EOF", FILE: "EFILE", NOMEM: "ENOMEM", DESTRUCTION: "EDESTRUCTION", BADSTR: "EBADSTR",
-    BADFLAGS: "EBADFLAGS", NONAME: "ENONAME", BADHINTS: "EBADHINTS", NOTINITIALIZED: "ENOTINITIALIZED",
-    LOADIPHLPAPI: "ELOADIPHLPAPI", ADDRGETNETWORKPARAMS: "EADDRGETNETWORKPARAMS", CANCELLED: "ECANCELLED"
-  };
-  const dnsModule = extend("dns", dnsCodes);
-  const dnsPromises = Object.assign({}, dnsModule.promises, dnsCodes);
-  dnsPromises.default = dnsPromises;
-  dnsModule.promises = dnsPromises;
-  table["dns/promises"] = dnsPromises;
+  table["dns/promises"] = table.dns.promises;
 
   // readline/promises was not a module, and the engine's readline.promises
   // answered an object with only createInterface on it whose async iterator
@@ -1362,8 +1216,7 @@ function __browserRuntimeFillModules(table: Record<string, any>) {
  * async iterator on a Readable, `duplexPair`, `isDisturbed`, the high-water
  * marks) is Node's own file's now and is gone.
  */
-function __browserRuntimeFillStreams(table: Record<string, any>) {
-  const Bytes = BufferPolyfill;
+function __browserRuntimeFillStreams(table: Record<string, any>, Bytes = BufferPolyfill) {
   const collect = async (source: any) => {
     const chunks: any[] = [];
     if (source && typeof source.getReader === "function") {
@@ -1585,7 +1438,7 @@ function __substrateModuleClassFor(moduleCache: Record<string, Module>, requireF
   Module._pathCache = Object.create(null);
   Module.builtinModules = moduleShim.builtinModules;
   Module.isBuiltin = moduleShim.isBuiltin;
-  Module.syncBuiltinESMExports = syncBuiltinESMExports;
+  Module.syncBuiltinESMExports = () => syncBuiltinESMExports(process);
   Module.globalPaths = ["/node_modules"];
   Module._nodeModulePaths = (directory: string) => {
     const result = [];
@@ -1613,7 +1466,7 @@ function __substrateModuleClassFor(moduleCache: Record<string, Module>, requireF
   // the fast path Node keeps too. They hang off the Module class because that
   // class is this run's -- one per module cache -- and Node's are per process.
   Module.__substrateHooks = void 0;
-  const __substrateHooksOf = (): RunModuleHooks => (Module.__substrateHooks ??= new RunModuleHooks());
+  const __substrateHooksOf = (): RunModuleHooks => (Module.__substrateHooks ??= new RunModuleHooks(process));
   Module.registerHooks = (hooks: { resolve?: unknown; load?: unknown }) => __substrateHooksOf().sync.registerHooks(hooks);
   Module.register = (specifier: unknown, parentURL?: unknown, options?: { parentURL?: unknown; data?: unknown; transferList?: unknown }) =>
     __substrateHooksOf().register(specifier, parentURL, options, (url: string, from: string) => Module.createRequire(from)(url));
@@ -1971,7 +1824,7 @@ function createRequire(
     try {
       const importMetaUrl = resolvedPath.startsWith('data:') ? resolvedPath : 'file://' + resolvedPath;
       const strictBody = code.startsWith(__substrateModuleMarker);
-      code = __substrateScopeConstructors(code);
+      code = __substrateScopeGlobalCalls(code);
       // The wrapper is one line and the body begins on it, as Node's
       // `Module.wrap` is one line, so a module's line N is line N of the
       // script V8 compiles and a stack names the module's own lines. The
@@ -1979,8 +1832,8 @@ function createRequire(
       // `global` among them for code that reads the process off them
       // directly; the inner function is what lets the body's own `let` and
       // `const` shadow that scope. `__substrateSourceURL` names the script.
-      const wrappedCode = `(function($exports, $require, $module, $filename, $dirname, $process, $console, $importMeta, $dynamicImport, __substrateGuestGlobal, __substrateGuestConstructor) { var exports = $exports; var require = $require; var module = $module; var __filename = $filename; var __dirname = $dirname; var process = $process; var console = $console; var import_meta = $importMeta; var __dynamicImport = $dynamicImport; var document = void 0, window = void 0, location = void 0, self = void 0; var globalThis = __substrateGuestGlobal($process); var global = globalThis; var Buffer = globalThis.Buffer; var queueMicrotask = globalThis.queueMicrotask, atob = globalThis.atob, btoa = globalThis.btoa, structuredClone = globalThis.structuredClone, setTimeout = globalThis.setTimeout, clearTimeout = globalThis.clearTimeout, setInterval = globalThis.setInterval, clearInterval = globalThis.clearInterval; globalThis.process = $process; global.process = $process; return (function() {${code}
-}).call(${strictBody ? 'void 0' : '$module.exports'});
+      const wrappedCode = `(function($exports, $require, $module, $filename, $dirname, $process, $console, $importMeta, $dynamicImport, __substrateGuestGlobal, __substrateGuestConstructor) { var exports = $exports; var require = $require; var module = $module; var __filename = $filename; var __dirname = $dirname; var process = $process; var console = $console; var import_meta = $importMeta; var __dynamicImport = $dynamicImport; var document = void 0, window = void 0, location = void 0, self = void 0; var globalThis = __substrateGuestGlobal($process); var global = globalThis; var Buffer = globalThis.Buffer; var queueMicrotask = globalThis.queueMicrotask, atob = globalThis.atob, btoa = globalThis.btoa, structuredClone = globalThis.structuredClone, setTimeout = globalThis.setTimeout, clearTimeout = globalThis.clearTimeout, setInterval = globalThis.setInterval, clearInterval = globalThis.clearInterval; globalThis.process = $process; global.process = $process; with ({ __proto__: null, get navigator() { return globalThis.navigator; }, set navigator(value) { globalThis.navigator = value; }, get Navigator() { return globalThis.Navigator; }, set Navigator(value) { globalThis.Navigator = value; }, get Promise() { return globalThis.Promise; }, set Promise(value) { globalThis.Promise = value; }, get fetch() { return globalThis.fetch; }, set fetch(value) { globalThis.fetch = value; } }) { return (function() {${code}
+}).call(${strictBody ? 'void 0' : '$module.exports'}); }
 })${__substrateSourceURL(resolvedPath)}`;
 
       // A lowered ES module body is a generator that yields at each import
@@ -2004,7 +1857,7 @@ function createRequire(
         catch { throw new SyntaxError(`${msg} (in ${resolvedPath})`); }
       }
       // Create dynamic import function for this module context
-      const dynamicImport = createDynamicImport(moduleRequire, importMetaUrl);
+      const dynamicImport = createDynamicImport(moduleRequire, process, importMetaUrl);
 
       const body = fn(
         module.exports,
@@ -2185,8 +2038,14 @@ function createRequire(
     if (id === 'wasi') {
       return __substrateGuestWasi(fsShim, process);
     }
+    if (id === 'stream/consumers') return nativeModuleFor(process, id, () => {
+      const table: Record<string, any> = {};
+      __browserRuntimeFillStreams(table, loadNodeLibFor(process, 'buffer').Buffer);
+      return table[id];
+    });
+    if (hasNodeLibModule(id)) return loadNodeLibFor(process, id);
     if (builtinModules[id] && !__substrateInstalledWins(id) && !(id === 'fsevents' || id === 'chokidar' || id === 'readdirp')) {
-      return id === 'esbuild' ? __substrateGuestEsbuild(process) : id === 'rollup' ? __substrateGuestRollup(process) : builtinModules[id];
+      return id === 'esbuild' ? __substrateGuestEsbuild(process) : id === 'rollup' ? __substrateGuestRollup(process) : nativeModuleFor(process, id, () => builtinModules[id]);
     }
 
     if (!__substrateInstalledWins(id)) {
@@ -2209,7 +2068,7 @@ function createRequire(
 
     // If resolved to a built-in name (shouldn't happen but safety check)
     if (builtinModules[resolved] && !(resolved === 'fsevents' || resolved === 'chokidar' || resolved === 'readdirp')) {
-      return resolved === 'esbuild' ? __substrateGuestEsbuild(process) : resolved === 'rollup' ? __substrateGuestRollup(process) : builtinModules[resolved];
+      return requirePlain(resolved);
     }
 
     // Also check if resolved path is to rollup, esbuild, or prettier in node_modules
@@ -2417,8 +2276,6 @@ export class Runtime {
     code: string,
     filename: string = '/index.js'
   ): { exports: unknown; module: Module } {
-    const dirname = pathShim.dirname(filename);
-
     // The tree holds the file the run names; it is written only when the
     // text differs. Every run wrote it, and a file run as it stands in the
     // tree was rewritten with itself, which fired its watcher (a dev server
@@ -2427,6 +2284,19 @@ export class Runtime {
     let held: string | undefined;
     try { held = this.vfs.readFileSync(filename, 'utf8') as string; } catch { held = undefined; }
     if (held !== code) this.vfs.writeFileSync(filename, code);
+    return this.evaluate(code, filename);
+  }
+
+  /**
+   * Runs source that is not a file of the tree -- `node -e`'s, named
+   * `[eval]` in the directory it runs in, as Node names it -- the way
+   * `execute` runs a file's, without writing it anywhere.
+   */
+  evaluate(
+    code: string,
+    filename: string
+  ): { exports: unknown; module: Module } {
+    const dirname = pathShim.dirname(filename);
 
     // Create require function
     const require = createRequire(
@@ -2486,7 +2356,7 @@ export class Runtime {
     try {
       const importMetaUrl = 'file://' + filename;
       const strictBody = code.startsWith(__substrateModuleMarker);
-      code = __substrateScopeConstructors(code);
+      code = __substrateScopeGlobalCalls(code);
       // The wrapper is one line and the body begins on it, as Node's
       // `Module.wrap` is one line, so a module's line N is line N of the
       // script V8 compiles and a stack names the module's own lines. The
@@ -2494,12 +2364,12 @@ export class Runtime {
       // `global` among them for code that reads the process off them
       // directly; the inner function is what lets the body's own `let` and
       // `const` shadow that scope. `__substrateSourceURL` names the script.
-      const wrappedCode = `(function($exports, $require, $module, $filename, $dirname, $process, $console, $importMeta, $dynamicImport, __substrateGuestGlobal, __substrateGuestConstructor) { var exports = $exports; var require = $require; var module = $module; var __filename = $filename; var __dirname = $dirname; var process = $process; var console = $console; var import_meta = $importMeta; var __dynamicImport = $dynamicImport; var document = void 0, window = void 0, location = void 0, self = void 0; var globalThis = __substrateGuestGlobal($process); var global = globalThis; var Buffer = globalThis.Buffer; var queueMicrotask = globalThis.queueMicrotask, atob = globalThis.atob, btoa = globalThis.btoa, structuredClone = globalThis.structuredClone, setTimeout = globalThis.setTimeout, clearTimeout = globalThis.clearTimeout, setInterval = globalThis.setInterval, clearInterval = globalThis.clearInterval; globalThis.process = $process; global.process = $process; return (function() {${code}
-}).call(${strictBody ? 'void 0' : '$module.exports'});
+      const wrappedCode = `(function($exports, $require, $module, $filename, $dirname, $process, $console, $importMeta, $dynamicImport, __substrateGuestGlobal, __substrateGuestConstructor) { var exports = $exports; var require = $require; var module = $module; var __filename = $filename; var __dirname = $dirname; var process = $process; var console = $console; var import_meta = $importMeta; var __dynamicImport = $dynamicImport; var document = void 0, window = void 0, location = void 0, self = void 0; var globalThis = __substrateGuestGlobal($process); var global = globalThis; var Buffer = globalThis.Buffer; var queueMicrotask = globalThis.queueMicrotask, atob = globalThis.atob, btoa = globalThis.btoa, structuredClone = globalThis.structuredClone, setTimeout = globalThis.setTimeout, clearTimeout = globalThis.clearTimeout, setInterval = globalThis.setInterval, clearInterval = globalThis.clearInterval; globalThis.process = $process; global.process = $process; with ({ __proto__: null, get navigator() { return globalThis.navigator; }, set navigator(value) { globalThis.navigator = value; }, get Navigator() { return globalThis.Navigator; }, set Navigator(value) { globalThis.Navigator = value; }, get Promise() { return globalThis.Promise; }, set Promise(value) { globalThis.Promise = value; }, get fetch() { return globalThis.fetch; }, set fetch(value) { globalThis.fetch = value; } }) { return (function() {${code}
+}).call(${strictBody ? 'void 0' : '$module.exports'}); }
 })${__substrateSourceURL(filename)}`;
 
       // Create dynamic import function for this module context
-      const dynamicImport = createDynamicImport(require, filename.startsWith('data:') ? filename : `file://${filename}`);
+      const dynamicImport = createDynamicImport(require, this.process, filename.startsWith('data:') ? filename : `file://${filename}`);
 
       // A module with top-level await runs. Node runs a `.js` file of a package
       // with `"type": "module"` as a module, where `await` is valid at the top;
@@ -2736,7 +2606,7 @@ forGuestRealm(() => {
 // That correction used to be made on the realm, which replaced the
 // `setTimeout` of any Node process that imported the engine. It is the
 // guest's, and it is made on the guest's own timers, in
-// `__substrateTimerFunctions`.
+// `guestTimerFunctions`.
 
 forGuestRealm(() => {
   // Node's `fetch` does not apply the fetch specification's
@@ -2759,6 +2629,7 @@ forGuestRealm(() => {
     class NodeRequest extends Native {
       constructor(input: RequestInfo | URL, init?: RequestInit) {
         super(input as RequestInfo, init);
+        rememberRequestBodySource(this, input, init);
         const asked = new Headers(init?.headers ?? (input instanceof Native ? (input as Request).headers : undefined));
         const headers = new Headers(super.headers);
         asked.forEach((value, name) => { if (!headers.has(name)) headers.set(name, value); });
@@ -2767,6 +2638,11 @@ forGuestRealm(() => {
       get headers(): Headers {
         return kept.get(this) ?? super.headers;
       }
+      clone(): Request {
+        const copy = super.clone();
+        rememberRequestBodySource(copy, this);
+        return new NodeRequest(copy, { headers: this.headers });
+      }
     }
     Object.defineProperty(NodeRequest, '__substrateHeaderGuard', { value: true });
     Object.defineProperty(NodeRequest, 'name', { value: 'Request', configurable: true });