sandboxedjs 0.1.81 → 0.1.85

package/dist/worker-entry.js

@@ -3882,7 +3882,7 @@ var require_acorn = __commonJS({
         }
         return i2 + 2;
       };
-      RegExpValidationState3.prototype.current = function current2(forceU) {
+      RegExpValidationState3.prototype.current = function current3(forceU) {
         if (forceU === void 0) forceU = false;
         return this.at(this.pos, forceU);
       };
@@ -3907,8 +3907,8 @@ var require_acorn = __commonJS({
         var pos = this.pos;
         for (var i2 = 0, list2 = chs; i2 < list2.length; i2 += 1) {
           var ch = list2[i2];
-          var current2 = this.at(pos, forceU);
-          if (current2 === -1 || current2 !== ch) {
+          var current3 = this.at(pos, forceU);
+          if (current3 === -1 || current3 !== ch) {
             return false;
           }
           pos = this.nextIndex(pos, forceU);
@@ -8795,7 +8795,7 @@ var require_path_browserify = __commonJS({
         if (hasRoot && end === 1) return "//";
         return path.slice(0, end);
       },
-      basename: function basename(path, ext) {
+      basename: function basename2(path, ext) {
         if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
         assertPath(path);
         var start = 0;
@@ -8849,7 +8849,7 @@ var require_path_browserify = __commonJS({
           return path.slice(start, end);
         }
       },
-      extname: function extname(path) {
+      extname: function extname2(path) {
         assertPath(path);
         var startDot = -1;
         var startPart = 0;
@@ -9583,11 +9583,11 @@ var require_stream_writable = __commonJS({
       this.corkedRequestsFree = new CorkedRequest(this);
     }
     WritableState.prototype.getBuffer = function getBuffer() {
-      var current2 = this.bufferedRequest;
+      var current3 = this.bufferedRequest;
       var out = [];
-      while (current2) {
-        out.push(current2);
-        current2 = current2.next;
+      while (current3) {
+        out.push(current3);
+        current3 = current3.next;
       }
       return out;
     };
@@ -11188,12 +11188,12 @@ var require_stream_readable = __commonJS({
       if (!state.flowing) {
         debug("resume");
         state.flowing = !state.readableListening;
-        resume(this, state);
+        resume2(this, state);
       }
       state.paused = false;
       return this;
     };
-    function resume(stream, state) {
+    function resume2(stream, state) {
       if (!state.resumeScheduled) {
         state.resumeScheduled = true;
         process.nextTick(resume_, stream, state);
@@ -15513,6 +15513,18 @@ function dirname(p) {
   if (idx === 0) return "/";
   return norm.slice(0, idx);
 }
+function basename(p, ext) {
+  const norm = stripTrailing(normalize(p));
+  if (norm === "/") return "/";
+  const idx = norm.lastIndexOf("/");
+  let base2 = idx < 0 ? norm : norm.slice(idx + 1);
+  return base2;
+}
+function extname(p) {
+  const base2 = basename(p);
+  const idx = base2.lastIndexOf(".");
+  return idx <= 0 ? "" : base2.slice(idx);
+}
 function clean(p) {
   return stripTrailing(normalize(p));
 }
@@ -19157,8 +19169,8 @@ RegExpValidationState.prototype.eatChars = function eatChars(chs, forceU) {
   var pos = this.pos;
   for (var i = 0, list = chs; i < list.length; i += 1) {
     var ch = list[i];
-    var current2 = this.at(pos, forceU);
-    if (current2 === -1 || current2 !== ch) {
+    var current3 = this.at(pos, forceU);
+    if (current3 === -1 || current3 !== ch) {
       return false;
     }
     pos = this.nextIndex(pos, forceU);
@@ -21472,9 +21484,9 @@ ${applyEdits(source, edits)}` : applyEdits(source, edits),
       }
     }
     function lookup(name, scope) {
-      for (let current2 = scope; current2; current2 = current2.parent) {
-        if (current2.names.has(name)) {
-          return current2.parent === null ? importBindings.get(name) ?? null : null;
+      for (let current3 = scope; current3; current3 = current3.parent) {
+        if (current3.names.has(name)) {
+          return current3.parent === null ? importBindings.get(name) ?? null : null;
         }
       }
       return null;
@@ -21507,7 +21519,7 @@ function containsImportExpression(node) {
 function containsImportMeta(node) {
   if (Array.isArray(node)) return node.some(containsImportMeta);
   if (!isNode(node)) return false;
-  if (node.type === "MetaProperty") return true;
+  if (node.type === "MetaProperty" && node.meta?.name === "import") return true;
   for (const [key, value] of Object.entries(node)) {
     if (key === "type" || key === "start" || key === "end") continue;
     if (containsImportMeta(value)) return true;
@@ -21618,6 +21630,261 @@ var NOTHING = [];
 var PROPERTY = ["property", "key"];
 var LABEL = ["label"];
 
+// src/node/async-context-transform.ts
+var import_acorn_jsx2 = __toESM(require_acorn_jsx());
+
+// src/node/async-context.ts
+var EMPTY = /* @__PURE__ */ new Map();
+var current2 = EMPTY;
+function capture() {
+  return current2;
+}
+function restore(frame) {
+  current2 = frame ?? EMPTY;
+}
+function resume(frame, value) {
+  current2 = frame;
+  return value;
+}
+function runInFrame(frame, fn) {
+  const previous = current2;
+  current2 = frame;
+  try {
+    return fn();
+  } finally {
+    current2 = previous;
+  }
+}
+function bindToCurrent(fn) {
+  const frame = current2;
+  if (frame === EMPTY) {
+    return function(...args) {
+      return runInFrame(EMPTY, () => fn.apply(this, args));
+    };
+  }
+  return function(...args) {
+    return runInFrame(frame, () => fn.apply(this, args));
+  };
+}
+function installPromiseContext(PromiseClass = Promise) {
+  const proto = PromiseClass.prototype;
+  if (proto.__sbxContextThen) return;
+  const nativeThen = proto.then;
+  Object.defineProperty(proto, "then", {
+    configurable: true,
+    writable: true,
+    value: function then(onFulfilled, onRejected) {
+      const frame = current2;
+      const wrap2 = (handler) => typeof handler === "function" ? (value) => runInFrame(frame, () => handler(value)) : handler;
+      return nativeThen.call(this, wrap2(onFulfilled), wrap2(onRejected));
+    }
+  });
+  Object.defineProperty(proto, "__sbxContextThen", { value: true });
+}
+var AsyncLocalStorage = class {
+  #enabled = true;
+  getStore() {
+    return current2.get(this);
+  }
+  run(store, callback, ...args) {
+    const next = new Map(current2);
+    next.set(this, store);
+    this.#enabled = true;
+    return runInFrame(next, () => callback(...args));
+  }
+  exit(callback, ...args) {
+    if (!current2.has(this)) return callback(...args);
+    const next = new Map(current2);
+    next.delete(this);
+    return runInFrame(next, () => callback(...args));
+  }
+  /** Replace the store for the rest of the current execution and its continuations. */
+  enterWith(store) {
+    const next = new Map(current2);
+    next.set(this, store);
+    current2 = next;
+    this.#enabled = true;
+  }
+  disable() {
+    if (!this.#enabled) return;
+    this.#enabled = false;
+    if (current2.has(this)) {
+      const next = new Map(current2);
+      next.delete(this);
+      current2 = next;
+    }
+  }
+  static bind(fn) {
+    return bindToCurrent(fn);
+  }
+  static snapshot() {
+    const frame = current2;
+    return (fn, ...args) => runInFrame(frame, () => fn(...args));
+  }
+};
+var AsyncResource = class _AsyncResource {
+  #frame;
+  type;
+  constructor(type, _options) {
+    this.type = type;
+    this.#frame = current2;
+  }
+  runInAsyncScope(fn, thisArg, ...args) {
+    return runInFrame(this.#frame, () => fn.apply(thisArg, args));
+  }
+  bind(fn, thisArg) {
+    return ((...args) => this.runInAsyncScope(fn, thisArg, ...args));
+  }
+  emitDestroy() {
+    return this;
+  }
+  asyncId() {
+    return 1;
+  }
+  triggerAsyncId() {
+    return 0;
+  }
+  static bind(fn, type = "bound-anonymous-fn", thisArg) {
+    return new _AsyncResource(type).bind(fn, thisArg);
+  }
+};
+var CONTEXT_HELPERS = {
+  capture: "__sbxCapture",
+  resume: "__sbxResume",
+  restore: "__sbxRestore"
+};
+
+// src/node/async-context-transform.ts
+var JSX_EXTENSION2 = /\.[jt]sx$/;
+var JsxParser2 = Parser.extend((0, import_acorn_jsx2.default)());
+var MAYBE_AWAIT = /\bawait\b/;
+var OPTIONS_MODULE = {
+  ecmaVersion: "latest",
+  sourceType: "module",
+  allowAwaitOutsideFunction: true,
+  allowHashBang: true,
+  allowReturnOutsideFunction: true,
+  allowImportExportEverywhere: true
+};
+var OPTIONS_SCRIPT = { ...OPTIONS_MODULE, sourceType: "script" };
+var { capture: CAPTURE, resume: RESUME, restore: RESTORE } = CONTEXT_HELPERS;
+function transformAsyncContext(source, filename = "module.js") {
+  if (!MAYBE_AWAIT.test(source)) return null;
+  const ast = parseEither(source, filename);
+  if (!ast) return null;
+  const edits = collectEdits(ast, source, filename);
+  if (edits.length === 0) return null;
+  return applyEdits2(source, edits);
+}
+function parseEither(source, filename) {
+  const parser = JSX_EXTENSION2.test(filename) ? JsxParser2.parse.bind(JsxParser2) : parse3;
+  for (const options of [OPTIONS_SCRIPT, OPTIONS_MODULE]) {
+    try {
+      return parser(source, options);
+    } catch {
+    }
+  }
+  return null;
+}
+var frameCounter = 0;
+function collectEdits(root, source, filename) {
+  const edits = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node) visit(item);
+      return;
+    }
+    if (!isNode2(node)) return;
+    switch (node.type) {
+      case "AwaitExpression": {
+        edits.push({ start: node.start, end: node.start, text: `${RESUME}(${CAPTURE}(), ` });
+        edits.push({ start: node.end, end: node.end, text: ")" });
+        visit(node.argument);
+        return;
+      }
+      case "TryStatement": {
+        if (containsAwait(node.block) || containsAwait(node.handler) || containsAwait(node.finalizer)) {
+          const frame = `__sbxFrame${frameCounter++}`;
+          edits.push({ start: node.start, end: node.start, text: `{ const ${frame} = ${CAPTURE}(); ` });
+          const handler = node.handler;
+          if (handler) {
+            const body = handler.body;
+            edits.push({ start: body.start + 1, end: body.start + 1, text: ` ${RESTORE}(${frame});` });
+          }
+          const finalizer = node.finalizer;
+          if (finalizer) {
+            edits.push({ start: finalizer.start + 1, end: finalizer.start + 1, text: ` ${RESTORE}(${frame});` });
+          }
+          edits.push({ start: node.end, end: node.end, text: " }" });
+        }
+        visit(node.block);
+        visit(node.handler);
+        visit(node.finalizer);
+        return;
+      }
+      case "ForOfStatement": {
+        if (node.await === true) {
+          const frame = `__sbxFrame${frameCounter++}`;
+          const body = node.body;
+          edits.push({ start: node.start, end: node.start, text: `{ const ${frame} = ${CAPTURE}(); ` });
+          if (body.type === "BlockStatement") {
+            edits.push({ start: body.start + 1, end: body.start + 1, text: ` ${RESTORE}(${frame});` });
+          } else {
+            edits.push({ start: body.start, end: body.start, text: `{ ${RESTORE}(${frame}); ` });
+            edits.push({ start: body.end, end: body.end, text: " }" });
+          }
+          edits.push({ start: node.end, end: node.end, text: " }" });
+        }
+        visit(node.left);
+        visit(node.right);
+        visit(node.body);
+        return;
+      }
+      case "CallExpression": {
+        const callee = node.callee;
+        const args = node.arguments;
+        const first = args[0];
+        if (callee.type === "Identifier" && callee.name === "eval" && first && first.type === "Literal" && typeof first.value === "string" && MAYBE_AWAIT.test(first.value)) {
+          const inner = transformAsyncContext(first.value, filename);
+          if (inner !== null) edits.push({ start: first.start, end: first.end, text: JSON.stringify(inner) });
+          for (const argument of args.slice(1)) visit(argument);
+          return;
+        }
+        break;
+      }
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      if (value && typeof value === "object") visit(value);
+    }
+  };
+  visit(root);
+  return edits;
+}
+function containsAwait(node) {
+  if (Array.isArray(node)) return node.some(containsAwait);
+  if (!isNode2(node)) return false;
+  if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+    return false;
+  }
+  if (node.type === "AwaitExpression") return true;
+  if (node.type === "ForOfStatement" && node.await === true) return true;
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (value && typeof value === "object" && containsAwait(value)) return true;
+  }
+  return false;
+}
+function applyEdits2(source, edits) {
+  const ordered = edits.map((edit, index) => ({ ...edit, index })).sort((a, b) => b.start - a.start || b.end - a.end || b.index - a.index);
+  let out = source;
+  for (const edit of ordered) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  return out;
+}
+function isNode2(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+
 // node_modules/resolve.exports/dist/index.mjs
 function e(e2, n2, r2) {
   throw new Error(r2 ? `No known conditions for "${n2}" specifier in "${e2}" package` : `Missing "${n2}" specifier in "${e2}" package`);
@@ -21686,6 +21953,62 @@ var CommonJsEngine = class {
     this.globals = { ...options.globals };
     this.aliases = { ...options.aliases };
     this.overrides = { ...options.overrides };
+    const engine = this;
+    this.moduleApi = function Module(id = "", parent = null) {
+      Object.assign(this, { id, filename: id, exports: {}, loaded: false, parent, children: [] });
+    };
+    Object.assign(this.moduleApi, this.builtins.module);
+    this.moduleApi.Module = this.moduleApi;
+    this.moduleApi._extensions = {
+      ".js": (module, filename) => this.evaluate(module, this.readText(filename)),
+      ".json": (module, filename) => {
+        module.exports = JSON.parse(this.readText(filename));
+      },
+      ".node": (_module, filename) => {
+        throw dlopenFailed(filename);
+      }
+    };
+    this.moduleApi._cache = new Proxy(/* @__PURE__ */ Object.create(null), {
+      get: (_target, key) => typeof key === "string" ? this.cache.get(key) : void 0,
+      set: (_target, key, value) => {
+        this.cache.set(String(key), value);
+        return true;
+      },
+      deleteProperty: (_target, key) => this.cache.delete(String(key)),
+      ownKeys: () => [...this.cache.keys()],
+      getOwnPropertyDescriptor: (_target, key) => this.cache.has(String(key)) ? { enumerable: true, configurable: true, writable: true, value: this.cache.get(String(key)) } : void 0
+    });
+    this.moduleApi._resolveFilename = (request, parent) => this.resolve(request, parent?.filename || join(this.cwd, "__entry__.js"));
+    this.moduleApi._nodeModulePaths = (from) => {
+      const directory = resolve(this.cwd, String(from));
+      if (directory === "/") return ["/node_modules"];
+      const parts = segments(directory);
+      const paths = [];
+      for (let index = parts.length; index > 0; index--) {
+        if (parts[index - 1] === "node_modules") continue;
+        paths.push(`/${[...parts.slice(0, index), "node_modules"].join("/")}`);
+      }
+      paths.push("/node_modules");
+      return paths;
+    };
+    this.moduleApi._load = (request, parent) => this.makeRequire(parent ?? Object.assign(new this.moduleApi(join(this.cwd, "__entry__.js")), { filename: join(this.cwd, "__entry__.js") }))(request);
+    this.moduleApi.prototype.require = function(request) {
+      const filename = engine.moduleApi._resolveFilename(request, this);
+      const builtin = engine.builtin(filename, this);
+      if (builtin.found) return builtin.value;
+      const target = engine.load(filename, this, false);
+      if (target.pending) throw requireOfAsyncModule(request);
+      return target.exports;
+    };
+    this.moduleApi.prototype._compile = function(source, filename) {
+      this.filename = filename;
+      engine.evaluate(this, source);
+    };
+    this.moduleApi.createRequire = (filename) => {
+      const path = String(filename).startsWith("file:") ? pathFromFileUrl(String(filename)) : String(filename);
+      if (!path.startsWith("/")) throw new TypeError("createRequire requires an absolute path or file URL");
+      return this.makeRequire(Object.assign(new this.moduleApi(path), { filename: path }));
+    };
   }
   volume;
   cache = /* @__PURE__ */ new Map();
@@ -21698,6 +22021,7 @@ var CommonJsEngine = class {
   /** `package.json` per directory; resolution reads them constantly. */
   manifests = /* @__PURE__ */ new Map();
   evaluationDepth = 0;
+  moduleApi;
   /**
    * Is a module body running synchronously right now?
    *
@@ -21734,7 +22058,7 @@ var CommonJsEngine = class {
       specifier = pathFromFileUrl(specifier);
     }
     const builtin = this.builtin(specifier);
-    if (builtin.found) return specifier.replace(/^node:/, "");
+    if (builtin.found) return specifier;
     if (specifier.startsWith("#")) {
       const found = this.resolveImports(specifier, importer, kind);
       if (found) return found;
@@ -21767,17 +22091,14 @@ var CommonJsEngine = class {
       parent,
       children: []
     };
+    Object.setPrototypeOf(module, this.moduleApi.prototype);
     this.cache.set(filename, module);
     parent?.children.push(module);
     if (isMain) this.main = module;
     try {
-      if (filename.endsWith(".node")) {
-        throw dlopenFailed(filename);
-      } else if (filename.endsWith(".json")) {
-        module.exports = JSON.parse(this.readText(filename));
-      } else {
-        this.evaluate(module, this.readText(filename));
-      }
+      const extension = extname(filename);
+      const loader = this.moduleApi._extensions[extension] ?? this.moduleApi._extensions[".js"];
+      loader(module, filename);
       module.loaded = true;
       return module;
     } catch (error) {
@@ -21789,7 +22110,8 @@ var CommonJsEngine = class {
   evaluate(module, source) {
     if (source.startsWith("#!")) source = source.replace(/^#![^\n]*(?:\n|$)/, "");
     const transformed = transformEsm(source, module.filename);
-    const body = transformed?.code ?? source;
+    const esmBody = transformed?.code ?? source;
+    const body = transformAsyncContext(esmBody, module.filename) ?? esmBody;
     const code = transformed?.topLevelAwait ? `return (async () => {
 ${body}
 })();` : body;
@@ -21797,7 +22119,10 @@ ${body}
       [HELPERS.import, (specifier) => this.importNamespace(specifier, module)],
       [HELPERS.dynamic, (specifier) => this.dynamicImport(specifier, module)],
       [HELPERS.exportAll, exportAll],
-      [HELPERS.meta, this.importMeta(module)]
+      [HELPERS.meta, this.importMeta(module)],
+      [CONTEXT_HELPERS.capture, capture],
+      [CONTEXT_HELPERS.resume, resume],
+      [CONTEXT_HELPERS.restore, restore]
     ];
     const bindings = transformed?.esm ? [[HELPERS.exports, module.exports], ...helpers] : [
       ["exports", module.exports],
@@ -21830,15 +22155,12 @@ ${code}
   /** The `require` a module sees, complete with `resolve`, `cache` and `main`. */
   makeRequire(module) {
     const localRequire = ((specifier) => {
-      const builtin = this.builtin(specifier, module);
-      if (builtin.found) return builtin.value;
-      const target = this.load(this.resolve(specifier, module.filename, "require"), module, false);
-      if (target.pending) throw requireOfAsyncModule(specifier);
-      return target.exports;
+      return this.moduleApi.prototype.require.call(module, specifier);
     });
-    localRequire.resolve = (specifier) => this.resolve(specifier, module.filename, "require");
+    localRequire.resolve = (specifier) => this.moduleApi._resolveFilename(specifier, module);
     Object.defineProperty(localRequire, "main", { get: () => this.main });
-    localRequire.cache = Object.fromEntries(this.cache);
+    localRequire.cache = this.moduleApi._cache;
+    localRequire.extensions = this.moduleApi._extensions;
     return localRequire;
   }
   /**
@@ -22013,12 +22335,7 @@ ${code}
     if (prefixOnly || !Object.prototype.hasOwnProperty.call(this.builtins, name)) {
       return Object.prototype.hasOwnProperty.call(this.overrides, specifier) ? { found: true, value: this.overrides[specifier] } : { found: false, value: void 0 };
     }
-    if (name === "module" && importer) {
-      return {
-        found: true,
-        value: { ...this.builtins.module, createRequire: () => this.makeRequire(importer) }
-      };
-    }
+    if (name === "module") return { found: true, value: this.moduleApi };
     return { found: true, value: this.builtins[name] };
   }
   exists(path) {
@@ -22126,10 +22443,229 @@ function splitSpecifier(specifier) {
   return { name: parts.slice(0, size).join("/"), subpath: parts.slice(size).join("/") };
 }
 
+// src/node/diagnostics-channel.ts
+function createDiagnosticsChannel() {
+  const channels = /* @__PURE__ */ new Map();
+  class Channel {
+    constructor(name) {
+      this.name = name;
+    }
+    name;
+    listeners = /* @__PURE__ */ new Set();
+    get hasSubscribers() {
+      return this.listeners.size > 0;
+    }
+    subscribe(fn) {
+      if (typeof fn !== "function") throw new TypeError("subscriber must be a function");
+      this.listeners.add(fn);
+    }
+    unsubscribe(fn) {
+      return this.listeners.delete(fn);
+    }
+    publish(message) {
+      for (const fn of [...this.listeners]) {
+        try {
+          fn(message, this.name);
+        } catch (error) {
+          queueMicrotask(() => {
+            throw error;
+          });
+        }
+      }
+    }
+  }
+  const channel = (name) => {
+    if (typeof name !== "string" && typeof name !== "symbol") throw new TypeError("channel name must be a string or symbol");
+    let result = channels.get(name);
+    if (!result) {
+      result = new Channel(name);
+      channels.set(name, result);
+    }
+    return result;
+  };
+  return {
+    Channel,
+    channel,
+    hasSubscribers: (name) => channels.get(name)?.hasSubscribers ?? false,
+    subscribe: (name, fn) => channel(name).subscribe(fn),
+    unsubscribe: (name, fn) => channels.get(name)?.unsubscribe(fn) ?? false
+  };
+}
+
+// src/node/ipc-channel.ts
+var IPC_CHANNEL_ENV = "SANDBOXEDJS_IPC_CHANNEL";
+function newIpcChannelId() {
+  const random = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : Math.random().toString(36).slice(2);
+  return `ipc-${random}`;
+}
+
+// src/node/vm-module.ts
+var contexts = /* @__PURE__ */ new WeakSet();
+var globalEval = eval;
+var filenameOf = (options) => typeof options === "string" ? options : options?.filename;
+var withSourceUrl = (code, options) => {
+  const filename = filenameOf(options);
+  return filename ? `${code}
+//# sourceURL=${filename.replace(/\s/g, "%20")}` : code;
+};
+function runWithScope(code, sandbox, options) {
+  const scope = new Proxy(sandbox, {
+    /* The wrapper's own variables must resolve to the wrapper, never to the
+     * context — otherwise `__sbx_vm_result__ = eval(…)` stores the completion
+     * value on the sandbox and the function returns undefined. */
+    has: (target, key) => !(typeof key === "string" && key.startsWith("__sbx_vm_")) && (key in target || !(key in globalThis)),
+    get: (target, key) => {
+      if (key === Symbol.unscopables) return void 0;
+      if (key in target) return target[key];
+      return globalThis[key];
+    },
+    set: (target, key, value) => {
+      target[key] = value;
+      return true;
+    }
+  });
+  const declared = topLevelDeclarations(code);
+  const evaluate = new Function(
+    "__sbx_vm_scope__",
+    "__sbx_vm_source__",
+    "__sbx_vm_names__",
+    "__sbx_vm_target__",
+    "var __sbx_vm_result__; with (__sbx_vm_scope__) { __sbx_vm_result__ = eval(__sbx_vm_source__); }for (var __sbx_vm_i__ = 0; __sbx_vm_i__ < __sbx_vm_names__.length; __sbx_vm_i__++) {  try { var __sbx_vm_value__ = eval(__sbx_vm_names__[__sbx_vm_i__]); if (__sbx_vm_value__ !== undefined || !(__sbx_vm_names__[__sbx_vm_i__] in __sbx_vm_target__)) __sbx_vm_target__[__sbx_vm_names__[__sbx_vm_i__]] = __sbx_vm_value__; } catch (e) {}}return __sbx_vm_result__;"
+  );
+  return evaluate(scope, withSourceUrl(code, options), declared, sandbox);
+}
+function topLevelDeclarations(code) {
+  const names = /* @__PURE__ */ new Set();
+  let depth = 0;
+  for (let index = 0; index < code.length; index++) {
+    const char = code[index];
+    if (char === "/" && code[index + 1] === "/") {
+      const end = code.indexOf("\n", index);
+      index = end === -1 ? code.length : end;
+      continue;
+    }
+    if (char === "/" && code[index + 1] === "*") {
+      const end = code.indexOf("*/", index + 2);
+      index = end === -1 ? code.length : end + 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      for (index++; index < code.length && code[index] !== char; index++) if (code[index] === "\\") index++;
+      continue;
+    }
+    if (char === "{") {
+      depth++;
+      continue;
+    }
+    if (char === "}") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth !== 0 || !/[A-Za-z_$]/.test(char) || index > 0 && /[\w$]/.test(code[index - 1])) continue;
+    const rest = code.slice(index);
+    const fn = /^(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)/.exec(rest);
+    if (fn) {
+      names.add(fn[1]);
+      continue;
+    }
+    const declaration = /^var\s+([^;]+)/.exec(rest);
+    if (declaration) {
+      for (const part of declaration[1].split(",")) {
+        const name = /^\s*([A-Za-z_$][\w$]*)/.exec(part);
+        if (name) names.add(name[1]);
+      }
+    }
+  }
+  return [...names];
+}
+function createContext(sandbox = {}) {
+  contexts.add(sandbox);
+  if (!("globalThis" in sandbox)) Object.defineProperty(sandbox, "globalThis", { value: sandbox, writable: true, configurable: true });
+  return sandbox;
+}
+function isContext(value) {
+  return typeof value === "object" && value !== null && contexts.has(value);
+}
+function runInThisContext(code, options) {
+  return globalEval(withSourceUrl(String(code), options));
+}
+function runInContext(code, context, options) {
+  if (!isContext(context)) {
+    throw Object.assign(new TypeError('The "contextifiedObject" argument must be an vm.Context'), { code: "ERR_INVALID_ARG_TYPE" });
+  }
+  return runWithScope(String(code), context, options);
+}
+function runInNewContext(code, sandbox, options) {
+  return runWithScope(String(code), createContext(sandbox ?? {}), options);
+}
+var Script = class {
+  #code;
+  #options;
+  constructor(code, options = {}) {
+    this.#code = String(code);
+    this.#options = typeof options === "string" ? { filename: options } : { ...options };
+    new Function(this.#code.replace(/^#!.*/, ""));
+  }
+  runInThisContext(options) {
+    return runInThisContext(this.#code, { ...this.#options, ...options });
+  }
+  runInContext(context, options) {
+    return runInContext(this.#code, context, { ...this.#options, ...options });
+  }
+  runInNewContext(sandbox, options) {
+    return runInNewContext(this.#code, sandbox, { ...this.#options, ...options });
+  }
+  createCachedData() {
+    return new Uint8Array();
+  }
+};
+function compileFunction(code, params = [], options = {}) {
+  const source = withSourceUrl(String(code), options.filename);
+  if (options.parsingContext && isContext(options.parsingContext)) {
+    return runWithScope(`(function (${params.join(", ")}) {
+${source}
+})`, options.parsingContext, void 0);
+  }
+  return new Function(...params, source);
+}
+var vmModule = {
+  Script,
+  createContext,
+  isContext,
+  runInThisContext,
+  runInContext,
+  runInNewContext,
+  compileFunction,
+  constants: {
+    USE_MAIN_CONTEXT_DEFAULT_LOADER: /* @__PURE__ */ Symbol("vm_dynamic_import_main_context_default"),
+    DONT_CONTEXTIFY: /* @__PURE__ */ Symbol("vm_context_no_contextify")
+  },
+  measureMemory: async () => ({ total: { jsMemoryEstimate: 0, jsMemoryRange: [0, 0] } })
+};
+var vm_module_default = vmModule;
+
 // src/node/buffer-module.ts
 var import_buffer = __toESM(require_buffer());
 var platformBuffer = globalThis.Buffer;
-var Buffer2 = platformBuffer ?? addBase64UrlSupport(import_buffer.Buffer);
+addUint8ArraySupport(addBase64UrlSupport(import_buffer.Buffer));
+var Buffer2 = platformBuffer ?? import_buffer.Buffer;
+function addUint8ArraySupport(BufferClass) {
+  const target = BufferClass;
+  if (target.__sandboxedUint8Array) return BufferClass;
+  Object.defineProperty(target, "__sandboxedUint8Array", { value: true });
+  const asBuffer = (value) => value instanceof Uint8Array && !target.isBuffer(value) ? target.from(value.buffer, value.byteOffset, value.byteLength) : value;
+  for (const method of ["indexOf", "lastIndexOf", "includes"]) {
+    const original = target.prototype[method];
+    target.prototype[method] = function(value, ...rest) {
+      return original.call(this, asBuffer(value), ...rest);
+    };
+  }
+  const equals = target.prototype.equals;
+  target.prototype.equals = function(other) {
+    return equals.call(this, asBuffer(other));
+  };
+  return BufferClass;
+}
 function addBase64UrlSupport(BufferClass) {
   const target = BufferClass;
   if (target.__sandboxedBase64Url) return BufferClass;
@@ -22160,90 +22696,330 @@ function normalizeEncoding(value) {
 // src/node/core-modules.ts
 var import_events4 = __toESM(require_events());
 var import_path_browserify = __toESM(require_path_browserify());
-var import_stream_browserify4 = __toESM(require_stream_browserify());
+var import_stream_browserify5 = __toESM(require_stream_browserify());
 
-// src/node/readable-from.ts
-function createReadableFrom(Readable) {
-  return function from(source, options = {}) {
-    if (source && typeof source.pipe === "function") return source;
-    const iterator = source && typeof source[Symbol.asyncIterator] === "function" ? source[Symbol.asyncIterator]() : source && typeof source[Symbol.iterator] === "function" ? source[Symbol.iterator]() : (function* () {
-      yield source;
-    })();
+// src/node/stream-compat.ts
+var import_stream_browserify = __toESM(require_stream_browserify());
+function define2(proto, name, get) {
+  if (Object.getOwnPropertyDescriptor(proto, name)) return;
+  Object.defineProperty(proto, name, { configurable: true, enumerable: false, get });
+}
+var installed = false;
+function installWebStreamAdapters(stream) {
+  const { Readable, Writable, Duplex } = stream;
+  const toError = (reason) => reason instanceof Error ? reason : new Error(reason === void 0 ? "aborted" : String(reason));
+  const readableToWeb = (source, options = {}) => {
+    let onData;
+    return new ReadableStream({
+      start(controller) {
+        const objectMode = Boolean(source?._readableState?.objectMode);
+        onData = (chunk) => {
+          const value = objectMode || !(chunk instanceof Uint8Array) && typeof chunk !== "string" ? chunk : typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+          controller.enqueue(value);
+          if ((controller.desiredSize ?? 1) <= 0) source.pause();
+        };
+        source.on("data", onData);
+        source.once("end", () => {
+          try {
+            controller.close();
+          } catch {
+          }
+        });
+        source.once("error", (error) => {
+          try {
+            controller.error(error);
+          } catch {
+          }
+        });
+        source.once("close", () => {
+          if (!source.readableEnded && !source._readableState?.endEmitted) {
+            try {
+              controller.error(new Error("The stream was destroyed before it ended"));
+            } catch {
+            }
+          }
+        });
+      },
+      pull() {
+        if (typeof source.isPaused === "function" && source.isPaused()) source.resume();
+      },
+      cancel(reason) {
+        if (onData) source.off("data", onData);
+        source.destroy(reason === void 0 ? void 0 : toError(reason));
+      }
+    }, options.strategy ?? { highWaterMark: 1 });
+  };
+  const readableFromWeb = (web, options = {}) => {
+    const reader = web.getReader();
     let reading = false;
-    const stream = new Readable({
+    const readable = new Readable({
       ...options,
-      objectMode: options.objectMode ?? false,
       read() {
         if (reading) return;
         reading = true;
         void (async () => {
           try {
             for (; ; ) {
-              const next = await iterator.next();
-              if (next.done) {
-                stream.push(null);
+              const { done, value } = await reader.read();
+              if (done) {
+                readable.push(null);
                 return;
               }
-              const value = next.value;
-              if (!stream.push(value === void 0 ? null : value)) return;
+              const chunk = value instanceof Uint8Array && !options.objectMode ? Buffer2.from(value.buffer, value.byteOffset, value.byteLength) : value;
+              if (!readable.push(chunk)) return;
             }
           } catch (error) {
-            stream.destroy(error);
+            readable.destroy(toError(error));
           } finally {
             reading = false;
           }
         })();
       },
       destroy(error, callback) {
-        void (async () => {
-          try {
-            await iterator.return?.();
-          } catch {
-          }
-          callback(error);
-        })();
+        reader.cancel(error ?? void 0).catch(() => {
+        }).finally(() => callback(error));
       }
     });
-    return stream;
+    return readable;
   };
-}
-function installReadableFrom(streamModule5) {
-  streamModule5.Readable.from = createReadableFrom(streamModule5.Readable);
-}
-
-// src/node/env.ts
-function parseEnv(text) {
-  if (typeof text !== "string") {
-    throw Object.assign(new TypeError('The "content" argument must be of type string'), { code: "ERR_INVALID_ARG_TYPE" });
-  }
-  const out = {};
-  const lines = text.split(/\r?\n/);
-  for (let index = 0; index < lines.length; index++) {
-    const raw = lines[index];
-    const match2 = /^[ \t]*(?:export[ \t]+)?([^=#]+?)[ \t]*=[ \t]*(.*)$/.exec(raw);
-    if (!match2) continue;
-    const name = match2[1];
-    let value = match2[2];
-    const quote2 = value[0];
-    if (quote2 === '"' || quote2 === "'" || quote2 === "`") {
-      const start = index;
-      const original = value;
-      value = value.slice(1);
-      while (true) {
-        const end = value.indexOf(quote2);
-        if (end >= 0) {
-          value = value.slice(0, end);
-          break;
-        }
-        if (++index >= lines.length) {
-          index = start;
-          value = original;
-          break;
+  const writableToWeb = (sink) => new WritableStream({
+    write(chunk) {
+      return new Promise((resolve2, reject) => {
+        const ok2 = sink.write(chunk, (error) => {
+          if (error) reject(error);
+        });
+        if (ok2) resolve2();
+        else {
+          const onDrain = () => {
+            sink.off("error", onError);
+            resolve2();
+          };
+          const onError = (error) => {
+            sink.off("drain", onDrain);
+            reject(error);
+          };
+          sink.once("drain", onDrain);
+          sink.once("error", onError);
         }
-        value += `
-${lines[index]}`;
-      }
-      if (quote2 === '"') value = value.replace(/\\n/g, "\n");
+      });
+    },
+    close() {
+      return new Promise((resolve2, reject) => {
+        sink.once("error", reject);
+        sink.end(() => resolve2());
+      });
+    },
+    abort(reason) {
+      sink.destroy(toError(reason));
+    }
+  });
+  const writableFromWeb = (web, options = {}) => {
+    const writer = web.getWriter();
+    return new Writable({
+      ...options,
+      write(chunk, _encoding, callback) {
+        writer.write(chunk).then(() => callback(), (error) => callback(toError(error)));
+      },
+      final(callback) {
+        writer.close().then(() => callback(), (error) => callback(toError(error)));
+      },
+      destroy(error, callback) {
+        (error ? writer.abort(error) : writer.close()).catch(() => {
+        }).finally(() => callback(error));
+      }
+    });
+  };
+  const define3 = (target, name, value) => {
+    if (typeof target[name] === "function") return;
+    Object.defineProperty(target, name, { configurable: true, writable: true, value });
+  };
+  define3(Readable, "toWeb", readableToWeb);
+  define3(Readable, "fromWeb", readableFromWeb);
+  define3(Writable, "toWeb", writableToWeb);
+  define3(Writable, "fromWeb", writableFromWeb);
+  define3(Duplex, "toWeb", (duplex) => ({ readable: readableToWeb(duplex), writable: writableToWeb(duplex) }));
+  define3(Duplex, "fromWeb", (pair, options = {}) => {
+    const readable = readableFromWeb(pair.readable, options);
+    const writable = writableFromWeb(pair.writable, options);
+    const duplex = new Duplex({
+      ...options,
+      read() {
+        readable.resume();
+      },
+      write(chunk, encoding, callback) {
+        writable.write(chunk, encoding, callback);
+      },
+      final(callback) {
+        writable.end(callback);
+      }
+    });
+    readable.on("data", (chunk) => {
+      if (!duplex.push(chunk)) readable.pause();
+    });
+    readable.once("end", () => duplex.push(null));
+    readable.once("error", (error) => duplex.destroy(error));
+    writable.once("error", (error) => duplex.destroy(error));
+    return duplex;
+  });
+}
+function installStreamCompat() {
+  if (installed) return;
+  installed = true;
+  const stream = import_stream_browserify.default;
+  const writable = (self2) => self2._writableState;
+  const readable = (self2) => self2._readableState;
+  for (const proto of [stream.Writable.prototype, stream.Duplex.prototype]) {
+    define2(proto, "writableEnded", function() {
+      return Boolean(writable(this)?.ending);
+    });
+    define2(proto, "writableFinished", function() {
+      return Boolean(writable(this)?.finished);
+    });
+    define2(proto, "writableNeedDrain", function() {
+      const state = writable(this);
+      return Boolean(state && !state.destroyed && !state.ending && state.needDrain);
+    });
+    define2(proto, "writableCorked", function() {
+      return Number(writable(this)?.corked ?? 0);
+    });
+    define2(proto, "writableObjectMode", function() {
+      return Boolean(writable(this)?.objectMode);
+    });
+    define2(proto, "writableAborted", function() {
+      const state = writable(this);
+      return Boolean(state && state.destroyed && !state.finished);
+    });
+  }
+  for (const proto of [stream.Readable.prototype, stream.Duplex.prototype]) {
+    define2(proto, "readableEnded", function() {
+      return Boolean(readable(this)?.endEmitted);
+    });
+    define2(proto, "readableAborted", function() {
+      const state = readable(this);
+      return Boolean(state && state.destroyed && !state.endEmitted);
+    });
+    define2(proto, "readableDidRead", function() {
+      return Boolean(readable(this)?.dataEmitted ?? readable(this)?.readingMore);
+    });
+  }
+  const writableProto = stream.Writable.prototype;
+  const originalEnd = writableProto.end;
+  const originalEmit = writableProto.emit;
+  const inEnd = /* @__PURE__ */ new WeakSet();
+  writableProto.end = function(...args) {
+    inEnd.add(this);
+    try {
+      return originalEnd.apply(this, args);
+    } finally {
+      inEnd.delete(this);
+    }
+  };
+  writableProto.emit = function(event, ...args) {
+    if (event === "finish" && inEnd.has(this)) {
+      const self2 = this;
+      const later = globalThis.process?.nextTick;
+      const deliver = () => {
+        originalEmit.call(self2, event, ...args);
+      };
+      if (typeof later === "function") later(deliver);
+      else queueMicrotask(deliver);
+      return true;
+    }
+    return originalEmit.call(this, event, ...args);
+  };
+  installWebStreamAdapters(stream);
+  for (const proto of [stream.Writable.prototype, stream.Readable.prototype, stream.Duplex.prototype]) {
+    define2(proto, "closed", function() {
+      return Boolean(writable(this)?.destroyed || readable(this)?.destroyed);
+    });
+    define2(proto, "errored", function() {
+      return this.__sbxErrored ?? null;
+    });
+  }
+}
+
+// src/node/readable-from.ts
+function createReadableFrom(Readable) {
+  return function from(source, options = {}) {
+    if (source && typeof source.pipe === "function") return source;
+    const iterator = source && typeof source[Symbol.asyncIterator] === "function" ? source[Symbol.asyncIterator]() : source && typeof source[Symbol.iterator] === "function" ? source[Symbol.iterator]() : (function* () {
+      yield source;
+    })();
+    let reading = false;
+    const stream = new Readable({
+      ...options,
+      objectMode: options.objectMode ?? false,
+      read() {
+        if (reading) return;
+        reading = true;
+        void (async () => {
+          try {
+            for (; ; ) {
+              const next = await iterator.next();
+              if (next.done) {
+                stream.push(null);
+                return;
+              }
+              const value = next.value;
+              if (!stream.push(value === void 0 ? null : value)) return;
+            }
+          } catch (error) {
+            stream.destroy(error);
+          } finally {
+            reading = false;
+          }
+        })();
+      },
+      destroy(error, callback) {
+        void (async () => {
+          try {
+            await iterator.return?.();
+          } catch {
+          }
+          callback(error);
+        })();
+      }
+    });
+    return stream;
+  };
+}
+function installReadableFrom(streamModule6) {
+  streamModule6.Readable.from = createReadableFrom(streamModule6.Readable);
+}
+
+// src/node/env.ts
+function parseEnv(text) {
+  if (typeof text !== "string") {
+    throw Object.assign(new TypeError('The "content" argument must be of type string'), { code: "ERR_INVALID_ARG_TYPE" });
+  }
+  const out = {};
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const raw = lines[index];
+    const match2 = /^[ \t]*(?:export[ \t]+)?([^=#]+?)[ \t]*=[ \t]*(.*)$/.exec(raw);
+    if (!match2) continue;
+    const name = match2[1];
+    let value = match2[2];
+    const quote2 = value[0];
+    if (quote2 === '"' || quote2 === "'" || quote2 === "`") {
+      const start = index;
+      const original = value;
+      value = value.slice(1);
+      while (true) {
+        const end = value.indexOf(quote2);
+        if (end >= 0) {
+          value = value.slice(0, end);
+          break;
+        }
+        if (++index >= lines.length) {
+          index = start;
+          value = original;
+          break;
+        }
+        value += `
+${lines[index]}`;
+      }
+      if (quote2 === '"') value = value.replace(/\\n/g, "\n");
     } else {
       const comment = value.indexOf("#");
       if (comment >= 0) value = value.slice(0, comment);
@@ -22254,6 +23030,132 @@ ${lines[index]}`;
   return out;
 }
 
+// src/node/parse-args.ts
+function argError(code, message) {
+  return Object.assign(new TypeError(message), { code });
+}
+function parseArgs(config = {}) {
+  const args = config.args ?? globalThis.process?.argv?.slice(2) ?? [];
+  const options = config.options ?? {};
+  const strict = config.strict ?? true;
+  const allowPositionals = config.allowPositionals ?? !strict;
+  const allowNegative = config.allowNegative ?? false;
+  const byShort = /* @__PURE__ */ new Map();
+  for (const [name, option] of Object.entries(options)) {
+    if (option.type !== "string" && option.type !== "boolean") {
+      throw argError("ERR_INVALID_ARG_VALUE", `The property 'options.${name}.type' must be one of: 'string', 'boolean'`);
+    }
+    if (option.short !== void 0) {
+      if (option.short.length !== 1) {
+        throw argError("ERR_INVALID_ARG_VALUE", `The property 'options.${name}.short' must be a single character`);
+      }
+      byShort.set(option.short, name);
+    }
+  }
+  const tokens = [];
+  const takesValue = (name) => options[name]?.type === "string";
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      tokens.push({ kind: "option-terminator", index });
+      for (let rest = index + 1; rest < args.length; rest++) tokens.push({ kind: "positional", index: rest, value: args[rest] });
+      break;
+    }
+    if (arg.startsWith("--") && arg.length > 2) {
+      const equals = arg.indexOf("=");
+      if (equals !== -1) {
+        tokens.push({ kind: "option", name: arg.slice(2, equals), rawName: arg.slice(0, equals), index, value: arg.slice(equals + 1), inlineValue: true });
+        continue;
+      }
+      const name = arg.slice(2);
+      if (takesValue(name) && index + 1 < args.length) {
+        tokens.push({ kind: "option", name, rawName: arg, index, value: args[index + 1], inlineValue: false });
+        index++;
+      } else {
+        tokens.push({ kind: "option", name, rawName: arg, index, value: void 0, inlineValue: void 0 });
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1) {
+      for (let at2 = 1; at2 < arg.length; at2++) {
+        const short = arg[at2];
+        const name = byShort.get(short) ?? short;
+        if (takesValue(name)) {
+          if (at2 + 1 < arg.length) {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: arg.slice(at2 + 1), inlineValue: true });
+          } else if (index + 1 < args.length) {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: args[index + 1], inlineValue: false });
+            index++;
+          } else {
+            tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: void 0, inlineValue: void 0 });
+          }
+          break;
+        }
+        tokens.push({ kind: "option", name, rawName: `-${short}`, index, value: void 0, inlineValue: void 0 });
+      }
+      continue;
+    }
+    tokens.push({ kind: "positional", index, value: arg });
+  }
+  const values = /* @__PURE__ */ Object.create(null);
+  const positionals = [];
+  const store = (name, value) => {
+    if (options[name]?.multiple) {
+      const list = values[name] ?? [];
+      list.push(value);
+      values[name] = list;
+    } else {
+      values[name] = value;
+    }
+  };
+  for (const token of tokens) {
+    if (token.kind === "option-terminator") continue;
+    if (token.kind === "positional") {
+      if (!allowPositionals) {
+        throw argError("ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL", `Unexpected argument '${token.value}'. This command does not take positional arguments`);
+      }
+      positionals.push(token.value);
+      continue;
+    }
+    let name = token.name;
+    let negated = false;
+    if (allowNegative && name.startsWith("no-") && token.rawName.startsWith("--") && options[name.slice(3)]?.type === "boolean") {
+      name = name.slice(3);
+      negated = true;
+    }
+    const option = options[name];
+    if (!option) {
+      if (strict) {
+        throw argError(
+          "ERR_PARSE_ARGS_UNKNOWN_OPTION",
+          `Unknown option '${token.rawName}'${allowPositionals ? `. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- ${JSON.stringify(token.rawName)}'` : ""}`
+        );
+      }
+      store(name, token.value ?? true);
+      continue;
+    }
+    if (option.type === "string") {
+      if (token.value === void 0) {
+        if (strict) throw argError("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", `Option '${token.rawName} <value>' argument missing`);
+        store(name, true);
+        continue;
+      }
+      store(name, token.value);
+    } else {
+      if (token.inlineValue && strict) {
+        throw argError("ERR_PARSE_ARGS_INVALID_OPTION_VALUE", `Option '${token.rawName}' does not take an argument`);
+      }
+      store(name, !negated);
+    }
+  }
+  for (const [name, option] of Object.entries(options)) {
+    if (option.default !== void 0 && values[name] === void 0) {
+      values[name] = Array.isArray(option.default) ? option.default.slice() : option.default;
+    }
+  }
+  return config.tokens ? { values, positionals, tokens } : { values, positionals };
+}
+
 // src/node/util-module.ts
 var customInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var promisifyCustom = /* @__PURE__ */ Symbol.for("nodejs.util.promisify.custom");
@@ -22282,8 +23184,9 @@ function render(value, depth, seen, options) {
   if (value === null) return "null";
   const object = value;
   const custom = object[customInspect];
-  if (typeof custom === "function") {
-    return String(custom.call(object, depth, options));
+  if (options.customInspect !== false && typeof custom === "function") {
+    const result = custom.call(object, depth, options, inspect);
+    if (result !== object) return typeof result === "string" ? result : render(result, depth, seen, options);
   }
   if (seen.has(object)) return "[Circular *1]";
   if (depth < 0) return Array.isArray(object) ? "[Array]" : "[Object]";
@@ -22618,6 +23521,7 @@ var legacy = {
 inspect.custom = customInspect;
 var utilModule = {
   parseEnv,
+  parseArgs,
   format,
   formatWithOptions,
   inspect,
@@ -22721,12 +23625,12 @@ function matches(error, expected) {
   return String(error) === String(expected);
 }
 function throws(block, expected, message) {
-  const [error, threw] = capture(block);
+  const [error, threw] = capture2(block);
   if (!threw) fail(void 0, expected, message ?? "Missing expected exception.", "throws");
   if (!matches(error, expected)) throw error;
 }
 function doesNotThrow(block, expected, message) {
-  const [error, threw] = capture(block);
+  const [error, threw] = capture2(block);
   if (!threw) return;
   if (matches(error, expected)) {
     fail(error, expected, message ?? "Got unwanted exception.", "doesNotThrow");
@@ -22746,7 +23650,7 @@ async function doesNotReject(block, expected, message) {
   }
   throw error;
 }
-function capture(block) {
+function capture2(block) {
   try {
     block();
     return [void 0, false];
@@ -22807,7 +23711,7 @@ var assert_module_default = assertModule;
 var import_browser = __toESM(require_browser2());
 
 // src/node/zlib-module.ts
-var import_stream_browserify = __toESM(require_stream_browserify());
+var import_stream_browserify2 = __toESM(require_stream_browserify());
 
 // node_modules/pako/dist/pako.esm.mjs
 var Z_FIXED$1 = 4;
@@ -25023,10 +25927,12 @@ function gzip$1(input, options) {
   options.gzip = true;
   return deflate$1(input, options);
 }
+var Deflate_1$1 = Deflate$1;
 var deflate_2 = deflate$1;
 var deflateRaw_1$1 = deflateRaw$1;
 var gzip_1$1 = gzip$1;
 var deflate_1$1 = {
+  Deflate: Deflate_1$1,
   deflate: deflate_2,
   deflateRaw: deflateRaw_1$1,
   gzip: gzip_1$1};
@@ -26989,29 +27895,37 @@ function inflateRaw$1(input, options) {
   options.raw = true;
   return inflate$1(input, options);
 }
+var Inflate_1$1 = Inflate$1;
 var inflate_2 = inflate$1;
 var inflateRaw_1$1 = inflateRaw$1;
 var ungzip$1 = inflate$1;
 var inflate_1$1 = {
+  Inflate: Inflate_1$1,
   inflate: inflate_2,
   inflateRaw: inflateRaw_1$1,
   ungzip: ungzip$1};
-var { deflate, deflateRaw, gzip } = deflate_1$1;
-var { inflate, inflateRaw, ungzip } = inflate_1$1;
+var { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
+var { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
+var Deflate_1 = Deflate;
 var deflate_1 = deflate;
 var deflateRaw_1 = deflateRaw;
 var gzip_1 = gzip;
+var Inflate_1 = Inflate;
 var inflate_1 = inflate;
 var inflateRaw_1 = inflateRaw;
 var ungzip_1 = ungzip;
 
 // src/node/zlib-module.ts
+var Z_NO_FLUSH2 = 0;
+var Z_SYNC_FLUSH2 = 2;
+var Z_FULL_FLUSH2 = 3;
+var Z_FINISH2 = 4;
 var bytes = (data2) => {
   if (typeof data2 === "string") return new Uint8Array(Buffer2.from(data2, "utf8"));
   if (data2 instanceof ArrayBuffer) return new Uint8Array(data2);
   return data2;
 };
-function codec(name, run2) {
+function codec(run2) {
   const sync = (data2, options) => Buffer2.from(run2(bytes(data2), options));
   const async_ = (data2, options, callback) => {
     const done = typeof options === "function" ? options : callback;
@@ -27024,37 +27938,159 @@ function codec(name, run2) {
       }
     });
   };
-  const Stream = class extends import_stream_browserify.default.Transform {
-    chunks = [];
-    options;
-    constructor(options) {
-      super();
-      this.options = options;
+  return { sync, async: async_ };
+}
+function createEngine(mode, options) {
+  const windowBits = typeof options.windowBits === "number" ? options.windowBits : 15;
+  const level = typeof options.level === "number" ? options.level : -1;
+  const memLevel = typeof options.memLevel === "number" ? options.memLevel : 8;
+  const strategy = typeof options.strategy === "number" ? options.strategy : 0;
+  const deflateOptions = { level, memLevel, strategy, windowBits };
+  switch (mode) {
+    case "Deflate":
+      return new Deflate_1(deflateOptions);
+    case "Gzip":
+      return new Deflate_1({ ...deflateOptions, gzip: true });
+    case "DeflateRaw":
+      return new Deflate_1({ ...deflateOptions, raw: true });
+    case "Inflate":
+      return new Inflate_1({ windowBits });
+    case "InflateRaw":
+      return new Inflate_1({ raw: true, windowBits });
+    /* zlib's `windowBits + 16` means gzip only; `+ 32` detects gzip or zlib
+     * from the header, which is exactly `Unzip`. */
+    case "Gunzip":
+      return new Inflate_1({ windowBits: windowBits + 16 });
+    case "Unzip":
+      return new Inflate_1({ windowBits: windowBits + 32 });
+  }
+}
+function zlibError(engine) {
+  const codes = { [-2]: "Z_STREAM_ERROR", [-3]: "Z_DATA_ERROR", [-4]: "Z_MEM_ERROR", [-5]: "Z_BUF_ERROR", 2: "Z_NEED_DICT" };
+  return Object.assign(new Error(engine.msg || "zlib error"), { errno: engine.err, code: codes[engine.err] ?? "Z_DATA_ERROR" });
+}
+function zlibClass(mode) {
+  const ZlibStream = class extends import_stream_browserify2.default.Transform {
+    bytesWritten = 0;
+    _handle;
+    _engine;
+    _settings;
+    _output = [];
+    _finished = false;
+    constructor(options = {}) {
+      super(options);
+      this._settings = options;
+      this._engine = this._attach(createEngine(mode, options));
+      this._handle = { close: () => {
+        this._handle = null;
+      } };
+    }
+    _attach(engine) {
+      engine.onData = (chunk) => this._output.push(chunk);
+      engine.onEnd = (status) => {
+        const state = engine;
+        if (status !== 0) {
+          state.err = status;
+          state.msg = state.strm?.msg ?? state.msg;
+        }
+      };
+      return engine;
+    }
+    /** Code one chunk now and hand back what it produced. */
+    _processChunk(chunk, flushFlag = Z_NO_FLUSH2, callback) {
+      const input = typeof chunk === "string" ? Buffer2.from(chunk) : chunk;
+      try {
+        const out = this._code(input, flushFlag);
+        if (callback) queueMicrotask(() => callback(null, out));
+        return out;
+      } catch (error) {
+        if (callback) {
+          queueMicrotask(() => callback(error));
+          return Buffer2.alloc(0);
+        }
+        throw error;
+      }
+    }
+    _code(input, flushFlag) {
+      if (this._finished) {
+        return Buffer2.alloc(0);
+      }
+      this.bytesWritten += input.length;
+      const engine = this._engine;
+      if (input.length > 0 || flushFlag !== Z_NO_FLUSH2) {
+        const mapped = flushFlag === Z_FINISH2 ? Z_FINISH2 : flushFlag === Z_FULL_FLUSH2 ? Z_FULL_FLUSH2 : flushFlag === Z_SYNC_FLUSH2 ? Z_SYNC_FLUSH2 : Z_NO_FLUSH2;
+        engine.push(input, mapped);
+        if (engine.err) throw zlibError(engine);
+      }
+      if (engine.ended || flushFlag === Z_FINISH2) this._finished = engine.ended === true || mode.startsWith("Deflate") || mode === "Gzip";
+      const produced = this._output;
+      this._output = [];
+      return produced.length === 1 ? Buffer2.from(produced[0]) : Buffer2.concat(produced.map((part) => Buffer2.from(part)));
     }
     _transform(chunk, _encoding, next) {
-      this.chunks.push(Buffer2.from(chunk));
-      next();
+      try {
+        const out = this._code(chunk, typeof this._settings.flush === "number" ? this._settings.flush : Z_NO_FLUSH2);
+        if (out.length) this.push(out);
+        next();
+      } catch (error) {
+        next(error);
+      }
     }
     _flush(next) {
       try {
-        this.push(sync(Buffer2.concat(this.chunks), this.options));
+        const finish = typeof this._settings.finishFlush === "number" ? this._settings.finishFlush : Z_FINISH2;
+        const out = this._code(new Uint8Array(0), finish);
+        if (out.length) this.push(out);
         next();
       } catch (error) {
         next(error);
       }
     }
+    /** `flush([kind], callback)`: emit what is pending without ending the stream. */
+    flush(kind, callback) {
+      const done = typeof kind === "function" ? kind : callback;
+      const flag = typeof kind === "number" ? kind : Z_FULL_FLUSH2;
+      try {
+        const out = this._code(new Uint8Array(0), flag);
+        if (out.length) this.push(out);
+      } catch (error) {
+        this.destroy(error);
+      }
+      if (done) queueMicrotask(done);
+    }
+    reset() {
+      this._engine = this._attach(createEngine(mode, this._settings));
+      this._output = [];
+      this._finished = false;
+    }
+    params(level, strategy, callback) {
+      this._settings.level = level;
+      this._settings.strategy = strategy;
+      if (callback) queueMicrotask(callback);
+    }
+    close(callback) {
+      this._handle?.close();
+      if (callback) this.once("close", callback);
+      if (!this.destroyed) this.destroy();
+    }
   };
-  Object.defineProperty(Stream, "name", { value: name });
-  return { sync, async: async_, Stream };
-}
-var gzipCodec = codec("Gzip", (input, options) => gzip_1(input, options));
-var gunzipCodec = codec("Gunzip", (input) => ungzip_1(input));
-var deflateCodec = codec("Deflate", (input, options) => deflate_1(input, options));
-var inflateCodec = codec("Inflate", (input) => inflate_1(input));
-var deflateRawCodec = codec("DeflateRaw", (input, options) => deflateRaw_1(input, options));
-var inflateRawCodec = codec("InflateRaw", (input) => inflateRaw_1(input));
+  Object.defineProperty(ZlibStream, "name", { value: mode });
+  return ZlibStream;
+}
+var Gzip = zlibClass("Gzip");
+var Gunzip = zlibClass("Gunzip");
+var Deflate2 = zlibClass("Deflate");
+var Inflate2 = zlibClass("Inflate");
+var DeflateRaw = zlibClass("DeflateRaw");
+var InflateRaw = zlibClass("InflateRaw");
+var Unzip = zlibClass("Unzip");
+var gzipCodec = codec((input, options) => gzip_1(input, options));
+var gunzipCodec = codec((input) => ungzip_1(input));
+var deflateCodec = codec((input, options) => deflate_1(input, options));
+var inflateCodec = codec((input) => inflate_1(input));
+var deflateRawCodec = codec((input, options) => deflateRaw_1(input, options));
+var inflateRawCodec = codec((input) => inflateRaw_1(input));
 var unzipCodec = codec(
-  "Unzip",
   (input) => input[0] === 31 && input[1] === 139 ? ungzip_1(input) : inflate_1(input)
 );
 function brotliUnavailable(name) {
@@ -27065,27 +28101,34 @@ function brotliUnavailable(name) {
   throw error;
 }
 var zlibModule = {
+  Gzip,
+  Gunzip,
+  Deflate: Deflate2,
+  Inflate: Inflate2,
+  DeflateRaw,
+  InflateRaw,
+  Unzip,
   gzipSync: gzipCodec.sync,
   gzip: gzipCodec.async,
-  createGzip: (o2) => new gzipCodec.Stream(o2),
+  createGzip: (o2) => new Gzip(o2),
   gunzipSync: gunzipCodec.sync,
   gunzip: gunzipCodec.async,
-  createGunzip: (o2) => new gunzipCodec.Stream(o2),
+  createGunzip: (o2) => new Gunzip(o2),
   deflateSync: deflateCodec.sync,
   deflate: deflateCodec.async,
-  createDeflate: (o2) => new deflateCodec.Stream(o2),
+  createDeflate: (o2) => new Deflate2(o2),
   inflateSync: inflateCodec.sync,
   inflate: inflateCodec.async,
-  createInflate: (o2) => new inflateCodec.Stream(o2),
+  createInflate: (o2) => new Inflate2(o2),
   deflateRawSync: deflateRawCodec.sync,
   deflateRaw: deflateRawCodec.async,
-  createDeflateRaw: (o2) => new deflateRawCodec.Stream(o2),
+  createDeflateRaw: (o2) => new DeflateRaw(o2),
   inflateRawSync: inflateRawCodec.sync,
   inflateRaw: inflateRawCodec.async,
-  createInflateRaw: (o2) => new inflateRawCodec.Stream(o2),
+  createInflateRaw: (o2) => new InflateRaw(o2),
   unzipSync: unzipCodec.sync,
   unzip: unzipCodec.async,
-  createUnzip: (o2) => new unzipCodec.Stream(o2),
+  createUnzip: (o2) => new Unzip(o2),
   brotliCompressSync: () => brotliUnavailable("brotliCompressSync"),
   brotliDecompressSync: () => brotliUnavailable("brotliDecompressSync"),
   brotliCompress: () => brotliUnavailable("brotliCompress"),
@@ -27186,7 +28229,7 @@ var url_module_default = urlModule;
 
 // src/node/virtual-http.ts
 var import_events = __toESM(require_events());
-var import_stream_browserify2 = __toESM(require_stream_browserify());
+var import_stream_browserify3 = __toESM(require_stream_browserify());
 
 // src/net/policy.ts
 function isLoopbackHostname(hostname) {
@@ -27260,7 +28303,8 @@ function policedWebSocket(Native, policy) {
 }
 
 // src/node/virtual-http.ts
-var VirtualIncomingMessage = class extends import_stream_browserify2.default.Readable {
+installStreamCompat();
+var VirtualIncomingMessage = class extends import_stream_browserify3.default.Readable {
   method;
   url;
   headers;
@@ -27300,7 +28344,7 @@ var VirtualIncomingMessage = class extends import_stream_browserify2.default.Rea
     return this;
   }
 };
-var VirtualServerResponse = class extends import_stream_browserify2.default.Writable {
+var VirtualServerResponse = class extends import_stream_browserify3.default.Writable {
   statusCode = 200;
   statusMessage = "OK";
   headersSent = false;
@@ -27326,16 +28370,38 @@ var VirtualServerResponse = class extends import_stream_browserify2.default.Writ
   }
   _final(callback) {
     this.headersSent = true;
+    this.settle();
+    this.once("finish", () => queueMicrotask(() => {
+      if (!this.destroyed) this.destroy();
+    }));
+    callback();
+  }
+  /*
+   * A destroyed response still answers.
+   *
+   * Node sends whatever was written and closes the socket; the caller sees a
+   * response, however short. Here the caller is waiting on `completed`, which
+   * only `_final` used to settle — so a response torn down before `end()`
+   * (an aborted stream, `res.destroy(err)` from a web-stream pipe) left the
+   * request unanswered forever while the server had already moved on.
+   */
+  _destroy(error, callback) {
+    this.settle();
+    callback(error);
+  }
+  settled = false;
+  settle() {
+    if (this.settled) return;
+    this.settled = true;
     if (this.sendDate && !this.hasHeader("date")) this.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString());
     const headers = {};
-    for (const { name, value } of this.headers.values()) headers[name] = Array.isArray(value) ? value.join(", ") : value;
+    for (const [key, { value }] of this.headers) headers[key] = Array.isArray(value) ? value.join(", ") : value;
     this.resolve({
       statusCode: this.statusCode,
       statusMessage: this.statusMessage || STATUS_CODES[this.statusCode] || "",
       headers,
       body: new Uint8Array(Buffer2.concat(this.chunks))
     });
-    callback();
   }
   setHeader(name, value) {
     validateHeaderName(name);
@@ -27344,9 +28410,9 @@ var VirtualServerResponse = class extends import_stream_browserify2.default.Writ
     return this;
   }
   appendHeader(name, value) {
-    const current2 = this.getHeader(name);
+    const current3 = this.getHeader(name);
     const next = Array.isArray(value) ? [...value] : [String(value)];
-    return this.setHeader(name, current2 === void 0 ? next : [...Array.isArray(current2) ? current2 : [String(current2)], ...next]);
+    return this.setHeader(name, current3 === void 0 ? next : [...Array.isArray(current3) ? current3 : [String(current3)], ...next]);
   }
   getHeader(name) {
     return this.headers.get(name.toLowerCase())?.value;
@@ -27374,6 +28440,25 @@ var VirtualServerResponse = class extends import_stream_browserify2.default.Writ
   flushHeaders() {
     this.headersSent = true;
   }
+  /*
+   * Node's `OutgoingMessage` internals that middleware reaches past the public
+   * API for. `compression` — which Next's dev server wraps every response in —
+   * calls `_implicitHeader()` from its own `write`/`end` to commit the status
+   * line before the first byte, the way Node's `write` does internally.
+   */
+  _implicitHeader() {
+    if (!this.headersSent) this.writeHead(this.statusCode);
+  }
+  get _header() {
+    return this.headersSent ? `HTTP/1.1 ${this.statusCode} ${this.statusMessage}\r
+` : null;
+  }
+  get finished() {
+    return this.writableEnded;
+  }
+  chunkedEncoding = false;
+  useChunkedEncodingByDefault = true;
+  strictContentLength = false;
   writeContinue() {
   }
   writeProcessing() {
@@ -27385,7 +28470,7 @@ var VirtualServerResponse = class extends import_stream_browserify2.default.Writ
     return this;
   }
 };
-var VirtualSocket = class extends import_stream_browserify2.default.Duplex {
+var VirtualSocket = class extends import_stream_browserify3.default.Duplex {
   remoteAddress = "127.0.0.1";
   remotePort = 0;
   localAddress = "127.0.0.1";
@@ -27590,7 +28675,7 @@ var VirtualHttpRouter = class {
     };
   }
 };
-var VirtualClientResponse = class extends import_stream_browserify2.default.Readable {
+var VirtualClientResponse = class extends import_stream_browserify3.default.Readable {
   constructor(statusCode, statusMessage, headers, body) {
     super();
     this.statusCode = statusCode;
@@ -27657,7 +28742,7 @@ function resolveTarget(input, overrides, defaultProtocol) {
 function isLoopback(hostname) {
   return isLoopbackHostname(hostname);
 }
-var VirtualClientRequest = class extends import_stream_browserify2.default.Writable {
+var VirtualClientRequest = class extends import_stream_browserify3.default.Writable {
   constructor(target, router, fetchImpl, trackRequest, loopback = void 0) {
     super();
     this.target = target;
@@ -27887,6 +28972,7 @@ function createVirtualFetch(router, options = {}) {
     const request = new Request(input, init);
     const url = new URL(request.url);
     const release = options.trackRequest?.();
+    let handedOff = false;
     try {
       if (!isLoopback(url.hostname)) {
         if (!options.fetch) {
@@ -27894,7 +28980,10 @@ function createVirtualFetch(router, options = {}) {
             cause: Object.assign(new Error(`getaddrinfo ENOTFOUND ${url.hostname}`), { code: "ENOTFOUND" })
           });
         }
-        return await options.fetch(request);
+        const response = await options.fetch(request);
+        if (!release || !response.body) return response;
+        handedOff = true;
+        return releaseWhenConsumed(response, release);
       }
       const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
       const headers = {};
@@ -27934,9 +29023,43 @@ function createVirtualFetch(router, options = {}) {
         headers: responseHeaders
       });
     } finally {
-      release?.();
+      if (!handedOff) release?.();
+    }
+  });
+}
+function releaseWhenConsumed(response, release) {
+  let released = false;
+  const once = () => {
+    if (!released) {
+      released = true;
+      release();
+    }
+  };
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          once();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        controller.error(error);
+        once();
+      }
+    },
+    cancel(reason) {
+      once();
+      return reader.cancel(reason);
     }
   });
+  const wrapped = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+  Object.defineProperty(wrapped, "url", { value: response.url });
+  Object.defineProperty(wrapped, "redirected", { value: response.redirected });
+  return wrapped;
 }
 function validateHeaderName(name) {
   if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name)) throw Object.assign(new TypeError(`Header name must be a valid HTTP token [${name}]`), { code: "ERR_INVALID_HTTP_TOKEN" });
@@ -28031,12 +29154,12 @@ function invoke(host, fn, context, timeout) {
 function createMockTracker() {
   const restorers = [];
   const fn = (original = () => void 0, implementation = original) => {
-    let current2 = implementation;
+    let current3 = implementation;
     const once = /* @__PURE__ */ new Map();
     const calls = [];
     const mocked = function(...args) {
       const index = calls.length;
-      const chosen = once.get(index) ?? current2;
+      const chosen = once.get(index) ?? current3;
       once.delete(index);
       const call = { arguments: args, result: void 0, error: void 0, this: this };
       calls.push(call);
@@ -28056,13 +29179,13 @@ function createMockTracker() {
           calls.length = 0;
         },
         mockImplementation: (next) => {
-          current2 = next;
+          current3 = next;
         },
         mockImplementationOnce: (next, onCall) => {
           once.set(onCall ?? calls.length, next);
         },
         restore: () => {
-          current2 = original;
+          current3 = original;
         }
       }
     });
@@ -28075,21 +29198,21 @@ function createMockTracker() {
     }
     const mocked = fn(original, implementation ?? original);
     object[name] = mocked;
-    const restore = () => {
+    const restore2 = () => {
       object[name] = original;
     };
-    mocked.mock.restore = restore;
-    restorers.push(restore);
+    mocked.mock.restore = restore2;
+    restorers.push(restore2);
     return mocked;
   };
   return {
     fn,
     method,
     reset: () => {
-      for (const restore of restorers.splice(0)) restore();
+      for (const restore2 of restorers.splice(0)) restore2();
     },
     restoreAll: () => {
-      for (const restore of restorers.splice(0)) restore();
+      for (const restore2 of restorers.splice(0)) restore2();
     }
   };
 }
@@ -29577,35 +30700,25 @@ var SyncChannelClient = class {
   waitWhile(state) {
     for (; ; ) {
       Atomics.wait(this.control, STATE, state, WAIT_SLICE_MS);
-      const current2 = Atomics.load(this.control, STATE);
-      if (current2 !== state) return current2;
+      const current3 = Atomics.load(this.control, STATE);
+      if (current3 !== state) return current3;
     }
   }
 };
 
 // src/node/child-process-module.ts
 var import_events2 = __toESM(require_events());
-var import_stream_browserify3 = __toESM(require_stream_browserify());
+var import_stream_browserify4 = __toESM(require_stream_browserify());
 var ChildProcess = class extends import_events2.default {
-  stdout = new import_stream_browserify3.default.PassThrough();
-  stderr = new import_stream_browserify3.default.PassThrough();
-  stdin;
-  stdio;
-  pid;
-  exitCode = null;
-  signalCode = null;
-  killed = false;
-  spawnfile;
-  spawnargs;
-  handle;
-  settled = false;
-  constructor(handle, file, args) {
+  constructor(handle, file, args, referenceChanged = () => {
+  }, extraPipes = []) {
     super();
+    this.referenceChanged = referenceChanged;
     this.handle = handle;
     this.pid = handle.pid;
     this.spawnfile = file;
     this.spawnargs = [file, ...args];
-    this.stdin = new import_stream_browserify3.default.Writable({
+    this.stdin = new import_stream_browserify4.default.Writable({
       write: (chunk, _encoding, done) => {
         try {
           handle.sendStdin(typeof chunk === "string" ? chunk : Buffer2.from(chunk).toString("utf8"));
@@ -29622,43 +30735,144 @@ var ChildProcess = class extends import_events2.default {
       }
     });
     this.stdio = [this.stdin, this.stdout, this.stderr];
+    for (const fd of extraPipes) this.stdio[fd] = this.extraPipe(fd);
+    handle.on("fd", (event) => {
+      const pipe = this.stdio[event.fd];
+      pipe?.push(Buffer2.from(event.text));
+    });
     handle.on("stdout", (text) => this.stdout.write(text));
     handle.on("stderr", (text) => this.stderr.write(text));
     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;
+    referenceChanged(1);
+    try {
+      handle.exec();
+    } catch (error) {
+      this.unref();
+      throw error;
+    }
   }
-  disconnect() {
-    this.emit("disconnect");
+  referenceChanged;
+  stdout = new import_stream_browserify4.default.PassThrough();
+  stderr = new import_stream_browserify4.default.PassThrough();
+  stdin;
+  stdio;
+  pid;
+  exitCode = null;
+  signalCode = null;
+  killed = false;
+  spawnfile;
+  spawnargs;
+  handle;
+  settled = false;
+  referenced = true;
+  /**
+   * The parent's end of `stdio[fd] = "pipe"` for a descriptor above 2.
+   *
+   * One Duplex per descriptor, as Node gives: what the parent writes reaches
+   * the child's `fd`, and what the child writes there is readable here. Chunks
+   * are Buffers because the DevTools pipe is framed by NUL bytes and its reader
+   * searches the chunk with `indexOf("\0")`.
+   */
+  extraPipe(fd) {
+    const handle = this.handle;
+    return new import_stream_browserify4.default.Duplex({
+      read() {
+      },
+      write(chunk, _encoding, done) {
+        try {
+          handle.writeFd?.(fd, typeof chunk === "string" ? chunk : Buffer2.from(chunk).toString("utf8"));
+        } catch {
+        }
+        done();
+      },
+      final(done) {
+        try {
+          handle.endFd?.(fd);
+        } catch {
+        }
+        done();
+      }
+    });
   }
-  /** No IPC channel exists, and reporting that honestly beats a silent drop. */
-  send() {
-    return false;
+  kill(signal = "SIGTERM") {
+    this.killed = true;
+    this.handle.kill(typeof signal === "number" ? "SIGTERM" : signal);
+    return true;
+  }
+  ref() {
+    if (!this.settled && !this.referenced) {
+      this.referenced = true;
+      this.referenceChanged(1);
+    }
+    return this;
+  }
+  unref() {
+    if (this.referenced) {
+      this.referenced = false;
+      this.referenceChanged(-1);
+    }
+    return this;
+  }
+  channel;
+  channelOpen = false;
+  /** Open the parent's end of a `fork` channel. */
+  attachChannel(transport, id) {
+    this.channelOpen = true;
+    this.channel = transport.attach(
+      id,
+      "parent",
+      (message) => this.emit("message", message, void 0),
+      () => this.channelClosed()
+    );
   }
   get connected() {
-    return false;
+    return this.channelOpen;
+  }
+  /** `send(message[, sendHandle][, options][, callback])`, as Node spells it. */
+  send(message, ...rest) {
+    const callback = rest.find((value) => typeof value === "function");
+    if (!this.channel || !this.channelOpen) {
+      const error = Object.assign(new Error("Channel closed"), { code: "ERR_IPC_CHANNEL_CLOSED" });
+      if (callback) queueMicrotask(() => callback(error));
+      else queueMicrotask(() => this.emit("error", error));
+      return false;
+    }
+    this.channel.send(message);
+    if (callback) queueMicrotask(() => callback(null));
+    return true;
+  }
+  disconnect() {
+    if (!this.channelOpen) return;
+    this.channel?.disconnect();
+    this.channelClosed();
+  }
+  channelClosed() {
+    if (!this.channelOpen) return;
+    this.channelOpen = false;
+    this.emit("disconnect");
   }
   finish(code) {
     if (this.settled) return;
+    this.channel?.disconnect();
+    this.channelClosed();
+    this.unref();
     this.settled = true;
     this.exitCode = code;
     this.stdout.end();
     this.stderr.end();
+    for (const pipe of this.stdio.slice(3)) {
+      if (!pipe) continue;
+      pipe.once("end", () => pipe.destroy());
+      pipe.push(null);
+      if (!pipe.readableFlowing) queueMicrotask(() => {
+        if (!pipe.readableFlowing) pipe.destroy();
+      });
+    }
     this.emit("exit", code, null);
     queueMicrotask(() => this.emit("close", code, null));
   }
 };
-function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({})) {
+function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv = () => ({}), lifecycle = {}) {
   const environmentFor = (options) => options.env ? { ...options.env } : defaultEnv();
   const throughShell = (command, options) => {
     const shell = typeof options.shell === "string" ? options.shell : "/bin/sh";
@@ -29669,16 +30883,27 @@ function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv
     if (stdio === "ignore") return true;
     return Array.isArray(stdio) && stdio[0] === "ignore";
   };
+  const wantsChannel = (options) => Array.isArray(options.stdio) && options.stdio.includes("ipc");
+  const extraPipesOf = (options) => Array.isArray(options.stdio) ? options.stdio.flatMap((entry, fd) => fd > 2 && (entry === "pipe" || entry === "overlapped") ? [fd] : []) : [];
   const start = (file, args, options) => {
     const resolved = options.shell ? throughShell([file, ...args].join(" "), options) : { file, args };
+    const channelId = wantsChannel(options) && lifecycle.ipc ? newIpcChannelId() : void 0;
+    const extraPipes = extraPipesOf(options);
     const handle = spawnChild({
       command: resolved.file,
       args: resolved.args,
       cwd: options.cwd ?? defaultCwd(),
-      env: environmentFor(options),
-      ...stdinIgnored(options) ? { stdinIgnored: true } : {}
+      env: channelId ? { ...environmentFor(options), [IPC_CHANNEL_ENV]: channelId } : environmentFor(options),
+      ...options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[0] === "inherit" ? { inheritStdio: true } : {},
+      ...stdinIgnored(options) ? { stdinIgnored: true } : {},
+      ...extraPipes.length ? { extraPipes } : {}
     });
-    return new ChildProcess(handle, resolved.file, resolved.args);
+    const child = new ChildProcess(handle, resolved.file, resolved.args, lifecycle.referenceChanged, extraPipes);
+    if (channelId && lifecycle.ipc) child.attachChannel(lifecycle.ipc, channelId);
+    const inherited = (index) => options.stdio === "inherit" || Array.isArray(options.stdio) && options.stdio[index] === "inherit";
+    if (inherited(1)) child.stdout.on("data", (chunk) => lifecycle.stdout?.(chunk.toString()));
+    if (inherited(2)) child.stderr.on("data", (chunk) => lifecycle.stderr?.(chunk.toString()));
+    return child;
   };
   const spawn = (file, args = [], options = {}) => {
     if (!Array.isArray(args)) return start(file, [], args);
@@ -29721,7 +30946,13 @@ ${err2.join("")}`),
     spawn,
     exec,
     execFile,
-    fork: (modulePath, args = [], options = {}) => spawn("node", [modulePath, ...args], options),
+    fork: (modulePath, args = [], options = {}) => {
+      const [list, opts] = Array.isArray(args) ? [args, options] : [[], args ?? {}];
+      const stdio = Array.isArray(opts.stdio) ? opts.stdio : typeof opts.stdio === "string" ? [opts.stdio, opts.stdio, opts.stdio] : opts.silent ? ["pipe", "pipe", "pipe"] : ["inherit", "inherit", "inherit"];
+      const withChannel = stdio.includes("ipc") ? stdio : [...stdio, "ipc"];
+      const execArgv = (opts.execArgv ?? []).filter((flag) => !/^--(inspect|debug)/.test(flag));
+      return start("node", [...execArgv, modulePath, ...list], { ...opts, shell: false, stdio: withChannel });
+    },
     ...buildSyncFamily(syncSpawn, throughShell, defaultCwd, environmentFor),
     ChildProcess
   };
@@ -30253,7 +31484,8 @@ var KERNEL_RELEASE = "5.10.0";
 var KERNEL_VERSION = `Linux version ${KERNEL_RELEASE} (sandboxedjs@sandbox) (gcc version 12.2.0) #1 SMP PREEMPT_DYNAMIC`;
 
 // src/node/core-modules.ts
-installReadableFrom(import_stream_browserify4.default);
+installStreamCompat();
+installReadableFrom(import_stream_browserify5.default);
 var Dirent = class {
   /** Node 20+ exposes the containing directory, and `fs.glob` consumers read it. */
   constructor(name, stat, parentPath = "") {
@@ -30394,6 +31626,9 @@ function createCoreModules(options) {
     argv: options.argv?.slice() ?? ["/usr/bin/node"],
     argv0: "node",
     execPath: "/usr/bin/node",
+    /* `process/browser.js` has no `execArgv`; Node always has an array, and
+     * CLIs that fork copy it (`[...process.execArgv]`). */
+    execArgv: [],
     env,
     platform: "linux",
     arch: "x64",
@@ -30435,7 +31670,7 @@ function createCoreModules(options) {
       if (typeof fn !== "function") {
         throw Object.assign(new TypeError('The "callback" argument must be of type function'), { code: "ERR_INVALID_ARG_TYPE" });
       }
-      tickQueue.push([fn, args]);
+      tickQueue.push([bindToCurrent(fn), args]);
       if (!tickDrainScheduled) {
         tickDrainScheduled = true;
         afterMicrotasks(runTicks);
@@ -30447,6 +31682,25 @@ function createCoreModules(options) {
     const implementation = import_events4.default.prototype[method];
     if (typeof implementation === "function") processObject[method] = implementation;
   }
+  const hrtime = (previous) => {
+    const now = performance.timeOrigin + performance.now();
+    let seconds = Math.floor(now / 1e3);
+    let nanoseconds = Math.floor(now % 1e3 * 1e6);
+    if (previous) {
+      seconds -= previous[0];
+      nanoseconds -= previous[1];
+      if (nanoseconds < 0) {
+        seconds -= 1;
+        nanoseconds += 1e9;
+      }
+    }
+    return [seconds, nanoseconds];
+  };
+  hrtime.bigint = () => {
+    const [seconds, nanoseconds] = hrtime();
+    return BigInt(seconds) * 1000000000n + BigInt(nanoseconds);
+  };
+  processObject.hrtime = hrtime;
   const tty = options.tty === true;
   processObject.stdout = makeOutputStream(stdoutWrite, 1, tty);
   processObject.stderr = makeOutputStream(stderrWrite, 2, tty);
@@ -30488,15 +31742,16 @@ function createCoreModules(options) {
     }
   };
   const defer = (fn) => {
+    const bound = bindToCurrent(fn);
     queueMicrotask(() => {
       try {
-        fn();
+        bound();
       } catch (error) {
         reportUncaught(error);
       }
     });
   };
-  const stdin = options.interactiveStdin ? new import_stream_browserify4.default.PassThrough() : new import_stream_browserify4.default.Readable({ read() {
+  const stdin = options.interactiveStdin ? new import_stream_browserify5.default.PassThrough() : new import_stream_browserify5.default.Readable({ read() {
     this.push(null);
   } });
   Object.assign(stdin, {
@@ -30531,6 +31786,7 @@ function createCoreModules(options) {
   const moduleBuiltin = {
     builtinModules: builtinNames.flatMap((name) => [name, `node:${name}`]),
     isBuiltin: (name) => builtinNames.includes(name.replace(/^node:/, "")),
+    findSourceMap: () => void 0,
     createRequire: () => {
       throw new Error("createRequire is only available inside a loaded module");
     }
@@ -30553,18 +31809,98 @@ function createCoreModules(options) {
   };
   const http = options.http ? createHttpModule(options.http.router, options.http.owner, httpOptions, "http:") : createUnsupportedModule("http");
   const https = options.http ? createHttpModule(options.http.router, options.http.owner, httpOptions, "https:") : createUnsupportedModule("https");
-  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env })) : createUnsupportedModule("child_process");
+  let referencedChildren = 0;
+  const childProcess = options.spawnChild ? createChildProcessModule(options.spawnChild, () => cwd, options.syncSpawn, () => ({ ...processObject.env }), {
+    referenceChanged: (delta) => {
+      referencedChildren += delta;
+    },
+    stdout: options.stdout,
+    stderr: options.stderr,
+    ...options.ipc ? { ipc: options.ipc } : {}
+  }) : createUnsupportedModule("child_process");
+  let channelReferenced = 0;
+  const channelId = env[IPC_CHANNEL_ENV];
+  if (channelId && options.ipc) {
+    delete env[IPC_CHANNEL_ENV];
+    let open = true;
+    let referenced = true;
+    channelReferenced = 1;
+    const close = () => {
+      if (!open) return;
+      open = false;
+      if (referenced) channelReferenced = 0;
+      processObject.connected = false;
+      delete processObject.send;
+      try {
+        processObject.emit("disconnect");
+      } catch (error) {
+        reportUncaught(error);
+      }
+      runTicks();
+    };
+    const endpoint = options.ipc.attach(
+      channelId,
+      "child",
+      (message) => {
+        try {
+          processObject.emit("message", message, void 0);
+        } catch (error) {
+          reportUncaught(error);
+        }
+        runTicks();
+      },
+      close
+    );
+    processObject.connected = true;
+    processObject.send = (message, ...rest) => {
+      const callback = rest.find((value) => typeof value === "function");
+      if (!open) {
+        const error = Object.assign(new Error("Channel closed"), { code: "ERR_IPC_CHANNEL_CLOSED" });
+        if (callback) defer(() => callback(error));
+        else defer(() => {
+          processObject.emit("error", error);
+        });
+        return false;
+      }
+      endpoint.send(message);
+      if (callback) defer(() => callback(null));
+      return true;
+    };
+    processObject.disconnect = () => {
+      if (open) {
+        endpoint.disconnect();
+        close();
+      }
+    };
+    processObject.channel = {
+      ref() {
+        if (open && !referenced) {
+          referenced = true;
+          channelReferenced = 1;
+        }
+        return this;
+      },
+      unref() {
+        if (referenced) {
+          referenced = false;
+          channelReferenced = 0;
+        }
+        return this;
+      }
+    };
+  }
   const readline = createReadlineModule(() => processObject.stdin, () => processObject.stdout);
   const dns = createDnsModule(defer);
   const builtins = {
     assert: assert_module_default,
     "assert/strict": assert_module_default.strict ?? assert_module_default,
-    buffer: { Buffer: Buffer2, SlowBuffer: Buffer2, INSPECT_MAX_BYTES: 50, kMaxLength: Buffer2.kMaxLength },
+    buffer: createBufferBuiltin(),
     async_hooks: asyncHooks,
     child_process: childProcess,
     console: consoleObject,
     constants: fs.constants,
     crypto: createCryptoModule(),
+    diagnostics_channel: createDiagnosticsChannel(),
     dns,
     "dns/promises": dns.promises,
     events: import_events4.default,
@@ -30582,12 +31918,31 @@ function createCoreModules(options) {
     querystring: import_querystring_es3.default,
     readline,
     "readline/promises": readline.promises,
-    stream: import_stream_browserify4.default,
+    stream: import_stream_browserify5.default,
+    "stream/web": Object.fromEntries([
+      "ReadableStream",
+      "ReadableStreamDefaultReader",
+      "ReadableStreamBYOBReader",
+      "ReadableStreamDefaultController",
+      "ReadableByteStreamController",
+      "ReadableStreamBYOBRequest",
+      "WritableStream",
+      "WritableStreamDefaultWriter",
+      "WritableStreamDefaultController",
+      "TransformStream",
+      "TransformStreamDefaultController",
+      "ByteLengthQueuingStrategy",
+      "CountQueuingStrategy",
+      "TextEncoderStream",
+      "TextDecoderStream",
+      "CompressionStream",
+      "DecompressionStream"
+    ].filter((name) => name in globalThis).map((name) => [name, globalThis[name]])),
     "stream/promises": createStreamPromises(),
     string_decoder: import_string_decoder.default,
     timers: { ...import_timers_browserify.default, ...timers.api },
     "timers/promises": createTimerPromises(timers.api),
-    tty: { isatty: () => false, ReadStream: import_stream_browserify4.default.Readable, WriteStream: import_stream_browserify4.default.Writable },
+    tty: { isatty: () => false, ReadStream: import_stream_browserify5.default.Readable, WriteStream: import_stream_browserify5.default.Writable },
     url: url_module_default,
     util: util_module_default,
     "util/types": util_module_default.types ?? {},
@@ -30614,19 +31969,73 @@ function createCoreModules(options) {
     })
   };
   for (const name of stubNames) builtins[name] = createUnsupportedModule(name);
+  builtins.worker_threads = {
+    MessagePort: globalThis.MessagePort ?? class MessagePort {
+    },
+    markAsUncloneable: () => {
+    },
+    isMarkedAsUncloneable: () => false,
+    markAsUntransferable: () => {
+    },
+    isMarkedAsUntransferable: () => false
+  };
   builtins.net = createNetModule();
+  builtins.vm = vm_module_default;
+  builtins.inspector = createUnsupportedModule("inspector", {
+    url: () => void 0,
+    close: () => {
+    },
+    waitForDebugger: () => {
+      throw Object.assign(new Error("Inspector is not active"), { code: "ERR_INSPECTOR_NOT_ACTIVE" });
+    },
+    console: consoleObject
+  });
+  builtins.v8 = createUnsupportedModule("v8", {
+    getHeapStatistics: () => {
+      const memory = performance.memory;
+      const limit = memory?.jsHeapSizeLimit ?? 4 * 1024 ** 3;
+      return {
+        total_heap_size: memory?.totalJSHeapSize ?? 0,
+        total_heap_size_executable: 0,
+        total_physical_size: memory?.totalJSHeapSize ?? 0,
+        total_available_size: limit - (memory?.usedJSHeapSize ?? 0),
+        used_heap_size: memory?.usedJSHeapSize ?? 0,
+        heap_size_limit: limit,
+        malloced_memory: 0,
+        peak_malloced_memory: 0,
+        does_zap_garbage: 0,
+        number_of_native_contexts: 1,
+        number_of_detached_contexts: 0,
+        total_global_handles_size: 0,
+        used_global_handles_size: 0,
+        external_memory: 0
+      };
+    },
+    getHeapSpaceStatistics: () => [],
+    getHeapCodeStatistics: () => ({ code_and_metadata_size: 0, bytecode_and_metadata_size: 0, external_script_source_size: 0, cpu_profiler_metadata_size: 0 }),
+    cachedDataVersionTag: () => 0,
+    setFlagsFromString: () => {
+    },
+    setHeapSnapshotNearHeapLimit: () => {
+    },
+    serialize: (value) => Buffer2.from(JSON.stringify(value) ?? "null"),
+    deserialize: (buffer) => JSON.parse(Buffer2.from(buffer).toString("utf8"))
+  });
   const globals = {
     Buffer: Buffer2,
     console: consoleObject,
     process: processObject,
     ...timers.api,
-    queueMicrotask: (fn) => queueMicrotask(() => {
-      try {
-        fn();
-      } catch (error) {
-        reportUncaught(error);
-      }
-    })
+    queueMicrotask: (fn) => {
+      const bound = bindToCurrent(fn);
+      queueMicrotask(() => {
+        try {
+          bound();
+        } catch (error) {
+          reportUncaught(error);
+        }
+      });
+    }
   };
   if (options.http) {
     globals.fetch = createVirtualFetch(options.http.router, {
@@ -30649,7 +32058,7 @@ function createCoreModules(options) {
     builtins,
     globals,
     process: processObject,
-    pendingHandles: timers.pending,
+    pendingHandles: () => timers.pending() + referencedChildren + channelReferenced,
     pendingUnrefed: timers.pendingUnrefed,
     /** Client requests sent but not yet read to completion. */
     pendingRequests: () => inFlightRequests,
@@ -30671,7 +32080,7 @@ function createCoreModules(options) {
     },
     loopActivity: () => timers.scheduled() + requestsStarted,
     writeStdin: (data2) => {
-      if (options.interactiveStdin) stdin.write(data2);
+      if (options.interactiveStdin) stdin.write(typeof data2 === "string" ? data2 : Buffer2.from(data2));
     },
     endStdin: () => {
       if (options.interactiveStdin) stdin.end();
@@ -30715,7 +32124,9 @@ var ASYNC_FS_METHODS = [
   "close",
   "read",
   "write",
-  "exists"
+  "exists",
+  "fsync",
+  "fdatasync"
 ];
 function createPathModule(cwd) {
   const resolve2 = (...segments2) => import_path_browserify.default.resolve(cwd(), ...segments2);
@@ -30892,10 +32303,27 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     },
     writeSync: (fd, data2, offset2, length, position) => {
       const file = requiredFd(fds, fd);
+      if (typeof data2 === "string") {
+        const stringPosition = typeof offset2 === "number" ? offset2 : null;
+        const encoding = typeof length === "string" ? length : "utf8";
+        data2 = Buffer2.from(data2, encoding);
+        position = stringPosition;
+        offset2 = 0;
+        length = data2.length;
+      }
       const input = bytes2(data2);
-      const chunk = typeof data2 === "string" ? input : input.subarray(offset2 ?? 0, (offset2 ?? 0) + (length ?? input.length));
+      const chunk = input.subarray(offset2 ?? 0, (offset2 ?? 0) + (length ?? input.length));
+      const size = volume.lstatSync(file.path).size;
+      const append = file.flags.startsWith("a") || (position ?? file.position) >= size;
+      if (append) {
+        const at2 = file.flags.startsWith("a") ? size : position ?? file.position;
+        if (at2 > size) volume.appendFileSync(file.path, new Uint8Array(at2 - size));
+        volume.appendFileSync(file.path, chunk);
+        if (position == null) file.position = at2 + chunk.length;
+        return chunk.length;
+      }
       const old = volume.readFileSync(file.path);
-      const start = file.flags.startsWith("a") ? old.length : position ?? file.position;
+      const start = position ?? file.position;
       const next = new Uint8Array(Math.max(old.length, start + chunk.length));
       next.set(old);
       next.set(chunk, start);
@@ -30903,41 +32331,22 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
       if (position == null) file.position = start + chunk.length;
       return chunk.length;
     },
-    createReadStream: (path, options) => {
-      const target = abs(path);
-      const settings = typeof options === "string" ? { encoding: options } : options ?? {};
-      const whole = Buffer2.from(volume.readFileSync(resolveLinks(volume, target)));
-      const start = settings.start ?? 0;
-      const end = settings.end === void 0 ? whole.length : Math.min(settings.end + 1, whole.length);
-      const slice = whole.subarray(start, Math.max(start, end));
-      const stream = import_stream_browserify4.default.Readable.from([settings.encoding ? slice.toString(settings.encoding) : slice]);
-      Object.assign(stream, { path: target, bytesRead: slice.length, close: () => stream.destroy() });
-      defer(() => {
-        stream.emit("open", 0);
-        stream.emit("ready");
-      });
-      return stream;
-    },
-    createWriteStream: (path, options) => {
-      const target = abs(path);
-      let first = true;
-      return new import_stream_browserify4.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);
-        }
-      } });
-    },
+    /* Looked up on `fs` at call time, so a package that replaces
+     * `fs.ReadStream`/`fs.WriteStream` — graceful-fs does — is honoured. */
+    createReadStream: (path, options) => new fs.ReadStream(path, options),
+    createWriteStream: (path, options) => new fs.WriteStream(path, options),
     watch: () => new FsWatcher(),
     watchFile: () => {
     },
     unwatchFile: () => {
     }
   };
+  fs.fsyncSync = (fd) => {
+    requiredFd(fds, fd);
+  };
+  fs.fdatasyncSync = (fd) => {
+    requiredFd(fds, fd);
+  };
   fs.ftruncateSync = (fd, length) => fs.truncateSync(requiredFd(fds, fd).path, length);
   fs.fchmodSync = (fd, mode) => fs.chmodSync(requiredFd(fds, fd).path, mode);
   fs.fchownSync = (fd, uid, gid) => fs.chownSync(requiredFd(fds, fd).path, uid, gid);
@@ -30979,6 +32388,264 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     };
   }
   fs.realpath.native = fs.realpath;
+  const streamSettings = (options) => typeof options === "string" ? { encoding: options } : options ?? {};
+  function WriteStream(path, options) {
+    const self2 = this;
+    if (!Object.prototype.isPrototypeOf.call(WriteStream.prototype, self2)) return new WriteStream(path, options);
+    const settings = streamSettings(options);
+    import_stream_browserify5.default.Writable.call(self2, { highWaterMark: settings.highWaterMark, emitClose: true });
+    self2.path = abs(path);
+    self2.flags = settings.flags ?? "w";
+    self2.mode = settings.mode ?? 438;
+    self2.fd = typeof settings.fd === "number" ? settings.fd : null;
+    self2.bytesWritten = 0;
+    self2.pending = true;
+    self2._opened = self2.fd !== null;
+    self2.once("open", () => {
+      self2._opened = true;
+      self2.pending = false;
+    });
+    self2.once("finish", () => {
+      if (!self2.destroyed) self2.destroy();
+    });
+    if (self2.fd === null) self2.open();
+    else defer(() => {
+      self2.emit("open", self2.fd);
+      self2.emit("ready");
+    });
+  }
+  WriteStream.prototype = Object.create(import_stream_browserify5.default.Writable.prototype, {
+    constructor: { value: WriteStream, writable: true, configurable: true }
+  });
+  WriteStream.prototype.open = function() {
+    const self2 = this;
+    try {
+      if (String(self2.flags).startsWith("a")) {
+        if (!fs.existsSync(self2.path)) volume.writeFileSync(self2.path, new Uint8Array());
+      } else volume.writeFileSync(self2.path, new Uint8Array());
+    } catch (error) {
+      defer(() => self2.destroy(error));
+      return;
+    }
+    defer(() => {
+      self2.emit("open", 0);
+      self2.emit("ready");
+    });
+  };
+  WriteStream.prototype._write = function(chunk, encoding, done) {
+    const self2 = this;
+    const append = () => {
+      try {
+        const bytes3 = typeof chunk === "string" ? Buffer2.from(chunk, encoding) : chunk;
+        volume.appendFileSync(self2.path, new Uint8Array(bytes3));
+        self2.bytesWritten += bytes3.length;
+        done();
+      } catch (error) {
+        done(error);
+      }
+    };
+    if (self2._opened) append();
+    else self2.once("open", append);
+  };
+  WriteStream.prototype.close = function(callback2) {
+    const self2 = this;
+    if (callback2) {
+      if (self2.closed) defer(() => callback2(null));
+      else {
+        self2.once("close", () => callback2(null));
+        self2.once("error", (error) => callback2(error));
+      }
+    }
+    if (!self2.writableEnded) self2.end();
+    else if (!self2.destroyed) self2.destroy();
+  };
+  function ReadStream(path, options) {
+    const self2 = this;
+    if (!Object.prototype.isPrototypeOf.call(ReadStream.prototype, self2)) return new ReadStream(path, options);
+    const settings = streamSettings(options);
+    import_stream_browserify5.default.Readable.call(self2, { highWaterMark: settings.highWaterMark, encoding: settings.encoding, emitClose: true });
+    self2.path = abs(path);
+    self2.flags = settings.flags ?? "r";
+    self2.mode = settings.mode ?? 438;
+    self2.fd = typeof settings.fd === "number" ? settings.fd : null;
+    self2.start = settings.start;
+    self2.end = settings.end;
+    self2.bytesRead = 0;
+    self2.pending = true;
+    self2._delivered = false;
+    self2.once("open", () => {
+      self2.pending = false;
+    });
+    self2.once("end", () => {
+      if (!self2.destroyed) self2.destroy();
+    });
+    if (self2.fd === null) self2.open();
+    else defer(() => {
+      self2.emit("open", self2.fd);
+      self2.emit("ready");
+    });
+  }
+  ReadStream.prototype = Object.create(import_stream_browserify5.default.Readable.prototype, {
+    constructor: { value: ReadStream, writable: true, configurable: true }
+  });
+  ReadStream.prototype.open = function() {
+    const self2 = this;
+    defer(() => {
+      self2.emit("open", 0);
+      self2.emit("ready");
+    });
+  };
+  ReadStream.prototype._read = function() {
+    const self2 = this;
+    if (self2._delivered) {
+      self2.push(null);
+      return;
+    }
+    self2._delivered = true;
+    let whole;
+    try {
+      whole = Buffer2.from(volume.readFileSync(resolveLinks(volume, self2.path)));
+    } catch (error) {
+      self2.destroy(error);
+      return;
+    }
+    const start = self2.start ?? 0;
+    const end = self2.end === void 0 ? whole.length : Math.min(self2.end + 1, whole.length);
+    const slice = whole.subarray(start, Math.max(start, end));
+    self2.bytesRead = slice.length;
+    if (slice.length) self2.push(slice);
+    self2.push(null);
+  };
+  ReadStream.prototype.close = function(callback2) {
+    const self2 = this;
+    if (callback2) {
+      if (self2.closed) defer(() => callback2(null));
+      else self2.once("close", () => callback2(null));
+    }
+    if (!self2.destroyed) self2.destroy();
+  };
+  fs.WriteStream = WriteStream;
+  fs.ReadStream = ReadStream;
+  fs.FileWriteStream = WriteStream;
+  fs.FileReadStream = ReadStream;
+  class Dir {
+    path;
+    entries;
+    closed = false;
+    constructor(path) {
+      this.path = path;
+      this.entries = fs.readdirSync(path, { withFileTypes: true });
+    }
+    assertOpen() {
+      if (this.closed) throw Object.assign(new Error("Directory handle was closed"), { code: "ERR_DIR_CLOSED" });
+    }
+    readSync() {
+      this.assertOpen();
+      return this.entries.shift() ?? null;
+    }
+    read(callback2) {
+      if (callback2) {
+        defer(() => {
+          let entry;
+          try {
+            entry = this.readSync();
+          } catch (error) {
+            callback2(error, null);
+            return;
+          }
+          callback2(null, entry);
+        });
+        return;
+      }
+      return Promise.resolve().then(() => this.readSync());
+    }
+    closeSync() {
+      this.assertOpen();
+      this.closed = true;
+    }
+    close(callback2) {
+      if (callback2) {
+        defer(() => {
+          try {
+            this.closeSync();
+          } catch (error) {
+            callback2(error);
+            return;
+          }
+          callback2(null);
+        });
+        return;
+      }
+      return Promise.resolve().then(() => this.closeSync());
+    }
+    /* Iterating a `Dir` reads it to the end and then closes it, as in Node. */
+    async *[Symbol.asyncIterator]() {
+      try {
+        for (let entry = this.readSync(); entry; entry = this.readSync()) yield entry;
+      } finally {
+        if (!this.closed) this.closeSync();
+      }
+    }
+    *entriesSync() {
+      try {
+        for (let entry = this.readSync(); entry; entry = this.readSync()) yield entry;
+      } finally {
+        if (!this.closed) this.closeSync();
+      }
+    }
+  }
+  fs.Dir = Dir;
+  fs.opendirSync = (path) => new Dir(abs(path));
+  fs.opendir = (path, options, callback2) => {
+    const done = typeof options === "function" ? options : callback2;
+    if (typeof done !== "function") throw new TypeError("callback must be a function");
+    defer(() => {
+      let dir;
+      try {
+        dir = fs.opendirSync(path);
+      } catch (error) {
+        done(error);
+        return;
+      }
+      done(null, dir);
+    });
+  };
+  const runThenCall = (work, cb) => {
+    defer(() => {
+      let result;
+      try {
+        result = work();
+      } catch (error) {
+        cb(error);
+        return;
+      }
+      cb(null, ...result);
+    });
+  };
+  fs.read = (fd, ...rest) => {
+    const cb = rest.pop();
+    if (typeof cb !== "function") throw new TypeError("callback must be a function");
+    let buffer;
+    let offset2;
+    let length;
+    let position;
+    if (ArrayBuffer.isView(rest[0])) {
+      buffer = rest[0];
+      if (rest[1] !== null && typeof rest[1] === "object") ({ offset: offset2, length, position } = rest[1]);
+      else [offset2, length, position] = [rest[1], rest[2], rest[3]];
+    } else {
+      const options = rest[0] ?? {};
+      buffer = options.buffer ?? Buffer2.alloc(16384);
+      ({ offset: offset2, length, position } = options);
+    }
+    const start = offset2 ?? 0;
+    runThenCall(() => [fs.readSync(fd, buffer, start, length ?? buffer.byteLength - start, position ?? null), buffer], cb);
+  };
+  fs.write = (fd, data2, ...rest) => {
+    const cb = rest.pop();
+    if (typeof cb !== "function") throw new TypeError("callback must be a function");
+    runThenCall(() => [fs.writeSync(fd, data2, ...rest), data2], cb);
+  };
   fs.exists = (path, cb) => {
     defer(() => cb(fs.existsSync(path)));
   };
@@ -30990,7 +32657,8 @@ function createFsModule(volume, cwd, stdinPath, defer = queueMicrotask) {
     /* The promise API hands back a FileHandle object rather than a numeric
      * descriptor, and callers use its methods instead of passing the number
      * to `fs.read`. */
-    open: async (path, flags = "r", mode) => makeFileHandle(fs, fs.openSync(path, flags, mode))
+    open: async (path, flags = "r", mode) => makeFileHandle(fs, fs.openSync(path, flags, mode)),
+    opendir: async (path) => fs.opendirSync(path)
   };
   return fs;
 }
@@ -30998,6 +32666,8 @@ function makeFileHandle(fs, fd) {
   return {
     fd,
     close: async () => fs.closeSync(fd),
+    sync: async () => fs.fsyncSync(fd),
+    datasync: async () => fs.fdatasyncSync(fd),
     stat: async () => fs.fstatSync(fd),
     truncate: async (length) => fs.ftruncateSync(fd, length),
     chmod: async (mode) => fs.fchmodSync(fd, mode),
@@ -31035,6 +32705,37 @@ function resolveLinks(volume, input) {
   }
   throw fsError("ELOOP", "realpath", input);
 }
+function createBufferBuiltin() {
+  const MAX_LENGTH = typeof Buffer2.kMaxLength === "number" ? Buffer2.kMaxLength : 2 ** 32;
+  const MAX_STRING_LENGTH = 2 ** 29 - 24;
+  const textDecoder = typeof TextDecoder === "function" ? new TextDecoder("utf-8", { fatal: true }) : void 0;
+  return {
+    Buffer: Buffer2,
+    SlowBuffer: Buffer2,
+    INSPECT_MAX_BYTES: 50,
+    kMaxLength: MAX_LENGTH,
+    kStringMaxLength: MAX_STRING_LENGTH,
+    constants: { MAX_LENGTH, MAX_STRING_LENGTH },
+    ...typeof Blob === "function" ? { Blob } : {},
+    ...typeof globalThis.File === "function" ? { File: globalThis.File } : {},
+    atob: (data2) => globalThis.atob(String(data2)),
+    btoa: (data2) => globalThis.btoa(String(data2)),
+    isUtf8: (input) => {
+      if (!textDecoder) return true;
+      try {
+        textDecoder.decode(input);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    isAscii: (input) => {
+      const bytes2 = input instanceof ArrayBuffer ? new Uint8Array(input) : new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      for (const byte of bytes2) if (byte > 127) return false;
+      return true;
+    }
+  };
+}
 function requiredFd(fds, fd) {
   const file = fds.get(fd);
   if (!file) throw fsError("EBADF", "fd", String(fd));
@@ -31044,8 +32745,8 @@ function fsError(code, syscall, path) {
   return Object.assign(new Error(`${code}: ${syscall}, '${path}'`), { code, syscall, path });
 }
 function makeOutputStream(write, fd, isTTY = false) {
-  const stream = new import_stream_browserify4.default.Writable({ write(chunk, _encoding, done) {
-    write(Buffer2.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+  const stream = new import_stream_browserify5.default.Writable({ decodeStrings: false, write(chunk, _encoding, done) {
+    write(Buffer2.isBuffer(chunk) ? new Uint8Array(chunk) : String(chunk));
     done();
   } });
   return Object.assign(stream, { fd, isTTY, columns: 80, rows: 24 });
@@ -31311,6 +33012,12 @@ function createTrackedTimers(onError = (error) => {
     }
     afterCallback();
   };
+  const hostSetTimeout = globalThis.setTimeout.bind(globalThis);
+  const hostClearTimeout = globalThis.clearTimeout.bind(globalThis);
+  const hostSetInterval = globalThis.setInterval.bind(globalThis);
+  const hostClearInterval = globalThis.clearInterval.bind(globalThis);
+  const hostSetImmediate = typeof globalThis.setImmediate === "function" ? globalThis.setImmediate.bind(globalThis) : void 0;
+  const hostClearImmediate = typeof globalThis.clearImmediate === "function" ? globalThis.clearImmediate.bind(globalThis) : hostClearTimeout;
   let scheduled = 0;
   const live = /* @__PURE__ */ new Set();
   const unrefed = /* @__PURE__ */ new Set();
@@ -31350,9 +33057,10 @@ function createTrackedTimers(onError = (error) => {
     live.delete(handle);
     unrefed.delete(handle);
   };
-  const setTimeoutTracked = (fn, delay, ...args) => {
+  const setTimeoutTracked = (callback, delay, ...args) => {
+    const fn = bindToCurrent(callback);
     let handle;
-    const native = setTimeout(
+    const native = hostSetTimeout(
       (...inner) => {
         complete(handle);
         run2(fn, inner);
@@ -31363,10 +33071,13 @@ function createTrackedTimers(onError = (error) => {
     handle = track(native);
     return handle;
   };
-  const setIntervalTracked = (fn, delay, ...args) => track(setInterval((...inner) => run2(fn, inner), delay, ...args));
-  const hostSetImmediate = globalThis.setImmediate;
-  const setImmediateTracked = (fn, ...args) => {
-    if (!hostSetImmediate) return setTimeoutTracked(fn, 0, ...args);
+  const setIntervalTracked = (callback, delay, ...args) => {
+    const fn = bindToCurrent(callback);
+    return track(hostSetInterval((...inner) => run2(fn, inner), delay, ...args));
+  };
+  const setImmediateTracked = (callback, ...args) => {
+    if (!hostSetImmediate) return setTimeoutTracked(callback, 0, ...args);
+    const fn = bindToCurrent(callback);
     let handle;
     const native = hostSetImmediate((...inner) => {
       complete(handle);
@@ -31395,15 +33106,15 @@ function createTrackedTimers(onError = (error) => {
       if (!state) continue;
       state.active = false;
       try {
-        clearTimeout(state.native);
+        hostClearTimeout(state.native);
       } catch {
       }
       try {
-        clearInterval(state.native);
+        hostClearInterval(state.native);
       } catch {
       }
       try {
-        (globalThis.clearImmediate ?? clearTimeout)(state.native);
+        hostClearImmediate(state.native);
       } catch {
       }
     }
@@ -31415,9 +33126,9 @@ function createTrackedTimers(onError = (error) => {
       setTimeout: setTimeoutTracked,
       setInterval: setIntervalTracked,
       setImmediate: setImmediateTracked,
-      clearTimeout: (handle) => clear(handle, clearTimeout),
-      clearInterval: (handle) => clear(handle, clearInterval),
-      clearImmediate: (handle) => clear(handle, globalThis.clearImmediate ?? clearTimeout)
+      clearTimeout: (handle) => clear(handle, hostClearTimeout),
+      clearInterval: (handle) => clear(handle, hostClearInterval),
+      clearImmediate: (handle) => clear(handle, hostClearImmediate)
     },
     pending: () => live.size,
     pendingUnrefed: () => unrefed.size,
@@ -31432,66 +33143,6 @@ function createTimerPromises(timers) {
   };
 }
 function createAsyncHooksModule() {
-  class AsyncResource {
-    constructor(type, _options) {
-      this.type = type;
-    }
-    type;
-    runInAsyncScope(fn, thisArg, ...args) {
-      return fn.apply(thisArg, args);
-    }
-    bind(fn, thisArg) {
-      return ((...args) => this.runInAsyncScope(fn, thisArg, ...args));
-    }
-    emitDestroy() {
-      return this;
-    }
-    asyncId() {
-      return 1;
-    }
-    triggerAsyncId() {
-      return 0;
-    }
-    static bind(fn, type = "bound-anonymous-fn", thisArg) {
-      return new AsyncResource(type).bind(fn, thisArg);
-    }
-  }
-  class AsyncLocalStorage {
-    value;
-    disable() {
-      this.value = void 0;
-    }
-    getStore() {
-      return this.value;
-    }
-    enterWith(store) {
-      this.value = store;
-    }
-    run(store, callback, ...args) {
-      const previous = this.value;
-      this.value = store;
-      try {
-        return callback(...args);
-      } finally {
-        this.value = previous;
-      }
-    }
-    exit(callback, ...args) {
-      const previous = this.value;
-      this.value = void 0;
-      try {
-        return callback(...args);
-      } finally {
-        this.value = previous;
-      }
-    }
-    static bind(fn) {
-      return fn;
-    }
-    static snapshot() {
-      return (fn, ...args) => fn(...args);
-    }
-  }
   return {
     AsyncResource,
     AsyncLocalStorage,
@@ -31509,10 +33160,10 @@ function createStreamPromises() {
   return {
     pipeline: (...streams) => new Promise((resolve2, reject) => {
       const callback = (error) => error ? reject(error) : resolve2();
-      import_stream_browserify4.default.pipeline(...streams, callback);
+      import_stream_browserify5.default.pipeline(...streams, callback);
     }),
     finished: (stream) => new Promise((resolve2, reject) => {
-      import_stream_browserify4.default.finished(stream, (error) => error ? reject(error) : resolve2());
+      import_stream_browserify5.default.finished(stream, (error) => error ? reject(error) : resolve2());
     })
   };
 }
@@ -31526,6 +33177,7 @@ function createUnsupportedModule(name, supported = {}) {
   const module = new Proxy(target, {
     get(object, key) {
       if (key === "default") return module;
+      if (key === "__esModule" || typeof key === "symbol") return object[key];
       return key in object ? object[key] : unsupported;
     }
   });
@@ -31548,10 +33200,20 @@ function createNetModule() {
     const count = groups.reduce((total, half) => total + half.length, 0);
     return halves.length === 2 ? count <= 7 : count === 8;
   };
+  let autoSelectFamily = true;
+  let autoSelectFamilyAttemptTimeout = 250;
   return createUnsupportedModule("net", {
     isIPv4,
     isIPv6,
-    isIP: (value) => isIPv4(value) ? 4 : isIPv6(value) ? 6 : 0
+    isIP: (value) => isIPv4(value) ? 4 : isIPv6(value) ? 6 : 0,
+    getDefaultAutoSelectFamily: () => autoSelectFamily,
+    setDefaultAutoSelectFamily: (value) => {
+      autoSelectFamily = Boolean(value);
+    },
+    getDefaultAutoSelectFamilyAttemptTimeout: () => autoSelectFamilyAttemptTimeout,
+    setDefaultAutoSelectFamilyAttemptTimeout: (value) => {
+      autoSelectFamilyAttemptTimeout = Math.max(10, Number(value) || 250);
+    }
   });
 }
 function parseTestSettings(raw) {
@@ -31591,7 +33253,7 @@ function formatUncaught(error) {
 Node.js v22.12.0
 `;
 }
-var stubNames = ["cluster", "dgram", "diagnostics_channel", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
+var stubNames = ["cluster", "dgram", "domain", "http2", "inspector", "net", "tls", "v8", "vm", "worker_threads"];
 var builtinNames = [
   "assert",
   "assert/strict",
@@ -31604,6 +33266,7 @@ var builtinNames = [
   "events",
   "fs",
   "fs/promises",
+  "diagnostics_channel",
   "dns",
   "dns/promises",
   "http",
@@ -31619,6 +33282,7 @@ var builtinNames = [
   "readline",
   "readline/promises",
   "stream",
+  "stream/web",
   "stream/promises",
   "string_decoder",
   "timers",
@@ -31767,10 +33431,10 @@ function spawnSyncOverChannel(channel, request) {
 
 // src/node/global-process.ts
 var import_browser2 = __toESM(require_browser2());
-var installed = false;
+var installed2 = false;
 function ensureProcessGlobal() {
-  if (installed) return;
-  installed = true;
+  if (installed2) return;
+  installed2 = true;
   if (typeof globalThis.process !== "undefined") return;
   Object.defineProperty(globalThis, "process", {
     value: import_browser2.default,
@@ -31816,6 +33480,7 @@ async function main() {
   port.postMessage({ type: "sandboxedjs:ready" });
 }
 async function run(port, start) {
+  installPromiseContext();
   const channel = new SyncChannelClient(start.buffers, () => port.postMessage({ type: "wake" }));
   const volume = new RemoteVolume(channel);
   const router = new VirtualHttpRouter();
@@ -31846,6 +33511,7 @@ async function run(port, start) {
     /* Asynchronous children are the host's business: it owns the process table
      * and the PATH. Both forms end up in the same place, one blocking. */
     spawnChild: (config) => hostChildProcess(port, config),
+    ipc: hostIpcOverPort(port),
     syncSpawn: (request) => spawnSyncOverChannel(channel, request),
     ...start.stdinPath ? { stdinPath: start.stdinPath } : {},
     ...start.interactiveStdin ? { interactiveStdin: true } : {},
@@ -31879,7 +33545,7 @@ async function run(port, start) {
   };
   port.onMessage((message) => {
     if (message?.type === "wake") return;
-    if (message?.type === "stdin") core.writeStdin(String(message.data));
+    if (message?.type === "stdin") core.writeStdin(message.data instanceof Uint8Array ? message.data : String(message.data));
     if (message?.type === "stdin-end") core.endStdin();
     if (message?.type === "kill") {
       core.cancelTimers();
@@ -31998,6 +33664,12 @@ function hostChildProcess(port, config) {
     endStdin() {
       port.postMessage({ type: "child-stdin-end", id });
     },
+    writeFd(fd, data2) {
+      port.postMessage({ type: "child-fd", id, fd, data: data2 });
+    },
+    endFd(fd) {
+      port.postMessage({ type: "child-fd-end", id, fd });
+    },
     kill(signal = "SIGTERM") {
       port.postMessage({ type: "child-kill", id, signal });
     }
@@ -32012,6 +33684,32 @@ function hostChildProcess(port, config) {
   });
   return handle;
 }
+function hostIpcOverPort(port) {
+  const ends = /* @__PURE__ */ new Map();
+  port.onMessage((message) => {
+    if (message?.type !== "ipc-message" && message?.type !== "ipc-disconnect") return;
+    const end = ends.get(`${message.side}:${message.id}`);
+    if (!end) return;
+    if (message.type === "ipc-message") end.message(message.value);
+    else {
+      ends.delete(`${message.side}:${message.id}`);
+      end.disconnect();
+    }
+  });
+  return {
+    attach(id, side, onMessage, onDisconnect) {
+      ends.set(`${side}:${id}`, { message: onMessage, disconnect: onDisconnect });
+      port.postMessage({ type: "ipc-attach", id, side });
+      return {
+        send: (value) => port.postMessage({ type: "ipc-send", id, side, value: value === void 0 ? void 0 : JSON.parse(JSON.stringify(value)) }),
+        disconnect: () => {
+          ends.delete(`${side}:${id}`);
+          port.postMessage({ type: "ipc-close", id, side });
+        }
+      };
+    }
+  };
+}
 function formatError(error) {
   if (error instanceof Error) return `${error.stack ?? `${error.name}: ${error.message}`}
 `;