@secure-exec/nodejs 0.2.0-rc.1 → 0.2.0-rc.2

package/dist/bridge.js

@@ -31,373 +31,6 @@ var bridge = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // ../../node_modules/.pnpm/text-encoding-utf-8@1.0.2/node_modules/text-encoding-utf-8/lib/encoding.lib.js
-  var require_encoding_lib = __commonJS({
-    "../../node_modules/.pnpm/text-encoding-utf-8@1.0.2/node_modules/text-encoding-utf-8/lib/encoding.lib.js"(exports) {
-      "use strict";
-      function inRange(a, min, max) {
-        return min <= a && a <= max;
-      }
-      function ToDictionary(o) {
-        if (o === void 0) return {};
-        if (o === Object(o)) return o;
-        throw TypeError("Could not convert argument to dictionary");
-      }
-      function stringToCodePoints(string) {
-        var s = String(string);
-        var n = s.length;
-        var i = 0;
-        var u = [];
-        while (i < n) {
-          var c = s.charCodeAt(i);
-          if (c < 55296 || c > 57343) {
-            u.push(c);
-          } else if (56320 <= c && c <= 57343) {
-            u.push(65533);
-          } else if (55296 <= c && c <= 56319) {
-            if (i === n - 1) {
-              u.push(65533);
-            } else {
-              var d = string.charCodeAt(i + 1);
-              if (56320 <= d && d <= 57343) {
-                var a = c & 1023;
-                var b = d & 1023;
-                u.push(65536 + (a << 10) + b);
-                i += 1;
-              } else {
-                u.push(65533);
-              }
-            }
-          }
-          i += 1;
-        }
-        return u;
-      }
-      function codePointsToString(code_points) {
-        var s = "";
-        for (var i = 0; i < code_points.length; ++i) {
-          var cp = code_points[i];
-          if (cp <= 65535) {
-            s += String.fromCharCode(cp);
-          } else {
-            cp -= 65536;
-            s += String.fromCharCode(
-              (cp >> 10) + 55296,
-              (cp & 1023) + 56320
-            );
-          }
-        }
-        return s;
-      }
-      var end_of_stream = -1;
-      function Stream(tokens) {
-        this.tokens = [].slice.call(tokens);
-      }
-      Stream.prototype = {
-        /**
-         * @return {boolean} True if end-of-stream has been hit.
-         */
-        endOfStream: function() {
-          return !this.tokens.length;
-        },
-        /**
-         * When a token is read from a stream, the first token in the
-         * stream must be returned and subsequently removed, and
-         * end-of-stream must be returned otherwise.
-         *
-         * @return {number} Get the next token from the stream, or
-         * end_of_stream.
-         */
-        read: function() {
-          if (!this.tokens.length)
-            return end_of_stream;
-          return this.tokens.shift();
-        },
-        /**
-         * When one or more tokens are prepended to a stream, those tokens
-         * must be inserted, in given order, before the first token in the
-         * stream.
-         *
-         * @param {(number|!Array.<number>)} token The token(s) to prepend to the stream.
-         */
-        prepend: function(token) {
-          if (Array.isArray(token)) {
-            var tokens = (
-              /**@type {!Array.<number>}*/
-              token
-            );
-            while (tokens.length)
-              this.tokens.unshift(tokens.pop());
-          } else {
-            this.tokens.unshift(token);
-          }
-        },
-        /**
-         * When one or more tokens are pushed to a stream, those tokens
-         * must be inserted, in given order, after the last token in the
-         * stream.
-         *
-         * @param {(number|!Array.<number>)} token The tokens(s) to prepend to the stream.
-         */
-        push: function(token) {
-          if (Array.isArray(token)) {
-            var tokens = (
-              /**@type {!Array.<number>}*/
-              token
-            );
-            while (tokens.length)
-              this.tokens.push(tokens.shift());
-          } else {
-            this.tokens.push(token);
-          }
-        }
-      };
-      var finished = -1;
-      function decoderError(fatal, opt_code_point) {
-        if (fatal)
-          throw TypeError("Decoder error");
-        return opt_code_point || 65533;
-      }
-      var DEFAULT_ENCODING = "utf-8";
-      function TextDecoder3(encoding, options) {
-        if (!(this instanceof TextDecoder3)) {
-          return new TextDecoder3(encoding, options);
-        }
-        encoding = encoding !== void 0 ? String(encoding).toLowerCase() : DEFAULT_ENCODING;
-        if (encoding !== DEFAULT_ENCODING) {
-          throw new Error("Encoding not supported. Only utf-8 is supported");
-        }
-        options = ToDictionary(options);
-        this._streaming = false;
-        this._BOMseen = false;
-        this._decoder = null;
-        this._fatal = Boolean(options["fatal"]);
-        this._ignoreBOM = Boolean(options["ignoreBOM"]);
-        Object.defineProperty(this, "encoding", { value: "utf-8" });
-        Object.defineProperty(this, "fatal", { value: this._fatal });
-        Object.defineProperty(this, "ignoreBOM", { value: this._ignoreBOM });
-      }
-      TextDecoder3.prototype = {
-        /**
-         * @param {ArrayBufferView=} input The buffer of bytes to decode.
-         * @param {Object=} options
-         * @return {string} The decoded string.
-         */
-        decode: function decode(input, options) {
-          var bytes;
-          if (typeof input === "object" && input instanceof ArrayBuffer) {
-            bytes = new Uint8Array(input);
-          } else if (typeof input === "object" && "buffer" in input && input.buffer instanceof ArrayBuffer) {
-            bytes = new Uint8Array(
-              input.buffer,
-              input.byteOffset,
-              input.byteLength
-            );
-          } else {
-            bytes = new Uint8Array(0);
-          }
-          options = ToDictionary(options);
-          if (!this._streaming) {
-            this._decoder = new UTF8Decoder({ fatal: this._fatal });
-            this._BOMseen = false;
-          }
-          this._streaming = Boolean(options["stream"]);
-          var input_stream = new Stream(bytes);
-          var code_points = [];
-          var result;
-          while (!input_stream.endOfStream()) {
-            result = this._decoder.handler(input_stream, input_stream.read());
-            if (result === finished)
-              break;
-            if (result === null)
-              continue;
-            if (Array.isArray(result))
-              code_points.push.apply(
-                code_points,
-                /**@type {!Array.<number>}*/
-                result
-              );
-            else
-              code_points.push(result);
-          }
-          if (!this._streaming) {
-            do {
-              result = this._decoder.handler(input_stream, input_stream.read());
-              if (result === finished)
-                break;
-              if (result === null)
-                continue;
-              if (Array.isArray(result))
-                code_points.push.apply(
-                  code_points,
-                  /**@type {!Array.<number>}*/
-                  result
-                );
-              else
-                code_points.push(result);
-            } while (!input_stream.endOfStream());
-            this._decoder = null;
-          }
-          if (code_points.length) {
-            if (["utf-8"].indexOf(this.encoding) !== -1 && !this._ignoreBOM && !this._BOMseen) {
-              if (code_points[0] === 65279) {
-                this._BOMseen = true;
-                code_points.shift();
-              } else {
-                this._BOMseen = true;
-              }
-            }
-          }
-          return codePointsToString(code_points);
-        }
-      };
-      function TextEncoder3(encoding, options) {
-        if (!(this instanceof TextEncoder3))
-          return new TextEncoder3(encoding, options);
-        encoding = encoding !== void 0 ? String(encoding).toLowerCase() : DEFAULT_ENCODING;
-        if (encoding !== DEFAULT_ENCODING) {
-          throw new Error("Encoding not supported. Only utf-8 is supported");
-        }
-        options = ToDictionary(options);
-        this._streaming = false;
-        this._encoder = null;
-        this._options = { fatal: Boolean(options["fatal"]) };
-        Object.defineProperty(this, "encoding", { value: "utf-8" });
-      }
-      TextEncoder3.prototype = {
-        /**
-         * @param {string=} opt_string The string to encode.
-         * @param {Object=} options
-         * @return {Uint8Array} Encoded bytes, as a Uint8Array.
-         */
-        encode: function encode(opt_string, options) {
-          opt_string = opt_string ? String(opt_string) : "";
-          options = ToDictionary(options);
-          if (!this._streaming)
-            this._encoder = new UTF8Encoder(this._options);
-          this._streaming = Boolean(options["stream"]);
-          var bytes = [];
-          var input_stream = new Stream(stringToCodePoints(opt_string));
-          var result;
-          while (!input_stream.endOfStream()) {
-            result = this._encoder.handler(input_stream, input_stream.read());
-            if (result === finished)
-              break;
-            if (Array.isArray(result))
-              bytes.push.apply(
-                bytes,
-                /**@type {!Array.<number>}*/
-                result
-              );
-            else
-              bytes.push(result);
-          }
-          if (!this._streaming) {
-            while (true) {
-              result = this._encoder.handler(input_stream, input_stream.read());
-              if (result === finished)
-                break;
-              if (Array.isArray(result))
-                bytes.push.apply(
-                  bytes,
-                  /**@type {!Array.<number>}*/
-                  result
-                );
-              else
-                bytes.push(result);
-            }
-            this._encoder = null;
-          }
-          return new Uint8Array(bytes);
-        }
-      };
-      function UTF8Decoder(options) {
-        var fatal = options.fatal;
-        var utf8_code_point = 0, utf8_bytes_seen = 0, utf8_bytes_needed = 0, utf8_lower_boundary = 128, utf8_upper_boundary = 191;
-        this.handler = function(stream, bite) {
-          if (bite === end_of_stream && utf8_bytes_needed !== 0) {
-            utf8_bytes_needed = 0;
-            return decoderError(fatal);
-          }
-          if (bite === end_of_stream)
-            return finished;
-          if (utf8_bytes_needed === 0) {
-            if (inRange(bite, 0, 127)) {
-              return bite;
-            }
-            if (inRange(bite, 194, 223)) {
-              utf8_bytes_needed = 1;
-              utf8_code_point = bite - 192;
-            } else if (inRange(bite, 224, 239)) {
-              if (bite === 224)
-                utf8_lower_boundary = 160;
-              if (bite === 237)
-                utf8_upper_boundary = 159;
-              utf8_bytes_needed = 2;
-              utf8_code_point = bite - 224;
-            } else if (inRange(bite, 240, 244)) {
-              if (bite === 240)
-                utf8_lower_boundary = 144;
-              if (bite === 244)
-                utf8_upper_boundary = 143;
-              utf8_bytes_needed = 3;
-              utf8_code_point = bite - 240;
-            } else {
-              return decoderError(fatal);
-            }
-            utf8_code_point = utf8_code_point << 6 * utf8_bytes_needed;
-            return null;
-          }
-          if (!inRange(bite, utf8_lower_boundary, utf8_upper_boundary)) {
-            utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
-            utf8_lower_boundary = 128;
-            utf8_upper_boundary = 191;
-            stream.prepend(bite);
-            return decoderError(fatal);
-          }
-          utf8_lower_boundary = 128;
-          utf8_upper_boundary = 191;
-          utf8_bytes_seen += 1;
-          utf8_code_point += bite - 128 << 6 * (utf8_bytes_needed - utf8_bytes_seen);
-          if (utf8_bytes_seen !== utf8_bytes_needed)
-            return null;
-          var code_point = utf8_code_point;
-          utf8_code_point = utf8_bytes_needed = utf8_bytes_seen = 0;
-          return code_point;
-        };
-      }
-      function UTF8Encoder(options) {
-        var fatal = options.fatal;
-        this.handler = function(stream, code_point) {
-          if (code_point === end_of_stream)
-            return finished;
-          if (inRange(code_point, 0, 127))
-            return code_point;
-          var count, offset;
-          if (inRange(code_point, 128, 2047)) {
-            count = 1;
-            offset = 192;
-          } else if (inRange(code_point, 2048, 65535)) {
-            count = 2;
-            offset = 224;
-          } else if (inRange(code_point, 65536, 1114111)) {
-            count = 3;
-            offset = 240;
-          }
-          var bytes = [(code_point >> 6 * count) + offset];
-          while (count > 0) {
-            var temp = code_point >> 6 * (count - 1);
-            bytes.push(128 | temp & 63);
-            count -= 1;
-          }
-          return bytes;
-        };
-      }
-      exports.TextEncoder = TextEncoder3;
-      exports.TextDecoder = TextDecoder3;
-    }
-  });
-
   // ../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
   var require_base64_js = __commonJS({
     "../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
@@ -5841,6 +5474,9 @@ var bridge = (() => {
   var index_exports = {};
   __export(index_exports, {
     Buffer: () => Buffer3,
+    CustomEvent: () => CustomEvent,
+    Event: () => Event,
+    EventTarget: () => EventTarget,
     Module: () => Module,
     ProcessExitError: () => ProcessExitError,
     SourceMap: () => SourceMap,
@@ -5871,7 +5507,118 @@ var bridge = (() => {
   });
 
   // src/bridge/polyfills.ts
-  var import_text_encoding_utf_8 = __toESM(require_encoding_lib(), 1);
+  function defineGlobal(name, value) {
+    globalThis[name] = value;
+  }
+  if (typeof globalThis.global === "undefined") {
+    defineGlobal("global", globalThis);
+  }
+  if (typeof globalThis.RegExp === "function" && !("__secureExecRgiEmojiCompat" in globalThis.RegExp)) {
+    const NativeRegExp = globalThis.RegExp;
+    const rgiEmojiPattern = "^\\p{RGI_Emoji}$";
+    const rgiEmojiBaseClass = "[\\u{00A9}\\u{00AE}\\u{203C}\\u{2049}\\u{2122}\\u{2139}\\u{2194}-\\u{21AA}\\u{231A}-\\u{23FF}\\u{24C2}\\u{25AA}-\\u{27BF}\\u{2934}-\\u{2935}\\u{2B05}-\\u{2B55}\\u{3030}\\u{303D}\\u{3297}\\u{3299}\\u{1F000}-\\u{1FAFF}]";
+    const rgiEmojiKeycap = "[#*0-9]\\uFE0F?\\u20E3";
+    const rgiEmojiFallbackSource = "^(?:" + rgiEmojiKeycap + "|\\p{Regional_Indicator}{2}|" + rgiEmojiBaseClass + "(?:\\uFE0F|\\u200D(?:" + rgiEmojiKeycap + "|" + rgiEmojiBaseClass + ")|[\\u{1F3FB}-\\u{1F3FF}])*)$";
+    try {
+      new NativeRegExp(rgiEmojiPattern, "v");
+    } catch (error) {
+      if (String(error?.message ?? error).includes("RGI_Emoji")) {
+        const CompatRegExp = function CompatRegExp2(pattern, flags) {
+          const normalizedPattern = pattern instanceof NativeRegExp && flags === void 0 ? pattern.source : String(pattern);
+          const normalizedFlags = flags === void 0 ? pattern instanceof NativeRegExp ? pattern.flags : "" : String(flags);
+          try {
+            return new NativeRegExp(pattern, flags);
+          } catch (innerError) {
+            if (normalizedPattern === rgiEmojiPattern && normalizedFlags === "v") {
+              return new NativeRegExp(rgiEmojiFallbackSource, "u");
+            }
+            throw innerError;
+          }
+        };
+        Object.setPrototypeOf(CompatRegExp, NativeRegExp);
+        CompatRegExp.prototype = NativeRegExp.prototype;
+        Object.defineProperty(CompatRegExp.prototype, "constructor", {
+          value: CompatRegExp,
+          writable: true,
+          configurable: true
+        });
+        defineGlobal(
+          "RegExp",
+          Object.assign(CompatRegExp, { __secureExecRgiEmojiCompat: true })
+        );
+      }
+    }
+  }
+  function withCode(error, code) {
+    error.code = code;
+    return error;
+  }
+  function createEncodingNotSupportedError(label) {
+    return withCode(
+      new RangeError(`The "${label}" encoding is not supported`),
+      "ERR_ENCODING_NOT_SUPPORTED"
+    );
+  }
+  function createEncodingInvalidDataError(encoding) {
+    return withCode(
+      new TypeError(`The encoded data was not valid for encoding ${encoding}`),
+      "ERR_ENCODING_INVALID_ENCODED_DATA"
+    );
+  }
+  function createInvalidDecodeInputError() {
+    return withCode(
+      new TypeError(
+        'The "input" argument must be an instance of ArrayBuffer, SharedArrayBuffer, or ArrayBufferView.'
+      ),
+      "ERR_INVALID_ARG_TYPE"
+    );
+  }
+  function trimAsciiWhitespace(value) {
+    return value.replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+  }
+  function normalizeEncodingLabel(label) {
+    const normalized = trimAsciiWhitespace(
+      label === void 0 ? "utf-8" : String(label)
+    ).toLowerCase();
+    switch (normalized) {
+      case "utf-8":
+      case "utf8":
+      case "unicode-1-1-utf-8":
+      case "unicode11utf8":
+      case "unicode20utf8":
+      case "x-unicode20utf8":
+        return "utf-8";
+      case "utf-16":
+      case "utf-16le":
+      case "ucs-2":
+      case "ucs2":
+      case "csunicode":
+      case "iso-10646-ucs-2":
+      case "unicode":
+      case "unicodefeff":
+        return "utf-16le";
+      case "utf-16be":
+      case "unicodefffe":
+        return "utf-16be";
+      default:
+        throw createEncodingNotSupportedError(normalized);
+    }
+  }
+  function toUint8Array(input) {
+    if (input === void 0) {
+      return new Uint8Array(0);
+    }
+    if (ArrayBuffer.isView(input)) {
+      return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    }
+    if (input instanceof ArrayBuffer) {
+      return new Uint8Array(input);
+    }
+    if (typeof SharedArrayBuffer !== "undefined" && input instanceof SharedArrayBuffer) {
+      return new Uint8Array(input);
+    }
+    throw createInvalidDecodeInputError();
+  }
   function encodeUtf8ScalarValue(codePoint, bytes) {
     if (codePoint <= 127) {
       bytes.push(codePoint);
@@ -5923,22 +5670,514 @@ var bridge = (() => {
     }
     return new Uint8Array(bytes);
   }
+  function appendCodePoint(output, codePoint) {
+    if (codePoint <= 65535) {
+      output.push(String.fromCharCode(codePoint));
+      return;
+    }
+    const adjusted = codePoint - 65536;
+    output.push(
+      String.fromCharCode(55296 + (adjusted >> 10)),
+      String.fromCharCode(56320 + (adjusted & 1023))
+    );
+  }
+  function isContinuationByte(value) {
+    return value >= 128 && value <= 191;
+  }
+  function decodeUtf8(bytes, fatal, stream, encoding) {
+    const output = [];
+    for (let index = 0; index < bytes.length; ) {
+      const first = bytes[index];
+      if (first <= 127) {
+        output.push(String.fromCharCode(first));
+        index += 1;
+        continue;
+      }
+      let needed = 0;
+      let codePoint = 0;
+      if (first >= 194 && first <= 223) {
+        needed = 1;
+        codePoint = first & 31;
+      } else if (first >= 224 && first <= 239) {
+        needed = 2;
+        codePoint = first & 15;
+      } else if (first >= 240 && first <= 244) {
+        needed = 3;
+        codePoint = first & 7;
+      } else {
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        index += 1;
+        continue;
+      }
+      if (index + needed >= bytes.length) {
+        if (stream) {
+          return {
+            text: output.join(""),
+            pending: Array.from(bytes.slice(index))
+          };
+        }
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        break;
+      }
+      const second = bytes[index + 1];
+      if (!isContinuationByte(second)) {
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        index += 1;
+        continue;
+      }
+      if (first === 224 && second < 160 || first === 237 && second > 159 || first === 240 && second < 144 || first === 244 && second > 143) {
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        index += 1;
+        continue;
+      }
+      codePoint = codePoint << 6 | second & 63;
+      if (needed >= 2) {
+        const third = bytes[index + 2];
+        if (!isContinuationByte(third)) {
+          if (fatal) {
+            throw createEncodingInvalidDataError(encoding);
+          }
+          output.push("\uFFFD");
+          index += 1;
+          continue;
+        }
+        codePoint = codePoint << 6 | third & 63;
+      }
+      if (needed === 3) {
+        const fourth = bytes[index + 3];
+        if (!isContinuationByte(fourth)) {
+          if (fatal) {
+            throw createEncodingInvalidDataError(encoding);
+          }
+          output.push("\uFFFD");
+          index += 1;
+          continue;
+        }
+        codePoint = codePoint << 6 | fourth & 63;
+      }
+      if (codePoint >= 55296 && codePoint <= 57343) {
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        index += needed + 1;
+        continue;
+      }
+      appendCodePoint(output, codePoint);
+      index += needed + 1;
+    }
+    return { text: output.join(""), pending: [] };
+  }
+  function decodeUtf16(bytes, encoding, fatal, stream, bomSeen) {
+    const output = [];
+    let endian = encoding === "utf-16be" ? "be" : "le";
+    if (!bomSeen && encoding === "utf-16le" && bytes.length >= 2) {
+      if (bytes[0] === 254 && bytes[1] === 255) {
+        endian = "be";
+      }
+    }
+    for (let index = 0; index < bytes.length; ) {
+      if (index + 1 >= bytes.length) {
+        if (stream) {
+          return {
+            text: output.join(""),
+            pending: Array.from(bytes.slice(index))
+          };
+        }
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        break;
+      }
+      const first = bytes[index];
+      const second = bytes[index + 1];
+      const codeUnit = endian === "le" ? first | second << 8 : first << 8 | second;
+      index += 2;
+      if (codeUnit >= 55296 && codeUnit <= 56319) {
+        if (index + 1 >= bytes.length) {
+          if (stream) {
+            return {
+              text: output.join(""),
+              pending: Array.from(bytes.slice(index - 2))
+            };
+          }
+          if (fatal) {
+            throw createEncodingInvalidDataError(encoding);
+          }
+          output.push("\uFFFD");
+          continue;
+        }
+        const nextFirst = bytes[index];
+        const nextSecond = bytes[index + 1];
+        const nextCodeUnit = endian === "le" ? nextFirst | nextSecond << 8 : nextFirst << 8 | nextSecond;
+        if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
+          const codePoint = 65536 + (codeUnit - 55296 << 10) + (nextCodeUnit - 56320);
+          appendCodePoint(output, codePoint);
+          index += 2;
+          continue;
+        }
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        continue;
+      }
+      if (codeUnit >= 56320 && codeUnit <= 57343) {
+        if (fatal) {
+          throw createEncodingInvalidDataError(encoding);
+        }
+        output.push("\uFFFD");
+        continue;
+      }
+      output.push(String.fromCharCode(codeUnit));
+    }
+    return { text: output.join(""), pending: [] };
+  }
   var PatchedTextEncoder = class {
     encode(input = "") {
       return encodeUtf8(input);
     }
+    encodeInto(input, destination) {
+      const value = String(input);
+      let read = 0;
+      let written = 0;
+      for (let index = 0; index < value.length; index += 1) {
+        const codeUnit = value.charCodeAt(index);
+        let chunk = "";
+        if (codeUnit >= 55296 && codeUnit <= 56319 && index + 1 < value.length) {
+          const nextCodeUnit = value.charCodeAt(index + 1);
+          if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
+            chunk = value.slice(index, index + 2);
+          }
+        }
+        if (chunk === "") {
+          chunk = value[index] ?? "";
+        }
+        const encoded = encodeUtf8(chunk);
+        if (written + encoded.length > destination.length) {
+          break;
+        }
+        destination.set(encoded, written);
+        written += encoded.length;
+        read += chunk.length;
+        if (chunk.length === 2) {
+          index += 1;
+        }
+      }
+      return { read, written };
+    }
     get encoding() {
       return "utf-8";
     }
+    get [Symbol.toStringTag]() {
+      return "TextEncoder";
+    }
+  };
+  var PatchedTextDecoder = class {
+    normalizedEncoding;
+    fatalFlag;
+    ignoreBOMFlag;
+    pendingBytes = [];
+    bomSeen = false;
+    constructor(label, options) {
+      const normalizedOptions = options == null ? {} : Object(options);
+      this.normalizedEncoding = normalizeEncodingLabel(label);
+      this.fatalFlag = Boolean(
+        normalizedOptions.fatal
+      );
+      this.ignoreBOMFlag = Boolean(
+        normalizedOptions.ignoreBOM
+      );
+    }
+    get encoding() {
+      return this.normalizedEncoding;
+    }
+    get fatal() {
+      return this.fatalFlag;
+    }
+    get ignoreBOM() {
+      return this.ignoreBOMFlag;
+    }
+    get [Symbol.toStringTag]() {
+      return "TextDecoder";
+    }
+    decode(input, options) {
+      const normalizedOptions = options == null ? {} : Object(options);
+      const stream = Boolean(
+        normalizedOptions.stream
+      );
+      const incoming = toUint8Array(input);
+      const merged = new Uint8Array(this.pendingBytes.length + incoming.length);
+      merged.set(this.pendingBytes, 0);
+      merged.set(incoming, this.pendingBytes.length);
+      const decoded = this.normalizedEncoding === "utf-8" ? decodeUtf8(
+        merged,
+        this.fatalFlag,
+        stream,
+        this.normalizedEncoding
+      ) : decodeUtf16(
+        merged,
+        this.normalizedEncoding,
+        this.fatalFlag,
+        stream,
+        this.bomSeen
+      );
+      this.pendingBytes = decoded.pending;
+      let text = decoded.text;
+      if (!this.bomSeen && text.length > 0) {
+        if (!this.ignoreBOMFlag && text.charCodeAt(0) === 65279) {
+          text = text.slice(1);
+        }
+        this.bomSeen = true;
+      }
+      if (!stream && this.pendingBytes.length > 0) {
+        const pending = this.pendingBytes;
+        this.pendingBytes = [];
+        if (this.fatalFlag) {
+          throw createEncodingInvalidDataError(this.normalizedEncoding);
+        }
+        return text + "\uFFFD".repeat(Math.ceil(pending.length / 2));
+      }
+      return text;
+    }
   };
-  var TextEncoder2 = typeof globalThis.TextEncoder === "function" ? globalThis.TextEncoder : PatchedTextEncoder;
-  var TextDecoder2 = typeof globalThis.TextDecoder === "function" ? globalThis.TextDecoder : import_text_encoding_utf_8.TextDecoder;
-  if (typeof globalThis.TextEncoder === "undefined") {
-    globalThis.TextEncoder = TextEncoder2;
+  function normalizeAddEventListenerOptions(options) {
+    if (typeof options === "boolean") {
+      return {
+        capture: options,
+        once: false,
+        passive: false
+      };
+    }
+    if (options == null) {
+      return {
+        capture: false,
+        once: false,
+        passive: false
+      };
+    }
+    const normalized = Object(options);
+    return {
+      capture: Boolean(normalized.capture),
+      once: Boolean(normalized.once),
+      passive: Boolean(normalized.passive),
+      signal: normalized.signal
+    };
   }
-  if (typeof globalThis.TextDecoder === "undefined") {
-    globalThis.TextDecoder = TextDecoder2;
+  function normalizeRemoveEventListenerOptions(options) {
+    if (typeof options === "boolean") {
+      return options;
+    }
+    if (options == null) {
+      return false;
+    }
+    return Boolean(Object(options).capture);
+  }
+  function isAbortSignalLike(value) {
+    return typeof value === "object" && value !== null && "aborted" in value && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
   }
+  var PatchedEvent = class {
+    static NONE = 0;
+    static CAPTURING_PHASE = 1;
+    static AT_TARGET = 2;
+    static BUBBLING_PHASE = 3;
+    type;
+    bubbles;
+    cancelable;
+    composed;
+    detail = null;
+    defaultPrevented = false;
+    target = null;
+    currentTarget = null;
+    eventPhase = 0;
+    returnValue = true;
+    cancelBubble = false;
+    timeStamp = Date.now();
+    isTrusted = false;
+    srcElement = null;
+    inPassiveListener = false;
+    propagationStopped = false;
+    immediatePropagationStopped = false;
+    constructor(type, init) {
+      if (arguments.length === 0) {
+        throw new TypeError("The event type must be provided");
+      }
+      const normalizedInit = init == null ? {} : Object(init);
+      this.type = String(type);
+      this.bubbles = Boolean(normalizedInit.bubbles);
+      this.cancelable = Boolean(normalizedInit.cancelable);
+      this.composed = Boolean(normalizedInit.composed);
+    }
+    get [Symbol.toStringTag]() {
+      return "Event";
+    }
+    preventDefault() {
+      if (this.cancelable && !this.inPassiveListener) {
+        this.defaultPrevented = true;
+        this.returnValue = false;
+      }
+    }
+    stopPropagation() {
+      this.propagationStopped = true;
+      this.cancelBubble = true;
+    }
+    stopImmediatePropagation() {
+      this.propagationStopped = true;
+      this.immediatePropagationStopped = true;
+      this.cancelBubble = true;
+    }
+    composedPath() {
+      return this.target ? [this.target] : [];
+    }
+    _setPassive(value) {
+      this.inPassiveListener = value;
+    }
+    _isPropagationStopped() {
+      return this.propagationStopped;
+    }
+    _isImmediatePropagationStopped() {
+      return this.immediatePropagationStopped;
+    }
+  };
+  var PatchedCustomEvent = class extends PatchedEvent {
+    constructor(type, init) {
+      super(type, init);
+      const normalizedInit = init == null ? null : Object(init);
+      this.detail = normalizedInit && "detail" in normalizedInit ? normalizedInit.detail : null;
+    }
+    get [Symbol.toStringTag]() {
+      return "CustomEvent";
+    }
+  };
+  var PatchedEventTarget = class {
+    listeners = /* @__PURE__ */ new Map();
+    addEventListener(type, listener, options) {
+      const normalized = normalizeAddEventListenerOptions(options);
+      if (normalized.signal !== void 0 && !isAbortSignalLike(normalized.signal)) {
+        throw new TypeError(
+          'The "signal" option must be an instance of AbortSignal.'
+        );
+      }
+      if (listener == null) {
+        return void 0;
+      }
+      if (typeof listener !== "function" && (typeof listener !== "object" || listener === null)) {
+        return void 0;
+      }
+      if (normalized.signal?.aborted) {
+        return void 0;
+      }
+      const records = this.listeners.get(type) ?? [];
+      const existing = records.find(
+        (record2) => record2.listener === listener && record2.capture === normalized.capture
+      );
+      if (existing) {
+        return void 0;
+      }
+      const record = {
+        listener,
+        capture: normalized.capture,
+        once: normalized.once,
+        passive: normalized.passive,
+        kind: typeof listener === "function" ? "function" : "object",
+        signal: normalized.signal
+      };
+      if (normalized.signal) {
+        record.abortListener = () => {
+          this.removeEventListener(type, listener, normalized.capture);
+        };
+        normalized.signal.addEventListener("abort", record.abortListener, {
+          once: true
+        });
+      }
+      records.push(record);
+      this.listeners.set(type, records);
+      return void 0;
+    }
+    removeEventListener(type, listener, options) {
+      if (listener == null) {
+        return;
+      }
+      const capture = normalizeRemoveEventListenerOptions(options);
+      const records = this.listeners.get(type);
+      if (!records) {
+        return;
+      }
+      const nextRecords = records.filter((record) => {
+        const match = record.listener === listener && record.capture === capture;
+        if (match && record.signal && record.abortListener) {
+          record.signal.removeEventListener("abort", record.abortListener);
+        }
+        return !match;
+      });
+      if (nextRecords.length === 0) {
+        this.listeners.delete(type);
+        return;
+      }
+      this.listeners.set(type, nextRecords);
+    }
+    dispatchEvent(event) {
+      if (typeof event !== "object" || event === null || typeof event.type !== "string") {
+        throw new TypeError("Argument 1 must be an Event");
+      }
+      const patchedEvent = event;
+      const records = (this.listeners.get(patchedEvent.type) ?? []).slice();
+      patchedEvent.target = this;
+      patchedEvent.currentTarget = this;
+      patchedEvent.eventPhase = 2;
+      for (const record of records) {
+        const active = this.listeners.get(patchedEvent.type)?.includes(record);
+        if (!active) {
+          continue;
+        }
+        if (record.once) {
+          this.removeEventListener(patchedEvent.type, record.listener, record.capture);
+        }
+        patchedEvent._setPassive(record.passive);
+        if (record.kind === "function") {
+          record.listener.call(this, patchedEvent);
+        } else {
+          const handleEvent = record.listener.handleEvent;
+          if (typeof handleEvent === "function") {
+            handleEvent.call(record.listener, patchedEvent);
+          }
+        }
+        patchedEvent._setPassive(false);
+        if (patchedEvent._isImmediatePropagationStopped()) {
+          break;
+        }
+        if (patchedEvent._isPropagationStopped()) {
+          break;
+        }
+      }
+      patchedEvent.currentTarget = null;
+      patchedEvent.eventPhase = 0;
+      return !patchedEvent.defaultPrevented;
+    }
+  };
+  var TextEncoder2 = PatchedTextEncoder;
+  var TextDecoder2 = PatchedTextDecoder;
+  var Event = PatchedEvent;
+  var CustomEvent = PatchedCustomEvent;
+  var EventTarget = PatchedEventTarget;
+  defineGlobal("TextEncoder", TextEncoder2);
+  defineGlobal("TextDecoder", TextDecoder2);
+  defineGlobal("Event", Event);
+  defineGlobal("CustomEvent", CustomEvent);
+  defineGlobal("EventTarget", EventTarget);
 
   // ../core/dist/shared/global-exposure.js
   var NODE_CUSTOM_GLOBAL_INVENTORY = [
@@ -6422,6 +6661,11 @@ var bridge = (() => {
       classification: "hardened",
       rationale: "Host HTTP/2 session settings bridge reference."
     },
+    {
+      name: "_networkHttp2SessionSetLocalWindowSizeRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 session local-window bridge reference."
+    },
     {
       name: "_networkHttp2SessionGoawayRaw",
       classification: "hardened",
@@ -6443,24 +6687,59 @@ var bridge = (() => {
       rationale: "Host HTTP/2 session lifetime bridge reference."
     },
     {
-      name: "_networkHttp2StreamRespondRaw",
+      name: "_networkHttp2ServerPollRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 server event-poll bridge reference."
+    },
+    {
+      name: "_networkHttp2SessionPollRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 session event-poll bridge reference."
+    },
+    {
+      name: "_networkHttp2StreamRespondRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 stream respond bridge reference."
+    },
+    {
+      name: "_networkHttp2StreamPushStreamRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 push stream bridge reference."
+    },
+    {
+      name: "_networkHttp2StreamWriteRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 stream write bridge reference."
+    },
+    {
+      name: "_networkHttp2StreamEndRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 stream end bridge reference."
+    },
+    {
+      name: "_networkHttp2StreamCloseRaw",
+      classification: "hardened",
+      rationale: "Host HTTP/2 stream close bridge reference."
+    },
+    {
+      name: "_networkHttp2StreamPauseRaw",
       classification: "hardened",
-      rationale: "Host HTTP/2 stream respond bridge reference."
+      rationale: "Host HTTP/2 stream pause bridge reference."
     },
     {
-      name: "_networkHttp2StreamPushStreamRaw",
+      name: "_networkHttp2StreamResumeRaw",
       classification: "hardened",
-      rationale: "Host HTTP/2 push stream bridge reference."
+      rationale: "Host HTTP/2 stream resume bridge reference."
     },
     {
-      name: "_networkHttp2StreamWriteRaw",
+      name: "_networkHttp2StreamRespondWithFileRaw",
       classification: "hardened",
-      rationale: "Host HTTP/2 stream write bridge reference."
+      rationale: "Host HTTP/2 stream respondWithFile bridge reference."
     },
     {
-      name: "_networkHttp2StreamEndRaw",
+      name: "_networkHttp2ServerRespondRaw",
       classification: "hardened",
-      rationale: "Host HTTP/2 stream end bridge reference."
+      rationale: "Host HTTP/2 server-response bridge reference."
     },
     {
       name: "_upgradeSocketWriteRaw",
@@ -6552,6 +6831,46 @@ var bridge = (() => {
       classification: "hardened",
       rationale: "Host net server close bridge reference."
     },
+    {
+      name: "_dgramSocketCreateRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket create bridge reference."
+    },
+    {
+      name: "_dgramSocketBindRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket bind bridge reference."
+    },
+    {
+      name: "_dgramSocketRecvRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket receive bridge reference."
+    },
+    {
+      name: "_dgramSocketSendRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket send bridge reference."
+    },
+    {
+      name: "_dgramSocketCloseRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket close bridge reference."
+    },
+    {
+      name: "_dgramSocketAddressRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket address bridge reference."
+    },
+    {
+      name: "_dgramSocketSetBufferSizeRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket buffer-size setter bridge reference."
+    },
+    {
+      name: "_dgramSocketGetBufferSizeRaw",
+      classification: "hardened",
+      rationale: "Host dgram socket buffer-size getter bridge reference."
+    },
     {
       name: "_batchResolveModules",
       classification: "hardened",
@@ -6657,11 +6976,26 @@ var bridge = (() => {
       classification: "hardened",
       rationale: "Network Response API global \u2014 must not be replaceable by sandbox code."
     },
+    {
+      name: "DOMException",
+      classification: "hardened",
+      rationale: "DOMException global stub for undici/bootstrap compatibility."
+    },
+    {
+      name: "__importMetaResolve",
+      classification: "hardened",
+      rationale: "Internal import.meta.resolve helper for transformed ESM modules."
+    },
     {
       name: "Blob",
       classification: "hardened",
       rationale: "Blob API global stub \u2014 must not be replaceable by sandbox code."
     },
+    {
+      name: "File",
+      classification: "hardened",
+      rationale: "File API global stub \u2014 must not be replaceable by sandbox code."
+    },
     {
       name: "FormData",
       classification: "hardened",
@@ -7224,15 +7558,30 @@ var bridge = (() => {
     async read(buffer, offset, length, position) {
       const handle = _FileHandle._assertHandle(this);
       let target = buffer;
+      let readOffset = offset;
+      let readLength = length;
+      let readPosition = position;
+      if (target !== null && typeof target === "object" && !ArrayBuffer.isView(target)) {
+        readOffset = target.offset;
+        readLength = target.length;
+        readPosition = target.position;
+        target = target.buffer ?? null;
+      }
       if (target === null) {
         target = import_buffer.Buffer.alloc(FILE_HANDLE_READ_BUFFER_BYTES);
       }
       if (!ArrayBuffer.isView(target)) {
         throw createInvalidArgTypeError("buffer", "an instance of ArrayBufferView", target);
       }
-      const readOffset = offset ?? 0;
-      const readLength = length ?? target.byteLength - readOffset;
-      const bytesRead = fs.readSync(handle.fd, target, readOffset, readLength, position ?? null);
+      const normalizedOffset = readOffset ?? 0;
+      const normalizedLength = readLength ?? target.byteLength - normalizedOffset;
+      const bytesRead = fs.readSync(
+        handle.fd,
+        target,
+        normalizedOffset,
+        normalizedLength,
+        readPosition ?? null
+      );
       return { bytesRead, buffer: target };
     }
     async write(buffer, offsetOrPosition, lengthOrEncoding, position) {
@@ -9973,6 +10322,12 @@ var bridge = (() => {
     tmpdir: typeof _osConfig !== "undefined" && _osConfig.tmpdir || "/tmp",
     hostname: typeof _osConfig !== "undefined" && _osConfig.hostname || "sandbox"
   };
+  function getRuntimeHomeDir() {
+    return globalThis.process?.env?.HOME || config.homedir;
+  }
+  function getRuntimeTmpDir() {
+    return globalThis.process?.env?.TMPDIR || config.tmpdir;
+  }
   var signals = {
     SIGHUP: 1,
     SIGINT: 2,
@@ -10116,10 +10471,10 @@ var bridge = (() => {
     },
     // Directory information
     homedir() {
-      return config.homedir;
+      return getRuntimeHomeDir();
     },
     tmpdir() {
-      return config.tmpdir;
+      return getRuntimeTmpDir();
     },
     // System information
     hostname() {
@@ -10132,7 +10487,7 @@ var bridge = (() => {
         uid: 0,
         gid: 0,
         shell: "/bin/bash",
-        homedir: config.homedir
+        homedir: getRuntimeHomeDir()
       };
     },
     // CPU information
@@ -10225,7 +10580,7 @@ var bridge = (() => {
     spawnSync: () => spawnSync
   });
   var childProcessInstances = /* @__PURE__ */ new Map();
-  var childProcessDispatch = (sessionId, type, data) => {
+  function routeChildProcessEvent(sessionId, type, data) {
     const child = childProcessInstances.get(sessionId);
     if (!child) return;
     if (type === "stdout") {
@@ -10245,6 +10600,49 @@ var bridge = (() => {
         _unregisterHandle(`child:${sessionId}`);
       }
     }
+  }
+  var childProcessDispatch = (eventTypeOrSessionId, payloadOrType, data) => {
+    if (typeof eventTypeOrSessionId === "number") {
+      routeChildProcessEvent(
+        eventTypeOrSessionId,
+        payloadOrType,
+        data
+      );
+      return;
+    }
+    const payload = (() => {
+      if (payloadOrType && typeof payloadOrType === "object") {
+        return payloadOrType;
+      }
+      if (typeof payloadOrType === "string") {
+        try {
+          return JSON.parse(payloadOrType);
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    })();
+    const sessionId = typeof payload?.sessionId === "number" ? payload.sessionId : Number(payload?.sessionId);
+    if (!Number.isFinite(sessionId)) {
+      return;
+    }
+    if (eventTypeOrSessionId === "child_stdout" || eventTypeOrSessionId === "child_stderr") {
+      const encoded = typeof payload?.dataBase64 === "string" ? payload.dataBase64 : typeof payload?.data === "string" ? payload.data : "";
+      const bytes = typeof Buffer !== "undefined" ? Buffer.from(encoded, "base64") : new Uint8Array(
+        atob(encoded).split("").map((char) => char.charCodeAt(0))
+      );
+      routeChildProcessEvent(
+        sessionId,
+        eventTypeOrSessionId === "child_stdout" ? "stdout" : "stderr",
+        bytes
+      );
+      return;
+    }
+    if (eventTypeOrSessionId === "child_exit") {
+      const code = typeof payload?.code === "number" ? payload.code : Number(payload?.code ?? 1);
+      routeChildProcessEvent(sessionId, "exit", code);
+    }
   };
   exposeCustomGlobal("_childProcessDispatch", childProcessDispatch);
   function checkStreamMaxListeners(stream, event) {
@@ -10823,6 +11221,79 @@ var bridge = (() => {
     https: () => https
   });
   var MAX_HTTP_BODY_BYTES = 50 * 1024 * 1024;
+  var _fetchHandleCounter = 0;
+  function encodeFetchBody(body, bodyEncoding) {
+    if (bodyEncoding === "base64" && typeof Buffer !== "undefined") {
+      return new Uint8Array(Buffer.from(body, "base64"));
+    }
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(body);
+    }
+    const bytes = new Uint8Array(body.length);
+    for (let index = 0; index < body.length; index += 1) {
+      bytes[index] = body.charCodeAt(index) & 255;
+    }
+    return bytes;
+  }
+  function createFetchBodyStream(body, bodyEncoding) {
+    const ReadableStreamCtor = globalThis.ReadableStream;
+    if (typeof ReadableStreamCtor !== "function") {
+      return null;
+    }
+    const bytes = encodeFetchBody(body, bodyEncoding);
+    const handleId = typeof _registerHandle === "function" ? `fetch-body:${++_fetchHandleCounter}` : null;
+    let released = false;
+    let delivered = false;
+    const release = () => {
+      if (released || !handleId) {
+        return;
+      }
+      released = true;
+      _unregisterHandle?.(handleId);
+    };
+    if (handleId) {
+      _registerHandle?.(handleId, "fetch response body");
+    }
+    return new ReadableStreamCtor({
+      pull(controller) {
+        if (delivered) {
+          release();
+          controller.close();
+          return;
+        }
+        delivered = true;
+        controller.enqueue(bytes);
+        controller.close();
+        release();
+      },
+      cancel() {
+        release();
+      }
+    });
+  }
+  function serializeFetchHeaders(headers) {
+    if (!headers) {
+      return {};
+    }
+    if (headers instanceof Headers) {
+      return Object.fromEntries(headers.entries());
+    }
+    if (isFlatHeaderList(headers)) {
+      const normalized = {};
+      for (let index = 0; index < headers.length; index += 2) {
+        const key = headers[index];
+        const value = headers[index + 1];
+        if (key !== void 0 && value !== void 0) {
+          normalized[key] = value;
+        }
+      }
+      return normalized;
+    }
+    return Object.fromEntries(new Headers(headers).entries());
+  }
+  function createFetchHeaders(headers) {
+    return new Headers(serializeFetchHeaders(headers));
+  }
   async function fetch(input, options = {}) {
     if (typeof _networkFetchRaw === "undefined") {
       console.error("fetch requires NetworkAdapter to be configured");
@@ -10833,7 +11304,7 @@ var bridge = (() => {
       resolvedUrl = input.url;
       options = {
         method: input.method,
-        headers: Object.fromEntries(input.headers.entries()),
+        headers: serializeFetchHeaders(input.headers),
         body: input.body,
         ...options
       };
@@ -10842,37 +11313,62 @@ var bridge = (() => {
     }
     const optionsJson = JSON.stringify({
       method: options.method || "GET",
-      headers: options.headers || {},
+      headers: serializeFetchHeaders(options.headers),
       body: options.body || null
     });
-    const responseJson = await _networkFetchRaw.apply(void 0, [resolvedUrl, optionsJson], {
-      result: { promise: true }
-    });
-    const response = JSON.parse(responseJson);
-    return {
-      ok: response.ok,
-      status: response.status,
-      statusText: response.statusText,
-      headers: new Map(Object.entries(response.headers || {})),
-      url: response.url || resolvedUrl,
-      redirected: response.redirected || false,
-      type: "basic",
-      async text() {
-        return response.body || "";
-      },
-      async json() {
-        return JSON.parse(response.body || "{}");
-      },
-      async arrayBuffer() {
-        return new ArrayBuffer(0);
-      },
-      async blob() {
-        throw new Error("Blob not supported in sandbox");
-      },
-      clone() {
-        return { ...this };
+    const handleId = typeof _registerHandle === "function" ? `fetch:${++_fetchHandleCounter}` : null;
+    if (handleId) {
+      _registerHandle?.(handleId, `fetch ${resolvedUrl}`);
+    }
+    try {
+      const responseJson = await _networkFetchRaw.apply(void 0, [resolvedUrl, optionsJson], {
+        result: { promise: true }
+      });
+      const response = JSON.parse(responseJson);
+      const bodyEncoding = response.headers?.["x-body-encoding"] ?? null;
+      const responseBody = response.body ?? "";
+      let bodyStream;
+      return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Map(Object.entries(response.headers || {})),
+        url: response.url || resolvedUrl,
+        redirected: response.redirected || false,
+        type: "basic",
+        get body() {
+          if (bodyStream === void 0) {
+            bodyStream = createFetchBodyStream(responseBody, bodyEncoding);
+          }
+          return bodyStream;
+        },
+        async text() {
+          if (bodyEncoding === "base64" && typeof Buffer !== "undefined") {
+            return Buffer.from(responseBody, "base64").toString("utf8");
+          }
+          return responseBody;
+        },
+        async json() {
+          const textBody = bodyEncoding === "base64" && typeof Buffer !== "undefined" ? Buffer.from(responseBody, "base64").toString("utf8") : responseBody;
+          return JSON.parse(textBody || "{}");
+        },
+        async arrayBuffer() {
+          return Uint8Array.from(
+            encodeFetchBody(responseBody, bodyEncoding)
+          ).buffer;
+        },
+        async blob() {
+          throw new Error("Blob not supported in sandbox");
+        },
+        clone() {
+          return { ...this };
+        }
+      };
+    } finally {
+      if (handleId) {
+        _unregisterHandle?.(handleId);
       }
-    };
+    }
   }
   var Headers = class _Headers {
     _headers = {};
@@ -10941,7 +11437,9 @@ var bridge = (() => {
     constructor(input, init = {}) {
       this.url = typeof input === "string" ? input : input.url;
       this.method = init.method || (typeof input !== "string" ? input.method : void 0) || "GET";
-      this.headers = new Headers(init.headers || (typeof input !== "string" ? input.headers : void 0));
+      this.headers = createFetchHeaders(
+        init.headers || (typeof input !== "string" ? input.headers : void 0)
+      );
       this.body = init.body || null;
       this.mode = init.mode || "cors";
       this.credentials = init.credentials || "same-origin";
@@ -11531,64 +12029,7 @@ var bridge = (() => {
         }
         const normalizedHeaders = normalizeRequestHeaders(this._options.headers);
         const requestMethod = String(this._options.method || "GET").toUpperCase();
-        const loopbackServerByPort = findLoopbackServerByPort(this._options);
-        const directLoopbackConnectServer = requestMethod === "CONNECT" ? loopbackServerByPort : null;
-        const directLoopbackUpgradeServer = requestMethod !== "CONNECT" && hasUpgradeRequestHeaders(normalizedHeaders) && loopbackServerByPort?.listenerCount("upgrade") ? loopbackServerByPort : null;
-        if (directLoopbackConnectServer) {
-          const response2 = await dispatchLoopbackConnectRequest(
-            directLoopbackConnectServer,
-            this._options
-          );
-          this.finished = true;
-          this.socket = response2.socket;
-          response2.response.socket = response2.socket;
-          response2.socket.once("close", () => {
-            this._emit("close");
-          });
-          this._emit("connect", response2.response, response2.socket, response2.head);
-          process.nextTick(() => {
-            this._finalizeSocket(socket, false);
-          });
-          return;
-        }
-        if (directLoopbackUpgradeServer) {
-          const response2 = await dispatchLoopbackUpgradeRequest(
-            directLoopbackUpgradeServer,
-            this._options,
-            this._body
-          );
-          this.finished = true;
-          this.socket = response2.socket;
-          response2.response.socket = response2.socket;
-          response2.socket.once("close", () => {
-            this._emit("close");
-          });
-          this._emit("upgrade", response2.response, response2.socket, response2.head);
-          process.nextTick(() => {
-            this._finalizeSocket(socket, false);
-          });
-          return;
-        }
-        const directLoopbackServer = requestMethod !== "CONNECT" && hasUpgradeRequestHeaders(normalizedHeaders) && !directLoopbackUpgradeServer ? loopbackServerByPort : findLoopbackServerForRequest(this._options);
-        const directLoopbackHttp2CompatServer = !directLoopbackServer && requestMethod !== "CONNECT" && !hasUpgradeRequestHeaders(normalizedHeaders) ? findLoopbackHttp2CompatibilityServer(this._options) : null;
-        const serializedRequest = JSON.stringify({
-          method: requestMethod,
-          url: this._options.path || "/",
-          headers: normalizedHeaders,
-          rawHeaders: flattenRawHeaders(normalizedHeaders),
-          bodyBase64: this._body ? Buffer.from(this._body).toString("base64") : void 0
-        });
-        const loopbackResponse = directLoopbackServer ? await dispatchLoopbackServerRequest(
-          directLoopbackServer._bridgeServerId,
-          serializedRequest
-        ) : directLoopbackHttp2CompatServer ? await dispatchLoopbackHttp2CompatibilityRequest(
-          directLoopbackHttp2CompatServer,
-          serializedRequest
-        ) : null;
-        if (loopbackResponse) {
-          this._loopbackAbort = loopbackResponse.abortRequest;
-        }
-        const responseJson = loopbackResponse ? loopbackResponse.responseJson : await _networkHttpRequestRaw.apply(void 0, [url, JSON.stringify({
+        const responseJson = await _networkHttpRequestRaw.apply(void 0, [url, JSON.stringify({
           method: this._options.method || "GET",
           headers: normalizedHeaders,
           body: this._body || null,
@@ -11645,14 +12086,6 @@ var bridge = (() => {
           });
           return;
         }
-        if (response.connectionReset) {
-          const error = createConnResetError();
-          this._emit("error", error);
-          process.nextTick(() => {
-            this._finalizeSocket(socket, false);
-          });
-          return;
-        }
         for (const informational of response.informational || []) {
           this._emit("information", new IncomingMessage({
             headers: Object.fromEntries(informational.headers || []),
@@ -11667,9 +12100,6 @@ var bridge = (() => {
         res.once("end", () => {
           process.nextTick(() => {
             this._finalizeSocket(socket, this._agent?.keepAlive === true && !this.aborted);
-            if (response.connectionEnded) {
-              queueMicrotask(() => socket.end?.());
-            }
           });
         });
         if (this._callback) {
@@ -12790,19 +13220,6 @@ var bridge = (() => {
     const existing = target[key];
     target[key] = existing === void 0 ? value : `${joinHeaderValue(existing)}, ${value}`;
   }
-  function flattenRawHeaders(headers) {
-    const rawHeaders = [];
-    for (const [key, value] of Object.entries(headers)) {
-      if (Array.isArray(value)) {
-        value.forEach((entry) => {
-          rawHeaders.push(key, entry);
-        });
-        continue;
-      }
-      rawHeaders.push(key, value);
-    }
-    return rawHeaders;
-  }
   function validateRequestMethod(method) {
     if (method == null || method === "") {
       return void 0;
@@ -13260,48 +13677,6 @@ ${headerLines}\r
     const bare = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
     return bare === "localhost" || bare === "127.0.0.1" || bare === "::1";
   }
-  function findLoopbackServerForRequest(options) {
-    if (String(options.method || "GET").toUpperCase() === "CONNECT") {
-      return null;
-    }
-    return findLoopbackServerByPort(options, true);
-  }
-  function findLoopbackServerByPort(options, skipUpgradeHeaders = false) {
-    const hostname = String(options.hostname || options.host || "localhost");
-    if (!isLoopbackRequestHost(hostname)) {
-      return null;
-    }
-    const normalizedHeaders = normalizeRequestHeaders(options.headers);
-    if (skipUpgradeHeaders && hasUpgradeRequestHeaders(normalizedHeaders)) {
-      return null;
-    }
-    const port = Number(options.port) || 80;
-    for (const server of serverInstances.values()) {
-      const address = server.address();
-      if (!address) continue;
-      if (address.port === port) {
-        return server;
-      }
-    }
-    return null;
-  }
-  function findLoopbackHttp2CompatibilityServer(options) {
-    const hostname = String(options.hostname || options.host || "localhost");
-    if (!isLoopbackRequestHost(hostname)) {
-      return null;
-    }
-    const port = Number(options.port) || 443;
-    for (const server of http2Servers.values()) {
-      const address = server.address();
-      if (!address || typeof address !== "object") {
-        continue;
-      }
-      if (address.port === port && server.encrypted && server.allowHTTP1 && server.listenerCount("request") > 0) {
-        return server;
-      }
-    }
-    return null;
-  }
   var ServerIncomingMessage = class {
     headers;
     rawHeaders;
@@ -14413,201 +14788,6 @@ ${headerLines}\r
       server._endRequestDispatch();
     }
   }
-  async function dispatchLoopbackConnectRequest(server, options) {
-    return await new Promise((resolve, reject) => {
-      const request = new ServerIncomingMessage({
-        method: "CONNECT",
-        url: String(options.path || "/"),
-        headers: normalizeRequestHeaders(options.headers),
-        rawHeaders: flattenRawHeaders(normalizeRequestHeaders(options.headers))
-      });
-      const clientSocket = new DirectTunnelSocket({
-        host: String(options.hostname || options.host || "127.0.0.1"),
-        port: Number(options.port) || 80
-      });
-      const serverSocket = new DirectTunnelSocket({
-        host: "127.0.0.1",
-        port: 0
-      });
-      clientSocket._attachPeer(serverSocket);
-      serverSocket._attachPeer(clientSocket);
-      const originalWrite = serverSocket.write.bind(serverSocket);
-      const originalEnd = serverSocket.end.bind(serverSocket);
-      let handshakeBuffer = Buffer.alloc(0);
-      let handshakeResolved = false;
-      const maybeResolveHandshake = () => {
-        if (handshakeResolved) {
-          return;
-        }
-        const separator = handshakeBuffer.indexOf("\r\n\r\n");
-        if (separator === -1) {
-          return;
-        }
-        const headerBuffer = handshakeBuffer.subarray(0, separator);
-        const head = handshakeBuffer.subarray(separator + 4);
-        const [statusLine, ...headerLines] = headerBuffer.toString("latin1").split("\r\n");
-        const statusMatch = /^HTTP\/1\.[01]\s+(\d{3})(?:\s+(.*))?$/.exec(statusLine);
-        if (!statusMatch) {
-          reject(new Error(`Invalid CONNECT response: ${statusLine}`));
-          return;
-        }
-        handshakeResolved = true;
-        const headers = {};
-        const rawHeaders = [];
-        for (const headerLine of headerLines) {
-          const separatorIndex = headerLine.indexOf(":");
-          if (separatorIndex === -1) {
-            continue;
-          }
-          const key = headerLine.slice(0, separatorIndex).trim();
-          const value = headerLine.slice(separatorIndex + 1).trim();
-          headers[key.toLowerCase()] = value;
-          rawHeaders.push(key, value);
-        }
-        resolve({
-          response: new IncomingMessage({
-            headers,
-            rawHeaders,
-            status: Number(statusMatch[1]),
-            statusText: statusMatch[2] || HTTP_STATUS_TEXT[Number(statusMatch[1])]
-          }),
-          socket: clientSocket,
-          head
-        });
-      };
-      serverSocket.write = ((data, encodingOrCb, cb) => {
-        if (handshakeResolved) {
-          return originalWrite(data, encodingOrCb, cb);
-        }
-        const callback = typeof encodingOrCb === "function" ? encodingOrCb : cb;
-        handshakeBuffer = Buffer.concat([handshakeBuffer, normalizeSocketChunk(data)]);
-        maybeResolveHandshake();
-        callback?.();
-        return true;
-      });
-      serverSocket.end = ((data) => {
-        if (data !== void 0) {
-          serverSocket.write(data);
-        }
-        if (!handshakeResolved) {
-          maybeResolveHandshake();
-        }
-        return originalEnd();
-      });
-      try {
-        server._emit("connect", request, serverSocket, Buffer.alloc(0));
-      } catch (error) {
-        reject(error instanceof Error ? error : new Error(String(error)));
-        return;
-      }
-      queueMicrotask(() => {
-        if (!handshakeResolved) {
-          reject(new Error("Loopback CONNECT handler did not establish a tunnel"));
-        }
-      });
-    });
-  }
-  async function dispatchLoopbackUpgradeRequest(server, options, requestBody) {
-    return await new Promise((resolve, reject) => {
-      const normalizedHeaders = normalizeRequestHeaders(options.headers);
-      const request = new ServerIncomingMessage({
-        method: String(options.method || "GET").toUpperCase(),
-        url: String(options.path || "/"),
-        headers: normalizedHeaders,
-        rawHeaders: flattenRawHeaders(normalizedHeaders),
-        bodyBase64: requestBody ? Buffer.from(requestBody).toString("base64") : void 0
-      });
-      const clientSocket = new DirectTunnelSocket({
-        host: String(options.hostname || options.host || "127.0.0.1"),
-        port: Number(options.port) || 80
-      });
-      const serverSocket = new DirectTunnelSocket({
-        host: "127.0.0.1",
-        port: 0
-      });
-      clientSocket._attachPeer(serverSocket);
-      serverSocket._attachPeer(clientSocket);
-      const originalWrite = serverSocket.write.bind(serverSocket);
-      const originalEnd = serverSocket.end.bind(serverSocket);
-      let handshakeBuffer = Buffer.alloc(0);
-      let handshakeResolved = false;
-      const maybeResolveHandshake = () => {
-        if (handshakeResolved) {
-          return;
-        }
-        const separator = handshakeBuffer.indexOf("\r\n\r\n");
-        if (separator === -1) {
-          return;
-        }
-        const headerBuffer = handshakeBuffer.subarray(0, separator);
-        const head = handshakeBuffer.subarray(separator + 4);
-        const [statusLine, ...headerLines] = headerBuffer.toString("latin1").split("\r\n");
-        const statusMatch = /^HTTP\/1\.[01]\s+(\d{3})(?:\s+(.*))?$/.exec(statusLine);
-        if (!statusMatch) {
-          reject(new Error(`Invalid upgrade response: ${statusLine}`));
-          return;
-        }
-        handshakeResolved = true;
-        const headers = {};
-        const rawHeaders = [];
-        for (const headerLine of headerLines) {
-          const separatorIndex = headerLine.indexOf(":");
-          if (separatorIndex === -1) {
-            continue;
-          }
-          const key = headerLine.slice(0, separatorIndex).trim();
-          const value = headerLine.slice(separatorIndex + 1).trim();
-          headers[key.toLowerCase()] = value;
-          rawHeaders.push(key, value);
-        }
-        resolve({
-          response: new IncomingMessage({
-            headers,
-            rawHeaders,
-            status: Number(statusMatch[1]),
-            statusText: statusMatch[2] || HTTP_STATUS_TEXT[Number(statusMatch[1])]
-          }),
-          socket: clientSocket,
-          head
-        });
-      };
-      serverSocket.write = ((data, encodingOrCb, cb) => {
-        if (handshakeResolved) {
-          return originalWrite(data, encodingOrCb, cb);
-        }
-        const callback = typeof encodingOrCb === "function" ? encodingOrCb : cb;
-        handshakeBuffer = Buffer.concat([handshakeBuffer, normalizeSocketChunk(data)]);
-        maybeResolveHandshake();
-        callback?.();
-        return true;
-      });
-      serverSocket.end = ((data) => {
-        if (data !== void 0) {
-          serverSocket.write(data);
-        }
-        if (!handshakeResolved) {
-          maybeResolveHandshake();
-        }
-        return originalEnd();
-      });
-      try {
-        server._emit(
-          "upgrade",
-          request,
-          serverSocket,
-          request.rawBody || Buffer.alloc(0)
-        );
-      } catch (error) {
-        reject(error instanceof Error ? error : new Error(String(error)));
-        return;
-      }
-      queueMicrotask(() => {
-        if (!handshakeResolved) {
-          reject(new Error("Loopback upgrade handler did not establish a protocol switch"));
-        }
-      });
-    });
-  }
   function dispatchSocketRequest(event, serverId, requestJson, headBase64, socketId) {
     const server = serverInstances.get(serverId);
     if (!server) {
@@ -14932,26 +15112,6 @@ ${headerLines}\r
       STATUS_CODES: HTTP_STATUS_TEXT
     };
   }
-  async function dispatchLoopbackHttp2CompatibilityRequest(server, requestInput) {
-    const request = typeof requestInput === "string" ? JSON.parse(requestInput) : requestInput;
-    const incoming = new ServerIncomingMessage(request);
-    const outgoing = new ServerResponseBridge();
-    incoming.socket = outgoing.socket;
-    incoming.connection = outgoing.socket;
-    server.emit("request", incoming, outgoing);
-    if (incoming.rawBody && incoming.rawBody.length > 0) {
-      incoming.emit("data", incoming.rawBody);
-    }
-    incoming.emit("end");
-    if (!outgoing.writableFinished) {
-      outgoing.end();
-    }
-    await outgoing.waitForClose();
-    return {
-      responseJson: JSON.stringify(outgoing.serialize()),
-      abortRequest: () => incoming._abort()
-    };
-  }
   var http = createHttpModule("http");
   var https = createHttpModule("https");
   var HTTP2_K_SOCKET = /* @__PURE__ */ Symbol.for("secure-exec.http2.kSocket");
@@ -15031,8 +15191,13 @@ ${headerLines}\r
     remoteFamily = "IPv4";
     servername;
     alpnProtocol = false;
+    readable = true;
+    writable = true;
     destroyed = false;
+    _bridgeReadPollTimer = null;
+    _loopbackServer = null;
     _onDestroy;
+    _destroyCallbackInvoked = false;
     constructor(state, onDestroy) {
       super();
       this._onDestroy = onDestroy;
@@ -15051,8 +15216,27 @@ ${headerLines}\r
       this.servername = state.servername;
       this.alpnProtocol = state.alpnProtocol ?? this.alpnProtocol;
     }
+    _clearTimeoutTimer() {
+    }
+    _emitNet(event, error) {
+      if (event === "error" && error) {
+        this.emit("error", error);
+        return;
+      }
+      if (event === "close") {
+        if (!this._destroyCallbackInvoked) {
+          this._destroyCallbackInvoked = true;
+          queueMicrotask(() => {
+            this._onDestroy?.();
+          });
+        }
+        this.emit("close");
+      }
+    }
     end() {
       this.destroyed = true;
+      this.readable = false;
+      this.writable = false;
       this.emit("close");
       return this;
     }
@@ -15061,8 +15245,9 @@ ${headerLines}\r
         return this;
       }
       this.destroyed = true;
-      this._onDestroy?.();
-      this.emit("close");
+      this.readable = false;
+      this.writable = false;
+      this._emitNet("close");
       return this;
     }
   };
@@ -15089,6 +15274,166 @@ ${headerLines}\r
     error.code = "ERR_HTTP2_INVALID_SETTING_VALUE";
     return error;
   }
+  var HTTP2_INTERNAL_BINDING_CONSTANTS = {
+    NGHTTP2_NO_ERROR: 0,
+    NGHTTP2_PROTOCOL_ERROR: 1,
+    NGHTTP2_INTERNAL_ERROR: 2,
+    NGHTTP2_FLOW_CONTROL_ERROR: 3,
+    NGHTTP2_SETTINGS_TIMEOUT: 4,
+    NGHTTP2_STREAM_CLOSED: 5,
+    NGHTTP2_FRAME_SIZE_ERROR: 6,
+    NGHTTP2_REFUSED_STREAM: 7,
+    NGHTTP2_CANCEL: 8,
+    NGHTTP2_COMPRESSION_ERROR: 9,
+    NGHTTP2_CONNECT_ERROR: 10,
+    NGHTTP2_ENHANCE_YOUR_CALM: 11,
+    NGHTTP2_INADEQUATE_SECURITY: 12,
+    NGHTTP2_HTTP_1_1_REQUIRED: 13,
+    NGHTTP2_NV_FLAG_NONE: 0,
+    NGHTTP2_NV_FLAG_NO_INDEX: 1,
+    NGHTTP2_ERR_DEFERRED: -508,
+    NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE: -509,
+    NGHTTP2_ERR_STREAM_CLOSED: -510,
+    NGHTTP2_ERR_INVALID_ARGUMENT: -501,
+    NGHTTP2_ERR_FRAME_SIZE_ERROR: -522,
+    NGHTTP2_ERR_NOMEM: -901,
+    NGHTTP2_FLAG_NONE: 0,
+    NGHTTP2_FLAG_END_STREAM: 1,
+    NGHTTP2_FLAG_END_HEADERS: 4,
+    NGHTTP2_FLAG_ACK: 1,
+    NGHTTP2_FLAG_PADDED: 8,
+    NGHTTP2_FLAG_PRIORITY: 32,
+    NGHTTP2_DEFAULT_WEIGHT: 16,
+    NGHTTP2_SETTINGS_HEADER_TABLE_SIZE: 1,
+    NGHTTP2_SETTINGS_ENABLE_PUSH: 2,
+    NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS: 3,
+    NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE: 4,
+    NGHTTP2_SETTINGS_MAX_FRAME_SIZE: 5,
+    NGHTTP2_SETTINGS_MAX_HEADER_LIST_SIZE: 6,
+    NGHTTP2_SETTINGS_ENABLE_CONNECT_PROTOCOL: 8
+  };
+  var HTTP2_NGHTTP2_ERROR_MESSAGES = {
+    [HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_ERR_DEFERRED]: "Data deferred",
+    [HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE]: "Stream ID is not available",
+    [HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_ERR_STREAM_CLOSED]: "Stream was already closed or invalid",
+    [HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_ERR_INVALID_ARGUMENT]: "Invalid argument",
+    [HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_ERR_FRAME_SIZE_ERROR]: "Frame size error",
+    [HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_ERR_NOMEM]: "Out of memory"
+  };
+  var NghttpError = class extends Error {
+    code = "ERR_HTTP2_ERROR";
+    constructor(message) {
+      super(message);
+      this.name = "Error";
+    }
+  };
+  function nghttp2ErrorString(code) {
+    return HTTP2_NGHTTP2_ERROR_MESSAGES[code] ?? `HTTP/2 error (${String(code)})`;
+  }
+  function createHttp2InvalidArgValueError(property, value) {
+    return createTypeErrorWithCode(
+      `The property 'options.${property}' is invalid. Received ${formatHttp2InvalidValue(value)}`,
+      "ERR_INVALID_ARG_VALUE"
+    );
+  }
+  function formatHttp2InvalidValue(value) {
+    if (typeof value === "function") {
+      return `[Function${value.name ? `: ${value.name}` : ": function"}]`;
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (Array.isArray(value)) {
+      return "[]";
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "object") {
+      return "{}";
+    }
+    return String(value);
+  }
+  function createHttp2PayloadForbiddenError(statusCode) {
+    return createHttp2Error(
+      "ERR_HTTP2_PAYLOAD_FORBIDDEN",
+      `Responses with ${String(statusCode)} status must not have a payload`
+    );
+  }
+  var S_IFMT = 61440;
+  var S_IFDIR = 16384;
+  var S_IFREG = 32768;
+  var S_IFIFO = 4096;
+  var S_IFSOCK = 49152;
+  var S_IFLNK = 40960;
+  function createHttp2BridgeStat(stat) {
+    const atimeMs = stat.atimeMs ?? 0;
+    const mtimeMs = stat.mtimeMs ?? atimeMs;
+    const ctimeMs = stat.ctimeMs ?? mtimeMs;
+    const birthtimeMs = stat.birthtimeMs ?? ctimeMs;
+    const fileType = stat.mode & S_IFMT;
+    return {
+      size: stat.size,
+      mode: stat.mode,
+      atimeMs,
+      mtimeMs,
+      ctimeMs,
+      birthtimeMs,
+      atime: new Date(atimeMs),
+      mtime: new Date(mtimeMs),
+      ctime: new Date(ctimeMs),
+      birthtime: new Date(birthtimeMs),
+      isFile: () => fileType === S_IFREG,
+      isDirectory: () => fileType === S_IFDIR,
+      isFIFO: () => fileType === S_IFIFO,
+      isSocket: () => fileType === S_IFSOCK,
+      isSymbolicLink: () => fileType === S_IFLNK
+    };
+  }
+  function normalizeHttp2FileResponseOptions(options) {
+    const normalized = options ?? {};
+    const offset = normalized.offset;
+    if (offset !== void 0 && (typeof offset !== "number" || !Number.isFinite(offset))) {
+      throw createHttp2InvalidArgValueError("offset", offset);
+    }
+    const length = normalized.length;
+    if (length !== void 0 && (typeof length !== "number" || !Number.isFinite(length))) {
+      throw createHttp2InvalidArgValueError("length", length);
+    }
+    const statCheck = normalized.statCheck;
+    if (statCheck !== void 0 && typeof statCheck !== "function") {
+      throw createHttp2InvalidArgValueError("statCheck", statCheck);
+    }
+    const onError = normalized.onError;
+    return {
+      offset: offset === void 0 ? 0 : Math.max(0, Math.trunc(offset)),
+      length: typeof length === "number" ? Math.trunc(length) : void 0,
+      statCheck: typeof statCheck === "function" ? statCheck : void 0,
+      onError: typeof onError === "function" ? onError : void 0
+    };
+  }
+  function sliceHttp2FileBody(body, offset, length) {
+    const safeOffset = Math.max(0, Math.min(offset, body.length));
+    if (length === void 0 || length < 0) {
+      return body.subarray(safeOffset);
+    }
+    return body.subarray(safeOffset, Math.min(body.length, safeOffset + length));
+  }
+  var Http2Stream = class {
+    constructor(_streamId) {
+      this._streamId = _streamId;
+    }
+    respond(headers) {
+      if (typeof _networkHttp2StreamRespondRaw === "undefined") {
+        throw new Error("http2 server stream respond bridge is not available");
+      }
+      _networkHttp2StreamRespondRaw.applySync(void 0, [
+        this._streamId,
+        serializeHttp2Headers(headers)
+      ]);
+      return 0;
+    }
+  };
   var DEFAULT_HTTP2_SETTINGS = {
     headerTableSize: 4096,
     enablePush: true,
@@ -15537,7 +15882,10 @@ ${headerLines}\r
   }
   var ServerHttp2Stream = class _ServerHttp2Stream extends Http2EventEmitter {
     _streamId;
+    _binding;
     _responded = false;
+    _endQueued = false;
+    _pendingSyntheticErrorSuppressions = 0;
     _requestHeaders;
     _isPushStream;
     session;
@@ -15550,6 +15898,7 @@ ${headerLines}\r
     constructor(streamId, session, requestHeaders, isPushStream = false) {
       super();
       this._streamId = streamId;
+      this._binding = new Http2Stream(streamId);
       this.session = session;
       this._requestHeaders = requestHeaders;
       this._isPushStream = isPushStream;
@@ -15562,12 +15911,56 @@ ${headerLines}\r
         ended: requestHeaders?.[":method"] === "HEAD"
       };
     }
-    respond(headers) {
-      if (typeof _networkHttp2StreamRespondRaw === "undefined") {
-        throw new Error("http2 server stream respond bridge is not available");
+    _closeWithCode(code) {
+      this.rstCode = code;
+      _networkHttp2StreamCloseRaw?.applySync(void 0, [this._streamId, code]);
+    }
+    _markSyntheticClose() {
+      this.destroyed = true;
+      this.readable = false;
+      this.writable = false;
+    }
+    _shouldSuppressHostError() {
+      if (this._pendingSyntheticErrorSuppressions <= 0) {
+        return false;
       }
+      this._pendingSyntheticErrorSuppressions -= 1;
+      return true;
+    }
+    _emitNghttp2Error(errorCode) {
+      const error = new NghttpError(nghttp2ErrorString(errorCode));
+      this._pendingSyntheticErrorSuppressions += 1;
+      this._markSyntheticClose();
+      this.emit("error", error);
+      this._closeWithCode(HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_INTERNAL_ERROR);
+    }
+    _emitInternalStreamError() {
+      const error = createHttp2Error(
+        "ERR_HTTP2_STREAM_ERROR",
+        "Stream closed with error code NGHTTP2_INTERNAL_ERROR"
+      );
+      this._pendingSyntheticErrorSuppressions += 1;
+      this._markSyntheticClose();
+      this.emit("error", error);
+      this._closeWithCode(HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_INTERNAL_ERROR);
+    }
+    _submitResponse(headers) {
       this._responded = true;
-      _networkHttp2StreamRespondRaw.applySync(void 0, [this._streamId, serializeHttp2Headers(headers)]);
+      const ngError = this._binding.respond(headers);
+      if (typeof ngError === "number" && ngError !== 0) {
+        this._emitNghttp2Error(ngError);
+        return false;
+      }
+      return true;
+    }
+    respond(headers) {
+      if (this.destroyed) {
+        throw createHttp2Error("ERR_HTTP2_INVALID_STREAM", "The stream has been destroyed");
+      }
+      if (this._responded) {
+        throw createHttp2Error("ERR_HTTP2_HEADERS_SENT", "Response has already been initiated.");
+      }
+      this._submitResponse(headers);
     }
     pushStream(headers, optionsOrCallback, maybeCallback) {
       if (this._isPushStream) {
@@ -15584,7 +15977,7 @@ ${headerLines}\r
         throw new Error("http2 server stream push bridge is not available");
       }
       const options = optionsOrCallback && typeof optionsOrCallback === "object" && !Array.isArray(optionsOrCallback) ? optionsOrCallback : {};
-      const resultJson = _networkHttp2StreamPushStreamRaw.applySyncPromise(
+      const resultJson = _networkHttp2StreamPushStreamRaw.applySync(
         void 0,
         [
           this._streamId,
@@ -15593,20 +15986,18 @@ ${headerLines}\r
         ]
       );
       const result = JSON.parse(resultJson);
-      queueMicrotask(() => {
-        if (result.error) {
-          callback(parseHttp2ErrorPayload(result.error));
-          return;
-        }
-        const pushStream = new _ServerHttp2Stream(
-          Number(result.streamId),
-          this.session,
-          parseHttp2Headers(result.headers),
-          true
-        );
-        http2Streams.set(Number(result.streamId), pushStream);
-        callback(null, pushStream, parseHttp2Headers(result.headers));
-      });
+      if (result.error) {
+        callback(parseHttp2ErrorPayload(result.error));
+        return;
+      }
+      const pushStream = new _ServerHttp2Stream(
+        Number(result.streamId),
+        this.session,
+        parseHttp2Headers(result.headers),
+        true
+      );
+      http2Streams.set(Number(result.streamId), pushStream);
+      callback(null, pushStream, parseHttp2Headers(result.headers));
     }
     write(data) {
       if (this._writableState.ended) {
@@ -15623,7 +16014,12 @@ ${headerLines}\r
     }
     end(data) {
       if (!this._responded) {
-        this.respond({ ":status": 200 });
+        if (!this._submitResponse({ ":status": 200 })) {
+          return;
+        }
+      }
+      if (this._endQueued) {
+        return;
       }
       if (typeof _networkHttp2StreamEndRaw === "undefined") {
         throw new Error("http2 server stream end bridge is not available");
@@ -15634,8 +16030,14 @@ ${headerLines}\r
         const buffer = Buffer.isBuffer(data) ? data : typeof data === "string" ? Buffer.from(data) : Buffer.from(data);
         encoded = buffer.toString("base64");
       }
-      _networkHttp2StreamEndRaw.applySync(void 0, [this._streamId, encoded]);
-      this._writableState.ended = true;
+      this._endQueued = true;
+      queueMicrotask(() => {
+        if (!this._endQueued || this.destroyed) {
+          return;
+        }
+        this._endQueued = false;
+        _networkHttp2StreamEndRaw.applySync(void 0, [this._streamId, encoded]);
+      });
     }
     pause() {
       this._readableState.flowing = false;
@@ -15648,18 +16050,43 @@ ${headerLines}\r
       return this;
     }
     respondWithFile(path, headers, options) {
+      if (this.destroyed) {
+        throw createHttp2Error("ERR_HTTP2_INVALID_STREAM", "The stream has been destroyed");
+      }
+      if (this._responded) {
+        throw createHttp2Error("ERR_HTTP2_HEADERS_SENT", "Response has already been initiated.");
+      }
+      const normalizedOptions = normalizeHttp2FileResponseOptions(options);
+      const responseHeaders = { ...headers ?? {} };
+      const statusCode = responseHeaders[":status"];
+      if (statusCode === 204 || statusCode === 205 || statusCode === 304) {
+        throw createHttp2PayloadForbiddenError(Number(statusCode));
+      }
       try {
+        const statJson = _fs.stat.applySyncPromise(void 0, [path]);
         const bodyBase64 = _fs.readFileBinary.applySyncPromise(void 0, [path]);
+        const stat = createHttp2BridgeStat(JSON.parse(statJson));
+        const callbackOptions = {
+          offset: normalizedOptions.offset,
+          length: normalizedOptions.length ?? Math.max(0, stat.size - normalizedOptions.offset)
+        };
+        normalizedOptions.statCheck?.(stat, responseHeaders, callbackOptions);
         const body = Buffer.from(bodyBase64, "base64");
-        this._responded = true;
-        this.respond({
+        const slicedBody = sliceHttp2FileBody(
+          body,
+          normalizedOptions.offset,
+          normalizedOptions.length
+        );
+        if (responseHeaders["content-length"] === void 0) {
+          responseHeaders["content-length"] = slicedBody.byteLength;
+        }
+        if (!this._submitResponse({
           ":status": 200,
-          ...headers ?? {}
-        });
-        this.end(body);
-        queueMicrotask(() => {
-          this.session.close();
-        });
+          ...responseHeaders
+        })) {
+          return;
+        }
+        this.end(slicedBody);
         return;
       } catch {
       }
@@ -15681,10 +16108,22 @@ ${headerLines}\r
       const fd = typeof fdOrHandle === "number" ? fdOrHandle : typeof fdOrHandle?.fd === "number" ? fdOrHandle.fd : NaN;
       const path = Number.isFinite(fd) ? _fdGetPath.applySync(void 0, [fd]) : null;
       if (!path) {
-        throw new Error("Invalid file descriptor for respondWithFD");
+        this._emitInternalStreamError();
+        return;
       }
       this.respondWithFile(path, headers, options);
     }
+    destroy(error) {
+      if (this.destroyed) {
+        return this;
+      }
+      this.destroyed = true;
+      if (error) {
+        this.emit("error", error);
+      }
+      this._closeWithCode(HTTP2_INTERNAL_BINDING_CONSTANTS.NGHTTP2_CANCEL);
+      return this;
+    }
     _emitData(dataBase64) {
       if (!dataBase64) {
         return;
@@ -15896,7 +16335,11 @@ ${headerLines}\r
     constructor(sessionId, socketState) {
       super();
       this._sessionId = sessionId;
-      this.socket = new Http2SocketProxy(socketState, () => this.destroy());
+      this.socket = new Http2SocketProxy(socketState, () => {
+        setTimeout(() => {
+          this.destroy();
+        }, 0);
+      });
       this[HTTP2_K_SOCKET] = this.socket;
     }
     _retain() {
@@ -16468,6 +16911,9 @@ ${headerLines}\r
     if (kind === "serverStreamError") {
       const stream = http2Streams.get(id);
       if (!stream) return;
+      if (typeof stream._shouldSuppressHostError === "function" && stream._shouldSuppressHostError()) {
+        return;
+      }
       stream.emit("error", parseHttp2ErrorPayload(data));
       return;
     }
@@ -16573,6 +17019,9 @@ ${headerLines}\r
   var http2 = {
     Http2ServerRequest,
     Http2ServerResponse,
+    Http2Stream,
+    NghttpError,
+    nghttp2ErrorString,
     constants: {
       HTTP2_HEADER_METHOD: ":method",
       HTTP2_HEADER_PATH: ":path",
@@ -16581,19 +17030,14 @@ ${headerLines}\r
       HTTP2_HEADER_STATUS: ":status",
       HTTP2_HEADER_CONTENT_TYPE: "content-type",
       HTTP2_HEADER_CONTENT_LENGTH: "content-length",
+      HTTP2_HEADER_LAST_MODIFIED: "last-modified",
       HTTP2_HEADER_ACCEPT: "accept",
       HTTP2_HEADER_ACCEPT_ENCODING: "accept-encoding",
       HTTP2_METHOD_GET: "GET",
       HTTP2_METHOD_POST: "POST",
       HTTP2_METHOD_PUT: "PUT",
       HTTP2_METHOD_DELETE: "DELETE",
-      NGHTTP2_NO_ERROR: 0,
-      NGHTTP2_PROTOCOL_ERROR: 1,
-      NGHTTP2_INTERNAL_ERROR: 2,
-      NGHTTP2_FRAME_SIZE_ERROR: 6,
-      NGHTTP2_FLOW_CONTROL_ERROR: 3,
-      NGHTTP2_REFUSED_STREAM: 7,
-      NGHTTP2_CANCEL: 8,
+      ...HTTP2_INTERNAL_BINDING_CONSTANTS,
       DEFAULT_SETTINGS_MAX_HEADER_LIST_SIZE: 65535
     },
     getDefaultSettings() {
@@ -16655,6 +17099,20 @@ ${headerLines}\r
     exposeCustomGlobal("Blob", class BlobStub {
     });
   }
+  if (typeof globalThis.File === "undefined") {
+    class FileStub extends Blob {
+      name;
+      lastModified;
+      webkitRelativePath;
+      constructor(parts = [], name = "", options = {}) {
+        super(parts, options);
+        this.name = String(name);
+        this.lastModified = typeof options.lastModified === "number" ? options.lastModified : Date.now();
+        this.webkitRelativePath = "";
+      }
+    }
+    exposeCustomGlobal("File", FileStub);
+  }
   if (typeof globalThis.FormData === "undefined") {
     class FormDataStub {
       _entries = [];
@@ -20092,10 +20550,12 @@ ${headerLines}\r
   var _exited = false;
   var ProcessExitError = class extends Error {
     code;
+    _isProcessExit;
     constructor(code) {
       super("process.exit(" + code + ")");
       this.name = "ProcessExitError";
       this.code = code;
+      this._isProcessExit = true;
     }
   };
   exposeCustomGlobal("ProcessExitError", ProcessExitError);
@@ -20131,6 +20591,10 @@ ${headerLines}\r
     SIGPWR: 30,
     SIGSYS: 31
   };
+  var _signalNamesByNumber = Object.fromEntries(
+    Object.entries(_signalNumbers).map(([name, num]) => [num, name])
+  );
+  var _ignoredSelfSignals = /* @__PURE__ */ new Set(["SIGWINCH", "SIGCHLD", "SIGCONT", "SIGURG"]);
   function _resolveSignal(signal) {
     if (signal === void 0 || signal === null) return 15;
     if (typeof signal === "number") return signal;
@@ -20189,6 +20653,33 @@ ${headerLines}\r
     }
     return handled;
   }
+  function isProcessExitError(error) {
+    return Boolean(
+      error && typeof error === "object" && (error._isProcessExit === true || error.name === "ProcessExitError")
+    );
+  }
+  function normalizeAsyncError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  function routeAsyncCallbackError(error) {
+    if (isProcessExitError(error)) {
+      return { handled: false, rethrow: error };
+    }
+    const normalized = normalizeAsyncError(error);
+    try {
+      if (_emit("uncaughtException", normalized, "uncaughtException")) {
+        return { handled: true, rethrow: null };
+      }
+    } catch (emitError) {
+      return { handled: false, rethrow: emitError };
+    }
+    return { handled: false, rethrow: normalized };
+  }
+  function scheduleAsyncRethrow(error) {
+    setTimeout2(() => {
+      throw error;
+    }, 0);
+  }
   function _getStdinIsTTY() {
     return typeof __runtimeTtyConfig !== "undefined" && __runtimeTtyConfig.stdinIsTTY || false;
   }
@@ -20198,60 +20689,110 @@ ${headerLines}\r
   function _getStderrIsTTY() {
     return typeof __runtimeTtyConfig !== "undefined" && __runtimeTtyConfig.stderrIsTTY || false;
   }
-  var _stdout = {
+  function getWriteCallback(encodingOrCallback, callback) {
+    if (typeof encodingOrCallback === "function") {
+      return encodingOrCallback;
+    }
+    if (typeof callback === "function") {
+      return callback;
+    }
+    return void 0;
+  }
+  function emitListeners(listeners, onceListeners, event, args) {
+    const persistent = listeners[event] ? listeners[event].slice() : [];
+    const once = onceListeners[event] ? onceListeners[event].slice() : [];
+    if (once.length > 0) {
+      onceListeners[event] = [];
+    }
+    for (const listener of persistent) {
+      listener(...args);
+    }
+    for (const listener of once) {
+      listener(...args);
+    }
+    return persistent.length + once.length > 0;
+  }
+  function createStdioWriteStream(options) {
+    const listeners = {};
+    const onceListeners = {};
+    const remove = (event, listener) => {
+      if (listeners[event]) {
+        const idx = listeners[event].indexOf(listener);
+        if (idx !== -1) listeners[event].splice(idx, 1);
+      }
+      if (onceListeners[event]) {
+        const idx = onceListeners[event].indexOf(listener);
+        if (idx !== -1) onceListeners[event].splice(idx, 1);
+      }
+    };
+    const stream = {
+      write(data, encodingOrCallback, callback) {
+        options.write(String(data));
+        const done = getWriteCallback(encodingOrCallback, callback);
+        if (done) {
+          _queueMicrotask(() => done(null));
+        }
+        return true;
+      },
+      end() {
+        return stream;
+      },
+      on(event, listener) {
+        if (!listeners[event]) listeners[event] = [];
+        listeners[event].push(listener);
+        return stream;
+      },
+      once(event, listener) {
+        if (!onceListeners[event]) onceListeners[event] = [];
+        onceListeners[event].push(listener);
+        return stream;
+      },
+      off(event, listener) {
+        remove(event, listener);
+        return stream;
+      },
+      removeListener(event, listener) {
+        remove(event, listener);
+        return stream;
+      },
+      addListener(event, listener) {
+        return stream.on(event, listener);
+      },
+      emit(event, ...args) {
+        return emitListeners(listeners, onceListeners, event, args);
+      },
+      writable: true,
+      get isTTY() {
+        return options.isTTY();
+      },
+      columns: 80,
+      rows: 24
+    };
+    return stream;
+  }
+  var _stdout = createStdioWriteStream({
     write(data) {
       if (typeof _log !== "undefined") {
-        _log.applySync(void 0, [String(data).replace(/\n$/, "")]);
+        _log.applySync(void 0, [data]);
       }
-      return true;
-    },
-    end() {
-      return this;
-    },
-    on() {
-      return this;
-    },
-    once() {
-      return this;
     },
-    emit() {
-      return false;
-    },
-    writable: true,
-    get isTTY() {
-      return _getStdoutIsTTY();
-    },
-    columns: 80,
-    rows: 24
-  };
-  var _stderr = {
+    isTTY: _getStdoutIsTTY
+  });
+  var _stderr = createStdioWriteStream({
     write(data) {
       if (typeof _error !== "undefined") {
-        _error.applySync(void 0, [String(data).replace(/\n$/, "")]);
+        _error.applySync(void 0, [data]);
       }
-      return true;
-    },
-    end() {
-      return this;
-    },
-    on() {
-      return this;
-    },
-    once() {
-      return this;
-    },
-    emit() {
-      return false;
     },
-    writable: true,
-    get isTTY() {
-      return _getStderrIsTTY();
-    },
-    columns: 80,
-    rows: 24
-  };
+    isTTY: _getStderrIsTTY
+  });
   var _stdinListeners = {};
   var _stdinOnceListeners = {};
+  var _stdinLiveDecoder = new TextDecoder2();
+  var STDIN_HANDLE_ID = "process.stdin";
+  var _stdinLiveBuffer = "";
+  var _stdinLiveStarted = false;
+  var _stdinLiveHandleRegistered = false;
   exposeMutableRuntimeStateGlobal(
     "_stdinData",
     typeof _processConfig !== "undefined" && _processConfig.stdin || ""
@@ -20303,11 +20844,94 @@ ${headerLines}\r
       }
     }
   }
+  function emitStdinListeners(event, value) {
+    const listeners = [..._stdinListeners[event] || [], ..._stdinOnceListeners[event] || []];
+    _stdinOnceListeners[event] = [];
+    for (const listener of listeners) {
+      listener(value);
+    }
+  }
+  function syncLiveStdinHandle(active) {
+    if (active) {
+      if (!_stdinLiveHandleRegistered && typeof _registerHandle === "function") {
+        try {
+          _registerHandle(STDIN_HANDLE_ID, "process.stdin");
+          _stdinLiveHandleRegistered = true;
+        } catch {
+        }
+      }
+      return;
+    }
+    if (_stdinLiveHandleRegistered && typeof _unregisterHandle === "function") {
+      try {
+        _unregisterHandle(STDIN_HANDLE_ID);
+      } catch {
+      }
+      _stdinLiveHandleRegistered = false;
+    }
+  }
+  function flushLiveStdinBuffer() {
+    if (!getStdinFlowMode() || _stdinLiveBuffer.length === 0) return;
+    const chunk = _stdinLiveBuffer;
+    _stdinLiveBuffer = "";
+    emitStdinListeners("data", chunk);
+  }
+  function finishLiveStdin() {
+    if (getStdinEnded()) return;
+    setStdinEnded(true);
+    flushLiveStdinBuffer();
+    emitStdinListeners("end");
+    emitStdinListeners("close");
+    syncLiveStdinHandle(false);
+  }
+  function ensureLiveStdinStarted() {
+    if (_stdinLiveStarted || !_getStdinIsTTY()) return;
+    _stdinLiveStarted = true;
+    syncLiveStdinHandle(!_stdin.paused);
+    void (async () => {
+      try {
+        while (!getStdinEnded()) {
+          if (typeof _kernelStdinRead === "undefined") {
+            break;
+          }
+          const next = await _kernelStdinRead.apply(void 0, [], {
+            result: { promise: true }
+          });
+          if (next?.done) {
+            break;
+          }
+          const dataBase64 = String(next?.dataBase64 ?? "");
+          if (!dataBase64) {
+            continue;
+          }
+          _stdinLiveBuffer += _stdinLiveDecoder.decode(
+            import_buffer2.Buffer.from(dataBase64, "base64"),
+            { stream: true }
+          );
+          flushLiveStdinBuffer();
+        }
+      } catch {
+      }
+      _stdinLiveBuffer += _stdinLiveDecoder.decode();
+      finishLiveStdin();
+    })();
+  }
   var _stdin = {
     readable: true,
     paused: true,
     encoding: null,
+    isRaw: false,
     read(size) {
+      if (_stdinLiveBuffer.length > 0) {
+        if (!size || size >= _stdinLiveBuffer.length) {
+          const chunk3 = _stdinLiveBuffer;
+          _stdinLiveBuffer = "";
+          return chunk3;
+        }
+        const chunk2 = _stdinLiveBuffer.slice(0, size);
+        _stdinLiveBuffer = _stdinLiveBuffer.slice(size);
+        return chunk2;
+      }
       if (getStdinPosition() >= getStdinData().length) return null;
       const chunk = size ? getStdinData().slice(getStdinPosition(), getStdinPosition() + size) : getStdinData().slice(getStdinPosition());
       setStdinPosition(getStdinPosition() + chunk.length);
@@ -20316,6 +20940,12 @@ ${headerLines}\r
     on(event, listener) {
       if (!_stdinListeners[event]) _stdinListeners[event] = [];
       _stdinListeners[event].push(listener);
+      if (_getStdinIsTTY() && (event === "data" || event === "end" || event === "close")) {
+        ensureLiveStdinStarted();
+      }
+      if (event === "data" && this.paused) {
+        this.resume();
+      }
       if (event === "end" && getStdinData() && !getStdinEnded()) {
         setStdinFlowMode(true);
         _emitStdinData();
@@ -20348,11 +20978,17 @@ ${headerLines}\r
     pause() {
       this.paused = true;
       setStdinFlowMode(false);
+      syncLiveStdinHandle(false);
       return this;
     },
     resume() {
+      if (_getStdinIsTTY()) {
+        ensureLiveStdinStarted();
+        syncLiveStdinHandle(true);
+      }
       this.paused = false;
       setStdinFlowMode(true);
+      flushLiveStdinBuffer();
       _emitStdinData();
       return this;
     },
@@ -20367,6 +21003,7 @@ ${headerLines}\r
       if (typeof _ptySetRawMode !== "undefined") {
         _ptySetRawMode.applySync(void 0, [mode]);
       }
+      this.isRaw = mode;
       return this;
     },
     get isTTY() {
@@ -20508,11 +21145,8 @@ ${headerLines}\r
       return process2.exit(1);
     },
     nextTick(callback, ...args) {
-      if (typeof queueMicrotask === "function") {
-        queueMicrotask(() => callback(...args));
-      } else {
-        Promise.resolve().then(() => callback(...args));
-      }
+      _nextTickQueue.push({ callback, args });
+      scheduleNextTickFlush();
     },
     hrtime,
     getuid() {
@@ -20601,6 +21235,16 @@ ${headerLines}\r
         throw err;
       }
       const sigNum = _resolveSignal(signal);
+      if (sigNum === 0) {
+        return true;
+      }
+      const sigName = _signalNamesByNumber[sigNum] ?? `SIG${sigNum}`;
+      if (_emit(sigName, sigName)) {
+        return true;
+      }
+      if (_ignoredSelfSignals.has(sigName)) {
+        return true;
+      }
       return process2.exit(128 + sigNum);
     },
     // EventEmitter methods
@@ -20803,6 +21447,34 @@ ${headerLines}\r
     }
   };
   var _timerEntries = /* @__PURE__ */ new Map();
+  var _nextTickQueue = [];
+  var _nextTickScheduled = false;
+  function flushNextTickQueue() {
+    _nextTickScheduled = false;
+    while (_nextTickQueue.length > 0) {
+      const entry = _nextTickQueue.shift();
+      if (!entry) {
+        break;
+      }
+      try {
+        entry.callback(...entry.args);
+      } catch (error) {
+        const outcome = routeAsyncCallbackError(error);
+        if (!outcome.handled && outcome.rethrow !== null) {
+          _nextTickQueue.length = 0;
+          scheduleAsyncRethrow(outcome.rethrow);
+        }
+        return;
+      }
+    }
+  }
+  function scheduleNextTickFlush() {
+    if (_nextTickScheduled) {
+      return;
+    }
+    _nextTickScheduled = true;
+    _queueMicrotask(flushNextTickQueue);
+  }
   function timerDispatch(_eventType, payload) {
     const timerId = typeof payload === "number" ? payload : Number(payload?.timerId);
     if (!Number.isFinite(timerId)) return;
@@ -20814,7 +21486,12 @@ ${headerLines}\r
     }
     try {
       entry.callback(...entry.args);
-    } catch (_e) {
+    } catch (error) {
+      const outcome = routeAsyncCallbackError(error);
+      if (!outcome.handled && outcome.rethrow !== null) {
+        throw outcome.rethrow;
+      }
+      return;
     }
     if (entry.repeat && _timerEntries.has(timerId)) {
       armKernelTimer(timerId);
@@ -21304,12 +21981,11 @@ ${headerLines}\r
       g.queueMicrotask = _queueMicrotask;
     }
     installWhatwgUrlGlobals(g);
-    if (typeof g.TextEncoder === "undefined") {
-      g.TextEncoder = TextEncoder2;
-    }
-    if (typeof g.TextDecoder === "undefined") {
-      g.TextDecoder = TextDecoder2;
-    }
+    g.TextEncoder = TextEncoder2;
+    g.TextDecoder = TextDecoder2;
+    g.Event = Event;
+    g.CustomEvent = CustomEvent;
+    g.EventTarget = EventTarget;
     if (typeof g.Buffer === "undefined") {
       g.Buffer = Buffer3;
     }