sandboxedjs 0.1.73 → 0.1.74

package/dist/index.cjs

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var pako = require('pako');
+var acorn = require('acorn');
+var jsx = require('acorn-jsx');
 var sha256 = require('@noble/hashes/sha256');
 var index_js = require('buffer/index.js');
 var sha512 = require('@noble/hashes/sha512');
 var sha1 = require('@noble/hashes/sha1');
 var semver = require('semver');
-var acorn = require('acorn');
 var EventEmitter4 = require('events/events.js');
-var jsx = require('acorn-jsx');
 var resolve_exports = require('resolve.exports');
 var pathModule = require('path-browserify');
 var streamModule4 = require('stream-browserify');
@@ -25,8 +25,8 @@ var hmac = require('@noble/hashes/hmac');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var EventEmitter4__default = /*#__PURE__*/_interopDefault(EventEmitter4);
 var jsx__default = /*#__PURE__*/_interopDefault(jsx);
+var EventEmitter4__default = /*#__PURE__*/_interopDefault(EventEmitter4);
 var pathModule__default = /*#__PURE__*/_interopDefault(pathModule);
 var streamModule4__default = /*#__PURE__*/_interopDefault(streamModule4);
 var processShim__default = /*#__PURE__*/_interopDefault(processShim);
@@ -3824,7 +3824,10 @@ function builtinKill({ shell, argv, io }) {
   for (const target of args.slice(i)) {
     if (target.startsWith("%")) {
       const job = shell.jobs.find((j) => j.id === Number(target.slice(1)));
-      if (job) continue;
+      if (job) {
+        if (job.state !== "done") shell.kernel.procs.signal(job.pgid, signal);
+        continue;
+      }
       io.stderr.write(`kill: ${target}: no such job
 `);
       status = 1;
@@ -5420,6 +5423,51 @@ var BufferSink = class {
     this.total = 0;
   }
 };
+var DetachableOutput = class {
+  constructor(inner, onDetached) {
+    this.inner = inner;
+    this.onDetached = onDetached;
+  }
+  inner;
+  onDetached;
+  attached = true;
+  decoder = new TextDecoder();
+  get closed() {
+    return this.attached ? this.inner.closed : false;
+  }
+  get isTTY() {
+    return this.inner.isTTY;
+  }
+  set isTTY(value) {
+    this.inner.isTTY = value;
+  }
+  get columns() {
+    return this.inner.columns;
+  }
+  set columns(value) {
+    this.inner.columns = value;
+  }
+  get rows() {
+    return this.inner.rows;
+  }
+  set rows(value) {
+    this.inner.rows = value;
+  }
+  write(data) {
+    if (this.attached) {
+      this.inner.write(data);
+      return;
+    }
+    if (!this.onDetached) return;
+    this.onDetached(typeof data === "string" ? data : this.decoder.decode(data, { stream: true }));
+  }
+  end() {
+    if (this.attached) this.inner.end();
+  }
+  detach() {
+    this.attached = false;
+  }
+};
 var CallbackSink = class {
   constructor(sink, opts = {}) {
     this.sink = sink;
@@ -7282,6 +7330,77 @@ function createSysProvider(kernel) {
   };
 }
 
+// src/net/policy.ts
+function isLoopbackHostname(hostname) {
+  const host2 = hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  return host2 === "localhost" || host2 === "0.0.0.0" || host2 === "::1" || host2 === "::" || host2.startsWith("127.") || host2.endsWith(".localhost");
+}
+function outboundAllowed(policy, url) {
+  if (!policy.allowOutbound) return false;
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  if (isLoopbackHostname(hostname)) return false;
+  const hosts = policy.allowedHosts;
+  if (!hosts) return true;
+  return hosts.some((allowed) => hostname === allowed || hostname.endsWith(`.${allowed}`));
+}
+function outboundBlockedError(url) {
+  let host2 = url;
+  try {
+    host2 = new URL(url).host;
+  } catch {
+  }
+  return Object.assign(
+    new Error(
+      `connect ENETUNREACH ${host2}: outbound network access is disabled for this container (allowed by the host with network.allowOutbound and network.allowedHosts)`
+    ),
+    { code: "ENETUNREACH", errno: -101, syscall: "connect", hostname: host2 }
+  );
+}
+function requestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function policedFetch(policy, fetchImpl) {
+  return (async (input, init) => {
+    const url = requestUrl(input);
+    if (!outboundAllowed(policy, url)) {
+      throw Object.assign(new TypeError("fetch failed"), { cause: outboundBlockedError(url) });
+    }
+    return fetchImpl(input, init);
+  });
+}
+function policedWebSocket(Native, policy) {
+  const Base = Native;
+  return class PolicedWebSocket extends Base {
+    constructor(url, protocols) {
+      const href = url instanceof URL ? url.href : String(url);
+      let parsed = null;
+      try {
+        parsed = new URL(href);
+      } catch {
+      }
+      if (parsed && isLoopbackHostname(parsed.hostname)) {
+        throw Object.assign(
+          new Error(
+            `WebSocket to ${parsed.host} is not available from a program inside the container; reach servers in the container over HTTP`
+          ),
+          { code: "ERR_UNSUPPORTED" }
+        );
+      }
+      if (parsed && !outboundAllowed(policy, href.replace(/^ws(s?):/i, "http$1:"))) {
+        throw outboundBlockedError(href);
+      }
+      super(url, protocols);
+    }
+  };
+}
+
 // src/net/stack.ts
 var NetworkStack = class {
   constructor(pod, vfs, options = {}) {
@@ -7420,16 +7539,12 @@ var NetworkStack = class {
     return false;
   }
   // ── outbound policy ──────────────────────────────────────────────────────
+  /** The policy every way out of the container applies, not only the shell's. */
+  get policy() {
+    return { allowOutbound: this.options.allowOutbound, allowedHosts: this.options.allowedHosts ?? null };
+  }
   outboundAllowed(url) {
-    if (!this.options.allowOutbound) return false;
-    const hosts = this.options.allowedHosts;
-    if (hosts === null || hosts === void 0) return true;
-    try {
-      const { hostname } = new URL(url);
-      return hosts.some((h) => hostname === h || hostname.endsWith("." + h));
-    } catch {
-      return false;
-    }
+    return outboundAllowed(this.policy, url);
   }
   // ── /proc plumbing ───────────────────────────────────────────────────────
   procNetDev() {
@@ -8577,11 +8692,16 @@ var Shell = class _Shell {
     }
     return path;
   }
-  /** A copy that shares nothing mutable with this shell. */
-  fork() {
+  /**
+   * A copy that shares nothing mutable with this shell.
+   *
+   * Subshells and pipeline stages run as part of this shell's process. A
+   * background job passes a process of its own, the way fork(2) gives one.
+   */
+  fork(proc = this.proc) {
     const sub = new _Shell({
       kernel: this.kernel,
-      proc: this.proc,
+      proc,
       cwd: this.cwd,
       cred: this.cred,
       env: {},
@@ -8736,29 +8856,42 @@ sys	${fmt2(Math.floor(ms * 0.2))}
 `);
   }
   startBackgroundJob(node2, io) {
-    const sub = this.fork();
+    const jobProc = this.kernel.procs.create({
+      argv: [this.scriptName],
+      cwd: this.cwd,
+      env: this.vars.environment(),
+      cred: this.cred,
+      ppid: this.proc.pid,
+      kind: "shell",
+      tty: this.proc.tty,
+      stdio: { stdin: new NullInput(), stdout: io.stdout, stderr: io.stderr }
+    });
+    const sub = this.fork(jobProc);
     const id = this.nextJobId++;
     const command = describeNode(node2);
     const job = {
       id,
-      pgid: this.proc.pid + id,
+      pgid: jobProc.pid,
       command,
       state: "running",
       exitCode: null,
-      pids: [],
+      pids: [jobProc.pid],
       promise: Promise.resolve(0)
     };
     job.promise = (async () => {
+      let code;
       try {
-        const code = await sub.run(node2, { stdin: new NullInput(), stdout: io.stdout, stderr: io.stderr });
-        job.exitCode = code;
-        job.state = "done";
-        return code;
+        code = await sub.run(node2, { stdin: new NullInput(), stdout: io.stdout, stderr: io.stderr });
       } catch (e) {
-        job.state = "done";
-        job.exitCode = e instanceof ShellExit ? e.code : 1;
-        return job.exitCode;
+        code = e instanceof ShellExit ? e.code : 1;
       }
+      jobProc.exit(code);
+      job.exitCode = jobProc.exitCode ?? code;
+      job.state = "done";
+      queueMicrotask(() => {
+        if (jobProc.children.size === 0) this.kernel.procs.remove(jobProc.pid);
+      });
+      return job.exitCode;
     })();
     this.jobs.push(job);
     this.lastBackgroundPid = job.pgid;
@@ -17495,437 +17628,1110 @@ var commands11 = [xsel, xclip, pbcopy, pbpaste, wlCopy, wlPaste];
 
 // src/node/node.ts
 init_path();
-var NODE_VERSION = "v22.12.0";
-new TextEncoder();
-var tempCounter = 0;
-function tempPath(kind, pid, ext = ".js") {
-  return `/tmp/.sbx-${kind}-${pid}-${tempCounter++}${ext}`;
-}
-function withPrelude(source, prelude) {
-  if (!source.startsWith("#!")) return prelude + source;
-  const eol = source.indexOf("\n");
-  if (eol < 0) return source + "\n" + prelude;
-  return source.slice(0, eol + 1) + prelude + source.slice(eol + 1);
-}
-function siblingPath(script, pid) {
-  const ext = extname(script) || ".js";
-  return join(dirname(script), `.sbx-${pid}-${tempCounter++}-${basename(script, ext)}${ext}`);
-}
-var BUFFER_COMPAT_SHIM = `
-(function () {
-  const seen = new Set();
-  const widen = (B) => {
-    if (!B || seen.has(B) || typeof B.isBuffer !== 'function') return;
-    seen.add(B);
-    const original = B.isBuffer.bind(B);
-    B.isBuffer = (value) => original(value) || value instanceof Uint8Array;
-  };
-  try { widen(globalThis.Buffer); } catch (e) {}
-  try { widen(require('buffer').Buffer); } catch (e) {}
-})();
-`;
-function buildPrelude(scriptPath, argv, stdinPath) {
-  const argvLiteral = JSON.stringify(["/usr/bin/node", scriptPath, ...argv]);
-  const pathLiteral = JSON.stringify(scriptPath);
-  const stdinLiteral = JSON.stringify(stdinPath);
-  return `${BUFFER_COMPAT_SHIM}
-process.argv = ${argvLiteral};
-try {
-  __filename = ${pathLiteral};
-  module.filename = ${pathLiteral};
-  module.id = ${pathLiteral};
-  if (require.main === module) require.main.filename = ${pathLiteral};
-} catch (e) {}
-${stdinPath === null ? "" : `(function () {
-  const fs = require('fs');
-  const { Readable } = require('stream');
-  let data;
-  try { data = fs.readFileSync(${stdinLiteral}); } catch (e) { data = Buffer.alloc(0); }
-  const stream = Readable.from([data]);
-  stream.isTTY = false;
-  stream.fd = 0;
-  stream.setRawMode = function () { return this; };
-  try {
-    Object.defineProperty(process, 'stdin', { value: stream, configurable: true, writable: true });
-  } catch (e) { process.stdin = stream; }
-})();
-`}`;
+var HELPERS = {
+  /** Import a specifier and return an ES-module-shaped namespace. */
+  import: "__sbxImport",
+  /** `import(...)`, returning a promise of a namespace. */
+  dynamic: "__sbxDynamicImport",
+  /** `export * from` — copy live bindings onto `exports`. */
+  exportAll: "__sbxExportAll",
+  /** `import.meta`. */
+  meta: "__sbxMeta",
+  /**
+   * The exports object, under a name of the engine's choosing.
+   *
+   * An ES module is free to declare its own top-level `exports`, `require` or
+   * `__dirname` — they are ordinary identifiers there, and real packages use
+   * all three (`const require = createRequire(import.meta.url)` is close to
+   * idiomatic). Naming the wrapper's binding something no source would write
+   * removes that entire class of collision instead of patching it up after a
+   * `SyntaxError`.
+   */
+  exports: "__sbxExports"
+};
+var DEFAULT_LOCAL = "__sbxDefault";
+var MAYBE_ESM = /(^|[\s;}(])(?:import|export)(?:[\s({[*"']|$)|\bimport\s*\.\s*meta\b/;
+function looksLikeEsm(source) {
+  return MAYBE_ESM.test(source);
 }
-async function execute(ctx, invocation) {
-  const { pod } = ctx.kernel;
-  const live = ctx.stdin.interactive || ctx.stdin.isTTY;
-  const tty = ctx.stdin.isTTY;
-  let exitCode = 0;
+function transformEsm(source, filename = "module.js") {
+  if (!looksLikeEsm(source)) return null;
+  let ast;
   try {
-    const proc = await pod.spawn("node", [invocation.script], {
-      cwd: ctx.cwd,
-      env: { ...ctx.env, PWD: ctx.cwd },
-      argv: ["/usr/bin/node", invocation.argvPath ?? invocation.script, ...invocation.argv],
-      ...invocation.stdinPath ? { stdinPath: invocation.stdinPath } : {},
-      /* An interactive caller's input was not captured to a file, so the
-       * program's stdin has to stay open and be fed as it arrives — and be
-       * reported as a terminal, since that is what decides whether a CLI
-       * prompts or takes its defaults. */
-      ...live ? { interactiveStdin: true } : {},
-      ...tty ? { tty: true } : {}
-    });
-    proc.on("output", (chunk) => {
-      try {
-        ctx.write(chunk);
-      } catch {
-      }
-    });
-    proc.on("error", (chunk) => {
-      try {
-        ctx.stderr.write(chunk);
-      } catch {
-      }
-    });
-    proc.on("rawmode", (enabled) => {
-      ctx.stdin.rawMode = enabled;
-    });
-    let forwarding = false;
-    if (live) {
-      forwarding = true;
-      void (async () => {
-        while (forwarding) {
-          const chunk = await ctx.stdin.read();
-          if (chunk === null) {
-            proc.endInput?.();
-            break;
-          }
-          try {
-            proc.write(new TextDecoder().decode(chunk));
-          } catch {
-            break;
-          }
-        }
-      })();
-    }
-    let onAbort;
-    const aborted = new Promise((resolve3) => {
-      onAbort = () => {
-        try {
-          proc.kill();
-        } catch {
-        }
-        resolve3({ exitCode: 137 });
-      };
-      if (ctx.signal.aborted) onAbort();
-      else ctx.signal.addEventListener("abort", onAbort, { once: true });
-    });
-    const result = await Promise.race([proc.completion, aborted]);
-    forwarding = false;
-    if (onAbort) ctx.signal.removeEventListener("abort", onAbort);
-    exitCode = result.exitCode;
-  } catch (e) {
-    ctx.stderr.write(`node: ${e instanceof Error ? e.message : String(e)}
-`);
-    exitCode = 1;
-  } finally {
-    for (const temp of invocation.temps) {
-      try {
-        ctx.vfs.unlink(temp);
-      } catch {
-      }
-    }
+    ast = parseModule(source, filename);
+  } catch {
+    return null;
   }
-  return exitCode;
-}
-async function captureStdin(ctx) {
-  if (ctx.stdin.isTTY || ctx.stdin.interactive) return null;
-  const bytes2 = await ctx.stdin.readAll();
-  if (bytes2.length === 0) return null;
-  const path = tempPath("stdin", ctx.proc.pid, ".dat");
-  ctx.vfs.writeFile(path, bytes2, { privileged: true, mode: 384 });
-  return path;
-}
-var node = defineCommand({
-  name: "node",
-  path: "/usr/bin/node",
-  aliases: ["nodejs"],
-  summary: "run a JavaScript program with Node.js",
-  usage: "node [options] [script.js] [arguments]",
-  manual: `Runs JavaScript with a real Node.js API surface \u2014 fs, path, http,
-crypto, streams, worker_threads and npm packages \u2014 inside the container.
-The filesystem a script sees is the container's filesystem.`,
-  async run(ctx) {
-    const argv = ctx.args;
-    const temps = [];
-    let i = 0;
-    let evalSource;
-    let printResult = false;
-    let scriptArg;
-    for (; i < argv.length; i++) {
-      const arg = argv[i];
-      if (arg === "-v" || arg === "--version") {
-        ctx.line(NODE_VERSION);
-        return 0;
-      }
-      if (arg === "-h" || arg === "--help") {
-        printHelp(ctx);
-        return 0;
-      }
-      if (arg === "-e" || arg === "--eval") {
-        evalSource = argv[++i] ?? "";
-        i++;
-        break;
-      }
-      if (arg === "-p" || arg === "--print") {
-        printResult = true;
-        evalSource = argv[++i] ?? "";
-        i++;
-        break;
-      }
-      if (arg.startsWith("--eval=")) {
-        evalSource = arg.slice("--eval=".length);
-        i++;
+  const body = ast.body;
+  const hasModuleSyntax = body.some(
+    (node2) => node2.type.startsWith("Import") || node2.type.startsWith("Export")
+  );
+  const usesImportMeta = !hasModuleSyntax && containsImportMeta(ast);
+  const esm = hasModuleSyntax || usesImportMeta;
+  if (!esm && !containsImportExpression(ast)) return null;
+  const edits = [];
+  const prelude = [];
+  const importBindings = /* @__PURE__ */ new Map();
+  const exportGetters = /* @__PURE__ */ new Map();
+  let namespaceCount = 0;
+  const namespaceFor = (specifier) => {
+    const id = `__sbxNs${namespaceCount++}`;
+    prelude.push(`var ${id} = ${HELPERS.import}(${JSON.stringify(specifier)});`);
+    return id;
+  };
+  for (const node2 of body) {
+    if (node2.type === "ImportDeclaration") collectImport(node2);
+  }
+  for (const node2 of body) {
+    switch (node2.type) {
+      case "ExportNamedDeclaration":
+        collectNamedExport(node2);
         break;
-      }
-      if (arg.startsWith("--print=")) {
-        printResult = true;
-        evalSource = arg.slice("--print=".length);
-        i++;
+      case "ExportDefaultDeclaration":
+        collectDefaultExport(node2);
         break;
-      }
-      if (arg === "--") {
-        i++;
+      case "ExportAllDeclaration":
+        collectExportAll(node2);
         break;
-      }
-      if (arg.startsWith("-") && arg !== "-") {
-        continue;
-      }
-      scriptArg = arg;
-      i++;
-      break;
-    }
-    const scriptArgs = argv.slice(i);
-    if (evalSource !== void 0) {
-      const body = printResult ? `const __sbxResult = (function(){ return (${evalSource}
-); })();
-console.log(typeof __sbxResult === 'string' ? __sbxResult : require('util').inspect(__sbxResult));` : evalSource;
-      const path = tempPath("eval", ctx.proc.pid);
-      const stdinPath2 = await captureStdin(ctx);
-      if (stdinPath2) temps.push(stdinPath2);
-      ctx.vfs.writeFile(path, buildBootstrapForEval(body, ["/usr/bin/node", ...scriptArgs], stdinPath2), {
-        privileged: true,
-        mode: 384
-      });
-      temps.push(path);
-      return execute(ctx, { script: path, argv: scriptArgs, stdinPath: stdinPath2, temps });
     }
-    if (scriptArg === void 0 || scriptArg === "-") {
-      if (ctx.stdin.isTTY) {
-        ctx.line(`Welcome to Node.js ${NODE_VERSION}.`);
-        ctx.line('Type ".help" for more information.');
-        return runRepl(ctx);
+  }
+  rewriteReferences();
+  const header = esm ? [
+    `Object.defineProperty(${HELPERS.exports}, "__esModule", { value: true });`,
+    ...prelude,
+    ...[...exportGetters].map(
+      ([name, expression]) => `Object.defineProperty(${HELPERS.exports}, ${JSON.stringify(name)}, { enumerable: true, configurable: true, get: function () { return ${expression}; } });`
+    )
+  ].join("\n") : "";
+  return {
+    code: header ? `${header}
+${applyEdits(source, edits)}` : applyEdits(source, edits),
+    esm,
+    topLevelAwait: hasTopLevelAwait(ast)
+  };
+  function collectImport(node2) {
+    const specifier = node2.source.value;
+    const specifiers = node2.specifiers ?? [];
+    const id = namespaceFor(specifier);
+    for (const entry of specifiers) {
+      const local = entry.local.name ?? "";
+      if (entry.type === "ImportDefaultSpecifier") {
+        importBindings.set(local, `${id}.default`);
+      } else if (entry.type === "ImportNamespaceSpecifier") {
+        importBindings.set(local, id);
+      } else {
+        const imported = entry.imported;
+        const name = imported.type === "Identifier" ? imported.name : imported.value;
+        importBindings.set(local, `${id}[${JSON.stringify(name)}]`);
       }
-      const source = new TextDecoder().decode(await ctx.stdin.readAll());
-      if (source.trim() === "") return 0;
-      const path = tempPath("stdin-script", ctx.proc.pid);
-      ctx.vfs.writeFile(path, buildBootstrapForEval(source, ["/usr/bin/node", ...scriptArgs], null), {
-        privileged: true,
-        mode: 384
-      });
-      temps.push(path);
-      return execute(ctx, { script: path, argv: scriptArgs, temps });
     }
-    const script = resolveScript(ctx, scriptArg);
-    if (!script) {
-      ctx.stderr.write(
-        `node:internal/modules/cjs/loader:1215
-  throw err;
-  ^
-
-Error: Cannot find module '${ctx.path(scriptArg)}'
-`
-      );
-      return 1;
+    drop(node2);
+  }
+  function collectNamedExport(node2) {
+    const declaration = node2.declaration;
+    if (declaration) {
+      for (const name of declaredNames(declaration)) exportGetters.set(name, name);
+      edits.push({ start: node2.start, end: declaration.start, text: "" });
+      return;
     }
-    const stdinPath = await captureStdin(ctx);
-    if (stdinPath) temps.push(stdinPath);
-    const sibling = siblingPath(script, ctx.proc.pid);
-    try {
-      const source = ctx.vfs.readText(script, ctx.cred);
-      ctx.vfs.writeFile(sibling, withPrelude(source, buildPrelude(script, scriptArgs, stdinPath)), {
-        privileged: true,
-        mode: 384
-      });
-      temps.push(sibling);
-      return await execute(ctx, { script: sibling, argvPath: script, argv: scriptArgs, stdinPath, temps });
-    } catch {
-      return await execute(ctx, { script, argv: scriptArgs, stdinPath, temps });
+    const source_ = node2.source;
+    const id = source_ ? namespaceFor(source_.value) : null;
+    for (const entry of node2.specifiers ?? []) {
+      const local = nameOf(entry.local);
+      const exported = nameOf(entry.exported);
+      const read = id ? `${id}[${JSON.stringify(local)}]` : importBindings.get(local) ?? local;
+      exportGetters.set(exported, read);
     }
+    drop(node2);
   }
-});
-function buildBootstrapForEval(source, argv, stdinPath) {
-  const prelude = stdinPath ? `const fs = require('fs');
-const { Readable } = require('stream');
-let __sbxData; try { __sbxData = fs.readFileSync(${JSON.stringify(stdinPath)}); } catch (e) { __sbxData = Buffer.alloc(0); }
-const __sbxStdin = Readable.from([__sbxData]);
-__sbxStdin.isTTY = false;
-__sbxStdin.setRawMode = function () { return this; };
-try { Object.defineProperty(process, 'stdin', { value: __sbxStdin, configurable: true, writable: true }); } catch (e) { process.stdin = __sbxStdin; }
-` : "";
-  return `${BUFFER_COMPAT_SHIM}process.argv = ${JSON.stringify(argv)};
-${prelude}${source}
-`;
-}
-function resolveScript(ctx, operand) {
-  const base2 = ctx.path(operand);
-  const candidates = [base2, `${base2}.js`, `${base2}.mjs`, `${base2}.cjs`, `${base2}.json`];
-  for (const candidate of candidates) {
-    try {
-      const st = ctx.vfs.stat(candidate, { cred: ctx.cred });
-      if (st.isFile()) return ctx.vfs.realpath(candidate, ctx.cred);
-      if (st.isDirectory()) {
-        const manifest = join(candidate, "package.json");
-        if (ctx.vfs.lexists(manifest)) {
-          try {
-            const main = JSON.parse(ctx.vfs.readText(manifest, ctx.cred)).main;
-            if (main) {
-              const mainPath = resolve(candidate, main);
-              if (ctx.vfs.lexists(mainPath)) return ctx.vfs.realpath(mainPath, ctx.cred);
-              if (ctx.vfs.lexists(mainPath + ".js")) return ctx.vfs.realpath(mainPath + ".js", ctx.cred);
-            }
-          } catch {
-          }
-        }
-        for (const index of ["index.js", "index.mjs", "index.cjs"]) {
-          const path = join(candidate, index);
-          if (ctx.vfs.lexists(path)) return ctx.vfs.realpath(path, ctx.cred);
-        }
+  function collectDefaultExport(node2) {
+    const declaration = node2.declaration;
+    const isDeclaration = declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration";
+    if (isDeclaration) {
+      const named = declaration.id;
+      if (named) {
+        exportGetters.set("default", named.name);
+        edits.push({ start: node2.start, end: declaration.start, text: "" });
+        return;
       }
-    } catch {
+      const keyword = declaration.type === "FunctionDeclaration" ? "function" : "class";
+      const keywordEnd = source.indexOf(keyword, declaration.start) + keyword.length;
+      exportGetters.set("default", DEFAULT_LOCAL);
+      edits.push({ start: node2.start, end: declaration.start, text: "" });
+      edits.push({ start: keywordEnd, end: keywordEnd, text: ` ${DEFAULT_LOCAL}` });
+      return;
     }
+    exportGetters.set("default", DEFAULT_LOCAL);
+    edits.push({ start: node2.start, end: declaration.start, text: `var ${DEFAULT_LOCAL} = ` });
+    edits.push({ start: node2.end, end: node2.end, text: ";" });
   }
-  return null;
-}
-async function runRepl(ctx) {
-  const historyPath = join(ctx.env.HOME ?? "/root", ".node_repl_history");
-  const statements = [];
-  for (; ; ) {
-    ctx.write("> ");
-    const line = await ctx.stdin.readLine();
-    if (line === null) {
-      ctx.line("");
-      break;
-    }
-    const trimmed = line.trim();
-    if (trimmed === ".exit") break;
-    if (trimmed === ".help") {
-      ctx.line(".exit     Exit the REPL");
-      ctx.line(".help     Print this help message");
-      ctx.line(".clear    Reset the session context");
-      continue;
-    }
-    if (trimmed === ".clear") {
-      statements.length = 0;
-      continue;
-    }
-    if (trimmed === "") continue;
-    const program = [...statements, `console.log(require('util').inspect((${trimmed})))`].join(";\n");
-    const fallback = [...statements, trimmed].join(";\n");
-    const path = tempPath("repl", ctx.proc.pid);
-    ctx.vfs.writeFile(path, program, { privileged: true, mode: 384 });
-    const result = await runQuiet(ctx, path);
-    if (result.exitCode !== 0) {
-      ctx.vfs.writeFile(path, fallback, { privileged: true, mode: 384 });
-      const second = await runQuiet(ctx, path);
-      ctx.write(second.stdout);
-      if (second.exitCode === 0) statements.push(trimmed);
-      else ctx.stderr.write(second.stderr);
-    } else {
-      ctx.write(result.stdout);
-      statements.push(trimmed);
-    }
-    try {
-      ctx.vfs.unlink(path);
-    } catch {
+  function collectExportAll(node2) {
+    const id = namespaceFor(node2.source.value);
+    const exported = node2.exported;
+    if (exported) exportGetters.set(nameOf(exported), id);
+    else prelude.push(`${HELPERS.exportAll}(${HELPERS.exports}, ${id});`);
+    drop(node2);
+  }
+  function drop(node2) {
+    edits.push({ start: node2.start, end: node2.end, text: "" });
+  }
+  function rewriteReferences() {
+    const programScope = { names: new Set(importBindings.keys()), parent: null };
+    visit(ast, programScope, true);
+    function visit(node2, scope, isProgram = false) {
+      let childScope = scope;
+      let skip = NOTHING;
+      switch (node2.type) {
+        case "ImportDeclaration":
+        case "ExportAllDeclaration":
+          return;
+        case "ExportNamedDeclaration":
+          if (!node2.declaration) return;
+          break;
+        case "FunctionDeclaration":
+        case "FunctionExpression":
+        case "ArrowFunctionExpression": {
+          const names = /* @__PURE__ */ new Set();
+          for (const param of node2.params ?? []) collectPattern(param, names);
+          const id = node2.id;
+          if (id && node2.type === "FunctionExpression") names.add(id.name);
+          const fnBody = node2.body;
+          if (fnBody?.type === "BlockStatement") {
+            for (const name of hoistedNames(fnBody.body)) names.add(name);
+          }
+          childScope = { names, parent: scope };
+          break;
+        }
+        case "CatchClause": {
+          const names = /* @__PURE__ */ new Set();
+          if (node2.param) collectPattern(node2.param, names);
+          childScope = { names, parent: scope };
+          break;
+        }
+        case "ClassExpression": {
+          const id = node2.id;
+          if (id) childScope = { names: /* @__PURE__ */ new Set([id.name]), parent: scope };
+          break;
+        }
+        case "BlockStatement":
+        case "StaticBlock":
+          if (!isProgram) {
+            childScope = { names: blockNames(node2.body), parent: scope };
+          }
+          break;
+        case "ForStatement":
+        case "ForInStatement":
+        case "ForOfStatement": {
+          const head2 = node2.init ?? node2.left;
+          if (head2?.type === "VariableDeclaration" && head2.kind !== "var") {
+            const names = /* @__PURE__ */ new Set();
+            for (const declarator of head2.declarations) {
+              collectPattern(declarator.id, names);
+            }
+            childScope = { names, parent: scope };
+          }
+          break;
+        }
+        case "MetaProperty":
+          edits.push({ start: node2.start, end: node2.end, text: HELPERS.meta });
+          return;
+        case "ImportExpression": {
+          const argument = node2.source;
+          edits.push({ start: node2.start, end: argument.start, text: `${HELPERS.dynamic}(` });
+          visit(argument, childScope);
+          edits.push({ start: argument.end, end: node2.end, text: ")" });
+          return;
+        }
+        case "Identifier": {
+          const replacement = lookup(node2.name, scope);
+          if (replacement) edits.push({ start: node2.start, end: node2.end, text: replacement });
+          return;
+        }
+        case "MemberExpression":
+        case "MethodDefinition":
+        case "PropertyDefinition":
+          skip = node2.computed ? NOTHING : PROPERTY;
+          break;
+        case "Property": {
+          if (node2.computed) break;
+          if (node2.shorthand) {
+            const value = node2.value;
+            if (value.type === "Identifier") {
+              const replacement = lookup(value.name, scope);
+              if (replacement) {
+                edits.push({ start: value.start, end: value.end, text: `${value.name}: ${replacement}` });
+                return;
+              }
+            }
+            break;
+          }
+          skip = PROPERTY;
+          break;
+        }
+        case "LabeledStatement":
+        case "BreakStatement":
+        case "ContinueStatement":
+          skip = LABEL;
+          break;
+      }
+      for (const [key, value] of Object.entries(node2)) {
+        if (key === "type" || key === "start" || key === "end" || skip.includes(key)) continue;
+        if (Array.isArray(value)) {
+          for (const item of value) if (isNode2(item)) visit(item, childScope);
+        } else if (isNode2(value)) {
+          visit(value, childScope);
+        }
+      }
     }
-    try {
-      ctx.vfs.appendFile(historyPath, trimmed + "\n", { cred: ctx.cred });
-    } catch {
+    function lookup(name, scope) {
+      for (let current = scope; current; current = current.parent) {
+        if (current.names.has(name)) {
+          return current.parent === null ? importBindings.get(name) ?? null : null;
+        }
+      }
+      return null;
     }
   }
-  return 0;
 }
-async function runQuiet(ctx, script) {
-  try {
-    const proc = await ctx.kernel.pod.spawn("node", [script], { cwd: ctx.cwd, env: ctx.env });
-    return await proc.completion;
-  } catch (e) {
-    return { exitCode: 1, stdout: "", stderr: `${e instanceof Error ? e.message : String(e)}
-` };
+var JSX_EXTENSION = /\.[jt]sx$/;
+var JsxParser = acorn.Parser.extend(jsx__default.default());
+var PARSE_OPTIONS = {
+  ecmaVersion: "latest",
+  sourceType: "module",
+  allowAwaitOutsideFunction: true,
+  allowHashBang: true,
+  allowReturnOutsideFunction: true
+};
+function parseModule(source, filename) {
+  const parser = JSX_EXTENSION.test(filename) ? JsxParser.parse.bind(JsxParser) : acorn.parse;
+  return parser(source, PARSE_OPTIONS);
+}
+function containsImportExpression(node2) {
+  if (Array.isArray(node2)) return node2.some(containsImportExpression);
+  if (!isNode2(node2)) return false;
+  if (node2.type === "ImportExpression") return true;
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (containsImportExpression(value)) return true;
   }
+  return false;
 }
-function printHelp(ctx) {
-  ctx.line("Usage: node [options] [script.js] [arguments]");
-  ctx.line("");
-  ctx.line("Options:");
-  ctx.line("  -v, --version              print Node.js version");
-  ctx.line("  -e, --eval script          evaluate script");
-  ctx.line("  -p, --print                evaluate script and print result");
-  ctx.line("  -h, --help                 print this message");
+function containsImportMeta(node2) {
+  if (Array.isArray(node2)) return node2.some(containsImportMeta);
+  if (!isNode2(node2)) return false;
+  if (node2.type === "MetaProperty") return true;
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (containsImportMeta(value)) return true;
+  }
+  return false;
 }
-var nodeVersionFile = defineCommand({
-  name: "nvm",
-  path: "/usr/local/bin/nvm",
-  summary: "node version manager (single-version stub)",
-  run(ctx) {
-    const sub = ctx.args[0];
-    if (sub === "current" || sub === "version") {
-      ctx.line(NODE_VERSION);
-      return 0;
+function hasTopLevelAwait(node2) {
+  if (Array.isArray(node2)) return node2.some(hasTopLevelAwait);
+  if (!isNode2(node2)) return false;
+  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
+    return false;
+  }
+  if (node2.type === "AwaitExpression") return true;
+  if (node2.type === "ForOfStatement" && node2.await === true) return true;
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (hasTopLevelAwait(value)) return true;
+  }
+  return false;
+}
+function declaredNames(declaration) {
+  const names = /* @__PURE__ */ new Set();
+  if (declaration.type === "VariableDeclaration") {
+    for (const declarator of declaration.declarations) {
+      collectPattern(declarator.id, names);
     }
-    if (sub === "ls" || sub === "list") {
-      ctx.line(`->     ${NODE_VERSION}`);
-      return 0;
+  } else if (isNode2(declaration.id)) {
+    names.add(declaration.id.name);
+  }
+  return [...names];
+}
+function nameOf(node2) {
+  return node2.type === "Identifier" ? node2.name : node2.value;
+}
+function hoistedNames(body) {
+  const names = blockNames(body);
+  collectVars(body, names);
+  return names;
+}
+function blockNames(body) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node2 of body ?? []) {
+    if (node2.type === "VariableDeclaration" && node2.kind !== "var") {
+      for (const declarator of node2.declarations) {
+        collectPattern(declarator.id, names);
+      }
+    } else if ((node2.type === "ClassDeclaration" || node2.type === "FunctionDeclaration") && isNode2(node2.id)) {
+      names.add(node2.id.name);
     }
-    ctx.line(`nvm: only ${NODE_VERSION} is available in this container`);
-    return 0;
   }
-});
-function nodeCommands() {
-  return [node, nodeVersionFile];
+  return names;
 }
-
-// src/python/python.ts
-init_path();
-
-// src/python/host-abi.ts
-var SBX_HOST_ABI_VERSION = 1;
-var SBX_REQUEST_HEADER_BYTES = 16;
-var SBX_RESPONSE_HEADER_BYTES = 20;
-var Op = {
-  handshake: 0,
-  openat: 1,
-  close: 2,
-  read: 3,
-  write: 4,
-  pread: 5,
-  pwrite: 6,
-  lseek: 7,
-  fstat: 8,
-  statat: 9,
-  ftruncate: 10,
-  renameat: 11,
-  unlinkat: 12,
-  mkdirat: 13,
-  readlinkat: 14,
-  symlinkat: 15,
-  getdents: 16,
-  fsync: 17,
-  dup: 256,
-  dup2: 257,
-  get_flags: 258,
-  set_flags: 259,
-  pipe: 512,
-  poll: 768,
-  clock_gettime: 1024,
-  sleep: 1025,
-  getpid: 1280,
-  getcwd: 1281,
+function collectVars(nodes, names) {
+  if (Array.isArray(nodes)) {
+    for (const item of nodes) collectVars(item, names);
+    return;
+  }
+  if (!isNode2(nodes)) return;
+  const node2 = nodes;
+  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
+    if (isNode2(node2.id)) names.add(node2.id.name);
+    return;
+  }
+  if (node2.type === "VariableDeclaration" && node2.kind === "var") {
+    for (const declarator of node2.declarations) {
+      collectPattern(declarator.id, names);
+    }
+  }
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    collectVars(value, names);
+  }
+}
+function collectPattern(node2, names) {
+  if (!isNode2(node2)) return;
+  switch (node2.type) {
+    case "Identifier":
+      names.add(node2.name);
+      return;
+    case "ObjectPattern":
+      for (const property of node2.properties) {
+        collectPattern(property.value ?? property.argument, names);
+      }
+      return;
+    case "ArrayPattern":
+      for (const element of node2.elements) collectPattern(element, names);
+      return;
+    case "AssignmentPattern":
+      collectPattern(node2.left, names);
+      return;
+    case "RestElement":
+      collectPattern(node2.argument, names);
+      return;
+    default:
+      return;
+  }
+}
+function applyEdits(source, edits) {
+  const ordered = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+  let out = source;
+  for (const edit of ordered) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  return out;
+}
+function isNode2(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+var NOTHING = [];
+var PROPERTY = ["property", "key"];
+var LABEL = ["label"];
+
+// src/node/node.ts
+var NODE_VERSION = "v22.12.0";
+new TextEncoder();
+var tempCounter = 0;
+function tempPath(kind, pid, ext = ".js") {
+  return `/tmp/.sbx-${kind}-${pid}-${tempCounter++}${ext}`;
+}
+function withPrelude(source, prelude) {
+  if (!source.startsWith("#!")) return prelude + source;
+  const eol = source.indexOf("\n");
+  if (eol < 0) return source + "\n" + prelude;
+  return source.slice(0, eol + 1) + prelude + source.slice(eol + 1);
+}
+function siblingPath(script, pid) {
+  const ext = extname(script) || ".js";
+  return join(dirname(script), `.sbx-${pid}-${tempCounter++}-${basename(script, ext)}${ext}`);
+}
+var BUFFER_COMPAT_SHIM = `
+(function () {
+  const seen = new Set();
+  const widen = (B) => {
+    if (!B || seen.has(B) || typeof B.isBuffer !== 'function') return;
+    seen.add(B);
+    const original = B.isBuffer.bind(B);
+    B.isBuffer = (value) => original(value) || value instanceof Uint8Array;
+  };
+  try { widen(globalThis.Buffer); } catch (e) {}
+  try { widen(require('buffer').Buffer); } catch (e) {}
+})();
+`;
+function buildPrelude(scriptPath, argv, stdinPath, preloads = []) {
+  const argvLiteral = JSON.stringify(["/usr/bin/node", scriptPath, ...argv]);
+  const pathLiteral = JSON.stringify(scriptPath);
+  const stdinLiteral = JSON.stringify(stdinPath);
+  return `${BUFFER_COMPAT_SHIM}
+process.argv = ${argvLiteral};
+try {
+  __filename = ${pathLiteral};
+  module.filename = ${pathLiteral};
+  module.id = ${pathLiteral};
+  if (require.main === module) require.main.filename = ${pathLiteral};
+} catch (e) {}
+${stdinPath === null ? "" : `(function () {
+  const fs = require('fs');
+  const { Readable } = require('stream');
+  let data;
+  try { data = fs.readFileSync(${stdinLiteral}); } catch (e) { data = Buffer.alloc(0); }
+  const stream = Readable.from([data]);
+  stream.isTTY = false;
+  stream.fd = 0;
+  stream.setRawMode = function () { return this; };
+  try {
+    Object.defineProperty(process, 'stdin', { value: stream, configurable: true, writable: true });
+  } catch (e) { process.stdin = stream; }
+})();
+`}${preloadRequires(preloads)}`;
+}
+function preloadRequires(preloads) {
+  return preloads.map((specifier) => `require(${JSON.stringify(specifier)});
+`).join("");
+}
+async function execute(ctx, invocation) {
+  const { pod } = ctx.kernel;
+  const live = ctx.stdin.interactive || ctx.stdin.isTTY;
+  const tty = ctx.stdin.isTTY;
+  let exitCode = 0;
+  try {
+    const proc = await pod.spawn("node", [invocation.script], {
+      cwd: ctx.cwd,
+      env: { ...invocation.env ?? ctx.env, PWD: ctx.cwd },
+      argv: ["/usr/bin/node", invocation.argvPath ?? invocation.script, ...invocation.argv],
+      ...invocation.stdinPath ? { stdinPath: invocation.stdinPath } : {},
+      /* An interactive caller's input was not captured to a file, so the
+       * program's stdin has to stay open and be fed as it arrives — and be
+       * reported as a terminal, since that is what decides whether a CLI
+       * prompts or takes its defaults. */
+      ...live ? { interactiveStdin: true } : {},
+      ...tty ? { tty: true } : {}
+    });
+    proc.on("output", (chunk) => {
+      try {
+        ctx.write(chunk);
+      } catch {
+      }
+    });
+    proc.on("error", (chunk) => {
+      try {
+        ctx.stderr.write(chunk);
+      } catch {
+      }
+    });
+    proc.on("rawmode", (enabled) => {
+      ctx.stdin.rawMode = enabled;
+    });
+    let forwarding = false;
+    if (live) {
+      forwarding = true;
+      void (async () => {
+        while (forwarding) {
+          const chunk = await ctx.stdin.read();
+          if (chunk === null) {
+            proc.endInput?.();
+            break;
+          }
+          try {
+            proc.write(new TextDecoder().decode(chunk));
+          } catch {
+            break;
+          }
+        }
+      })();
+    }
+    let onAbort;
+    const aborted = new Promise((resolve3) => {
+      onAbort = () => {
+        try {
+          proc.kill();
+        } catch {
+        }
+        resolve3({ exitCode: 137 });
+      };
+      if (ctx.signal.aborted) onAbort();
+      else ctx.signal.addEventListener("abort", onAbort, { once: true });
+    });
+    const result = await Promise.race([proc.completion, aborted]);
+    forwarding = false;
+    if (onAbort) ctx.signal.removeEventListener("abort", onAbort);
+    exitCode = result.exitCode;
+  } catch (e) {
+    ctx.stderr.write(`node: ${e instanceof Error ? e.message : String(e)}
+`);
+    exitCode = 1;
+  } finally {
+    for (const temp of invocation.temps) {
+      try {
+        ctx.vfs.unlink(temp);
+      } catch {
+      }
+    }
+  }
+  return exitCode;
+}
+async function captureStdin(ctx) {
+  if (ctx.stdin.isTTY || ctx.stdin.interactive) return null;
+  const bytes2 = await ctx.stdin.readAll();
+  if (bytes2.length === 0) return null;
+  const path = tempPath("stdin", ctx.proc.pid, ".dat");
+  ctx.vfs.writeFile(path, bytes2, { privileged: true, mode: 384 });
+  return path;
+}
+var node = defineCommand({
+  name: "node",
+  path: "/usr/bin/node",
+  aliases: ["nodejs"],
+  summary: "run a JavaScript program with Node.js",
+  usage: "node [options] [script.js] [arguments]",
+  manual: `Runs JavaScript with a real Node.js API surface \u2014 fs, path, http,
+crypto, streams, worker_threads and npm packages \u2014 inside the container.
+The filesystem a script sees is the container's filesystem.`,
+  async run(ctx) {
+    const argv = ctx.args;
+    const temps = [];
+    let i = 0;
+    let evalSource;
+    let printResult = false;
+    let scriptArg;
+    const preloads = [];
+    const envFiles = [];
+    let testMode = false;
+    let checkOnly = false;
+    const testSettings = { namePatterns: [] };
+    for (; i < argv.length; i++) {
+      const arg = argv[i];
+      if (arg === "-v" || arg === "--version") {
+        ctx.line(NODE_VERSION);
+        return 0;
+      }
+      if (arg === "-h" || arg === "--help") {
+        printHelp(ctx);
+        return 0;
+      }
+      if (arg === "-e" || arg === "--eval") {
+        evalSource = argv[++i] ?? "";
+        i++;
+        break;
+      }
+      if (arg === "-p" || arg === "--print") {
+        printResult = true;
+        evalSource = argv[++i] ?? "";
+        i++;
+        break;
+      }
+      if (arg.startsWith("--eval=")) {
+        evalSource = arg.slice("--eval=".length);
+        i++;
+        break;
+      }
+      if (arg.startsWith("--print=")) {
+        printResult = true;
+        evalSource = arg.slice("--print=".length);
+        i++;
+        break;
+      }
+      if (arg === "--") {
+        i++;
+        break;
+      }
+      const flag = arg.startsWith("--") ? arg.split("=", 1)[0] : arg;
+      if (VALUE_FLAGS.has(flag)) {
+        const value = arg.length > flag.length ? arg.slice(flag.length + 1) : argv[++i];
+        if (value === void 0) {
+          ctx.stderr.write(`node: ${flag} requires an argument
+`);
+          return 9;
+        }
+        if (flag === "-r" || flag === "--require" || flag === "--import") preloads.push(value);
+        else if (flag === "--env-file") envFiles.push({ path: value, optional: false });
+        else if (flag === "--env-file-if-exists") envFiles.push({ path: value, optional: true });
+        else if (flag === "--test-reporter") testSettings.reporter = value === "tap" ? "tap" : "spec";
+        else if (flag === "--test-name-pattern") testSettings.namePatterns.push(value);
+        else if (flag === "--loader" || flag === "--experimental-loader") {
+          ctx.stderr.write(`node: ${flag} is not supported in this container; ${value} was not loaded
+`);
+        }
+        continue;
+      }
+      if (arg === "--test") {
+        testMode = true;
+        continue;
+      }
+      if (arg === "--test-only") {
+        testSettings.only = true;
+        continue;
+      }
+      if (arg === "-c" || arg === "--check") {
+        checkOnly = true;
+        continue;
+      }
+      if (flag === "--watch" || flag === "--watch-path" || flag === "--watch-preserve-output") {
+        ctx.stderr.write(
+          `node: ${flag} is not available in this container: file changes are not watched. Run the program again after changing it.
+`
+        );
+        return 9;
+      }
+      if (arg.startsWith("-") && arg !== "-") {
+        continue;
+      }
+      scriptArg = arg;
+      i++;
+      break;
+    }
+    const scriptArgs = argv.slice(i);
+    let env2;
+    if (envFiles.length > 0) {
+      const loaded = {};
+      for (const file3 of envFiles) {
+        let text2;
+        try {
+          text2 = ctx.vfs.readText(ctx.path(file3.path), ctx.cred);
+        } catch {
+          if (file3.optional) continue;
+          ctx.stderr.write(`node: ${file3.path}: not found
+`);
+          return 9;
+        }
+        Object.assign(loaded, parseEnvFile(text2));
+      }
+      env2 = { ...loaded, ...ctx.env };
+    }
+    const preloadSpecs = preloads.map((spec) => spec.startsWith(".") || spec.startsWith("/") ? ctx.path(spec) : spec);
+    if (testMode) {
+      return runTestFiles(ctx, scriptArg === void 0 ? scriptArgs : [scriptArg, ...scriptArgs], testSettings, preloads, env2 ?? ctx.env);
+    }
+    if (checkOnly && scriptArg !== void 0) {
+      const script2 = resolveScript(ctx, scriptArg);
+      if (!script2) {
+        ctx.stderr.write(`node: cannot find module '${ctx.path(scriptArg)}'
+`);
+        return 1;
+      }
+      return checkSyntax(ctx, script2);
+    }
+    if (evalSource !== void 0) {
+      const body = printResult ? `const __sbxResult = (function(){ return (${evalSource}
+); })();
+console.log(typeof __sbxResult === 'string' ? __sbxResult : require('util').inspect(__sbxResult));` : evalSource;
+      const path = tempPath("eval", ctx.proc.pid);
+      const stdinPath2 = await captureStdin(ctx);
+      if (stdinPath2) temps.push(stdinPath2);
+      ctx.vfs.writeFile(path, buildBootstrapForEval(body, ["/usr/bin/node", ...scriptArgs], stdinPath2, preloadSpecs), {
+        privileged: true,
+        mode: 384
+      });
+      temps.push(path);
+      return execute(ctx, { script: path, argv: scriptArgs, stdinPath: stdinPath2, temps, ...env2 ? { env: env2 } : {} });
+    }
+    if (scriptArg === void 0 || scriptArg === "-") {
+      if (ctx.stdin.isTTY) {
+        ctx.line(`Welcome to Node.js ${NODE_VERSION}.`);
+        ctx.line('Type ".help" for more information.');
+        return runRepl(ctx);
+      }
+      const source = new TextDecoder().decode(await ctx.stdin.readAll());
+      if (source.trim() === "") return 0;
+      const path = tempPath("stdin-script", ctx.proc.pid);
+      ctx.vfs.writeFile(path, buildBootstrapForEval(source, ["/usr/bin/node", ...scriptArgs], null, preloadSpecs), {
+        privileged: true,
+        mode: 384
+      });
+      temps.push(path);
+      return execute(ctx, { script: path, argv: scriptArgs, temps, ...env2 ? { env: env2 } : {} });
+    }
+    const script = resolveScript(ctx, scriptArg);
+    if (!script) {
+      ctx.stderr.write(
+        `node:internal/modules/cjs/loader:1215
+  throw err;
+  ^
+
+Error: Cannot find module '${ctx.path(scriptArg)}'
+`
+      );
+      return 1;
+    }
+    const stdinPath = await captureStdin(ctx);
+    if (stdinPath) temps.push(stdinPath);
+    const sibling = siblingPath(script, ctx.proc.pid);
+    try {
+      const source = ctx.vfs.readText(script, ctx.cred);
+      ctx.vfs.writeFile(sibling, withPrelude(source, buildPrelude(script, scriptArgs, stdinPath, preloadSpecs)), {
+        privileged: true,
+        mode: 384
+      });
+      temps.push(sibling);
+      return await execute(ctx, {
+        script: sibling,
+        argvPath: script,
+        argv: scriptArgs,
+        stdinPath,
+        temps,
+        ...env2 ? { env: env2 } : {}
+      });
+    } catch {
+      return await execute(ctx, { script, argv: scriptArgs, stdinPath, temps, ...env2 ? { env: env2 } : {} });
+    }
+  }
+});
+function buildBootstrapForEval(source, argv, stdinPath, preloads = []) {
+  const prelude = stdinPath ? `const fs = require('fs');
+const { Readable } = require('stream');
+let __sbxData; try { __sbxData = fs.readFileSync(${JSON.stringify(stdinPath)}); } catch (e) { __sbxData = Buffer.alloc(0); }
+const __sbxStdin = Readable.from([__sbxData]);
+__sbxStdin.isTTY = false;
+__sbxStdin.setRawMode = function () { return this; };
+try { Object.defineProperty(process, 'stdin', { value: __sbxStdin, configurable: true, writable: true }); } catch (e) { process.stdin = __sbxStdin; }
+` : "";
+  return `${BUFFER_COMPAT_SHIM}process.argv = ${JSON.stringify(argv)};
+${prelude}${preloadRequires(preloads)}${source}
+`;
+}
+function resolveScript(ctx, operand) {
+  const base2 = ctx.path(operand);
+  const candidates = [base2, `${base2}.js`, `${base2}.mjs`, `${base2}.cjs`, `${base2}.json`];
+  for (const candidate of candidates) {
+    try {
+      const st = ctx.vfs.stat(candidate, { cred: ctx.cred });
+      if (st.isFile()) return ctx.vfs.realpath(candidate, ctx.cred);
+      if (st.isDirectory()) {
+        const manifest = join(candidate, "package.json");
+        if (ctx.vfs.lexists(manifest)) {
+          try {
+            const main = JSON.parse(ctx.vfs.readText(manifest, ctx.cred)).main;
+            if (main) {
+              const mainPath = resolve(candidate, main);
+              if (ctx.vfs.lexists(mainPath)) return ctx.vfs.realpath(mainPath, ctx.cred);
+              if (ctx.vfs.lexists(mainPath + ".js")) return ctx.vfs.realpath(mainPath + ".js", ctx.cred);
+            }
+          } catch {
+          }
+        }
+        for (const index of ["index.js", "index.mjs", "index.cjs"]) {
+          const path = join(candidate, index);
+          if (ctx.vfs.lexists(path)) return ctx.vfs.realpath(path, ctx.cred);
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function runRepl(ctx) {
+  const historyPath = join(ctx.env.HOME ?? "/root", ".node_repl_history");
+  const statements = [];
+  for (; ; ) {
+    ctx.write("> ");
+    const line = await ctx.stdin.readLine();
+    if (line === null) {
+      ctx.line("");
+      break;
+    }
+    const trimmed = line.trim();
+    if (trimmed === ".exit") break;
+    if (trimmed === ".help") {
+      ctx.line(".exit     Exit the REPL");
+      ctx.line(".help     Print this help message");
+      ctx.line(".clear    Reset the session context");
+      continue;
+    }
+    if (trimmed === ".clear") {
+      statements.length = 0;
+      continue;
+    }
+    if (trimmed === "") continue;
+    const program = [...statements, `console.log(require('util').inspect((${trimmed})))`].join(";\n");
+    const fallback = [...statements, trimmed].join(";\n");
+    const path = tempPath("repl", ctx.proc.pid);
+    ctx.vfs.writeFile(path, program, { privileged: true, mode: 384 });
+    const result = await runQuiet(ctx, path);
+    if (result.exitCode !== 0) {
+      ctx.vfs.writeFile(path, fallback, { privileged: true, mode: 384 });
+      const second = await runQuiet(ctx, path);
+      ctx.write(second.stdout);
+      if (second.exitCode === 0) statements.push(trimmed);
+      else ctx.stderr.write(second.stderr);
+    } else {
+      ctx.write(result.stdout);
+      statements.push(trimmed);
+    }
+    try {
+      ctx.vfs.unlink(path);
+    } catch {
+    }
+    try {
+      ctx.vfs.appendFile(historyPath, trimmed + "\n", { cred: ctx.cred });
+    } catch {
+    }
+  }
+  return 0;
+}
+async function runQuiet(ctx, script) {
+  try {
+    const proc = await ctx.kernel.pod.spawn("node", [script], { cwd: ctx.cwd, env: ctx.env });
+    return await proc.completion;
+  } catch (e) {
+    return { exitCode: 1, stdout: "", stderr: `${e instanceof Error ? e.message : String(e)}
+` };
+  }
+}
+function printHelp(ctx) {
+  ctx.line("Usage: node [options] [script.js] [arguments]");
+  ctx.line("       node --test [files or globs]");
+  ctx.line("");
+  ctx.line("Options:");
+  ctx.line("  -v, --version              print Node.js version");
+  ctx.line("  -e, --eval script          evaluate script");
+  ctx.line("  -p, --print                evaluate script and print result");
+  ctx.line("  -c, --check                check syntax without running");
+  ctx.line("  -r, --require module       load a module before the program");
+  ctx.line("  --import module            load a module before the program");
+  ctx.line("  --env-file file            load environment variables from a file");
+  ctx.line("  --test                     run test files with node:test");
+  ctx.line("  --test-reporter spec|tap   choose the test report format");
+  ctx.line("  --test-name-pattern regex  run only tests whose name matches");
+  ctx.line("  -h, --help                 print this message");
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-r",
+  "--require",
+  "--import",
+  "--loader",
+  "--experimental-loader",
+  "--env-file",
+  "--env-file-if-exists",
+  "--input-type",
+  "--title",
+  "-C",
+  "--conditions",
+  "--test-reporter",
+  "--test-reporter-destination",
+  "--test-name-pattern",
+  "--test-skip-pattern",
+  "--test-concurrency",
+  "--test-timeout",
+  "--test-shard",
+  "--disable-warning",
+  "--redirect-warnings",
+  "--stack-trace-limit",
+  "--inspect-port",
+  "--report-dir",
+  "--report-filename"
+]);
+function parseEnvFile(text2) {
+  const out = {};
+  for (const raw of text2.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const match2 = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_.-]*)\s*=\s*(.*)$/.exec(line);
+    if (!match2) continue;
+    let value = match2[2];
+    const quote3 = value[0];
+    if ((quote3 === '"' || quote3 === "'" || quote3 === "`") && value.length >= 2 && value.endsWith(quote3)) {
+      value = value.slice(1, -1);
+      if (quote3 === '"') value = value.replace(/\\n/g, "\n");
+    } else {
+      const comment = value.indexOf(" #");
+      if (comment >= 0) value = value.slice(0, comment);
+      value = value.trim();
+    }
+    out[match2[1]] = value;
+  }
+  return out;
+}
+var AsyncFunction = Object.getPrototypeOf(async function() {
+}).constructor;
+function checkSyntax(ctx, script) {
+  let source = ctx.vfs.readText(script, ctx.cred);
+  if (source.startsWith("#!")) source = `//${source.slice(2)}`;
+  try {
+    const esm = script.endsWith(".mjs") || !script.endsWith(".cjs") && looksLikeEsm(source);
+    const transformed = esm ? transformEsm(source, script) : null;
+    new AsyncFunction("exports", "require", "module", "__filename", "__dirname", transformed?.code ?? source);
+    return 0;
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    ctx.stderr.write(`${script}
+
+${error.name}: ${error.message}
+
+Node.js ${NODE_VERSION}
+`);
+    return 1;
+  }
+}
+var TEST_FILE_NAME = /^(?:test|test-.+|.+[.\-_]test)\.(?:c|m)?js$/;
+var SCRIPT_FILE = /\.(?:c|m)?js$/;
+function globToRegExp(pattern) {
+  let out = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const ch = pattern[index];
+    if (ch === "*") {
+      if (pattern[index + 1] === "*") {
+        index += 1;
+        if (pattern[index + 1] === "/") index += 1;
+        out += "(?:.*/)?";
+      } else out += "[^/]*";
+    } else if (ch === "?") out += "[^/]";
+    else out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${out}$`);
+}
+function discoverTestFiles(ctx, patterns) {
+  const files = /* @__PURE__ */ new Set();
+  const missing = [];
+  const walk = (dir3, visit, underTestDir = false) => {
+    let names;
+    try {
+      names = ctx.vfs.readdir(dir3, ctx.cred);
+    } catch {
+      return;
+    }
+    for (const name of [...names].sort()) {
+      if (name === "node_modules" || name.startsWith(".")) continue;
+      const path = join(dir3, name);
+      let isDirectory;
+      try {
+        isDirectory = ctx.vfs.stat(path, { cred: ctx.cred }).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDirectory) walk(path, visit, underTestDir || name === "test");
+      else visit(path, name, underTestDir);
+    }
+  };
+  const byName = (path, name, underTestDir) => {
+    if (SCRIPT_FILE.test(name) && (underTestDir || TEST_FILE_NAME.test(name))) files.add(path);
+  };
+  if (patterns.length === 0) walk(ctx.cwd, byName);
+  for (const pattern of patterns) {
+    const target = ctx.path(pattern);
+    let stat2 = null;
+    try {
+      stat2 = ctx.vfs.stat(target, { cred: ctx.cred });
+    } catch {
+      stat2 = null;
+    }
+    if (stat2?.isFile()) {
+      files.add(target);
+      continue;
+    }
+    if (stat2?.isDirectory()) {
+      walk(target, byName, basename(target) === "test");
+      continue;
+    }
+    if (/[*?]/.test(pattern)) {
+      const matcher = globToRegExp(target);
+      const before = files.size;
+      walk(ctx.cwd, (path) => {
+        if (matcher.test(path)) files.add(path);
+      });
+      if (files.size > before) continue;
+    }
+    missing.push(pattern);
+  }
+  return { files: [...files].sort(), missing };
+}
+async function runTestFiles(ctx, args, settings, preloads, env2) {
+  const patterns = [];
+  for (const arg of args) {
+    if (arg.startsWith("--test-reporter=")) settings.reporter = arg.endsWith("=tap") ? "tap" : "spec";
+    else if (arg.startsWith("--test-name-pattern=")) settings.namePatterns.push(arg.slice("--test-name-pattern=".length));
+    else if (arg === "--test-only") settings.only = true;
+    else if (!arg.startsWith("-")) patterns.push(arg);
+  }
+  const { files, missing } = discoverTestFiles(ctx, patterns);
+  if (missing.length > 0) {
+    for (const pattern of missing) ctx.stderr.write(`Could not find '${ctx.path(pattern)}'
+`);
+    return 1;
+  }
+  if (files.length === 0) {
+    ctx.stderr.write(
+      "node --test: no test files found. Test files are named *.test.js, *-test.js, *_test.js, test-*.js or test.js (also .mjs and .cjs), or live in a test/ directory; node_modules is not searched.\n"
+    );
+    return 0;
+  }
+  const childEnv = { ...env2, SANDBOXEDJS_NODE_TEST: JSON.stringify(settings) };
+  let failed = 0;
+  for (const file3 of files) {
+    const child = ctx.kernel.spawn(["node", ...preloads.flatMap((spec) => ["-r", spec]), file3], {
+      cwd: ctx.cwd,
+      env: childEnv,
+      cred: ctx.cred,
+      ppid: ctx.proc.pid,
+      stdout: ctx.stdout,
+      stderr: ctx.stderr
+    });
+    if (await child.wait() !== 0) failed += 1;
+  }
+  if (files.length > 1) {
+    ctx.line(settings.reporter === "tap" ? `# files ${files.length} failed ${failed}` : `\u2139 files ${files.length}, failed ${failed}`);
+  }
+  return failed > 0 ? 1 : 0;
+}
+var nodeVersionFile = defineCommand({
+  name: "nvm",
+  path: "/usr/local/bin/nvm",
+  summary: "node version manager (single-version stub)",
+  run(ctx) {
+    const sub = ctx.args[0];
+    if (sub === "current" || sub === "version") {
+      ctx.line(NODE_VERSION);
+      return 0;
+    }
+    if (sub === "ls" || sub === "list") {
+      ctx.line(`->     ${NODE_VERSION}`);
+      return 0;
+    }
+    ctx.line(`nvm: only ${NODE_VERSION} is available in this container`);
+    return 0;
+  }
+});
+function nodeCommands() {
+  return [node, nodeVersionFile];
+}
+
+// src/python/python.ts
+init_path();
+
+// src/python/host-abi.ts
+var SBX_HOST_ABI_VERSION = 1;
+var SBX_REQUEST_HEADER_BYTES = 16;
+var SBX_RESPONSE_HEADER_BYTES = 20;
+var Op = {
+  handshake: 0,
+  openat: 1,
+  close: 2,
+  read: 3,
+  write: 4,
+  pread: 5,
+  pwrite: 6,
+  lseek: 7,
+  fstat: 8,
+  statat: 9,
+  ftruncate: 10,
+  renameat: 11,
+  unlinkat: 12,
+  mkdirat: 13,
+  readlinkat: 14,
+  symlinkat: 15,
+  getdents: 16,
+  fsync: 17,
+  dup: 256,
+  dup2: 257,
+  get_flags: 258,
+  set_flags: 259,
+  pipe: 512,
+  poll: 768,
+  clock_gettime: 1024,
+  sleep: 1025,
+  getpid: 1280,
+  getcwd: 1281,
   chdir: 1282,
   environ: 1283,
   getrandom: 1536,
@@ -18363,7 +19169,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.73"};
+  version: "0.1.74"};
 
 // src/python/config.ts
 function runtimeModuleUrl() {
@@ -22334,7 +23140,7 @@ var pyodideModule = null;
 var indexUrl;
 var moduleUrl;
 var DEFAULT_BROWSER_INDEX_URL = "https://cdn.jsdelivr.net/pyodide/v0.28.3/full/";
-var isNode2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var isNode3 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 function configureCPython(options = {}) {
   if (options.indexURL !== void 0) indexUrl = options.indexURL;
   if (options.moduleURL !== void 0) {
@@ -22350,7 +23156,7 @@ function importPyodide() {
         /* webpackIgnore: true */
         moduleUrl
       );
-    } else if (isNode2) {
+    } else if (isNode3) {
       pyodideModule = nodeOnlyModule("pyodide");
     } else {
       pyodideModule = import(
@@ -22364,7 +23170,7 @@ function importPyodide() {
 }
 async function resolveIndexUrl() {
   if (indexUrl) return indexUrl;
-  if (!isNode2) return DEFAULT_BROWSER_INDEX_URL;
+  if (!isNode3) return DEFAULT_BROWSER_INDEX_URL;
   try {
     const { createRequire } = await nodeBuiltin("module");
     const path = await nodeBuiltin("path");
@@ -24303,7 +25109,7 @@ function renameShadowedExports(source) {
     (node2) => node2.type.startsWith("Import") || node2.type.startsWith("Export")
   );
   if (!isModule) return null;
-  const programScope = { bindsExports: hoistedNames(body).has(NAME), parent: null };
+  const programScope = { bindsExports: hoistedNames2(body).has(NAME), parent: null };
   if (!programScope.bindsExports) return null;
   const targets = [];
   let bail = false;
@@ -24319,24 +25125,24 @@ function renameShadowedExports(source) {
   function visit(node2, scope) {
     if (bail) return;
     let childScope = scope;
-    let skip = NOTHING;
+    let skip = NOTHING2;
     switch (node2.type) {
       case "FunctionDeclaration":
       case "FunctionExpression":
       case "ArrowFunctionExpression": {
         const names = /* @__PURE__ */ new Set();
-        for (const param of node2.params ?? []) collectPattern(param, names);
+        for (const param of node2.params ?? []) collectPattern2(param, names);
         if (isExports(node2.id) && node2.type === "FunctionExpression") names.add(NAME);
         const fnBody = node2.body;
         if (fnBody?.type === "BlockStatement") {
-          for (const name of hoistedNames(fnBody.body)) names.add(name);
+          for (const name of hoistedNames2(fnBody.body)) names.add(name);
         }
         childScope = { bindsExports: names.has(NAME), parent: scope };
         break;
       }
       case "CatchClause": {
         const names = /* @__PURE__ */ new Set();
-        if (node2.param) collectPattern(node2.param, names);
+        if (node2.param) collectPattern2(node2.param, names);
         childScope = { bindsExports: names.has(NAME), parent: scope };
         break;
       }
@@ -24350,7 +25156,7 @@ function renameShadowedExports(source) {
       case "StaticBlock":
         if (node2 !== ast.body) {
           childScope = {
-            bindsExports: blockNames(node2.body).has(NAME),
+            bindsExports: blockNames2(node2.body).has(NAME),
             parent: scope
           };
         }
@@ -24362,7 +25168,7 @@ function renameShadowedExports(source) {
         if (head2?.type === "VariableDeclaration" && head2.kind !== "var") {
           const names = /* @__PURE__ */ new Set();
           for (const declarator of head2.declarations) {
-            collectPattern(declarator.id, names);
+            collectPattern2(declarator.id, names);
           }
           childScope = { bindsExports: names.has(NAME), parent: scope };
         }
@@ -24386,7 +25192,7 @@ function renameShadowedExports(source) {
       case "MemberExpression":
       case "MethodDefinition":
       case "PropertyDefinition":
-        skip = node2.computed ? NOTHING : PROPERTY;
+        skip = node2.computed ? NOTHING2 : PROPERTY2;
         break;
       case "Property":
         if (node2.computed) break;
@@ -24397,19 +25203,19 @@ function renameShadowedExports(source) {
           }
           return;
         }
-        skip = PROPERTY;
+        skip = PROPERTY2;
         break;
       case "LabeledStatement":
       case "BreakStatement":
       case "ContinueStatement":
-        skip = LABEL;
+        skip = LABEL2;
         break;
     }
     for (const [key, value] of Object.entries(node2)) {
       if (key === "type" || key === "start" || key === "end" || skip.includes(key)) continue;
       if (Array.isArray(value)) {
-        for (const item of value) if (isNode3(item)) visit(item, childScope);
-      } else if (isNode3(value)) {
+        for (const item of value) if (isNode4(item)) visit(item, childScope);
+      } else if (isNode4(value)) {
         visit(value, childScope);
       }
     }
@@ -24421,73 +25227,73 @@ function resolvesToProgram(scope) {
   }
   return false;
 }
-function hoistedNames(body) {
-  const names = blockNames(body);
-  collectVars(body, names);
+function hoistedNames2(body) {
+  const names = blockNames2(body);
+  collectVars2(body, names);
   return names;
 }
-function blockNames(body) {
+function blockNames2(body) {
   const names = /* @__PURE__ */ new Set();
   for (const node2 of body ?? []) {
     if (node2.type === "VariableDeclaration" && node2.kind !== "var") {
       for (const declarator of node2.declarations) {
-        collectPattern(declarator.id, names);
+        collectPattern2(declarator.id, names);
       }
-    } else if (node2.type === "ClassDeclaration" && isNode3(node2.id)) {
+    } else if (node2.type === "ClassDeclaration" && isNode4(node2.id)) {
       names.add(node2.id.name);
-    } else if (node2.type === "FunctionDeclaration" && isNode3(node2.id)) {
+    } else if (node2.type === "FunctionDeclaration" && isNode4(node2.id)) {
       names.add(node2.id.name);
     }
   }
   return names;
 }
-function collectVars(nodes, names) {
+function collectVars2(nodes, names) {
   if (Array.isArray(nodes)) {
-    for (const item of nodes) collectVars(item, names);
+    for (const item of nodes) collectVars2(item, names);
     return;
   }
-  if (!isNode3(nodes)) return;
+  if (!isNode4(nodes)) return;
   const node2 = nodes;
   if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
-    if (isNode3(node2.id)) names.add(node2.id.name);
+    if (isNode4(node2.id)) names.add(node2.id.name);
     return;
   }
   if (node2.type === "VariableDeclaration" && node2.kind === "var") {
     for (const declarator of node2.declarations) {
-      collectPattern(declarator.id, names);
+      collectPattern2(declarator.id, names);
     }
   }
   for (const [key, value] of Object.entries(node2)) {
     if (key === "type" || key === "start" || key === "end") continue;
-    collectVars(value, names);
+    collectVars2(value, names);
   }
 }
-function collectPattern(node2, names) {
-  if (!isNode3(node2)) return;
+function collectPattern2(node2, names) {
+  if (!isNode4(node2)) return;
   switch (node2.type) {
     case "Identifier":
       names.add(node2.name);
       return;
     case "ObjectPattern":
       for (const property of node2.properties) {
-        collectPattern(property.value ?? property.argument, names);
+        collectPattern2(property.value ?? property.argument, names);
       }
       return;
     case "ArrayPattern":
-      for (const element of node2.elements) collectPattern(element, names);
+      for (const element of node2.elements) collectPattern2(element, names);
       return;
     case "AssignmentPattern":
-      collectPattern(node2.left, names);
+      collectPattern2(node2.left, names);
       return;
     case "RestElement":
-      collectPattern(node2.argument, names);
+      collectPattern2(node2.argument, names);
       return;
     default:
       return;
   }
 }
 function isExports(value) {
-  return isNode3(value) && value.type === "Identifier" && value.name === NAME;
+  return isNode4(value) && value.type === "Identifier" && value.name === NAME;
 }
 function freshName(source) {
   let name = "__sandboxedjs_exports";
@@ -24495,12 +25301,12 @@ function freshName(source) {
   while (source.includes(name)) name = `__sandboxedjs_exports${++suffix}`;
   return name;
 }
-function isNode3(value) {
+function isNode4(value) {
   return typeof value === "object" && value !== null && typeof value.type === "string";
 }
-var NOTHING = [];
-var PROPERTY = ["property", "key"];
-var LABEL = ["label"];
+var NOTHING2 = [];
+var PROPERTY2 = ["property", "key"];
+var LABEL2 = ["label"];
 
 // src/pkg/index.ts
 init_path();
@@ -25246,752 +26052,356 @@ var ContainerFs = class {
     this.vfs.symlink(target, clean(link));
   }
   async readlink(path) {
-    return this.vfs.readlink(clean(path));
-  }
-  async realpath(path) {
-    return this.vfs.realpath(clean(path));
-  }
-  async chmod(path, mode) {
-    this.vfs.chmod(clean(path), mode);
-  }
-  async chown(path, uid, gid) {
-    this.vfs.chown(clean(path), uid, gid, ROOT_CRED);
-  }
-  /** Every path beneath `root`, depth-first. */
-  async walk(root = "/") {
-    return [...this.vfs.walk(clean(root))];
-  }
-  /** Total bytes and file counts, as `df` reports them. */
-  async usage(root = "/") {
-    return this.vfs.usage(clean(root));
-  }
-  /** Read many files at once, keyed by path. */
-  async readAll(paths) {
-    const out = {};
-    for (const path of paths) out[path] = this.vfs.readText(clean(path));
-    return out;
-  }
-  /** Write a whole map of files, creating parents. */
-  async writeAll(files, opts = {}) {
-    for (const [key, value] of Object.entries(files)) {
-      await this.writeFile(resolve(opts.cwd ?? "/", key), value);
-    }
-  }
-};
-
-// src/container/session.ts
-var Session = class {
-  constructor(kernel, init) {
-    this.kernel = kernel;
-    this.proc = kernel.procs.create({
-      argv: ["-sh"],
-      cwd: init.cwd,
-      env: init.env,
-      cred: init.cred,
-      ppid: 1,
-      kind: "shell",
-      tty: "pts/0"
-    });
-    this.shell = new Shell({
-      kernel,
-      proc: this.proc,
-      cwd: init.cwd,
-      env: init.env,
-      cred: init.cred,
-      scriptName: "sh",
-      options: { interactive: true }
-    });
-    this.hooks = init.hooks ?? {};
-  }
-  kernel;
-  shell;
-  proc;
-  closed = false;
-  hooks;
-  get cwd() {
-    return this.shell.cwd;
-  }
-  get env() {
-    return this.shell.vars.environment();
-  }
-  get history() {
-    return this.shell.history;
-  }
-  /** Run a command line, keeping every side effect for the next call. */
-  async run(command, opts = {}) {
-    if (this.closed) throw new Error("session is closed");
-    const combined = [];
-    const decoder9 = new TextDecoder();
-    const stdout = new BufferSink((chunk) => {
-      const text2 = decoder9.decode(chunk, { stream: true });
-      combined.push(text2);
-      opts.onStdout?.(text2);
-      this.hooks.onStdout?.(text2);
-    });
-    const stderr = new BufferSink((chunk) => {
-      const text2 = decoder9.decode(chunk, { stream: true });
-      combined.push(text2);
-      opts.onStderr?.(text2);
-      this.hooks.onStderr?.(text2);
-    });
-    if (opts.tty) {
-      stdout.isTTY = true;
-      stderr.isTTY = true;
-      stdout.columns = opts.columns ?? 80;
-      stdout.rows = opts.rows ?? 24;
-    }
-    const stdin = opts.stdin === void 0 ? new NullInput() : typeof opts.stdin === "string" || opts.stdin instanceof Uint8Array ? Pipe.from(opts.stdin) : opts.stdin;
-    this.shell.history.push(command);
-    let timer;
-    if (opts.timeoutMs !== void 0) {
-      timer = setTimeout(() => this.proc.deliver("SIGKILL"), opts.timeoutMs);
-    }
-    let exitCode;
-    try {
-      exitCode = await this.shell.execute(command, { stdin, stdout, stderr });
-    } finally {
-      if (timer) clearTimeout(timer);
-    }
-    return { exitCode, stdout: stdout.text(), stderr: stderr.text(), output: combined.join("") };
-  }
-  /** Stream a long-running command; resolves when it exits. */
-  async stream(command, handlers = {}) {
-    const result = await this.run(command, handlers);
-    return result.exitCode;
-  }
-  /** Feed the session an arbitrary output stream, for terminal integration. */
-  async pipeTo(command, stdout, stderr, stdin) {
-    return this.shell.execute(command, { stdin: stdin ?? new NullInput(), stdout, stderr });
-  }
-  /** True when the last command asked the shell to exit. */
-  get isExiting() {
-    return this.shell.isExiting;
-  }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.proc.exit(0);
-    this.kernel.procs.remove(this.proc.pid);
-  }
-};
-
-// src/node/node-child-process-bridge.ts
-var KernelChildProcess = class {
-  pid;
-  command;
-  args;
-  parentPid;
-  state = "running";
-  exitCode;
-  stdout = "";
-  stderr = "";
-  listeners = /* @__PURE__ */ new Map();
-  kernel;
-  cred;
-  cwd;
-  env;
-  stdin = new Pipe();
-  process;
-  started = false;
-  cancelled = false;
-  constructor(kernel, cred, config2, pid) {
-    this.stdin.interactive = true;
-    if (config2.inheritStdio) this.stdin.isTTY = true;
-    if (config2.stdinIgnored) this.stdin.end();
-    this.stdin.onRawMode = (enabled) => this.emit("rawmode", enabled);
-    this.kernel = kernel;
-    this.cred = cred;
-    this.pid = pid;
-    this.command = config2.command;
-    this.args = config2.args?.slice() ?? [];
-    this.parentPid = config2.parentPid;
-    this.cwd = config2.cwd ?? "/";
-    this.env = { ...config2.env };
-  }
-  on(event, listener) {
-    let listeners = this.listeners.get(event);
-    if (!listeners) {
-      listeners = /* @__PURE__ */ new Set();
-      this.listeners.set(event, listeners);
-    }
-    listeners.add(listener);
-    return this;
-  }
-  emit(event, ...args) {
-    for (const listener of this.listeners.get(event) ?? []) listener(...args);
-  }
-  exec() {
-    if (this.started) return;
-    this.started = true;
-    queueMicrotask(() => {
-      if (this.cancelled) {
-        this.finish(143);
-        return;
-      }
-      const stdout = new ChildOutput(this, "stdout");
-      const stderr = new ChildOutput(this, "stderr");
-      try {
-        this.process = this.kernel.spawn([this.command, ...this.args], {
-          cwd: this.cwd,
-          env: this.env,
-          cred: this.cred,
-          stdin: this.stdin,
-          stdout,
-          stderr,
-          ppid: 1
-        });
-        void this.process.wait().then((code) => {
-          stdout.end();
-          stderr.end();
-          this.finish(code);
-        });
-      } catch (error) {
-        stderr.write(error instanceof Error ? error.message : String(error));
-        stderr.end();
-        stdout.end();
-        this.finish(1);
-      }
-    });
-  }
-  sendStdin(data) {
-    try {
-      this.stdin.write(data);
-    } catch {
-    }
-  }
-  /** Signal EOF, so a child reading stdin to the end can finish. */
-  endStdin() {
-    try {
-      this.stdin.end();
-    } catch {
-    }
-  }
-  kill(signal = "SIGTERM") {
-    if (this.process) {
-      this.process.deliver(signal);
-      return;
-    }
-    this.cancelled = true;
+    return this.vfs.readlink(clean(path));
   }
-  finish(code) {
-    if (this.state === "exited") return;
-    this.state = "exited";
-    this.exitCode = code;
-    this.emit("exit", code);
+  async realpath(path) {
+    return this.vfs.realpath(clean(path));
   }
-  append(stream, text2) {
-    this[stream] += text2;
-    this.emit(stream, text2);
+  async chmod(path, mode) {
+    this.vfs.chmod(clean(path), mode);
   }
-};
-var ChildOutput = class {
-  constructor(child, stream) {
-    this.child = child;
-    this.stream = stream;
+  async chown(path, uid, gid) {
+    this.vfs.chown(clean(path), uid, gid, ROOT_CRED);
   }
-  child;
-  stream;
-  isTTY = false;
-  closedState = false;
-  decoder = new TextDecoder();
-  get closed() {
-    return this.closedState;
+  /** Every path beneath `root`, depth-first. */
+  async walk(root = "/") {
+    return [...this.vfs.walk(clean(root))];
   }
-  write(data) {
-    if (this.closedState) return;
-    const text2 = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
-    if (text2) this.child.append(this.stream, text2);
+  /** Total bytes and file counts, as `df` reports them. */
+  async usage(root = "/") {
+    return this.vfs.usage(clean(root));
   }
-  end() {
-    if (this.closedState) return;
-    this.closedState = true;
-    const tail2 = this.decoder.decode();
-    if (tail2) this.child.append(this.stream, tail2);
+  /** Read many files at once, keyed by path. */
+  async readAll(paths) {
+    const out = {};
+    for (const path of paths) out[path] = this.vfs.readText(clean(path));
+    return out;
   }
-};
-var nextBridgePid = 1073741824;
-function installNodeChildProcessBridge(pod, kernel, cred) {
-  const manager = pod.processManager;
-  const originalSpawn = manager.spawn;
-  manager.spawn = (config2) => {
-    const resolved = kernel.resolveExecutable(config2.command, config2.cwd ?? "/", config2.env ?? {}, cred);
-    if (resolved?.kind === "builtin") {
-      return new KernelChildProcess(kernel, cred, config2, nextBridgePid++);
+  /** Write a whole map of files, creating parents. */
+  async writeAll(files, opts = {}) {
+    for (const [key, value] of Object.entries(files)) {
+      await this.writeFile(resolve(opts.cwd ?? "/", key), value);
     }
-    return originalSpawn.call(manager, config2);
-  };
-  return () => {
-    if (manager.spawn === originalSpawn) return;
-    manager.spawn = originalSpawn;
-  };
-}
-
-// src/node/host-module-tracker.ts
-var HostModuleTracker = class {
-  active = 0;
-  disposed = false;
-  dispose() {
-    this.disposed = true;
-  }
-  wrapped = /* @__PURE__ */ new WeakMap();
-  originals = /* @__PURE__ */ new WeakMap();
-  pending = () => this.active;
-  unwrap = (value) => value && (typeof value === "object" || typeof value === "function") ? this.originals.get(value) ?? value : value;
-  wrap(value) {
-    if (value === null || typeof value !== "object" && typeof value !== "function") return value;
-    const object = value;
-    if (Array.isArray(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value;
-    if (this.wrapped.has(object)) return this.wrapped.get(object);
-    const tracker = this;
-    const proxy = new Proxy(object, {
-      // CommonJS native loaders re-export by assigning exports back onto the
-      // binding object. Never store a process-owned proxy in a shared module.
-      set(target, key, member) {
-        return Reflect.set(target, key, tracker.unwrap(member), target);
-      },
-      defineProperty(target, key, descriptor) {
-        return Reflect.defineProperty(target, key, "value" in descriptor ? { ...descriptor, value: tracker.unwrap(descriptor.value) } : descriptor);
-      },
-      get(target, key) {
-        const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-        const member = Reflect.get(target, key, target);
-        if (descriptor && !descriptor.configurable && "value" in descriptor && !descriptor.writable) return member;
-        return typeof member === "function" ? tracker.wrap(member) : member;
-      },
-      apply(target, receiver, args) {
-        const result = Reflect.apply(target, tracker.unwrap(receiver), args.map(tracker.unwrap));
-        if (result && typeof result.then === "function") {
-          tracker.active++;
-          return Promise.resolve(result).then(
-            (value2) => {
-              tracker.active--;
-              return tracker.disposed ? new Promise(() => {
-              }) : tracker.wrap(value2);
-            },
-            (error) => {
-              tracker.active--;
-              if (tracker.disposed) return new Promise(() => {
-              });
-              throw error;
-            }
-          );
-        }
-        return tracker.wrap(result);
-      },
-      construct(target, args, newTarget) {
-        return tracker.wrap(Reflect.construct(target, args.map(tracker.unwrap), tracker.unwrap(newTarget)));
-      }
-    });
-    this.wrapped.set(object, proxy);
-    this.originals.set(proxy, object);
-    return proxy;
   }
 };
 
-// src/node/commonjs-engine.ts
-init_path();
-var HELPERS = {
-  /** Import a specifier and return an ES-module-shaped namespace. */
-  import: "__sbxImport",
-  /** `import(...)`, returning a promise of a namespace. */
-  dynamic: "__sbxDynamicImport",
-  /** `export * from` — copy live bindings onto `exports`. */
-  exportAll: "__sbxExportAll",
-  /** `import.meta`. */
-  meta: "__sbxMeta",
-  /**
-   * The exports object, under a name of the engine's choosing.
-   *
-   * An ES module is free to declare its own top-level `exports`, `require` or
-   * `__dirname` — they are ordinary identifiers there, and real packages use
-   * all three (`const require = createRequire(import.meta.url)` is close to
-   * idiomatic). Naming the wrapper's binding something no source would write
-   * removes that entire class of collision instead of patching it up after a
-   * `SyntaxError`.
-   */
-  exports: "__sbxExports"
-};
-var DEFAULT_LOCAL = "__sbxDefault";
-var MAYBE_ESM = /(^|[\s;}(])(?:import|export)(?:[\s({[*"']|$)|\bimport\s*\.\s*meta\b/;
-function looksLikeEsm(source) {
-  return MAYBE_ESM.test(source);
-}
-function transformEsm(source, filename = "module.js") {
-  if (!looksLikeEsm(source)) return null;
-  let ast;
-  try {
-    ast = parseModule(source, filename);
-  } catch {
-    return null;
-  }
-  const body = ast.body;
-  const hasModuleSyntax = body.some(
-    (node2) => node2.type.startsWith("Import") || node2.type.startsWith("Export")
-  );
-  const usesImportMeta = !hasModuleSyntax && containsImportMeta(ast);
-  const esm = hasModuleSyntax || usesImportMeta;
-  if (!esm && !containsImportExpression(ast)) return null;
-  const edits = [];
-  const prelude = [];
-  const importBindings = /* @__PURE__ */ new Map();
-  const exportGetters = /* @__PURE__ */ new Map();
-  let namespaceCount = 0;
-  const namespaceFor = (specifier) => {
-    const id = `__sbxNs${namespaceCount++}`;
-    prelude.push(`var ${id} = ${HELPERS.import}(${JSON.stringify(specifier)});`);
-    return id;
-  };
-  for (const node2 of body) {
-    if (node2.type === "ImportDeclaration") collectImport(node2);
+// src/container/session.ts
+var Session = class {
+  constructor(kernel, init) {
+    this.kernel = kernel;
+    this.proc = kernel.procs.create({
+      argv: ["-sh"],
+      cwd: init.cwd,
+      env: init.env,
+      cred: init.cred,
+      ppid: 1,
+      kind: "shell",
+      tty: "pts/0"
+    });
+    this.shell = new Shell({
+      kernel,
+      proc: this.proc,
+      cwd: init.cwd,
+      env: init.env,
+      cred: init.cred,
+      scriptName: "sh",
+      options: { interactive: true }
+    });
+    this.hooks = init.hooks ?? {};
   }
-  for (const node2 of body) {
-    switch (node2.type) {
-      case "ExportNamedDeclaration":
-        collectNamedExport(node2);
-        break;
-      case "ExportDefaultDeclaration":
-        collectDefaultExport(node2);
-        break;
-      case "ExportAllDeclaration":
-        collectExportAll(node2);
-        break;
-    }
+  kernel;
+  shell;
+  proc;
+  closed = false;
+  hooks;
+  get cwd() {
+    return this.shell.cwd;
   }
-  rewriteReferences();
-  const header = esm ? [
-    `Object.defineProperty(${HELPERS.exports}, "__esModule", { value: true });`,
-    ...prelude,
-    ...[...exportGetters].map(
-      ([name, expression]) => `Object.defineProperty(${HELPERS.exports}, ${JSON.stringify(name)}, { enumerable: true, configurable: true, get: function () { return ${expression}; } });`
-    )
-  ].join("\n") : "";
-  return {
-    code: header ? `${header}
-${applyEdits(source, edits)}` : applyEdits(source, edits),
-    esm,
-    topLevelAwait: hasTopLevelAwait(ast)
-  };
-  function collectImport(node2) {
-    const specifier = node2.source.value;
-    const specifiers = node2.specifiers ?? [];
-    const id = namespaceFor(specifier);
-    for (const entry of specifiers) {
-      const local = entry.local.name ?? "";
-      if (entry.type === "ImportDefaultSpecifier") {
-        importBindings.set(local, `${id}.default`);
-      } else if (entry.type === "ImportNamespaceSpecifier") {
-        importBindings.set(local, id);
-      } else {
-        const imported = entry.imported;
-        const name = imported.type === "Identifier" ? imported.name : imported.value;
-        importBindings.set(local, `${id}[${JSON.stringify(name)}]`);
-      }
-    }
-    drop(node2);
+  get env() {
+    return this.shell.vars.environment();
   }
-  function collectNamedExport(node2) {
-    const declaration = node2.declaration;
-    if (declaration) {
-      for (const name of declaredNames(declaration)) exportGetters.set(name, name);
-      edits.push({ start: node2.start, end: declaration.start, text: "" });
-      return;
+  get history() {
+    return this.shell.history;
+  }
+  /** Run a command line, keeping every side effect for the next call. */
+  async run(command, opts = {}) {
+    if (this.closed) throw new Error("session is closed");
+    const combined = [];
+    const decoder9 = new TextDecoder();
+    const stdout = new BufferSink((chunk) => {
+      const text2 = decoder9.decode(chunk, { stream: true });
+      combined.push(text2);
+      opts.onStdout?.(text2);
+      this.hooks.onStdout?.(text2);
+    });
+    const stderr = new BufferSink((chunk) => {
+      const text2 = decoder9.decode(chunk, { stream: true });
+      combined.push(text2);
+      opts.onStderr?.(text2);
+      this.hooks.onStderr?.(text2);
+    });
+    const outGate = new DetachableOutput(stdout, (text2) => this.hooks.onStdout?.(text2));
+    const errGate = new DetachableOutput(stderr, (text2) => this.hooks.onStderr?.(text2));
+    if (opts.tty) {
+      outGate.isTTY = true;
+      errGate.isTTY = true;
+      outGate.columns = opts.columns ?? 80;
+      outGate.rows = opts.rows ?? 24;
     }
-    const source_ = node2.source;
-    const id = source_ ? namespaceFor(source_.value) : null;
-    for (const entry of node2.specifiers ?? []) {
-      const local = nameOf(entry.local);
-      const exported = nameOf(entry.exported);
-      const read = id ? `${id}[${JSON.stringify(local)}]` : importBindings.get(local) ?? local;
-      exportGetters.set(exported, read);
+    const stdin = opts.stdin === void 0 ? new NullInput() : typeof opts.stdin === "string" || opts.stdin instanceof Uint8Array ? Pipe.from(opts.stdin) : opts.stdin;
+    this.shell.history.push(command);
+    let timer;
+    if (opts.timeoutMs !== void 0) {
+      timer = setTimeout(() => this.proc.deliver("SIGKILL"), opts.timeoutMs);
     }
-    drop(node2);
-  }
-  function collectDefaultExport(node2) {
-    const declaration = node2.declaration;
-    const isDeclaration = declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration";
-    if (isDeclaration) {
-      const named = declaration.id;
-      if (named) {
-        exportGetters.set("default", named.name);
-        edits.push({ start: node2.start, end: declaration.start, text: "" });
-        return;
-      }
-      const keyword = declaration.type === "FunctionDeclaration" ? "function" : "class";
-      const keywordEnd = source.indexOf(keyword, declaration.start) + keyword.length;
-      exportGetters.set("default", DEFAULT_LOCAL);
-      edits.push({ start: node2.start, end: declaration.start, text: "" });
-      edits.push({ start: keywordEnd, end: keywordEnd, text: ` ${DEFAULT_LOCAL}` });
-      return;
+    let exitCode;
+    try {
+      exitCode = await this.shell.execute(command, { stdin, stdout: outGate, stderr: errGate });
+    } finally {
+      if (timer) clearTimeout(timer);
+      outGate.detach();
+      errGate.detach();
     }
-    exportGetters.set("default", DEFAULT_LOCAL);
-    edits.push({ start: node2.start, end: declaration.start, text: `var ${DEFAULT_LOCAL} = ` });
-    edits.push({ start: node2.end, end: node2.end, text: ";" });
+    return { exitCode, stdout: stdout.text(), stderr: stderr.text(), output: combined.join("") };
   }
-  function collectExportAll(node2) {
-    const id = namespaceFor(node2.source.value);
-    const exported = node2.exported;
-    if (exported) exportGetters.set(nameOf(exported), id);
-    else prelude.push(`${HELPERS.exportAll}(${HELPERS.exports}, ${id});`);
-    drop(node2);
+  /** Stream a long-running command; resolves when it exits. */
+  async stream(command, handlers = {}) {
+    const result = await this.run(command, handlers);
+    return result.exitCode;
   }
-  function drop(node2) {
-    edits.push({ start: node2.start, end: node2.end, text: "" });
+  /** Feed the session an arbitrary output stream, for terminal integration. */
+  async pipeTo(command, stdout, stderr, stdin) {
+    return this.shell.execute(command, { stdin: stdin ?? new NullInput(), stdout, stderr });
   }
-  function rewriteReferences() {
-    const programScope = { names: new Set(importBindings.keys()), parent: null };
-    visit(ast, programScope, true);
-    function visit(node2, scope, isProgram = false) {
-      let childScope = scope;
-      let skip = NOTHING2;
-      switch (node2.type) {
-        case "ImportDeclaration":
-        case "ExportAllDeclaration":
-          return;
-        case "ExportNamedDeclaration":
-          if (!node2.declaration) return;
-          break;
-        case "FunctionDeclaration":
-        case "FunctionExpression":
-        case "ArrowFunctionExpression": {
-          const names = /* @__PURE__ */ new Set();
-          for (const param of node2.params ?? []) collectPattern2(param, names);
-          const id = node2.id;
-          if (id && node2.type === "FunctionExpression") names.add(id.name);
-          const fnBody = node2.body;
-          if (fnBody?.type === "BlockStatement") {
-            for (const name of hoistedNames2(fnBody.body)) names.add(name);
-          }
-          childScope = { names, parent: scope };
-          break;
-        }
-        case "CatchClause": {
-          const names = /* @__PURE__ */ new Set();
-          if (node2.param) collectPattern2(node2.param, names);
-          childScope = { names, parent: scope };
-          break;
-        }
-        case "ClassExpression": {
-          const id = node2.id;
-          if (id) childScope = { names: /* @__PURE__ */ new Set([id.name]), parent: scope };
-          break;
-        }
-        case "BlockStatement":
-        case "StaticBlock":
-          if (!isProgram) {
-            childScope = { names: blockNames2(node2.body), parent: scope };
-          }
-          break;
-        case "ForStatement":
-        case "ForInStatement":
-        case "ForOfStatement": {
-          const head2 = node2.init ?? node2.left;
-          if (head2?.type === "VariableDeclaration" && head2.kind !== "var") {
-            const names = /* @__PURE__ */ new Set();
-            for (const declarator of head2.declarations) {
-              collectPattern2(declarator.id, names);
-            }
-            childScope = { names, parent: scope };
-          }
-          break;
-        }
-        case "MetaProperty":
-          edits.push({ start: node2.start, end: node2.end, text: HELPERS.meta });
-          return;
-        case "ImportExpression": {
-          const argument = node2.source;
-          edits.push({ start: node2.start, end: argument.start, text: `${HELPERS.dynamic}(` });
-          visit(argument, childScope);
-          edits.push({ start: argument.end, end: node2.end, text: ")" });
-          return;
-        }
-        case "Identifier": {
-          const replacement = lookup(node2.name, scope);
-          if (replacement) edits.push({ start: node2.start, end: node2.end, text: replacement });
-          return;
-        }
-        case "MemberExpression":
-        case "MethodDefinition":
-        case "PropertyDefinition":
-          skip = node2.computed ? NOTHING2 : PROPERTY2;
-          break;
-        case "Property": {
-          if (node2.computed) break;
-          if (node2.shorthand) {
-            const value = node2.value;
-            if (value.type === "Identifier") {
-              const replacement = lookup(value.name, scope);
-              if (replacement) {
-                edits.push({ start: value.start, end: value.end, text: `${value.name}: ${replacement}` });
-                return;
-              }
-            }
-            break;
-          }
-          skip = PROPERTY2;
-          break;
-        }
-        case "LabeledStatement":
-        case "BreakStatement":
-        case "ContinueStatement":
-          skip = LABEL2;
-          break;
-      }
-      for (const [key, value] of Object.entries(node2)) {
-        if (key === "type" || key === "start" || key === "end" || skip.includes(key)) continue;
-        if (Array.isArray(value)) {
-          for (const item of value) if (isNode4(item)) visit(item, childScope);
-        } else if (isNode4(value)) {
-          visit(value, childScope);
-        }
-      }
-    }
-    function lookup(name, scope) {
-      for (let current = scope; current; current = current.parent) {
-        if (current.names.has(name)) {
-          return current.parent === null ? importBindings.get(name) ?? null : null;
-        }
-      }
-      return null;
-    }
+  /** True when the last command asked the shell to exit. */
+  get isExiting() {
+    return this.shell.isExiting;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.proc.exit(0);
+    this.kernel.procs.remove(this.proc.pid);
   }
-}
-var JSX_EXTENSION = /\.[jt]sx$/;
-var JsxParser = acorn.Parser.extend(jsx__default.default());
-var PARSE_OPTIONS = {
-  ecmaVersion: "latest",
-  sourceType: "module",
-  allowAwaitOutsideFunction: true,
-  allowHashBang: true,
-  allowReturnOutsideFunction: true
 };
-function parseModule(source, filename) {
-  const parser = JSX_EXTENSION.test(filename) ? JsxParser.parse.bind(JsxParser) : acorn.parse;
-  return parser(source, PARSE_OPTIONS);
-}
-function containsImportExpression(node2) {
-  if (Array.isArray(node2)) return node2.some(containsImportExpression);
-  if (!isNode4(node2)) return false;
-  if (node2.type === "ImportExpression") return true;
-  for (const [key, value] of Object.entries(node2)) {
-    if (key === "type" || key === "start" || key === "end") continue;
-    if (containsImportExpression(value)) return true;
+
+// src/node/node-child-process-bridge.ts
+var KernelChildProcess = class {
+  pid;
+  command;
+  args;
+  parentPid;
+  state = "running";
+  exitCode;
+  stdout = "";
+  stderr = "";
+  listeners = /* @__PURE__ */ new Map();
+  kernel;
+  cred;
+  cwd;
+  env;
+  stdin = new Pipe();
+  process;
+  started = false;
+  cancelled = false;
+  constructor(kernel, cred, config2, pid) {
+    this.stdin.interactive = true;
+    if (config2.inheritStdio) this.stdin.isTTY = true;
+    if (config2.stdinIgnored) this.stdin.end();
+    this.stdin.onRawMode = (enabled) => this.emit("rawmode", enabled);
+    this.kernel = kernel;
+    this.cred = cred;
+    this.pid = pid;
+    this.command = config2.command;
+    this.args = config2.args?.slice() ?? [];
+    this.parentPid = config2.parentPid;
+    this.cwd = config2.cwd ?? "/";
+    this.env = { ...config2.env };
+  }
+  on(event, listener) {
+    let listeners = this.listeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(event, listeners);
+    }
+    listeners.add(listener);
+    return this;
   }
-  return false;
-}
-function containsImportMeta(node2) {
-  if (Array.isArray(node2)) return node2.some(containsImportMeta);
-  if (!isNode4(node2)) return false;
-  if (node2.type === "MetaProperty") return true;
-  for (const [key, value] of Object.entries(node2)) {
-    if (key === "type" || key === "start" || key === "end") continue;
-    if (containsImportMeta(value)) return true;
+  emit(event, ...args) {
+    for (const listener of this.listeners.get(event) ?? []) listener(...args);
   }
-  return false;
-}
-function hasTopLevelAwait(node2) {
-  if (Array.isArray(node2)) return node2.some(hasTopLevelAwait);
-  if (!isNode4(node2)) return false;
-  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
-    return false;
+  exec() {
+    if (this.started) return;
+    this.started = true;
+    queueMicrotask(() => {
+      if (this.cancelled) {
+        this.finish(143);
+        return;
+      }
+      const stdout = new ChildOutput(this, "stdout");
+      const stderr = new ChildOutput(this, "stderr");
+      try {
+        this.process = this.kernel.spawn([this.command, ...this.args], {
+          cwd: this.cwd,
+          env: this.env,
+          cred: this.cred,
+          stdin: this.stdin,
+          stdout,
+          stderr,
+          ppid: 1
+        });
+        void this.process.wait().then((code) => {
+          stdout.end();
+          stderr.end();
+          this.finish(code);
+        });
+      } catch (error) {
+        stderr.write(error instanceof Error ? error.message : String(error));
+        stderr.end();
+        stdout.end();
+        this.finish(1);
+      }
+    });
   }
-  if (node2.type === "AwaitExpression") return true;
-  if (node2.type === "ForOfStatement" && node2.await === true) return true;
-  for (const [key, value] of Object.entries(node2)) {
-    if (key === "type" || key === "start" || key === "end") continue;
-    if (hasTopLevelAwait(value)) return true;
+  sendStdin(data) {
+    try {
+      this.stdin.write(data);
+    } catch {
+    }
   }
-  return false;
-}
-function declaredNames(declaration) {
-  const names = /* @__PURE__ */ new Set();
-  if (declaration.type === "VariableDeclaration") {
-    for (const declarator of declaration.declarations) {
-      collectPattern2(declarator.id, names);
+  /** Signal EOF, so a child reading stdin to the end can finish. */
+  endStdin() {
+    try {
+      this.stdin.end();
+    } catch {
     }
-  } else if (isNode4(declaration.id)) {
-    names.add(declaration.id.name);
   }
-  return [...names];
-}
-function nameOf(node2) {
-  return node2.type === "Identifier" ? node2.name : node2.value;
-}
-function hoistedNames2(body) {
-  const names = blockNames2(body);
-  collectVars2(body, names);
-  return names;
-}
-function blockNames2(body) {
-  const names = /* @__PURE__ */ new Set();
-  for (const node2 of body ?? []) {
-    if (node2.type === "VariableDeclaration" && node2.kind !== "var") {
-      for (const declarator of node2.declarations) {
-        collectPattern2(declarator.id, names);
-      }
-    } else if ((node2.type === "ClassDeclaration" || node2.type === "FunctionDeclaration") && isNode4(node2.id)) {
-      names.add(node2.id.name);
+  kill(signal = "SIGTERM") {
+    if (this.process) {
+      this.process.deliver(signal);
+      return;
     }
+    this.cancelled = true;
   }
-  return names;
-}
-function collectVars2(nodes, names) {
-  if (Array.isArray(nodes)) {
-    for (const item of nodes) collectVars2(item, names);
-    return;
+  finish(code) {
+    if (this.state === "exited") return;
+    this.state = "exited";
+    this.exitCode = code;
+    this.emit("exit", code);
   }
-  if (!isNode4(nodes)) return;
-  const node2 = nodes;
-  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
-    if (isNode4(node2.id)) names.add(node2.id.name);
-    return;
+  append(stream, text2) {
+    this[stream] += text2;
+    this.emit(stream, text2);
   }
-  if (node2.type === "VariableDeclaration" && node2.kind === "var") {
-    for (const declarator of node2.declarations) {
-      collectPattern2(declarator.id, names);
-    }
+};
+var ChildOutput = class {
+  constructor(child, stream) {
+    this.child = child;
+    this.stream = stream;
   }
-  for (const [key, value] of Object.entries(node2)) {
-    if (key === "type" || key === "start" || key === "end") continue;
-    collectVars2(value, names);
+  child;
+  stream;
+  isTTY = false;
+  closedState = false;
+  decoder = new TextDecoder();
+  get closed() {
+    return this.closedState;
+  }
+  write(data) {
+    if (this.closedState) return;
+    const text2 = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
+    if (text2) this.child.append(this.stream, text2);
+  }
+  end() {
+    if (this.closedState) return;
+    this.closedState = true;
+    const tail2 = this.decoder.decode();
+    if (tail2) this.child.append(this.stream, tail2);
   }
+};
+var nextBridgePid = 1073741824;
+function installNodeChildProcessBridge(pod, kernel, cred) {
+  const manager = pod.processManager;
+  const originalSpawn = manager.spawn;
+  manager.spawn = (config2) => {
+    const resolved = kernel.resolveExecutable(config2.command, config2.cwd ?? "/", config2.env ?? {}, cred);
+    if (resolved?.kind === "builtin") {
+      return new KernelChildProcess(kernel, cred, config2, nextBridgePid++);
+    }
+    return originalSpawn.call(manager, config2);
+  };
+  return () => {
+    if (manager.spawn === originalSpawn) return;
+    manager.spawn = originalSpawn;
+  };
 }
-function collectPattern2(node2, names) {
-  if (!isNode4(node2)) return;
-  switch (node2.type) {
-    case "Identifier":
-      names.add(node2.name);
-      return;
-    case "ObjectPattern":
-      for (const property of node2.properties) {
-        collectPattern2(property.value ?? property.argument, names);
+
+// src/node/host-module-tracker.ts
+var HostModuleTracker = class {
+  active = 0;
+  disposed = false;
+  dispose() {
+    this.disposed = true;
+  }
+  wrapped = /* @__PURE__ */ new WeakMap();
+  originals = /* @__PURE__ */ new WeakMap();
+  pending = () => this.active;
+  unwrap = (value) => value && (typeof value === "object" || typeof value === "function") ? this.originals.get(value) ?? value : value;
+  wrap(value) {
+    if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+    const object = value;
+    if (Array.isArray(value) || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) return value;
+    if (this.wrapped.has(object)) return this.wrapped.get(object);
+    const tracker = this;
+    const proxy = new Proxy(object, {
+      // CommonJS native loaders re-export by assigning exports back onto the
+      // binding object. Never store a process-owned proxy in a shared module.
+      set(target, key, member) {
+        return Reflect.set(target, key, tracker.unwrap(member), target);
+      },
+      defineProperty(target, key, descriptor) {
+        return Reflect.defineProperty(target, key, "value" in descriptor ? { ...descriptor, value: tracker.unwrap(descriptor.value) } : descriptor);
+      },
+      get(target, key) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+        const member = Reflect.get(target, key, target);
+        if (descriptor && !descriptor.configurable && "value" in descriptor && !descriptor.writable) return member;
+        return typeof member === "function" ? tracker.wrap(member) : member;
+      },
+      apply(target, receiver, args) {
+        const result = Reflect.apply(target, tracker.unwrap(receiver), args.map(tracker.unwrap));
+        if (result && typeof result.then === "function") {
+          tracker.active++;
+          return Promise.resolve(result).then(
+            (value2) => {
+              tracker.active--;
+              return tracker.disposed ? new Promise(() => {
+              }) : tracker.wrap(value2);
+            },
+            (error) => {
+              tracker.active--;
+              if (tracker.disposed) return new Promise(() => {
+              });
+              throw error;
+            }
+          );
+        }
+        return tracker.wrap(result);
+      },
+      construct(target, args, newTarget) {
+        return tracker.wrap(Reflect.construct(target, args.map(tracker.unwrap), tracker.unwrap(newTarget)));
       }
-      return;
-    case "ArrayPattern":
-      for (const element of node2.elements) collectPattern2(element, names);
-      return;
-    case "AssignmentPattern":
-      collectPattern2(node2.left, names);
-      return;
-    case "RestElement":
-      collectPattern2(node2.argument, names);
-      return;
-    default:
-      return;
+    });
+    this.wrapped.set(object, proxy);
+    this.originals.set(proxy, object);
+    return proxy;
   }
-}
-function applyEdits(source, edits) {
-  const ordered = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
-  let out = source;
-  for (const edit of ordered) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
-  return out;
-}
-function isNode4(value) {
-  return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-var NOTHING2 = [];
-var PROPERTY2 = ["property", "key"];
-var LABEL2 = ["label"];
+};
+
+// src/node/commonjs-engine.ts
+init_path();
 var EXTENSIONS = [".js", ".mjs", ".cjs", ".json", ".node"];
+var PREFIX_ONLY_BUILTINS = /* @__PURE__ */ new Set(["test", "test/reporters", "sea", "sqlite"]);
 var CONDITION_SETS = {
   import: [["node", "import", "module", "default"], ["node", "require", "default"], ["default"]],
   require: [["node", "require", "default"], ["node", "import", "module", "default"], ["default"]]
@@ -26331,7 +26741,8 @@ ${code}
   }
   builtin(specifier, importer) {
     const name = specifier.replace(/^node:/, "");
-    if (!Object.prototype.hasOwnProperty.call(this.builtins, name)) {
+    const prefixOnly = PREFIX_ONLY_BUILTINS.has(name) && !specifier.startsWith("node:");
+    if (prefixOnly || !Object.prototype.hasOwnProperty.call(this.builtins, name)) {
       return Object.prototype.hasOwnProperty.call(this.overrides, specifier) ? { found: true, value: this.overrides[specifier] } : { found: false, value: void 0 };
     }
     if (name === "module" && importer) {
@@ -27601,21 +28012,23 @@ function resolveTarget(input, overrides, defaultProtocol) {
   };
 }
 function isLoopback(hostname) {
-  return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "::" || hostname.startsWith("127.") || hostname.endsWith(".localhost");
+  return isLoopbackHostname(hostname);
 }
 var VirtualClientRequest = class extends streamModule4__default.default.Writable {
-  constructor(target, router, fetchImpl, trackRequest) {
+  constructor(target, router, fetchImpl, trackRequest, loopback = void 0) {
     super();
     this.target = target;
     this.router = router;
     this.fetchImpl = fetchImpl;
     this.trackRequest = trackRequest;
+    this.loopback = loopback;
     for (const [name, value] of Object.entries(target.headers)) this.setHeader(name, value);
   }
   target;
   router;
   fetchImpl;
   trackRequest;
+  loopback;
   socket = socketStub();
   connection = this.socket;
   chunks = [];
@@ -27729,7 +28142,9 @@ var VirtualClientRequest = class extends streamModule4__default.default.Writable
     } catch (error) {
       clearTimeout(this.timer);
       if (this.destroyedByUser) return;
-      const failure2 = error instanceof Error ? error : new Error(String(error));
+      const thrown = error instanceof Error ? error : new Error(String(error));
+      const cause = thrown.cause;
+      const failure2 = cause instanceof Error && "code" in cause ? cause : thrown;
       if (!("code" in failure2)) Object.assign(failure2, { code: "ECONNREFUSED" });
       this.emit("error", failure2);
     } finally {
@@ -27737,18 +28152,21 @@ var VirtualClientRequest = class extends streamModule4__default.default.Writable
     }
   }
   async viaRouter(body) {
-    if (!this.router.activePortsIncludes(this.target.port)) {
+    const init = {
+      method: this.target.method,
+      path: this.target.path,
+      headers: this.getHeaders(),
+      body: body.length ? new Uint8Array(body) : null
+    };
+    const local = this.router.activePortsIncludes(this.target.port);
+    const remote = local || !this.loopback ? null : await this.loopback(this.target.port, init);
+    if (!local && !remote) {
       throw Object.assign(
         new Error(`connect ECONNREFUSED ${this.target.hostname}:${this.target.port}`),
         { code: "ECONNREFUSED", errno: -61, syscall: "connect", address: this.target.hostname, port: this.target.port }
       );
     }
-    const result = await this.router.request(this.target.port, {
-      method: this.target.method,
-      path: this.target.path,
-      headers: this.getHeaders(),
-      body: body.length ? new Uint8Array(body) : null
-    });
+    const result = remote ?? await this.router.request(this.target.port, init);
     const body_ = result.body;
     const bytes2 = typeof body_ === "string" ? new TextEncoder().encode(body_) : body_ instanceof ArrayBuffer ? new Uint8Array(body_) : body_ ?? new Uint8Array();
     const status = result.statusCode ?? 200;
@@ -27788,7 +28206,13 @@ function createHttpModule(router, owner, options = {}, defaultProtocol = "http:"
   const request = (input, second, third) => {
     const overrides = second && typeof second === "object" && !(second instanceof Function) ? second : void 0;
     const callback = [second, third].find((value) => typeof value === "function");
-    const req = new VirtualClientRequest(resolveTarget(input, overrides, defaultProtocol), router, options.fetch, options.trackRequest);
+    const req = new VirtualClientRequest(
+      resolveTarget(input, overrides, defaultProtocol),
+      router,
+      options.fetch,
+      options.trackRequest,
+      options.loopback
+    );
     if (callback) req.on("response", callback);
     return req;
   };
@@ -27815,6 +28239,62 @@ function createHttpModule(router, owner, options = {}, defaultProtocol = "http:"
     }
   };
 }
+function createVirtualFetch(router, options = {}) {
+  return (async (input, init) => {
+    const request = new Request(input, init);
+    const url = new URL(request.url);
+    const release = options.trackRequest?.();
+    try {
+      if (!isLoopback(url.hostname)) {
+        if (!options.fetch) {
+          throw Object.assign(new TypeError("fetch failed"), {
+            cause: Object.assign(new Error(`getaddrinfo ENOTFOUND ${url.hostname}`), { code: "ENOTFOUND" })
+          });
+        }
+        return await options.fetch(request);
+      }
+      const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
+      const headers = {};
+      request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      const bodyless = request.method === "GET" || request.method === "HEAD";
+      const loopbackRequest = {
+        method: request.method,
+        path: `${url.pathname}${url.search}`,
+        headers,
+        body: bodyless ? null : new Uint8Array(await request.arrayBuffer())
+      };
+      const result = router.activePortsIncludes(port) ? await router.request(port, loopbackRequest) : await options.loopback?.(port, loopbackRequest) ?? null;
+      if (!result) {
+        throw Object.assign(new TypeError("fetch failed"), {
+          cause: Object.assign(new Error(`connect ECONNREFUSED ${url.hostname}:${port}`), {
+            code: "ECONNREFUSED",
+            errno: -61,
+            syscall: "connect",
+            address: url.hostname,
+            port
+          })
+        });
+      }
+      const status = result.statusCode ?? 200;
+      const responseHeaders = new Headers();
+      for (const [name, value] of Object.entries(result.headers ?? {})) {
+        for (const part of Array.isArray(value) ? value : [value]) responseHeaders.append(name, String(part));
+      }
+      const raw = result.body;
+      const bytes2 = typeof raw === "string" ? new TextEncoder().encode(raw) : raw instanceof ArrayBuffer ? new Uint8Array(raw) : raw ?? new Uint8Array();
+      const nullBody = status === 204 || status === 205 || status === 304 || request.method === "HEAD";
+      return new Response(nullBody ? null : new Uint8Array(bytes2), {
+        status,
+        statusText: result.statusMessage ?? STATUS_CODES[status] ?? "",
+        headers: responseHeaders
+      });
+    } finally {
+      release?.();
+    }
+  });
+}
 function validateHeaderName(name) {
   if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)) throw Object.assign(new TypeError(`Header name must be a valid HTTP token [${name}]`), { code: "ERR_INVALID_HTTP_TOKEN" });
 }
@@ -27834,6 +28314,492 @@ function socketStub() {
 }
 var METHODS = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE", "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "REBIND", "REPORT", "SEARCH", "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE"];
 var STATUS_CODES = { 100: "Continue", 200: "OK", 201: "Created", 202: "Accepted", 204: "No Content", 206: "Partial Content", 301: "Moved Permanently", 302: "Found", 304: "Not Modified", 307: "Temporary Redirect", 308: "Permanent Redirect", 400: "Bad Request", 401: "Unauthorized", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed", 409: "Conflict", 413: "Payload Too Large", 415: "Unsupported Media Type", 422: "Unprocessable Entity", 429: "Too Many Requests", 500: "Internal Server Error", 501: "Not Implemented", 502: "Bad Gateway", 503: "Service Unavailable" };
+
+// src/node/test-module.ts
+function parseArguments(args) {
+  let name = "<anonymous>";
+  let options = {};
+  let fn;
+  for (const arg of args) {
+    if (typeof arg === "string") name = arg;
+    else if (typeof arg === "function") {
+      fn = arg;
+      if (name === "<anonymous>" && arg.name) name = arg.name;
+    } else if (arg && typeof arg === "object") options = arg;
+  }
+  return { name, options, fn };
+}
+function errorText(error) {
+  if (error instanceof Error) {
+    const stack = error.stack ?? `${error.name}: ${error.message}`;
+    return stack.includes(error.message) ? stack : `${error.name}: ${error.message}
+${stack}`;
+  }
+  return String(error);
+}
+function indent(text2, spaces) {
+  const pad2 = " ".repeat(spaces);
+  return text2.split("\n").map((line) => line ? pad2 + line : line).join("\n");
+}
+function duration(started) {
+  return (performance.now() - started).toFixed(6).replace(/\.?0+$/, "");
+}
+function invoke(host2, fn, context, timeout) {
+  const body = new Promise((resolve3, reject) => {
+    if (fn.length >= 2) {
+      let settled = false;
+      const done = (error) => {
+        if (settled) return;
+        settled = true;
+        if (error) reject(error);
+        else resolve3();
+      };
+      try {
+        const returned = fn(context, done);
+        if (returned && typeof returned.then === "function") {
+          reject(new Error("passed a callback but also returned a Promise"));
+        }
+      } catch (error) {
+        done(error);
+      }
+      return;
+    }
+    try {
+      Promise.resolve(fn(context)).then(() => resolve3(), reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
+  if (timeout === void 0 || !Number.isFinite(timeout)) return body;
+  return new Promise((resolve3, reject) => {
+    const timer = host2.setTimeout(() => reject(new Error(`test timed out after ${timeout}ms`)), timeout);
+    body.then(
+      () => {
+        host2.clearTimeout(timer);
+        resolve3();
+      },
+      (error) => {
+        host2.clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function createMockTracker() {
+  const restorers = [];
+  const fn = (original = () => void 0, implementation = original) => {
+    let current = implementation;
+    const once = /* @__PURE__ */ new Map();
+    const calls = [];
+    const mocked = function(...args) {
+      const index = calls.length;
+      const chosen = once.get(index) ?? current;
+      once.delete(index);
+      const call = { arguments: args, result: void 0, error: void 0, this: this };
+      calls.push(call);
+      try {
+        call.result = chosen.apply(this, args);
+        return call.result;
+      } catch (error) {
+        call.error = error;
+        throw error;
+      }
+    };
+    Object.defineProperty(mocked, "mock", {
+      value: {
+        calls,
+        callCount: () => calls.length,
+        resetCalls: () => {
+          calls.length = 0;
+        },
+        mockImplementation: (next) => {
+          current = next;
+        },
+        mockImplementationOnce: (next, onCall) => {
+          once.set(onCall ?? calls.length, next);
+        },
+        restore: () => {
+          current = original;
+        }
+      }
+    });
+    return mocked;
+  };
+  const method = (object, name, implementation) => {
+    const original = object[name];
+    if (typeof original !== "function") {
+      throw new TypeError(`The property '${name}' is not a function and cannot be mocked`);
+    }
+    const mocked = fn(original, implementation ?? original);
+    object[name] = mocked;
+    const restore = () => {
+      object[name] = original;
+    };
+    mocked.mock.restore = restore;
+    restorers.push(restore);
+    return mocked;
+  };
+  return {
+    fn,
+    method,
+    reset: () => {
+      for (const restore of restorers.splice(0)) restore();
+    },
+    restoreAll: () => {
+      for (const restore of restorers.splice(0)) restore();
+    }
+  };
+}
+function createTestModule(host2) {
+  const root = {
+    kind: "suite",
+    name: "",
+    options: {},
+    parent: null,
+    children: [],
+    hooks: { before: [], after: [], beforeEach: [], afterEach: [] }
+  };
+  let collecting = root;
+  let scheduled = false;
+  let running = null;
+  const mock = createMockTracker();
+  const counts = { tests: 0, suites: 0, pass: 0, fail: 0, cancelled: 0, skipped: 0, todo: 0 };
+  const failures = [];
+  let tapIndex = 0;
+  let onlyWarned = false;
+  const settings = () => host2.settings();
+  const tap = () => settings().reporter === "tap";
+  const schedule = () => {
+    if (scheduled) return;
+    scheduled = true;
+    host2.setTimeout(() => {
+      running = runAll();
+    }, 0);
+  };
+  const fullName = (node2) => {
+    const parts = [];
+    let cursor = node2;
+    while (cursor && cursor !== root) {
+      parts.unshift(cursor.name);
+      cursor = cursor.parent;
+    }
+    return parts.join(" ");
+  };
+  const matchesPattern2 = (name) => {
+    const patterns = settings().namePatterns ?? [];
+    if (patterns.length === 0) return true;
+    return patterns.some((pattern) => {
+      try {
+        return new RegExp(pattern).test(name);
+      } catch {
+        return name.includes(pattern);
+      }
+    });
+  };
+  const hasOnly = (node2) => Boolean(node2.options.only) || node2.kind === "suite" && node2.children.some(hasOnly);
+  const report = (depth, outcome, name, started, detail) => {
+    if (tap()) {
+      tapIndex += 1;
+      const ok2 = outcome === "fail" ? "not ok" : "ok";
+      const directive = outcome === "skip" ? " # SKIP" : outcome === "todo" ? " # TODO" : outcome === "cancelled" ? " # CANCELLED" : "";
+      host2.write(`${ok2} ${tapIndex} - ${name}${directive}
+`);
+      host2.write(`  ---
+  duration_ms: ${duration(started)}
+`);
+      if (detail) host2.write(`  error: |-
+${indent(detail, 4)}
+`);
+      host2.write("  ...\n");
+      return;
+    }
+    const pad2 = "  ".repeat(depth);
+    const mark = outcome === "pass" ? "\u2714" : outcome === "fail" ? "\u2716" : outcome === "cancelled" ? "\u2716" : "\uFE63";
+    const suffix = outcome === "skip" ? " # SKIP" : outcome === "todo" ? " # TODO" : "";
+    host2.write(`${pad2}${mark} ${name} (${duration(started)}ms)${suffix}
+`);
+    if (detail) host2.write(`${indent(detail, depth * 2 + 2)}
+`);
+  };
+  const record = (outcome, name, error) => {
+    counts.tests += 1;
+    if (outcome === "pass") counts.pass += 1;
+    else if (outcome === "fail") {
+      counts.fail += 1;
+      failures.push({ name, error });
+    } else if (outcome === "cancelled") {
+      counts.cancelled += 1;
+      failures.push({ name, error });
+    } else if (outcome === "skip") counts.skipped += 1;
+    else counts.todo += 1;
+  };
+  const ancestors = (suite) => {
+    const chain = [];
+    for (let cursor = suite; cursor; cursor = cursor.parent) chain.unshift(cursor);
+    return chain;
+  };
+  const runTest = async (name, display, options, fn, depth, suite, extraHooks, runOnly) => {
+    const started = performance.now();
+    if (!matchesPattern2(display)) return true;
+    if (runOnly && !options.only) return true;
+    if (options.skip) {
+      record("skip", display);
+      report(depth, "skip", name, started);
+      return true;
+    }
+    if (!fn) {
+      const outcome = options.todo ? "todo" : "skip";
+      record(outcome, display);
+      report(depth, outcome, name, started);
+      return true;
+    }
+    const controller = new AbortController();
+    const subtests = [];
+    const ownHooks = { before: [], after: [], beforeEach: [], afterEach: [] };
+    let skipped = false;
+    let todo = options.todo ?? false;
+    const context = {
+      name,
+      fullName: display,
+      signal: controller.signal,
+      mock,
+      test: (...args) => {
+        const sub = parseArguments(args);
+        const promise = runTest(
+          sub.name,
+          `${display} ${sub.name}`,
+          sub.options,
+          sub.fn,
+          depth + 1,
+          suite,
+          ownHooks,
+          false
+        );
+        subtests.push(promise);
+        return promise.then(() => void 0);
+      },
+      skip: (message) => {
+        skipped = message ?? true;
+      },
+      todo: (message) => {
+        todo = message ?? true;
+      },
+      diagnostic: (message) => {
+        host2.write(tap() ? `# ${message}
+` : `${"  ".repeat(depth + 1)}\u2139 ${message}
+`);
+      },
+      plan: () => {
+      },
+      before: (hook2) => ownHooks.before.push(hook2),
+      after: (hook2) => ownHooks.after.push(hook2),
+      beforeEach: (hook2) => ownHooks.beforeEach.push(hook2),
+      afterEach: (hook2) => ownHooks.afterEach.push(hook2)
+    };
+    let error;
+    try {
+      const chain = ancestors(suite);
+      for (const level of chain) for (const hook2 of level.hooks.beforeEach) await invoke(host2, hook2, context, void 0);
+      for (const hook2 of extraHooks.beforeEach) await invoke(host2, hook2, context, void 0);
+      await invoke(host2, fn, context, options.timeout);
+      const results = await Promise.all(subtests);
+      for (const hook2 of ownHooks.after) await invoke(host2, hook2, context, void 0);
+      if (results.includes(false)) error = new Error(`${results.filter((ok2) => !ok2).length} subtest(s) failed`);
+      for (const hook2 of extraHooks.afterEach) await invoke(host2, hook2, context, void 0);
+      for (const level of [...chain].reverse()) for (const hook2 of level.hooks.afterEach) await invoke(host2, hook2, context, void 0);
+    } catch (caught) {
+      error = caught;
+    } finally {
+      controller.abort();
+    }
+    if (skipped) {
+      record("skip", display);
+      report(depth, "skip", name, started);
+      return true;
+    }
+    if (error !== void 0) {
+      if (todo) {
+        record("todo", display);
+        report(depth, "todo", name, started);
+        return true;
+      }
+      record("fail", display, error);
+      report(depth, "fail", name, started, errorText(error));
+      return false;
+    }
+    record(todo ? "todo" : "pass", display);
+    report(depth, todo ? "todo" : "pass", name, started);
+    return true;
+  };
+  const runSuite = async (suite, depth, runOnly) => {
+    const started = performance.now();
+    const display = fullName(suite);
+    const isRoot = suite === root;
+    if (!isRoot) {
+      counts.suites += 1;
+      if (tap()) host2.write(`# Subtest: ${suite.name}
+`);
+      else host2.write(`${"  ".repeat(depth)}\u25B6 ${suite.name}
+`);
+      if (suite.options.skip) {
+        for (const child of suite.children) if (child.kind === "test") record("skip", fullName(child));
+        report(depth, "skip", suite.name, started);
+        return true;
+      }
+    }
+    const context = { name: suite.name, signal: new AbortController().signal };
+    let ok2 = true;
+    try {
+      for (const hook2 of suite.hooks.before) await invoke(host2, hook2, context, void 0);
+    } catch (error) {
+      for (const child of suite.children) {
+        if (child.kind === "test") {
+          record("cancelled", fullName(child), error);
+          report(depth + (isRoot ? 0 : 1), "cancelled", child.name, started, errorText(error));
+        }
+      }
+      if (!isRoot) report(depth, "fail", suite.name, started);
+      return false;
+    }
+    const only = runOnly || settings().only === true && suite.children.some(hasOnly);
+    for (const child of suite.children) {
+      const childDepth = depth + (isRoot ? 0 : 1);
+      if (child.kind === "suite") {
+        if (only && !hasOnly(child) && !child.options.only) continue;
+        ok2 = await runSuite(child, childDepth, only && !child.options.only) && ok2;
+      } else {
+        ok2 = await runTest(
+          child.name,
+          fullName(child),
+          child.options,
+          child.fn,
+          childDepth,
+          suite,
+          { before: [], after: [], beforeEach: [], afterEach: [] },
+          only
+        ) && ok2;
+      }
+    }
+    try {
+      for (const hook2 of suite.hooks.after) await invoke(host2, hook2, context, void 0);
+    } catch (error) {
+      ok2 = false;
+      failures.push({ name: `${display || "<root>"} (after hook)`, error });
+      host2.write(`${indent(`\u2716 after hook failed
+${errorText(error)}`, depth * 2)}
+`);
+    }
+    if (!isRoot) {
+      if (tap()) host2.write(`${ok2 ? "ok" : "not ok"} ${++tapIndex} - ${suite.name}
+`);
+      else host2.write(`${"  ".repeat(depth)}${ok2 ? "\u25B6" : "\u2716"} ${suite.name} (${duration(started)}ms)
+`);
+    }
+    return ok2;
+  };
+  const runAll = async () => {
+    const release = host2.keepAlive();
+    const started = performance.now();
+    if (tap()) host2.write("TAP version 13\n");
+    if (!settings().only && !onlyWarned && root.children.some(hasOnly)) {
+      onlyWarned = true;
+      host2.write("\u2139 'only' and 'runOnly' require the --test-only command-line option.\n");
+    }
+    let ok2 = true;
+    try {
+      ok2 = await runSuite(root, 0, false);
+    } catch (error) {
+      ok2 = false;
+      failures.push({ name: "<test runner>", error });
+    }
+    mock.restoreAll();
+    if (tap()) {
+      host2.write(`1..${tapIndex}
+`);
+      for (const [key, value] of Object.entries(counts)) host2.write(`# ${key} ${value}
+`);
+      host2.write(`# duration_ms ${duration(started)}
+`);
+    } else {
+      for (const [key, value] of Object.entries(counts)) host2.write(`\u2139 ${key} ${value}
+`);
+      host2.write(`\u2139 duration_ms ${duration(started)}
+`);
+      if (failures.length > 0) {
+        host2.write("\n\u2716 failing tests:\n\n");
+        for (const failure2 of failures) host2.write(`test at ${failure2.name}
+${indent(errorText(failure2.error), 2)}
+
+`);
+      }
+    }
+    release();
+    host2.exit(ok2 && counts.fail === 0 && counts.cancelled === 0 ? 0 : 1);
+  };
+  const declareTest = (extra) => (...args) => {
+    const { name, options, fn } = parseArguments(args);
+    if (running && collecting === root && scheduled) {
+      host2.write(`\u2716 test "${name}" was declared after the run started and did not run
+`);
+      return Promise.resolve();
+    }
+    collecting.children.push({ kind: "test", name, options: { ...options, ...extra }, parent: collecting, fn });
+    schedule();
+    return Promise.resolve();
+  };
+  const declareSuite = (extra) => (...args) => {
+    const { name, options, fn } = parseArguments(args);
+    const suite = {
+      kind: "suite",
+      name,
+      options: { ...options, ...extra },
+      parent: collecting,
+      children: [],
+      hooks: { before: [], after: [], beforeEach: [], afterEach: [] }
+    };
+    collecting.children.push(suite);
+    schedule();
+    const previous = collecting;
+    collecting = suite;
+    try {
+      fn?.({ name, signal: new AbortController().signal });
+    } finally {
+      collecting = previous;
+    }
+    return Promise.resolve();
+  };
+  const withModifiers = (make) => {
+    const base2 = make({});
+    base2.skip = make({ skip: true });
+    base2.todo = make({ todo: true });
+    base2.only = make({ only: true });
+    return base2;
+  };
+  const test = withModifiers(declareTest);
+  const describe2 = withModifiers(declareSuite);
+  const hook = (kind) => (fn) => {
+    collecting.hooks[kind].push(fn);
+    schedule();
+  };
+  Object.assign(test, {
+    test,
+    it: test,
+    describe: describe2,
+    suite: describe2,
+    before: hook("before"),
+    after: hook("after"),
+    beforeEach: hook("beforeEach"),
+    afterEach: hook("afterEach"),
+    mock,
+    run: () => {
+      throw Object.assign(new Error("node:test run() is not available in this container; use `node --test`"), {
+        code: "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM"
+      });
+    }
+  });
+  Object.defineProperty(test, "default", { value: test, enumerable: false });
+  return test;
+}
 var hashes = { md5: legacy$1.md5, sha1: legacy$1.sha1, "sha-1": legacy$1.sha1, sha224: sha256.sha224, "sha-224": sha256.sha224, sha256: sha256.sha256, "sha-256": sha256.sha256, sha384: sha512.sha384, "sha-384": sha512.sha384, sha512: sha512.sha512, "sha-512": sha512.sha512 };
 function createCryptoModule() {
   const cryptoObject = globalThis.crypto;
@@ -28790,7 +29756,7 @@ function createCoreModules(options) {
   });
   const stderrWrite = options.stderr ?? (() => {
   });
-  const timers = createTrackedTimers();
+  const timers = createTrackedTimers((error) => reportUncaught(error));
   const processObject = Object.assign(new EventEmitter4__default.default(), processShim__default.default, {
     argv: options.argv?.slice() ?? ["/usr/bin/node"],
     argv0: "node",
@@ -28820,16 +29786,65 @@ function createCoreModules(options) {
     uptime: () => performance.now() / 1e3,
     memoryUsage: () => ({ rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 }),
     cpuUsage: () => ({ user: 0, system: 0 }),
-    exit: (code = 0) => {
-      exitCode = code;
-      processObject.exitCode = code;
-      options.onExit?.(code);
+    /* A bare `process.exit()` ends with `process.exitCode`, as in Node. */
+    exit: (code) => {
+      const status = normalizeExitCode(code ?? processObject.exitCode);
+      exitCode = status;
+      processObject.exitCode = status;
+      emitExit(status);
+      options.onExit?.(status);
+    },
+    nextTick: (fn, ...args) => {
+      queueMicrotask(() => {
+        try {
+          fn(...args);
+        } catch (error) {
+          reportUncaught(error);
+        }
+      });
     },
     kill: () => true
   });
+  for (const method of EVENT_EMITTER_METHODS) {
+    const implementation = EventEmitter4__default.default.prototype[method];
+    if (typeof implementation === "function") processObject[method] = implementation;
+  }
   const tty = options.tty === true;
   processObject.stdout = makeOutputStream(stdoutWrite, 1, tty);
   processObject.stderr = makeOutputStream(stderrWrite, 2, tty);
+  let exiting = false;
+  const emitExit = (status) => {
+    if (exiting) return;
+    exiting = true;
+    try {
+      processObject.emit("exit", status);
+    } catch {
+    }
+  };
+  const reportUncaught = (error, origin = "uncaughtException") => {
+    if (!exiting && processObject.listenerCount(origin) > 0) {
+      try {
+        processObject.emit(origin, error, origin === "uncaughtException" ? origin : void 0);
+        return;
+      } catch (handlerError) {
+        error = handlerError;
+      }
+    }
+    stderrWrite(formatUncaught(error));
+    try {
+      processObject.exit(1);
+    } catch {
+    }
+  };
+  const defer = (fn) => {
+    queueMicrotask(() => {
+      try {
+        fn();
+      } catch (error) {
+        reportUncaught(error);
+      }
+    });
+  };
   const stdin = options.interactiveStdin ? new streamModule4__default.default.PassThrough() : new streamModule4__default.default.Readable({ read() {
     this.push(null);
   } });
@@ -28849,7 +29864,7 @@ function createCoreModules(options) {
   });
   processObject.stdin = stdin;
   Reflect.deleteProperty(processObject, "browser");
-  const fs = createFsModule(volume, () => cwd, options.stdinPath);
+  const fs = createFsModule(volume, () => cwd, options.stdinPath, defer);
   const path = createPathModule(() => cwd);
   const consoleObject = new Console(stdoutWrite, stderrWrite);
   const os = createOsModule();
@@ -28862,20 +29877,24 @@ function createCoreModules(options) {
     }
   };
   let inFlightRequests = 0;
+  const trackRequest = () => {
+    inFlightRequests++;
+    return () => {
+      inFlightRequests--;
+    };
+  };
+  const ambientFetch = options.http?.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+  const outboundFetch = options.http?.policy && ambientFetch ? policedFetch(options.http.policy, ambientFetch) : ambientFetch;
   const httpOptions = {
-    ...options.http?.fetch ? { fetch: options.http.fetch } : {},
-    trackRequest: () => {
-      inFlightRequests++;
-      return () => {
-        inFlightRequests--;
-      };
-    }
+    ...outboundFetch ? { fetch: outboundFetch } : {},
+    ...options.http?.loopback ? { loopback: options.http.loopback } : {},
+    trackRequest
   };
   const http = options.http ? createHttpModule(options.http.router, options.http.owner, httpOptions, "http:") : createUnsupportedModule("http");
   const https = options.http ? createHttpModule(options.http.router, options.http.owner, httpOptions, "https:") : createUnsupportedModule("https");
   const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env })) : createUnsupportedModule("child_process");
   const readline = createReadlineModule(() => processObject.stdin, () => processObject.stdout);
-  const dns = createDnsModule();
+  const dns = createDnsModule(defer);
   const builtins = {
     assert: assert_module_default,
     "assert/strict": assert_module_default.strict ?? assert_module_default,
@@ -28911,7 +29930,27 @@ function createCoreModules(options) {
     url: url_module_default,
     util: util_module_default,
     "util/types": util_module_default.types ?? {},
-    zlib: zlib_module_default
+    zlib: zlib_module_default,
+    test: createTestModule({
+      write: stdoutWrite,
+      setTimeout: (fn, ms) => timers.api.setTimeout(fn, ms),
+      clearTimeout: (handle) => timers.api.clearTimeout(handle),
+      /* A pending interval is what keeps a process alive in this runtime; a test
+       * awaiting nothing but promises would otherwise be judged finished. */
+      keepAlive: () => {
+        const handle = timers.api.setInterval(() => {
+        }, 1 << 30);
+        return () => timers.api.clearInterval(handle);
+      },
+      exit: (code) => {
+        processObject.exitCode = code;
+        try {
+          processObject.exit(code);
+        } catch {
+        }
+      },
+      settings: () => parseTestSettings(env2.SANDBOXEDJS_NODE_TEST)
+    })
   };
   for (const name of stubNames) builtins[name] = createUnsupportedModule(name);
   builtins.net = createNetModule();
@@ -28919,8 +29958,26 @@ function createCoreModules(options) {
     Buffer: Buffer2,
     console: consoleObject,
     process: processObject,
-    ...timers.api
+    ...timers.api,
+    queueMicrotask: (fn) => queueMicrotask(() => {
+      try {
+        fn();
+      } catch (error) {
+        reportUncaught(error);
+      }
+    })
   };
+  if (options.http) {
+    globals.fetch = createVirtualFetch(options.http.router, {
+      ...outboundFetch ? { fetch: outboundFetch } : {},
+      ...options.http.loopback ? { loopback: options.http.loopback } : {},
+      trackRequest
+    });
+    const NativeWebSocket = globalThis.WebSocket;
+    if (options.http.policy && NativeWebSocket) {
+      globals.WebSocket = policedWebSocket(NativeWebSocket, options.http.policy);
+    }
+  }
   const globalOverlay = new Proxy(globalThis, {
     get: (target, key) => typeof key === "string" && key in globals ? globals[key] : key === "global" || key === "globalThis" ? globalOverlay : Reflect.get(target, key),
     has: (target, key) => typeof key === "string" && key in globals || Reflect.has(target, key)
@@ -28936,6 +29993,10 @@ function createCoreModules(options) {
     /** Client requests sent but not yet read to completion. */
     pendingRequests: () => inFlightRequests,
     cancelTimers: timers.cancelAll,
+    reportUncaught: (error) => reportUncaught(error),
+    reportUnhandledRejection: (reason) => reportUncaught(reason, "unhandledRejection"),
+    exitStatus: () => normalizeExitCode(processObject.exitCode),
+    emitExit,
     writeStdin: (data) => {
       if (options.interactiveStdin) stdin.write(data);
     },
@@ -28997,7 +30058,7 @@ function createPathModule(cwd) {
   path.default = path;
   return path;
 }
-function createFsModule(volume, cwd, stdinPath) {
+function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
   const fds = /* @__PURE__ */ new Map();
   let nextFd = 3;
   if (stdinPath) fds.set(0, { path: stdinPath, position: 0, flags: "r" });
@@ -29037,12 +30098,15 @@ function createFsModule(volume, cwd, stdinPath) {
     volume.rmdirSync(path);
   };
   const callback = (operation, cb) => {
-    queueMicrotask(() => {
+    defer(() => {
+      let value;
       try {
-        cb(null, operation());
+        value = operation();
       } catch (error) {
         cb(error);
+        return;
       }
+      cb(null, value);
     });
   };
   const fs = {
@@ -29172,7 +30236,7 @@ function createFsModule(volume, cwd, stdinPath) {
       const slice = whole.subarray(start2, Math.max(start2, end));
       const stream = streamModule4__default.default.Readable.from([settings.encoding ? slice.toString(settings.encoding) : slice]);
       Object.assign(stream, { path: target, bytesRead: slice.length, close: () => stream.destroy() });
-      queueMicrotask(() => {
+      defer(() => {
         stream.emit("open", 0);
         stream.emit("ready");
       });
@@ -29240,7 +30304,7 @@ function createFsModule(volume, cwd, stdinPath) {
   }
   fs.realpath.native = fs.realpath;
   fs.exists = (path, cb) => {
-    queueMicrotask(() => cb(fs.existsSync(path)));
+    defer(() => cb(fs.existsSync(path)));
   };
   fs.promises = {
     ...Object.fromEntries(
@@ -29362,7 +30426,7 @@ var Console = class {
   timeLog = (_label = "default") => {
   };
 };
-function createDnsModule() {
+function createDnsModule(defer = queueMicrotask) {
   const LOOPBACK = {
     localhost: { address: "127.0.0.1", family: 4 },
     "127.0.0.1": { address: "127.0.0.1", family: 4 },
@@ -29382,7 +30446,7 @@ function createDnsModule() {
   const lookup = (hostname, options, callback) => {
     const done = typeof options === "function" ? options : callback;
     const all = typeof options === "object" && options !== null && options.all;
-    queueMicrotask(() => {
+    defer(() => {
       try {
         const entry = lookupSync(hostname);
         done?.(null, all ? [entry] : entry.address, entry.family);
@@ -29540,7 +30604,16 @@ var ERRNO_CONSTANTS = {
   EWOULDBLOCK: 11,
   EXDEV: 18
 };
-function createTrackedTimers() {
+function createTrackedTimers(onError = (error) => {
+  throw error;
+}) {
+  const run2 = (fn, args) => {
+    try {
+      fn(...args);
+    } catch (error) {
+      onError(error);
+    }
+  };
   const live = /* @__PURE__ */ new Set();
   const unrefed = /* @__PURE__ */ new Set();
   const states = /* @__PURE__ */ new WeakMap();
@@ -29583,7 +30656,7 @@ function createTrackedTimers() {
     const native = setTimeout(
       (...inner) => {
         complete(handle);
-        fn(...inner);
+        run2(fn, inner);
       },
       delay,
       ...args
@@ -29591,14 +30664,14 @@ function createTrackedTimers() {
     handle = track(native);
     return handle;
   };
-  const setIntervalTracked = (fn, delay, ...args) => track(setInterval(fn, delay, ...args));
+  const setIntervalTracked = (fn, delay, ...args) => track(setInterval((...inner) => run2(fn, inner), delay, ...args));
   const hostSetImmediate = globalThis.setImmediate;
   const setImmediateTracked = (fn, ...args) => {
     if (!hostSetImmediate) return setTimeoutTracked(fn, 0, ...args);
     let handle;
     const native = hostSetImmediate((...inner) => {
       complete(handle);
-      fn(...inner);
+      run2(fn, inner);
     }, ...args);
     handle = track(native);
     return handle;
@@ -29781,6 +30854,43 @@ function createNetModule() {
     isIP: (value) => isIPv4(value) ? 4 : isIPv6(value) ? 6 : 0
   });
 }
+function parseTestSettings(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+var EVENT_EMITTER_METHODS = [
+  "on",
+  "addListener",
+  "once",
+  "off",
+  "removeListener",
+  "removeAllListeners",
+  "emit",
+  "prependListener",
+  "prependOnceListener",
+  "listeners",
+  "rawListeners",
+  "listenerCount",
+  "eventNames",
+  "setMaxListeners",
+  "getMaxListeners"
+];
+function normalizeExitCode(value) {
+  const code = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+  return typeof code === "number" && Number.isInteger(code) ? code & 255 : 0;
+}
+function formatUncaught(error) {
+  const text2 = error instanceof Error ? error.stack ?? `${error.name}: ${error.message}` : `Uncaught ${typeof error === "string" ? JSON.stringify(error) : String(error)}`;
+  return `${text2}
+
+Node.js v22.12.0
+`;
+}
 var stubNames = ["cluster", "dgram", "diagnostics_channel", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
 var builtinNames2 = [
   "assert",
@@ -29818,6 +30928,7 @@ var builtinNames2 = [
   "util",
   "util/types",
   "zlib",
+  "test",
   ...stubNames
 ];
 
@@ -30639,16 +31750,20 @@ async function loadNodeRolldownMemfsBinding() {
     return null;
   }
   const fromBinding = createRequire(join3(packageDir, "package.json"));
-  let runtime;
+  let runtimeModuleUrl2;
   let fsModuleUrl;
-  let createContext2;
   try {
-    runtime = fromBinding("@napi-rs/wasm-runtime");
+    runtimeModuleUrl2 = resolveSubpath(node2, fromBinding, "@napi-rs/wasm-runtime", ".");
     fsModuleUrl = resolveSubpath(node2, fromBinding, "@napi-rs/wasm-runtime", "./fs");
-    ({ createContext: createContext2 } = fromBinding("@emnapi/runtime"));
   } catch {
     return null;
   }
+  const runtime = await import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    runtimeModuleUrl2
+  );
+  const createContext2 = runtime.createContext;
   const { memfs } = await import(
     /* @vite-ignore */
     /* webpackIgnore: true */
@@ -30680,7 +31795,7 @@ async function loadNodeRolldownMemfsBinding() {
     onCreateWorker() {
       const worker = new Worker2(workerPath, {
         env: process.env,
-        workerData: { runtimeAnchor, fsModuleUrl },
+        workerData: { runtimeAnchor, runtimeModuleUrl: runtimeModuleUrl2, fsModuleUrl },
         /*
          * Deliberately no `execArgv`.
          *
@@ -31123,6 +32238,8 @@ var LocalRuntimePod = class _LocalRuntimePod {
   rolldownBinding;
   /** Backs outbound `http`/`https` client requests from inside the sandbox. */
   fetch;
+  /** What guest programs may reach outside the container. */
+  networkPolicy;
   constructor(options) {
     ensureProcessGlobal();
     this.sockets = new VirtualTcpNetwork((port) => this.router.activePortsIncludes(port));
@@ -31140,6 +32257,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
       this.router.onListen = (port) => notify(port, `http://localhost:${port}`);
     }
     if (options.fetch) this.fetch = options.fetch;
+    if (options.network) this.networkPolicy = { ...options.network };
     this.packages = new CleanPackageInstaller(this.volume, {
       cwd: this.workdir,
       ...options.registry ? { registry: options.registry } : {},
@@ -31150,6 +32268,10 @@ var LocalRuntimePod = class _LocalRuntimePod {
   static async boot(options = {}) {
     return new _LocalRuntimePod(options);
   }
+  /** Apply a container's outbound policy to programs started from now on. */
+  setNetworkPolicy(policy) {
+    this.networkPolicy = { ...policy };
+  }
   async spawn(command, args = [], options = {}) {
     this.assertActive();
     if (command !== "node" && command !== "nodejs") throw commandError(command);
@@ -31162,7 +32284,6 @@ var LocalRuntimePod = class _LocalRuntimePod {
       await this.prepareRolldown(cwd, env2);
       if (proc.isKilled()) return 137;
       const untrack = trackProcess(proc);
-      let requestedExit = 0;
       let engine;
       const core = createCoreModules({
         volume: this.volume,
@@ -31176,11 +32297,15 @@ var LocalRuntimePod = class _LocalRuntimePod {
          * thrown from a later callback it would escape into whichever library
          * scheduled that callback and look like an unrelated crash. */
         onExit: (code) => {
-          requestedExit = code;
           proc.exitNow(code);
           if (engine?.isEvaluating) throw new ProcessExit(code);
         },
-        http: { router: this.router, owner, ...this.fetch ? { fetch: this.fetch } : {} },
+        http: {
+          router: this.router,
+          owner,
+          ...this.fetch ? { fetch: this.fetch } : {},
+          ...this.networkPolicy ? { policy: this.networkPolicy } : {}
+        },
         spawnChild: (config2) => this.processManager.spawn(config2),
         ...typeof options.stdinPath === "string" ? { stdinPath: options.stdinPath } : {},
         ...options.interactiveStdin ? { interactiveStdin: true } : {},
@@ -31204,7 +32329,9 @@ var LocalRuntimePod = class _LocalRuntimePod {
       try {
         await Promise.race([engine.run(script), proc.waitForKill()]);
         await this.settle(owner, core.pendingHandles, core.readingStdin, () => core.pendingRequests() + hostWork.pending(), () => proc.isKilled());
-        return requestedExit;
+        const status = core.exitStatus();
+        core.emitExit(status);
+        return status;
       } finally {
         hostWork.dispose();
         core.cancelTimers();
@@ -31707,6 +32834,9 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
         case "http-response":
           this.settleProxied(Number(message.id), message.response);
           return;
+        case "loopback-request":
+          void this.answerLoopback(worker, message);
+          return;
         case "ws-data":
           this.upgraded.get(Number(message.id))?.write(new Uint8Array(message.data));
           return;
@@ -31742,7 +32872,8 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
       aliases: this.aliases,
       ...typeof options.stdinPath === "string" ? { stdinPath: options.stdinPath } : {},
       ...options.interactiveStdin ? { interactiveStdin: true } : {},
-      ...options.tty ? { tty: true } : {}
+      ...options.tty ? { tty: true } : {},
+      ...this.networkPolicy ? { network: this.networkPolicy } : {}
     });
     process2.begin();
     return process2;
@@ -31878,6 +33009,38 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
       init: { method: request.method, path: request.url, headers: request.headers }
     });
   }
+  /**
+   * Answer a program that is calling a server in this container.
+   *
+   * A guest's router holds only the servers on its own thread, so a request to
+   * a port some other process opened comes here, where every server in the
+   * container is registered. `null` means nothing listens, which the guest
+   * reports as a refused connection.
+   */
+  async answerLoopback(worker, message) {
+    const port = Number(message.port);
+    let response = null;
+    if (this.router.activePortsIncludes(port)) {
+      try {
+        const result = await this.router.request(port, message.request);
+        const body = result.body;
+        response = {
+          statusCode: result.statusCode,
+          statusMessage: result.statusMessage,
+          headers: result.headers,
+          body: typeof body === "string" ? new TextEncoder().encode(body) : body instanceof ArrayBuffer ? new Uint8Array(body) : body ?? new Uint8Array()
+        };
+      } catch (error) {
+        response = {
+          statusCode: 502,
+          statusMessage: "Bad Gateway",
+          headers: {},
+          body: new TextEncoder().encode(error instanceof Error ? error.message : String(error))
+        };
+      }
+    }
+    worker.postMessage({ type: "loopback-response", id: message.id, response });
+  }
   settleProxied(id, response) {
     const resolve3 = this.waiting.get(id);
     if (!resolve3) return;
@@ -31968,13 +33131,19 @@ var Container = class _Container {
   // ── boot ──────────────────────────────────────────────────────────────────
   static async create(opts = {}) {
     if (opts.python) configurePython(opts.python);
+    const network = {
+      allowOutbound: opts.network?.allowOutbound ?? false,
+      allowedHosts: opts.network?.allowedHosts ?? null
+    };
     const podOptions = {
       workdir: opts.cwd ?? "/",
       env: opts.env ?? {},
+      network,
       ...opts.onServerReady ? { onServerReady: opts.onServerReady } : {}
     };
     const workerOptions = { ...podOptions, ...opts.workerUrl ? { workerUrl: opts.workerUrl } : {} };
     const pod = opts.pod ?? (opts.isolation === "realm" ? null : opts.isolation === "worker" ? await WorkerRuntimePod.boot(workerOptions) : await WorkerRuntimePod.tryBoot(workerOptions, opts.onRuntimeFallback)) ?? await LocalRuntimePod.boot(podOptions);
+    if (opts.pod) opts.pod.setNetworkPolicy?.(network);
     const kernel = new Kernel({
       pod,
       hostname: opts.hostname ?? "sandbox",
@@ -32069,7 +33238,7 @@ var Container = class _Container {
   async exec(command, opts = {}) {
     this.assertActive();
     const started = Date.now();
-    const { io, stdout, stderr, combined } = this.makeStdio(opts);
+    const { io, stdout, stderr, combined, detach } = this.makeStdio(opts);
     const cred = opts.user ? this.kernel.users.credFor(opts.user) : this.defaults.cred;
     const env2 = { ...this.defaults.env, ...opts.env };
     const cwd = opts.cwd ? resolve(this.defaults.cwd, opts.cwd) : this.defaults.cwd;
@@ -32098,6 +33267,7 @@ var Container = class _Container {
       ]);
     } finally {
       if (timer) clearTimeout(timer);
+      detach();
       proc.exit(0);
       this.kernel.procs.remove(proc.pid);
     }
@@ -32114,7 +33284,7 @@ var Container = class _Container {
   async run(argv, opts = {}) {
     this.assertActive();
     const started = Date.now();
-    const { io, stdout, stderr, combined } = this.makeStdio(opts);
+    const { io, stdout, stderr, combined, detach } = this.makeStdio(opts);
     const cred = opts.user ? this.kernel.users.credFor(opts.user) : this.defaults.cred;
     const cwd = opts.cwd ? resolve(this.defaults.cwd, opts.cwd) : this.defaults.cwd;
     const result = await this.kernel.run(argv, {
@@ -32126,6 +33296,7 @@ var Container = class _Container {
       stderr: io.stderr,
       ...opts.timeoutMs ?? this.defaults.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs ?? this.defaults.timeoutMs } : {}
     });
+    detach();
     return {
       exitCode: result.exitCode,
       stdout: stdout.text(),
@@ -32216,6 +33387,14 @@ var Container = class _Container {
     if (!this.defaultSession) this.defaultSession = this.session();
     return this.defaultSession;
   }
+  /**
+   * The streams one call collects into.
+   *
+   * They are detachable because a background job started by the command keeps
+   * writing after the call has returned. Nothing reads the result any more by
+   * then, so without `detach` a chatty server would grow the buffer for as long
+   * as it ran; afterwards its output still reaches the container-wide taps.
+   */
   makeStdio(opts) {
     const combined = [];
     const decoder9 = new TextDecoder();
@@ -32231,14 +33410,25 @@ var Container = class _Container {
       opts.onStderr?.(text2);
       this.hooks.onStderr?.(text2);
     });
+    const outGate = new DetachableOutput(stdout, (text2) => this.hooks.onStdout?.(text2));
+    const errGate = new DetachableOutput(stderr, (text2) => this.hooks.onStderr?.(text2));
     if (opts.tty) {
-      stdout.isTTY = true;
-      stderr.isTTY = true;
-      stdout.columns = opts.columns ?? 80;
-      stdout.rows = opts.rows ?? 24;
+      outGate.isTTY = true;
+      errGate.isTTY = true;
+      outGate.columns = opts.columns ?? 80;
+      outGate.rows = opts.rows ?? 24;
     }
     const stdin = opts.stdin === void 0 ? new NullInput() : Pipe.from(opts.stdin);
-    return { io: { stdin, stdout, stderr }, stdout, stderr, combined };
+    return {
+      io: { stdin, stdout: outGate, stderr: errGate },
+      stdout,
+      stderr,
+      combined,
+      detach: () => {
+        outGate.detach();
+        errGate.detach();
+      }
+    };
   }
   // ── networking ────────────────────────────────────────────────────────────
   /** Send an HTTP request to a server running inside the container. */