sandboxedjs 0.1.81 → 0.1.85

package/dist/index.js

@@ -1,4 +1,4 @@
-import { inflateRaw, ungzip, gzip as gzip$1, deflate as deflate$1, inflate as inflate$1, deflateRaw } from 'pako';
+import { Inflate as Inflate$1, Deflate as Deflate$1, inflateRaw, ungzip, gzip as gzip$1, deflate as deflate$1, inflate as inflate$1, deflateRaw } from 'pako';
 import { sha256, sha224 } from '@noble/hashes/sha256';
 import { Parser as Parser$1, parse as parse$1 } from 'acorn';
 import jsx from 'acorn-jsx';
@@ -9,7 +9,7 @@ import { valid, maxSatisfying } from 'semver';
 import EventEmitter4 from 'events/events.js';
 import { exports as exports$1, imports } from 'resolve.exports';
 import pathModule from 'path-browserify';
-import streamModule4 from 'stream-browserify';
+import streamModule5 from 'stream-browserify';
 import processShim from 'process/browser.js';
 import querystringModule from 'querystring-es3';
 import stringDecoderModule from 'string_decoder/lib/string_decoder.js';
@@ -364,11 +364,11 @@ function formatMode(mode) {
 function octalMode(mode, width = 4) {
   return (mode & PERM_MASK).toString(8).padStart(width, "0");
 }
-function applyChmod(spec, current, isDir, umask = 18) {
+function applyChmod(spec, current2, isDir, umask = 18) {
   if (/^[0-7]{1,4}$/.test(spec)) {
-    return current & ~PERM_MASK | parseInt(spec, 8) & PERM_MASK;
+    return current2 & ~PERM_MASK | parseInt(spec, 8) & PERM_MASK;
   }
-  let perms = current & PERM_MASK;
+  let perms = current2 & PERM_MASK;
   const clauses = spec.split(",");
   for (const clause of clauses) {
     const m = /^([ugoa]*)([+\-=])([ugo]|[rwxXst]*)$/.exec(clause.trim());
@@ -434,7 +434,7 @@ function applyChmod(spec, current, isDir, umask = 18) {
       perms = perms & ~clear2 | all;
     }
   }
-  return current & ~PERM_MASK | perms & PERM_MASK;
+  return current2 & ~PERM_MASK | perms & PERM_MASK;
 }
 function parseUmask(spec) {
   if (/^[0-7]{1,4}$/.test(spec)) return parseInt(spec, 8) & PERM_MASK;
@@ -1197,44 +1197,44 @@ var init_arith = __esm({
           if (next?.kind === "op" && assignOps.includes(next.value)) {
             this.i += 2;
             const rhs = this.assignment();
-            const current = this.readVar(t.value);
+            const current2 = this.readVar(t.value);
             let result;
             switch (next.value) {
               case "=":
                 result = rhs;
                 break;
               case "+=":
-                result = current + rhs;
+                result = current2 + rhs;
                 break;
               case "-=":
-                result = current - rhs;
+                result = current2 - rhs;
                 break;
               case "*=":
-                result = current * rhs;
+                result = current2 * rhs;
                 break;
               case "/=":
-                result = this.divide(current, rhs);
+                result = this.divide(current2, rhs);
                 break;
               case "%=":
-                result = this.modulo(current, rhs);
+                result = this.modulo(current2, rhs);
                 break;
               case "<<=":
-                result = current << rhs;
+                result = current2 << rhs;
                 break;
               case ">>=":
-                result = current >> rhs;
+                result = current2 >> rhs;
                 break;
               case "&=":
-                result = current & rhs;
+                result = current2 & rhs;
                 break;
               case "^=":
-                result = current ^ rhs;
+                result = current2 ^ rhs;
                 break;
               case "|=":
-                result = current | rhs;
+                result = current2 | rhs;
                 break;
               default:
-                result = Math.pow(current, rhs);
+                result = Math.pow(current2, rhs);
             }
             return this.writeVar(t.value, Math.trunc(result));
           }
@@ -1503,13 +1503,13 @@ function matchBrace(word, open) {
 function splitBraceAlternatives(body) {
   const out = [];
   let depth = 0;
-  let current = "";
+  let current2 = "";
   let inSingle = false;
   let inDouble = false;
   for (let i = 0; i < body.length; i++) {
     const c = body[i];
     if (c === "\\") {
-      current += c + (body[i + 1] ?? "");
+      current2 += c + (body[i + 1] ?? "");
       i++;
       continue;
     }
@@ -1519,14 +1519,14 @@ function splitBraceAlternatives(body) {
       if (c === "{") depth++;
       else if (c === "}") depth--;
       else if (c === "," && depth === 0) {
-        out.push(current);
-        current = "";
+        out.push(current2);
+        current2 = "";
         continue;
       }
     }
-    current += c;
+    current2 += c;
   }
-  out.push(current);
+  out.push(current2);
   return out;
 }
 function expandSequence(body) {
@@ -1845,13 +1845,13 @@ async function expandBracedParameter(body, ctx, quoted) {
   const name = opMatch[1];
   const rest = opMatch[2];
   if (rest === "") return valueFragments(name, ctx, quoted);
-  const current = name === "@" || name === "*" ? ctx.positional.join(" ") : lookupScalar(name, ctx);
+  const current2 = name === "@" || name === "*" ? ctx.positional.join(" ") : lookupScalar(name, ctx);
   const defaults = /^(:?)([-=?+])([\s\S]*)$/.exec(rest);
   if (defaults) {
     const colon = defaults[1] === ":";
     const op = defaults[2];
     const wordText = defaults[3];
-    const unset = current === void 0 || colon && current === "";
+    const unset = current2 === void 0 || colon && current2 === "";
     switch (op) {
       case "-":
         if (unset) return await expandFragments(wordText, ctx);
@@ -1880,7 +1880,7 @@ async function expandBracedParameter(body, ctx, quoted) {
   if (rest.startsWith(":")) {
     const spec = rest.slice(1);
     const parts = splitOnUnquotedColon(spec);
-    const value = current ?? "";
+    const value = current2 ?? "";
     const chars = [...value];
     let offset = Math.trunc(evalArith(parts[0] || "0", arithScope(ctx)));
     if (offset < 0) offset = Math.max(0, chars.length + offset);
@@ -1896,7 +1896,7 @@ async function expandBracedParameter(body, ctx, quoted) {
     if ((name === "@" || name === "*") && quoted) {
       return ctx.positional.map((v, i) => ({ text: apply(v), split: false, glob: false, endsField: i < ctx.positional.length - 1 }));
     }
-    return [frag(apply(current ?? ""), quoted)];
+    return [frag(apply(current2 ?? ""), quoted)];
   }
   if (rest.startsWith("/")) {
     const spec = rest.slice(1);
@@ -1913,12 +1913,12 @@ async function expandBracedParameter(body, ctx, quoted) {
     if ((name === "@" || name === "*") && quoted) {
       return ctx.positional.map((v, i) => ({ text: apply(v), split: false, glob: false, endsField: i < ctx.positional.length - 1 }));
     }
-    return [frag(apply(current ?? ""), quoted)];
+    return [frag(apply(current2 ?? ""), quoted)];
   }
   const caseOp = /^(\^{1,2}|,{1,2})([\s\S]*)$/.exec(rest);
   if (caseOp) {
     const op = caseOp[1];
-    const value = current ?? "";
+    const value = current2 ?? "";
     const upper = op.startsWith("^");
     const all = op.length === 2;
     const transformed = all ? upper ? value.toUpperCase() : value.toLowerCase() : value.length === 0 ? value : (upper ? value[0].toUpperCase() : value[0].toLowerCase()) + value.slice(1);
@@ -1926,7 +1926,7 @@ async function expandBracedParameter(body, ctx, quoted) {
   }
   const transform = /^@([QEPAaULK])$/.exec(rest);
   if (transform) {
-    const value = current ?? "";
+    const value = current2 ?? "";
     switch (transform[1]) {
       case "Q":
         return [frag(shellQuote(value), quoted)];
@@ -2019,24 +2019,24 @@ function shellQuote(value) {
 function splitOnUnquotedColon(spec) {
   const out = [];
   let depth = 0;
-  let current = "";
+  let current2 = "";
   for (let i = 0; i < spec.length; i++) {
     const c = spec[i];
     if (c === "\\") {
-      current += c + (spec[i + 1] ?? "");
+      current2 += c + (spec[i + 1] ?? "");
       i++;
       continue;
     }
     if (c === "(" || c === "[") depth++;
     if (c === ")" || c === "]") depth--;
     if (c === ":" && depth === 0) {
-      out.push(current);
-      current = "";
+      out.push(current2);
+      current2 = "";
       continue;
     }
-    current += c;
+    current2 += c;
   }
-  out.push(current);
+  out.push(current2);
   return out;
 }
 function findUnescaped(text2, ch) {
@@ -2109,15 +2109,15 @@ function fieldSplit(fragments, ifs) {
   const whitespace = [...ifs].filter((c) => " 	\n".includes(c));
   const others = [...ifs].filter((c) => !" 	\n".includes(c));
   const fields = [];
-  let current = [];
+  let current2 = [];
   let sawAnything = false;
   const endField = () => {
-    fields.push(current);
-    current = [];
+    fields.push(current2);
+    current2 = [];
   };
   for (const fragment of fragments) {
     if (!fragment.split) {
-      current.push(fragment);
+      current2.push(fragment);
       sawAnything = true;
       if (fragment.endsField) endField();
       continue;
@@ -2128,8 +2128,8 @@ function fieldSplit(fragments, ifs) {
     while (i < text2.length) {
       const c = text2[i];
       if (whitespace.includes(c) || others.includes(c)) {
-        if (buffer !== "" || current.length > 0) {
-          if (buffer !== "") current.push({ ...fragment, text: buffer });
+        if (buffer !== "" || current2.length > 0) {
+          if (buffer !== "") current2.push({ ...fragment, text: buffer });
           buffer = "";
           endField();
           sawAnything = true;
@@ -2155,11 +2155,11 @@ function fieldSplit(fragments, ifs) {
       i++;
     }
     if (buffer !== "") {
-      current.push({ ...fragment, text: buffer });
+      current2.push({ ...fragment, text: buffer });
       sawAnything = true;
     }
   }
-  if (current.length > 0 || !sawAnything && fields.length === 0) fields.push(current);
+  if (current2.length > 0 || !sawAnything && fields.length === 0) fields.push(current2);
   return fields.filter((f, idx) => f.length > 0 || idx === 0 && fields.length === 1 && fragments.some((x) => !x.split));
 }
 async function pathnameExpand(field, ctx) {
@@ -3365,24 +3365,24 @@ function splitByIfs(line, ifs, max) {
   if (ifs === "") return [line];
   const chars = /* @__PURE__ */ new Set([...ifs]);
   const out = [];
-  let current = "";
+  let current2 = "";
   let i = 0;
   while (i < line.length && chars.has(line[i]) && " 	\n".includes(line[i])) i++;
   for (; i < line.length; i++) {
     if (out.length === max - 1) {
-      current = line.slice(i).replace(new RegExp(`[${escapeForClass(ifs)}]+$`), "");
+      current2 = line.slice(i).replace(new RegExp(`[${escapeForClass(ifs)}]+$`), "");
       break;
     }
     const c = line[i];
     if (chars.has(c)) {
-      out.push(current);
-      current = "";
+      out.push(current2);
+      current2 = "";
       while (i + 1 < line.length && chars.has(line[i + 1]) && " 	\n".includes(line[i + 1])) i++;
       continue;
     }
-    current += c;
+    current2 += c;
   }
-  out.push(current);
+  out.push(current2);
   return out;
 }
 async function builtinMapfile({ shell, argv, io }) {
@@ -3420,15 +3420,15 @@ function builtinGetopts({ shell, argv, io }) {
   if (!Number.isFinite(optind) || optind < 1) optind = 1;
   let charIndex = Number(shell.vars.get("_OPTCHAR") ?? "1");
   for (; ; ) {
-    const current = args[optind - 1];
-    if (current === void 0 || current === "--" || !current.startsWith("-") || current === "-") {
-      if (current === "--") shell.vars.set("OPTIND", String(optind + 1));
+    const current2 = args[optind - 1];
+    if (current2 === void 0 || current2 === "--" || !current2.startsWith("-") || current2 === "-") {
+      if (current2 === "--") shell.vars.set("OPTIND", String(optind + 1));
       else shell.vars.set("OPTIND", String(optind));
       shell.vars.set("_OPTCHAR", "1");
       shell.vars.set(name, "?");
       return 1;
     }
-    const flag = current[charIndex];
+    const flag = current2[charIndex];
     if (flag === void 0) {
       optind++;
       charIndex = 1;
@@ -3440,11 +3440,11 @@ function builtinGetopts({ shell, argv, io }) {
       shell.vars.set("OPTARG", silent ? flag : "");
       if (!silent) io.stderr.write(`${shell.scriptName}: illegal option -- ${flag}
 `);
-      advance(shell, current, optind, charIndex);
+      advance(shell, current2, optind, charIndex);
       return 0;
     }
     if (spec[specIndex + 1] === ":") {
-      const inline = current.slice(charIndex + 1);
+      const inline = current2.slice(charIndex + 1);
       if (inline !== "") {
         shell.vars.set("OPTARG", inline);
         shell.vars.set("OPTIND", String(optind + 1));
@@ -3468,12 +3468,12 @@ function builtinGetopts({ shell, argv, io }) {
     }
     shell.vars.set(name, flag);
     shell.vars.unset("OPTARG");
-    advance(shell, current, optind, charIndex);
+    advance(shell, current2, optind, charIndex);
     return 0;
   }
 }
-function advance(shell, current, optind, charIndex) {
-  if (charIndex + 1 < current.length) {
+function advance(shell, current2, optind, charIndex) {
+  if (charIndex + 1 < current2.length) {
     shell.vars.set("OPTIND", String(optind));
     shell.vars.set("_OPTCHAR", String(charIndex + 1));
   } else {
@@ -3698,10 +3698,10 @@ function builtinTrap({ shell, argv, io }) {
 function builtinJobs({ shell, argv, io }) {
   const idsOnly = argv.includes("-p");
   shell.jobs.forEach((job, index) => {
-    const current = index === shell.jobs.length - 1 ? "+" : index === shell.jobs.length - 2 ? "-" : " ";
+    const current2 = index === shell.jobs.length - 1 ? "+" : index === shell.jobs.length - 2 ? "-" : " ";
     if (idsOnly) io.stdout.write(`${job.pgid}
 `);
-    else io.stdout.write(`[${job.id}]${current}  ${job.state.padEnd(8)} ${job.command}
+    else io.stdout.write(`[${job.id}]${current2}  ${job.state.padEnd(8)} ${job.command}
 `);
   });
   return 0;
@@ -3858,7 +3858,7 @@ function builtinPushd({ shell, argv, io }) {
       io.stderr.write("pushd: no other directory\n");
       return 1;
     }
-    const current = shell.cwd;
+    const current2 = shell.cwd;
     try {
       shell.changeDirectory(top2);
     } catch {
@@ -3866,7 +3866,7 @@ function builtinPushd({ shell, argv, io }) {
 `);
       return 1;
     }
-    shell.dirStack[0] = current;
+    shell.dirStack[0] = current2;
     return builtinDirs({ shell, argv: ["dirs"], io });
   }
   const previous = shell.cwd;
@@ -4657,13 +4657,13 @@ var Vfs = class {
   resolvePath(abs, opts = {}) {
     const { cred, followFinal = true } = opts;
     const parts = segments(normalize(abs));
-    let current = "";
+    let current2 = "";
     let hops = 0;
     for (let i = 0; i < parts.length; i++) {
       const isFinal = i === parts.length - 1;
-      const next = `${current}/${parts[i]}`;
-      if (cred && current !== "") {
-        const parentStat = this.tryLstat(current);
+      const next = `${current2}/${parts[i]}`;
+      if (cred && current2 !== "") {
+        const parentStat = this.tryLstat(current2);
         if (parentStat && parentStat.isDirectory() && !this.permitted(parentStat, X_OK, cred)) {
           throw new SysError("EACCES", "open", abs);
         }
@@ -4672,15 +4672,15 @@ var Vfs = class {
       if (st?.isSymbolicLink() && (!isFinal || followFinal)) {
         if (++hops > MAX_SYMLINKS) throw new SysError("ELOOP", "open", abs);
         const target = this.readlinkRaw(next);
-        const resolved = isAbsolute(target) ? target : resolve(current === "" ? "/" : current, target);
+        const resolved = isAbsolute(target) ? target : resolve(current2 === "" ? "/" : current2, target);
         const rest = parts.slice(i + 1);
         const combined = rest.length ? `${resolved}/${rest.join("/")}` : resolved;
         return this.resolvePath(combined, { ...opts, cred });
       }
-      current = next;
+      current2 = next;
       if (!isFinal && st && !st.isDirectory()) throw new SysError("ENOTDIR", "open", abs);
     }
-    return current === "" ? "/" : current;
+    return current2 === "" ? "/" : current2;
   }
   /** lstat that returns null instead of throwing, for internal probing. */
   tryLstat(abs) {
@@ -5574,6 +5574,8 @@ var Process = class {
   stdin;
   stdout;
   stderr;
+  /** Descriptors above 2 the parent handed over, such as Chromium's fds 3 and 4. */
+  fds = /* @__PURE__ */ new Map();
   children = /* @__PURE__ */ new Set();
   aborter = new AbortController();
   exitWaiters = [];
@@ -5592,6 +5594,7 @@ var Process = class {
     this.stdin = opts.stdio?.stdin ?? new NullInput();
     this.stdout = opts.stdio?.stdout ?? new NullOutput();
     this.stderr = opts.stdio?.stderr ?? new NullOutput();
+    for (const [fd, stream] of Object.entries(opts.fds ?? {})) this.fds.set(Number(fd), stream);
   }
   /** Basename of argv[0], the `comm` field in `ps`. */
   get comm() {
@@ -6775,10 +6778,10 @@ var WasiHost = class {
     return this.setTimes(abs, atim, mtim, flags);
   }
   setTimes(path, atim, mtim, flags) {
-    const current = this.opts.vfs.stat(path, { cred: this.opts.cred });
+    const current2 = this.opts.vfs.stat(path, { cred: this.opts.cred });
     const now = this.opts.now();
-    const atime = flags & FST_ATIM_NOW ? now : flags & FST_ATIM ? Number(atim / 1000000n) : current.atimeMs;
-    const mtime = flags & FST_MTIM_NOW ? now : flags & FST_MTIM ? Number(mtim / 1000000n) : current.mtimeMs;
+    const atime = flags & FST_ATIM_NOW ? now : flags & FST_ATIM ? Number(atim / 1000000n) : current2.atimeMs;
+    const mtime = flags & FST_MTIM_NOW ? now : flags & FST_MTIM ? Number(mtim / 1000000n) : current2.mtimeMs;
     this.opts.vfs.utimes(path, atime, mtime, this.opts.cred);
     return WASI_ESUCCESS;
   }
@@ -7541,7 +7544,8 @@ var Kernel = class {
         stdin: this.toInputStream(opts.stdin),
         stdout: opts.stdout ?? new NullOutput(),
         stderr: opts.stderr ?? new NullOutput()
-      }
+      },
+      ...opts.fds ? { fds: opts.fds } : {}
     });
     const cancelWithParent = () => {
       if (parent?.termSignal) proc.deliver(parent.termSignal);
@@ -8245,9 +8249,9 @@ function createProcProvider(kernel) {
       const [head2, ...tail2] = rel.split("/");
       const rest = tail2.join("/");
       if (head2 === "self") {
-        const current = kernel.currentProcess ?? kernel.init;
-        if (rest === "") return { kind: "symlink", mode: 511, target: `/proc/${current.pid}` };
-        return pidNodes(current, rest);
+        const current2 = kernel.currentProcess ?? kernel.init;
+        if (rest === "") return { kind: "symlink", mode: 511, target: `/proc/${current2.pid}` };
+        return pidNodes(current2, rest);
       }
       if (head2 && /^\d+$/.test(head2)) {
         const proc = kernel.procs.get(Number(head2));
@@ -10242,18 +10246,18 @@ sys	${fmt2(Math.floor(ms * 0.2))}
   substituteAlias(words) {
     if (!this.shopts.has("expand_aliases") || words.length === 0) return words;
     const seen = /* @__PURE__ */ new Set();
-    let current = words;
+    let current2 = words;
     for (let i = 0; i < 8; i++) {
-      const head2 = current[0];
+      const head2 = current2[0];
       if (seen.has(head2)) break;
       const replacement = this.aliases.get(head2);
       if (replacement === void 0) break;
       seen.add(head2);
       const parts = splitAliasWords(replacement);
       if (parts.length === 0) break;
-      current = [...parts, ...current.slice(1)];
+      current2 = [...parts, ...current2.slice(1)];
     }
-    return current;
+    return current2;
   }
   async invoke(words, assignments, io) {
     const [name, ...args] = words;
@@ -10261,11 +10265,11 @@ sys	${fmt2(Math.floor(ms * 0.2))}
     if (fn) return await this.callFunction(name, fn, args, assignments, io);
     const builtin = getBuiltin(name);
     if (builtin) {
-      const restore = await this.applyTemporaryAssignments(assignments, isSpecialBuiltin(name));
+      const restore2 = await this.applyTemporaryAssignments(assignments, isSpecialBuiltin(name));
       try {
         return await builtin({ shell: this, argv: words, io });
       } finally {
-        restore();
+        restore2();
       }
     }
     return await this.runExternal(words, assignments, io);
@@ -10278,7 +10282,7 @@ sys	${fmt2(Math.floor(ms * 0.2))}
     }
     const savedPositional = this.positional;
     const savedName = this.scriptName;
-    const restore = await this.applyTemporaryAssignments(assignments, true);
+    const restore2 = await this.applyTemporaryAssignments(assignments, true);
     this.positional = args;
     this.vars.pushScope();
     this.functionDepth++;
@@ -10293,7 +10297,7 @@ sys	${fmt2(Math.floor(ms * 0.2))}
       this.vars.popScope();
       this.positional = savedPositional;
       this.scriptName = savedName;
-      restore();
+      restore2();
     }
   }
   async runExternal(words, assignments, io) {
@@ -10510,13 +10514,13 @@ sys	${fmt2(Math.floor(ms * 0.2))}
 };
 function splitAliasWords(text2) {
   const out = [];
-  let current = "";
+  let current2 = "";
   let quote3 = null;
   for (let i = 0; i < text2.length; i++) {
     const c = text2[i];
     if (quote3) {
       if (c === quote3) quote3 = null;
-      else current += c;
+      else current2 += c;
       continue;
     }
     if (c === "'" || c === '"') {
@@ -10524,13 +10528,13 @@ function splitAliasWords(text2) {
       continue;
     }
     if (c === " " || c === "	") {
-      if (current !== "") out.push(current);
-      current = "";
+      if (current2 !== "") out.push(current2);
+      current2 = "";
       continue;
     }
-    current += c;
+    current2 += c;
   }
-  if (current !== "") out.push(current);
+  if (current2 !== "") out.push(current2);
   return out;
 }
 function describeNode(node2) {
@@ -14652,29 +14656,29 @@ var Interpreter = class {
       this.writeLvalue(expr.target, value);
       return value;
     }
-    const current = this.toNum(this.readLvalue(expr.target));
+    const current2 = this.toNum(this.readLvalue(expr.target));
     const operand = this.toNum(value);
     let next;
     switch (expr.op) {
       case "+=":
-        next = current + operand;
+        next = current2 + operand;
         break;
       case "-=":
-        next = current - operand;
+        next = current2 - operand;
         break;
       case "*=":
-        next = current * operand;
+        next = current2 * operand;
         break;
       case "/=":
         if (operand === 0) throw new AwkError("division by zero in /=");
-        next = current / operand;
+        next = current2 / operand;
         break;
       case "%=":
         if (operand === 0) throw new AwkError("division by zero in %=");
-        next = current % operand;
+        next = current2 % operand;
         break;
       default:
-        next = Math.pow(current, operand);
+        next = Math.pow(current2, operand);
         break;
     }
     const result = Value.fromNumber(next);
@@ -16814,18 +16818,18 @@ function diffLines(a, b) {
 }
 function groupScript(edits) {
   const groups = [];
-  let current = null;
+  let current2 = null;
   for (const edit of edits) {
     if (edit.op === "equal") {
-      current = null;
+      current2 = null;
       continue;
     }
-    if (!current) {
-      current = { aStart: edit.aIndex, aCount: 0, bStart: edit.bIndex, bCount: 0 };
-      groups.push(current);
+    if (!current2) {
+      current2 = { aStart: edit.aIndex, aCount: 0, bStart: edit.bIndex, bCount: 0 };
+      groups.push(current2);
     }
-    if (edit.op === "delete") current.aCount++;
-    else current.bCount++;
+    if (edit.op === "delete") current2.aCount++;
+    else current2.bCount++;
   }
   return groups;
 }
@@ -18906,9 +18910,9 @@ ${applyEdits(source, edits)}` : applyEdits(source, edits),
       }
     }
     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;
+      for (let current2 = scope; current2; current2 = current2.parent) {
+        if (current2.names.has(name)) {
+          return current2.parent === null ? importBindings.get(name) ?? null : null;
         }
       }
       return null;
@@ -18941,7 +18945,7 @@ function containsImportExpression(node2) {
 function containsImportMeta(node2) {
   if (Array.isArray(node2)) return node2.some(containsImportMeta);
   if (!isNode2(node2)) return false;
-  if (node2.type === "MetaProperty") return true;
+  if (node2.type === "MetaProperty" && node2.meta?.name === "import") return true;
   for (const [key, value] of Object.entries(node2)) {
     if (key === "type" || key === "start" || key === "end") continue;
     if (containsImportMeta(value)) return true;
@@ -19174,7 +19178,7 @@ async function execute(ctx, invocation) {
       ...live ? { interactiveStdin: true } : {},
       ...tty ? { tty: true } : {}
     });
-    proc.on("output", (chunk) => {
+    proc.on(proc.rawOutput ? "raw-output" : "output", (chunk) => {
       try {
         ctx.write(chunk);
       } catch {
@@ -19200,7 +19204,7 @@ async function execute(ctx, invocation) {
             break;
           }
           try {
-            proc.write(new TextDecoder().decode(chunk));
+            proc.write(chunk);
           } catch {
             break;
           }
@@ -20221,7 +20225,7 @@ var wheels_default = {
 
 // package.json
 var package_default = {
-  version: "0.1.81"};
+  version: "0.1.85"};
 
 // src/python/config.ts
 function runtimeModuleUrl() {
@@ -20437,10 +20441,10 @@ var FileDescription = class {
     return this.writeAt(data, offset);
   }
   writeAt(data, offset) {
-    const current = this.inode.contents();
+    const current2 = this.inode.contents();
     const end = offset + data.length;
-    const next = new Uint8Array(Math.max(current.length, end));
-    next.set(current, 0);
+    const next = new Uint8Array(Math.max(current2.length, end));
+    next.set(current2, 0);
     next.set(data, offset);
     this.inode.replace(next);
     return data.length;
@@ -20453,9 +20457,9 @@ var FileDescription = class {
     return next;
   }
   truncate(length) {
-    const current = this.inode.contents();
+    const current2 = this.inode.contents();
     const next = new Uint8Array(length);
-    next.set(current.subarray(0, Math.min(length, current.length)), 0);
+    next.set(current2.subarray(0, Math.min(length, current2.length)), 0);
     this.inode.replace(next);
   }
   stat() {
@@ -22443,6 +22447,192 @@ function splitOnce(text2, separator) {
   return at < 0 ? [text2] : [text2.slice(0, at), text2.slice(at + 1)];
 }
 
+// src/browser/playwright-browsers.ts
+init_path();
+var PLAYWRIGHT_REGISTRY = "/root/.cache/ms-playwright";
+var LAYOUTS = {
+  "chromium": ["chrome-linux64", "chrome"],
+  "chromium-headless-shell": ["chrome-headless-shell-linux64", "chrome-headless-shell"]
+};
+function virtualBrowserFiles(browsersJson) {
+  let manifest;
+  try {
+    manifest = JSON.parse(browsersJson);
+  } catch {
+    return [];
+  }
+  const encoder9 = new TextEncoder();
+  const files = [];
+  for (const browser of manifest.browsers ?? []) {
+    const layout = LAYOUTS[browser.name];
+    if (!layout) continue;
+    const dir3 = join(PLAYWRIGHT_REGISTRY, `${browser.name.replace(/-/g, "_")}-${browser.revision}`);
+    files.push({ path: join(dir3, ...layout), data: encoder9.encode(`#!${BUILTIN_INTERPRETER} chrome
+`), mode: 493 });
+    files.push({ path: join(dir3, "INSTALLATION_COMPLETE"), data: new Uint8Array() });
+  }
+  return files;
+}
+function mkdirp(volume, path) {
+  let current2 = "";
+  for (const part of segments(path)) {
+    current2 += `/${part}`;
+    try {
+      volume.mkdirSync(current2, { mode: 493 });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  }
+}
+function installVirtualPlaywrightBrowsers(volume, packageDir) {
+  let text2;
+  try {
+    text2 = new TextDecoder().decode(volume.readFileSync(join(packageDir, "browsers.json")));
+  } catch {
+    return [];
+  }
+  const written = [];
+  for (const file3 of virtualBrowserFiles(text2)) {
+    mkdirp(volume, dirname(file3.path));
+    volume.writeFileSync(file3.path, file3.data);
+    if (file3.mode !== void 0) {
+      volume.chmodSync(file3.path, file3.mode);
+      written.push(file3.path);
+    }
+  }
+  return written;
+}
+
+// src/python/substitutions.ts
+var SUBSTITUTED_WHEELS = {
+  playwright: /-py3-none-manylinux1_x86_64\.whl$/
+};
+function isSubstitutedWheel(name, filename) {
+  return SUBSTITUTED_WHEELS[name]?.test(filename) ?? false;
+}
+var GREENLET_VERSION = "3.2.4";
+var GREENLET_SOURCE = `"""SandboxedJs stand-in for greenlet.
+
+The real greenlet switches native C stacks, which a WebAssembly interpreter
+cannot do. This module imports and can be subclassed, so libraries that only
+switch greenlets on some paths keep working on the others -- Playwright's
+asyncio API is the case it exists for. Switching raises greenlet.error.
+"""
+
+__version__ = ${JSON.stringify(GREENLET_VERSION)}
+
+_UNSUPPORTED = (
+    "greenlet cannot switch stacks in this WebAssembly Python runtime; "
+    "use an asyncio API instead (for Playwright: playwright.async_api)"
+)
+
+
+class error(Exception):
+    pass
+
+
+class GreenletExit(BaseException):
+    pass
+
+
+class greenlet:
+    def __init__(self, run=None, parent=None):
+        if run is not None:
+            self.run = run
+        self.parent = parent
+
+    def switch(self, *args, **kwargs):
+        raise error(_UNSUPPORTED)
+
+    def throw(self, *args, **kwargs):
+        raise error(_UNSUPPORTED)
+
+    @property
+    def dead(self):
+        return False
+
+    def __bool__(self):
+        return False
+
+
+_main = greenlet()
+
+
+def getcurrent():
+    return _main
+
+
+# The real class carries these too; code that reaches them through the class
+# must get the refusal above, not an AttributeError that names neither cause.
+greenlet.getcurrent = staticmethod(getcurrent)
+greenlet.error = error
+greenlet.GreenletExit = GreenletExit
+
+
+def settrace(callback):
+    return None
+
+
+def gettrace():
+    return None
+`;
+var BUILTINS3 = {
+  greenlet: {
+    version: GREENLET_VERSION,
+    files: {
+      "greenlet/__init__.py": GREENLET_SOURCE,
+      [`greenlet-${GREENLET_VERSION}.dist-info/METADATA`]: `Metadata-Version: 2.1
+Name: greenlet
+Version: ${GREENLET_VERSION}
+Summary: SandboxedJs stand-in: importable, cannot switch stacks
+`,
+      [`greenlet-${GREENLET_VERSION}.dist-info/WHEEL`]: "Wheel-Version: 1.0\nGenerator: sandboxedjs\nRoot-Is-Purelib: true\nTag: py3-none-any\n",
+      [`greenlet-${GREENLET_VERSION}.dist-info/INSTALLER`]: "sandboxedjs\n",
+      [`greenlet-${GREENLET_VERSION}.dist-info/RECORD`]: ""
+    }
+  }
+};
+function builtinCandidates(name) {
+  const builtin = BUILTINS3[name];
+  if (!builtin) return [];
+  return [{
+    name,
+    version: builtin.version,
+    kind: "builtin",
+    url: `sbx-builtin:${name}-${builtin.version}`,
+    filename: `${name}-${builtin.version}-py3-none-any.whl`,
+    sha256: "",
+    metadataUrl: null,
+    indexedRequires: []
+  }];
+}
+function isBuiltinOnly(name) {
+  return name in BUILTINS3;
+}
+function builtinFiles(name, sitePackages) {
+  const encoder9 = new TextEncoder();
+  return Object.entries(BUILTINS3[name]?.files ?? {}).map(([relative2, text2]) => ({
+    path: `${sitePackages}/${relative2}`,
+    data: encoder9.encode(text2)
+  }));
+}
+function substituteFiles(name, files, sitePackages) {
+  if (name !== "playwright") return files;
+  const driver = `${sitePackages}/playwright/driver`;
+  const kept = files.filter((file3) => file3.path !== `${driver}/node`);
+  kept.push({
+    path: `${driver}/node`,
+    data: new TextEncoder().encode(`#!/bin/sh
+# sandboxedjs: the container's Node.js runs Playwright's driver
+exec node "$@"
+`),
+    mode: 493
+  });
+  const browsers = files.find((file3) => file3.path === `${driver}/package/browsers.json`);
+  if (browsers) kept.push(...virtualBrowserFiles(new TextDecoder().decode(browsers.data)));
+  return kept;
+}
+
 // src/python/extension-abi.ts
 var EXTENSION_ABI = {
   "abiId": "sbxabi1-c2637d04695ad927",
@@ -22515,7 +22705,7 @@ function metadataUrlFor(file3) {
   const declared = file3["core-metadata"] ?? file3.core_metadata;
   return declared ? `${file3.url}.metadata` : null;
 }
-var KIND_RANK = { pure: 0, "sbx-wasm": 1, sdist: 2 };
+var KIND_RANK = { pure: 0, "sbx-wasm": 1, builtin: 2, substituted: 3, sdist: 4 };
 async function resolve2(options) {
   const {
     client,
@@ -22709,6 +22899,8 @@ async function fetchCandidates(client, name, allowSourceBuilds, prebuilt, reject
       indexedRequires: wheel.requires
     });
   }
+  candidates.push(...builtinCandidates(normalize2(name)));
+  if (isBuiltinOnly(normalize2(name))) return candidates;
   let index;
   try {
     index = await client.json(`https://pypi.org/pypi/${name}/json`, { timeoutMs: 3e4 });
@@ -22720,7 +22912,7 @@ async function fetchCandidates(client, name, allowSourceBuilds, prebuilt, reject
     if (isPreRelease(version)) continue;
     for (const file3 of files) {
       if (file3.yanked) continue;
-      const kind = classifyFile(file3, allowSourceBuilds);
+      const kind = classifyFile(file3, allowSourceBuilds) ?? (isSubstitutedWheel(normalize2(name), file3.filename) ? "substituted" : null);
       if (!kind) {
         if (file3.packagetype === "sdist") rejected.sourceAvailable = true;
         rejected.versions.add(version);
@@ -22795,22 +22987,28 @@ async function installRequirements(options) {
     progress: { collecting: (name) => options.progress.collecting(name) }
   });
   const staged = [];
-  const installed2 = [];
+  const installed3 = [];
   for (const distribution of solved.distributions) {
     if (distribution.kind === "sdist") {
       throw new ResolutionError(
         `${distribution.name} ${distribution.version} resolved to a source distribution, and no local builder is configured to build it for this runtime`
       );
     }
+    if (distribution.kind === "builtin") {
+      staged.push(...builtinFiles(distribution.name, SITE_PACKAGES));
+      installed3.push({ name: distribution.name, version: distribution.version });
+      continue;
+    }
     options.progress.downloading(distribution.name, distribution.version);
     const bytes2 = await options.client.bytes(distribution.url, { timeoutMs: 12e4 });
     requireArchive(distribution, bytes2);
     verifyDigest(distribution, bytes2);
-    staged.push(...stageWheel(readZip(bytes2)));
-    installed2.push({ name: distribution.name, version: distribution.version });
+    const files = stageWheel(readZip(bytes2));
+    staged.push(...distribution.kind === "substituted" ? substituteFiles(distribution.name, files, SITE_PACKAGES) : files);
+    installed3.push({ name: distribution.name, version: distribution.version });
   }
   commit(options.vfs, options.cred, staged);
-  return { installed: installed2, skipped: solved.skipped };
+  return { installed: installed3, skipped: solved.skipped };
 }
 function requireArchive(distribution, bytes2) {
   if (bytes2.length > 1 && bytes2[0] === 80 && bytes2[1] === 75) return;
@@ -22920,17 +23118,57 @@ function waitStatus(proc) {
   return ((proc.exitCode ?? 0) & 255) << 8;
 }
 function outputFor(description, fallback) {
-  if (!description) return fallback;
+  if (!description) return Object.assign(fallback, { drained: () => Promise.resolve() });
+  const queue = [];
+  let broken = false;
+  let active = false;
+  let done = Promise.resolve();
+  const pump = async () => {
+    active = true;
+    try {
+      await drain();
+    } finally {
+      active = false;
+    }
+  };
+  const drain = async () => {
+    while (queue.length > 0 && !broken) {
+      const head2 = queue[0];
+      let accepted = 0;
+      try {
+        accepted = description.write(head2);
+      } catch (error) {
+        const errno = error.errno;
+        if (errno === Errno.EAGAIN) {
+          await description.whenReady();
+          continue;
+        }
+        broken = true;
+        queue.length = 0;
+        break;
+      }
+      if (accepted >= head2.length) queue.shift();
+      else {
+        queue[0] = head2.subarray(accepted);
+        await description.whenReady();
+      }
+    }
+  };
   return {
     write(data) {
-      description.write(typeof data === "string" ? new TextEncoder().encode(data) : data);
+      if (broken) return;
+      const bytes2 = typeof data === "string" ? new TextEncoder().encode(data) : data;
+      if (bytes2.length === 0) return;
+      queue.push(bytes2.slice());
+      if (!active) done = pump();
     },
     end() {
     },
     get closed() {
-      return false;
+      return broken;
     },
-    isTTY: fallback.isTTY
+    isTTY: fallback.isTTY,
+    drained: () => active ? done : Promise.resolve()
   };
 }
 function createProcessService(ctx) {
@@ -22945,6 +23183,8 @@ function createProcessService(ctx) {
       PENDING_INHERITANCE.set(token, held);
       env2[INHERIT_TOKEN] = token;
       const stdin = request.files.get(0);
+      const childStdout = outputFor(request.files.get(1), ctx.stdout);
+      const childStderr = outputFor(request.files.get(2), ctx.stderr);
       const argv = [containerProgram(ctx, request.argv[0] ?? ""), ...request.argv.slice(1)];
       const proc = ctx.kernel.spawn(argv, {
         cwd: request.cwd,
@@ -22952,11 +23192,11 @@ function createProcessService(ctx) {
         cred: ctx.cred,
         ppid: ctx.proc.pid,
         stdin: stdin ? descriptionInput(stdin) : void 0,
-        stdout: outputFor(request.files.get(1), ctx.stdout),
-        stderr: outputFor(request.files.get(2), ctx.stderr)
+        stdout: childStdout,
+        stderr: childStderr
       });
       children.set(proc.pid, proc);
-      void proc.wait().finally(() => {
+      void proc.wait().then(() => Promise.all([childStdout.drained(), childStderr.drained()])).finally(() => {
         if (PENDING_INHERITANCE.delete(token)) held.closeAll();
       });
       return proc.pid;
@@ -23020,7 +23260,12 @@ function descriptionInput(description) {
   };
   return {
     isTTY: false,
-    interactive: false,
+    /* A pipe, socket or inherited stream has a writer that may keep it open
+     * for the child's whole life. Reporting it as not interactive let `node`
+     * read it to end-of-file before starting the script — so a driver fed
+     * over stdin (Playwright's, from Python) never started at all. Only a
+     * regular file is safe to slurp. */
+    interactive: description.kind !== "file" && description.kind !== "dir",
     read,
     get available() {
       return pending.length;
@@ -23181,6 +23426,81 @@ if sys.platform in ("emscripten", "wasi"):
     os.system = _system
     os.popen = _popen
 
+    class _SbxPollingChildWatcher:
+        """Reap asyncio's children by polling on the event loop, not a thread.
+
+        Without pidfd_open, CPython picks ThreadedChildWatcher, whose blocking
+        waitpid runs on a helper thread. Host calls are served one at a time,
+        so that waitpid fails with EIO and the subprocess never reports its
+        exit. WNOHANG on the loop's own thread asks the same kernel and works.
+        """
+
+        def __init__(self):
+            self._pending = {}
+
+        def is_active(self):
+            return True
+
+        def close(self):
+            for handle in self._pending.values():
+                handle.cancel()
+            self._pending.clear()
+
+        def attach_loop(self, loop):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return None
+
+        def add_child_handler(self, pid, callback, *args):
+            import asyncio
+            self._poll(asyncio.get_running_loop(), pid, callback, args, 0.005)
+
+        def remove_child_handler(self, pid):
+            handle = self._pending.pop(pid, None)
+            if handle is not None:
+                handle.cancel()
+            return handle is not None
+
+        def _poll(self, loop, pid, callback, args, delay):
+            self._pending.pop(pid, None)
+            try:
+                reaped, status = os.waitpid(pid, os.WNOHANG)
+                returncode = os.waitstatus_to_exitcode(status) if reaped else None
+            except ChildProcessError:
+                reaped, returncode = pid, 255
+            if reaped:
+                callback(pid, returncode, *args)
+                return
+            self._pending[pid] = loop.call_later(
+                delay, self._poll, loop, pid, callback, args, min(delay * 2, 0.1))
+
+    class _SbxAsyncioWatcherHook:
+        """Swap the watcher in as asyncio.unix_events loads, so importing
+        sitecustomize does not import asyncio for programs that never use it."""
+
+        def find_spec(self, name, path=None, target=None):
+            if name != "asyncio.unix_events":
+                return None
+            import importlib.machinery
+            spec = importlib.machinery.PathFinder.find_spec(name, path)
+            if spec is None or spec.loader is None:
+                return spec
+            load = spec.loader.exec_module
+
+            def exec_module(module):
+                load(module)
+                module.can_use_pidfd = lambda: False
+                module.ThreadedChildWatcher = _SbxPollingChildWatcher
+
+            spec.loader.exec_module = exec_module
+            return spec
+
+    sys.meta_path.insert(0, _SbxAsyncioWatcherHook())
+
 
 _egress = os.environ.get("SBX_HTTP_EGRESS")
 if _egress:
@@ -23703,10 +24023,10 @@ function mountContainerFs(FS, opts) {
     /** Absolute container path for a node. */
     realPath(node2) {
       const parts = [];
-      let current = node2;
-      while (current && current.parent !== current) {
-        parts.unshift(current.name);
-        current = current.parent;
+      let current2 = node2;
+      while (current2 && current2.parent !== current2) {
+        parts.unshift(current2.name);
+        current2 = current2.parent;
       }
       const relative2 = parts.join("/");
       if (mountRoot === "/") return "/" + relative2;
@@ -23874,10 +24194,10 @@ function mountContainerFs(FS, opts) {
       return size;
     },
     write(stream, buffer, offset, length, position) {
-      const current = stream.sbxBuffer ?? new Uint8Array(0);
-      const end = Math.max(current.length, position + length);
+      const current2 = stream.sbxBuffer ?? new Uint8Array(0);
+      const end = Math.max(current2.length, position + length);
       const next = new Uint8Array(end);
-      next.set(current);
+      next.set(current2);
       next.set(buffer.subarray(offset, offset + length), position);
       stream.sbxBuffer = next;
       stream.sbxDirty = true;
@@ -24114,7 +24434,25 @@ function wasiCommands() {
   return [wasi];
 }
 var platformBuffer = globalThis.Buffer;
-var Buffer2 = platformBuffer ?? addBase64UrlSupport(Buffer$1);
+addUint8ArraySupport(addBase64UrlSupport(Buffer$1));
+var Buffer2 = platformBuffer ?? Buffer$1;
+function addUint8ArraySupport(BufferClass) {
+  const target = BufferClass;
+  if (target.__sandboxedUint8Array) return BufferClass;
+  Object.defineProperty(target, "__sandboxedUint8Array", { value: true });
+  const asBuffer = (value) => value instanceof Uint8Array && !target.isBuffer(value) ? target.from(value.buffer, value.byteOffset, value.byteLength) : value;
+  for (const method of ["indexOf", "lastIndexOf", "includes"]) {
+    const original = target.prototype[method];
+    target.prototype[method] = function(value, ...rest) {
+      return original.call(this, asBuffer(value), ...rest);
+    };
+  }
+  const equals = target.prototype.equals;
+  target.prototype.equals = function(other) {
+    return equals.call(this, asBuffer(other));
+  };
+  return BufferClass;
+}
 function addBase64UrlSupport(BufferClass) {
   const target = BufferClass;
   if (target.__sandboxedBase64Url) return BufferClass;
@@ -24201,18 +24539,23 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
       }
     }
     const target = join(modulesRoot, name);
-    const installed2 = this.tryReadJson(join(target, "package.json"));
+    const installed3 = this.tryReadJson(join(target, "package.json"));
     if (ancestry.has(identity)) return manifest;
-    if (installed2?.version !== version) {
+    if (installed3?.version !== version) {
       options.onProgress?.(`Fetching ${identity}`);
       const archive = await this.getTarball(manifest.dist.tarball);
       verifyIntegrity(archive, manifest.dist.integrity, manifest.dist.shasum, identity);
       this.removeIfPresent(target);
-      mkdirp(this.volume, target);
+      mkdirp2(this.volume, target);
       extractNpmTarball(this.volume, archive, target);
       options.onProgress?.(`Installed ${identity}`);
     }
     this.createBinLinks(manifest, target, modulesRoot);
+    if (name === "playwright-core") {
+      for (const executable of installVirtualPlaywrightBrowsers(this.volume, target)) {
+        options.onProgress?.(`Linked ${executable} to the virtual browser`);
+      }
+    }
     const nextAncestry = new Set(ancestry).add(identity);
     const childRoot = join(target, "node_modules");
     const required = Object.fromEntries(Object.entries(manifest.dependencies ?? {}).filter(([name2]) => !(name2 in (manifest.optionalDependencies ?? {}))));
@@ -24317,7 +24660,7 @@ var CleanPackageInstaller = class _CleanPackageInstaller {
     if (!manifest.bin) return;
     const bins = typeof manifest.bin === "string" ? { [unscoped(manifest.name)]: manifest.bin } : manifest.bin;
     const binDir = join(modulesRoot, ".bin");
-    mkdirp(this.volume, binDir);
+    mkdirp2(this.volume, binDir);
     for (const [name, path] of Object.entries(bins)) {
       const link = join(binDir, name);
       this.removeIfPresent(link);
@@ -24363,11 +24706,11 @@ var IncompatiblePlatform = class extends Error {
 function supportsPlatform(manifest) {
   return platformListAllows(manifest.os, PLATFORM.os) && platformListAllows(manifest.cpu, PLATFORM.cpu) && platformListAllows(manifest.libc, PLATFORM.libc);
 }
-function platformListAllows(values, current) {
+function platformListAllows(values, current2) {
   if (!values?.length) return true;
-  if (values.includes(`!${current}`)) return false;
+  if (values.includes(`!${current2}`)) return false;
   const positive = values.filter((value) => !value.startsWith("!"));
-  return positive.length === 0 || positive.includes(current) || positive.includes("any");
+  return positive.length === 0 || positive.includes(current2) || positive.includes("any");
 }
 function resolveVersion(metadata, range) {
   const tag2 = metadata["dist-tags"]?.[range];
@@ -24421,29 +24764,29 @@ function extractNpmTarball(volume, compressed, destination) {
     const target = safeTarget(destination, name);
     const mode = octal(header, 100, 8) || 420;
     if (type === "5") {
-      mkdirp(volume, target, mode);
+      mkdirp2(volume, target, mode);
     } else if (type === "2") {
-      mkdirp(volume, dirname(target));
+      mkdirp2(volume, dirname(target));
       volume.symlinkSync(text(header, 157, 100), target);
     } else if (type === "1") {
-      mkdirp(volume, dirname(target));
+      mkdirp2(volume, dirname(target));
       volume.linkSync(safeTarget(destination, stripPackageRoot(text(header, 157, 100))), target);
     } else if (type === "0" || type === "\0" || type === "7") {
-      mkdirp(volume, dirname(target));
+      mkdirp2(volume, dirname(target));
       volume.writeFileSync(target, data.slice());
       volume.chmodSync(target, mode);
     }
   }
 }
-function mkdirp(volume, path, mode = 493) {
-  let current = "";
+function mkdirp2(volume, path, mode = 493) {
+  let current2 = "";
   for (const part of segments(path)) {
-    current += `/${part}`;
+    current2 += `/${part}`;
     try {
-      volume.mkdirSync(current, { mode });
+      volume.mkdirSync(current2, { mode });
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
-      if (!volume.lstatSync(current).isDirectory()) throw error;
+      if (!volume.lstatSync(current2).isDirectory()) throw error;
     }
   }
 }
@@ -24615,8 +24958,8 @@ function renameShadowedExports(source) {
   }
 }
 function resolvesToProgram(scope) {
-  for (let current = scope; current; current = current.parent) {
-    if (current.bindsExports) return current.parent === null;
+  for (let current2 = scope; current2; current2 = current2.parent) {
+    if (current2.bindsExports) return current2.parent === null;
   }
   return false;
 }
@@ -25124,7 +25467,7 @@ unless the container was created with network: { allowOutbound: true }.`,
     const packageSpec = packages[0] ?? spec;
     const packageName = packages[0] ? splitPackageSpec(packages[0]).name : specName;
     let command = packages.length > 0 ? spec : basename(specName);
-    const run2 = async (binary) => {
+    const run3 = async (binary) => {
       const env2 = {
         ...ctx.env,
         PATH: `${binDir}:${ctx.env.PATH ?? ""}`,
@@ -25141,8 +25484,8 @@ unless the container was created with network: { allowOutbound: true }.`,
       }).wait();
     };
     if (!version) {
-      if (findLocalBin(ctx, command)) return run2(command);
-      if (ctx.kernel.which(command, ctx.cwd, ctx.env, ctx.cred)) return run2(command);
+      if (findLocalBin(ctx, command)) return run3(command);
+      if (ctx.kernel.which(command, ctx.cwd, ctx.env, ctx.cred)) return run3(command);
     }
     if (args.has("no-install")) {
       ctx.warn(`command not found: ${command}`);
@@ -25157,12 +25500,12 @@ unless the container was created with network: { allowOutbound: true }.`,
     }
     ctx.stderr.write(`npx: installing ${packageSpec}...
 `);
-    const installed2 = await installPackages(ctx, [packageSpec], {
+    const installed3 = await installPackages(ctx, [packageSpec], {
       cwd: root,
       save: false,
       quiet: true
     });
-    if (installed2 !== 0) return installed2;
+    if (installed3 !== 0) return installed3;
     if (!findLocalBin(ctx, command)) {
       const binaries = packageBinaries(ctx, root, packageName);
       const chosen = binaries.includes(command) ? command : binaries[0];
@@ -25180,7 +25523,7 @@ unless the container was created with network: { allowOutbound: true }.`,
       }
       command = chosen;
     }
-    return run2(command);
+    return run3(command);
   }
 });
 function makeNpmAlias(name, path) {
@@ -25199,7 +25542,21 @@ function makeNpmAlias(name, path) {
         exec: ["exec", ...rest],
         list: ["ls", ...rest],
         why: ["ls", ...rest],
-        dlx: ["exec", ...rest]
+        dlx: ["exec", ...rest],
+        /* Verbs of the package manager itself, never script names. Tools ask
+         * them in passing — Next resolves its download registry with
+         * `yarn config get registry` whenever yarn is on PATH — and running
+         * them as scripts failed with "could not read package.json". */
+        config: ["config", ...rest],
+        cache: ["cache", ...rest],
+        root: ["root", ...rest],
+        prefix: ["prefix", ...rest],
+        ping: ["ping", ...rest],
+        whoami: ["whoami", ...rest],
+        init: ["init", ...rest],
+        create: ["create", ...rest],
+        uninstall: ["uninstall", ...rest],
+        rm: ["uninstall", ...rest]
       };
       if (subcommand === void 0) return npm.run({ ...ctx, args: ["install"], argv: [name, "install"] });
       if (subcommand === "-v" || subcommand === "--version") {
@@ -25340,6 +25697,425 @@ function packageCommands() {
   return [npm, npx, yarn, pnpm, apt, dpkg];
 }
 
+// src/browser/cdp-server.ts
+init_binary();
+var VIRTUAL_CHROMIUM_VERSION = "153.0.8010.12";
+var VIRTUAL_BROWSER_PRODUCT = `HeadlessChrome/${VIRTUAL_CHROMIUM_VERSION}`;
+var VIRTUAL_USER_AGENT = `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/${VIRTUAL_CHROMIUM_VERSION} Safari/537.36 SandboxedJs`;
+var ProtocolError2 = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  code;
+};
+var defaultRealmFactory = async (hooks) => {
+  const console2 = Object.fromEntries(
+    ["log", "info", "warn", "error", "debug"].map((type) => [type, (...args) => hooks.console(type === "warn" ? "warning" : type, args)])
+  );
+  let vm;
+  try {
+    vm = await nodeBuiltin("vm");
+  } catch {
+    vm = void 0;
+  }
+  if (vm?.createContext) {
+    const context = vm.createContext({ console: console2, setTimeout, clearTimeout, setInterval, clearInterval, queueMicrotask });
+    return { evaluate: (source) => vm.runInContext(source, context), dispose: () => {
+    } };
+  }
+  const doc = globalThis.document;
+  if (doc) {
+    const frame = doc.createElement("iframe");
+    frame.setAttribute("sandbox", "allow-scripts allow-same-origin");
+    frame.style.display = "none";
+    doc.documentElement.append(frame);
+    const win = frame.contentWindow;
+    if (!win) throw new Error("virtual browser: could not create a realm");
+    Object.assign(win, { console: console2 });
+    return { evaluate: (source) => win.eval(source), dispose: () => frame.remove() };
+  }
+  throw new Error("virtual browser: this host offers neither node:vm nor a document to create a realm in");
+};
+var CdpServer = class {
+  constructor(options) {
+    this.options = options;
+    this.realmFactory = options.realmFactory ?? defaultRealmFactory;
+  }
+  options;
+  pages = /* @__PURE__ */ new Map();
+  browserContexts = /* @__PURE__ */ new Set();
+  nextTarget = 0;
+  nextContext = 0;
+  nextContextId = 0;
+  nextScript = 0;
+  realmFactory;
+  /** Answered in arrival order: a driver may send `evaluate` before a navigation's contexts exist. */
+  queue = Promise.resolve();
+  /** Handle one message; replies and events leave through `send`. */
+  dispatch(message) {
+    this.queue = this.queue.then(() => this.handle(message));
+    return this.queue;
+  }
+  dispose() {
+    for (const page of this.pages.values()) this.destroyContexts(page, false);
+    this.pages.clear();
+  }
+  async handle(message) {
+    const { id, method = "", params = {}, sessionId } = message;
+    const reply = (result = {}) => this.options.send({ id, result, ...sessionId ? { sessionId } : {} });
+    try {
+      const page = sessionId ? this.pages.get(sessionId) : void 0;
+      if (sessionId && !page) throw new ProtocolError2(-32001, `Session with given id not found.`);
+      const result = await this.call(method, params, page, message);
+      if (result === DEFERRED) return;
+      reply(result);
+    } catch (error) {
+      const failure2 = error instanceof ProtocolError2 ? error : new ProtocolError2(-32e3, error?.message ?? String(error));
+      this.options.send({ id, error: { code: failure2.code, message: failure2.message }, ...sessionId ? { sessionId } : {} });
+    }
+  }
+  async call(method, params, page, message) {
+    switch (method) {
+      case "Browser.getVersion":
+        return { protocolVersion: "1.3", product: VIRTUAL_BROWSER_PRODUCT, revision: "sandboxedjs", userAgent: VIRTUAL_USER_AGENT, jsVersion: "sandboxedjs" };
+      case "Browser.getWindowForTarget":
+        return { windowId: 1, bounds: { left: 0, top: 0, width: 1280, height: 720, windowState: "normal" } };
+      case "Browser.close":
+        this.options.send({ id: message.id, result: {} });
+        this.dispose();
+        this.options.onClose?.();
+        return DEFERRED;
+      case "Target.createBrowserContext": {
+        const browserContextId = `CTX${++this.nextContext}`;
+        this.browserContexts.add(browserContextId);
+        return { browserContextId };
+      }
+      case "Target.disposeBrowserContext":
+        for (const target of [...this.pages.values()].filter((p) => p.browserContextId === params.browserContextId)) this.closeTarget(target);
+        this.browserContexts.delete(params.browserContextId);
+        return {};
+      case "Target.getBrowserContexts":
+        return { browserContextIds: [...this.browserContexts] };
+      case "Target.createTarget":
+        return this.createTarget(params);
+      case "Target.closeTarget": {
+        const target = [...this.pages.values()].find((p) => p.targetId === params.targetId);
+        if (!target) throw new ProtocolError2(-32602, "No target with given id found");
+        this.closeTarget(target);
+        return { success: true };
+      }
+      case "Target.getTargets":
+        return { targetInfos: [...this.pages.values()].map((p) => this.targetInfo(p)) };
+      case "Target.getTargetInfo":
+        return { targetInfo: page ? this.targetInfo(page) : { targetId: "browser", type: "browser", title: "", url: "", attached: true, canAccessOpener: false } };
+      case "Page.getFrameTree":
+        return { frameTree: { frame: this.frame(this.need(page)), childFrames: [] } };
+      case "Page.createIsolatedWorld": {
+        const target = this.need(page);
+        target.worlds.add(params.worldName);
+        return { executionContextId: await this.createContext(target, params.worldName, false) };
+      }
+      case "Page.addScriptToEvaluateOnNewDocument":
+        return { identifier: String(++this.nextScript) };
+      case "Page.navigate":
+        return this.navigate(this.need(page), String(params.url), message);
+      case "Page.reload":
+        await this.commitNavigation(this.need(page), this.need(page).url);
+        return {};
+      case "Page.getNavigationHistory": {
+        const target = this.need(page);
+        return { currentIndex: 0, entries: [{ id: 0, url: target.url, userTypedURL: target.url, title: "", transitionType: "typed" }] };
+      }
+      case "Page.close":
+        this.closeTarget(this.need(page));
+        return {};
+      case "Runtime.enable": {
+        const target = this.need(page);
+        if (![...target.contexts.values()].some((c) => c.isDefault)) await this.createContext(target, "", true);
+        else for (const context of target.contexts.values()) this.announceContext(target, context);
+        return {};
+      }
+      case "Runtime.evaluate":
+        return this.evaluate(this.need(page), params);
+      case "Runtime.callFunctionOn":
+        return this.callFunctionOn(this.need(page), params);
+      case "Runtime.releaseObject":
+        for (const context of this.need(page).contexts.values()) context.objects.delete(params.objectId);
+        return {};
+      case "Runtime.releaseObjectGroup":
+        return {};
+      case "Runtime.runIfWaitingForDebugger":
+        return {};
+    }
+    const [, name = ""] = method.split(".");
+    if (name === "enable" || name === "disable" || /^set[A-Z]/.test(name)) return {};
+    throw new ProtocolError2(-32601, `'${method}' wasn't found`);
+  }
+  need(page) {
+    if (!page) throw new ProtocolError2(-32601, "This method is only available on a page session");
+    return page;
+  }
+  targetInfo(page) {
+    return { targetId: page.targetId, type: "page", title: page.url, url: page.url, attached: true, canAccessOpener: false, browserContextId: page.browserContextId };
+  }
+  async createTarget(params) {
+    const n = ++this.nextTarget;
+    const page = {
+      targetId: `T${n}`,
+      sessionId: `S${n}`,
+      browserContextId: params.browserContextId ?? "CTX0",
+      url: "about:blank",
+      loader: 1,
+      contexts: /* @__PURE__ */ new Map(),
+      worlds: /* @__PURE__ */ new Set()
+    };
+    this.pages.set(page.sessionId, page);
+    this.options.send({
+      method: "Target.attachedToTarget",
+      params: { sessionId: page.sessionId, targetInfo: this.targetInfo(page), waitingForDebugger: true }
+    });
+    if (params.url && params.url !== "about:blank") queueMicrotask(() => {
+      void this.commitNavigation(page, String(params.url));
+    });
+    return { targetId: page.targetId };
+  }
+  closeTarget(page) {
+    this.destroyContexts(page, false);
+    this.pages.delete(page.sessionId);
+    this.options.send({ method: "Target.detachedFromTarget", params: { sessionId: page.sessionId, targetId: page.targetId } });
+    this.options.send({ method: "Target.targetDestroyed", params: { targetId: page.targetId } });
+  }
+  frame(page) {
+    let origin = "://";
+    try {
+      origin = new URL(page.url).origin;
+    } catch {
+    }
+    return {
+      id: page.targetId,
+      loaderId: `L${page.loader}`,
+      url: page.url,
+      domainAndRegistry: "",
+      securityOrigin: origin === "null" ? "://" : origin,
+      mimeType: "text/html",
+      adFrameStatus: { adFrameType: "none" },
+      secureContextType: page.url.startsWith("https:") ? "Secure" : "InsecureScheme",
+      crossOriginIsolatedContextType: "NotIsolated",
+      gatedAPIFeatures: []
+    };
+  }
+  event(page, method, params) {
+    this.options.send({ method, params, sessionId: page.sessionId });
+  }
+  async createContext(page, name, isDefault) {
+    const id = ++this.nextContextId;
+    const realm = await this.realmFactory({
+      console: (type, args) => this.event(page, "Runtime.consoleAPICalled", {
+        type,
+        args: args.map((value) => this.remote(context, value, true)),
+        executionContextId: id,
+        timestamp: Date.now()
+      })
+    });
+    const context = { id, name, isDefault, realm, objects: /* @__PURE__ */ new Map(), nextObject: 0 };
+    page.contexts.set(id, context);
+    this.announceContext(page, context);
+    return id;
+  }
+  announceContext(page, context) {
+    this.event(page, "Runtime.executionContextCreated", {
+      context: {
+        id: context.id,
+        origin: this.frame(page).securityOrigin,
+        name: context.name,
+        uniqueId: `U${context.id}`,
+        auxData: { frameId: page.targetId, isDefault: context.isDefault, type: context.isDefault ? "default" : "isolated" }
+      }
+    });
+  }
+  destroyContexts(page, announce) {
+    for (const context of page.contexts.values()) {
+      context.realm.dispose();
+      if (announce) this.event(page, "Runtime.executionContextDestroyed", { executionContextId: context.id, executionContextUniqueId: `U${context.id}` });
+    }
+    page.contexts.clear();
+  }
+  async navigate(page, url, message) {
+    try {
+      new URL(url);
+    } catch {
+      return { frameId: page.targetId, errorText: "net::ERR_INVALID_URL" };
+    }
+    const loaderId = `L${page.loader + 1}`;
+    this.options.send({ id: message.id, result: { frameId: page.targetId, loaderId }, sessionId: page.sessionId });
+    await this.commitNavigation(page, url);
+    return DEFERRED;
+  }
+  async commitNavigation(page, url) {
+    page.loader += 1;
+    page.url = url;
+    this.destroyContexts(page, true);
+    this.event(page, "Page.frameStartedLoading", { frameId: page.targetId });
+    this.event(page, "Page.frameNavigated", { frame: this.frame(page), type: "Navigation" });
+    await this.createContext(page, "", true);
+    for (const world of page.worlds) await this.createContext(page, world, false);
+    const timestamp2 = Date.now() / 1e3;
+    for (const name of ["init", "DOMContentLoaded", "load"]) {
+      this.event(page, "Page.lifecycleEvent", { frameId: page.targetId, loaderId: `L${page.loader}`, name, timestamp: timestamp2 });
+    }
+    this.event(page, "Page.domContentEventFired", { timestamp: timestamp2 });
+    this.event(page, "Page.loadEventFired", { timestamp: timestamp2 });
+    this.event(page, "Page.frameStoppedLoading", { frameId: page.targetId });
+  }
+  contextFor(page, id) {
+    const context = id === void 0 ? [...page.contexts.values()].find((c) => c.isDefault) : page.contexts.get(id);
+    if (!context) throw new ProtocolError2(-32e3, "Cannot find context with specified id");
+    return context;
+  }
+  contextOfObject(page, objectId) {
+    const context = page.contexts.get(Number(objectId.split(".")[0]));
+    if (!context?.objects.has(objectId)) throw new ProtocolError2(-32e3, "Could not find object with given id");
+    return context;
+  }
+  evaluate(page, params) {
+    const context = this.contextFor(page, params.contextId);
+    return this.settle(context, () => context.realm.evaluate(String(params.expression)), params);
+  }
+  callFunctionOn(page, params) {
+    const context = params.objectId ? this.contextOfObject(page, params.objectId) : this.contextFor(page, params.executionContextId);
+    const receiver = params.objectId ? context.objects.get(params.objectId) : void 0;
+    const args = (params.arguments ?? []).map((argument) => this.argument(page, argument));
+    return this.settle(context, () => {
+      const fn = context.realm.evaluate(`(${params.functionDeclaration})`);
+      return fn.apply(receiver, args);
+    }, params);
+  }
+  argument(page, argument) {
+    if (argument.objectId) return this.contextOfObject(page, argument.objectId).objects.get(argument.objectId);
+    if (argument.unserializableValue !== void 0) {
+      const raw = String(argument.unserializableValue);
+      if (raw === "NaN") return NaN;
+      if (raw === "Infinity") return Infinity;
+      if (raw === "-Infinity") return -Infinity;
+      if (raw === "-0") return -0;
+      if (/^-?\d+n$/.test(raw)) return BigInt(raw.slice(0, -1));
+      throw new ProtocolError2(-32602, `Invalid unserializable value ${raw}`);
+    }
+    return argument.value;
+  }
+  async settle(context, run3, params) {
+    try {
+      let value = run3();
+      if (params.awaitPromise && value && typeof value.then === "function") value = await value;
+      return { result: this.remote(context, value, Boolean(params.returnByValue)) };
+    } catch (error) {
+      const description = error instanceof Object && "stack" in error ? String(error.stack) : String(error);
+      const exception = error !== null && typeof error === "object" ? { ...this.remote(context, error, false), subtype: "error", description } : this.remote(context, error, true);
+      return {
+        result: exception,
+        exceptionDetails: { exceptionId: 1, text: "Uncaught", lineNumber: 0, columnNumber: 0, exception }
+      };
+    }
+  }
+  remote(context, value, byValue) {
+    const type = typeof value;
+    if (value === void 0) return { type: "undefined" };
+    if (value === null) return { type: "object", subtype: "null", value: null };
+    if (type === "number") {
+      const n = value;
+      if (Number.isNaN(n) || !Number.isFinite(n) || Object.is(n, -0)) return { type, unserializableValue: Object.is(n, -0) ? "-0" : String(n), description: String(n) };
+      return { type, value: n, description: String(n) };
+    }
+    if (type === "bigint") return { type, unserializableValue: `${String(value)}n`, description: `${String(value)}n` };
+    if (type === "string" || type === "boolean") return { type, value, description: String(value) };
+    if (byValue && type !== "function" && type !== "symbol") {
+      try {
+        return { type, value: JSON.parse(JSON.stringify(value)) };
+      } catch {
+      }
+    }
+    const objectId = `${context.id}.${++context.nextObject}`;
+    context.objects.set(objectId, value);
+    const className = value?.constructor?.name ?? "Object";
+    const subtype = Array.isArray(value) ? "array" : value instanceof Error ? "error" : void 0;
+    return { type, objectId, className, description: type === "function" ? "function" : className, ...subtype ? { subtype } : {} };
+  }
+};
+var DEFERRED = /* @__PURE__ */ Symbol("reply already sent");
+
+// src/browser/chrome-command.ts
+var USAGE = "chrome --remote-debugging-pipe [chromium flags\u2026]";
+async function run2(ctx) {
+  if (ctx.args.includes("--version")) {
+    ctx.line(`Chromium ${VIRTUAL_CHROMIUM_VERSION} (SandboxedJs virtual browser)`);
+    return 0;
+  }
+  if (!ctx.args.includes("--remote-debugging-pipe")) {
+    return ctx.fail(
+      "only --remote-debugging-pipe is supported: this is the SandboxedJs virtual browser, driven through the DevTools protocol (Playwright, Puppeteer), not an interactive Chromium"
+    );
+  }
+  const input = ctx.proc.fds.get(3);
+  const output = ctx.proc.fds.get(4);
+  if (!input || !output) {
+    return ctx.fail("--remote-debugging-pipe needs descriptors 3 and 4 open as pipes (stdio: ['ignore','pipe','pipe','pipe','pipe'])");
+  }
+  let closed = false;
+  const server = new CdpServer({
+    send: (message) => {
+      if (output.closed) return;
+      output.write(`${JSON.stringify(message)}\0`);
+    },
+    onClose: () => {
+      closed = true;
+      input.close();
+    }
+  });
+  ctx.stderr.write(`
+DevTools listening on pipe (SandboxedJs virtual browser ${VIRTUAL_CHROMIUM_VERSION})
+`);
+  const decoder9 = new TextDecoder();
+  let pending = "";
+  const aborted = new Promise((resolve3) => ctx.signal.addEventListener("abort", () => resolve3(null), { once: true }));
+  try {
+    while (!closed) {
+      const chunk = await Promise.race([input.read(), aborted]);
+      if (chunk === null) break;
+      pending += decoder9.decode(chunk, { stream: true });
+      let end;
+      while ((end = pending.indexOf("\0")) >= 0) {
+        const frame = pending.slice(0, end);
+        pending = pending.slice(end + 1);
+        if (!frame) continue;
+        let message;
+        try {
+          message = JSON.parse(frame);
+        } catch {
+          ctx.warn(`dropping malformed DevTools message: ${frame.slice(0, 80)}`);
+          continue;
+        }
+        void server.dispatch(message);
+      }
+    }
+  } finally {
+    server.dispose();
+    output.end();
+  }
+  return 0;
+}
+function browserCommands() {
+  return [
+    defineCommand({
+      name: "chrome",
+      aliases: ["chromium", "chromium-browser", "google-chrome", "chrome-headless-shell"],
+      summary: "SandboxedJs virtual browser, driven over the DevTools protocol",
+      usage: USAGE,
+      run: run2
+    })
+  ];
+}
+
 // src/bin/index.ts
 function allCommands() {
   return [
@@ -25358,7 +26134,8 @@ function allCommands() {
     ...pythonCommands(),
     ...ffmpegCommands(),
     ...wasiCommands(),
-    ...packageCommands()
+    ...packageCommands(),
+    ...browserCommands()
   ];
 }
 function installUserland(kernel) {
@@ -25579,6 +26356,35 @@ var Session = class {
 };
 
 // src/node/node-child-process-bridge.ts
+var ExtraDescriptor = class extends Pipe {
+  constructor(child, fd) {
+    super();
+    this.child = child;
+    this.fd = fd;
+    this.interactive = true;
+  }
+  child;
+  fd;
+  decoder = new TextDecoder();
+  writerGone = false;
+  write(data) {
+    if (this.writerGone) return;
+    const text2 = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
+    if (text2) this.child.emit("fd", { fd: this.fd, text: text2 });
+  }
+  /** The child closed its writing side. Input from the parent is unaffected. */
+  end() {
+    this.writerGone = true;
+  }
+  /** The parent wrote to this descriptor. */
+  deliver(data) {
+    super.write(data);
+  }
+  /** The parent closed this descriptor: the child sees EOF. */
+  finishInput() {
+    super.end();
+  }
+};
 var KernelChildProcess = class {
   pid;
   command;
@@ -25610,6 +26416,17 @@ var KernelChildProcess = class {
     this.parentPid = config2.parentPid;
     this.cwd = config2.cwd ?? "/";
     this.env = { ...config2.env };
+    for (const fd of config2.extraPipes ?? []) this.descriptors.set(fd, new ExtraDescriptor(this, fd));
+  }
+  descriptors = /* @__PURE__ */ new Map();
+  writeFd(fd, data) {
+    try {
+      this.descriptors.get(fd)?.deliver(data);
+    } catch {
+    }
+  }
+  endFd(fd) {
+    this.descriptors.get(fd)?.finishInput();
   }
   on(event, listener) {
     let listeners2 = this.listeners.get(event);
@@ -25641,7 +26458,8 @@ var KernelChildProcess = class {
           stdin: this.stdin,
           stdout,
           stderr,
-          ppid: 1
+          ppid: 1,
+          ...this.descriptors.size ? { fds: Object.fromEntries(this.descriptors) } : {}
         });
         void this.process.wait().then((code) => {
           stdout.end();
@@ -25793,36 +26611,330 @@ var HostModuleTracker = class {
 
 // 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"]]
-};
-var ENTRY_FIELDS = {
-  import: ["module", "main"],
-  require: ["main", "module"]
+
+// src/node/async-context.ts
+var EMPTY = /* @__PURE__ */ new Map();
+var current = EMPTY;
+function capture() {
+  return current;
+}
+function restore(frame) {
+  current = frame ?? EMPTY;
+}
+function resume(frame, value) {
+  current = frame;
+  return value;
+}
+function runInFrame(frame, fn) {
+  const previous = current;
+  current = frame;
+  try {
+    return fn();
+  } finally {
+    current = previous;
+  }
+}
+function bindToCurrent(fn) {
+  const frame = current;
+  if (frame === EMPTY) {
+    return function(...args) {
+      return runInFrame(EMPTY, () => fn.apply(this, args));
+    };
+  }
+  return function(...args) {
+    return runInFrame(frame, () => fn.apply(this, args));
+  };
+}
+var AsyncLocalStorage = class {
+  #enabled = true;
+  getStore() {
+    return current.get(this);
+  }
+  run(store, callback, ...args) {
+    const next = new Map(current);
+    next.set(this, store);
+    this.#enabled = true;
+    return runInFrame(next, () => callback(...args));
+  }
+  exit(callback, ...args) {
+    if (!current.has(this)) return callback(...args);
+    const next = new Map(current);
+    next.delete(this);
+    return runInFrame(next, () => callback(...args));
+  }
+  /** Replace the store for the rest of the current execution and its continuations. */
+  enterWith(store) {
+    const next = new Map(current);
+    next.set(this, store);
+    current = next;
+    this.#enabled = true;
+  }
+  disable() {
+    if (!this.#enabled) return;
+    this.#enabled = false;
+    if (current.has(this)) {
+      const next = new Map(current);
+      next.delete(this);
+      current = next;
+    }
+  }
+  static bind(fn) {
+    return bindToCurrent(fn);
+  }
+  static snapshot() {
+    const frame = current;
+    return (fn, ...args) => runInFrame(frame, () => fn(...args));
+  }
 };
-var CommonJsEngine = class {
-  constructor(volume, options = {}) {
-    this.volume = volume;
-    this.cwd = options.cwd ?? "/";
-    this.builtins = { ...options.builtins };
-    this.globals = { ...options.globals };
-    this.aliases = { ...options.aliases };
-    this.overrides = { ...options.overrides };
+var AsyncResource = class _AsyncResource {
+  #frame;
+  type;
+  constructor(type, _options) {
+    this.type = type;
+    this.#frame = current;
   }
-  volume;
-  cache = /* @__PURE__ */ new Map();
-  builtins;
-  globals;
-  aliases;
-  overrides;
+  runInAsyncScope(fn, thisArg, ...args) {
+    return runInFrame(this.#frame, () => fn.apply(thisArg, args));
+  }
+  bind(fn, thisArg) {
+    return ((...args) => this.runInAsyncScope(fn, thisArg, ...args));
+  }
+  emitDestroy() {
+    return this;
+  }
+  asyncId() {
+    return 1;
+  }
+  triggerAsyncId() {
+    return 0;
+  }
+  static bind(fn, type = "bound-anonymous-fn", thisArg) {
+    return new _AsyncResource(type).bind(fn, thisArg);
+  }
+};
+var CONTEXT_HELPERS = {
+  capture: "__sbxCapture",
+  resume: "__sbxResume",
+  restore: "__sbxRestore"
+};
+
+// src/node/async-context-transform.ts
+var JSX_EXTENSION2 = /\.[jt]sx$/;
+var JsxParser2 = Parser$1.extend(jsx());
+var MAYBE_AWAIT = /\bawait\b/;
+var OPTIONS_MODULE = {
+  ecmaVersion: "latest",
+  sourceType: "module",
+  allowAwaitOutsideFunction: true,
+  allowHashBang: true,
+  allowReturnOutsideFunction: true,
+  allowImportExportEverywhere: true
+};
+var OPTIONS_SCRIPT = { ...OPTIONS_MODULE, sourceType: "script" };
+var { capture: CAPTURE, resume: RESUME, restore: RESTORE } = CONTEXT_HELPERS;
+function transformAsyncContext(source, filename = "module.js") {
+  if (!MAYBE_AWAIT.test(source)) return null;
+  const ast = parseEither(source, filename);
+  if (!ast) return null;
+  const edits = collectEdits(ast, source, filename);
+  if (edits.length === 0) return null;
+  return applyEdits2(source, edits);
+}
+function parseEither(source, filename) {
+  const parser = JSX_EXTENSION2.test(filename) ? JsxParser2.parse.bind(JsxParser2) : parse$1;
+  for (const options of [OPTIONS_SCRIPT, OPTIONS_MODULE]) {
+    try {
+      return parser(source, options);
+    } catch {
+    }
+  }
+  return null;
+}
+var frameCounter = 0;
+function collectEdits(root, source, filename) {
+  const edits = [];
+  const visit = (node2) => {
+    if (Array.isArray(node2)) {
+      for (const item of node2) visit(item);
+      return;
+    }
+    if (!isNode4(node2)) return;
+    switch (node2.type) {
+      case "AwaitExpression": {
+        edits.push({ start: node2.start, end: node2.start, text: `${RESUME}(${CAPTURE}(), ` });
+        edits.push({ start: node2.end, end: node2.end, text: ")" });
+        visit(node2.argument);
+        return;
+      }
+      case "TryStatement": {
+        if (containsAwait(node2.block) || containsAwait(node2.handler) || containsAwait(node2.finalizer)) {
+          const frame = `__sbxFrame${frameCounter++}`;
+          edits.push({ start: node2.start, end: node2.start, text: `{ const ${frame} = ${CAPTURE}(); ` });
+          const handler = node2.handler;
+          if (handler) {
+            const body = handler.body;
+            edits.push({ start: body.start + 1, end: body.start + 1, text: ` ${RESTORE}(${frame});` });
+          }
+          const finalizer = node2.finalizer;
+          if (finalizer) {
+            edits.push({ start: finalizer.start + 1, end: finalizer.start + 1, text: ` ${RESTORE}(${frame});` });
+          }
+          edits.push({ start: node2.end, end: node2.end, text: " }" });
+        }
+        visit(node2.block);
+        visit(node2.handler);
+        visit(node2.finalizer);
+        return;
+      }
+      case "ForOfStatement": {
+        if (node2.await === true) {
+          const frame = `__sbxFrame${frameCounter++}`;
+          const body = node2.body;
+          edits.push({ start: node2.start, end: node2.start, text: `{ const ${frame} = ${CAPTURE}(); ` });
+          if (body.type === "BlockStatement") {
+            edits.push({ start: body.start + 1, end: body.start + 1, text: ` ${RESTORE}(${frame});` });
+          } else {
+            edits.push({ start: body.start, end: body.start, text: `{ ${RESTORE}(${frame}); ` });
+            edits.push({ start: body.end, end: body.end, text: " }" });
+          }
+          edits.push({ start: node2.end, end: node2.end, text: " }" });
+        }
+        visit(node2.left);
+        visit(node2.right);
+        visit(node2.body);
+        return;
+      }
+      case "CallExpression": {
+        const callee = node2.callee;
+        const args = node2.arguments;
+        const first = args[0];
+        if (callee.type === "Identifier" && callee.name === "eval" && first && first.type === "Literal" && typeof first.value === "string" && MAYBE_AWAIT.test(first.value)) {
+          const inner = transformAsyncContext(first.value, filename);
+          if (inner !== null) edits.push({ start: first.start, end: first.end, text: JSON.stringify(inner) });
+          for (const argument of args.slice(1)) visit(argument);
+          return;
+        }
+        break;
+      }
+    }
+    for (const [key, value] of Object.entries(node2)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      if (value && typeof value === "object") visit(value);
+    }
+  };
+  visit(root);
+  return edits;
+}
+function containsAwait(node2) {
+  if (Array.isArray(node2)) return node2.some(containsAwait);
+  if (!isNode4(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 (value && typeof value === "object" && containsAwait(value)) return true;
+  }
+  return false;
+}
+function applyEdits2(source, edits) {
+  const ordered = edits.map((edit, index) => ({ ...edit, index })).sort((a, b) => b.start - a.start || b.end - a.end || b.index - a.index);
+  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 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"]]
+};
+var ENTRY_FIELDS = {
+  import: ["module", "main"],
+  require: ["main", "module"]
+};
+var CommonJsEngine = class {
+  constructor(volume, options = {}) {
+    this.volume = volume;
+    this.cwd = options.cwd ?? "/";
+    this.builtins = { ...options.builtins };
+    this.globals = { ...options.globals };
+    this.aliases = { ...options.aliases };
+    this.overrides = { ...options.overrides };
+    const engine = this;
+    this.moduleApi = function Module(id = "", parent = null) {
+      Object.assign(this, { id, filename: id, exports: {}, loaded: false, parent, children: [] });
+    };
+    Object.assign(this.moduleApi, this.builtins.module);
+    this.moduleApi.Module = this.moduleApi;
+    this.moduleApi._extensions = {
+      ".js": (module, filename) => this.evaluate(module, this.readText(filename)),
+      ".json": (module, filename) => {
+        module.exports = JSON.parse(this.readText(filename));
+      },
+      ".node": (_module, filename) => {
+        throw dlopenFailed(filename);
+      }
+    };
+    this.moduleApi._cache = new Proxy(/* @__PURE__ */ Object.create(null), {
+      get: (_target, key) => typeof key === "string" ? this.cache.get(key) : void 0,
+      set: (_target, key, value) => {
+        this.cache.set(String(key), value);
+        return true;
+      },
+      deleteProperty: (_target, key) => this.cache.delete(String(key)),
+      ownKeys: () => [...this.cache.keys()],
+      getOwnPropertyDescriptor: (_target, key) => this.cache.has(String(key)) ? { enumerable: true, configurable: true, writable: true, value: this.cache.get(String(key)) } : void 0
+    });
+    this.moduleApi._resolveFilename = (request, parent) => this.resolve(request, parent?.filename || join(this.cwd, "__entry__.js"));
+    this.moduleApi._nodeModulePaths = (from) => {
+      const directory2 = resolve(this.cwd, String(from));
+      if (directory2 === "/") return ["/node_modules"];
+      const parts = segments(directory2);
+      const paths = [];
+      for (let index = parts.length; index > 0; index--) {
+        if (parts[index - 1] === "node_modules") continue;
+        paths.push(`/${[...parts.slice(0, index), "node_modules"].join("/")}`);
+      }
+      paths.push("/node_modules");
+      return paths;
+    };
+    this.moduleApi._load = (request, parent) => this.makeRequire(parent ?? Object.assign(new this.moduleApi(join(this.cwd, "__entry__.js")), { filename: join(this.cwd, "__entry__.js") }))(request);
+    this.moduleApi.prototype.require = function(request) {
+      const filename = engine.moduleApi._resolveFilename(request, this);
+      const builtin = engine.builtin(filename, this);
+      if (builtin.found) return builtin.value;
+      const target = engine.load(filename, this, false);
+      if (target.pending) throw requireOfAsyncModule(request);
+      return target.exports;
+    };
+    this.moduleApi.prototype._compile = function(source, filename) {
+      this.filename = filename;
+      engine.evaluate(this, source);
+    };
+    this.moduleApi.createRequire = (filename) => {
+      const path = String(filename).startsWith("file:") ? pathFromFileUrl(String(filename)) : String(filename);
+      if (!path.startsWith("/")) throw new TypeError("createRequire requires an absolute path or file URL");
+      return this.makeRequire(Object.assign(new this.moduleApi(path), { filename: path }));
+    };
+  }
+  volume;
+  cache = /* @__PURE__ */ new Map();
+  builtins;
+  globals;
+  aliases;
+  overrides;
   cwd;
   main = null;
   /** `package.json` per directory; resolution reads them constantly. */
   manifests = /* @__PURE__ */ new Map();
   evaluationDepth = 0;
+  moduleApi;
   /**
    * Is a module body running synchronously right now?
    *
@@ -25859,7 +26971,7 @@ var CommonJsEngine = class {
       specifier = pathFromFileUrl(specifier);
     }
     const builtin = this.builtin(specifier);
-    if (builtin.found) return specifier.replace(/^node:/, "");
+    if (builtin.found) return specifier;
     if (specifier.startsWith("#")) {
       const found = this.resolveImports(specifier, importer, kind);
       if (found) return found;
@@ -25892,17 +27004,14 @@ var CommonJsEngine = class {
       parent,
       children: []
     };
+    Object.setPrototypeOf(module, this.moduleApi.prototype);
     this.cache.set(filename, module);
     parent?.children.push(module);
     if (isMain) this.main = module;
     try {
-      if (filename.endsWith(".node")) {
-        throw dlopenFailed(filename);
-      } else if (filename.endsWith(".json")) {
-        module.exports = JSON.parse(this.readText(filename));
-      } else {
-        this.evaluate(module, this.readText(filename));
-      }
+      const extension = extname(filename);
+      const loader = this.moduleApi._extensions[extension] ?? this.moduleApi._extensions[".js"];
+      loader(module, filename);
       module.loaded = true;
       return module;
     } catch (error) {
@@ -25914,7 +27023,8 @@ var CommonJsEngine = class {
   evaluate(module, source) {
     if (source.startsWith("#!")) source = source.replace(/^#![^\n]*(?:\n|$)/, "");
     const transformed = transformEsm(source, module.filename);
-    const body = transformed?.code ?? source;
+    const esmBody = transformed?.code ?? source;
+    const body = transformAsyncContext(esmBody, module.filename) ?? esmBody;
     const code = transformed?.topLevelAwait ? `return (async () => {
 ${body}
 })();` : body;
@@ -25922,7 +27032,10 @@ ${body}
       [HELPERS.import, (specifier) => this.importNamespace(specifier, module)],
       [HELPERS.dynamic, (specifier) => this.dynamicImport(specifier, module)],
       [HELPERS.exportAll, exportAll],
-      [HELPERS.meta, this.importMeta(module)]
+      [HELPERS.meta, this.importMeta(module)],
+      [CONTEXT_HELPERS.capture, capture],
+      [CONTEXT_HELPERS.resume, resume],
+      [CONTEXT_HELPERS.restore, restore]
     ];
     const bindings = transformed?.esm ? [[HELPERS.exports, module.exports], ...helpers] : [
       ["exports", module.exports],
@@ -25955,15 +27068,12 @@ ${code}
   /** The `require` a module sees, complete with `resolve`, `cache` and `main`. */
   makeRequire(module) {
     const localRequire = ((specifier) => {
-      const builtin = this.builtin(specifier, module);
-      if (builtin.found) return builtin.value;
-      const target = this.load(this.resolve(specifier, module.filename, "require"), module, false);
-      if (target.pending) throw requireOfAsyncModule(specifier);
-      return target.exports;
+      return this.moduleApi.prototype.require.call(module, specifier);
     });
-    localRequire.resolve = (specifier) => this.resolve(specifier, module.filename, "require");
+    localRequire.resolve = (specifier) => this.moduleApi._resolveFilename(specifier, module);
     Object.defineProperty(localRequire, "main", { get: () => this.main });
-    localRequire.cache = Object.fromEntries(this.cache);
+    localRequire.cache = this.moduleApi._cache;
+    localRequire.extensions = this.moduleApi._extensions;
     return localRequire;
   }
   /**
@@ -26138,12 +27248,7 @@ ${code}
     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) {
-      return {
-        found: true,
-        value: { ...this.builtins.module, createRequire: () => this.makeRequire(importer) }
-      };
-    }
+    if (name === "module") return { found: true, value: this.moduleApi };
     return { found: true, value: this.builtins[name] };
   }
   exists(path) {
@@ -26251,6 +27356,490 @@ function splitSpecifier(specifier) {
   return { name: parts.slice(0, size).join("/"), subpath: parts.slice(size).join("/") };
 }
 
+// src/node/diagnostics-channel.ts
+function createDiagnosticsChannel() {
+  const channels2 = /* @__PURE__ */ new Map();
+  class Channel {
+    constructor(name) {
+      this.name = name;
+    }
+    name;
+    listeners = /* @__PURE__ */ new Set();
+    get hasSubscribers() {
+      return this.listeners.size > 0;
+    }
+    subscribe(fn) {
+      if (typeof fn !== "function") throw new TypeError("subscriber must be a function");
+      this.listeners.add(fn);
+    }
+    unsubscribe(fn) {
+      return this.listeners.delete(fn);
+    }
+    publish(message) {
+      for (const fn of [...this.listeners]) {
+        try {
+          fn(message, this.name);
+        } catch (error) {
+          queueMicrotask(() => {
+            throw error;
+          });
+        }
+      }
+    }
+  }
+  const channel = (name) => {
+    if (typeof name !== "string" && typeof name !== "symbol") throw new TypeError("channel name must be a string or symbol");
+    let result = channels2.get(name);
+    if (!result) {
+      result = new Channel(name);
+      channels2.set(name, result);
+    }
+    return result;
+  };
+  return {
+    Channel,
+    channel,
+    hasSubscribers: (name) => channels2.get(name)?.hasSubscribers ?? false,
+    subscribe: (name, fn) => channel(name).subscribe(fn),
+    unsubscribe: (name, fn) => channels2.get(name)?.unsubscribe(fn) ?? false
+  };
+}
+
+// src/node/ipc-channel.ts
+var IPC_CHANNEL_ENV = "SANDBOXEDJS_IPC_CHANNEL";
+var channels = /* @__PURE__ */ new Map();
+var closedChannels = /* @__PURE__ */ new Set();
+function newIpcChannelId() {
+  const random = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : Math.random().toString(36).slice(2);
+  return `ipc-${random}`;
+}
+var hostIpcTransport = {
+  attach(id, side, onMessage, onDisconnect) {
+    let channel = channels.get(id);
+    if (!channel && !closedChannels.has(id)) {
+      channel = { parent: { backlog: [] }, child: { backlog: [] }, closed: false };
+      channels.set(id, channel);
+    }
+    if (!channel || channel.closed) {
+      queueMicrotask(onDisconnect);
+      return { send: () => {
+      }, disconnect: () => {
+      } };
+    }
+    const own = channel[side];
+    const other = channel[side === "parent" ? "child" : "parent"];
+    own.deliver = onMessage;
+    own.disconnected = onDisconnect;
+    for (const message of own.backlog.splice(0)) queueMicrotask(() => onMessage(message));
+    return {
+      send(message) {
+        if (channel.closed) return;
+        const copy = message === void 0 ? void 0 : JSON.parse(JSON.stringify(message));
+        if (other.deliver) {
+          const deliver = other.deliver;
+          setTimeout(() => {
+            if (!channel.closed) deliver(copy);
+          }, 0);
+        } else {
+          other.backlog.push(copy);
+        }
+      },
+      disconnect() {
+        if (channel.closed) return;
+        channel.closed = true;
+        channels.delete(id);
+        closedChannels.add(id);
+        for (const end of [channel.parent, channel.child]) {
+          const notify = end.disconnected;
+          if (notify) setTimeout(notify, 0);
+        }
+      }
+    };
+  }
+};
+
+// src/node/vm-module.ts
+var contexts = /* @__PURE__ */ new WeakSet();
+var globalEval = eval;
+var filenameOf = (options) => typeof options === "string" ? options : options?.filename;
+var withSourceUrl = (code, options) => {
+  const filename = filenameOf(options);
+  return filename ? `${code}
+//# sourceURL=${filename.replace(/\s/g, "%20")}` : code;
+};
+function runWithScope(code, sandbox, options) {
+  const scope = new Proxy(sandbox, {
+    /* The wrapper's own variables must resolve to the wrapper, never to the
+     * context — otherwise `__sbx_vm_result__ = eval(…)` stores the completion
+     * value on the sandbox and the function returns undefined. */
+    has: (target, key) => !(typeof key === "string" && key.startsWith("__sbx_vm_")) && (key in target || !(key in globalThis)),
+    get: (target, key) => {
+      if (key === Symbol.unscopables) return void 0;
+      if (key in target) return target[key];
+      return globalThis[key];
+    },
+    set: (target, key, value) => {
+      target[key] = value;
+      return true;
+    }
+  });
+  const declared = topLevelDeclarations(code);
+  const evaluate = new Function(
+    "__sbx_vm_scope__",
+    "__sbx_vm_source__",
+    "__sbx_vm_names__",
+    "__sbx_vm_target__",
+    "var __sbx_vm_result__; with (__sbx_vm_scope__) { __sbx_vm_result__ = eval(__sbx_vm_source__); }for (var __sbx_vm_i__ = 0; __sbx_vm_i__ < __sbx_vm_names__.length; __sbx_vm_i__++) {  try { var __sbx_vm_value__ = eval(__sbx_vm_names__[__sbx_vm_i__]); if (__sbx_vm_value__ !== undefined || !(__sbx_vm_names__[__sbx_vm_i__] in __sbx_vm_target__)) __sbx_vm_target__[__sbx_vm_names__[__sbx_vm_i__]] = __sbx_vm_value__; } catch (e) {}}return __sbx_vm_result__;"
+  );
+  return evaluate(scope, withSourceUrl(code, options), declared, sandbox);
+}
+function topLevelDeclarations(code) {
+  const names = /* @__PURE__ */ new Set();
+  let depth = 0;
+  for (let index = 0; index < code.length; index++) {
+    const char = code[index];
+    if (char === "/" && code[index + 1] === "/") {
+      const end = code.indexOf("\n", index);
+      index = end === -1 ? code.length : end;
+      continue;
+    }
+    if (char === "/" && code[index + 1] === "*") {
+      const end = code.indexOf("*/", index + 2);
+      index = end === -1 ? code.length : end + 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      for (index++; index < code.length && code[index] !== char; index++) if (code[index] === "\\") index++;
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      continue;
+    }
+    if (char === "}") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth !== 0 || !/[A-Za-z_$]/.test(char) || index > 0 && /[\w$]/.test(code[index - 1])) continue;
+    const rest = code.slice(index);
+    const fn = /^(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/.exec(rest);
+    if (fn) {
+      names.add(fn[1]);
+      continue;
+    }
+    const declaration = /^var\s+([^;]+)/.exec(rest);
+    if (declaration) {
+      for (const part of declaration[1].split(",")) {
+        const name = /^\s*([A-Za-z_$][\w$]*)/.exec(part);
+        if (name) names.add(name[1]);
+      }
+    }
+  }
+  return [...names];
+}
+function createContext2(sandbox = {}) {
+  contexts.add(sandbox);
+  if (!("globalThis" in sandbox)) Object.defineProperty(sandbox, "globalThis", { value: sandbox, writable: true, configurable: true });
+  return sandbox;
+}
+function isContext(value) {
+  return typeof value === "object" && value !== null && contexts.has(value);
+}
+function runInThisContext(code, options) {
+  return globalEval(withSourceUrl(String(code), options));
+}
+function runInContext(code, context, options) {
+  if (!isContext(context)) {
+    throw Object.assign(new TypeError('The "contextifiedObject" argument must be an vm.Context'), { code: "ERR_INVALID_ARG_TYPE" });
+  }
+  return runWithScope(String(code), context, options);
+}
+function runInNewContext(code, sandbox, options) {
+  return runWithScope(String(code), createContext2(sandbox ?? {}), options);
+}
+var Script = class {
+  #code;
+  #options;
+  constructor(code, options = {}) {
+    this.#code = String(code);
+    this.#options = typeof options === "string" ? { filename: options } : { ...options };
+    new Function(this.#code.replace(/^#!.*/, ""));
+  }
+  runInThisContext(options) {
+    return runInThisContext(this.#code, { ...this.#options, ...options });
+  }
+  runInContext(context, options) {
+    return runInContext(this.#code, context, { ...this.#options, ...options });
+  }
+  runInNewContext(sandbox, options) {
+    return runInNewContext(this.#code, sandbox, { ...this.#options, ...options });
+  }
+  createCachedData() {
+    return new Uint8Array();
+  }
+};
+function compileFunction(code, params = [], options = {}) {
+  const source = withSourceUrl(String(code), options.filename);
+  if (options.parsingContext && isContext(options.parsingContext)) {
+    return runWithScope(`(function (${params.join(", ")}) {
+${source}
+})`, options.parsingContext, void 0);
+  }
+  return new Function(...params, source);
+}
+var vmModule = {
+  Script,
+  createContext: createContext2,
+  isContext,
+  runInThisContext,
+  runInContext,
+  runInNewContext,
+  compileFunction,
+  constants: {
+    USE_MAIN_CONTEXT_DEFAULT_LOADER: /* @__PURE__ */ Symbol("vm_dynamic_import_main_context_default"),
+    DONT_CONTEXTIFY: /* @__PURE__ */ Symbol("vm_context_no_contextify")
+  },
+  measureMemory: async () => ({ total: { jsMemoryEstimate: 0, jsMemoryRange: [0, 0] } })
+};
+var vm_module_default = vmModule;
+function define(proto, name, get) {
+  if (Object.getOwnPropertyDescriptor(proto, name)) return;
+  Object.defineProperty(proto, name, { configurable: true, enumerable: false, get });
+}
+var installed = false;
+function installWebStreamAdapters(stream) {
+  const { Readable, Writable, Duplex } = stream;
+  const toError = (reason) => reason instanceof Error ? reason : new Error(reason === void 0 ? "aborted" : String(reason));
+  const readableToWeb = (source, options = {}) => {
+    let onData;
+    return new ReadableStream({
+      start(controller) {
+        const objectMode = Boolean(source?._readableState?.objectMode);
+        onData = (chunk) => {
+          const value = objectMode || !(chunk instanceof Uint8Array) && typeof chunk !== "string" ? chunk : typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+          controller.enqueue(value);
+          if ((controller.desiredSize ?? 1) <= 0) source.pause();
+        };
+        source.on("data", onData);
+        source.once("end", () => {
+          try {
+            controller.close();
+          } catch {
+          }
+        });
+        source.once("error", (error) => {
+          try {
+            controller.error(error);
+          } catch {
+          }
+        });
+        source.once("close", () => {
+          if (!source.readableEnded && !source._readableState?.endEmitted) {
+            try {
+              controller.error(new Error("The stream was destroyed before it ended"));
+            } catch {
+            }
+          }
+        });
+      },
+      pull() {
+        if (typeof source.isPaused === "function" && source.isPaused()) source.resume();
+      },
+      cancel(reason) {
+        if (onData) source.off("data", onData);
+        source.destroy(reason === void 0 ? void 0 : toError(reason));
+      }
+    }, options.strategy ?? { highWaterMark: 1 });
+  };
+  const readableFromWeb = (web, options = {}) => {
+    const reader = web.getReader();
+    let reading = false;
+    const readable = new Readable({
+      ...options,
+      read() {
+        if (reading) return;
+        reading = true;
+        void (async () => {
+          try {
+            for (; ; ) {
+              const { done, value } = await reader.read();
+              if (done) {
+                readable.push(null);
+                return;
+              }
+              const chunk = value instanceof Uint8Array && !options.objectMode ? Buffer2.from(value.buffer, value.byteOffset, value.byteLength) : value;
+              if (!readable.push(chunk)) return;
+            }
+          } catch (error) {
+            readable.destroy(toError(error));
+          } finally {
+            reading = false;
+          }
+        })();
+      },
+      destroy(error, callback) {
+        reader.cancel(error ?? void 0).catch(() => {
+        }).finally(() => callback(error));
+      }
+    });
+    return readable;
+  };
+  const writableToWeb = (sink) => new WritableStream({
+    write(chunk) {
+      return new Promise((resolve3, reject) => {
+        const ok2 = sink.write(chunk, (error) => {
+          if (error) reject(error);
+        });
+        if (ok2) resolve3();
+        else {
+          const onDrain = () => {
+            sink.off("error", onError);
+            resolve3();
+          };
+          const onError = (error) => {
+            sink.off("drain", onDrain);
+            reject(error);
+          };
+          sink.once("drain", onDrain);
+          sink.once("error", onError);
+        }
+      });
+    },
+    close() {
+      return new Promise((resolve3, reject) => {
+        sink.once("error", reject);
+        sink.end(() => resolve3());
+      });
+    },
+    abort(reason) {
+      sink.destroy(toError(reason));
+    }
+  });
+  const writableFromWeb = (web, options = {}) => {
+    const writer = web.getWriter();
+    return new Writable({
+      ...options,
+      write(chunk, _encoding, callback) {
+        writer.write(chunk).then(() => callback(), (error) => callback(toError(error)));
+      },
+      final(callback) {
+        writer.close().then(() => callback(), (error) => callback(toError(error)));
+      },
+      destroy(error, callback) {
+        (error ? writer.abort(error) : writer.close()).catch(() => {
+        }).finally(() => callback(error));
+      }
+    });
+  };
+  const define2 = (target, name, value) => {
+    if (typeof target[name] === "function") return;
+    Object.defineProperty(target, name, { configurable: true, writable: true, value });
+  };
+  define2(Readable, "toWeb", readableToWeb);
+  define2(Readable, "fromWeb", readableFromWeb);
+  define2(Writable, "toWeb", writableToWeb);
+  define2(Writable, "fromWeb", writableFromWeb);
+  define2(Duplex, "toWeb", (duplex) => ({ readable: readableToWeb(duplex), writable: writableToWeb(duplex) }));
+  define2(Duplex, "fromWeb", (pair, options = {}) => {
+    const readable = readableFromWeb(pair.readable, options);
+    const writable = writableFromWeb(pair.writable, options);
+    const duplex = new Duplex({
+      ...options,
+      read() {
+        readable.resume();
+      },
+      write(chunk, encoding, callback) {
+        writable.write(chunk, encoding, callback);
+      },
+      final(callback) {
+        writable.end(callback);
+      }
+    });
+    readable.on("data", (chunk) => {
+      if (!duplex.push(chunk)) readable.pause();
+    });
+    readable.once("end", () => duplex.push(null));
+    readable.once("error", (error) => duplex.destroy(error));
+    writable.once("error", (error) => duplex.destroy(error));
+    return duplex;
+  });
+}
+function installStreamCompat() {
+  if (installed) return;
+  installed = true;
+  const stream = streamModule5;
+  const writable = (self) => self._writableState;
+  const readable = (self) => self._readableState;
+  for (const proto of [stream.Writable.prototype, stream.Duplex.prototype]) {
+    define(proto, "writableEnded", function() {
+      return Boolean(writable(this)?.ending);
+    });
+    define(proto, "writableFinished", function() {
+      return Boolean(writable(this)?.finished);
+    });
+    define(proto, "writableNeedDrain", function() {
+      const state = writable(this);
+      return Boolean(state && !state.destroyed && !state.ending && state.needDrain);
+    });
+    define(proto, "writableCorked", function() {
+      return Number(writable(this)?.corked ?? 0);
+    });
+    define(proto, "writableObjectMode", function() {
+      return Boolean(writable(this)?.objectMode);
+    });
+    define(proto, "writableAborted", function() {
+      const state = writable(this);
+      return Boolean(state && state.destroyed && !state.finished);
+    });
+  }
+  for (const proto of [stream.Readable.prototype, stream.Duplex.prototype]) {
+    define(proto, "readableEnded", function() {
+      return Boolean(readable(this)?.endEmitted);
+    });
+    define(proto, "readableAborted", function() {
+      const state = readable(this);
+      return Boolean(state && state.destroyed && !state.endEmitted);
+    });
+    define(proto, "readableDidRead", function() {
+      return Boolean(readable(this)?.dataEmitted ?? readable(this)?.readingMore);
+    });
+  }
+  const writableProto = stream.Writable.prototype;
+  const originalEnd = writableProto.end;
+  const originalEmit = writableProto.emit;
+  const inEnd = /* @__PURE__ */ new WeakSet();
+  writableProto.end = function(...args) {
+    inEnd.add(this);
+    try {
+      return originalEnd.apply(this, args);
+    } finally {
+      inEnd.delete(this);
+    }
+  };
+  writableProto.emit = function(event, ...args) {
+    if (event === "finish" && inEnd.has(this)) {
+      const self = this;
+      const later = globalThis.process?.nextTick;
+      const deliver = () => {
+        originalEmit.call(self, event, ...args);
+      };
+      if (typeof later === "function") later(deliver);
+      else queueMicrotask(deliver);
+      return true;
+    }
+    return originalEmit.call(this, event, ...args);
+  };
+  installWebStreamAdapters(stream);
+  for (const proto of [stream.Writable.prototype, stream.Readable.prototype, stream.Duplex.prototype]) {
+    define(proto, "closed", function() {
+      return Boolean(writable(this)?.destroyed || readable(this)?.destroyed);
+    });
+    define(proto, "errored", function() {
+      return this.__sbxErrored ?? null;
+    });
+  }
+}
+
 // src/node/readable-from.ts
 function createReadableFrom(Readable) {
   return function from(source, options = {}) {
@@ -26296,8 +27885,134 @@ function createReadableFrom(Readable) {
     return stream;
   };
 }
-function installReadableFrom(streamModule5) {
-  streamModule5.Readable.from = createReadableFrom(streamModule5.Readable);
+function installReadableFrom(streamModule6) {
+  streamModule6.Readable.from = createReadableFrom(streamModule6.Readable);
+}
+
+// src/node/parse-args.ts
+function argError(code, message) {
+  return Object.assign(new TypeError(message), { code });
+}
+function parseArgs2(config2 = {}) {
+  const args = config2.args ?? globalThis.process?.argv?.slice(2) ?? [];
+  const options = config2.options ?? {};
+  const strict = config2.strict ?? true;
+  const allowPositionals = config2.allowPositionals ?? !strict;
+  const allowNegative = config2.allowNegative ?? false;
+  const byShort = /* @__PURE__ */ new Map();
+  for (const [name, option] of Object.entries(options)) {
+    if (option.type !== "string" && option.type !== "boolean") {
+      throw argError("ERR_INVALID_ARG_VALUE", `The property 'options.${name}.type' must be one of: 'string', 'boolean'`);
+    }
+    if (option.short !== void 0) {
+      if (option.short.length !== 1) {
+        throw argError("ERR_INVALID_ARG_VALUE", `The property 'options.${name}.short' must be a single character`);
+      }
+      byShort.set(option.short, name);
+    }
+  }
+  const tokens = [];
+  const takesValue = (name) => options[name]?.type === "string";
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      tokens.push({ kind: "option-terminator", index });
+      for (let rest = index + 1; rest < args.length; rest++) tokens.push({ kind: "positional", index: rest, value: args[rest] });
+      break;
+    }
+    if (arg.startsWith("--") && arg.length > 2) {
+      const equals = arg.indexOf("=");
+      if (equals !== -1) {
+        tokens.push({ kind: "option", name: arg.slice(2, equals), rawName: arg.slice(0, equals), index, value: arg.slice(equals + 1), inlineValue: true });
+        continue;
+      }
+      const name = arg.slice(2);
+      if (takesValue(name) && index + 1 < args.length) {
+        tokens.push({ kind: "option", name, rawName: arg, index, value: args[index + 1], inlineValue: false });
+        index++;
+      } else {
+        tokens.push({ kind: "option", name, rawName: arg, index, value: void 0, inlineValue: void 0 });
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1) {
+      for (let at = 1; at < arg.length; at++) {
+        const short = arg[at];
+        const name = byShort.get(short) ?? short;
+        if (takesValue(name)) {
+          if (at + 1 < arg.length) {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: arg.slice(at + 1), inlineValue: true });
+          } else if (index + 1 < args.length) {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: args[index + 1], inlineValue: false });
+            index++;
+          } else {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: void 0, inlineValue: void 0 });
+          }
+          break;
+        }
+        tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: void 0, inlineValue: void 0 });
+      }
+      continue;
+    }
+    tokens.push({ kind: "positional", index, value: arg });
+  }
+  const values = /* @__PURE__ */ Object.create(null);
+  const positionals = [];
+  const store = (name, value) => {
+    if (options[name]?.multiple) {
+      const list = values[name] ?? [];
+      list.push(value);
+      values[name] = list;
+    } else {
+      values[name] = value;
+    }
+  };
+  for (const token of tokens) {
+    if (token.kind === "option-terminator") continue;
+    if (token.kind === "positional") {
+      if (!allowPositionals) {
+        throw argError("ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", `Unexpected argument '${token.value}'. This command does not take positional arguments`);
+      }
+      positionals.push(token.value);
+      continue;
+    }
+    let name = token.name;
+    let negated = false;
+    if (allowNegative && name.startsWith("no-") && token.rawName.startsWith("--") && options[name.slice(3)]?.type === "boolean") {
+      name = name.slice(3);
+      negated = true;
+    }
+    const option = options[name];
+    if (!option) {
+      if (strict) {
+        throw argError(
+          "ERR_PARSE_ARGS_UNKNOWN_OPTION",
+          `Unknown option '${token.rawName}'${allowPositionals ? `. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- ${JSON.stringify(token.rawName)}'` : ""}`
+        );
+      }
+      store(name, token.value ?? true);
+      continue;
+    }
+    if (option.type === "string") {
+      if (token.value === void 0) {
+        if (strict) throw argError("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", `Option '${token.rawName} <value>' argument missing`);
+        store(name, true);
+        continue;
+      }
+      store(name, token.value);
+    } else {
+      if (token.inlineValue && strict) {
+        throw argError("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", `Option '${token.rawName}' does not take an argument`);
+      }
+      store(name, !negated);
+    }
+  }
+  for (const [name, option] of Object.entries(options)) {
+    if (option.default !== void 0 && values[name] === void 0) {
+      values[name] = Array.isArray(option.default) ? option.default.slice() : option.default;
+    }
+  }
+  return config2.tokens ? { values, positionals, tokens } : { values, positionals };
 }
 
 // src/node/util-module.ts
@@ -26328,8 +28043,9 @@ function render(value, depth, seen, options) {
   if (value === null) return "null";
   const object = value;
   const custom = object[customInspect];
-  if (typeof custom === "function") {
-    return String(custom.call(object, depth, options));
+  if (options.customInspect !== false && typeof custom === "function") {
+    const result = custom.call(object, depth, options, inspect);
+    if (result !== object) return typeof result === "string" ? result : render(result, depth, seen, options);
   }
   if (seen.has(object)) return "[Circular *1]";
   if (depth < 0) return Array.isArray(object) ? "[Array]" : "[Object]";
@@ -26664,6 +28380,7 @@ var legacy = {
 inspect.custom = customInspect;
 var utilModule = {
   parseEnv,
+  parseArgs: parseArgs2,
   format,
   formatWithOptions,
   inspect,
@@ -26767,12 +28484,12 @@ function matches2(error, expected) {
   return String(error) === String(expected);
 }
 function throws(block, expected, message) {
-  const [error, threw] = capture(block);
+  const [error, threw] = capture2(block);
   if (!threw) fail(void 0, expected, message ?? "Missing expected exception.", "throws");
   if (!matches2(error, expected)) throw error;
 }
 function doesNotThrow(block, expected, message) {
-  const [error, threw] = capture(block);
+  const [error, threw] = capture2(block);
   if (!threw) return;
   if (matches2(error, expected)) {
     fail(error, expected, message ?? "Got unwanted exception.", "doesNotThrow");
@@ -26792,7 +28509,7 @@ async function doesNotReject(block, expected, message) {
   }
   throw error;
 }
-function capture(block) {
+function capture2(block) {
   try {
     block();
     return [void 0, false];
@@ -26848,13 +28565,17 @@ var assertModule = Object.assign(ok, base, {
   })
 });
 var assert_module_default = assertModule;
+var Z_NO_FLUSH = 0;
+var Z_SYNC_FLUSH = 2;
+var Z_FULL_FLUSH = 3;
+var Z_FINISH = 4;
 var bytes = (data) => {
   if (typeof data === "string") return new Uint8Array(Buffer2.from(data, "utf8"));
   if (data instanceof ArrayBuffer) return new Uint8Array(data);
   return data;
 };
-function codec(name, run2) {
-  const sync2 = (data, options) => Buffer2.from(run2(bytes(data), options));
+function codec(run3) {
+  const sync2 = (data, options) => Buffer2.from(run3(bytes(data), options));
   const async_ = (data, options, callback) => {
     const done = typeof options === "function" ? options : callback;
     const settings = typeof options === "function" ? void 0 : options;
@@ -26866,37 +28587,159 @@ function codec(name, run2) {
       }
     });
   };
-  const Stream = class extends streamModule4.Transform {
-    chunks = [];
-    options;
-    constructor(options) {
-      super();
-      this.options = options;
+  return { sync: sync2, async: async_ };
+}
+function createEngine(mode, options) {
+  const windowBits = typeof options.windowBits === "number" ? options.windowBits : 15;
+  const level = typeof options.level === "number" ? options.level : -1;
+  const memLevel = typeof options.memLevel === "number" ? options.memLevel : 8;
+  const strategy = typeof options.strategy === "number" ? options.strategy : 0;
+  const deflateOptions = { level, memLevel, strategy, windowBits };
+  switch (mode) {
+    case "Deflate":
+      return new Deflate$1(deflateOptions);
+    case "Gzip":
+      return new Deflate$1({ ...deflateOptions, gzip: true });
+    case "DeflateRaw":
+      return new Deflate$1({ ...deflateOptions, raw: true });
+    case "Inflate":
+      return new Inflate$1({ windowBits });
+    case "InflateRaw":
+      return new Inflate$1({ raw: true, windowBits });
+    /* zlib's `windowBits + 16` means gzip only; `+ 32` detects gzip or zlib
+     * from the header, which is exactly `Unzip`. */
+    case "Gunzip":
+      return new Inflate$1({ windowBits: windowBits + 16 });
+    case "Unzip":
+      return new Inflate$1({ windowBits: windowBits + 32 });
+  }
+}
+function zlibError(engine) {
+  const codes = { [-2]: "Z_STREAM_ERROR", [-3]: "Z_DATA_ERROR", [-4]: "Z_MEM_ERROR", [-5]: "Z_BUF_ERROR", 2: "Z_NEED_DICT" };
+  return Object.assign(new Error(engine.msg || "zlib error"), { errno: engine.err, code: codes[engine.err] ?? "Z_DATA_ERROR" });
+}
+function zlibClass(mode) {
+  const ZlibStream = class extends streamModule5.Transform {
+    bytesWritten = 0;
+    _handle;
+    _engine;
+    _settings;
+    _output = [];
+    _finished = false;
+    constructor(options = {}) {
+      super(options);
+      this._settings = options;
+      this._engine = this._attach(createEngine(mode, options));
+      this._handle = { close: () => {
+        this._handle = null;
+      } };
+    }
+    _attach(engine) {
+      engine.onData = (chunk) => this._output.push(chunk);
+      engine.onEnd = (status) => {
+        const state = engine;
+        if (status !== 0) {
+          state.err = status;
+          state.msg = state.strm?.msg ?? state.msg;
+        }
+      };
+      return engine;
+    }
+    /** Code one chunk now and hand back what it produced. */
+    _processChunk(chunk, flushFlag = Z_NO_FLUSH, callback) {
+      const input = typeof chunk === "string" ? Buffer2.from(chunk) : chunk;
+      try {
+        const out = this._code(input, flushFlag);
+        if (callback) queueMicrotask(() => callback(null, out));
+        return out;
+      } catch (error) {
+        if (callback) {
+          queueMicrotask(() => callback(error));
+          return Buffer2.alloc(0);
+        }
+        throw error;
+      }
+    }
+    _code(input, flushFlag) {
+      if (this._finished) {
+        return Buffer2.alloc(0);
+      }
+      this.bytesWritten += input.length;
+      const engine = this._engine;
+      if (input.length > 0 || flushFlag !== Z_NO_FLUSH) {
+        const mapped = flushFlag === Z_FINISH ? Z_FINISH : flushFlag === Z_FULL_FLUSH ? Z_FULL_FLUSH : flushFlag === Z_SYNC_FLUSH ? Z_SYNC_FLUSH : Z_NO_FLUSH;
+        engine.push(input, mapped);
+        if (engine.err) throw zlibError(engine);
+      }
+      if (engine.ended || flushFlag === Z_FINISH) this._finished = engine.ended === true || mode.startsWith("Deflate") || mode === "Gzip";
+      const produced = this._output;
+      this._output = [];
+      return produced.length === 1 ? Buffer2.from(produced[0]) : Buffer2.concat(produced.map((part) => Buffer2.from(part)));
     }
     _transform(chunk, _encoding, next) {
-      this.chunks.push(Buffer2.from(chunk));
-      next();
+      try {
+        const out = this._code(chunk, typeof this._settings.flush === "number" ? this._settings.flush : Z_NO_FLUSH);
+        if (out.length) this.push(out);
+        next();
+      } catch (error) {
+        next(error);
+      }
     }
     _flush(next) {
       try {
-        this.push(sync2(Buffer2.concat(this.chunks), this.options));
+        const finish = typeof this._settings.finishFlush === "number" ? this._settings.finishFlush : Z_FINISH;
+        const out = this._code(new Uint8Array(0), finish);
+        if (out.length) this.push(out);
         next();
       } catch (error) {
         next(error);
       }
     }
+    /** `flush([kind], callback)`: emit what is pending without ending the stream. */
+    flush(kind, callback) {
+      const done = typeof kind === "function" ? kind : callback;
+      const flag = typeof kind === "number" ? kind : Z_FULL_FLUSH;
+      try {
+        const out = this._code(new Uint8Array(0), flag);
+        if (out.length) this.push(out);
+      } catch (error) {
+        this.destroy(error);
+      }
+      if (done) queueMicrotask(done);
+    }
+    reset() {
+      this._engine = this._attach(createEngine(mode, this._settings));
+      this._output = [];
+      this._finished = false;
+    }
+    params(level, strategy, callback) {
+      this._settings.level = level;
+      this._settings.strategy = strategy;
+      if (callback) queueMicrotask(callback);
+    }
+    close(callback) {
+      this._handle?.close();
+      if (callback) this.once("close", callback);
+      if (!this.destroyed) this.destroy();
+    }
   };
-  Object.defineProperty(Stream, "name", { value: name });
-  return { sync: sync2, async: async_, Stream };
-}
-var gzipCodec = codec("Gzip", (input, options) => gzip$1(input, options));
-var gunzipCodec = codec("Gunzip", (input) => ungzip(input));
-var deflateCodec = codec("Deflate", (input, options) => deflate$1(input, options));
-var inflateCodec = codec("Inflate", (input) => inflate$1(input));
-var deflateRawCodec = codec("DeflateRaw", (input, options) => deflateRaw(input, options));
-var inflateRawCodec = codec("InflateRaw", (input) => inflateRaw(input));
+  Object.defineProperty(ZlibStream, "name", { value: mode });
+  return ZlibStream;
+}
+var Gzip = zlibClass("Gzip");
+var Gunzip = zlibClass("Gunzip");
+var Deflate = zlibClass("Deflate");
+var Inflate = zlibClass("Inflate");
+var DeflateRaw = zlibClass("DeflateRaw");
+var InflateRaw = zlibClass("InflateRaw");
+var Unzip = zlibClass("Unzip");
+var gzipCodec = codec((input, options) => gzip$1(input, options));
+var gunzipCodec = codec((input) => ungzip(input));
+var deflateCodec = codec((input, options) => deflate$1(input, options));
+var inflateCodec = codec((input) => inflate$1(input));
+var deflateRawCodec = codec((input, options) => deflateRaw(input, options));
+var inflateRawCodec = codec((input) => inflateRaw(input));
 var unzipCodec = codec(
-  "Unzip",
   (input) => input[0] === 31 && input[1] === 139 ? ungzip(input) : inflate$1(input)
 );
 function brotliUnavailable(name) {
@@ -26907,27 +28750,34 @@ function brotliUnavailable(name) {
   throw error;
 }
 var zlibModule = {
+  Gzip,
+  Gunzip,
+  Deflate,
+  Inflate,
+  DeflateRaw,
+  InflateRaw,
+  Unzip,
   gzipSync: gzipCodec.sync,
   gzip: gzipCodec.async,
-  createGzip: (o) => new gzipCodec.Stream(o),
+  createGzip: (o) => new Gzip(o),
   gunzipSync: gunzipCodec.sync,
   gunzip: gunzipCodec.async,
-  createGunzip: (o) => new gunzipCodec.Stream(o),
+  createGunzip: (o) => new Gunzip(o),
   deflateSync: deflateCodec.sync,
   deflate: deflateCodec.async,
-  createDeflate: (o) => new deflateCodec.Stream(o),
+  createDeflate: (o) => new Deflate(o),
   inflateSync: inflateCodec.sync,
   inflate: inflateCodec.async,
-  createInflate: (o) => new inflateCodec.Stream(o),
+  createInflate: (o) => new Inflate(o),
   deflateRawSync: deflateRawCodec.sync,
   deflateRaw: deflateRawCodec.async,
-  createDeflateRaw: (o) => new deflateRawCodec.Stream(o),
+  createDeflateRaw: (o) => new DeflateRaw(o),
   inflateRawSync: inflateRawCodec.sync,
   inflateRaw: inflateRawCodec.async,
-  createInflateRaw: (o) => new inflateRawCodec.Stream(o),
+  createInflateRaw: (o) => new InflateRaw(o),
   unzipSync: unzipCodec.sync,
   unzip: unzipCodec.async,
-  createUnzip: (o) => new unzipCodec.Stream(o),
+  createUnzip: (o) => new Unzip(o),
   brotliCompressSync: () => brotliUnavailable("brotliCompressSync"),
   brotliDecompressSync: () => brotliUnavailable("brotliDecompressSync"),
   brotliCompress: () => brotliUnavailable("brotliCompress"),
@@ -27020,7 +28870,8 @@ var url_module_default = urlModule;
 
 // src/node/core-modules.ts
 init_path();
-var VirtualIncomingMessage = class extends streamModule4.Readable {
+installStreamCompat();
+var VirtualIncomingMessage = class extends streamModule5.Readable {
   method;
   url;
   headers;
@@ -27060,7 +28911,7 @@ var VirtualIncomingMessage = class extends streamModule4.Readable {
     return this;
   }
 };
-var VirtualServerResponse = class extends streamModule4.Writable {
+var VirtualServerResponse = class extends streamModule5.Writable {
   statusCode = 200;
   statusMessage = "OK";
   headersSent = false;
@@ -27086,16 +28937,38 @@ var VirtualServerResponse = class extends streamModule4.Writable {
   }
   _final(callback) {
     this.headersSent = true;
+    this.settle();
+    this.once("finish", () => queueMicrotask(() => {
+      if (!this.destroyed) this.destroy();
+    }));
+    callback();
+  }
+  /*
+   * A destroyed response still answers.
+   *
+   * Node sends whatever was written and closes the socket; the caller sees a
+   * response, however short. Here the caller is waiting on `completed`, which
+   * only `_final` used to settle — so a response torn down before `end()`
+   * (an aborted stream, `res.destroy(err)` from a web-stream pipe) left the
+   * request unanswered forever while the server had already moved on.
+   */
+  _destroy(error, callback) {
+    this.settle();
+    callback(error);
+  }
+  settled = false;
+  settle() {
+    if (this.settled) return;
+    this.settled = true;
     if (this.sendDate && !this.hasHeader("date")) this.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString());
     const headers = {};
-    for (const { name, value } of this.headers.values()) headers[name] = Array.isArray(value) ? value.join(", ") : value;
+    for (const [key, { value }] of this.headers) headers[key] = Array.isArray(value) ? value.join(", ") : value;
     this.resolve({
       statusCode: this.statusCode,
       statusMessage: this.statusMessage || STATUS_CODES[this.statusCode] || "",
       headers,
       body: new Uint8Array(Buffer2.concat(this.chunks))
     });
-    callback();
   }
   setHeader(name, value) {
     validateHeaderName(name);
@@ -27104,9 +28977,9 @@ var VirtualServerResponse = class extends streamModule4.Writable {
     return this;
   }
   appendHeader(name, value) {
-    const current = this.getHeader(name);
+    const current2 = this.getHeader(name);
     const next = Array.isArray(value) ? [...value] : [String(value)];
-    return this.setHeader(name, current === void 0 ? next : [...Array.isArray(current) ? current : [String(current)], ...next]);
+    return this.setHeader(name, current2 === void 0 ? next : [...Array.isArray(current2) ? current2 : [String(current2)], ...next]);
   }
   getHeader(name) {
     return this.headers.get(name.toLowerCase())?.value;
@@ -27134,6 +29007,25 @@ var VirtualServerResponse = class extends streamModule4.Writable {
   flushHeaders() {
     this.headersSent = true;
   }
+  /*
+   * Node's `OutgoingMessage` internals that middleware reaches past the public
+   * API for. `compression` — which Next's dev server wraps every response in —
+   * calls `_implicitHeader()` from its own `write`/`end` to commit the status
+   * line before the first byte, the way Node's `write` does internally.
+   */
+  _implicitHeader() {
+    if (!this.headersSent) this.writeHead(this.statusCode);
+  }
+  get _header() {
+    return this.headersSent ? `HTTP/1.1 ${this.statusCode} ${this.statusMessage}\r
+` : null;
+  }
+  get finished() {
+    return this.writableEnded;
+  }
+  chunkedEncoding = false;
+  useChunkedEncodingByDefault = true;
+  strictContentLength = false;
   writeContinue() {
   }
   writeProcessing() {
@@ -27145,7 +29037,7 @@ var VirtualServerResponse = class extends streamModule4.Writable {
     return this;
   }
 };
-var VirtualSocket = class extends streamModule4.Duplex {
+var VirtualSocket = class extends streamModule5.Duplex {
   remoteAddress = "127.0.0.1";
   remotePort = 0;
   localAddress = "127.0.0.1";
@@ -27350,7 +29242,7 @@ var VirtualHttpRouter = class {
     };
   }
 };
-var VirtualClientResponse = class extends streamModule4.Readable {
+var VirtualClientResponse = class extends streamModule5.Readable {
   constructor(statusCode, statusMessage, headers, body) {
     super();
     this.statusCode = statusCode;
@@ -27417,7 +29309,7 @@ function resolveTarget(input, overrides, defaultProtocol) {
 function isLoopback2(hostname) {
   return isLoopbackHostname(hostname);
 }
-var VirtualClientRequest = class extends streamModule4.Writable {
+var VirtualClientRequest = class extends streamModule5.Writable {
   constructor(target, router, fetchImpl, trackRequest, loopback = void 0) {
     super();
     this.target = target;
@@ -27647,6 +29539,7 @@ function createVirtualFetch(router, options = {}) {
     const request = new Request(input, init);
     const url = new URL(request.url);
     const release = options.trackRequest?.();
+    let handedOff = false;
     try {
       if (!isLoopback2(url.hostname)) {
         if (!options.fetch) {
@@ -27654,7 +29547,10 @@ function createVirtualFetch(router, options = {}) {
             cause: Object.assign(new Error(`getaddrinfo ENOTFOUND ${url.hostname}`), { code: "ENOTFOUND" })
           });
         }
-        return await options.fetch(request);
+        const response = await options.fetch(request);
+        if (!release || !response.body) return response;
+        handedOff = true;
+        return releaseWhenConsumed(response, release);
       }
       const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
       const headers = {};
@@ -27694,9 +29590,43 @@ function createVirtualFetch(router, options = {}) {
         headers: responseHeaders
       });
     } finally {
-      release?.();
+      if (!handedOff) release?.();
+    }
+  });
+}
+function releaseWhenConsumed(response, release) {
+  let released = false;
+  const once = () => {
+    if (!released) {
+      released = true;
+      release();
+    }
+  };
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          once();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+        once();
+      }
+    },
+    cancel(reason) {
+      once();
+      return reader.cancel(reason);
     }
   });
+  const wrapped = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  Object.defineProperty(wrapped, "url", { value: response.url });
+  Object.defineProperty(wrapped, "redirected", { value: response.redirected });
+  return wrapped;
 }
 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" });
@@ -27791,12 +29721,12 @@ function invoke(host2, fn, context, timeout) {
 function createMockTracker() {
   const restorers = [];
   const fn = (original = () => void 0, implementation = original) => {
-    let current = implementation;
+    let current2 = implementation;
     const once = /* @__PURE__ */ new Map();
     const calls = [];
     const mocked = function(...args) {
       const index = calls.length;
-      const chosen = once.get(index) ?? current;
+      const chosen = once.get(index) ?? current2;
       once.delete(index);
       const call = { arguments: args, result: void 0, error: void 0, this: this };
       calls.push(call);
@@ -27816,13 +29746,13 @@ function createMockTracker() {
           calls.length = 0;
         },
         mockImplementation: (next) => {
-          current = next;
+          current2 = next;
         },
         mockImplementationOnce: (next, onCall) => {
           once.set(onCall ?? calls.length, next);
         },
         restore: () => {
-          current = original;
+          current2 = original;
         }
       }
     });
@@ -27835,21 +29765,21 @@ function createMockTracker() {
     }
     const mocked = fn(original, implementation ?? original);
     object[name] = mocked;
-    const restore = () => {
+    const restore2 = () => {
       object[name] = original;
     };
-    mocked.mock.restore = restore;
-    restorers.push(restore);
+    mocked.mock.restore = restore2;
+    restorers.push(restore2);
     return mocked;
   };
   return {
     fn,
     method,
     reset: () => {
-      for (const restore of restorers.splice(0)) restore();
+      for (const restore2 of restorers.splice(0)) restore2();
     },
     restoreAll: () => {
-      for (const restore of restorers.splice(0)) restore();
+      for (const restore2 of restorers.splice(0)) restore2();
     }
   };
 }
@@ -28430,8 +30360,50 @@ function concat6(parts) {
   return joined;
 }
 var ChildProcess = class extends EventEmitter4 {
-  stdout = new streamModule4.PassThrough();
-  stderr = new streamModule4.PassThrough();
+  constructor(handle, file3, args, referenceChanged = () => {
+  }, extraPipes = []) {
+    super();
+    this.referenceChanged = referenceChanged;
+    this.handle = handle;
+    this.pid = handle.pid;
+    this.spawnfile = file3;
+    this.spawnargs = [file3, ...args];
+    this.stdin = new streamModule5.Writable({
+      write: (chunk, _encoding, done) => {
+        try {
+          handle.sendStdin(typeof chunk === "string" ? chunk : Buffer2.from(chunk).toString("utf8"));
+        } catch {
+        }
+        done();
+      },
+      final: (done) => {
+        try {
+          handle.endStdin?.();
+        } catch {
+        }
+        done();
+      }
+    });
+    this.stdio = [this.stdin, this.stdout, this.stderr];
+    for (const fd of extraPipes) this.stdio[fd] = this.extraPipe(fd);
+    handle.on("fd", (event) => {
+      const pipe = this.stdio[event.fd];
+      pipe?.push(Buffer2.from(event.text));
+    });
+    handle.on("stdout", (text2) => this.stdout.write(text2));
+    handle.on("stderr", (text2) => this.stderr.write(text2));
+    handle.on("exit", (code) => this.finish(code));
+    referenceChanged(1);
+    try {
+      handle.exec();
+    } catch (error) {
+      this.unref();
+      throw error;
+    }
+  }
+  referenceChanged;
+  stdout = new streamModule5.PassThrough();
+  stderr = new streamModule5.PassThrough();
   stdin;
   stdio;
   pid;
@@ -28442,33 +30414,35 @@ var ChildProcess = class extends EventEmitter4 {
   spawnargs;
   handle;
   settled = false;
-  constructor(handle, file3, args) {
-    super();
-    this.handle = handle;
-    this.pid = handle.pid;
-    this.spawnfile = file3;
-    this.spawnargs = [file3, ...args];
-    this.stdin = new streamModule4.Writable({
-      write: (chunk, _encoding, done) => {
+  referenced = true;
+  /**
+   * The parent's end of `stdio[fd] = "pipe"` for a descriptor above 2.
+   *
+   * One Duplex per descriptor, as Node gives: what the parent writes reaches
+   * the child's `fd`, and what the child writes there is readable here. Chunks
+   * are Buffers because the DevTools pipe is framed by NUL bytes and its reader
+   * searches the chunk with `indexOf("\0")`.
+   */
+  extraPipe(fd) {
+    const handle = this.handle;
+    return new streamModule5.Duplex({
+      read() {
+      },
+      write(chunk, _encoding, done) {
         try {
-          handle.sendStdin(typeof chunk === "string" ? chunk : Buffer2.from(chunk).toString("utf8"));
+          handle.writeFd?.(fd, typeof chunk === "string" ? chunk : Buffer2.from(chunk).toString("utf8"));
         } catch {
         }
         done();
       },
-      final: (done) => {
+      final(done) {
         try {
-          handle.endStdin?.();
+          handle.endFd?.(fd);
         } catch {
         }
         done();
       }
     });
-    this.stdio = [this.stdin, this.stdout, this.stderr];
-    handle.on("stdout", (text2) => this.stdout.write(text2));
-    handle.on("stderr", (text2) => this.stderr.write(text2));
-    handle.on("exit", (code) => this.finish(code));
-    handle.exec();
   }
   kill(signal = "SIGTERM") {
     this.killed = true;
@@ -28476,32 +30450,79 @@ var ChildProcess = class extends EventEmitter4 {
     return true;
   }
   ref() {
+    if (!this.settled && !this.referenced) {
+      this.referenced = true;
+      this.referenceChanged(1);
+    }
     return this;
   }
   unref() {
+    if (this.referenced) {
+      this.referenced = false;
+      this.referenceChanged(-1);
+    }
     return this;
   }
-  disconnect() {
-    this.emit("disconnect");
-  }
-  /** No IPC channel exists, and reporting that honestly beats a silent drop. */
-  send() {
-    return false;
+  channel;
+  channelOpen = false;
+  /** Open the parent's end of a `fork` channel. */
+  attachChannel(transport, id) {
+    this.channelOpen = true;
+    this.channel = transport.attach(
+      id,
+      "parent",
+      (message) => this.emit("message", message, void 0),
+      () => this.channelClosed()
+    );
   }
   get connected() {
-    return false;
+    return this.channelOpen;
+  }
+  /** `send(message[, sendHandle][, options][, callback])`, as Node spells it. */
+  send(message, ...rest) {
+    const callback = rest.find((value) => typeof value === "function");
+    if (!this.channel || !this.channelOpen) {
+      const error = Object.assign(new Error("Channel closed"), { code: "ERR_IPC_CHANNEL_CLOSED" });
+      if (callback) queueMicrotask(() => callback(error));
+      else queueMicrotask(() => this.emit("error", error));
+      return false;
+    }
+    this.channel.send(message);
+    if (callback) queueMicrotask(() => callback(null));
+    return true;
+  }
+  disconnect() {
+    if (!this.channelOpen) return;
+    this.channel?.disconnect();
+    this.channelClosed();
+  }
+  channelClosed() {
+    if (!this.channelOpen) return;
+    this.channelOpen = false;
+    this.emit("disconnect");
   }
   finish(code) {
     if (this.settled) return;
+    this.channel?.disconnect();
+    this.channelClosed();
+    this.unref();
     this.settled = true;
     this.exitCode = code;
     this.stdout.end();
     this.stderr.end();
+    for (const pipe of this.stdio.slice(3)) {
+      if (!pipe) continue;
+      pipe.once("end", () => pipe.destroy());
+      pipe.push(null);
+      if (!pipe.readableFlowing) queueMicrotask(() => {
+        if (!pipe.readableFlowing) pipe.destroy();
+      });
+    }
     this.emit("exit", code, null);
     queueMicrotask(() => this.emit("close", code, null));
   }
 };
-function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({})) {
+function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({}), lifecycle = {}) {
   const environmentFor = (options) => options.env ? { ...options.env } : defaultEnv();
   const throughShell = (command, options) => {
     const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
@@ -28512,16 +30533,27 @@ function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv
     if (stdio === "ignore") return true;
     return Array.isArray(stdio) && stdio[0] === "ignore";
   };
+  const wantsChannel = (options) => Array.isArray(options.stdio) && options.stdio.includes("ipc");
+  const extraPipesOf = (options) => Array.isArray(options.stdio) ? options.stdio.flatMap((entry, fd) => fd > 2 && (entry === "pipe" || entry === "overlapped") ? [fd] : []) : [];
   const start2 = (file3, args, options) => {
     const resolved = options.shell ? throughShell([file3, ...args].join(" "), options) : { file: file3, args };
+    const channelId = wantsChannel(options) && lifecycle.ipc ? newIpcChannelId() : void 0;
+    const extraPipes = extraPipesOf(options);
     const handle = spawnChild({
       command: resolved.file,
       args: resolved.args,
       cwd: options.cwd ?? defaultCwd(),
-      env: environmentFor(options),
-      ...stdinIgnored(options) ? { stdinIgnored: true } : {}
+      env: channelId ? { ...environmentFor(options), [IPC_CHANNEL_ENV]: channelId } : environmentFor(options),
+      ...options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[0] === "inherit" ? { inheritStdio: true } : {},
+      ...stdinIgnored(options) ? { stdinIgnored: true } : {},
+      ...extraPipes.length ? { extraPipes } : {}
     });
-    return new ChildProcess(handle, resolved.file, resolved.args);
+    const child = new ChildProcess(handle, resolved.file, resolved.args, lifecycle.referenceChanged, extraPipes);
+    if (channelId && lifecycle.ipc) child.attachChannel(lifecycle.ipc, channelId);
+    const inherited = (index) => options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[index] === "inherit";
+    if (inherited(1)) child.stdout.on("data", (chunk) => lifecycle.stdout?.(chunk.toString()));
+    if (inherited(2)) child.stderr.on("data", (chunk) => lifecycle.stderr?.(chunk.toString()));
+    return child;
   };
   const spawn = (file3, args = [], options = {}) => {
     if (!Array.isArray(args)) return start2(file3, [], args);
@@ -28564,7 +30596,13 @@ ${err.join("")}`),
     spawn,
     exec,
     execFile,
-    fork: (modulePath, args = [], options = {}) => spawn("node", [modulePath, ...args], options),
+    fork: (modulePath, args = [], options = {}) => {
+      const [list, opts] = Array.isArray(args) ? [args, options] : [[], args ?? {}];
+      const stdio = Array.isArray(opts.stdio) ? opts.stdio : typeof opts.stdio === "string" ? [opts.stdio, opts.stdio, opts.stdio] : opts.silent ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
+      const withChannel = stdio.includes("ipc") ? stdio : [...stdio, "ipc"];
+      const execArgv = (opts.execArgv ?? []).filter((flag) => !/^--(inspect|debug)/.test(flag));
+      return start2("node", [...execArgv, modulePath, ...list], { ...opts, shell: false, stdio: withChannel });
+    },
     ...buildSyncFamily(syncSpawn, throughShell, defaultCwd, environmentFor),
     ChildProcess
   };
@@ -28577,7 +30615,7 @@ function buildSyncFamily(syncSpawn, throughShell, defaultCwd, environmentFor) {
       spawnSync: unavailable("spawnSync")
     };
   }
-  const run2 = (file3, args, options) => {
+  const run3 = (file3, args, options) => {
     const resolved = options.shell ? throughShell([file3, ...args].join(" "), options) : { file: file3, args };
     const input = options.input === void 0 ? void 0 : typeof options.input === "string" ? options.input : new TextDecoder().decode(options.input);
     const inherit = options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[0] === "inherit";
@@ -28611,7 +30649,7 @@ ${result.stderr}`), {
   };
   const spawnSync = (file3, args = [], options = {}) => {
     const [list, opts] = Array.isArray(args) ? [args, options] : [[], args];
-    const result = run2(file3, list, opts);
+    const result = run3(file3, list, opts);
     return {
       pid: 0,
       status: result.status,
@@ -28624,9 +30662,9 @@ ${result.stderr}`), {
   };
   const execFileSync = (file3, args = [], options = {}) => {
     const [list, opts] = Array.isArray(args) ? [args, options] : [[], args];
-    return orThrow(run2(file3, list, opts), [file3, ...list].join(" "), opts);
+    return orThrow(run3(file3, list, opts), [file3, ...list].join(" "), opts);
   };
-  const execSync = (command, options = {}) => orThrow(run2(command, [], { ...options, shell: options.shell ?? true }), command, options);
+  const execSync = (command, options = {}) => orThrow(run3(command, [], { ...options, shell: options.shell ?? true }), command, options);
   return { spawnSync, execFileSync, execSync };
 }
 function normalize3(options, callback) {
@@ -29054,7 +31092,8 @@ function createReadlineModule(defaultInput, defaultOutput = () => void 0) {
 }
 
 // src/node/core-modules.ts
-installReadableFrom(streamModule4);
+installStreamCompat();
+installReadableFrom(streamModule5);
 var Dirent = class {
   /** Node 20+ exposes the containing directory, and `fs.glob` consumers read it. */
   constructor(name, stat2, parentPath = "") {
@@ -29195,6 +31234,9 @@ function createCoreModules(options) {
     argv: options.argv?.slice() ?? ["/usr/bin/node"],
     argv0: "node",
     execPath: "/usr/bin/node",
+    /* `process/browser.js` has no `execArgv`; Node always has an array, and
+     * CLIs that fork copy it (`[...process.execArgv]`). */
+    execArgv: [],
     env: env2,
     platform: "linux",
     arch: "x64",
@@ -29236,7 +31278,7 @@ function createCoreModules(options) {
       if (typeof fn !== "function") {
         throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
       }
-      tickQueue.push([fn, args]);
+      tickQueue.push([bindToCurrent(fn), args]);
       if (!tickDrainScheduled) {
         tickDrainScheduled = true;
         afterMicrotasks(runTicks);
@@ -29248,6 +31290,25 @@ function createCoreModules(options) {
     const implementation = EventEmitter4.prototype[method];
     if (typeof implementation === "function") processObject[method] = implementation;
   }
+  const hrtime = (previous) => {
+    const now = performance.timeOrigin + performance.now();
+    let seconds = Math.floor(now / 1e3);
+    let nanoseconds = Math.floor(now % 1e3 * 1e6);
+    if (previous) {
+      seconds -= previous[0];
+      nanoseconds -= previous[1];
+      if (nanoseconds < 0) {
+        seconds -= 1;
+        nanoseconds += 1e9;
+      }
+    }
+    return [seconds, nanoseconds];
+  };
+  hrtime.bigint = () => {
+    const [seconds, nanoseconds] = hrtime();
+    return BigInt(seconds) * 1000000000n + BigInt(nanoseconds);
+  };
+  processObject.hrtime = hrtime;
   const tty = options.tty === true;
   processObject.stdout = makeOutputStream(stdoutWrite, 1, tty);
   processObject.stderr = makeOutputStream(stderrWrite, 2, tty);
@@ -29289,15 +31350,16 @@ function createCoreModules(options) {
     }
   };
   const defer = (fn) => {
+    const bound = bindToCurrent(fn);
     queueMicrotask(() => {
       try {
-        fn();
+        bound();
       } catch (error) {
         reportUncaught(error);
       }
     });
   };
-  const stdin = options.interactiveStdin ? new streamModule4.PassThrough() : new streamModule4.Readable({ read() {
+  const stdin = options.interactiveStdin ? new streamModule5.PassThrough() : new streamModule5.Readable({ read() {
     this.push(null);
   } });
   Object.assign(stdin, {
@@ -29332,6 +31394,7 @@ function createCoreModules(options) {
   const moduleBuiltin = {
     builtinModules: builtinNames2.flatMap((name) => [name, `node:${name}`]),
     isBuiltin: (name) => builtinNames2.includes(name.replace(/^node:/, "")),
+    findSourceMap: () => void 0,
     createRequire: () => {
       throw new Error("createRequire is only available inside a loaded module");
     }
@@ -29354,18 +31417,98 @@ function createCoreModules(options) {
   };
   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");
+  let referencedChildren = 0;
+  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env }), {
+    referenceChanged: (delta) => {
+      referencedChildren += delta;
+    },
+    stdout: options.stdout,
+    stderr: options.stderr,
+    ...options.ipc ? { ipc: options.ipc } : {}
+  }) : createUnsupportedModule("child_process");
+  let channelReferenced = 0;
+  const channelId = env2[IPC_CHANNEL_ENV];
+  if (channelId && options.ipc) {
+    delete env2[IPC_CHANNEL_ENV];
+    let open = true;
+    let referenced = true;
+    channelReferenced = 1;
+    const close = () => {
+      if (!open) return;
+      open = false;
+      if (referenced) channelReferenced = 0;
+      processObject.connected = false;
+      delete processObject.send;
+      try {
+        processObject.emit("disconnect");
+      } catch (error) {
+        reportUncaught(error);
+      }
+      runTicks();
+    };
+    const endpoint = options.ipc.attach(
+      channelId,
+      "child",
+      (message) => {
+        try {
+          processObject.emit("message", message, void 0);
+        } catch (error) {
+          reportUncaught(error);
+        }
+        runTicks();
+      },
+      close
+    );
+    processObject.connected = true;
+    processObject.send = (message, ...rest) => {
+      const callback = rest.find((value) => typeof value === "function");
+      if (!open) {
+        const error = Object.assign(new Error("Channel closed"), { code: "ERR_IPC_CHANNEL_CLOSED" });
+        if (callback) defer(() => callback(error));
+        else defer(() => {
+          processObject.emit("error", error);
+        });
+        return false;
+      }
+      endpoint.send(message);
+      if (callback) defer(() => callback(null));
+      return true;
+    };
+    processObject.disconnect = () => {
+      if (open) {
+        endpoint.disconnect();
+        close();
+      }
+    };
+    processObject.channel = {
+      ref() {
+        if (open && !referenced) {
+          referenced = true;
+          channelReferenced = 1;
+        }
+        return this;
+      },
+      unref() {
+        if (referenced) {
+          referenced = false;
+          channelReferenced = 0;
+        }
+        return this;
+      }
+    };
+  }
   const readline = createReadlineModule(() => processObject.stdin, () => processObject.stdout);
   const dns = createDnsModule(defer);
   const builtins = {
     assert: assert_module_default,
     "assert/strict": assert_module_default.strict ?? assert_module_default,
-    buffer: { Buffer: Buffer2, SlowBuffer: Buffer2, INSPECT_MAX_BYTES: 50, kMaxLength: Buffer2.kMaxLength },
+    buffer: createBufferBuiltin(),
     async_hooks: asyncHooks,
     child_process: childProcess,
     console: consoleObject,
     constants: fs.constants,
     crypto: createCryptoModule(),
+    diagnostics_channel: createDiagnosticsChannel(),
     dns,
     "dns/promises": dns.promises,
     events: EventEmitter4,
@@ -29383,12 +31526,31 @@ function createCoreModules(options) {
     querystring: querystringModule,
     readline,
     "readline/promises": readline.promises,
-    stream: streamModule4,
+    stream: streamModule5,
+    "stream/web": Object.fromEntries([
+      "ReadableStream",
+      "ReadableStreamDefaultReader",
+      "ReadableStreamBYOBReader",
+      "ReadableStreamDefaultController",
+      "ReadableByteStreamController",
+      "ReadableStreamBYOBRequest",
+      "WritableStream",
+      "WritableStreamDefaultWriter",
+      "WritableStreamDefaultController",
+      "TransformStream",
+      "TransformStreamDefaultController",
+      "ByteLengthQueuingStrategy",
+      "CountQueuingStrategy",
+      "TextEncoderStream",
+      "TextDecoderStream",
+      "CompressionStream",
+      "DecompressionStream"
+    ].filter((name) => name in globalThis).map((name) => [name, globalThis[name]])),
     "stream/promises": createStreamPromises(),
     string_decoder: stringDecoderModule,
     timers: { ...timersModule, ...timers.api },
     "timers/promises": createTimerPromises(timers.api),
-    tty: { isatty: () => false, ReadStream: streamModule4.Readable, WriteStream: streamModule4.Writable },
+    tty: { isatty: () => false, ReadStream: streamModule5.Readable, WriteStream: streamModule5.Writable },
     url: url_module_default,
     util: util_module_default,
     "util/types": util_module_default.types ?? {},
@@ -29415,19 +31577,73 @@ function createCoreModules(options) {
     })
   };
   for (const name of stubNames) builtins[name] = createUnsupportedModule(name);
+  builtins.worker_threads = {
+    MessagePort: globalThis.MessagePort ?? class MessagePort {
+    },
+    markAsUncloneable: () => {
+    },
+    isMarkedAsUncloneable: () => false,
+    markAsUntransferable: () => {
+    },
+    isMarkedAsUntransferable: () => false
+  };
   builtins.net = createNetModule();
+  builtins.vm = vm_module_default;
+  builtins.inspector = createUnsupportedModule("inspector", {
+    url: () => void 0,
+    close: () => {
+    },
+    waitForDebugger: () => {
+      throw Object.assign(new Error("Inspector is not active"), { code: "ERR_INSPECTOR_NOT_ACTIVE" });
+    },
+    console: consoleObject
+  });
+  builtins.v8 = createUnsupportedModule("v8", {
+    getHeapStatistics: () => {
+      const memory = performance.memory;
+      const limit = memory?.jsHeapSizeLimit ?? 4 * 1024 ** 3;
+      return {
+        total_heap_size: memory?.totalJSHeapSize ?? 0,
+        total_heap_size_executable: 0,
+        total_physical_size: memory?.totalJSHeapSize ?? 0,
+        total_available_size: limit - (memory?.usedJSHeapSize ?? 0),
+        used_heap_size: memory?.usedJSHeapSize ?? 0,
+        heap_size_limit: limit,
+        malloced_memory: 0,
+        peak_malloced_memory: 0,
+        does_zap_garbage: 0,
+        number_of_native_contexts: 1,
+        number_of_detached_contexts: 0,
+        total_global_handles_size: 0,
+        used_global_handles_size: 0,
+        external_memory: 0
+      };
+    },
+    getHeapSpaceStatistics: () => [],
+    getHeapCodeStatistics: () => ({ code_and_metadata_size: 0, bytecode_and_metadata_size: 0, external_script_source_size: 0, cpu_profiler_metadata_size: 0 }),
+    cachedDataVersionTag: () => 0,
+    setFlagsFromString: () => {
+    },
+    setHeapSnapshotNearHeapLimit: () => {
+    },
+    serialize: (value) => Buffer2.from(JSON.stringify(value) ?? "null"),
+    deserialize: (buffer) => JSON.parse(Buffer2.from(buffer).toString("utf8"))
+  });
   const globals = {
     Buffer: Buffer2,
     console: consoleObject,
     process: processObject,
     ...timers.api,
-    queueMicrotask: (fn) => queueMicrotask(() => {
-      try {
-        fn();
-      } catch (error) {
-        reportUncaught(error);
-      }
-    })
+    queueMicrotask: (fn) => {
+      const bound = bindToCurrent(fn);
+      queueMicrotask(() => {
+        try {
+          bound();
+        } catch (error) {
+          reportUncaught(error);
+        }
+      });
+    }
   };
   if (options.http) {
     globals.fetch = createVirtualFetch(options.http.router, {
@@ -29450,7 +31666,7 @@ function createCoreModules(options) {
     builtins,
     globals,
     process: processObject,
-    pendingHandles: timers.pending,
+    pendingHandles: () => timers.pending() + referencedChildren + channelReferenced,
     pendingUnrefed: timers.pendingUnrefed,
     /** Client requests sent but not yet read to completion. */
     pendingRequests: () => inFlightRequests,
@@ -29472,7 +31688,7 @@ function createCoreModules(options) {
     },
     loopActivity: () => timers.scheduled() + requestsStarted,
     writeStdin: (data) => {
-      if (options.interactiveStdin) stdin.write(data);
+      if (options.interactiveStdin) stdin.write(typeof data === "string" ? data : Buffer2.from(data));
     },
     endStdin: () => {
       if (options.interactiveStdin) stdin.end();
@@ -29516,7 +31732,9 @@ var ASYNC_FS_METHODS = [
   "close",
   "read",
   "write",
-  "exists"
+  "exists",
+  "fsync",
+  "fdatasync"
 ];
 function createPathModule(cwd) {
   const resolve3 = (...segments2) => pathModule.resolve(cwd(), ...segments2);
@@ -29693,10 +31911,27 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     },
     writeSync: (fd, data, offset, length, position) => {
       const file3 = requiredFd(fds, fd);
+      if (typeof data === "string") {
+        const stringPosition = typeof offset === "number" ? offset : null;
+        const encoding = typeof length === "string" ? length : "utf8";
+        data = Buffer2.from(data, encoding);
+        position = stringPosition;
+        offset = 0;
+        length = data.length;
+      }
       const input = bytes2(data);
-      const chunk = typeof data === "string" ? input : input.subarray(offset ?? 0, (offset ?? 0) + (length ?? input.length));
+      const chunk = input.subarray(offset ?? 0, (offset ?? 0) + (length ?? input.length));
+      const size = volume.lstatSync(file3.path).size;
+      const append = file3.flags.startsWith("a") || (position ?? file3.position) >= size;
+      if (append) {
+        const at = file3.flags.startsWith("a") ? size : position ?? file3.position;
+        if (at > size) volume.appendFileSync(file3.path, new Uint8Array(at - size));
+        volume.appendFileSync(file3.path, chunk);
+        if (position == null) file3.position = at + chunk.length;
+        return chunk.length;
+      }
       const old = volume.readFileSync(file3.path);
-      const start2 = file3.flags.startsWith("a") ? old.length : position ?? file3.position;
+      const start2 = position ?? file3.position;
       const next = new Uint8Array(Math.max(old.length, start2 + chunk.length));
       next.set(old);
       next.set(chunk, start2);
@@ -29704,41 +31939,22 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
       if (position == null) file3.position = start2 + chunk.length;
       return chunk.length;
     },
-    createReadStream: (path, options) => {
-      const target = abs(path);
-      const settings = typeof options === "string" ? { encoding: options } : options ?? {};
-      const whole = Buffer2.from(volume.readFileSync(resolveLinks(volume, target)));
-      const start2 = settings.start ?? 0;
-      const end = settings.end === void 0 ? whole.length : Math.min(settings.end + 1, whole.length);
-      const slice = whole.subarray(start2, Math.max(start2, end));
-      const stream = streamModule4.Readable.from([settings.encoding ? slice.toString(settings.encoding) : slice]);
-      Object.assign(stream, { path: target, bytesRead: slice.length, close: () => stream.destroy() });
-      defer(() => {
-        stream.emit("open", 0);
-        stream.emit("ready");
-      });
-      return stream;
-    },
-    createWriteStream: (path, options) => {
-      const target = abs(path);
-      let first = true;
-      return new streamModule4.Writable({ write(chunk, _encoding, done) {
-        try {
-          if (options?.flags?.startsWith("a") || !first) volume.appendFileSync(target, new Uint8Array(chunk));
-          else volume.writeFileSync(target, new Uint8Array(chunk));
-          first = false;
-          done();
-        } catch (error) {
-          done(error);
-        }
-      } });
-    },
+    /* Looked up on `fs` at call time, so a package that replaces
+     * `fs.ReadStream`/`fs.WriteStream` — graceful-fs does — is honoured. */
+    createReadStream: (path, options) => new fs.ReadStream(path, options),
+    createWriteStream: (path, options) => new fs.WriteStream(path, options),
     watch: () => new FsWatcher(),
     watchFile: () => {
     },
     unwatchFile: () => {
     }
   };
+  fs.fsyncSync = (fd) => {
+    requiredFd(fds, fd);
+  };
+  fs.fdatasyncSync = (fd) => {
+    requiredFd(fds, fd);
+  };
   fs.ftruncateSync = (fd, length) => fs.truncateSync(requiredFd(fds, fd).path, length);
   fs.fchmodSync = (fd, mode) => fs.chmodSync(requiredFd(fds, fd).path, mode);
   fs.fchownSync = (fd, uid, gid) => fs.chownSync(requiredFd(fds, fd).path, uid, gid);
@@ -29780,6 +31996,264 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     };
   }
   fs.realpath.native = fs.realpath;
+  const streamSettings = (options) => typeof options === "string" ? { encoding: options } : options ?? {};
+  function WriteStream(path, options) {
+    const self = this;
+    if (!Object.prototype.isPrototypeOf.call(WriteStream.prototype, self)) return new WriteStream(path, options);
+    const settings = streamSettings(options);
+    streamModule5.Writable.call(self, { highWaterMark: settings.highWaterMark, emitClose: true });
+    self.path = abs(path);
+    self.flags = settings.flags ?? "w";
+    self.mode = settings.mode ?? 438;
+    self.fd = typeof settings.fd === "number" ? settings.fd : null;
+    self.bytesWritten = 0;
+    self.pending = true;
+    self._opened = self.fd !== null;
+    self.once("open", () => {
+      self._opened = true;
+      self.pending = false;
+    });
+    self.once("finish", () => {
+      if (!self.destroyed) self.destroy();
+    });
+    if (self.fd === null) self.open();
+    else defer(() => {
+      self.emit("open", self.fd);
+      self.emit("ready");
+    });
+  }
+  WriteStream.prototype = Object.create(streamModule5.Writable.prototype, {
+    constructor: { value: WriteStream, writable: true, configurable: true }
+  });
+  WriteStream.prototype.open = function() {
+    const self = this;
+    try {
+      if (String(self.flags).startsWith("a")) {
+        if (!fs.existsSync(self.path)) volume.writeFileSync(self.path, new Uint8Array());
+      } else volume.writeFileSync(self.path, new Uint8Array());
+    } catch (error) {
+      defer(() => self.destroy(error));
+      return;
+    }
+    defer(() => {
+      self.emit("open", 0);
+      self.emit("ready");
+    });
+  };
+  WriteStream.prototype._write = function(chunk, encoding, done) {
+    const self = this;
+    const append = () => {
+      try {
+        const bytes3 = typeof chunk === "string" ? Buffer2.from(chunk, encoding) : chunk;
+        volume.appendFileSync(self.path, new Uint8Array(bytes3));
+        self.bytesWritten += bytes3.length;
+        done();
+      } catch (error) {
+        done(error);
+      }
+    };
+    if (self._opened) append();
+    else self.once("open", append);
+  };
+  WriteStream.prototype.close = function(callback2) {
+    const self = this;
+    if (callback2) {
+      if (self.closed) defer(() => callback2(null));
+      else {
+        self.once("close", () => callback2(null));
+        self.once("error", (error) => callback2(error));
+      }
+    }
+    if (!self.writableEnded) self.end();
+    else if (!self.destroyed) self.destroy();
+  };
+  function ReadStream(path, options) {
+    const self = this;
+    if (!Object.prototype.isPrototypeOf.call(ReadStream.prototype, self)) return new ReadStream(path, options);
+    const settings = streamSettings(options);
+    streamModule5.Readable.call(self, { highWaterMark: settings.highWaterMark, encoding: settings.encoding, emitClose: true });
+    self.path = abs(path);
+    self.flags = settings.flags ?? "r";
+    self.mode = settings.mode ?? 438;
+    self.fd = typeof settings.fd === "number" ? settings.fd : null;
+    self.start = settings.start;
+    self.end = settings.end;
+    self.bytesRead = 0;
+    self.pending = true;
+    self._delivered = false;
+    self.once("open", () => {
+      self.pending = false;
+    });
+    self.once("end", () => {
+      if (!self.destroyed) self.destroy();
+    });
+    if (self.fd === null) self.open();
+    else defer(() => {
+      self.emit("open", self.fd);
+      self.emit("ready");
+    });
+  }
+  ReadStream.prototype = Object.create(streamModule5.Readable.prototype, {
+    constructor: { value: ReadStream, writable: true, configurable: true }
+  });
+  ReadStream.prototype.open = function() {
+    const self = this;
+    defer(() => {
+      self.emit("open", 0);
+      self.emit("ready");
+    });
+  };
+  ReadStream.prototype._read = function() {
+    const self = this;
+    if (self._delivered) {
+      self.push(null);
+      return;
+    }
+    self._delivered = true;
+    let whole;
+    try {
+      whole = Buffer2.from(volume.readFileSync(resolveLinks(volume, self.path)));
+    } catch (error) {
+      self.destroy(error);
+      return;
+    }
+    const start2 = self.start ?? 0;
+    const end = self.end === void 0 ? whole.length : Math.min(self.end + 1, whole.length);
+    const slice = whole.subarray(start2, Math.max(start2, end));
+    self.bytesRead = slice.length;
+    if (slice.length) self.push(slice);
+    self.push(null);
+  };
+  ReadStream.prototype.close = function(callback2) {
+    const self = this;
+    if (callback2) {
+      if (self.closed) defer(() => callback2(null));
+      else self.once("close", () => callback2(null));
+    }
+    if (!self.destroyed) self.destroy();
+  };
+  fs.WriteStream = WriteStream;
+  fs.ReadStream = ReadStream;
+  fs.FileWriteStream = WriteStream;
+  fs.FileReadStream = ReadStream;
+  class Dir {
+    path;
+    entries;
+    closed = false;
+    constructor(path) {
+      this.path = path;
+      this.entries = fs.readdirSync(path, { withFileTypes: true });
+    }
+    assertOpen() {
+      if (this.closed) throw Object.assign(new Error("Directory handle was closed"), { code: "ERR_DIR_CLOSED" });
+    }
+    readSync() {
+      this.assertOpen();
+      return this.entries.shift() ?? null;
+    }
+    read(callback2) {
+      if (callback2) {
+        defer(() => {
+          let entry;
+          try {
+            entry = this.readSync();
+          } catch (error) {
+            callback2(error, null);
+            return;
+          }
+          callback2(null, entry);
+        });
+        return;
+      }
+      return Promise.resolve().then(() => this.readSync());
+    }
+    closeSync() {
+      this.assertOpen();
+      this.closed = true;
+    }
+    close(callback2) {
+      if (callback2) {
+        defer(() => {
+          try {
+            this.closeSync();
+          } catch (error) {
+            callback2(error);
+            return;
+          }
+          callback2(null);
+        });
+        return;
+      }
+      return Promise.resolve().then(() => this.closeSync());
+    }
+    /* Iterating a `Dir` reads it to the end and then closes it, as in Node. */
+    async *[Symbol.asyncIterator]() {
+      try {
+        for (let entry = this.readSync(); entry; entry = this.readSync()) yield entry;
+      } finally {
+        if (!this.closed) this.closeSync();
+      }
+    }
+    *entriesSync() {
+      try {
+        for (let entry = this.readSync(); entry; entry = this.readSync()) yield entry;
+      } finally {
+        if (!this.closed) this.closeSync();
+      }
+    }
+  }
+  fs.Dir = Dir;
+  fs.opendirSync = (path) => new Dir(abs(path));
+  fs.opendir = (path, options, callback2) => {
+    const done = typeof options === "function" ? options : callback2;
+    if (typeof done !== "function") throw new TypeError("callback must be a function");
+    defer(() => {
+      let dir3;
+      try {
+        dir3 = fs.opendirSync(path);
+      } catch (error) {
+        done(error);
+        return;
+      }
+      done(null, dir3);
+    });
+  };
+  const runThenCall = (work, cb) => {
+    defer(() => {
+      let result;
+      try {
+        result = work();
+      } catch (error) {
+        cb(error);
+        return;
+      }
+      cb(null, ...result);
+    });
+  };
+  fs.read = (fd, ...rest) => {
+    const cb = rest.pop();
+    if (typeof cb !== "function") throw new TypeError("callback must be a function");
+    let buffer;
+    let offset;
+    let length;
+    let position;
+    if (ArrayBuffer.isView(rest[0])) {
+      buffer = rest[0];
+      if (rest[1] !== null && typeof rest[1] === "object") ({ offset, length, position } = rest[1]);
+      else [offset, length, position] = [rest[1], rest[2], rest[3]];
+    } else {
+      const options = rest[0] ?? {};
+      buffer = options.buffer ?? Buffer2.alloc(16384);
+      ({ offset, length, position } = options);
+    }
+    const start2 = offset ?? 0;
+    runThenCall(() => [fs.readSync(fd, buffer, start2, length ?? buffer.byteLength - start2, position ?? null), buffer], cb);
+  };
+  fs.write = (fd, data, ...rest) => {
+    const cb = rest.pop();
+    if (typeof cb !== "function") throw new TypeError("callback must be a function");
+    runThenCall(() => [fs.writeSync(fd, data, ...rest), data], cb);
+  };
   fs.exists = (path, cb) => {
     defer(() => cb(fs.existsSync(path)));
   };
@@ -29791,7 +32265,8 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     /* The promise API hands back a FileHandle object rather than a numeric
      * descriptor, and callers use its methods instead of passing the number
      * to `fs.read`. */
-    open: async (path, flags = "r", mode) => makeFileHandle(fs, fs.openSync(path, flags, mode))
+    open: async (path, flags = "r", mode) => makeFileHandle(fs, fs.openSync(path, flags, mode)),
+    opendir: async (path) => fs.opendirSync(path)
   };
   return fs;
 }
@@ -29799,6 +32274,8 @@ function makeFileHandle(fs, fd) {
   return {
     fd,
     close: async () => fs.closeSync(fd),
+    sync: async () => fs.fsyncSync(fd),
+    datasync: async () => fs.fdatasyncSync(fd),
     stat: async () => fs.fstatSync(fd),
     truncate: async (length) => fs.ftruncateSync(fd, length),
     chmod: async (mode) => fs.fchmodSync(fd, mode),
@@ -29836,6 +32313,37 @@ function resolveLinks(volume, input) {
   }
   throw fsError("ELOOP", "realpath", input);
 }
+function createBufferBuiltin() {
+  const MAX_LENGTH = typeof Buffer2.kMaxLength === "number" ? Buffer2.kMaxLength : 2 ** 32;
+  const MAX_STRING_LENGTH = 2 ** 29 - 24;
+  const textDecoder = typeof TextDecoder === "function" ? new TextDecoder("utf-8", { fatal: true }) : void 0;
+  return {
+    Buffer: Buffer2,
+    SlowBuffer: Buffer2,
+    INSPECT_MAX_BYTES: 50,
+    kMaxLength: MAX_LENGTH,
+    kStringMaxLength: MAX_STRING_LENGTH,
+    constants: { MAX_LENGTH, MAX_STRING_LENGTH },
+    ...typeof Blob === "function" ? { Blob } : {},
+    ...typeof globalThis.File === "function" ? { File: globalThis.File } : {},
+    atob: (data) => globalThis.atob(String(data)),
+    btoa: (data) => globalThis.btoa(String(data)),
+    isUtf8: (input) => {
+      if (!textDecoder) return true;
+      try {
+        textDecoder.decode(input);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    isAscii: (input) => {
+      const bytes2 = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      for (const byte of bytes2) if (byte > 127) return false;
+      return true;
+    }
+  };
+}
 function requiredFd(fds, fd) {
   const file3 = fds.get(fd);
   if (!file3) throw fsError("EBADF", "fd", String(fd));
@@ -29845,8 +32353,8 @@ function fsError(code, syscall, path) {
   return Object.assign(new Error(`${code}: ${syscall}, '${path}'`), { code, syscall, path });
 }
 function makeOutputStream(write, fd, isTTY = false) {
-  const stream = new streamModule4.Writable({ write(chunk, _encoding, done) {
-    write(Buffer2.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+  const stream = new streamModule5.Writable({ decodeStrings: false, write(chunk, _encoding, done) {
+    write(Buffer2.isBuffer(chunk) ? new Uint8Array(chunk) : String(chunk));
     done();
   } });
   return Object.assign(stream, { fd, isTTY, columns: 80, rows: 24 });
@@ -30104,7 +32612,7 @@ function createTrackedTimers(onError = (error) => {
   throw error;
 }, afterCallback = () => {
 }) {
-  const run2 = (fn, args) => {
+  const run3 = (fn, args) => {
     try {
       fn(...args);
     } catch (error) {
@@ -30112,6 +32620,12 @@ function createTrackedTimers(onError = (error) => {
     }
     afterCallback();
   };
+  const hostSetTimeout = globalThis.setTimeout.bind(globalThis);
+  const hostClearTimeout = globalThis.clearTimeout.bind(globalThis);
+  const hostSetInterval = globalThis.setInterval.bind(globalThis);
+  const hostClearInterval = globalThis.clearInterval.bind(globalThis);
+  const hostSetImmediate = typeof globalThis.setImmediate === "function" ? globalThis.setImmediate.bind(globalThis) : void 0;
+  const hostClearImmediate = typeof globalThis.clearImmediate === "function" ? globalThis.clearImmediate.bind(globalThis) : hostClearTimeout;
   let scheduled = 0;
   const live = /* @__PURE__ */ new Set();
   const unrefed = /* @__PURE__ */ new Set();
@@ -30151,12 +32665,13 @@ function createTrackedTimers(onError = (error) => {
     live.delete(handle);
     unrefed.delete(handle);
   };
-  const setTimeoutTracked = (fn, delay, ...args) => {
+  const setTimeoutTracked = (callback, delay, ...args) => {
+    const fn = bindToCurrent(callback);
     let handle;
-    const native = setTimeout(
+    const native = hostSetTimeout(
       (...inner) => {
         complete(handle);
-        run2(fn, inner);
+        run3(fn, inner);
       },
       delay,
       ...args
@@ -30164,14 +32679,17 @@ function createTrackedTimers(onError = (error) => {
     handle = track(native);
     return handle;
   };
-  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);
+  const setIntervalTracked = (callback, delay, ...args) => {
+    const fn = bindToCurrent(callback);
+    return track(hostSetInterval((...inner) => run3(fn, inner), delay, ...args));
+  };
+  const setImmediateTracked = (callback, ...args) => {
+    if (!hostSetImmediate) return setTimeoutTracked(callback, 0, ...args);
+    const fn = bindToCurrent(callback);
     let handle;
     const native = hostSetImmediate((...inner) => {
       complete(handle);
-      run2(fn, inner);
+      run3(fn, inner);
     }, ...args);
     handle = track(native);
     return handle;
@@ -30196,15 +32714,15 @@ function createTrackedTimers(onError = (error) => {
       if (!state) continue;
       state.active = false;
       try {
-        clearTimeout(state.native);
+        hostClearTimeout(state.native);
       } catch {
       }
       try {
-        clearInterval(state.native);
+        hostClearInterval(state.native);
       } catch {
       }
       try {
-        (globalThis.clearImmediate ?? clearTimeout)(state.native);
+        hostClearImmediate(state.native);
       } catch {
       }
     }
@@ -30216,9 +32734,9 @@ function createTrackedTimers(onError = (error) => {
       setTimeout: setTimeoutTracked,
       setInterval: setIntervalTracked,
       setImmediate: setImmediateTracked,
-      clearTimeout: (handle) => clear2(handle, clearTimeout),
-      clearInterval: (handle) => clear2(handle, clearInterval),
-      clearImmediate: (handle) => clear2(handle, globalThis.clearImmediate ?? clearTimeout)
+      clearTimeout: (handle) => clear2(handle, hostClearTimeout),
+      clearInterval: (handle) => clear2(handle, hostClearInterval),
+      clearImmediate: (handle) => clear2(handle, hostClearImmediate)
     },
     pending: () => live.size,
     pendingUnrefed: () => unrefed.size,
@@ -30233,66 +32751,6 @@ function createTimerPromises(timers) {
   };
 }
 function createAsyncHooksModule() {
-  class AsyncResource {
-    constructor(type, _options) {
-      this.type = type;
-    }
-    type;
-    runInAsyncScope(fn, thisArg, ...args) {
-      return fn.apply(thisArg, args);
-    }
-    bind(fn, thisArg) {
-      return ((...args) => this.runInAsyncScope(fn, thisArg, ...args));
-    }
-    emitDestroy() {
-      return this;
-    }
-    asyncId() {
-      return 1;
-    }
-    triggerAsyncId() {
-      return 0;
-    }
-    static bind(fn, type = "bound-anonymous-fn", thisArg) {
-      return new AsyncResource(type).bind(fn, thisArg);
-    }
-  }
-  class AsyncLocalStorage {
-    value;
-    disable() {
-      this.value = void 0;
-    }
-    getStore() {
-      return this.value;
-    }
-    enterWith(store) {
-      this.value = store;
-    }
-    run(store, callback, ...args) {
-      const previous = this.value;
-      this.value = store;
-      try {
-        return callback(...args);
-      } finally {
-        this.value = previous;
-      }
-    }
-    exit(callback, ...args) {
-      const previous = this.value;
-      this.value = void 0;
-      try {
-        return callback(...args);
-      } finally {
-        this.value = previous;
-      }
-    }
-    static bind(fn) {
-      return fn;
-    }
-    static snapshot() {
-      return (fn, ...args) => fn(...args);
-    }
-  }
   return {
     AsyncResource,
     AsyncLocalStorage,
@@ -30310,10 +32768,10 @@ function createStreamPromises() {
   return {
     pipeline: (...streams) => new Promise((resolve3, reject) => {
       const callback = (error) => error ? reject(error) : resolve3();
-      streamModule4.pipeline(...streams, callback);
+      streamModule5.pipeline(...streams, callback);
     }),
     finished: (stream) => new Promise((resolve3, reject) => {
-      streamModule4.finished(stream, (error) => error ? reject(error) : resolve3());
+      streamModule5.finished(stream, (error) => error ? reject(error) : resolve3());
     })
   };
 }
@@ -30327,6 +32785,7 @@ function createUnsupportedModule(name, supported = {}) {
   const module = new Proxy(target, {
     get(object, key) {
       if (key === "default") return module;
+      if (key === "__esModule" || typeof key === "symbol") return object[key];
       return key in object ? object[key] : unsupported2;
     }
   });
@@ -30349,10 +32808,20 @@ function createNetModule() {
     const count = groups.reduce((total, half) => total + half.length, 0);
     return halves.length === 2 ? count <= 7 : count === 8;
   };
+  let autoSelectFamily = true;
+  let autoSelectFamilyAttemptTimeout = 250;
   return createUnsupportedModule("net", {
     isIPv4,
     isIPv6,
-    isIP: (value) => isIPv4(value) ? 4 : isIPv6(value) ? 6 : 0
+    isIP: (value) => isIPv4(value) ? 4 : isIPv6(value) ? 6 : 0,
+    getDefaultAutoSelectFamily: () => autoSelectFamily,
+    setDefaultAutoSelectFamily: (value) => {
+      autoSelectFamily = Boolean(value);
+    },
+    getDefaultAutoSelectFamilyAttemptTimeout: () => autoSelectFamilyAttemptTimeout,
+    setDefaultAutoSelectFamilyAttemptTimeout: (value) => {
+      autoSelectFamilyAttemptTimeout = Math.max(10, Number(value) || 250);
+    }
   });
 }
 function parseTestSettings(raw) {
@@ -30392,7 +32861,7 @@ function formatUncaught(error) {
 Node.js v22.12.0
 `;
 }
-var stubNames = ["cluster", "dgram", "diagnostics_channel", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
+var stubNames = ["cluster", "dgram", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
 var builtinNames2 = [
   "assert",
   "assert/strict",
@@ -30405,6 +32874,7 @@ var builtinNames2 = [
   "events",
   "fs",
   "fs/promises",
+  "diagnostics_channel",
   "dns",
   "dns/promises",
   "http",
@@ -30420,6 +32890,7 @@ var builtinNames2 = [
   "readline",
   "readline/promises",
   "stream",
+  "stream/web",
   "stream/promises",
   "string_decoder",
   "timers",
@@ -30489,6 +32960,7 @@ var MemoryStat = class {
   }
 };
 var encoder7 = new TextEncoder();
+var appendCapacity = /* @__PURE__ */ new WeakMap();
 var MemoryVolume = class {
   entries = /* @__PURE__ */ new Map();
   nextIno = 2;
@@ -30507,12 +32979,12 @@ var MemoryVolume = class {
     const key = this.key(path);
     this.requireParent(key, "open");
     const bytes2 = typeof data === "string" ? encoder7.encode(data) : data.slice();
-    const current = this.entries.get(key);
-    if (current?.kind === "directory") throw new VolumeError("EISDIR", "open", key);
-    if (current?.kind === "symlink") throw new VolumeError("EINVAL", "open", key);
-    if (current) {
-      current.data = bytes2;
-      this.touchChanged(current, true);
+    const current2 = this.entries.get(key);
+    if (current2?.kind === "directory") throw new VolumeError("EISDIR", "open", key);
+    if (current2?.kind === "symlink") throw new VolumeError("EINVAL", "open", key);
+    if (current2) {
+      current2.data = bytes2;
+      this.touchChanged(current2, true);
     } else {
       this.entries.set(key, this.inode("file", 438, bytes2));
     }
@@ -30520,14 +32992,27 @@ var MemoryVolume = class {
   appendFileSync(path, data) {
     const key = this.key(path);
     const bytes2 = typeof data === "string" ? encoder7.encode(data) : data;
-    const current = this.entries.get(key);
-    if (!current) return this.writeFileSync(key, bytes2);
-    if (current.kind !== "file") throw new VolumeError(current.kind === "directory" ? "EISDIR" : "EINVAL", "open", key);
-    const next = new Uint8Array(current.data.length + bytes2.length);
-    next.set(current.data);
-    next.set(bytes2, current.data.length);
-    current.data = next;
-    this.touchChanged(current, true);
+    const current2 = this.entries.get(key);
+    if (!current2) return this.writeFileSync(key, bytes2);
+    if (current2.kind !== "file") throw new VolumeError(current2.kind === "directory" ? "EISDIR" : "EINVAL", "open", key);
+    const length = current2.data.length;
+    const needed = length + bytes2.length;
+    const backing = current2.data.buffer;
+    const ownsTail = current2.data.byteOffset === 0 && backing instanceof ArrayBuffer && backing.byteLength >= needed && appendCapacity.get(current2) === backing;
+    if (ownsTail) {
+      const grown = new Uint8Array(backing, 0, needed);
+      grown.set(bytes2, length);
+      current2.data = grown;
+    } else {
+      const capacity = Math.max(needed, length * 2, 64 * 1024);
+      const buffer = new ArrayBuffer(capacity);
+      const grown = new Uint8Array(buffer, 0, needed);
+      grown.set(current2.data);
+      grown.set(bytes2, length);
+      current2.data = grown;
+      appendCapacity.set(current2, buffer);
+    }
+    this.touchChanged(current2, true);
   }
   readdirSync(path) {
     const key = this.key(path);
@@ -30842,8 +33327,8 @@ var MirroringVolume = class {
         return;
       }
       try {
-        const current = this.inner.readFileSync(path);
-        if (sameBytes(current, produced)) return;
+        const current2 = this.inner.readFileSync(path);
+        if (sameBytes(current2, produced)) return;
       } catch {
       }
       try {
@@ -30857,16 +33342,16 @@ var MirroringVolume = class {
   /** `mkdir -p`, which the volume does not offer directly. */
   ensureDirectory(path) {
     const parts = clean(path).split("/").filter(Boolean);
-    let current = "";
+    let current2 = "";
     for (const part of parts) {
-      current += `/${part}`;
+      current2 += `/${part}`;
       try {
-        if (this.inner.lstatSync(current).isDirectory()) continue;
+        if (this.inner.lstatSync(current2).isDirectory()) continue;
         return;
       } catch {
       }
       try {
-        this.inner.mkdirSync(current);
+        this.inner.mkdirSync(current2);
       } catch {
       }
     }
@@ -31206,10 +33691,10 @@ function esbuildUnavailable() {
   error.code = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
   return error;
 }
-var installed = false;
+var installed2 = false;
 function ensureProcessGlobal() {
-  if (installed) return;
-  installed = true;
+  if (installed2) return;
+  installed2 = true;
   if (typeof globalThis.process !== "undefined") return;
   Object.defineProperty(globalThis, "process", {
     value: processShim,
@@ -31264,7 +33749,7 @@ async function loadNodeRolldownMemfsBinding() {
     /* webpackIgnore: true */
     runtimeModuleUrl2
   );
-  const createContext2 = runtime.createContext;
+  const createContext3 = runtime.createContext;
   const { memfs } = await import(
     /* @vite-ignore */
     /* webpackIgnore: true */
@@ -31280,7 +33765,7 @@ async function loadNodeRolldownMemfsBinding() {
   const wasmFile = readFileSync(join3(packageDir, "rolldown-binding.wasm32-wasi.wasm"));
   const sharedMemory = new WebAssembly.Memory({ initial: 16384, maximum: 65536, shared: true });
   const workerPoolSize = Math.max(2, cpuCount());
-  const context = createContext2({ autoDestroy: false });
+  const context = createContext3({ autoDestroy: false });
   context.suppressDestroy();
   const workerPath = resolveWorkerPath(node2);
   if (!workerPath) return null;
@@ -31445,13 +33930,24 @@ var LocalProcess = class extends EventEmitter4 {
   on(event, listener) {
     return super.on(event, listener);
   }
-  output(text2) {
+  /**
+   * `output` and `error` stay text, as the contract promises. `raw-output`
+   * carries stdout exactly as written — a Buffer as its bytes — for consumers
+   * that forward it into a pipe, where decoding would corrupt binary framing.
+   */
+  rawOutput = true;
+  outText = new TextDecoder();
+  errText = new TextDecoder();
+  output(chunk) {
+    const text2 = typeof chunk === "string" ? chunk : this.outText.decode(chunk, { stream: true });
     this.out.push(text2);
-    this.emit("output", text2);
+    this.emit("raw-output", chunk);
+    if (text2) this.emit("output", text2);
   }
-  error(text2) {
+  error(chunk) {
+    const text2 = typeof chunk === "string" ? chunk : this.errText.decode(chunk, { stream: true });
     this.err.push(text2);
-    this.emit("error", text2);
+    if (text2) this.emit("error", text2);
   }
   /**
    * Deliver input to the running program.
@@ -31547,6 +34043,8 @@ var PodChildProcess = class {
   stdout = "";
   stderr = "";
   listeners = /* @__PURE__ */ new Map();
+  outText = new TextDecoder();
+  errText = new TextDecoder();
   started = false;
   cancelled = false;
   child;
@@ -31582,11 +34080,13 @@ var PodChildProcess = class {
             this.pendingInput = "";
           }
           if (this.inputEnded) child.endInput?.();
-          child.on("output", (text2) => {
+          child.on("output", (chunk) => {
+            const text2 = typeof chunk === "string" ? chunk : this.outText.decode(chunk, { stream: true });
             this.stdout += text2;
             this.emit("stdout", text2);
           });
-          child.on("error", (text2) => {
+          child.on("error", (chunk) => {
+            const text2 = typeof chunk === "string" ? chunk : this.errText.decode(chunk, { stream: true });
             this.stderr += text2;
             this.emit("stderr", text2);
           });
@@ -31808,6 +34308,7 @@ var LocalRuntimePod = class _LocalRuntimePod {
           ...this.networkPolicy ? { policy: this.networkPolicy } : {}
         },
         spawnChild: (config2) => this.processManager.spawn(config2),
+        ipc: hostIpcTransport,
         ...typeof options.stdinPath === "string" ? { stdinPath: options.stdinPath } : {},
         ...options.interactiveStdin ? { interactiveStdin: true } : {},
         ...options.tty ? { tty: true } : {},
@@ -32182,13 +34683,20 @@ var WorkerProcess = class extends EventEmitter4 {
     for (const chunk of this.pendingInput.splice(0)) this.worker.postMessage({ type: "stdin", data: chunk });
     if (this.inputEnded) this.worker.postMessage({ type: "stdin-end" });
   }
-  output(text2) {
+  /** As in the in-realm pod: `output` is text, `raw-output` the bytes as written. */
+  rawOutput = true;
+  outText = new TextDecoder();
+  errText = new TextDecoder();
+  output(chunk) {
+    const text2 = typeof chunk === "string" ? chunk : this.outText.decode(chunk, { stream: true });
     this.out.push(text2);
-    this.emit("output", text2);
+    this.emit("raw-output", chunk);
+    if (text2) this.emit("output", text2);
   }
-  error(text2) {
+  error(chunk) {
+    const text2 = typeof chunk === "string" ? chunk : this.errText.decode(chunk, { stream: true });
     this.err.push(text2);
-    this.emit("error", text2);
+    if (text2) this.emit("error", text2);
   }
   /**
    * Deliver input to the running program.
@@ -32199,7 +34707,7 @@ var WorkerProcess = class extends EventEmitter4 {
    */
   write(data) {
     if (this.inheritedInput) {
-      this.inheritedInput.sendStdin(data);
+      this.inheritedInput.sendStdin(typeof data === "string" ? data : new TextDecoder().decode(data));
       return;
     }
     if (this.started) this.worker.postMessage({ type: "stdin", data });
@@ -32301,9 +34809,12 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
     const entry = { worker, server };
     this.live.add(entry);
     const ownedChildren = /* @__PURE__ */ new Set();
+    const channelEnds = /* @__PURE__ */ new Map();
     const process2 = new WorkerProcess(worker, () => {
       for (const child of ownedChildren) child.kill("SIGTERM");
       ownedChildren.clear();
+      for (const end of channelEnds.values()) end.disconnect();
+      channelEnds.clear();
       this.live.delete(entry);
       server.close();
       this.closeProxies(owner);
@@ -32318,10 +34829,10 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
           void server.pump();
           return;
         case "output":
-          process2.output(String(message.text));
+          process2.output(message.text instanceof Uint8Array ? message.text : String(message.text));
           return;
         case "error":
-          process2.error(String(message.text));
+          process2.error(message.text instanceof Uint8Array ? message.text : String(message.text));
           return;
         case "rawmode":
           process2.rawMode(Boolean(message.enabled));
@@ -32365,9 +34876,39 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
         case "child-stdin-end":
           children.get(message.id)?.endStdin?.();
           return;
+        case "child-fd":
+          children.get(message.id)?.writeFd?.(Number(message.fd), String(message.data));
+          return;
+        case "child-fd-end":
+          children.get(message.id)?.endFd?.(Number(message.fd));
+          return;
         case "child-kill":
           children.get(message.id)?.kill(String(message.signal));
           return;
+        case "ipc-attach": {
+          const key = `${message.side}:${message.id}`;
+          if (channelEnds.has(key)) return;
+          channelEnds.set(key, hostIpcTransport.attach(
+            String(message.id),
+            message.side === "child" ? "child" : "parent",
+            (value) => worker.postMessage({ type: "ipc-message", id: message.id, side: message.side, value }),
+            () => {
+              channelEnds.delete(key);
+              worker.postMessage({ type: "ipc-disconnect", id: message.id, side: message.side });
+            }
+          ));
+          return;
+        }
+        case "ipc-send":
+          channelEnds.get(`${message.side}:${message.id}`)?.send(message.value);
+          return;
+        case "ipc-close": {
+          const key = `${message.side}:${message.id}`;
+          const end = channelEnds.get(key);
+          channelEnds.delete(key);
+          end?.disconnect();
+          return;
+        }
         default:
           return;
       }
@@ -32397,7 +34938,7 @@ var WorkerRuntimePod = class _WorkerRuntimePod extends LocalRuntimePod {
       owned.delete(handle);
       children.delete(message.id);
     });
-    for (const event of ["stdout", "stderr", "exit"]) {
+    for (const event of ["stdout", "stderr", "exit", "fd"]) {
       handle.on(event, (value) => worker.postMessage({ type: "child-event", id: message.id, event, value }));
     }
     handle.exec();