sandboxedjs 0.1.21 → 0.1.23

package/dist/index.cjs

@@ -4,8 +4,44 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var nodepod = require('@scelar/nodepod');
 var acorn = require('acorn');
+var EventEmitter3 = require('events');
+var jsx = require('acorn-jsx');
+var resolve_exports = require('resolve.exports');
+var buffer = require('buffer');
+var pathModule = require('path-browserify');
+var streamModule3 = require('stream-browserify');
+var utilModule = require('util');
+var assertModule = require('assert');
+var processShim = require('process');
+var zlibModule = require('browserify-zlib');
+var querystringModule = require('querystring-es3');
+var stringDecoderModule = require('string_decoder');
+var timersModule = require('timers-browserify');
+var urlModule = require('url');
+var legacy = require('@noble/hashes/legacy');
+var sha256 = require('@noble/hashes/sha256');
+var sha512 = require('@noble/hashes/sha512');
+var hmac = require('@noble/hashes/hmac');
+var pako = require('pako');
+var sha1 = require('@noble/hashes/sha1');
+var semver = require('semver');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var EventEmitter3__default = /*#__PURE__*/_interopDefault(EventEmitter3);
+var jsx__default = /*#__PURE__*/_interopDefault(jsx);
+var pathModule__default = /*#__PURE__*/_interopDefault(pathModule);
+var streamModule3__default = /*#__PURE__*/_interopDefault(streamModule3);
+var utilModule__default = /*#__PURE__*/_interopDefault(utilModule);
+var assertModule__default = /*#__PURE__*/_interopDefault(assertModule);
+var processShim__default = /*#__PURE__*/_interopDefault(processShim);
+var zlibModule__default = /*#__PURE__*/_interopDefault(zlibModule);
+var querystringModule__default = /*#__PURE__*/_interopDefault(querystringModule);
+var stringDecoderModule__default = /*#__PURE__*/_interopDefault(stringDecoderModule);
+var timersModule__default = /*#__PURE__*/_interopDefault(timersModule);
+var urlModule__default = /*#__PURE__*/_interopDefault(urlModule);
+
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
@@ -1070,16 +1106,16 @@ function tokenize(src) {
   out.push({ kind: "eof", value: "" });
   return out;
 }
