sandboxedjs 0.1.83 → 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);
@@ -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);
@@ -19169,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);
@@ -21484,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;
@@ -21519,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;
@@ -21630,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`);
@@ -21724,6 +21979,19 @@ var CommonJsEngine = class {
       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);
@@ -21842,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;
@@ -21850,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],
@@ -22227,10 +22499,173 @@ function newIpcChannelId() {
   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;
@@ -22261,7 +22696,247 @@ 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/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 readable = new Readable({
+      ...options,
+      read() {
+        if (reading) return;
+        reading = true;
+        void (async () => {
+          try {
+            for (; ; ) {
+              const { done, value } = await reader.read();
+              if (done) {
+                readable.push(null);
+                return;
+              }
+              const chunk = value instanceof Uint8Array && !options.objectMode ? Buffer2.from(value.buffer, value.byteOffset, value.byteLength) : value;
+              if (!readable.push(chunk)) return;
+            }
+          } catch (error) {
+            readable.destroy(toError(error));
+          } finally {
+            reading = false;
+          }
+        })();
+      },
+      destroy(error, callback) {
+        reader.cancel(error ?? void 0).catch(() => {
+        }).finally(() => callback(error));
+      }
+    });
+    return readable;
+  };
+  const writableToWeb = (sink) => new WritableStream({
+    write(chunk) {
+      return new Promise((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);
+        }
+      });
+    },
+    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) {
@@ -22308,8 +22983,8 @@ function createReadableFrom(Readable) {
     return stream;
   };
 }
-function installReadableFrom(streamModule5) {
-  streamModule5.Readable.from = createReadableFrom(streamModule5.Readable);
+function installReadableFrom(streamModule6) {
+  streamModule6.Readable.from = createReadableFrom(streamModule6.Readable);
 }
 
 // src/node/env.ts
@@ -22950,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");
@@ -22975,7 +23650,7 @@ async function doesNotReject(block, expected, message) {
   }
   throw error;
 }
-function capture(block) {
+function capture2(block) {
   try {
     block();
     return [void 0, false];
@@ -23036,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;
@@ -25252,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};
@@ -27218,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;
@@ -27253,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) {
@@ -27294,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"),
@@ -27415,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) {
@@ -27489,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;
@@ -27529,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;
@@ -27555,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);
@@ -27573,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;
@@ -27603,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() {
@@ -27614,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";
@@ -27819,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;
@@ -27886,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;
@@ -28116,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) {
@@ -28123,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 = {};
@@ -28163,10 +29023,44 @@ 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" });
 }
@@ -28260,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);
@@ -28285,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;
         }
       }
     });
@@ -28304,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();
     }
   };
 }
@@ -29806,25 +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 {
   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"));
@@ -29841,6 +30735,11 @@ 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));
@@ -29853,8 +30752,8 @@ var ChildProcess = class extends import_events2.default {
     }
   }
   referenceChanged;
-  stdout = new import_stream_browserify3.default.PassThrough();
-  stderr = new import_stream_browserify3.default.PassThrough();
+  stdout = new import_stream_browserify4.default.PassThrough();
+  stderr = new import_stream_browserify4.default.PassThrough();
   stdin;
   stdio;
   pid;
@@ -29866,6 +30765,35 @@ var ChildProcess = class extends import_events2.default {
   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();
+      }
+    });
+  }
   kill(signal = "SIGTERM") {
     this.killed = true;
     this.handle.kill(typeof signal === "number" ? "SIGTERM" : signal);
@@ -29932,6 +30860,14 @@ var ChildProcess = class extends import_events2.default {
     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));
   }
@@ -29948,18 +30884,21 @@ function createChildProcessModule(spawnChild, defaultCwd, syncSpawn, defaultEnv
     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: 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 } : {}
+      ...stdinIgnored(options) ? { stdinIgnored: true } : {},
+      ...extraPipes.length ? { extraPipes } : {}
     });
-    const child = new ChildProcess(handle, resolved.file, resolved.args, lifecycle.referenceChanged);
+    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()));
@@ -30545,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 = "") {
@@ -30730,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);
@@ -30802,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, {
@@ -30953,7 +31894,7 @@ function createCoreModules(options) {
   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,
@@ -30977,7 +31918,7 @@ 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",
@@ -31001,7 +31942,7 @@ function createCoreModules(options) {
     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 ?? {},
@@ -31039,6 +31980,7 @@ function createCoreModules(options) {
     isMarkedAsUntransferable: () => false
   };
   builtins.net = createNetModule();
+  builtins.vm = vm_module_default;
   builtins.inspector = createUnsupportedModule("inspector", {
     url: () => void 0,
     close: () => {
@@ -31084,13 +32026,16 @@ function createCoreModules(options) {
     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, {
@@ -31135,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();
@@ -31358,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);
@@ -31369,35 +32331,10 @@ 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: () => {
     },
@@ -31451,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)));
   };
@@ -31462,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;
 }
@@ -31509,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));
@@ -31518,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 });
@@ -31785,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();
@@ -31824,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);
@@ -31837,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);
@@ -31869,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 {
       }
     }
@@ -31889,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,
@@ -31906,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,
@@ -31983,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());
     })
   };
 }
@@ -32000,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;
     }
   });
@@ -32022,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) {
@@ -32243,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,
@@ -32292,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();
@@ -32356,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();
@@ -32475,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 });
     }