-function parseInBase(text, base) {
+function parseInBase(text2, base) {
   let value = 0;
-  for (const ch of text) {
+  for (const ch of text2) {
     let digit;
     if (base <= 36) {
       digit = DIGITS.toLowerCase().indexOf(ch.toLowerCase());
     } else {
       digit = DIGITS.indexOf(ch);
     }
-    if (digit < 0 || digit >= base) throw new exports.ArithError(`value too great for base (error token is "${text}")`);
+    if (digit < 0 || digit >= base) throw new exports.ArithError(`value too great for base (error token is "${text2}")`);
     value = value * base + digit;
   }
   return value;
@@ -1415,8 +1451,8 @@ function ifsOf(ctx) {
   const raw = ctx.vars.get("IFS");
   return raw === void 0 ? IFS_DEFAULT : raw;
 }
-function escapeGlob(text) {
-  return text.replace(/[*?[\]\\]/g, "\\$&");
+function escapeGlob(text2) {
+  return text2.replace(/[*?[\]\\]/g, "\\$&");
 }
 function braceExpand(word) {
   const open = findUnquotedBrace(word);
@@ -1572,12 +1608,12 @@ async function expandFragments(word, ctx, opts = {}) {
       literalGlob = true;
     }
   };
-  const pushLiteral = (text, globActive) => {
+  const pushLiteral = (text2, globActive) => {
     if (globActive !== literalGlob) {
       flushLiteral();
       literalGlob = globActive;
     }
-    literal += text;
+    literal += text2;
   };
   while (i < word.length) {
     const c = word[i];
@@ -1924,8 +1960,8 @@ async function expandBracedParameter(body, ctx, quoted) {
   }
   return valueFragments(name, ctx, quoted);
 }
-function frag(text, quoted) {
-  return { text, split: !quoted, glob: false };
+function frag(text2, quoted) {
+  return { text: text2, split: !quoted, glob: false };
 }
 function stripAffix(value, pattern, op, ctx) {
   const opts = { pathname: false, dot: true, extglob: ctx.extglob !== false };
@@ -2021,26 +2057,26 @@ function splitOnUnquotedColon(spec) {
   out.push(current);
   return out;
 }
-function findUnescaped(text, ch) {
-  for (let i = 0; i < text.length; i++) {
-    if (text[i] === "\\") {
+function findUnescaped(text2, ch) {
+  for (let i = 0; i < text2.length; i++) {
+    if (text2[i] === "\\") {
       i++;
       continue;
     }
-    if (text[i] === ch) return i;
+    if (text2[i] === ch) return i;
   }
   return -1;
 }
-function matchParen(text, open) {
+function matchParen(text2, open) {
   let depth = 0;
-  for (let i = open; i < text.length; i++) {
-    const c = text[i];
+  for (let i = open; i < text2.length; i++) {
+    const c = text2[i];
     if (c === "\\") {
       i++;
       continue;
     }
     if (c === "'") {
-      const end = text.indexOf("'", i + 1);
+      const end = text2.indexOf("'", i + 1);
       if (end < 0) return -1;
       i = end;
       continue;
@@ -2053,10 +2089,10 @@ function matchParen(text, open) {
   }
   return -1;
 }
-function matchDoubleParen(text, open) {
+function matchDoubleParen(text2, open) {
   let depth = 0;
-  for (let i = open; i < text.length; i++) {
-    const c = text[i];
+  for (let i = open; i < text2.length; i++) {
+    const c = text2[i];
     if (c === "\\") {
       i++;
       continue;
@@ -2069,21 +2105,21 @@ function matchDoubleParen(text, open) {
   }
   return -1;
 }
-function findBacktick(text, from) {
-  for (let i = from + 1; i < text.length; i++) {
-    if (text[i] === "\\") {
+function findBacktick(text2, from) {
+  for (let i = from + 1; i < text2.length; i++) {
+    if (text2[i] === "\\") {
       i++;
       continue;
     }
-    if (text[i] === "`") return i;
+    if (text2[i] === "`") return i;
   }
-  return text.length;
+  return text2.length;
 }
-function unescapeBacktick(text) {
-  return text.replace(/\\([`$\\])/g, "$1");
+function unescapeBacktick(text2) {
+  return text2.replace(/\\([`$\\])/g, "$1");
 }
-function stripTrailingNewlines(text) {
-  return text.replace(/\n+$/, "");
+function stripTrailingNewlines(text2) {
+  return text2.replace(/\n+$/, "");
 }
 function fieldSplit(fragments, ifs) {
   if (fragments.length === 0) return [];
@@ -2106,9 +2142,9 @@ function fieldSplit(fragments, ifs) {
     }
     let buffer = "";
     let i = 0;
-    const text = fragment.text;
-    while (i < text.length) {
-      const c = text[i];
+    const text2 = fragment.text;
+    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 });
@@ -2118,8 +2154,8 @@ function fieldSplit(fragments, ifs) {
         }
         let consumedNonWs = others.includes(c);
         i++;
-        while (i < text.length) {
-          const d = text[i];
+        while (i < text2.length) {
+          const d = text2[i];
           if (whitespace.includes(d)) {
             i++;
             continue;
@@ -2807,13 +2843,13 @@ function builtinEcho({ argv, io }) {
     }
     args = args.slice(1);
   }
-  let text = args.join(" ");
+  let text2 = args.join(" ");
   if (interpret) {
-    const decoded = decodeEscapes(text, { stopAtC: true });
-    text = decoded.text;
+    const decoded = decodeEscapes(text2, { stopAtC: true });
+    text2 = decoded.text;
     if (decoded.stopped) newline = false;
   }
-  io.stdout.write(newline ? text + "\n" : text);
+  io.stdout.write(newline ? text2 + "\n" : text2);
   return 0;
 }
 function builtinPrintf({ argv, io }) {
@@ -2830,9 +2866,9 @@ function builtinPrintf({ argv, io }) {
     return 2;
   }
   try {
-    const text = formatPrintf(format, args.slice(start + 1));
+    const text2 = formatPrintf(format, args.slice(start + 1));
     if (varName) return 0;
-    io.stdout.write(text);
+    io.stdout.write(text2);
     return 0;
   } catch (e) {
     io.stderr.write(`printf: ${e instanceof PrintfError ? e.message : String(e)}
@@ -2915,9 +2951,9 @@ async function builtinSource({ shell, argv, io }) {
     const found = shell.kernel.which(target, shell.cwd, shell.vars.environment(), shell.cred);
     if (found) path = found;
   }
-  let text;
+  let text2;
   try {
-    text = shell.kernel.vfs.readText(path, shell.cred);
+    text2 = shell.kernel.vfs.readText(path, shell.cred);
   } catch {
     io.stderr.write(`${argv[0]}: ${target}: No such file or directory
 `);
@@ -2926,7 +2962,7 @@ async function builtinSource({ shell, argv, io }) {
   const savedPositional = shell.positional;
   if (argv.length > 2) shell.positional = argv.slice(2);
   try {
-    return await shell.execute(text, io);
+    return await shell.execute(text2, io);
   } finally {
     shell.positional = savedPositional;
   }
@@ -4228,9 +4264,9 @@ var init_ffmpeg_core = __esm({
         }
         var wasmMemory;
         var ABORT = false;
-        function assert(condition, text) {
+        function assert(condition, text2) {
           if (!condition) {
-            abort(text);
+            abort(text2);
           }
         }
         var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPF64;
@@ -6721,8 +6757,8 @@ var init_ffmpeg_core = __esm({
           };
           function handleMessage(data) {
             if (typeof data == "string") {
-              var encoder6 = new TextEncoder();
-              data = encoder6.encode(data);
+              var encoder7 = new TextEncoder();
+              data = encoder7.encode(data);
             } else {
               assert(data.byteLength !== void 0);
               if (data.byteLength == 0) {
@@ -8805,15 +8841,15 @@ async function buildPatchedWorker() {
 function ensureEsbuild() {`)
   ].join("\n");
   const fingerprint = crypto2.createHash("sha256").update(`${source.length}:${wasmStat.size}:${patched.length}`).digest("hex").slice(0, 16);
-  const cached = path.join(os.tmpdir(), `sandboxedjs-worker-${fingerprint}.js`);
+  const cached2 = path.join(os.tmpdir(), `sandboxedjs-worker-${fingerprint}.js`);
   try {
-    await fs.access(cached);
+    await fs.access(cached2);
   } catch {
-    const staging = `${cached}.${process.pid}.tmp`;
+    const staging = `${cached2}.${process.pid}.tmp`;
     await fs.writeFile(staging, patched, "utf8");
-    await fs.rename(staging, cached);
+    await fs.rename(staging, cached2);
   }
-  return cached;
+  return cached2;
 }
 var INIT_HELPER = `let __sandboxedjsWasmUrl = null;
 async function __sandboxedjsEsbuildInit(wasmPath, wasmUrl) {
@@ -10398,16 +10434,16 @@ function createContext(init) {
     path(p) {
       return resolve(cwd, p);
     },
-    write(text) {
+    write(text2) {
       try {
-        stdout.write(text);
+        stdout.write(text2);
       } catch (e) {
         if (isSysError(e) && e.code === "EPIPE") proc.deliver("SIGPIPE");
         else throw e;
       }
     },
-    line(text = "") {
-      ctx.write(encoder3.encode(text + "\n"));
+    line(text2 = "") {
+      ctx.write(encoder3.encode(text2 + "\n"));
     },
     warn(message) {
       try {
@@ -11284,8 +11320,8 @@ function createProcProvider(kernel) {
     loadavg: () => textFile(() => {
       const running = kernel.procs.list().filter((p) => p.state === "R").length;
       const total = kernel.procs.list().length;
-      const load = (running / kernel.cpus).toFixed(2);
-      return `${load} ${load} ${load} ${running}/${total} ${kernel.procs.list().length + 1}
+      const load2 = (running / kernel.cpus).toFixed(2);
+      return `${load2} ${load2} ${load2} ${running}/${total} ${kernel.procs.list().length + 1}
 `;
     }),
     meminfo: () => textFile(() => {
@@ -11541,13 +11577,13 @@ var NetworkStack = class {
   /** Resolve through `/etc/hosts`; returns null when the name is not local. */
   resolve(host2) {
     if (/^\d+\.\d+\.\d+\.\d+$/.test(host2)) return host2;
-    let text = "";
+    let text2 = "";
     try {
-      text = this.vfs.readText("/etc/hosts");
+      text2 = this.vfs.readText("/etc/hosts");
     } catch {
       return null;
     }
-    for (const line of text.split("\n")) {
+    for (const line of text2.split("\n")) {
       const clean2 = line.split("#")[0].trim();
       if (clean2 === "") continue;
       const [addr, ...names] = clean2.split(/\s+/);
@@ -11906,9 +11942,9 @@ var Lexer = class _Lexer {
       }
     }
     if (i >= this.src.length) throw new IncompleteInputError(`unexpected EOF while looking for matching \`${close}'`, start);
-    const text = prefix + this.src.slice(openIdx, i + 1);
+    const text2 = prefix + this.src.slice(openIdx, i + 1);
     this.pos = i + 1;
-    return text;
+    return text2;
   }
   skipDoubleQuoted(from) {
     for (let i = from + 1; i < this.src.length; i++) {
@@ -12748,8 +12784,8 @@ var Shell = class _Shell {
   async makeProcessSubstitution(command, direction) {
     const path = `/tmp/.sbx-procsub-${this.proc.pid}-${this.tempFileCounter++}`;
     if (direction === "in") {
-      const text = await this.captureSubshell(command);
-      this.kernel.vfs.writeFile(path, text, { cred: this.cred, mode: 384 });
+      const text2 = await this.captureSubshell(command);
+      this.kernel.vfs.writeFile(path, text2, { cred: this.cred, mode: 384 });
     } else {
       this.kernel.vfs.writeFile(path, "", { cred: this.cred, mode: 384 });
     }
@@ -13530,12 +13566,12 @@ sys	${fmt2(Math.floor(ms * 0.2))}
     return finished;
   }
 };
-function splitAliasWords(text) {
+function splitAliasWords(text2) {
   const out = [];
   let current = "";
   let quote2 = null;
-  for (let i = 0; i < text.length; i++) {
-    const c = text[i];
+  for (let i = 0; i < text2.length; i++) {
+    const c = text2[i];
     if (quote2) {
       if (c === quote2) quote2 = null;
       else current += c;
@@ -13723,10 +13759,10 @@ async function readInputs(ctx, operands, opts = {}) {
   return { sources, ok };
 }
 function splitLines(bytes) {
-  const text = decoder3.decode(bytes);
-  if (text === "") return { lines: [], trailingNewline: true };
-  const trailingNewline = text.endsWith("\n");
-  const body = trailingNewline ? text.slice(0, -1) : text;
+  const text2 = decoder3.decode(bytes);
+  if (text2 === "") return { lines: [], trailingNewline: true };
+  const trailingNewline = text2.endsWith("\n");
+  const body = trailingNewline ? text2.slice(0, -1) : text2;
   return { lines: body.split("\n"), trailingNewline };
 }
 function joinLines(lines, trailingNewline = true) {
@@ -13782,9 +13818,9 @@ function columnize(items, width, gap = 2) {
   }
   return out;
 }
-function displayWidth(text) {
+function displayWidth(text2) {
   let width = 0;
-  for (const ch of text) {
+  for (const ch of text2) {
     const code = ch.codePointAt(0);
     if (code >= 4352 && (code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510)) {
       width += 2;
@@ -14060,9 +14096,9 @@ var cat = defineCommand({
         ctx.write(bytes);
         continue;
       }
-      const text = new TextDecoder().decode(bytes);
-      const hadTrailing = text.endsWith("\n");
-      const parts = (hadTrailing ? text.slice(0, -1) : text).split("\n");
+      const text2 = new TextDecoder().decode(bytes);
+      const hadTrailing = text2.endsWith("\n");
+      const parts = (hadTrailing ? text2.slice(0, -1) : text2).split("\n");
       for (const raw of parts) {
         if (args.has("squeeze-blank")) {
           if (raw === "" && lastWasBlank) continue;
@@ -14922,11 +14958,11 @@ function describeFile(ctx, abs, st, mime) {
   if (magic[0] === 31 && magic[1] === 139) return mime ? "application/gzip" : "gzip compressed data";
   if (magic[0] === 80 && magic[1] === 75) return mime ? "application/zip" : "Zip archive data";
   if (magic[0] === 137 && magic[1] === 80) return mime ? "image/png" : "PNG image data";
-  const text = new TextDecoder().decode(bytes);
-  const printable = [...text].every((c) => c === "\n" || c === "	" || c === "\r" || c >= " " && c <= "~" || c.charCodeAt(0) > 127);
+  const text2 = new TextDecoder().decode(bytes);
+  const printable = [...text2].every((c) => c === "\n" || c === "	" || c === "\r" || c >= " " && c <= "~" || c.charCodeAt(0) > 127);
   if (!printable) return mime ? "application/octet-stream" : "data";
-  if (text.startsWith("#!")) {
-    const interp = text.slice(2, text.indexOf("\n")).trim();
+  if (text2.startsWith("#!")) {
+    const interp = text2.slice(2, text2.indexOf("\n")).trim();
     return mime ? "text/x-shellscript" : `a ${interp} script, ASCII text executable`;
   }
   const ext = extname(abs);
@@ -14979,13 +15015,13 @@ var echo = defineCommand({
       }
       args = args.slice(1);
     }
-    let text = args.join(" ");
+    let text2 = args.join(" ");
     if (interpret) {
-      const decoded = decodeEscapes(text, { stopAtC: true });
-      text = decoded.text;
+      const decoded = decodeEscapes(text2, { stopAtC: true });
+      text2 = decoded.text;
       if (decoded.stopped) newline = false;
     }
-    ctx.write(newline ? text + "\n" : text);
+    ctx.write(newline ? text2 + "\n" : text2);
     return 0;
   }
 });
@@ -15056,8 +15092,8 @@ var yesCmd = defineCommand({
   path: "/usr/bin/yes",
   summary: "output a string repeatedly until killed",
   async run(ctx) {
-    const text = (ctx.args.length ? ctx.args.join(" ") : "y") + "\n";
-    const block = text.repeat(512);
+    const text2 = (ctx.args.length ? ctx.args.join(" ") : "y") + "\n";
+    const block = text2.repeat(512);
     for (let i = 0; i < 1e5 && !ctx.signal.aborted && !ctx.stdout.closed; i++) {
       ctx.write(block);
       await new Promise((r) => setTimeout(r, 0));
@@ -15099,8 +15135,8 @@ var seq = defineCommand({
     if (increment > 0) for (let v = first; v <= last + 1e-9; v += increment) values.push(v);
     else for (let v = first; v >= last - 1e-9; v += increment) values.push(v);
     const rendered = values.map((v) => {
-      const text = Number.isInteger(v) ? String(v) : String(Number(v.toFixed(10)));
-      return format ? formatPrintf(format, [String(v)]) : text;
+      const text2 = Number.isInteger(v) ? String(v) : String(Number(v.toFixed(10)));
+      return format ? formatPrintf(format, [String(v)]) : text2;
     });
     const width = args.has("equal-width") ? Math.max(0, ...rendered.map((r) => r.length)) : 0;
     const out = rendered.map((r) => width ? r.padStart(width, "0") : r);
@@ -16086,8 +16122,8 @@ var ScriptParser = class {
     return { type: "y", range, from: [...unescape(from)], to: [...unescape(to)] };
   }
 };
-function unescape(text) {
-  return text.replace(/\\(.)/g, (_, c) => ({ n: "\n", t: "	", r: "\r", "\\": "\\" })[c] ?? c);
+function unescape(text2) {
+  return text2.replace(/\\(.)/g, (_, c) => ({ n: "\n", t: "	", r: "\r", "\\": "\\" })[c] ?? c);
 }
 function toJsRegex(pattern, extended) {
   let out = "";
@@ -16193,15 +16229,15 @@ var BRACKET_CLASSES = {
   xdigit: "0-9A-Fa-f",
   word: "A-Za-z0-9_"
 };
-function translateBracket(text) {
-  return text.replace(/\[:([a-z]+):\]/g, (_, name) => BRACKET_CLASSES[name] ?? "");
+function translateBracket(text2) {
+  return text2.replace(/\[:([a-z]+):\]/g, (_, name) => BRACKET_CLASSES[name] ?? "");
 }
 function applyReplacement(replacement, match) {
   let out = "";
   let caseMode = null;
   let oneShot = null;
-  const emit = (text) => {
-    let value = text;
+  const emit = (text2) => {
+    let value = text2;
     if (oneShot && value.length > 0) {
       value = (oneShot === "u" ? value[0].toUpperCase() : value[0].toLowerCase()) + value.slice(1);
       oneShot = null;
@@ -16331,20 +16367,20 @@ async function runSed(ctx) {
       flushAppends(state);
       if (state.quit !== null) break;
     }
-    const text = joinLines(state.output, trailingNewline || state.output.length > 0);
+    const text2 = joinLines(state.output, trailingNewline || state.output.length > 0);
     if (inPlace && source.name !== "-" && source.name !== "standard input") {
       const abs = ctx.path(source.name);
       if (suffix) ctx.vfs.writeFile(ctx.path(source.name + suffix), source.bytes, { cred: ctx.cred });
-      ctx.vfs.writeFile(abs, text, { cred: ctx.cred });
+      ctx.vfs.writeFile(abs, text2, { cred: ctx.cred });
     } else {
-      ctx.write(text);
+      ctx.write(text2);
     }
     if (state.quit !== null && state.quit !== 0) status = state.quit;
   }
   return status;
 }
 function flushAppends(state) {
-  for (const text of state.appendQueue) state.output.push(text);
+  for (const text2 of state.appendQueue) state.output.push(text2);
   state.appendQueue = [];
 }
 function resetRanges(program) {
@@ -16530,8 +16566,8 @@ function substitute2(input, regex, replacement, global, occurrence) {
   out += input.slice(last);
   return { text: out, changed };
 }
-function escapeForL(text) {
-  return [...text].map((ch) => {
+function escapeForL(text2) {
+  return [...text2].map((ch) => {
     const code = ch.charCodeAt(0);
     if (ch === "\\") return "\\\\";
     if (ch === "	") return "\\t";
@@ -16743,10 +16779,10 @@ function tokenize2(src) {
             i += 2;
             continue;
           }
-          const octal = /^[0-7]{1,3}/.exec(src.slice(i + 1));
-          if (octal) {
-            value += String.fromCharCode(parseInt(octal[0], 8));
-            i += 1 + octal[0].length;
+          const octal2 = /^[0-7]{1,3}/.exec(src.slice(i + 1));
+          if (octal2) {
+            value += String.fromCharCode(parseInt(octal2[0], 8));
+            i += 1 + octal2[0].length;
             continue;
           }
           value += next;
@@ -17498,9 +17534,9 @@ var Interpreter = class {
     return this.numToStr(v.num, this.toStrRaw(this.globals.get("OFMT")));
   }
   // ── output ────────────────────────────────────────────────────────────────
-  emit(text, redirect) {
+  emit(text2, redirect) {
     if (!redirect) {
-      this.pendingOutput += text;
+      this.pendingOutput += text2;
       if (this.pendingOutput.length > 8192) this.flush();
       return;
     }
@@ -17510,7 +17546,7 @@ var Interpreter = class {
       target = this.openOutput(name, redirect.op);
       this.outputs.set(name, target);
     }
-    target.write(text);
+    target.write(text2);
   }
   flush() {
     if (this.pendingOutput !== "") {
@@ -17524,8 +17560,8 @@ var Interpreter = class {
       const ctx = this.ctx;
       const self2 = this;
       return {
-        write: (text) => {
-          buffer += text;
+        write: (text2) => {
+          buffer += text2;
         },
         close: () => {
           self2.flush();
@@ -17543,18 +17579,18 @@ var Interpreter = class {
       };
     }
     if (name === "/dev/stdout" || name === "-") {
-      return { write: (text) => this.ctx.write(text), close: () => {
+      return { write: (text2) => this.ctx.write(text2), close: () => {
       } };
     }
     if (name === "/dev/stderr") {
-      return { write: (text) => this.ctx.stderr.write(text), close: () => {
+      return { write: (text2) => this.ctx.stderr.write(text2), close: () => {
       } };
     }
     const abs = this.ctx.path(name);
     if (op === ">") this.ctx.vfs.writeFile(abs, "", { cred: this.ctx.cred });
     else if (!this.ctx.vfs.lexists(abs)) this.ctx.vfs.writeFile(abs, "", { cred: this.ctx.cred });
     return {
-      write: (text) => this.ctx.vfs.appendFile(abs, text, { cred: this.ctx.cred }),
+      write: (text2) => this.ctx.vfs.appendFile(abs, text2, { cred: this.ctx.cred }),
       close: () => {
       }
     };
@@ -17916,8 +17952,8 @@ var Interpreter = class {
       let handle = this.inputs.get(name);
       if (!handle) {
         try {
-          const text = this.ctx.vfs.readText(this.ctx.path(name), this.ctx.cred);
-          handle = { lines: splitLines(new TextEncoder().encode(text)).lines, index: 0 };
+          const text2 = this.ctx.vfs.readText(this.ctx.path(name), this.ctx.cred);
+          handle = { lines: splitLines(new TextEncoder().encode(text2)).lines, index: 0 };
         } catch {
           return Value.fromNumber(-1);
         }
@@ -17956,8 +17992,8 @@ var Interpreter = class {
       case "print": {
         const ofs = this.toStr(this.getVar("OFS"));
         const ors = this.toStr(this.getVar("ORS"));
-        const text = stmt.args.length === 0 ? this.toStr(this.getField(0)) : stmt.args.map((a) => this.outputStr(this.evaluate(a))).join(ofs);
-        this.emit(text + ors, stmt.redirect);
+        const text2 = stmt.args.length === 0 ? this.toStr(this.getField(0)) : stmt.args.map((a) => this.outputStr(this.evaluate(a))).join(ofs);
+        this.emit(text2 + ors, stmt.redirect);
         return;
       }
       case "printf": {
@@ -18442,13 +18478,13 @@ var wc = defineCommand({
     const totals = { lines: 0, words: 0, bytes: 0, chars: 0, maxLine: 0 };
     const rows = [];
     for (const source of sources) {
-      const text = decoder4.decode(source.bytes);
+      const text2 = decoder4.decode(source.bytes);
       const counts = {
-        lines: (text.match(/\n/g) ?? []).length,
-        words: text.split(/\s+/).filter((w) => w !== "").length,
+        lines: (text2.match(/\n/g) ?? []).length,
+        words: text2.split(/\s+/).filter((w) => w !== "").length,
         bytes: source.bytes.length,
-        chars: [...text].length,
-        maxLine: Math.max(0, ...text.split("\n").map((l) => displayWidth(l)))
+        chars: [...text2].length,
+        maxLine: Math.max(0, ...text2.split("\n").map((l) => displayWidth(l)))
       };
       totals.lines += counts.lines;
       totals.words += counts.words;
@@ -18515,15 +18551,15 @@ var sort = defineCommand({
       const slice = fields.slice(start, end === void 0 ? void 0 : end);
       return slice.join(separator ?? " ");
     };
-    const normalize2 = (line) => {
+    const normalize3 = (line) => {
       let value = keys.length ? fieldOf(line, keys[0]) : line;
       if (args.has("ignore-leading-blanks")) value = value.replace(/^\s+/, "");
       if (args.has("ignore-case")) value = value.toLowerCase();
       return value;
     };
     const compare = (a, b) => {
-      const x = normalize2(a);
-      const y = normalize2(b);
+      const x = normalize3(a);
+      const y = normalize3(b);
       if (args.has("numeric-sort") || args.has("general-numeric-sort")) {
         const nx = parseFloat(x) || 0;
         const ny = parseFloat(y) || 0;
@@ -18614,9 +18650,9 @@ var uniq = defineCommand({
       }
       out.push(args.has("count") ? `${String(group.count).padStart(7)} ${group.line}` : group.line);
     }
-    const text = joinLines(out, true);
-    if (output) ctx.vfs.writeFile(ctx.path(output), text, { cred: ctx.cred });
-    else ctx.write(text);
+    const text2 = joinLines(out, true);
+    if (output) ctx.vfs.writeFile(ctx.path(output), text2, { cred: ctx.cred });
+    else ctx.write(text2);
     return ok ? 0 : 1;
   }
 });
@@ -18726,11 +18762,11 @@ var tr = defineCommand({
     if (set1Raw === void 0) return ctx.fail("missing operand", 1);
     const set1 = expandSet(set1Raw);
     const set2 = set2Raw === void 0 ? [] : expandSet(set2Raw);
-    const text = decoder4.decode(await ctx.stdin.readAll());
+    const text2 = decoder4.decode(await ctx.stdin.readAll());
     const inSet1 = (ch) => args.has("complement") ? !set1.includes(ch) : set1.includes(ch);
     let out = "";
     let lastEmitted = "";
-    for (const ch of text) {
+    for (const ch of text2) {
       if (args.has("delete") && inSet1(ch)) continue;
       let mapped = ch;
       if (!args.has("delete") && set2.length && inSet1(ch)) {
@@ -19401,12 +19437,12 @@ var grep = defineCommand({
             }
             continue;
           }
-          let text = lines[i];
+          let text2 = lines[i];
           if (useColor && isMatchLine && !args.has("invert-match")) {
             regex.lastIndex = 0;
-            text = text.replace(regex, (m) => `\x1B[1;31m${m}\x1B[0m`);
+            text2 = text2.replace(regex, (m) => `\x1B[1;31m${m}\x1B[0m`);
           }
-          ctx.line(prefix + text);
+          ctx.line(prefix + text2);
           lastPrinted = i;
         }
       }
@@ -19414,8 +19450,8 @@ var grep = defineCommand({
     return anyMatch ? status === 2 ? 2 : 0 : status === 2 ? 2 : 1;
   }
 });
-function escapeLiteral(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeLiteral(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var find = defineCommand({
   name: "find",
@@ -19764,7 +19800,7 @@ var diff = defineCommand({
     if (a === void 0 || b === void 0) return ctx.fail("missing operand", 2);
     const { sources, ok } = await readInputs(ctx, [a, b]);
     if (!ok || sources.length < 2) return 2;
-    const normalize2 = (line) => {
+    const normalize3 = (line) => {
       let value = line;
       if (args.has("ignore-all-space")) value = value.replace(/\s+/g, "");
       else if (args.has("ignore-space-change")) value = value.replace(/\s+/g, " ").trim();
@@ -19773,7 +19809,7 @@ var diff = defineCommand({
     };
     const left = splitLines(sources[0].bytes).lines;
     const right = splitLines(sources[1].bytes).lines;
-    const script = diffLines(left.map(normalize2), right.map(normalize2));
+    const script = diffLines(left.map(normalize3), right.map(normalize3));
     if (script.length === 0) return 0;
     if (args.has("brief")) {
       ctx.line(`Files ${a} and ${b} differ`);
@@ -19936,8 +19972,8 @@ function writeString(block, offset, value, length) {
   for (let i = 0; i < length; i++) block[offset + i] = i < bytes.length ? bytes[i] : 0;
 }
 function writeOctal(block, offset, value, length) {
-  const text = value.toString(8).padStart(length - 1, "0");
-  writeString(block, offset, text, length);
+  const text2 = value.toString(8).padStart(length - 1, "0");
+  writeString(block, offset, text2, length);
 }
 function readString(block, offset, length) {
   let end = offset;
@@ -19945,8 +19981,8 @@ function readString(block, offset, length) {
   return decoder6.decode(block.subarray(offset, end));
 }
 function readOctal(block, offset, length) {
-  const text = readString(block, offset, length).trim();
-  return text === "" ? 0 : parseInt(text, 8) || 0;
+  const text2 = readString(block, offset, length).trim();
+  return text2 === "" ? 0 : parseInt(text2, 8) || 0;
 }
 function createTar(entries) {
   const blocks = [];
@@ -20341,9 +20377,9 @@ var base64Cmd = defineCommand({
     const { sources, ok } = await readInputs(ctx, args.positional);
     for (const source of sources) {
       if (args.has("decode")) {
-        const text = new TextDecoder().decode(source.bytes).replace(/\s+/g, "");
+        const text2 = new TextDecoder().decode(source.bytes).replace(/\s+/g, "");
         try {
-          ctx.write(new Uint8Array(Buffer.from(text, "base64")));
+          ctx.write(new Uint8Array(Buffer.from(text2, "base64")));
         } catch {
           return ctx.fail("invalid input");
         }
@@ -20370,11 +20406,11 @@ var base32Cmd = defineCommand({
     const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
     for (const source of sources) {
       if (args.has("decode")) {
-        const text = new TextDecoder().decode(source.bytes).replace(/[\s=]/g, "").toUpperCase();
+        const text2 = new TextDecoder().decode(source.bytes).replace(/[\s=]/g, "").toUpperCase();
         const out2 = [];
         let bits2 = 0;
         let value2 = 0;
-        for (const ch of text) {
+        for (const ch of text2) {
           const idx = ALPHABET.indexOf(ch);
           if (idx < 0) continue;
           value2 = value2 << 5 | idx;
@@ -21417,8 +21453,8 @@ var man = defineCommand({
     return 0;
   }
 });
-function capitalize(text) {
-  return text.length ? text[0].toUpperCase() + text.slice(1) : text;
+function capitalize(text2) {
+  return text2.length ? text2[0].toUpperCase() + text2.slice(1) : text2;
 }
 var whatis = defineCommand({
   name: "whatis",
@@ -21583,7 +21619,8 @@ async function execute(ctx, invocation) {
   try {
     const proc = await pod.spawn("node", [invocation.script], {
       cwd: ctx.cwd,
-      env: { ...ctx.env, PWD: ctx.cwd }
+      env: { ...ctx.env, PWD: ctx.cwd },
+      argv: ["/usr/bin/node", invocation.argvPath ?? invocation.script, ...invocation.argv]
     });
     proc.on("output", (chunk) => {
       try {
@@ -21762,7 +21799,7 @@ Error: Cannot find module '${ctx.path(scriptArg)}'
         mode: 384
       });
       temps.push(sibling);
-      return await execute(ctx, { script: sibling, argv: scriptArgs, temps });
+      return await execute(ctx, { script: sibling, argvPath: script, argv: scriptArgs, temps });
     } catch {
       return await execute(ctx, { script, argv: scriptArgs, temps });
     }
@@ -22163,6 +22200,8 @@ var RESERVED_FOR_INTERPRETER = /* @__PURE__ */ new Set(["lib", "dev", "proc"]);
 var pyodideModule = null;
 var indexUrl;
 var moduleUrl;
+var DEFAULT_BROWSER_INDEX_URL = "https://cdn.jsdelivr.net/pyodide/v0.28.3/full/";
+var isNode2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 function configureCPython(options = {}) {
   if (options.indexURL !== void 0) indexUrl = options.indexURL;
   if (options.moduleURL !== void 0) {
@@ -22172,19 +22211,27 @@ function configureCPython(options = {}) {
 }
 function importPyodide() {
   if (!pyodideModule) {
-    const specifier = moduleUrl ?? ["py", "odide"].join("");
-    pyodideModule = import(
-      /* @vite-ignore */
-      /* webpackIgnore: true */
-      specifier
-    );
+    if (moduleUrl) {
+      pyodideModule = import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        moduleUrl
+      );
+    } else if (isNode2) {
+      pyodideModule = nodeOnlyModule("pyodide");
+    } else {
+      pyodideModule = import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        `${DEFAULT_BROWSER_INDEX_URL}pyodide.mjs`
+      );
+    }
   }
   return pyodideModule;
 }
-var isNode2 = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 async function resolveIndexUrl() {
   if (indexUrl) return indexUrl;
-  if (!isNode2) return void 0;
+  if (!isNode2) return DEFAULT_BROWSER_INDEX_URL;
   try {
     const { createRequire } = await nodeBuiltin("module");
     const path = await nodeBuiltin("path");
@@ -22309,8 +22356,8 @@ function reportError(ctx, error) {
     ctx.stderr.write("KeyboardInterrupt\n");
     return 130;
   }
-  const text = message.replace(/^PythonError:\s*/, "");
-  ctx.stderr.write(text.endsWith("\n") ? text : `${text}
+  const text2 = message.replace(/^PythonError:\s*/, "");
+  ctx.stderr.write(text2.endsWith("\n") ? text2 : `${text2}
 `);
   return 1;
 }
@@ -22335,7 +22382,7 @@ async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
     });
   } catch {
   }
-  const encoder6 = new TextEncoder();
+  const encoder7 = new TextEncoder();
   const decoder7 = new TextDecoder();
   py.setStdout({
     write: (buffer) => {
@@ -22350,7 +22397,7 @@ async function runCPythonProgram(ctx, source, argv, scriptDir, stdinText) {
     }
   });
   if (stdinText !== null) {
-    const bytes = encoder6.encode(stdinText);
+    const bytes = encoder7.encode(stdinText);
     let offset = 0;
     py.setStdin({
       read: (buffer) => {
@@ -22723,8 +22770,8 @@ function renameShadowedExports(source) {
   const replacement = freshName(source);
   let out = source;
   for (const target of [...targets].sort((a, b) => b.start - a.start)) {
-    const text = target.shorthand ? `${NAME}: ${replacement}` : replacement;
-    out = out.slice(0, target.start) + text + out.slice(target.end);
+    const text2 = target.shorthand ? `${NAME}: ${replacement}` : replacement;
+    out = out.slice(0, target.start) + text2 + out.slice(target.end);
   }
   return out;
   function visit(node2, scope) {
@@ -22943,11 +22990,11 @@ function splitPackageSpec(spec) {
   return { name: spec.slice(0, at), version: spec.slice(at + 1) };
 }
 async function installPackages(ctx, specs, opts) {
-  const installer = opts.cwd === "/" ? ctx.kernel.pod.packages : new nodepod.DependencyInstaller(ctx.vfs.volume, { cwd: opts.cwd });
+  const installer = opts.cwd === "/" ? ctx.kernel.pod.packages : ctx.kernel.pod.packages.forCwd?.(opts.cwd) ?? new nodepod.DependencyInstaller(ctx.vfs.volume, { cwd: opts.cwd });
   const onProgress = (message) => {
     if (!opts.quiet) ctx.stderr.write(message.endsWith("\n") ? message : message + "\n");
   };
-  const note = (text) => opts.quiet ? ctx.stderr.write(text + "\n") : ctx.line(text);
+  const note = (text2) => opts.quiet ? ctx.stderr.write(text2 + "\n") : ctx.line(text2);
   if (!ctx.kernel.net.options.allowOutbound) {
     ctx.warn("npm error code ENOTFOUND");
     ctx.warn("npm error network request to https://registry.npmjs.org failed");
@@ -23002,7 +23049,13 @@ var npm = defineCommand({
       case "version":
         ctx.line(NPM_VERSION);
         return 0;
+      /* `npm create vite@latest` and `npm init vite` are the same command, and
+       * both are `npx` against a conventionally-named package. Only a bare
+       * `npm init` with no initializer writes a package.json. */
+      case "create":
+        return await runInitializer(ctx, rest);
       case "init": {
+        if (rest[0] && !rest[0].startsWith("-")) return await runInitializer(ctx, rest);
         const existing = readManifest(ctx, ctx.cwd);
         if (existing && !rest.includes("-f") && !rest.includes("--force")) {
           ctx.warn("package.json already exists");
@@ -23184,9 +23237,9 @@ function normalizeBinDirectories(ctx, root) {
         const st = ctx.vfs.lstat(path);
         if (st.isDirectory()) continue;
         if (!st.isSymbolicLink()) {
-          const text = ctx.vfs.readText(path, ctx.cred);
-          if (!text.startsWith("#!")) {
-            ctx.vfs.writeFile(path, "#!/bin/sh\n" + text, { privileged: true, mode: 493 });
+          const text2 = ctx.vfs.readText(path, ctx.cred);
+          if (!text2.startsWith("#!")) {
+            ctx.vfs.writeFile(path, "#!/bin/sh\n" + text2, { privileged: true, mode: 493 });
           }
         }
         ctx.vfs.chmod(path, 493, ctx.cred);
@@ -23252,6 +23305,26 @@ function findLocalBin(ctx, name) {
   }
   return null;
 }
+async function runInitializer(ctx, args) {
+  const [spec, ...rest] = args;
+  const { name, version } = splitPackageSpec(spec);
+  const suffix = version ? `@${version}` : "";
+  let packageName;
+  if (!name.startsWith("@")) {
+    packageName = `create-${name}`;
+  } else if (name.includes("/")) {
+    const [scope, unscoped2] = name.split("/");
+    packageName = `${scope}/create-${unscoped2}`;
+  } else {
+    packageName = `${name}/create`;
+  }
+  const forwarded = rest.filter((argument) => argument !== "--");
+  return await npx.run({
+    ...ctx,
+    args: ["-y", "--package", `${packageName}${suffix}`, basename(packageName), ...forwarded],
+    argv: ["npx", ...forwarded]
+  });
+}
 var npx = defineCommand({
   name: "npx",
   path: "/usr/bin/npx",
@@ -23696,16 +23769,16 @@ var Session = class {
     const combined = [];
     const decoder7 = new TextDecoder();
     const stdout = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
-      combined.push(text);
-      opts.onStdout?.(text);
-      this.hooks.onStdout?.(text);
+      const text2 = decoder7.decode(chunk, { stream: true });
+      combined.push(text2);
+      opts.onStdout?.(text2);
+      this.hooks.onStdout?.(text2);
     });
     const stderr = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
-      combined.push(text);
-      opts.onStderr?.(text);
-      this.hooks.onStderr?.(text);
+      const text2 = decoder7.decode(chunk, { stream: true });
+      combined.push(text2);
+      opts.onStderr?.(text2);
+      this.hooks.onStderr?.(text2);
     });
     if (opts.tty) {
       stdout.isTTY = true;
@@ -23841,9 +23914,9 @@ var KernelChildProcess = class {
     this.exitCode = code;
     this.emit("exit", code);
   }
-  append(stream, text) {
-    this[stream] += text;
-    this.emit(stream, text);
+  append(stream, text2) {
+    this[stream] += text2;
+    this.emit(stream, text2);
   }
 };
 var ChildOutput = class {
@@ -23861,8 +23934,8 @@ var ChildOutput = class {
   }
   write(data) {
     if (this.closedState) return;
-    const text = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
-    if (text) this.child.append(this.stream, text);
+    const text2 = typeof data === "string" ? data : this.decoder.decode(data, { stream: true });
+    if (text2) this.child.append(this.stream, text2);
   }
   end() {
     if (this.closedState) return;
@@ -23888,6 +23961,3286 @@ function installNodeChildProcessBridge(pod, kernel, cred) {
   };
 }
 
+// src/runtime/commonjs-engine.ts
+init_path();
+var HELPERS = {
+  /** Import a specifier and return an ES-module-shaped namespace. */
+  import: "__sbxImport",
+  /** `import(...)`, returning a promise of a namespace. */
+  dynamic: "__sbxDynamicImport",
+  /** `export * from` — copy live bindings onto `exports`. */
+  exportAll: "__sbxExportAll",
+  /** `import.meta`. */
+  meta: "__sbxMeta",
+  /**
+   * The exports object, under a name of the engine's choosing.
+   *
+   * An ES module is free to declare its own top-level `exports`, `require` or
+   * `__dirname` — they are ordinary identifiers there, and real packages use
+   * all three (`const require = createRequire(import.meta.url)` is close to
+   * idiomatic). Naming the wrapper's binding something no source would write
+   * removes that entire class of collision instead of patching it up after a
+   * `SyntaxError`.
+   */
+  exports: "__sbxExports"
+};
+var DEFAULT_LOCAL = "__sbxDefault";
+var MAYBE_ESM = /(^|[\s;}(])(?:import|export)(?:[\s({[*"']|$)|\bimport\s*\.\s*meta\b/;
+function looksLikeEsm(source) {
+  return MAYBE_ESM.test(source);
+}
+function transformEsm(source, filename = "module.js") {
+  if (!looksLikeEsm(source)) return null;
+  let ast;
+  try {
+    ast = parseModule(source, filename);
+  } catch {
+    return null;
+  }
+  const body = ast.body;
+  const hasModuleSyntax = body.some(
+    (node2) => node2.type.startsWith("Import") || node2.type.startsWith("Export")
+  );
+  const usesImportMeta = !hasModuleSyntax && containsImportMeta(ast);
+  const esm = hasModuleSyntax || usesImportMeta;
+  if (!esm && !containsImportExpression(ast)) return null;
+  const edits = [];
+  const prelude = [];
+  const importBindings = /* @__PURE__ */ new Map();
+  const exportGetters = /* @__PURE__ */ new Map();
+  let namespaceCount = 0;
+  const namespaceFor = (specifier) => {
+    const id = `__sbxNs${namespaceCount++}`;
+    prelude.push(`var ${id} = ${HELPERS.import}(${JSON.stringify(specifier)});`);
+    return id;
+  };
+  for (const node2 of body) {
+    if (node2.type === "ImportDeclaration") collectImport(node2);
+  }
+  for (const node2 of body) {
+    switch (node2.type) {
+      case "ExportNamedDeclaration":
+        collectNamedExport(node2);
+        break;
+      case "ExportDefaultDeclaration":
+        collectDefaultExport(node2);
+        break;
+      case "ExportAllDeclaration":
+        collectExportAll(node2);
+        break;
+    }
+  }
+  rewriteReferences();
+  const header = esm ? [
+    `Object.defineProperty(${HELPERS.exports}, "__esModule", { value: true });`,
+    ...prelude,
+    ...[...exportGetters].map(
+      ([name, expression]) => `Object.defineProperty(${HELPERS.exports}, ${JSON.stringify(name)}, { enumerable: true, configurable: true, get: function () { return ${expression}; } });`
+    )
+  ].join("\n") : "";
+  return {
+    code: header ? `${header}
+${applyEdits(source, edits)}` : applyEdits(source, edits),
+    esm,
+    topLevelAwait: hasTopLevelAwait(ast)
+  };
+  function collectImport(node2) {
+    const specifier = node2.source.value;
+    const specifiers = node2.specifiers ?? [];
+    const id = namespaceFor(specifier);
+    for (const entry of specifiers) {
+      const local = entry.local.name ?? "";
+      if (entry.type === "ImportDefaultSpecifier") {
+        importBindings.set(local, `${id}.default`);
+      } else if (entry.type === "ImportNamespaceSpecifier") {
+        importBindings.set(local, id);
+      } else {
+        const imported = entry.imported;
+        const name = imported.type === "Identifier" ? imported.name : imported.value;
+        importBindings.set(local, `${id}[${JSON.stringify(name)}]`);
+      }
+    }
+    drop(node2);
+  }
+  function collectNamedExport(node2) {
+    const declaration = node2.declaration;
+    if (declaration) {
+      for (const name of declaredNames(declaration)) exportGetters.set(name, name);
+      edits.push({ start: node2.start, end: declaration.start, text: "" });
+      return;
+    }
+    const source_ = node2.source;
+    const id = source_ ? namespaceFor(source_.value) : null;
+    for (const entry of node2.specifiers ?? []) {
+      const local = nameOf(entry.local);
+      const exported = nameOf(entry.exported);
+      const read = id ? `${id}[${JSON.stringify(local)}]` : importBindings.get(local) ?? local;
+      exportGetters.set(exported, read);
+    }
+    drop(node2);
+  }
+  function collectDefaultExport(node2) {
+    const declaration = node2.declaration;
+    const isDeclaration = declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration";
+    if (isDeclaration) {
+      const named = declaration.id;
+      if (named) {
+        exportGetters.set("default", named.name);
+        edits.push({ start: node2.start, end: declaration.start, text: "" });
+        return;
+      }
+      const keyword = declaration.type === "FunctionDeclaration" ? "function" : "class";
+      const keywordEnd = source.indexOf(keyword, declaration.start) + keyword.length;
+      exportGetters.set("default", DEFAULT_LOCAL);
+      edits.push({ start: node2.start, end: declaration.start, text: "" });
+      edits.push({ start: keywordEnd, end: keywordEnd, text: ` ${DEFAULT_LOCAL}` });
+      return;
+    }
+    exportGetters.set("default", DEFAULT_LOCAL);
+    edits.push({ start: node2.start, end: declaration.start, text: `var ${DEFAULT_LOCAL} = ` });
+    edits.push({ start: node2.end, end: node2.end, text: ";" });
+  }
+  function collectExportAll(node2) {
+    const id = namespaceFor(node2.source.value);
+    const exported = node2.exported;
+    if (exported) exportGetters.set(nameOf(exported), id);
+    else prelude.push(`${HELPERS.exportAll}(${HELPERS.exports}, ${id});`);
+    drop(node2);
+  }
+  function drop(node2) {
+    edits.push({ start: node2.start, end: node2.end, text: "" });
+  }
+  function rewriteReferences() {
+    const programScope = { names: new Set(importBindings.keys()), parent: null };
+    visit(ast, programScope, true);
+    function visit(node2, scope, isProgram = false) {
+      let childScope = scope;
+      let skip = NOTHING2;
+      switch (node2.type) {
+        case "ImportDeclaration":
+        case "ExportAllDeclaration":
+          return;
+        case "ExportNamedDeclaration":
+          if (!node2.declaration) return;
+          break;
+        case "FunctionDeclaration":
+        case "FunctionExpression":
+        case "ArrowFunctionExpression": {
+          const names = /* @__PURE__ */ new Set();
+          for (const param of node2.params ?? []) collectPattern2(param, names);
+          const id = node2.id;
+          if (id && node2.type === "FunctionExpression") names.add(id.name);
+          const fnBody = node2.body;
+          if (fnBody?.type === "BlockStatement") {
+            for (const name of hoistedNames2(fnBody.body)) names.add(name);
+          }
+          childScope = { names, parent: scope };
+          break;
+        }
+        case "CatchClause": {
+          const names = /* @__PURE__ */ new Set();
+          if (node2.param) collectPattern2(node2.param, names);
+          childScope = { names, parent: scope };
+          break;
+        }
+        case "ClassExpression": {
+          const id = node2.id;
+          if (id) childScope = { names: /* @__PURE__ */ new Set([id.name]), parent: scope };
+          break;
+        }
+        case "BlockStatement":
+        case "StaticBlock":
+          if (!isProgram) {
+            childScope = { names: blockNames2(node2.body), parent: scope };
+          }
+          break;
+        case "ForStatement":
+        case "ForInStatement":
+        case "ForOfStatement": {
+          const head2 = node2.init ?? node2.left;
+          if (head2?.type === "VariableDeclaration" && head2.kind !== "var") {
+            const names = /* @__PURE__ */ new Set();
+            for (const declarator of head2.declarations) {
+              collectPattern2(declarator.id, names);
+            }
+            childScope = { names, parent: scope };
+          }
+          break;
+        }
+        case "MetaProperty":
+          edits.push({ start: node2.start, end: node2.end, text: HELPERS.meta });
+          return;
+        case "ImportExpression": {
+          const argument = node2.source;
+          edits.push({ start: node2.start, end: argument.start, text: `${HELPERS.dynamic}(` });
+          visit(argument, childScope);
+          edits.push({ start: argument.end, end: node2.end, text: ")" });
+          return;
+        }
+        case "Identifier": {
+          const replacement = lookup(node2.name, scope);
+          if (replacement) edits.push({ start: node2.start, end: node2.end, text: replacement });
+          return;
+        }
+        case "MemberExpression":
+        case "MethodDefinition":
+        case "PropertyDefinition":
+          skip = node2.computed ? NOTHING2 : PROPERTY2;
+          break;
+        case "Property": {
+          if (node2.computed) break;
+          if (node2.shorthand) {
+            const value = node2.value;
+            if (value.type === "Identifier") {
+              const replacement = lookup(value.name, scope);
+              if (replacement) {
+                edits.push({ start: value.start, end: value.end, text: `${value.name}: ${replacement}` });
+                return;
+              }
+            }
+            break;
+          }
+          skip = PROPERTY2;
+          break;
+        }
+        case "LabeledStatement":
+        case "BreakStatement":
+        case "ContinueStatement":
+          skip = LABEL2;
+          break;
+      }
+      for (const [key, value] of Object.entries(node2)) {
+        if (key === "type" || key === "start" || key === "end" || skip.includes(key)) continue;
+        if (Array.isArray(value)) {
+          for (const item of value) if (isNode4(item)) visit(item, childScope);
+        } else if (isNode4(value)) {
+          visit(value, childScope);
+        }
+      }
+    }
+    function lookup(name, scope) {
+      for (let current = scope; current; current = current.parent) {
+        if (current.names.has(name)) {
+          return current.parent === null ? importBindings.get(name) ?? null : null;
+        }
+      }
+      return null;
+    }
+  }
+}
+var JSX_EXTENSION = /\.[jt]sx$/;
+var JsxParser = acorn.Parser.extend(jsx__default.default());
+var PARSE_OPTIONS = {
+  ecmaVersion: "latest",
+  sourceType: "module",
+  allowAwaitOutsideFunction: true,
+  allowHashBang: true,
+  allowReturnOutsideFunction: true
+};
+function parseModule(source, filename) {
+  const parser = JSX_EXTENSION.test(filename) ? JsxParser.parse.bind(JsxParser) : acorn.parse;
+  return parser(source, PARSE_OPTIONS);
+}
+function containsImportExpression(node2) {
+  if (Array.isArray(node2)) return node2.some(containsImportExpression);
+  if (!isNode4(node2)) return false;
+  if (node2.type === "ImportExpression") return true;
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (containsImportExpression(value)) return true;
+  }
+  return false;
+}
+function containsImportMeta(node2) {
+  if (Array.isArray(node2)) return node2.some(containsImportMeta);
+  if (!isNode4(node2)) return false;
+  if (node2.type === "MetaProperty") return true;
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (containsImportMeta(value)) return true;
+  }
+  return false;
+}
+function hasTopLevelAwait(node2) {
+  if (Array.isArray(node2)) return node2.some(hasTopLevelAwait);
+  if (!isNode4(node2)) return false;
+  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
+    return false;
+  }
+  if (node2.type === "AwaitExpression") return true;
+  if (node2.type === "ForOfStatement" && node2.await === true) return true;
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (hasTopLevelAwait(value)) return true;
+  }
+  return false;
+}
+function declaredNames(declaration) {
+  const names = /* @__PURE__ */ new Set();
+  if (declaration.type === "VariableDeclaration") {
+    for (const declarator of declaration.declarations) {
+      collectPattern2(declarator.id, names);
+    }
+  } else if (isNode4(declaration.id)) {
+    names.add(declaration.id.name);
+  }
+  return [...names];
+}
+function nameOf(node2) {
+  return node2.type === "Identifier" ? node2.name : node2.value;
+}
+function hoistedNames2(body) {
+  const names = blockNames2(body);
+  collectVars2(body, names);
+  return names;
+}
+function blockNames2(body) {
+  const names = /* @__PURE__ */ new Set();
+  for (const node2 of body ?? []) {
+    if (node2.type === "VariableDeclaration" && node2.kind !== "var") {
+      for (const declarator of node2.declarations) {
+        collectPattern2(declarator.id, names);
+      }
+    } else if ((node2.type === "ClassDeclaration" || node2.type === "FunctionDeclaration") && isNode4(node2.id)) {
+      names.add(node2.id.name);
+    }
+  }
+  return names;
+}
+function collectVars2(nodes, names) {
+  if (Array.isArray(nodes)) {
+    for (const item of nodes) collectVars2(item, names);
+    return;
+  }
+  if (!isNode4(nodes)) return;
+  const node2 = nodes;
+  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression") {
+    if (isNode4(node2.id)) names.add(node2.id.name);
+    return;
+  }
+  if (node2.type === "VariableDeclaration" && node2.kind === "var") {
+    for (const declarator of node2.declarations) {
+      collectPattern2(declarator.id, names);
+    }
+  }
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    collectVars2(value, names);
+  }
+}
+function collectPattern2(node2, names) {
+  if (!isNode4(node2)) return;
+  switch (node2.type) {
+    case "Identifier":
+      names.add(node2.name);
+      return;
+    case "ObjectPattern":
+      for (const property of node2.properties) {
+        collectPattern2(property.value ?? property.argument, names);
+      }
+      return;
+    case "ArrayPattern":
+      for (const element of node2.elements) collectPattern2(element, names);
+      return;
+    case "AssignmentPattern":
+      collectPattern2(node2.left, names);
+      return;
+    case "RestElement":
+      collectPattern2(node2.argument, names);
+      return;
+    default:
+      return;
+  }
+}
+function applyEdits(source, edits) {
+  const ordered = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+  let out = source;
+  for (const edit of ordered) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  return out;
+}
+function isNode4(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+var NOTHING2 = [];
+var PROPERTY2 = ["property", "key"];
+var LABEL2 = ["label"];
+var EXTENSIONS = [".js", ".mjs", ".cjs", ".json", ".node"];
+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 };
+  }
+  volume;
+  cache = /* @__PURE__ */ new Map();
+  builtins;
+  globals;
+  aliases;
+  overrides;
+  cwd;
+  main = null;
+  /** `package.json` per directory; resolution reads them constantly. */
+  manifests = /* @__PURE__ */ new Map();
+  /**
+   * Evaluate an entry point.
+   *
+   * Returns the module's exports, or a promise for them when the entry is an
+   * ES module with a top-level `await` — the caller has to await that before
+   * treating the program as finished.
+   */
+  run(entry) {
+    const operand = entry.startsWith("/") || entry.startsWith("./") || entry.startsWith("../") ? entry : `./${entry}`;
+    const filename = this.resolve(operand, join(this.cwd, "__entry__.js"));
+    const module = this.load(filename, null, true);
+    return module.pending ? module.pending.then(() => module.exports) : module.exports;
+  }
+  require(specifier, importer = join(this.cwd, "__entry__.js")) {
+    const builtin = this.builtin(specifier);
+    if (builtin.found) return builtin.value;
+    const target = this.load(this.resolve(specifier, importer), this.cache.get(importer) ?? null, false);
+    if (target.pending) throw requireOfAsyncModule(specifier);
+    return target.exports;
+  }
+  resolve(specifier, importer, kind = "require") {
+    const builtin = this.builtin(specifier);
+    if (builtin.found) return specifier.replace(/^node:/, "");
+    if (specifier.startsWith("#")) {
+      const found = this.resolveImports(specifier, importer, kind);
+      if (found) return found;
+      throw this.moduleNotFound(specifier, importer);
+    }
+    const baseDir = dirname(importer);
+    if (specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../")) {
+      const resolved = specifier.startsWith("/") ? clean(specifier) : resolve(baseDir, specifier);
+      const found = this.resolvePath(resolved, kind);
+      if (found) return found;
+    } else {
+      const aliased = this.aliasFor(specifier);
+      if (aliased) {
+        const substituted = this.resolvePackage(aliased, baseDir, kind);
+        if (substituted) return substituted;
+      }
+      const found = this.resolvePackage(specifier, baseDir, kind);
+      if (found) return found;
+    }
+    throw this.moduleNotFound(specifier, importer);
+  }
+  load(filename, parent, isMain) {
+    const cached2 = this.cache.get(filename);
+    if (cached2) return cached2;
+    const module = {
+      id: isMain ? "." : filename,
+      filename,
+      exports: {},
+      loaded: false,
+      parent,
+      children: []
+    };
+    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));
+      }
+      module.loaded = true;
+      return module;
+    } catch (error) {
+      this.cache.delete(filename);
+      if (isMain) this.main = null;
+      throw error;
+    }
+  }
+  evaluate(module, source) {
+    if (source.startsWith("#!")) source = source.replace(/^#![^\n]*(?:\n|$)/, "");
+    const transformed = transformEsm(source, module.filename);
+    const body = transformed?.code ?? source;
+    const code = transformed?.topLevelAwait ? `return (async () => {
+${body}
+})();` : body;
+    const helpers = [
+      [HELPERS.import, (specifier) => this.importNamespace(specifier, module)],
+      [HELPERS.dynamic, (specifier) => this.dynamicImport(specifier, module)],
+      [HELPERS.exportAll, exportAll],
+      [HELPERS.meta, this.importMeta(module)]
+    ];
+    const bindings = transformed?.esm ? [[HELPERS.exports, module.exports], ...helpers] : [
+      ["exports", module.exports],
+      ["require", this.makeRequire(module)],
+      ["module", module],
+      ["__filename", module.filename],
+      ["__dirname", dirname(module.filename)],
+      ...helpers
+    ];
+    const globalNames = Object.keys(this.globals);
+    const factory = new Function(
+      "__sbxGlobals",
+      `"use strict";
+` + (globalNames.length ? `const { ${globalNames.join(", ")} } = __sbxGlobals;
+` : "") + `return function (${bindings.map(([name]) => name).join(", ")}) {
+${code}
+};
+//# sourceURL=sandboxedjs:${module.filename}`
+    )(this.globals);
+    const result = factory(...bindings.map(([, value]) => value));
+    if (transformed?.topLevelAwait) module.pending = Promise.resolve(result).then(() => {
+    });
+  }
+  /** 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;
+    });
+    localRequire.resolve = (specifier) => this.resolve(specifier, module.filename, "require");
+    Object.defineProperty(localRequire, "main", { get: () => this.main });
+    localRequire.cache = Object.fromEntries(this.cache);
+    return localRequire;
+  }
+  /**
+   * Load `specifier` and present it as an ES module namespace.
+   *
+   * A static `import` is synchronous here, exactly as the CommonJS `require`
+   * it compiles down to. That is the one place this engine knowingly differs
+   * from Node's real ESM semantics, and it is the trade that lets both module
+   * systems share a single cache and resolver.
+   */
+  importNamespace(specifier, importer) {
+    const builtin = this.builtin(specifier, importer);
+    if (builtin.found) return namespaceOf(builtin.value);
+    const target = this.load(this.resolve(specifier, importer.filename, "import"), importer, false);
+    if (target.pending) throw requireOfAsyncModule(specifier);
+    return namespaceOf(target.exports);
+  }
+  /** `import(...)`: the same load, but able to await a top-level `await`. */
+  async dynamicImport(specifier, importer) {
+    const builtin = this.builtin(specifier, importer);
+    if (builtin.found) return namespaceOf(builtin.value);
+    const target = this.load(this.resolve(specifier, importer.filename, "import"), importer, false);
+    if (target.pending) await target.pending;
+    return namespaceOf(target.exports);
+  }
+  /** `import.meta` for a module. */
+  importMeta(module) {
+    return {
+      url: fileUrl(module.filename),
+      filename: module.filename,
+      dirname: dirname(module.filename),
+      resolve: (specifier) => fileUrl(this.resolve(specifier, module.filename, "import"))
+    };
+  }
+  /**
+   * The substituted specifier for `specifier`, or null when none applies.
+   *
+   * An alias names a package, so a subpath rides along: aliasing `rollup` also
+   * redirects `rollup/dist/native.js` into the substitute.
+   */
+  aliasFor(specifier) {
+    const { name, subpath } = splitSpecifier(specifier);
+    const target = this.aliases[name];
+    if (!target) return null;
+    return subpath ? `${target}/${subpath}` : target;
+  }
+  /**
+   * Resolve a bare specifier (`pkg`, `@scope/pkg`, `pkg/sub`) by walking
+   * `node_modules` up from the importer, exactly as Node does.
+   */
+  resolvePackage(specifier, from, kind) {
+    const { name, subpath } = splitSpecifier(specifier);
+    for (let dir3 = from; ; dir3 = dirname(dir3)) {
+      const root = join(dir3, "node_modules", name);
+      if (this.isDirectory(root)) {
+        const resolved = this.resolveInPackage(root, subpath, kind);
+        if (resolved) return resolved;
+      }
+      if (dir3 === "/") return null;
+    }
+  }
+  /**
+   * Resolve `subpath` ("" for the package root) inside an installed package.
+   *
+   * An `exports` map, when present, is authoritative: Node refuses paths it
+   * does not name, and packages rely on that to keep their internals private.
+   * Only a package without one falls back to `main`/`module` and to treating
+   * the subpath as a plain file path.
+   */
+  resolveInPackage(root, subpath, kind) {
+    const manifest = this.readManifest(root);
+    const entry = subpath ? `./${subpath}` : ".";
+    if (manifest?.exports !== void 0) {
+      for (const conditions of CONDITION_SETS[kind]) {
+        let targets;
+        try {
+          targets = resolve_exports.exports(manifest, entry, { conditions, unsafe: true });
+        } catch {
+          continue;
+        }
+        for (const target of targets ?? []) {
+          const found = this.resolvePath(resolve(root, target), kind);
+          if (found) return found;
+        }
+      }
+      return null;
+    }
+    if (subpath) return this.resolvePath(join(root, subpath), kind);
+    for (const field of ENTRY_FIELDS[kind]) {
+      const value = manifest?.[field];
+      if (typeof value === "string") {
+        const found = this.resolvePath(resolve(root, value), kind);
+        if (found) return found;
+      }
+    }
+    return this.resolveIndex(root);
+  }
+  /**
+   * Resolve a `#private` specifier through the importing package's `imports`
+   * map, which is scoped to the nearest enclosing package rather than to
+   * `node_modules`.
+   */
+  resolveImports(specifier, from, kind) {
+    const root = this.packageRoot(from);
+    if (!root) return null;
+    const manifest = this.readManifest(root);
+    if (!manifest?.imports) return null;
+    for (const conditions of CONDITION_SETS[kind]) {
+      let targets;
+      try {
+        targets = resolve_exports.imports(manifest, specifier, { conditions, unsafe: true });
+      } catch {
+        continue;
+      }
+      for (const target of targets ?? []) {
+        const found = target.startsWith(".") ? this.resolvePath(resolve(root, target), kind) : this.resolvePackage(target, root, kind);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  /** Resolve a path to a file, trying Node's extension and index fallbacks. */
+  resolvePath(path, kind = "require") {
+    if (this.isFile(path)) return path;
+    for (const extension of EXTENSIONS) {
+      const candidate = `${path}${extension}`;
+      if (this.isFile(candidate)) return candidate;
+    }
+    if (!this.isDirectory(path)) return null;
+    const manifest = this.readManifest(path);
+    for (const field of ENTRY_FIELDS[kind]) {
+      const value = manifest?.[field];
+      if (typeof value !== "string") continue;
+      const target = resolve(path, value);
+      if (this.isFile(target)) return target;
+      for (const extension of EXTENSIONS) {
+        if (this.isFile(`${target}${extension}`)) return `${target}${extension}`;
+      }
+      const nested = this.resolveIndex(target);
+      if (nested) return nested;
+    }
+    return this.resolveIndex(path);
+  }
+  resolveIndex(dir3) {
+    for (const extension of EXTENSIONS) {
+      const candidate = join(dir3, `index${extension}`);
+      if (this.isFile(candidate)) return candidate;
+    }
+    return null;
+  }
+  /** The nearest ancestor directory holding a `package.json`. */
+  packageRoot(from) {
+    for (let dir3 = dirname(from); ; dir3 = dirname(dir3)) {
+      if (this.isFile(join(dir3, "package.json"))) return dir3;
+      if (dir3 === "/") return null;
+    }
+  }
+  readManifest(root) {
+    const cached2 = this.manifests.get(root);
+    if (cached2 !== void 0) return cached2;
+    let manifest = null;
+    try {
+      manifest = JSON.parse(this.readText(join(root, "package.json")));
+    } catch {
+    }
+    this.manifests.set(root, manifest);
+    return manifest;
+  }
+  builtin(specifier, importer) {
+    const name = specifier.replace(/^node:/, "");
+    if (!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) }
+      };
+    }
+    return { found: true, value: this.builtins[name] };
+  }
+  exists(path) {
+    try {
+      this.volume.lstatSync(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  isFile(path) {
+    try {
+      return this.volume.lstatSync(path).isFile();
+    } catch {
+      return false;
+    }
+  }
+  isDirectory(path) {
+    try {
+      return this.volume.lstatSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  readText(path) {
+    return new TextDecoder().decode(this.volume.readFileSync(path));
+  }
+  moduleNotFound(specifier, importer) {
+    const error = new Error(`Cannot find module '${specifier}'
+Require stack:
+- ${importer}`);
+    error.code = "MODULE_NOT_FOUND";
+    return error;
+  }
+};
+var namespaces = /* @__PURE__ */ new WeakMap();
+function namespaceOf(exports) {
+  if (exports === null || typeof exports !== "object" && typeof exports !== "function") {
+    return { default: exports, __esModule: true };
+  }
+  const target = exports;
+  if (target.__esModule) return target;
+  const cached2 = namespaces.get(target);
+  if (cached2) return cached2;
+  const namespace = {};
+  for (const key of ownKeys(target)) {
+    if (key === "default" || key === "__esModule") continue;
+    Object.defineProperty(namespace, key, {
+      enumerable: true,
+      configurable: true,
+      get: () => target[key]
+    });
+  }
+  Object.defineProperty(namespace, "default", { enumerable: true, configurable: true, value: target });
+  Object.defineProperty(namespace, "__esModule", { value: true });
+  namespaces.set(target, namespace);
+  return namespace;
+}
+function exportAll(exports, namespace) {
+  if (namespace === null || typeof namespace !== "object") return;
+  const source = namespace;
+  for (const key of ownKeys(source)) {
+    if (key === "default" || key === "__esModule") continue;
+    if (Object.prototype.hasOwnProperty.call(exports, key)) continue;
+    Object.defineProperty(exports, key, {
+      enumerable: true,
+      configurable: true,
+      get: () => source[key]
+    });
+  }
+}
+function ownKeys(target) {
+  const keys = [];
+  for (const key of Object.getOwnPropertyNames(target)) {
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor?.enumerable) keys.push(key);
+  }
+  return keys;
+}
+function fileUrl(path) {
+  return `file://${path.split("/").map(encodeURIComponent).join("/")}`;
+}
+function dlopenFailed(filename) {
+  const error = new Error(
+    `Cannot load '${filename}': it is a compiled native addon, which the sandboxed runtime cannot execute. A pure-JavaScript or WebAssembly build of the package is needed instead.`
+  );
+  error.code = "ERR_DLOPEN_FAILED";
+  return error;
+}
+function requireOfAsyncModule(specifier) {
+  const error = new Error(
+    `require() cannot load ES module '${specifier}': it uses top-level await. Use import() instead.`
+  );
+  error.code = "ERR_REQUIRE_ASYNC_MODULE";
+  return error;
+}
+function splitSpecifier(specifier) {
+  const parts = specifier.split("/");
+  const size = specifier.startsWith("@") ? 2 : 1;
+  return { name: parts.slice(0, size).join("/"), subpath: parts.slice(size).join("/") };
+}
+
+// src/runtime/core-modules.ts
+init_path();
+var VirtualIncomingMessage = class extends streamModule3__default.default.Readable {
+  method;
+  url;
+  headers;
+  rawHeaders;
+  httpVersion = "1.1";
+  httpVersionMajor = 1;
+  httpVersionMinor = 1;
+  complete = true;
+  socket = socketStub();
+  connection = this.socket;
+  constructor(init) {
+    super();
+    this.method = (init.method ?? "GET").toUpperCase();
+    this.url = init.path ?? "/";
+    const body = init.body == null ? new Uint8Array() : typeof init.body === "string" ? new TextEncoder().encode(init.body) : init.body instanceof ArrayBuffer ? new Uint8Array(init.body) : init.body;
+    this.headers = Object.fromEntries(Object.entries(init.headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]));
+    if (body.length && this.headers["content-length"] === void 0 && this.headers["transfer-encoding"] === void 0) {
+      this.headers["content-length"] = String(body.length);
+    }
+    this.rawHeaders = Object.entries(this.headers).flatMap(([key, value]) => [key, value]);
+    if (body.length) this.push(buffer.Buffer.from(body));
+    this.push(null);
+  }
+  _read() {
+  }
+  setTimeout(_milliseconds, callback) {
+    if (callback) this.once("timeout", callback);
+    return this;
+  }
+};
+var VirtualServerResponse = class extends streamModule3__default.default.Writable {
+  statusCode = 200;
+  statusMessage = "OK";
+  headersSent = false;
+  sendDate = true;
+  req;
+  socket = socketStub();
+  connection = this.socket;
+  headers = /* @__PURE__ */ new Map();
+  chunks = [];
+  resolve;
+  completed;
+  constructor(request) {
+    super();
+    this.req = request;
+    this.completed = new Promise((resolve2) => {
+      this.resolve = resolve2;
+    });
+  }
+  _write(chunk, encoding, callback) {
+    this.headersSent = true;
+    this.chunks.push(buffer.Buffer.isBuffer(chunk) ? chunk : buffer.Buffer.from(chunk, encoding));
+    callback();
+  }
+  _final(callback) {
+    this.headersSent = 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;
+    this.resolve({
+      statusCode: this.statusCode,
+      statusMessage: this.statusMessage || STATUS_CODES[this.statusCode] || "",
+      headers,
+      body: new Uint8Array(buffer.Buffer.concat(this.chunks))
+    });
+    callback();
+  }
+  setHeader(name, value) {
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    this.headers.set(name.toLowerCase(), { name, value: Array.isArray(value) ? [...value].map(String) : String(value) });
+    return this;
+  }
+  appendHeader(name, value) {
+    const current = 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]);
+  }
+  getHeader(name) {
+    return this.headers.get(name.toLowerCase())?.value;
+  }
+  getHeaders() {
+    return Object.fromEntries([...this.headers].map(([key, entry]) => [key, entry.value]));
+  }
+  getHeaderNames() {
+    return [...this.headers.keys()];
+  }
+  hasHeader(name) {
+    return this.headers.has(name.toLowerCase());
+  }
+  removeHeader(name) {
+    this.headers.delete(name.toLowerCase());
+  }
+  writeHead(statusCode, statusMessage, headers) {
+    this.statusCode = statusCode;
+    if (typeof statusMessage === "string") this.statusMessage = statusMessage;
+    const values = (typeof statusMessage === "object" ? statusMessage : headers) ?? {};
+    for (const [name, value] of Object.entries(values)) if (value !== void 0) this.setHeader(name, value);
+    this.headersSent = true;
+    return this;
+  }
+  flushHeaders() {
+    this.headersSent = true;
+  }
+  writeContinue() {
+  }
+  writeProcessing() {
+  }
+  addTrailers(_headers) {
+  }
+  setTimeout(_milliseconds, callback) {
+    if (callback) this.once("timeout", callback);
+    return this;
+  }
+};
+var VirtualHttpServer = class extends EventEmitter3__default.default {
+  constructor(router, owner, listener) {
+    super();
+    this.router = router;
+    this.owner = owner;
+    if (listener) this.on("request", listener);
+  }
+  router;
+  owner;
+  listening = false;
+  portValue = null;
+  listen(...args) {
+    const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
+    const first = args[0];
+    const port = typeof first === "object" ? Number(first.port) : Number(first);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) throw Object.assign(new RangeError(`Invalid port: ${port}`), { code: "ERR_SOCKET_BAD_PORT" });
+    this.router.register(port, this, this.owner);
+    this.portValue = port;
+    this.listening = true;
+    queueMicrotask(() => {
+      this.emit("listening");
+      callback?.();
+    });
+    return this;
+  }
+  close(callback) {
+    if (this.portValue !== null) this.router.unregister(this.portValue, this);
+    this.portValue = null;
+    this.listening = false;
+    queueMicrotask(() => {
+      this.emit("close");
+      callback?.();
+    });
+    return this;
+  }
+  address() {
+    return this.portValue === null ? null : { address: "0.0.0.0", family: "IPv4", port: this.portValue };
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  setTimeout(_milliseconds, callback) {
+    if (callback) this.on("timeout", callback);
+    return this;
+  }
+};
+var VirtualHttpRouter = class {
+  servers = /* @__PURE__ */ new Map();
+  register(port, server, owner) {
+    if (this.servers.has(port)) throw Object.assign(new Error(`listen EADDRINUSE: address already in use 0.0.0.0:${port}`), { code: "EADDRINUSE", port });
+    this.servers.set(port, { server, owner });
+  }
+  unregister(port, server) {
+    if (this.servers.get(port)?.server === server) this.servers.delete(port);
+  }
+  activePorts(owner) {
+    return [...this.servers].filter(([, item]) => owner === void 0 || item.owner === owner).map(([port]) => port).sort((a, b) => a - b);
+  }
+  closeOwner(owner) {
+    for (const { server, owner: value } of [...this.servers.values()]) if (value === owner) server.close();
+  }
+  closeAll() {
+    for (const { server } of [...this.servers.values()]) server.close();
+  }
+  async request(port, init = {}) {
+    const item = this.servers.get(port);
+    if (!item) return { statusCode: 503, statusMessage: "Service Unavailable", headers: {}, body: "No server is listening" };
+    const request = new VirtualIncomingMessage(init);
+    const response = new VirtualServerResponse(request);
+    try {
+      item.server.emit("request", request, response);
+      return await response.completed;
+    } catch (error) {
+      if (!response.writableEnded) response.end(error instanceof Error ? error.message : String(error));
+      return { statusCode: 500, statusMessage: "Internal Server Error", headers: {}, body: error instanceof Error ? error.message : String(error) };
+    }
+  }
+};
+function createHttpModule(router, owner) {
+  const createServer = (listener) => new VirtualHttpServer(router, owner, listener);
+  const module = {
+    createServer,
+    Server: VirtualHttpServer,
+    ServerResponse: VirtualServerResponse,
+    IncomingMessage: VirtualIncomingMessage,
+    METHODS,
+    STATUS_CODES,
+    maxHeaderSize: 16 * 1024,
+    validateHeaderName,
+    validateHeaderValue,
+    globalAgent: { keepAlive: true },
+    Agent: class Agent {
+    }
+  };
+  return { ...module, request: unsupportedClient, get: unsupportedClient };
+}
+function unsupportedClient() {
+  throw Object.assign(new Error("http client requests are not implemented yet"), { code: "ERR_NOT_IMPLEMENTED" });
+}
+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" });
+}
+function validateHeaderValue(name, value) {
+  if (value === void 0 || /[\0\r\n]/.test(String(value))) throw Object.assign(new TypeError(`Invalid value for header "${name}"`), { code: "ERR_INVALID_CHAR" });
+}
+function socketStub() {
+  return { remoteAddress: "127.0.0.1", remotePort: 0, localAddress: "127.0.0.1", localPort: 0, encrypted: false, writable: true, readable: true, setTimeout() {
+  }, setNoDelay() {
+  }, setKeepAlive() {
+  }, ref() {
+    return this;
+  }, unref() {
+    return this;
+  }, destroy() {
+  } };
+}
+var METHODS = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE", "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "REBIND", "REPORT", "SEARCH", "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE"];
+var STATUS_CODES = { 100: "Continue", 200: "OK", 201: "Created", 202: "Accepted", 204: "No Content", 206: "Partial Content", 301: "Moved Permanently", 302: "Found", 304: "Not Modified", 307: "Temporary Redirect", 308: "Permanent Redirect", 400: "Bad Request", 401: "Unauthorized", 403: "Forbidden", 404: "Not Found", 405: "Method Not Allowed", 409: "Conflict", 413: "Payload Too Large", 415: "Unsupported Media Type", 422: "Unprocessable Entity", 429: "Too Many Requests", 500: "Internal Server Error", 501: "Not Implemented", 502: "Bad Gateway", 503: "Service Unavailable" };
+var hashes = { md5: legacy.md5, sha1: legacy.sha1, "sha-1": legacy.sha1, sha224: sha256.sha224, "sha-224": sha256.sha224, sha256: sha256.sha256, "sha-256": sha256.sha256, sha384: sha512.sha384, "sha-384": sha512.sha384, sha512: sha512.sha512, "sha-512": sha512.sha512 };
+function createCryptoModule() {
+  const cryptoObject = globalThis.crypto;
+  return {
+    createHash(algorithm) {
+      const hash = hashFor(algorithm).create();
+      const api = {
+        update(data, encoding) {
+          hash.update(toBytes2(data, encoding));
+          return api;
+        },
+        digest(encoding) {
+          const value = buffer.Buffer.from(hash.digest());
+          return encoding ? value.toString(encoding) : value;
+        },
+        copy() {
+          throw new Error("Hash.copy is not implemented");
+        }
+      };
+      return api;
+    },
+    createHmac(algorithm, key) {
+      const hash = hashFor(algorithm);
+      const state = hmac.hmac.create(hash, toBytes2(key));
+      const api = {
+        update(data, encoding) {
+          state.update(toBytes2(data, encoding));
+          return api;
+        },
+        digest(encoding) {
+          const value = buffer.Buffer.from(state.digest());
+          return encoding ? value.toString(encoding) : value;
+        }
+      };
+      return api;
+    },
+    randomBytes(size, callback) {
+      const value = buffer.Buffer.alloc(size);
+      cryptoObject.getRandomValues(value);
+      if (callback) {
+        queueMicrotask(() => callback(null, value));
+        return;
+      }
+      return value;
+    },
+    randomFillSync(target, offset = 0, size = target.length - offset) {
+      cryptoObject.getRandomValues(target.subarray(offset, offset + size));
+      return target;
+    },
+    randomUUID: () => cryptoObject.randomUUID(),
+    /* Node re-exports the Web Crypto entry points on the `crypto` module
+     * itself, and tools use whichever spelling they prefer — Vite's config
+     * hashing reaches for `getRandomValues` on the default import. */
+    getRandomValues: (target) => cryptoObject.getRandomValues(target),
+    randomInt(min, max) {
+      const [low, high] = max === void 0 ? [0, min] : [min, max];
+      const span = high - low;
+      if (!(span > 0)) throw new RangeError('The value of "max" is out of range');
+      const value = new Uint32Array(1);
+      cryptoObject.getRandomValues(value);
+      return low + value[0] % span;
+    },
+    randomFill(target, offset = 0, size, callback) {
+      const done = [offset, size, callback].find((value) => typeof value === "function");
+      const start = typeof offset === "number" ? offset : 0;
+      const length = typeof size === "number" ? size : target.length - start;
+      cryptoObject.getRandomValues(target.subarray(start, start + length));
+      queueMicrotask(() => done?.(null, target));
+    },
+    hash(algorithm, data, encoding = "hex") {
+      const digest = buffer.Buffer.from(hashFor(algorithm)(toBytes2(data)));
+      return encoding === "buffer" ? digest : digest.toString(encoding);
+    },
+    timingSafeEqual(a, b) {
+      if (a.length !== b.length) throw new RangeError("Input buffers must have the same byte length");
+      let difference = 0;
+      for (let index = 0; index < a.length; index++) difference |= a[index] ^ b[index];
+      return difference === 0;
+    },
+    getHashes: () => ["md5", "sha1", "sha224", "sha256", "sha384", "sha512"],
+    webcrypto: cryptoObject,
+    subtle: cryptoObject.subtle,
+    constants: {}
+  };
+}
+function hashFor(algorithm) {
+  const hash = hashes[algorithm.toLowerCase()];
+  if (!hash) throw Object.assign(new Error(`Digest method not supported: ${algorithm}`), { code: "ERR_OSSL_EVP_UNSUPPORTED" });
+  return hash;
+}
+function toBytes2(data, encoding) {
+  return typeof data === "string" ? buffer.Buffer.from(data, encoding) : data;
+}
+var ChildProcess = class extends EventEmitter3__default.default {
+  stdout = new streamModule3__default.default.PassThrough();
+  stderr = new streamModule3__default.default.PassThrough();
+  stdin;
+  stdio;
+  pid;
+  exitCode = null;
+  signalCode = null;
+  killed = false;
+  spawnfile;
+  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 streamModule3__default.default.Writable({
+      write: (chunk, _encoding, done) => {
+        try {
+          handle.sendStdin(typeof chunk === "string" ? chunk : buffer.Buffer.from(chunk).toString("utf8"));
+        } 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;
+    this.handle.kill(typeof signal === "number" ? "SIGTERM" : signal);
+    return true;
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  disconnect() {
+    this.emit("disconnect");
+  }
+  /** No IPC channel exists, and reporting that honestly beats a silent drop. */
+  send() {
+    return false;
+  }
+  get connected() {
+    return false;
+  }
+  finish(code) {
+    if (this.settled) return;
+    this.settled = true;
+    this.exitCode = code;
+    this.stdout.end();
+    this.stderr.end();
+    this.emit("exit", code, null);
+    queueMicrotask(() => this.emit("close", code, null));
+  }
+};
+function createChildProcessModule(spawnChild, defaultCwd) {
+  const throughShell = (command, options) => {
+    const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
+    return { file: shell, args: ["-c", command] };
+  };
+  const start = (file3, args, options) => {
+    const resolved = options.shell ? throughShell([file3, ...args].join(" "), options) : { file: file3, args };
+    const handle = spawnChild({
+      command: resolved.file,
+      args: resolved.args,
+      cwd: options.cwd ?? defaultCwd(),
+      ...options.env ? { env: options.env } : {}
+    });
+    return new ChildProcess(handle, resolved.file, resolved.args);
+  };
+  const spawn = (file3, args = [], options = {}) => {
+    if (!Array.isArray(args)) return start(file3, [], args);
+    return start(file3, args, options);
+  };
+  const collect = (child, options, callback) => {
+    if (!callback) return child;
+    const out = [];
+    const err = [];
+    child.stdout.on("data", (chunk) => out.push(String(chunk)));
+    child.stderr.on("data", (chunk) => err.push(String(chunk)));
+    child.on("close", (code) => {
+      const asBuffer = options.encoding === "buffer";
+      const stdout = asBuffer ? buffer.Buffer.from(out.join("")) : out.join("");
+      const stderr = asBuffer ? buffer.Buffer.from(err.join("")) : err.join("");
+      if (code === 0) {
+        callback(null, stdout, stderr);
+        return;
+      }
+      const error = Object.assign(
+        new Error(`Command failed: ${child.spawnargs.join(" ")}
+${err.join("")}`),
+        { code, killed: child.killed, cmd: child.spawnargs.join(" ") }
+      );
+      callback(error, stdout, stderr);
+    });
+    return child;
+  };
+  const exec = (command, options = {}, callback) => {
+    const [opts, cb] = normalize2(options, callback);
+    const { file: file3, args } = throughShell(command, opts);
+    return collect(start(file3, args, { ...opts, shell: false }), opts, cb);
+  };
+  const execFile = (file3, args = [], options = {}, callback) => {
+    const list = Array.isArray(args) ? args : [];
+    const [opts, cb] = Array.isArray(args) ? normalize2(options, callback) : normalize2(args, options);
+    return collect(start(file3, list, opts), opts, cb);
+  };
+  return {
+    spawn,
+    exec,
+    execFile,
+    fork: (modulePath, args = [], options = {}) => spawn("node", [modulePath, ...args], options),
+    execSync: unavailable("execSync"),
+    execFileSync: unavailable("execFileSync"),
+    spawnSync: unavailable("spawnSync"),
+    ChildProcess
+  };
+}
+function normalize2(options, callback) {
+  if (typeof options === "function") return [{}, options];
+  return [options ?? {}, callback];
+}
+function unavailable(name) {
+  return () => {
+    const error = new Error(
+      `child_process.${name} is not supported in the sandboxed runtime: it would have to block the JavaScript thread. Use the asynchronous form instead.`
+    );
+    error.code = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+    throw error;
+  };
+}
+
+// src/runtime/core-modules.ts
+init_signals();
+var Dirent = class {
+  /** Node 20+ exposes the containing directory, and `fs.glob` consumers read it. */
+  constructor(name, stat2, parentPath = "") {
+    this.name = name;
+    this.stat = stat2;
+    this.parentPath = parentPath;
+  }
+  name;
+  stat;
+  parentPath;
+  get path() {
+    return this.parentPath;
+  }
+  isFile() {
+    return this.stat.isFile();
+  }
+  isDirectory() {
+    return this.stat.isDirectory();
+  }
+  isSymbolicLink() {
+    return this.stat.isSymbolicLink();
+  }
+  isBlockDevice() {
+    return false;
+  }
+  isCharacterDevice() {
+    return false;
+  }
+  isFIFO() {
+    return false;
+  }
+  isSocket() {
+    return false;
+  }
+};
+var Stats2 = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  dev = 1;
+  rdev = 0;
+  blksize = 4096;
+  get mode() {
+    const type = this.inner.isDirectory() ? S_IFDIR2 : this.inner.isSymbolicLink() ? S_IFLNK2 : S_IFREG2;
+    return (this.inner.mode & S_IFMT2) !== 0 ? this.inner.mode : this.inner.mode | type;
+  }
+  get size() {
+    return this.inner.size;
+  }
+  get uid() {
+    return this.inner.uid;
+  }
+  get gid() {
+    return this.inner.gid;
+  }
+  get ino() {
+    return this.inner.ino;
+  }
+  get nlink() {
+    return this.inner.nlink;
+  }
+  get blocks() {
+    return Math.ceil(this.inner.size / 512);
+  }
+  get atimeMs() {
+    return this.inner.atimeMs;
+  }
+  get mtimeMs() {
+    return this.inner.mtimeMs;
+  }
+  get ctimeMs() {
+    return this.inner.ctimeMs;
+  }
+  get birthtimeMs() {
+    return this.inner.birthtimeMs;
+  }
+  get atime() {
+    return new Date(this.inner.atimeMs);
+  }
+  get mtime() {
+    return new Date(this.inner.mtimeMs);
+  }
+  get ctime() {
+    return new Date(this.inner.ctimeMs);
+  }
+  get birthtime() {
+    return new Date(this.inner.birthtimeMs);
+  }
+  isFile() {
+    return this.inner.isFile();
+  }
+  isDirectory() {
+    return this.inner.isDirectory();
+  }
+  isSymbolicLink() {
+    return this.inner.isSymbolicLink();
+  }
+  isBlockDevice() {
+    return false;
+  }
+  isCharacterDevice() {
+    return false;
+  }
+  isFIFO() {
+    return false;
+  }
+  isSocket() {
+    return false;
+  }
+};
+var S_IFMT2 = 61440;
+var S_IFREG2 = 32768;
+var S_IFDIR2 = 16384;
+var S_IFLNK2 = 40960;
+var FsWatcher = class extends EventEmitter3__default.default {
+  close() {
+    this.removeAllListeners();
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+};
+function createCoreModules(options) {
+  const volume = options.volume;
+  let cwd = clean(options.cwd ?? "/");
+  let exitCode = 0;
+  const env2 = { ...options.env };
+  const stdoutWrite = options.stdout ?? (() => {
+  });
+  const stderrWrite = options.stderr ?? (() => {
+  });
+  const timers = createTrackedTimers();
+  const processObject = Object.assign(new EventEmitter3__default.default(), processShim__default.default, {
+    argv: options.argv?.slice() ?? ["/usr/bin/node"],
+    argv0: "node",
+    execPath: "/usr/bin/node",
+    env: env2,
+    platform: "linux",
+    arch: "x64",
+    version: "v22.12.0",
+    versions: { ...processShim__default.default.versions, node: "22.12.0" },
+    pid: 100,
+    ppid: 1,
+    title: "node",
+    exitCode,
+    cwd: () => cwd,
+    chdir: (path2) => {
+      const next = resolve(cwd, path2);
+      const stat2 = volume.lstatSync(resolveLinks(volume, next));
+      if (!stat2.isDirectory()) throw fsError("ENOTDIR", "chdir", next);
+      cwd = next;
+    },
+    umask: (_mask) => 18,
+    getuid: () => 0,
+    geteuid: () => 0,
+    getgid: () => 0,
+    getegid: () => 0,
+    getgroups: () => [0],
+    uptime: () => performance.now() / 1e3,
+    memoryUsage: () => ({ rss: 0, heapTotal: 0, heapUsed: 0, external: 0, arrayBuffers: 0 }),
+    cpuUsage: () => ({ user: 0, system: 0 }),
+    exit: (code = 0) => {
+      exitCode = code;
+      processObject.exitCode = code;
+      options.onExit?.(code);
+    },
+    kill: () => true
+  });
+  processObject.stdout = makeOutputStream(stdoutWrite, 1);
+  processObject.stderr = makeOutputStream(stderrWrite, 2);
+  processObject.stdin = new streamModule3__default.default.Readable({ read() {
+    this.push(null);
+  } });
+  Object.assign(processObject.stdin, { fd: 0, isTTY: false, setRawMode() {
+    return this;
+  } });
+  const fs = createFsModule(volume, () => cwd);
+  const path = createPathModule(() => cwd);
+  const consoleObject = new Console(stdoutWrite, stderrWrite);
+  const os = createOsModule();
+  const asyncHooks = createAsyncHooksModule();
+  const moduleBuiltin = {
+    builtinModules: builtinNames2.flatMap((name) => [name, `node:${name}`]),
+    isBuiltin: (name) => builtinNames2.includes(name.replace(/^node:/, "")),
+    createRequire: () => {
+      throw new Error("createRequire is only available inside a loaded module");
+    }
+  };
+  const http = options.http ? createHttpModule(options.http.router, options.http.owner) : createUnsupportedModule("http");
+  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd) : createUnsupportedModule("child_process");
+  const readline2 = createReadlineModule(() => processObject.stdin);
+  const dns = createDnsModule();
+  const builtins = {
+    assert: assertModule__default.default,
+    "assert/strict": assertModule__default.default.strict ?? assertModule__default.default,
+    buffer: { Buffer: buffer.Buffer, SlowBuffer: buffer.Buffer, INSPECT_MAX_BYTES: 50, kMaxLength: buffer.Buffer.kMaxLength },
+    async_hooks: asyncHooks,
+    child_process: childProcess,
+    console: consoleObject,
+    constants: fs.constants,
+    crypto: createCryptoModule(),
+    dns,
+    "dns/promises": dns.promises,
+    events: EventEmitter3__default.default,
+    fs,
+    "fs/promises": fs.promises,
+    module: moduleBuiltin,
+    http,
+    https: http,
+    os,
+    path,
+    "path/posix": path,
+    perf_hooks: { performance, PerformanceObserver: globalThis.PerformanceObserver },
+    process: processObject,
+    punycode: urlModule__default.default.punycode ?? {},
+    querystring: querystringModule__default.default,
+    readline: readline2,
+    "readline/promises": readline2.promises,
+    stream: streamModule3__default.default,
+    "stream/promises": createStreamPromises(),
+    string_decoder: stringDecoderModule__default.default,
+    timers: { ...timersModule__default.default, ...timers.api },
+    "timers/promises": createTimerPromises(),
+    tty: { isatty: () => false, ReadStream: streamModule3__default.default.Readable, WriteStream: streamModule3__default.default.Writable },
+    url: urlModule__default.default,
+    util: utilModule__default.default,
+    "util/types": utilModule__default.default.types ?? {},
+    zlib: zlibModule__default.default
+  };
+  for (const name of stubNames) builtins[name] = createUnsupportedModule(name);
+  const globals = {
+    Buffer: buffer.Buffer,
+    console: consoleObject,
+    process: processObject,
+    ...timers.api
+  };
+  const globalOverlay = new Proxy(globalThis, {
+    get: (target, key) => typeof key === "string" && key in globals ? globals[key] : key === "global" || key === "globalThis" ? globalOverlay : Reflect.get(target, key),
+    has: (target, key) => typeof key === "string" && key in globals || Reflect.has(target, key)
+  });
+  globals.global = globalOverlay;
+  globals.globalThis = globalOverlay;
+  return { builtins, globals, process: processObject, pendingHandles: timers.pending };
+}
+var ASYNC_FS_METHODS = [
+  "readFile",
+  "writeFile",
+  "appendFile",
+  "stat",
+  "lstat",
+  "fstat",
+  "readdir",
+  "mkdir",
+  "mkdtemp",
+  "rm",
+  "rmdir",
+  "unlink",
+  "rename",
+  "readlink",
+  "symlink",
+  "link",
+  "realpath",
+  "truncate",
+  "ftruncate",
+  "chmod",
+  "lchmod",
+  "fchmod",
+  "chown",
+  "lchown",
+  "fchown",
+  "utimes",
+  "lutimes",
+  "futimes",
+  "access",
+  "copyFile",
+  "cp",
+  "open",
+  "close",
+  "read",
+  "write",
+  "exists"
+];
+function createPathModule(cwd) {
+  const resolve2 = (...segments2) => pathModule__default.default.resolve(cwd(), ...segments2);
+  const path = {
+    ...pathModule__default.default,
+    resolve: resolve2,
+    /* `relative` resolves both operands, and the implementation would do so
+     * against the host cwd, so they are resolved here first. */
+    relative: (from, to) => pathModule__default.default.relative(resolve2(from), resolve2(to))
+  };
+  path.posix = path;
+  path.win32 = pathModule__default.default.win32 ?? path;
+  path.default = path;
+  return path;
+}
+function createFsModule(volume, cwd) {
+  const fds = /* @__PURE__ */ new Map();
+  let nextFd = 3;
+  const abs = (value) => {
+    if (value instanceof URL) value = value.pathname;
+    if (buffer.Buffer.isBuffer(value) || value instanceof Uint8Array) value = new TextDecoder().decode(value);
+    if (typeof value !== "string") throw new TypeError("path must be a string, Buffer, or URL");
+    return value.startsWith("/") ? clean(value) : resolve(cwd(), value);
+  };
+  const bytes = (data, encoding) => {
+    if (typeof data === "string") return new Uint8Array(buffer.Buffer.from(data, encoding));
+    if (buffer.Buffer.isBuffer(data) || data instanceof Uint8Array) return new Uint8Array(data);
+    if (data instanceof ArrayBuffer) return new Uint8Array(data);
+    throw new TypeError("data must be a string or byte array");
+  };
+  const read = (path, encoding) => {
+    const data = buffer.Buffer.from(volume.readFileSync(resolveLinks(volume, abs(path))));
+    return encoding && encoding !== "buffer" ? data.toString(encoding) : data;
+  };
+  const mkdirRecursive = (path, mode) => {
+    let cursor = "";
+    for (const part of segments(path)) {
+      cursor += `/${part}`;
+      try {
+        if (!volume.lstatSync(cursor).isDirectory()) throw fsError("ENOTDIR", "mkdir", cursor);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+        volume.mkdirSync(cursor, { mode });
+      }
+    }
+  };
+  const rmRecursive = (path) => {
+    const stat2 = volume.lstatSync(path);
+    if (!stat2.isDirectory()) return volume.unlinkSync(path);
+    for (const name of volume.readdirSync(path)) rmRecursive(join(path, name));
+    volume.rmdirSync(path);
+  };
+  const callback = (operation, cb) => {
+    queueMicrotask(() => {
+      try {
+        cb(null, operation());
+      } catch (error) {
+        cb(error);
+      }
+    });
+  };
+  const fs = {
+    constants: {
+      F_OK: 0,
+      R_OK: 4,
+      W_OK: 2,
+      X_OK: 1,
+      O_RDONLY: 0,
+      O_WRONLY: 1,
+      O_RDWR: 2,
+      O_CREAT: 64,
+      O_EXCL: 128,
+      O_TRUNC: 512,
+      O_APPEND: 1024,
+      COPYFILE_EXCL: 1
+    },
+    Dirent,
+    readFileSync: (path, options) => read(path, typeof options === "object" && options ? options.encoding : options),
+    writeFileSync: (path, data, options) => {
+      const encoding = typeof options === "object" && options ? options.encoding : options === "buffer" ? void 0 : options ?? void 0;
+      volume.writeFileSync(abs(path), bytes(data, encoding ?? void 0));
+      if (typeof options === "object" && options?.mode !== void 0) volume.chmodSync(abs(path), options.mode);
+    },
+    appendFileSync: (path, data, options) => {
+      const encoding = typeof options === "object" && options ? options.encoding : options === "buffer" ? void 0 : options ?? void 0;
+      volume.appendFileSync(abs(path), bytes(data, encoding ?? void 0));
+    },
+    existsSync: (path) => {
+      try {
+        volume.lstatSync(abs(path));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    statSync: (path) => new Stats2(volume.lstatSync(resolveLinks(volume, abs(path)))),
+    lstatSync: (path) => new Stats2(volume.lstatSync(abs(path))),
+    readdirSync: (path, options) => {
+      const dir3 = resolveLinks(volume, abs(path));
+      const names = volume.readdirSync(dir3);
+      if (typeof options === "object" && options?.withFileTypes) {
+        return names.map((name) => new Dirent(name, new Stats2(volume.lstatSync(join(dir3, name))), dir3));
+      }
+      if ((typeof options === "string" ? options : options?.encoding) === "buffer") return names.map((name) => buffer.Buffer.from(name));
+      return names;
+    },
+    mkdirSync: (path, options) => {
+      const target = abs(path);
+      const mode = typeof options === "number" ? options : options?.mode ?? 511;
+      if (typeof options === "object" && options?.recursive) return mkdirRecursive(target, mode);
+      return volume.mkdirSync(target, { mode });
+    },
+    rmdirSync: (path, options) => options?.recursive ? rmRecursive(abs(path)) : volume.rmdirSync(abs(path)),
+    rmSync: (path, options) => {
+      try {
+        options?.recursive ? rmRecursive(abs(path)) : volume.unlinkSync(abs(path));
+      } catch (error) {
+        if (!options?.force) throw error;
+      }
+    },
+    unlinkSync: (path) => volume.unlinkSync(abs(path)),
+    renameSync: (from, to) => volume.renameSync(abs(from), abs(to)),
+    readlinkSync: (path, encoding) => {
+      const value = volume.readlinkSync(abs(path));
+      return encoding === "buffer" ? buffer.Buffer.from(value) : value;
+    },
+    symlinkSync: (target, path) => volume.symlinkSync(target, abs(path)),
+    linkSync: (from, to) => volume.linkSync(abs(from), abs(to)),
+    realpathSync: (path) => resolveLinks(volume, abs(path)),
+    truncateSync: (path, length = 0) => volume.truncateSync(abs(path), length),
+    chmodSync: (path, mode) => volume.chmodSync(resolveLinks(volume, abs(path)), mode),
+    chownSync: (path, uid, gid) => volume.chownSync(resolveLinks(volume, abs(path)), uid, gid),
+    utimesSync: (path, atime, mtime) => volume.utimesSync(resolveLinks(volume, abs(path)), new Date(atime), new Date(mtime)),
+    accessSync: (path) => {
+      volume.lstatSync(resolveLinks(volume, abs(path)));
+    },
+    copyFileSync: (from, to, flags = 0) => {
+      const target = abs(to);
+      if (flags && fs.existsSync(target)) throw fsError("EEXIST", "copyfile", target);
+      volume.writeFileSync(target, volume.readFileSync(resolveLinks(volume, abs(from))));
+    },
+    openSync: (path, flags) => {
+      const target = abs(path);
+      const textFlags = typeof flags === "number" ? flags === 0 ? "r" : "r+" : flags;
+      if (/[wa]/.test(textFlags) && !fs.existsSync(target)) volume.writeFileSync(target, new Uint8Array());
+      if (textFlags.startsWith("w")) volume.truncateSync(target, 0);
+      else volume.lstatSync(resolveLinks(volume, target));
+      const fd = nextFd++;
+      fds.set(fd, { path: target, position: textFlags.startsWith("a") ? volume.lstatSync(target).size : 0, flags: textFlags });
+      return fd;
+    },
+    closeSync: (fd) => {
+      if (!fds.delete(fd)) throw fsError("EBADF", "close", String(fd));
+    },
+    /** Used by the promise API's FileHandle to reach whole-file operations. */
+    __pathForFd: (fd) => requiredFd(fds, fd).path,
+    fstatSync: (fd) => new Stats2(volume.lstatSync(resolveLinks(volume, requiredFd(fds, fd).path))),
+    readSync: (fd, target, offset, length, position) => {
+      const file3 = requiredFd(fds, fd);
+      const source = volume.readFileSync(resolveLinks(volume, file3.path));
+      const start = position ?? file3.position;
+      const count = Math.max(0, Math.min(length, source.length - start));
+      target.set(source.subarray(start, start + count), offset);
+      if (position == null) file3.position += count;
+      return count;
+    },
+    writeSync: (fd, data, offset, length, position) => {
+      const file3 = requiredFd(fds, fd);
+      const input = bytes(data);
+      const chunk = typeof data === "string" ? input : input.subarray(offset ?? 0, (offset ?? 0) + (length ?? input.length));
+      const old = volume.readFileSync(file3.path);
+      const start = file3.flags.startsWith("a") ? old.length : position ?? file3.position;
+      const next = new Uint8Array(Math.max(old.length, start + chunk.length));
+      next.set(old);
+      next.set(chunk, start);
+      volume.writeFileSync(file3.path, next);
+      if (position == null) file3.position = start + chunk.length;
+      return chunk.length;
+    },
+    createReadStream: (path) => {
+      const data = buffer.Buffer.from(volume.readFileSync(resolveLinks(volume, abs(path))));
+      return streamModule3__default.default.Readable.from([data]);
+    },
+    createWriteStream: (path, options) => {
+      const target = abs(path);
+      let first = true;
+      return new streamModule3__default.default.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);
+        }
+      } });
+    },
+    watch: () => new FsWatcher(),
+    watchFile: () => {
+    },
+    unwatchFile: () => {
+    }
+  };
+  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);
+  fs.futimesSync = (fd, atime, mtime) => fs.utimesSync(requiredFd(fds, fd).path, atime, mtime);
+  fs.lchmodSync = (path, mode) => volume.lchmodSync(abs(path), mode);
+  fs.lchownSync = (path, uid, gid) => volume.lchownSync(abs(path), uid, gid);
+  fs.lutimesSync = (path, atime, mtime) => fs.utimesSync(path, atime, mtime);
+  fs.realpathSync.native = fs.realpathSync;
+  fs.mkdtempSync = (prefix) => {
+    const target = `${String(prefix)}${Math.random().toString(36).slice(2, 8)}`;
+    volume.mkdirSync(resolve(cwd(), target), { mode: 448 });
+    return target;
+  };
+  fs.cpSync = (from, to, options) => {
+    const copy = (source, destination) => {
+      const stat2 = volume.lstatSync(source);
+      if (stat2.isDirectory()) {
+        if (!options?.recursive) throw fsError("EISDIR", "cp", source);
+        mkdirRecursive(destination, stat2.mode);
+        for (const name of volume.readdirSync(source)) {
+          copy(join(source, name), join(destination, name));
+        }
+        return;
+      }
+      if (stat2.isSymbolicLink()) {
+        volume.symlinkSync(volume.readlinkSync(source), destination);
+        return;
+      }
+      volume.writeFileSync(destination, volume.readFileSync(source));
+    };
+    copy(abs(from), abs(to));
+  };
+  for (const name of ASYNC_FS_METHODS) {
+    if (name === "exists") continue;
+    fs[name] = (...args) => {
+      const cb = args.pop();
+      if (typeof cb !== "function") throw new TypeError("callback must be a function");
+      callback(() => fs[`${name}Sync`](...args), cb);
+    };
+  }
+  fs.realpath.native = fs.realpath;
+  fs.exists = (path, cb) => {
+    queueMicrotask(() => cb(fs.existsSync(path)));
+  };
+  fs.promises = {
+    ...Object.fromEntries(
+      ASYNC_FS_METHODS.filter((name) => name !== "exists" && name !== "open").map((name) => [name, (...args) => Promise.resolve().then(() => fs[`${name}Sync`](...args))])
+    ),
+    constants: fs.constants,
+    /* 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))
+  };
+  return fs;
+}
+function makeFileHandle(fs, fd) {
+  return {
+    fd,
+    close: async () => fs.closeSync(fd),
+    stat: async () => fs.fstatSync(fd),
+    truncate: async (length) => fs.ftruncateSync(fd, length),
+    chmod: async (mode) => fs.fchmodSync(fd, mode),
+    chown: async (uid, gid) => fs.fchownSync(fd, uid, gid),
+    utimes: async (atime, mtime) => fs.futimesSync(fd, atime, mtime),
+    read: async (buffer, offset = 0, length = buffer.length, position) => ({
+      bytesRead: fs.readSync(fd, buffer, offset, length, position),
+      buffer
+    }),
+    write: async (data, offset, length, position) => ({
+      bytesWritten: fs.writeSync(fd, data, offset, length, position),
+      buffer: data
+    }),
+    readFile: async (options) => fs.readFileSync(fs.__pathForFd(fd), options),
+    writeFile: async (data, options) => fs.writeFileSync(fs.__pathForFd(fd), data, options)
+  };
+}
+function resolveLinks(volume, input) {
+  let path = clean(input);
+  for (let hops = 0; hops < 40; hops++) {
+    const parts = segments(path);
+    let cursor = "";
+    let followed = false;
+    for (let index = 0; index < parts.length; index++) {
+      cursor += `/${parts[index]}`;
+      const stat2 = volume.lstatSync(cursor);
+      if (!stat2.isSymbolicLink()) continue;
+      const target = volume.readlinkSync(cursor);
+      const rest = parts.slice(index + 1).join("/");
+      path = resolve(dirname(cursor), target, rest);
+      followed = true;
+      break;
+    }
+    if (!followed) return path || "/";
+  }
+  throw fsError("ELOOP", "realpath", input);
+}
+function requiredFd(fds, fd) {
+  const file3 = fds.get(fd);
+  if (!file3) throw fsError("EBADF", "fd", String(fd));
+  return file3;
+}
+function fsError(code, syscall, path) {
+  return Object.assign(new Error(`${code}: ${syscall}, '${path}'`), { code, syscall, path });
+}
+function makeOutputStream(write, fd) {
+  const stream = new streamModule3__default.default.Writable({ write(chunk, _encoding, done) {
+    write(buffer.Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+    done();
+  } });
+  return Object.assign(stream, { fd, isTTY: false, columns: 80, rows: 24 });
+}
+var Console = class {
+  constructor(out, err) {
+    this.out = out;
+    this.err = err;
+  }
+  out;
+  err;
+  log = (...args) => {
+    this.out(utilModule__default.default.format(...args) + "\n");
+  };
+  info = (...args) => {
+    this.log(...args);
+  };
+  debug = (...args) => {
+    this.log(...args);
+  };
+  warn = (...args) => {
+    this.err(utilModule__default.default.format(...args) + "\n");
+  };
+  error = (...args) => {
+    this.warn(...args);
+  };
+  dir = (value, options) => {
+    this.out(utilModule__default.default.inspect(value, options) + "\n");
+  };
+  trace = (...args) => {
+    this.err(`Trace: ${utilModule__default.default.format(...args)}
+`);
+  };
+  assert = (value, ...args) => {
+    if (!value) this.err(`Assertion failed: ${utilModule__default.default.format(...args)}
+`);
+  };
+  group = (...args) => {
+    if (args.length) this.log(...args);
+  };
+  groupEnd = () => {
+  };
+  table = (value) => {
+    this.dir(value);
+  };
+  count = () => {
+  };
+  countReset = () => {
+  };
+  time = (_label = "default") => {
+  };
+  timeEnd = (_label = "default") => {
+  };
+  timeLog = (_label = "default") => {
+  };
+};
+function createReadlineModule(stdin) {
+  class Interface extends EventEmitter3__default.default {
+    constructor(input) {
+      super();
+      this.input = input;
+      input?.on?.("data", (chunk) => {
+        for (const line of String(chunk).split("\n")) this.lines.push(line);
+        while (this.lines.length > 1) this.emit("line", this.lines.shift());
+      });
+      input?.on?.("end", () => this.close());
+    }
+    input;
+    closed = false;
+    lines = [];
+    question(_query, callback) {
+      const answer = this.lines.shift() ?? "";
+      if (callback) {
+        queueMicrotask(() => callback(answer));
+        return;
+      }
+      return Promise.resolve(answer);
+    }
+    prompt() {
+    }
+    setPrompt() {
+    }
+    pause() {
+      return this;
+    }
+    resume() {
+      return this;
+    }
+    write() {
+    }
+    close() {
+      if (this.closed) return;
+      this.closed = true;
+      this.emit("close");
+    }
+    async *[Symbol.asyncIterator]() {
+      while (this.lines.length) yield this.lines.shift();
+    }
+  }
+  const createInterface = (options) => new Interface(options?.input ?? (Array.isArray(options) ? options[0] : stdin()));
+  const noop = () => {
+  };
+  const base = {
+    Interface,
+    createInterface,
+    clearLine: noop,
+    clearScreenDown: noop,
+    cursorTo: noop,
+    moveCursor: noop,
+    emitKeypressEvents: noop
+  };
+  return { ...base, promises: { ...base, Interface, createInterface } };
+}
+function createDnsModule() {
+  const LOOPBACK = {
+    localhost: { address: "127.0.0.1", family: 4 },
+    "127.0.0.1": { address: "127.0.0.1", family: 4 },
+    "0.0.0.0": { address: "0.0.0.0", family: 4 },
+    "::1": { address: "::1", family: 6 }
+  };
+  const lookupSync = (hostname) => {
+    const entry = LOOPBACK[hostname];
+    if (entry) return entry;
+    const error = new Error(`getaddrinfo ENOTFOUND ${hostname}`);
+    error.code = "ENOTFOUND";
+    error.errno = -3008;
+    error.syscall = "getaddrinfo";
+    error.hostname = hostname;
+    throw error;
+  };
+  const lookup = (hostname, options, callback) => {
+    const done = typeof options === "function" ? options : callback;
+    const all = typeof options === "object" && options !== null && options.all;
+    queueMicrotask(() => {
+      try {
+        const entry = lookupSync(hostname);
+        done?.(null, all ? [entry] : entry.address, entry.family);
+      } catch (error) {
+        done?.(error);
+      }
+    });
+  };
+  const notFound = (hostname) => Promise.reject(lookupThrow(hostname));
+  const lookupThrow = (hostname) => {
+    try {
+      lookupSync(hostname);
+      return null;
+    } catch (error) {
+      return error;
+    }
+  };
+  const promises = {
+    lookup: async (hostname, options) => {
+      const entry = lookupSync(hostname);
+      return options?.all ? [entry] : entry;
+    },
+    resolve4: async (hostname) => [lookupSync(hostname).address],
+    resolve6: async (hostname) => [lookupSync(hostname).address],
+    reverse: async (address) => address === "127.0.0.1" ? ["localhost"] : notFound(address)
+  };
+  return {
+    lookup,
+    promises,
+    Resolver: class Resolver {
+    },
+    getServers: () => [],
+    setServers: () => {
+    },
+    ADDRCONFIG: 1024,
+    V4MAPPED: 8,
+    ALL: 16,
+    NODATA: "ENODATA",
+    NOTFOUND: "ENOTFOUND"
+  };
+}
+function createOsModule() {
+  return {
+    EOL: "\n",
+    devNull: "/dev/null",
+    type: () => "Linux",
+    platform: () => "linux",
+    release: () => "5.10.0-sandboxedjs",
+    version: () => "#1 SMP SandboxedJS",
+    arch: () => "x64",
+    endianness: () => "LE",
+    hostname: () => "sandbox",
+    homedir: () => "/root",
+    tmpdir: () => "/tmp",
+    userInfo: () => ({ uid: 0, gid: 0, username: "root", homedir: "/root", shell: "/bin/sh" }),
+    cpus: () => [{ model: "SandboxedJS Virtual CPU", speed: 1e3, times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 } }],
+    totalmem: () => 2 * 1024 ** 3,
+    freemem: () => 1024 ** 3,
+    uptime: () => performance.now() / 1e3,
+    loadavg: () => [0, 0, 0],
+    networkInterfaces: () => ({}),
+    machine: () => "x86_64",
+    availableParallelism: () => 4,
+    /* `os.constants.signals` is not decoration: the `human-signals` package
+     * that `execa` pulls in enumerates it at load time, so every tool built on
+     * execa fails to even import without it. */
+    constants: {
+      signals: exports.SIGNALS,
+      errno: ERRNO_CONSTANTS,
+      priority: {
+        PRIORITY_LOW: 19,
+        PRIORITY_BELOW_NORMAL: 10,
+        PRIORITY_NORMAL: 0,
+        PRIORITY_ABOVE_NORMAL: -7,
+        PRIORITY_HIGH: -14,
+        PRIORITY_HIGHEST: -20
+      }
+    }
+  };
+}
+var ERRNO_CONSTANTS = {
+  E2BIG: 7,
+  EACCES: 13,
+  EADDRINUSE: 98,
+  EADDRNOTAVAIL: 99,
+  EAFNOSUPPORT: 97,
+  EAGAIN: 11,
+  EALREADY: 114,
+  EBADF: 9,
+  EBADMSG: 74,
+  EBUSY: 16,
+  ECANCELED: 125,
+  ECHILD: 10,
+  ECONNABORTED: 103,
+  ECONNREFUSED: 111,
+  ECONNRESET: 104,
+  EDEADLK: 35,
+  EDESTADDRREQ: 89,
+  EDOM: 33,
+  EDQUOT: 122,
+  EEXIST: 17,
+  EFAULT: 14,
+  EFBIG: 27,
+  EHOSTUNREACH: 113,
+  EIDRM: 43,
+  EILSEQ: 84,
+  EINPROGRESS: 115,
+  EINTR: 4,
+  EINVAL: 22,
+  EIO: 5,
+  EISCONN: 106,
+  EISDIR: 21,
+  ELOOP: 40,
+  EMFILE: 24,
+  EMLINK: 31,
+  EMSGSIZE: 90,
+  EMULTIHOP: 72,
+  ENAMETOOLONG: 36,
+  ENETDOWN: 100,
+  ENETRESET: 102,
+  ENETUNREACH: 101,
+  ENFILE: 23,
+  ENOBUFS: 105,
+  ENODATA: 61,
+  ENODEV: 19,
+  ENOENT: 2,
+  ENOEXEC: 8,
+  ENOLCK: 37,
+  ENOLINK: 67,
+  ENOMEM: 12,
+  ENOMSG: 42,
+  ENOPROTOOPT: 92,
+  ENOSPC: 28,
+  ENOSR: 63,
+  ENOSTR: 60,
+  ENOSYS: 38,
+  ENOTCONN: 107,
+  ENOTDIR: 20,
+  ENOTEMPTY: 39,
+  ENOTSOCK: 88,
+  ENOTSUP: 95,
+  ENOTTY: 25,
+  ENXIO: 6,
+  EOPNOTSUPP: 95,
+  EOVERFLOW: 75,
+  EPERM: 1,
+  EPIPE: 32,
+  EPROTO: 71,
+  EPROTONOSUPPORT: 93,
+  EPROTOTYPE: 91,
+  ERANGE: 34,
+  EROFS: 30,
+  ESPIPE: 29,
+  ESRCH: 3,
+  ESTALE: 116,
+  ETIME: 62,
+  ETIMEDOUT: 110,
+  ETXTBSY: 26,
+  EWOULDBLOCK: 11,
+  EXDEV: 18
+};
+function createTrackedTimers() {
+  const live = /* @__PURE__ */ new Set();
+  const track = (handle, repeating) => {
+    live.add(handle);
+    return handle;
+  };
+  const setTimeoutTracked = (fn, delay, ...args) => {
+    const handle = setTimeout(
+      (...inner) => {
+        live.delete(handle);
+        fn(...inner);
+      },
+      delay,
+      ...args
+    );
+    live.add(handle);
+    return handle;
+  };
+  const setIntervalTracked = (fn, delay, ...args) => track(setInterval(fn, delay, ...args));
+  const hostSetImmediate = globalThis.setImmediate;
+  const setImmediateTracked = (fn, ...args) => {
+    const handle = hostSetImmediate ? hostSetImmediate((...inner) => {
+      live.delete(handle);
+      fn(...inner);
+    }, ...args) : setTimeoutTracked(fn, 0, ...args);
+    live.add(handle);
+    return handle;
+  };
+  const clear2 = (handle, native) => {
+    live.delete(handle);
+    native(handle);
+  };
+  return {
+    api: {
+      setTimeout: setTimeoutTracked,
+      setInterval: setIntervalTracked,
+      setImmediate: setImmediateTracked,
+      clearTimeout: (handle) => clear2(handle, clearTimeout),
+      clearInterval: (handle) => clear2(handle, clearInterval),
+      clearImmediate: (handle) => clear2(handle, globalThis.clearImmediate ?? clearTimeout)
+    },
+    pending: () => live.size
+  };
+}
+function createTimerPromises() {
+  return {
+    setTimeout: (delay, value) => new Promise((resolve2) => setTimeout(resolve2, delay, value)),
+    setImmediate: (value) => new Promise((resolve2) => setTimeout(resolve2, 0, value))
+  };
+}
+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,
+    executionAsyncId: () => 1,
+    triggerAsyncId: () => 0,
+    executionAsyncResource: () => ({}),
+    createHook: () => ({ enable() {
+      return this;
+    }, disable() {
+      return this;
+    } })
+  };
+}
+function createStreamPromises() {
+  return {
+    pipeline: (...streams) => new Promise((resolve2, reject) => {
+      const callback = (error) => error ? reject(error) : resolve2();
+      streamModule3__default.default.pipeline(...streams, callback);
+    }),
+    finished: (stream) => new Promise((resolve2, reject) => {
+      streamModule3__default.default.finished(stream, (error) => error ? reject(error) : resolve2());
+    })
+  };
+}
+function createUnsupportedModule(name) {
+  const unsupported = () => {
+    const error = new Error(`${name} is unavailable in the browser runtime`);
+    error.code = "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM";
+    throw error;
+  };
+  return new Proxy({ unsupported }, { get(target, key) {
+    return key in target ? target[key] : unsupported;
+  } });
+}
+var stubNames = ["cluster", "dgram", "diagnostics_channel", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
+var builtinNames2 = [
+  "assert",
+  "assert/strict",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "console",
+  "constants",
+  "crypto",
+  "events",
+  "fs",
+  "fs/promises",
+  "dns",
+  "dns/promises",
+  "http",
+  "https",
+  "module",
+  "os",
+  "path",
+  "path/posix",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "readline/promises",
+  "stream",
+  "stream/promises",
+  "string_decoder",
+  "timers",
+  "timers/promises",
+  "tty",
+  "url",
+  "util",
+  "util/types",
+  "zlib",
+  ...stubNames
+];
+
+// src/runtime/memory-volume.ts
+init_path();
+var VolumeError = class extends Error {
+  constructor(code, operation, path) {
+    super(`${code}: ${operation}, '${path}'`);
+    this.code = code;
+    this.name = "VolumeError";
+  }
+  code;
+};
+var MemoryStat = class {
+  constructor(inode) {
+    this.inode = inode;
+  }
+  inode;
+  get mode() {
+    return this.inode.mode;
+  }
+  get size() {
+    return this.inode.kind === "file" ? this.inode.data.length : this.inode.kind === "symlink" ? new TextEncoder().encode(this.inode.target).length : 0;
+  }
+  get uid() {
+    return this.inode.uid;
+  }
+  get gid() {
+    return this.inode.gid;
+  }
+  get ino() {
+    return this.inode.ino;
+  }
+  get nlink() {
+    return this.inode.nlink;
+  }
+  get atimeMs() {
+    return this.inode.atimeMs;
+  }
+  get mtimeMs() {
+    return this.inode.mtimeMs;
+  }
+  get ctimeMs() {
+    return this.inode.ctimeMs;
+  }
+  get birthtimeMs() {
+    return this.inode.birthtimeMs;
+  }
+  isFile() {
+    return this.inode.kind === "file";
+  }
+  isDirectory() {
+    return this.inode.kind === "directory";
+  }
+  isSymbolicLink() {
+    return this.inode.kind === "symlink";
+  }
+};
+var encoder6 = new TextEncoder();
+var MemoryVolume = class {
+  entries = /* @__PURE__ */ new Map();
+  nextIno = 2;
+  constructor() {
+    this.entries.set("/", this.inode("directory", 493));
+  }
+  readFileSync(path) {
+    const key = this.key(path);
+    const node2 = this.required(key, "open");
+    if (node2.kind === "directory") throw new VolumeError("EISDIR", "read", key);
+    if (node2.kind !== "file") throw new VolumeError("EINVAL", "read", key);
+    node2.atimeMs = Date.now();
+    return node2.data.slice();
+  }
+  writeFileSync(path, data) {
+    const key = this.key(path);
+    this.requireParent(key, "open");
+    const bytes = typeof data === "string" ? encoder6.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 = bytes;
+      this.touchChanged(current, true);
+    } else {
+      this.entries.set(key, this.inode("file", 438, bytes));
+    }
+  }
+  appendFileSync(path, data) {
+    const key = this.key(path);
+    const bytes = typeof data === "string" ? encoder6.encode(data) : data;
+    const current = this.entries.get(key);
+    if (!current) return this.writeFileSync(key, bytes);
+    if (current.kind !== "file") throw new VolumeError(current.kind === "directory" ? "EISDIR" : "EINVAL", "open", key);
+    const next = new Uint8Array(current.data.length + bytes.length);
+    next.set(current.data);
+    next.set(bytes, current.data.length);
+    current.data = next;
+    this.touchChanged(current, true);
+  }
+  readdirSync(path) {
+    const key = this.key(path);
+    const node2 = this.required(key, "scandir");
+    if (node2.kind !== "directory") throw new VolumeError("ENOTDIR", "scandir", key);
+    const prefix = key === "/" ? "/" : `${key}/`;
+    const names = /* @__PURE__ */ new Set();
+    for (const candidate of this.entries.keys()) {
+      if (!candidate.startsWith(prefix) || candidate === key) continue;
+      const rest = candidate.slice(prefix.length);
+      if (rest && !rest.includes("/")) names.add(rest);
+    }
+    node2.atimeMs = Date.now();
+    return [...names].sort();
+  }
+  lstatSync(path) {
+    return new MemoryStat(this.required(this.key(path), "lstat"));
+  }
+  readlinkSync(path) {
+    const key = this.key(path);
+    const node2 = this.required(key, "readlink");
+    if (node2.kind !== "symlink") throw new VolumeError("EINVAL", "readlink", key);
+    return node2.target;
+  }
+  mkdirSync(path, options = {}) {
+    const key = this.key(path);
+    if (this.entries.has(key)) throw new VolumeError("EEXIST", "mkdir", key);
+    this.requireParent(key, "mkdir");
+    this.entries.set(key, this.inode("directory", options.mode ?? 511));
+  }
+  rmdirSync(path) {
+    const key = this.key(path);
+    if (key === "/") throw new VolumeError("EBUSY", "rmdir", key);
+    const node2 = this.required(key, "rmdir");
+    if (node2.kind !== "directory") throw new VolumeError("ENOTDIR", "rmdir", key);
+    const prefix = `${key}/`;
+    if ([...this.entries.keys()].some((candidate) => candidate.startsWith(prefix))) {
+      throw new VolumeError("ENOTEMPTY", "rmdir", key);
+    }
+    this.entries.delete(key);
+  }
+  unlinkSync(path) {
+    const key = this.key(path);
+    const node2 = this.required(key, "unlink");
+    if (node2.kind === "directory") throw new VolumeError("EISDIR", "unlink", key);
+    this.entries.delete(key);
+    node2.nlink--;
+    node2.ctimeMs = Date.now();
+  }
+  renameSync(from, to) {
+    const source = this.key(from);
+    const dest = this.key(to);
+    const node2 = this.required(source, "rename");
+    this.requireParent(dest, "rename");
+    if (source === "/") throw new VolumeError("EBUSY", "rename", source);
+    if (dest.startsWith(`${source}/`)) throw new VolumeError("EINVAL", "rename", source);
+    const existing = this.entries.get(dest);
+    if (existing?.kind === "directory" && this.readdirSync(dest).length > 0) {
+      throw new VolumeError("ENOTEMPTY", "rename", dest);
+    }
+    if (existing) {
+      this.entries.delete(dest);
+      existing.nlink--;
+    }
+    const moved = [...this.entries.entries()].filter(([path]) => path === source || path.startsWith(`${source}/`)).sort(([a], [b]) => a.length - b.length);
+    for (const [path] of moved) this.entries.delete(path);
+    for (const [path, value] of moved) {
+      this.entries.set(dest + path.slice(source.length), value);
+      value.ctimeMs = Date.now();
+    }
+    node2.ctimeMs = Date.now();
+  }
+  symlinkSync(target, path) {
+    const key = this.key(path);
+    if (this.entries.has(key)) throw new VolumeError("EEXIST", "symlink", key);
+    this.requireParent(key, "symlink");
+    const node2 = this.inode("symlink", 511);
+    node2.target = target;
+    this.entries.set(key, node2);
+  }
+  linkSync(existing, path) {
+    const source = this.key(existing);
+    const dest = this.key(path);
+    const node2 = this.required(source, "link");
+    if (node2.kind === "directory") throw new VolumeError("EPERM", "link", source);
+    if (this.entries.has(dest)) throw new VolumeError("EEXIST", "link", dest);
+    this.requireParent(dest, "link");
+    node2.nlink++;
+    node2.ctimeMs = Date.now();
+    this.entries.set(dest, node2);
+  }
+  truncateSync(path, length = 0) {
+    const key = this.key(path);
+    const node2 = this.required(key, "truncate");
+    if (node2.kind !== "file") throw new VolumeError(node2.kind === "directory" ? "EISDIR" : "EINVAL", "truncate", key);
+    const data = new Uint8Array(length);
+    data.set(node2.data.subarray(0, length));
+    node2.data = data;
+    this.touchChanged(node2, true);
+  }
+  chmodSync(path, mode) {
+    this.setMode(path, mode);
+  }
+  lchmodSync(path, mode) {
+    this.setMode(path, mode);
+  }
+  chownSync(path, uid, gid) {
+    this.setOwner(path, uid, gid);
+  }
+  lchownSync(path, uid, gid) {
+    this.setOwner(path, uid, gid);
+  }
+  utimesSync(path, atime, mtime) {
+    const node2 = this.required(this.key(path), "utimes");
+    node2.atimeMs = atime.getTime();
+    node2.mtimeMs = mtime.getTime();
+    node2.ctimeMs = Date.now();
+  }
+  getStats() {
+    const seen = /* @__PURE__ */ new Set();
+    let totalBytes = 0;
+    let fileCount = 0;
+    let directoryCount = 0;
+    for (const node2 of this.entries.values()) {
+      if (seen.has(node2.ino)) continue;
+      seen.add(node2.ino);
+      if (node2.kind === "directory") directoryCount++;
+      else {
+        fileCount++;
+        totalBytes += node2.kind === "file" ? node2.data.length : encoder6.encode(node2.target).length;
+      }
+    }
+    return { totalBytes, fileCount, directoryCount, dirCount: directoryCount };
+  }
+  snapshot() {
+    return [...this.entries.entries()].map(([path, node2]) => ({ path, ...node2, data: [...node2.data] }));
+  }
+  restore(snapshot) {
+    const inodes = /* @__PURE__ */ new Map();
+    const entries = /* @__PURE__ */ new Map();
+    for (const item of snapshot) {
+      let inode = inodes.get(item.ino);
+      if (!inode) {
+        inode = { ...item, data: new Uint8Array(item.data) };
+        inodes.set(item.ino, inode);
+      }
+      entries.set(this.key(item.path), inode);
+    }
+    if (!entries.has("/")) throw new VolumeError("EINVAL", "restore", "/");
+    this.entries.clear();
+    for (const [path, inode] of entries) this.entries.set(path, inode);
+    this.nextIno = Math.max(1, ...inodes.keys()) + 1;
+  }
+  /** Serializable representation used by RuntimePod snapshots. */
+  export() {
+    return [...this.entries.entries()].map(([path, node2]) => ({
+      path,
+      kind: node2.kind,
+      mode: node2.mode,
+      uid: node2.uid,
+      gid: node2.gid,
+      ...node2.kind === "file" ? { data: [...node2.data] } : {},
+      ...node2.kind === "symlink" ? { target: node2.target } : {}
+    }));
+  }
+  setMode(path, mode) {
+    const node2 = this.required(this.key(path), "chmod");
+    node2.mode = mode & 4095;
+    node2.ctimeMs = Date.now();
+  }
+  setOwner(path, uid, gid) {
+    const node2 = this.required(this.key(path), "chown");
+    node2.uid = uid;
+    node2.gid = gid;
+    node2.ctimeMs = Date.now();
+  }
+  key(path) {
+    const clean2 = clean(path);
+    if (!isAbsolute(clean2)) throw new VolumeError("EINVAL", "path", path);
+    return clean2;
+  }
+  required(path, operation) {
+    const node2 = this.entries.get(path);
+    if (!node2) throw new VolumeError("ENOENT", operation, path);
+    return node2;
+  }
+  requireParent(path, operation) {
+    const parent = this.required(dirname(path), operation);
+    if (parent.kind !== "directory") throw new VolumeError("ENOTDIR", operation, path);
+    return parent;
+  }
+  inode(kind, mode, data = new Uint8Array(0)) {
+    const now = Date.now();
+    return {
+      ino: kind === "directory" && this.entries.size === 0 ? 1 : this.nextIno++,
+      kind,
+      mode: mode & 4095,
+      uid: 0,
+      gid: 0,
+      nlink: 1,
+      data,
+      target: "",
+      atimeMs: now,
+      mtimeMs: now,
+      ctimeMs: now,
+      birthtimeMs: now
+    };
+  }
+  touchChanged(node2, modified) {
+    const now = Date.now();
+    node2.ctimeMs = now;
+    if (modified) node2.mtimeMs = now;
+  }
+};
+
+// src/pkg/clean-installer.ts
+init_path();
+var CleanPackageInstaller = class _CleanPackageInstaller {
+  constructor(volume, options = {}) {
+    this.volume = volume;
+    this.options = options;
+    this.registry = (options.registry ?? "https://registry.npmjs.org").replace(/\/$/, "");
+    this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  volume;
+  options;
+  registry;
+  fetcher;
+  metadata = /* @__PURE__ */ new Map();
+  tarballs = /* @__PURE__ */ new Map();
+  forCwd(cwd) {
+    return new _CleanPackageInstaller(this.volume, { ...this.options, cwd });
+  }
+  async install(name, version = "latest", options = {}) {
+    const cwd = this.options.cwd ?? "/";
+    const manifest = await this.installAt(name, version || "latest", join(cwd, "node_modules"), options, /* @__PURE__ */ new Set());
+    if (options.persist !== false) this.persist(cwd, name, version, options.persistDev === true);
+    return manifest;
+  }
+  async installFromManifest(path, options = {}) {
+    const project = this.readJson(path);
+    const cwd = dirname(path);
+    const dependencies = {
+      ...project.dependencies ?? {},
+      ...options.withDevDeps === false ? {} : project.devDependencies ?? {}
+    };
+    for (const [name, range] of Object.entries(dependencies)) {
+      await this.installAt(name, range, join(cwd, "node_modules"), options, /* @__PURE__ */ new Set());
+    }
+  }
+  async installAt(name, range, modulesRoot, options, ancestry) {
+    const metadata = await this.getMetadata(name);
+    const version = resolveVersion(metadata, range);
+    const manifest = metadata.versions[version];
+    if (!manifest) throw new Error(`No matching version found for ${name}@${range}`);
+    const identity = `${name}@${version}`;
+    const target = join(modulesRoot, name);
+    const installed2 = this.tryReadJson(join(target, "package.json"));
+    if (installed2?.version === version) return installed2;
+    if (ancestry.has(identity)) return manifest;
+    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);
+    extractNpmTarball(this.volume, archive, target);
+    options.onProgress?.(`Installed ${identity}`);
+    this.createBinLinks(manifest, target, modulesRoot);
+    const nextAncestry = new Set(ancestry).add(identity);
+    const childRoot = join(target, "node_modules");
+    for (const [dependency, dependencyRange] of Object.entries(manifest.dependencies ?? {})) {
+      await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
+    }
+    for (const [dependency, dependencyRange] of Object.entries(manifest.optionalDependencies ?? {})) {
+      try {
+        await this.installAt(dependency, dependencyRange, childRoot, options, nextAncestry);
+      } catch (error) {
+        options.onProgress?.(`Skipped optional ${dependency}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return manifest;
+  }
+  async getMetadata(name) {
+    let request = this.metadata.get(name);
+    if (!request) {
+      request = (async () => {
+        const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name);
+        const response = await this.fetcher(`${this.registry}/${encoded}`, {
+          headers: { Accept: "application/vnd.npm.install-v1+json" }
+        });
+        if (!response.ok) throw new Error(`registry returned ${response.status} for ${name}`);
+        return await response.json();
+      })();
+      this.metadata.set(name, request);
+    }
+    return request;
+  }
+  async getTarball(url) {
+    let request = this.tarballs.get(url);
+    if (!request) {
+      request = (async () => {
+        const response = await this.fetcher(url);
+        if (!response.ok) throw new Error(`tarball returned ${response.status}: ${url}`);
+        return new Uint8Array(await response.arrayBuffer());
+      })();
+      this.tarballs.set(url, request);
+    }
+    return request;
+  }
+  createBinLinks(manifest, target, modulesRoot) {
+    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);
+    for (const [name, path] of Object.entries(bins)) {
+      const link = join(binDir, name);
+      this.removeIfPresent(link);
+      this.volume.symlinkSync(relative(binDir, join(target, path)), link);
+    }
+  }
+  persist(cwd, name, range, dev) {
+    const path = join(cwd, "package.json");
+    const manifest = this.tryReadJson(path) ?? {};
+    const key = dev ? "devDependencies" : "dependencies";
+    manifest[key] = { ...manifest[key] ?? {}, [name]: range === "latest" ? "*" : range };
+    this.volume.writeFileSync(path, JSON.stringify(manifest, null, 2) + "\n");
+  }
+  removeIfPresent(path) {
+    let stat2;
+    try {
+      stat2 = this.volume.lstatSync(path);
+    } catch {
+      return;
+    }
+    if (!stat2.isDirectory()) return this.volume.unlinkSync(path);
+    for (const name of this.volume.readdirSync(path)) this.removeIfPresent(join(path, name));
+    this.volume.rmdirSync(path);
+  }
+  readJson(path) {
+    return JSON.parse(new TextDecoder().decode(this.volume.readFileSync(path)));
+  }
+  tryReadJson(path) {
+    try {
+      return this.readJson(path);
+    } catch {
+      return null;
+    }
+  }
+};
+function resolveVersion(metadata, range) {
+  const tag = metadata["dist-tags"]?.[range];
+  if (tag) return tag;
+  if (semver.valid(range) && metadata.versions[range]) return range;
+  const found = semver.maxSatisfying(Object.keys(metadata.versions), range === "latest" ? "*" : range, { includePrerelease: false });
+  if (!found) throw new Error(`No matching version found for ${metadata.name}@${range}`);
+  return found;
+}
+function verifyIntegrity(data, integrity, shasum, identity) {
+  if (integrity) {
+    const choices = integrity.trim().split(/\s+/);
+    for (const choice of choices) {
+      const dash = choice.indexOf("-");
+      const algorithm = choice.slice(0, dash);
+      const expected = choice.slice(dash + 1).replace(/\?.*$/, "");
+      const digest = algorithm === "sha512" ? sha512.sha512(data) : algorithm === "sha256" ? sha256.sha256(data) : null;
+      if (digest && buffer.Buffer.from(digest).toString("base64") === expected) return;
+    }
+    throw new Error(`Integrity check failed for ${identity}`);
+  }
+  if (shasum && buffer.Buffer.from(sha1.sha1(data)).toString("hex") === shasum) return;
+  if (shasum) throw new Error(`Legacy checksum check failed for ${identity}`);
+}
+function extractNpmTarball(volume, compressed, destination) {
+  const tar2 = pako.ungzip(compressed);
+  let offset = 0;
+  let longPath = null;
+  let paxPath = null;
+  while (offset + 512 <= tar2.length) {
+    const header = tar2.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const size = octal(header, 124, 12);
+    const type = String.fromCharCode(header[156] || 48);
+    const prefix = text(header, 345, 155);
+    let name = longPath ?? paxPath ?? [prefix, text(header, 0, 100)].filter(Boolean).join("/");
+    longPath = null;
+    paxPath = null;
+    const data = tar2.subarray(offset + 512, offset + 512 + size);
+    offset += 512 + Math.ceil(size / 512) * 512;
+    if (type === "L") {
+      longPath = new TextDecoder().decode(data).replace(/\0.*$/, "").trim();
+      continue;
+    }
+    if (type === "x" || type === "g") {
+      paxPath = parsePax(data).path ?? null;
+      continue;
+    }
+    name = stripPackageRoot(name);
+    if (!name) continue;
+    const target = safeTarget(destination, name);
+    const mode = octal(header, 100, 8) || 420;
+    if (type === "5") {
+      mkdirp(volume, target, mode);
+    } else if (type === "2") {
+      mkdirp(volume, dirname(target));
+      volume.symlinkSync(text(header, 157, 100), target);
+    } else if (type === "1") {
+      mkdirp(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));
+      volume.writeFileSync(target, data.slice());
+      volume.chmodSync(target, mode);
+    }
+  }
+}
+function mkdirp(volume, path, mode = 493) {
+  let current = "";
+  for (const part of segments(path)) {
+    current += `/${part}`;
+    try {
+      volume.mkdirSync(current, { mode });
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      if (!volume.lstatSync(current).isDirectory()) throw error;
+    }
+  }
+}
+function safeTarget(destination, name) {
+  const clean2 = clean(`/${name}`).slice(1);
+  if (!clean2 || clean2 === ".." || clean2.startsWith("../") || name.startsWith("/")) throw new Error(`Unsafe path in package: ${name}`);
+  return join(destination, clean2);
+}
+function stripPackageRoot(name) {
+  return name.replace(/^\.\//, "").replace(/^package\//, "").replace(/\/$/, "");
+}
+function text(bytes, start, length) {
+  return new TextDecoder().decode(bytes.subarray(start, start + length)).replace(/\0.*$/, "").trim();
+}
+function octal(bytes, start, length) {
+  return parseInt(text(bytes, start, length).replace(/^0+/, "") || "0", 8);
+}
+function parsePax(data) {
+  const value = new TextDecoder().decode(data);
+  const result = {};
+  let offset = 0;
+  while (offset < value.length) {
+    const space = value.indexOf(" ", offset);
+    if (space < 0) break;
+    const length = Number(value.slice(offset, space));
+    if (!Number.isFinite(length) || length <= 0) break;
+    const record = value.slice(space + 1, offset + length - 1);
+    const equal = record.indexOf("=");
+    if (equal > 0) result[record.slice(0, equal)] = record.slice(equal + 1);
+    offset += length;
+  }
+  return result;
+}
+function unscoped(name) {
+  return name.startsWith("@") ? name.slice(name.indexOf("/") + 1) : name;
+}
+
+// src/runtime/host-esbuild.ts
+var cached = null;
+function loadHostEsbuild() {
+  cached ??= load().catch((error) => {
+    if (typeof process !== "undefined" && process.env?.SANDBOXEDJS_DEBUG) {
+      console.error("[sandboxedjs] host esbuild unavailable:", error);
+    }
+    return null;
+  });
+  return cached;
+}
+async function load() {
+  if (typeof process === "undefined" || process.versions?.node == null) return null;
+  for (const specifier of ["esbuild-wasm", "esbuild"]) {
+    try {
+      const esbuild = await nodeOnlyModule(specifier);
+      const api = esbuild.default ?? esbuild;
+      if (specifier === "esbuild-wasm") await api.initialize({});
+      return api;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/runtime/local-runtime-pod.ts
+var WASM_ALIASES = {
+  esbuild: "esbuild-wasm",
+  rollup: "@rollup/wasm-node"
+};
+var ProcessExit = class extends Error {
+  constructor(code) {
+    super(`process exited with code ${code}`);
+    this.code = code;
+  }
+  code;
+};
+var LocalProcess = class extends EventEmitter3__default.default {
+  constructor(task) {
+    super();
+    this.task = task;
+    super.on("error", () => {
+    });
+    this.completion = new Promise((resolve2) => {
+      this.resolveCompletion = resolve2;
+    });
+    setTimeout(() => void this.start(), 0);
+  }
+  task;
+  completion;
+  resolveCompletion;
+  settled = false;
+  killed = false;
+  out = [];
+  err = [];
+  resolveKilled;
+  killedPromise = new Promise((resolve2) => {
+    this.resolveKilled = resolve2;
+  });
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  output(text2) {
+    this.out.push(text2);
+    this.emit("output", text2);
+  }
+  error(text2) {
+    this.err.push(text2);
+    this.emit("error", text2);
+  }
+  write(_data) {
+  }
+  kill(_signal = "SIGTERM") {
+    this.killed = true;
+    this.resolveKilled();
+  }
+  waitForKill() {
+    return this.killedPromise;
+  }
+  /** End the process now, for an asynchronous `process.exit`. */
+  exitNow(code) {
+    this.finish(code);
+    this.resolveKilled();
+  }
+  async start() {
+    if (this.killed) {
+      this.finish(137);
+      return;
+    }
+    try {
+      this.finish(await this.task(this));
+    } catch (error) {
+      if (error instanceof ProcessExit) this.finish(error.code);
+      else {
+        this.error(formatError(error));
+        this.finish(1);
+      }
+    }
+  }
+  finish(exitCode) {
+    if (this.settled) return;
+    this.settled = true;
+    const result = { exitCode, stdout: this.out.join(""), stderr: this.err.join("") };
+    this.emit("exit", exitCode);
+    this.resolveCompletion(result);
+  }
+};
+var PodChildProcess = class {
+  constructor(pid, config, launch) {
+    this.pid = pid;
+    this.config = config;
+    this.launch = launch;
+  }
+  pid;
+  config;
+  launch;
+  state = "starting";
+  exitCode;
+  stdout = "";
+  stderr = "";
+  listeners = /* @__PURE__ */ new Map();
+  started = false;
+  cancelled = false;
+  child;
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) this.listeners.set(event, set = /* @__PURE__ */ new Set());
+    set.add(listener);
+    return this;
+  }
+  emit(event, ...args) {
+    for (const listener of this.listeners.get(event) ?? []) listener(...args);
+  }
+  exec() {
+    if (this.started) return;
+    this.started = true;
+    queueMicrotask(() => {
+      if (this.cancelled) {
+        this.finish(143);
+        return;
+      }
+      this.state = "running";
+      void this.launch(this.config).then(
+        (child) => {
+          this.child = child;
+          if (this.cancelled) child.kill();
+          child.on("output", (text2) => {
+            this.stdout += text2;
+            this.emit("stdout", text2);
+          });
+          child.on("error", (text2) => {
+            this.stderr += text2;
+            this.emit("stderr", text2);
+          });
+          void child.completion.then((result) => this.finish(result.exitCode));
+        },
+        (error) => {
+          const text2 = error instanceof Error ? `${error.message}
+` : `${String(error)}
+`;
+          this.stderr += text2;
+          this.emit("stderr", text2);
+          this.finish(127);
+        }
+      );
+    });
+  }
+  sendStdin(data) {
+    this.child?.write(data);
+  }
+  kill(signal = "SIGTERM") {
+    if (this.child) this.child.kill(signal);
+    else this.cancelled = true;
+  }
+  finish(code) {
+    if (this.state === "exited") return;
+    this.state = "exited";
+    this.exitCode = code;
+    this.emit("exit", code);
+  }
+};
+var nextChildPid = 805306368;
+var LocalRuntimePod = class _LocalRuntimePod {
+  volume = new MemoryVolume();
+  packages;
+  instanceId = `sbx-${Math.random().toString(36).slice(2)}`;
+  router = new VirtualHttpRouter();
+  proxy = { activePorts: (_instanceId) => this.router.activePorts() };
+  /**
+   * Mutable on purpose: a container replaces `spawn` so that children resolve
+   * against the kernel's PATH. Left alone, it runs `node` and reports anything
+   * else as not found, which is the correct answer for a bare pod.
+   */
+  processManager = {
+    spawn: (config) => new PodChildProcess(
+      nextChildPid++,
+      config,
+      (child) => this.spawn(child.command, child.args ?? [], {
+        ...child.cwd ? { cwd: child.cwd } : {},
+        ...child.env ? { env: child.env } : {}
+      })
+    )
+  };
+  disposed = false;
+  workdir;
+  env;
+  aliases;
+  modules;
+  constructor(options) {
+    this.workdir = options.workdir ?? "/";
+    this.env = { ...options.env };
+    this.aliases = { ...WASM_ALIASES, ...options.aliases };
+    this.modules = { ...options.modules };
+    this.packages = new CleanPackageInstaller(this.volume, {
+      cwd: this.workdir,
+      ...options.registry ? { registry: options.registry } : {},
+      ...options.fetch ? { fetch: options.fetch } : {}
+    });
+    this.seed(options.files ?? {});
+  }
+  static async boot(options = {}) {
+    const pod = new _LocalRuntimePod(options);
+    if (options.hostEsbuild !== false && !pod.modules.esbuild) {
+      const esbuild = await loadHostEsbuild();
+      if (esbuild) pod.modules.esbuild = esbuild;
+    }
+    return pod;
+  }
+  async spawn(command, args = [], options = {}) {
+    this.assertActive();
+    if (command !== "node" && command !== "nodejs") throw commandError(command);
+    const script = args[0];
+    if (!script) throw new Error("node: a script path is required");
+    const cwd = typeof options.cwd === "string" ? options.cwd : this.workdir;
+    const env2 = { ...this.env, ...isRecord(options.env) ? options.env : {} };
+    const owner = `${this.instanceId}:${Math.random().toString(36).slice(2)}`;
+    return new LocalProcess(async (proc) => {
+      let requestedExit = 0;
+      let evaluating = true;
+      const core = createCoreModules({
+        volume: this.volume,
+        cwd,
+        env: env2,
+        argv: Array.isArray(options.argv) ? options.argv : ["/usr/bin/node", script, ...args.slice(1)],
+        stdout: (text2) => proc.output(text2),
+        stderr: (text2) => proc.error(text2),
+        onExit: (code) => {
+          requestedExit = code;
+          if (evaluating) throw new ProcessExit(code);
+          proc.exitNow(code);
+        },
+        http: { router: this.router, owner },
+        spawnChild: (config) => this.processManager.spawn(config)
+      });
+      const engine = new CommonJsEngine(this.volume, {
+        cwd,
+        builtins: core.builtins,
+        globals: core.globals,
+        aliases: this.aliases,
+        overrides: this.modules
+      });
+      try {
+        try {
+          await engine.run(script);
+        } finally {
+          evaluating = false;
+        }
+        await this.settle(owner, core.pendingHandles);
+        if (this.router.activePorts(owner).length) {
+          await proc.waitForKill();
+          return 137;
+        }
+        return requestedExit;
+      } finally {
+        this.router.closeOwner(owner);
+      }
+    });
+  }
+  /**
+   * Wait until the process has either started serving or genuinely run out of
+   * work.
+   *
+   * Timers are the observable half of the event loop, so a process with none
+   * outstanding and no port open has finished — and, being the common case for
+   * a plain script, is settled without waiting at all.
+   */
+  async settle(owner, pendingHandles) {
+    while (!this.router.activePorts(owner).length && pendingHandles() > 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 5));
+    }
+  }
+  async request(_port, _init = {}) {
+    return this.router.request(_port, _init);
+  }
+  snapshot() {
+    this.assertActive();
+    return this.volume.snapshot();
+  }
+  async restore(snapshot) {
+    this.assertActive();
+    if (!Array.isArray(snapshot)) throw new TypeError("invalid runtime snapshot");
+    this.volume.restore(snapshot);
+  }
+  teardown() {
+    this.disposed = true;
+    this.router.closeAll();
+  }
+  seed(files) {
+    for (const [path, data] of Object.entries(files)) {
+      const parts = path.split("/").filter(Boolean);
+      let parent = "";
+      for (const part of parts.slice(0, -1)) {
+        parent += `/${part}`;
+        try {
+          this.volume.mkdirSync(parent);
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+        }
+      }
+      this.volume.writeFileSync(path, data);
+    }
+  }
+  assertActive() {
+    if (this.disposed) throw new Error("runtime has been disposed");
+  }
+};
+function commandError(command) {
+  return Object.assign(new Error(`${command}: command not found`), { code: "ENOENT" });
+}
+function formatError(error) {
+  if (error instanceof Error) return `${error.stack ?? `${error.name}: ${error.message}`}
+`;
+  return `${String(error)}
+`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/container/container.ts
 var Container = class _Container {
   kernel;
@@ -23932,8 +27285,8 @@ var Container = class _Container {
   // ── boot ──────────────────────────────────────────────────────────────────
   static async create(opts = {}) {
     if (opts.python) configurePython(opts.python);
-    if (!opts.pod && isNodeRuntime()) await installEsbuildRuntime();
-    const pod = opts.pod ?? (isNodeRuntime() ? await bootHeadlessPod(opts) : await bootBrowserPod(opts));
+    if (!opts.pod && opts.runtime !== "sandboxedjs" && isNodeRuntime()) await installEsbuildRuntime();
+    const pod = opts.pod ?? (opts.runtime === "sandboxedjs" ? await LocalRuntimePod.boot({ workdir: opts.cwd ?? "/", env: opts.env ?? {} }) : isNodeRuntime() ? await bootHeadlessPod(opts) : await bootBrowserPod(opts));
     const kernel = new Kernel({
       pod,
       hostname: opts.hostname ?? "sandbox",
@@ -24177,16 +27530,16 @@ var Container = class _Container {
     const combined = [];
     const decoder7 = new TextDecoder();
     const stdout = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
-      combined.push(text);
-      opts.onStdout?.(text);
-      this.hooks.onStdout?.(text);
+      const text2 = decoder7.decode(chunk, { stream: true });
+      combined.push(text2);
+      opts.onStdout?.(text2);
+      this.hooks.onStdout?.(text2);
     });
     const stderr = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
-      combined.push(text);
-      opts.onStderr?.(text);
-      this.hooks.onStderr?.(text);
+      const text2 = decoder7.decode(chunk, { stream: true });
+      combined.push(text2);
+      opts.onStderr?.(text2);
+      this.hooks.onStderr?.(text2);
     });
     if (opts.tty) {
       stdout.isTTY = true;
@@ -24447,8 +27800,8 @@ var Terminal = class {
     return this.closed;
   }
   // ── rendering ─────────────────────────────────────────────────────────────
-  write(text) {
-    this.opts.write(text);
+  write(text2) {
+    this.opts.write(text2);
   }
   promptText() {
     if (this.opts.prompt) return this.opts.prompt(this.session);
@@ -24715,7 +28068,7 @@ var Terminal = class {
     stdin.isTTY = true;
     stdin.interactive = true;
     this.currentStdin = stdin;
-    const sink = new CallbackSink((text) => this.write(text.replace(/(?<!\r)\n/g, "\r\n")), {
+    const sink = new CallbackSink((text2) => this.write(text2.replace(/(?<!\r)\n/g, "\r\n")), {
       isTTY: true,
       columns: this.columns,
       rows: this.rows
@@ -24826,7 +28179,9 @@ var src_default = createContainer;
 
 exports.BufferSink = BufferSink;
 exports.CallbackSink = CallbackSink;
+exports.CleanPackageInstaller = CleanPackageInstaller;
 exports.CommandRegistry = CommandRegistry;
+exports.CommonJsEngine = CommonJsEngine;
 exports.Container = Container;
 exports.ContainerFs = ContainerFs;
 exports.FileInput = FileInput;
@@ -24835,6 +28190,8 @@ exports.IncompleteInputError = IncompleteInputError;
 exports.KERNEL_NAME = KERNEL_NAME;
 exports.KERNEL_RELEASE = KERNEL_RELEASE;
 exports.Kernel = Kernel;
+exports.LocalRuntimePod = LocalRuntimePod;
+exports.MemoryVolume = MemoryVolume;
 exports.NODE_VERSION = NODE_VERSION;
 exports.NPM_VERSION = NPM_VERSION;
 exports.NetworkStack = NetworkStack;
@@ -24856,6 +28213,11 @@ exports.TeeOutput = TeeOutput;
 exports.Terminal = Terminal;
 exports.UserDatabase = UserDatabase;
 exports.Vfs = Vfs;
+exports.VirtualHttpRouter = VirtualHttpRouter;
+exports.VirtualHttpServer = VirtualHttpServer;
+exports.VirtualIncomingMessage = VirtualIncomingMessage;
+exports.VirtualServerResponse = VirtualServerResponse;
+exports.WASM_ALIASES = WASM_ALIASES;
 exports.allCommands = allCommands;
 exports.applyChmod = applyChmod;
 exports.braceExpand = braceExpand;
@@ -24864,8 +28226,10 @@ exports.builtinNames = builtinNames;
 exports.captureStdio = captureStdio;
 exports.configureCPython = configureCPython;
 exports.configurePython = configurePython;
+exports.createChildProcessModule = createChildProcessModule;
 exports.createContainer = createContainer;
 exports.createContext = createContext;
+exports.createCoreModules = createCoreModules;
 exports.default = src_default;
 exports.defineCommand = defineCommand;
 exports.evalArith = evalArith;
@@ -24873,6 +28237,7 @@ exports.exitCodeForSignal = exitCodeForSignal;
 exports.expandPrompt = expandPrompt;
 exports.expandWord = expandWord;
 exports.expandWords = expandWords;
+exports.extractNpmTarball = extractNpmTarball;
 exports.fnmatch = fnmatch;
 exports.formatMode = formatMode;
 exports.getBuiltin = getBuiltin;
@@ -24884,6 +28249,7 @@ exports.isBuiltinName = isBuiltinName;
 exports.isCPythonAvailable = isCPythonAvailable;
 exports.isPythonAvailable = isPythonAvailable;
 exports.isSysError = isSysError;
+exports.looksLikeEsm = looksLikeEsm;
 exports.makeCred = makeCred;
 exports.normalizeSignal = normalizeSignal;
 exports.octalMode = octalMode;
@@ -24893,6 +28259,7 @@ exports.posixPath = path_exports;
 exports.resetPidCounter = resetPidCounter;
 exports.shellQuote = shellQuote;
 exports.strerror = strerror;
+exports.transformEsm = transformEsm;
 exports.unameInfo = unameInfo;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map