@qredence/fleet 0.10.2 → 0.10.4

package/dist/web/server/server.js

@@ -21,13 +21,12 @@ import {
   isNotFound,
   isPromise,
   isRedirect,
-  isStream,
   makeSerovalPlugin,
   resolveManifestAssetLink,
   resolveManifestCssLink,
   rootRouteId,
   waitForReason
-} from "./chunk-35RIM6VP.js";
+} from "./chunk-CPB76YQU.js";
 import "./chunk-CZ7CSFO4.js";
 
 // web/app/dist/server/server.js
@@ -199,7 +198,7 @@ var RawStreamJSONDeserializePlugin = /* @__PURE__ */ createPlugin({
   }
 });
 
-// node_modules/.pnpm/seroval-plugins@1.6.7_seroval@1.6.7/node_modules/seroval-plugins/dist/web-CWqRG00W.js
+// node_modules/.pnpm/seroval-plugins@1.7.1_seroval@1.7.1/node_modules/seroval-plugins/dist/web.js
 var READABLE_STREAM_FACTORY = {};
 var READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream) => new ReadableStream({ start(controller) {
   stream.on({
@@ -243,60 +242,85 @@ var ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin({
     return READABLE_STREAM_FACTORY;
   }
 });
-async function drainStream(stream, reader) {
-  try {
-    while (true) {
-      const result = await reader.read();
-      if (result.done) {
-        stream.return(result.value);
+function toAsyncIterable(value) {
+  return { [Symbol.asyncIterator]() {
+    const reader = value.getReader();
+    let active = true;
+    let reading = false;
+    const release = () => {
+      try {
         reader.releaseLock();
-        break;
+      } catch {
       }
-      stream.next(result.value);
-    }
-  } catch (error) {
-    reader.releaseLock();
-    stream.throw(error);
-  }
-}
-function cleanupStream(reader) {
-  reader.cancel().catch(() => {
-  });
-  reader.releaseLock();
-}
-function toStream(value) {
-  const stream = createStream();
-  const reader = value.getReader();
-  const cleanup = cleanupStream.bind(null, reader);
-  drainStream(stream, reader).catch(cleanup);
-  return [stream, cleanup];
+    };
+    return {
+      async next() {
+        if (!active) return {
+          done: true,
+          value: void 0
+        };
+        reading = true;
+        let result;
+        try {
+          result = await reader.read();
+        } catch (error) {
+          reading = false;
+          release();
+          if (!active) return {
+            done: true,
+            value: void 0
+          };
+          active = false;
+          throw error;
+        }
+        reading = false;
+        if (!active || result.done) {
+          active = false;
+          release();
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        return result;
+      },
+      return(reason) {
+        if (active) {
+          active = false;
+          try {
+            reader.cancel(reason).catch(() => {
+            });
+          } catch {
+          }
+          if (!reading) release();
+        }
+        return Promise.resolve({
+          done: true,
+          value: void 0
+        });
+      }
+    };
+  } };
 }
 var ReadableStreamPlugin = /* @__PURE__ */ createPlugin({
   tag: "seroval/plugins/web/ReadableStream",
   extends: [ReadableStreamFactoryPlugin],
+  skipPlainObjects: true,
   test(value) {
     if (typeof ReadableStream === "undefined") return false;
     return value instanceof ReadableStream;
   },
   parse: {
-    sync(_value, ctx) {
-      return {
-        factory: ctx.parse(READABLE_STREAM_FACTORY),
-        stream: ctx.parse(createStream())
-      };
-    },
     async async(value, ctx) {
       return {
         factory: await ctx.parse(READABLE_STREAM_FACTORY),
-        stream: await ctx.parse(toStream(value)[0])
+        stream: await ctx.parseStreamSource(toAsyncIterable(value))
       };
     },
     stream(value, ctx) {
-      const [stream, cleanup] = toStream(value);
-      ctx.addCleanup(cleanup);
       return {
         factory: ctx.parse(READABLE_STREAM_FACTORY),
-        stream: ctx.parse(stream)
+        stream: ctx.parseStreamSource(toAsyncIterable(value))
       };
     }
   },
@@ -305,7 +329,6 @@ var ReadableStreamPlugin = /* @__PURE__ */ createPlugin({
   },
   deserialize(node, ctx) {
     const stream = ctx.deserialize(node.stream);
-    if (!stream || typeof stream !== "object" || !isStream(stream)) throw new Error("Expected a stream source.");
     return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);
   }
 });
@@ -1863,7 +1886,7 @@ var renderRouterToStream = async ({ request, router, responseHeaders, children }
   }
   let rendererTeardown = false;
   const bot = isbot(request.headers.get("User-Agent"));
-  const onError2 = (renderer) => (error, info) => {
+  const onError = (renderer) => (error, info) => {
     if (!rendererTeardown && !signal.aborted) console.error(`Error in ${renderer}:`, error, info);
   };
   try {
@@ -1872,7 +1895,7 @@ var renderRouterToStream = async ({ request, router, responseHeaders, children }
         signal,
         nonce: router.options.ssr?.nonce,
         progressiveChunkSize: Number.POSITIVE_INFINITY,
-        onError: onError2("renderToReadableStream")
+        onError: onError("renderToReadableStream")
       });
       const rendererAbort = bot ? new AbortController() : void 0;
       const responseStream = transformReadableStreamWithRouter(router, stream, {
@@ -1911,7 +1934,7 @@ var renderRouterToStream = async ({ request, router, responseHeaders, children }
           nonce: router.options.ssr?.nonce,
           progressiveChunkSize: Number.POSITIVE_INFINITY,
           ...bot ? { onAllReady: resolveReady } : { onShellReady: resolveReady },
-          onError: onError2("renderToPipeableStream"),
+          onError: onError("renderToPipeableStream"),
           onShellError: (error) => rendererAbort.abort(error)
         });
         const responseStream = transformReadableStreamWithRouter(router, Readable.toWeb(reactAppPassthrough), {
@@ -2380,9 +2403,9 @@ function prepareResponse(val, event, config, nested) {
       if (val?.stack) error.stack = val.stack;
     }
     if (error.unhandled && !config.silent) console.error(error);
-    const { onError: onError2 } = config;
+    const { onError } = config;
     const errHeaders = event[kEventRes]?.[kEventResErrHeaders];
-    return onError2 && !nested ? Promise.resolve(onError2(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug, errHeaders);
+    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug, errHeaders);
   }
   const preparedRes = event[kEventRes];
   const preparedHeaders = preparedRes?.[kEventResHeaders];
@@ -2548,7 +2571,7 @@ function getResponse() {
 }
 var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
 async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("./_tanstack-start-manifest_v-CGHXgy5L-KSOQEPW7.js");
+  const { tsrStartManifest } = await import("./_tanstack-start-manifest_v-BhSwNUm2-HUY424SL.js");
   const startManifest = tsrStartManifest();
   let routes = startManifest.routes;
   routes[rootRouteId];
@@ -2614,20 +2637,15 @@ var SYM_SPLIT = Symbol.split;
 var SYM_TO_PRIMITIVE = Symbol.toPrimitive;
 var SYM_TO_STRING_TAG = Symbol.toStringTag;
 var SYM_UNSCOPABLES = Symbol.unscopables;
-var INV_SYMBOL_REF = {
-  [SYM_ASYNC_ITERATOR]: 0,
-  [SYM_HAS_INSTANCE]: 1,
-  [SYM_IS_CONCAT_SPREADABLE]: 2,
-  [SYM_ITERATOR]: 3,
-  [SYM_MATCH]: 4,
-  [SYM_MATCH_ALL]: 5,
-  [SYM_REPLACE]: 6,
-  [SYM_SEARCH]: 7,
-  [SYM_SPECIES]: 8,
-  [SYM_SPLIT]: 9,
-  [SYM_TO_PRIMITIVE]: 10,
-  [SYM_TO_STRING_TAG]: 11,
-  [SYM_UNSCOPABLES]: 12
+var TEMPORAL_TYPE_NAME = {
+  [0]: "Instant",
+  [1]: "Duration",
+  [2]: "PlainDate",
+  [3]: "PlainDateTime",
+  [4]: "PlainMonthDay",
+  [5]: "PlainTime",
+  [6]: "PlainYearMonth",
+  [7]: "ZonedDateTime"
 };
 var SYMBOL_REF = {
   [0]: SYM_ASYNC_ITERATOR,
@@ -2644,25 +2662,22 @@ var SYMBOL_REF = {
   [11]: SYM_TO_STRING_TAG,
   [12]: SYM_UNSCOPABLES
 };
+function createInverseSymbolTable() {
+  const result = {};
+  for (let i = 0; i <= 12; i++) result[SYMBOL_REF[i]] = i;
+  return result;
+}
+var INV_SYMBOL_REF = /* @__PURE__ */ createInverseSymbolTable();
 var CONSTANT_VAL = {
   [2]: true,
   [3]: false,
   [1]: void 0,
   [0]: null,
   [4]: -0,
-  [5]: Number.POSITIVE_INFINITY,
-  [6]: Number.NEGATIVE_INFINITY,
+  [5]: Infinity,
+  [6]: -Infinity,
   [7]: NaN
 };
-var ERROR_CONSTRUCTOR_STRING = {
-  [0]: "Error",
-  [1]: "EvalError",
-  [2]: "RangeError",
-  [3]: "ReferenceError",
-  [4]: "SyntaxError",
-  [5]: "TypeError",
-  [6]: "URIError"
-};
 var ERROR_CONSTRUCTOR = {
   [0]: Error,
   [1]: EvalError,
@@ -2672,7 +2687,18 @@ var ERROR_CONSTRUCTOR = {
   [5]: TypeError,
   [6]: URIError
 };
+function createErrorConstructorStringTable() {
+  const result = {};
+  for (let i = 0; i <= 6; i++) result[i] = ERROR_CONSTRUCTOR[i].name;
+  return result;
+}
+var ERROR_CONSTRUCTOR_STRING = /* @__PURE__ */ createErrorConstructorStringTable();
 function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) {
+  if (c === void 0 && m === void 0 && p === void 0 && e === void 0 && a === void 0 && f === void 0 && b === void 0 && o === void 0 && l === void 0) return {
+    t,
+    i,
+    s
+  };
   return {
     t,
     i,
@@ -2689,7 +2715,7 @@ function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) {
   };
 }
 function createConstantNode(value) {
-  return createSerovalNode(2, void 0, value, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(2, void 0, value);
 }
 var TRUE_NODE = /* @__PURE__ */ createConstantNode(2);
 var FALSE_NODE = /* @__PURE__ */ createConstantNode(3);
@@ -2700,80 +2726,116 @@ var INFINITY_NODE = /* @__PURE__ */ createConstantNode(5);
 var NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(6);
 var NAN_NODE = /* @__PURE__ */ createConstantNode(7);
 var MIN_JSON_STRINGIFY_LENGTH = 64;
-var JSON_ESCAPE_DIFFERENCES = /[\x00-\x07\x0b\x0e-\x1f<\u2028\u2029\ud800-\udfff]/;
-function serializeChar(str) {
-  switch (str) {
-    case '"':
+var NEEDS_ESCAPE = /["\\\n\r\b\t\f<\u2028\u2029]/;
+var JSON_ESCAPE_DIFFERENCES = /[\x00-\x07\x0b\x0e-\x1f\ud800-\udfff]/;
+var LESS_THAN = /</g;
+var LINE_SEPARATOR = /\u2028/g;
+var PARAGRAPH_SEPARATOR = /\u2029/g;
+function escapeCharCode(code) {
+  switch (code) {
+    case 34:
       return '\\"';
-    case "\\":
+    case 92:
       return "\\\\";
-    case "\n":
+    case 10:
       return "\\n";
-    case "\r":
+    case 13:
       return "\\r";
-    case "\b":
+    case 8:
       return "\\b";
-    case "	":
+    case 9:
       return "\\t";
-    case "\f":
+    case 12:
       return "\\f";
-    case "<":
+    case 60:
       return "\\x3C";
-    case "\u2028":
+    case 8232:
       return "\\u2028";
-    case "\u2029":
+    case 8233:
       return "\\u2029";
     default:
       return;
   }
 }
 function serializeString(str) {
-  if (str.length >= MIN_JSON_STRINGIFY_LENGTH && !JSON_ESCAPE_DIFFERENCES.test(str)) return JSON.stringify(str).slice(1, -1);
+  if (!NEEDS_ESCAPE.test(str)) return str;
+  if (str.length >= MIN_JSON_STRINGIFY_LENGTH && !JSON_ESCAPE_DIFFERENCES.test(str)) {
+    let result2 = JSON.stringify(str).slice(1, -1);
+    if (result2.includes("<")) result2 = result2.replace(LESS_THAN, "\\x3C");
+    if (result2.includes("\u2028")) result2 = result2.replace(LINE_SEPARATOR, "\\u2028");
+    if (result2.includes("\u2029")) result2 = result2.replace(PARAGRAPH_SEPARATOR, "\\u2029");
+    return result2;
+  }
   let result = "";
   let lastPos = 0;
   let replacement;
   for (let i = 0, len = str.length; i < len; i++) {
-    replacement = serializeChar(str[i]);
+    replacement = escapeCharCode(str.charCodeAt(i));
     if (replacement) {
       result += str.slice(lastPos, i) + replacement;
       lastPos = i + 1;
     }
   }
-  if (lastPos === 0) result = str;
-  else result += str.slice(lastPos);
-  return result;
-}
-function deserializeReplacer(str) {
-  switch (str) {
-    case "\\\\":
-      return "\\";
-    case '\\"':
-      return '"';
-    case "\\n":
-      return "\n";
-    case "\\r":
-      return "\r";
-    case "\\b":
-      return "\b";
-    case "\\t":
-      return "	";
-    case "\\f":
-      return "\f";
-    case "\\x3C":
-      return "<";
-    case "\\u2028":
-      return "\u2028";
-    case "\\u2029":
-      return "\u2029";
-    default:
-      return str;
-  }
+  return result + str.slice(lastPos);
 }
+var JSON_COMPATIBLE = /^(?:[^"\\\x00-\x1f]|\\["\\nrbtf])*$/;
+var ESCAPE_SEQUENCE = /(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g;
 function deserializeString(str) {
-  if (typeof str === "string" && !str.includes("\\")) return str;
-  return str.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, deserializeReplacer);
+  if (typeof str !== "string") return str.replace(ESCAPE_SEQUENCE, deserializeString);
+  let index = str.indexOf("\\");
+  if (index === -1) return str;
+  if (JSON_COMPATIBLE.test(str)) return JSON.parse('"' + str + '"');
+  let result = "";
+  let lastPos = 0;
+  const last = str.length - 1;
+  while (index !== -1 && index < last) {
+    let replacement;
+    let length = 2;
+    switch (str.charCodeAt(index + 1)) {
+      case 92:
+        replacement = "\\";
+        break;
+      case 34:
+        replacement = '"';
+        break;
+      case 110:
+        replacement = "\n";
+        break;
+      case 114:
+        replacement = "\r";
+        break;
+      case 98:
+        replacement = "\b";
+        break;
+      case 116:
+        replacement = "	";
+        break;
+      case 102:
+        replacement = "\f";
+        break;
+      case 120:
+        if (str.startsWith("3C", index + 2)) {
+          replacement = "<";
+          length = 4;
+        }
+        break;
+      case 117:
+        if (str.startsWith("2028", index + 2)) {
+          replacement = "\u2028";
+          length = 6;
+        } else if (str.startsWith("2029", index + 2)) {
+          replacement = "\u2029";
+          length = 6;
+        }
+    }
+    if (replacement) {
+      result += str.slice(lastPos, index) + replacement;
+      lastPos = index + length;
+      index = str.indexOf("\\", lastPos);
+    } else index = str.indexOf("\\", index + 1);
+  }
+  return result + str.slice(lastPos);
 }
-var { toString: objectToString } = Object.prototype;
 var STEP_ERROR_CODES = {
   parsing: 1,
   serialization: 2,
@@ -2782,10 +2844,9 @@ var STEP_ERROR_CODES = {
 function getErrorMessageProd(type) {
   return `Seroval Error (step: ${STEP_ERROR_CODES[type]})`;
 }
-var getErrorMessage = (type, cause) => getErrorMessageProd(type);
 var SerovalError = class extends Error {
   constructor(type, cause) {
-    super(getErrorMessage(type, cause));
+    super(getErrorMessageProd(type));
     this.cause = cause;
   }
 };
@@ -2823,12 +2884,6 @@ var SerovalMissingInstanceError = class extends Error {
     super(getSpecificErrorMessage(4));
   }
 };
-var SerovalMissingReferenceError = class extends Error {
-  constructor(value) {
-    super(getSpecificErrorMessage(5));
-    this.value = value;
-  }
-};
 var SerovalMissingReferenceForIdError = class extends Error {
   constructor(id) {
     super(getSpecificErrorMessage(6));
@@ -2844,92 +2899,73 @@ var SerovalMalformedNodeError = class extends Error {
     super(getSpecificErrorMessage(8));
   }
 };
+var SerovalConflictedNodeIdError = class extends Error {
+  constructor(node) {
+    super(getSpecificErrorMessage(9));
+  }
+};
 var SerovalDepthLimitError = class extends Error {
   constructor(limit) {
-    super(getSpecificErrorMessage(9));
+    super(getSpecificErrorMessage(10));
+  }
+};
+var SerovalLiveStreamError = class extends Error {
+  constructor(reason) {
+    super(getSpecificErrorMessage(12));
+    this.reason = reason;
   }
 };
-var REFERENCES_KEY = "__SEROVAL_REFS__";
-var REFERENCE = /* @__PURE__ */ new Map();
-var INV_REFERENCE = /* @__PURE__ */ new Map();
-function hasReferenceID(value) {
-  return REFERENCE.has(value);
-}
-function hasReference(id) {
-  return INV_REFERENCE.has(id);
-}
-function getReferenceID(value) {
-  if (hasReferenceID(value)) return REFERENCE.get(value);
-  throw new SerovalMissingReferenceError(value);
-}
-function getReference(id) {
-  if (hasReference(id)) return INV_REFERENCE.get(id);
-  throw new SerovalMissingReferenceForIdError(id);
-}
-if (typeof globalThis !== "undefined") Object.defineProperty(globalThis, REFERENCES_KEY, {
-  value: INV_REFERENCE,
-  configurable: true,
-  writable: false,
-  enumerable: false
-});
-else if (typeof window !== "undefined") Object.defineProperty(window, REFERENCES_KEY, {
-  value: INV_REFERENCE,
-  configurable: true,
-  writable: false,
-  enumerable: false
-});
-else if (typeof self !== "undefined") Object.defineProperty(self, REFERENCES_KEY, {
-  value: INV_REFERENCE,
-  configurable: true,
-  writable: false,
-  enumerable: false
-});
-else if (typeof global !== "undefined") Object.defineProperty(global, REFERENCES_KEY, {
-  value: INV_REFERENCE,
-  configurable: true,
-  writable: false,
-  enumerable: false
-});
 function getErrorConstructor(error) {
-  if (error instanceof EvalError) return 1;
-  if (error instanceof RangeError) return 2;
-  if (error instanceof ReferenceError) return 3;
-  if (error instanceof SyntaxError) return 4;
-  if (error instanceof TypeError) return 5;
-  if (error instanceof URIError) return 6;
+  for (let i = 1; i <= 6; i++) if (error instanceof ERROR_CONSTRUCTOR[i]) return i;
   return 0;
 }
-function getInitialErrorOptions(error) {
-  const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
-  if (error.name !== construct) return { name: error.name };
-  if (error.constructor.name !== construct) return { name: error.constructor.name };
-  return {};
-}
 function getErrorOptions(error, features) {
-  let options = getInitialErrorOptions(error);
-  const names = Object.getOwnPropertyNames(error);
-  for (let i = 0, len = names.length, name; i < len; i++) {
-    name = names[i];
-    if (name !== "name" && name !== "message") {
-      if (name === "stack") {
-        if (features & 4) {
-          options = options || {};
-          options[name] = error[name];
-        }
-      } else {
-        options = options || {};
-        options[name] = error[name];
-      }
-    }
-  }
+  const options = /* @__PURE__ */ Object.create(null);
+  const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];
+  if (error.name !== construct) options.name = error.name;
+  else if (error.constructor.name !== construct) options.name = error.constructor.name;
+  for (const name of Object.getOwnPropertyNames(error)) if (name !== "name" && name !== "message" && (name !== "stack" || features & 4)) options[name] = error[name];
   return options;
 }
 function getObjectFlag(obj) {
+  if (Object.isExtensible(obj)) return 0;
   if (Object.isFrozen(obj)) return 3;
   if (Object.isSealed(obj)) return 2;
-  if (Object.isExtensible(obj)) return 0;
   return 1;
 }
+function getTypedArrayConstructor(name) {
+  switch (name) {
+    case "Int8Array":
+      return Int8Array;
+    case "Int16Array":
+      return Int16Array;
+    case "Int32Array":
+      return Int32Array;
+    case "Uint8Array":
+      return Uint8Array;
+    case "Uint16Array":
+      return Uint16Array;
+    case "Uint32Array":
+      return Uint32Array;
+    case "Uint8ClampedArray":
+      return Uint8ClampedArray;
+    case "Float32Array":
+      return Float32Array;
+    case "Float64Array":
+      return Float64Array;
+    case "BigInt64Array":
+      return BigInt64Array;
+    case "BigUint64Array":
+      return BigUint64Array;
+    default:
+      throw new SerovalUnknownTypedArrayError(name);
+  }
+}
+var typedArrayNameGetter;
+function getTypedArrayName(value) {
+  if (!typedArrayNameGetter) typedArrayNameGetter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), Symbol.toStringTag).get;
+  return typedArrayNameGetter.call(value);
+}
 function createNumberNode(value) {
   switch (value) {
     case Number.POSITIVE_INFINITY:
@@ -2939,85 +2975,224 @@ function createNumberNode(value) {
   }
   if (value !== value) return NAN_NODE;
   if (Object.is(value, -0)) return NEG_ZERO_NODE;
-  return createSerovalNode(0, void 0, value, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(0, void 0, value);
 }
 function createStringNode(value) {
-  return createSerovalNode(1, void 0, serializeString(value), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(1, void 0, serializeString(value));
 }
 function createBigIntNode(current) {
-  return createSerovalNode(3, void 0, "" + current, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(3, void 0, "" + current);
 }
 function createIndexedValueNode(id) {
-  return createSerovalNode(4, id, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(4, id);
 }
 function createDateNode(id, current) {
   const timestamp = current.valueOf();
-  return createSerovalNode(5, id, timestamp !== timestamp ? "" : current.toISOString(), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(5, id, timestamp === timestamp ? current.toISOString() : "");
 }
 function createTemporalNode(id, type, current) {
-  return createSerovalNode(36, id, current.toString(), type, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(36, id, current.toString(), type);
 }
 function createRegExpNode(id, current) {
-  return createSerovalNode(6, id, void 0, serializeString(current.source), current.flags, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(6, id, void 0, serializeString(current.source), current.flags);
 }
 function createWKSymbolNode(id, current) {
-  return createSerovalNode(17, id, INV_SYMBOL_REF[current], void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(17, id, INV_SYMBOL_REF[current]);
 }
-function createReferenceNode(id, ref) {
-  return createSerovalNode(18, id, serializeString(getReferenceID(ref)), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+function createReferenceNode(id, referenceId) {
+  return createSerovalNode(18, id, serializeString(referenceId));
 }
 function createPluginNode(id, tag, value) {
-  return createSerovalNode(25, id, value, serializeString(tag), void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  return createSerovalNode(25, id, value, serializeString(tag));
 }
 function createArrayNode(id, current, parsedItems) {
-  return createSerovalNode(9, id, void 0, void 0, void 0, void 0, void 0, parsedItems, void 0, void 0, getObjectFlag(current), void 0);
+  return createSerovalNode(9, id, void 0, void 0, void 0, void 0, void 0, parsedItems, void 0, void 0, getObjectFlag(current));
 }
 function createBoxedNode(id, boxed) {
-  return createSerovalNode(21, id, void 0, void 0, void 0, void 0, void 0, void 0, boxed, void 0, void 0, void 0);
+  return createSerovalNode(21, id, void 0, void 0, void 0, void 0, void 0, void 0, boxed);
 }
 var MAX_TYPED_ARRAY_LENGTH = 1e6;
-function createTypedArrayNode(id, current, buffer) {
-  if (current.length > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
-  return createSerovalNode(15, id, void 0, current.constructor.name, void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, current.length);
-}
-function createBigIntTypedArrayNode(id, current, buffer) {
-  if (current.length > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
-  return createSerovalNode(16, id, void 0, current.constructor.name, void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, current.length);
-}
-function createDataViewNode(id, current, buffer) {
-  if (current.byteLength > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
-  return createSerovalNode(20, id, void 0, void 0, void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, current.byteLength);
+function createViewNode(type, id, current, buffer) {
+  const isDataView = type === 20;
+  const size = isDataView ? current.byteLength : current.length;
+  if (size > MAX_TYPED_ARRAY_LENGTH) throw new SerovalUnsupportedTypeError(current);
+  return createSerovalNode(type, id, void 0, isDataView ? void 0 : getTypedArrayName(current), void 0, void 0, void 0, void 0, buffer, current.byteOffset, void 0, size);
 }
-function createErrorNode(id, current, options) {
-  return createSerovalNode(13, id, getErrorConstructor(current), void 0, serializeString(current.message), options, void 0, void 0, void 0, void 0, void 0, void 0);
-}
-function createAggregateErrorNode(id, current, options) {
-  return createSerovalNode(14, id, getErrorConstructor(current), void 0, serializeString(current.message), options, void 0, void 0, void 0, void 0, void 0, void 0);
+function createErrorNode(type, id, current, options) {
+  return createSerovalNode(type, id, getErrorConstructor(current), void 0, serializeString(current.message), options);
 }
 function createSetNode(id, items) {
-  return createSerovalNode(7, id, void 0, void 0, void 0, void 0, void 0, items, void 0, void 0, void 0, void 0);
-}
-function createIteratorFactoryInstanceNode(factory, items) {
-  return createSerovalNode(28, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items], void 0, void 0, void 0, void 0);
-}
-function createAsyncIteratorFactoryInstanceNode(factory, items) {
-  return createSerovalNode(30, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items], void 0, void 0, void 0, void 0);
-}
-function createStreamConstructorNode(id, factory, sequence) {
-  return createSerovalNode(31, id, void 0, void 0, void 0, void 0, void 0, sequence, factory, void 0, void 0, void 0);
+  return createSerovalNode(7, id, void 0, void 0, void 0, void 0, void 0, items);
 }
-function createStreamNextNode(id, parsed) {
-  return createSerovalNode(32, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed, void 0, void 0, void 0);
+function createIteratorFactoryInstanceNode(type, factory, items) {
+  return createSerovalNode(type, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items]);
 }
-function createStreamThrowNode(id, parsed) {
-  return createSerovalNode(33, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed, void 0, void 0, void 0);
+function createStreamConstructorNode(id, factory, sequence, live) {
+  return createSerovalNode(31, id, void 0, void 0, void 0, void 0, void 0, sequence, factory, void 0, void 0, live);
 }
-function createStreamReturnNode(id, parsed) {
-  return createSerovalNode(34, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed, void 0, void 0, void 0);
+function createStreamEventNode(type, id, parsed) {
+  return createSerovalNode(type, id, void 0, void 0, void 0, void 0, void 0, void 0, parsed);
 }
 function createSequenceNode(id, sequence, throwAt, doneAt) {
   return createSerovalNode(35, id, throwAt, void 0, void 0, void 0, void 0, sequence, void 0, void 0, void 0, doneAt);
 }
+function isLiveStream(value) {
+  return value instanceof LiveStream;
+}
+var LiveStream = class {
+  constructor(options) {
+    this.consumed = false;
+    this.closed = false;
+    this.cancelled = false;
+    this.options = options;
+  }
+  deliver(reader, record) {
+    record.delivered = true;
+    reader.resolve({
+      event: record.event,
+      accept: () => {
+        if (this.pending === record && record.delivered) {
+          const terminal = record.event.type !== "next";
+          record.event = void 0;
+          this.pending = void 0;
+          const resolve = record.resolve;
+          record.resolve = void 0;
+          record.reject = void 0;
+          if (terminal) {
+            this.closed = true;
+            this.options = void 0;
+            const waiter = this.waiting;
+            this.waiting = void 0;
+            waiter?.reject(new SerovalLiveStreamError("closed"));
+          }
+          resolve?.();
+        }
+      }
+    });
+  }
+  /** @internal */
+  push(event) {
+    if (this.cancelled) return Promise.reject(this.cancelReason);
+    if (this.closed) return Promise.reject(new SerovalLiveStreamError("closed"));
+    if (this.pending) return Promise.reject(new SerovalLiveStreamError("pending"));
+    return new Promise((resolve, reject) => {
+      const record = {
+        event,
+        delivered: false,
+        resolve,
+        reject
+      };
+      this.pending = record;
+      if (this.waiting) {
+        const waiter = this.waiting;
+        this.waiting = void 0;
+        this.deliver(waiter, record);
+      }
+    });
+  }
+  cancel(reason) {
+    if (this.cancelled || this.closed) return;
+    this.cancelled = true;
+    this.cancelReason = reason;
+    const record = this.pending;
+    const waiter = this.waiting;
+    this.pending = void 0;
+    this.waiting = void 0;
+    const callbackOwner = this.options;
+    this.options = void 0;
+    if (record) {
+      record.event = void 0;
+      const reject = record.reject;
+      record.resolve = void 0;
+      record.reject = void 0;
+      reject?.(reason);
+    }
+    if (waiter) waiter.reject(reason);
+    callbackOwner?.onCancel?.(reason);
+  }
+  read() {
+    if (this.cancelled) return Promise.reject(this.cancelReason);
+    if (this.closed) return Promise.reject(new SerovalLiveStreamError("closed"));
+    if (this.waiting) return Promise.reject(new SerovalLiveStreamError("reading"));
+    return new Promise((resolve, reject) => {
+      const next = {
+        resolve,
+        reject
+      };
+      if (this.pending && !this.pending.delivered) this.deliver(next, this.pending);
+      else this.waiting = next;
+    });
+  }
+  consume() {
+    if (this.consumed) throw new SerovalLiveStreamError("consumed");
+    this.consumed = true;
+    return {
+      read: () => this.read(),
+      cancel: (reason) => this.cancel(reason)
+    };
+  }
+  /**
+  * Consumes the stream through a replay-style listener, accepting each
+  * event as soon as it has been delivered. Use `consume` or `pump` when
+  * acceptance must wait for processing.
+  */
+  on(listener) {
+    const wrap = (key) => (value, accept) => {
+      listener[key](value);
+      accept();
+    };
+    return this.pump({
+      next: wrap("next"),
+      throw: wrap("throw"),
+      return: wrap("return")
+    });
+  }
+  /**
+  * Consumes the stream into a sink that controls acceptance. Returns the
+  * cancel function.
+  * @internal
+  */
+  pump(sink) {
+    const consumer = this.consume();
+    let current = sink;
+    function next() {
+      consumer.read().then((delivery) => {
+        const target = current;
+        if (!target) return;
+        const event = delivery.event;
+        let failure;
+        let failed = false;
+        try {
+          failure = target[event.type](event.type === "throw" ? event.error : event.value, delivery.accept);
+        } catch (error) {
+          failed = true;
+          failure = error;
+        }
+        if (failed || failure !== void 0) {
+          current = void 0;
+          try {
+            consumer.cancel(failure);
+          } finally {
+            target.done?.();
+          }
+          return;
+        }
+        if (event.type === "next") {
+          next();
+          return;
+        }
+        current = void 0;
+        target.done?.();
+      }, (reason) => {
+        const target = current;
+        current = void 0;
+        target?.error?.(reason);
+      });
+    }
+    next();
+    return consumer.cancel;
+  }
+};
 var OpaqueReference = class {
   constructor(value, replacement) {
     this.value = value;
@@ -3036,75 +3211,6 @@ var PROMISE_CONSTRUCTOR = () => {
   });
   return resolver;
 };
-var STREAM_CONSTRUCTOR = () => {
-  const buffer = [];
-  const listeners = [];
-  let alive = true;
-  let success = false;
-  let count = 0;
-  const internal = {
-    flush(value, mode, x) {
-      for (x = 0; x < count; x++) {
-        const listener = listeners[x];
-        if (listener) listener[mode](value);
-      }
-    },
-    up(listener, x, z, current) {
-      for (x = 0, z = buffer.length; x < z; x++) {
-        current = buffer[x];
-        if (!alive && x === z - 1) listener[success ? "return" : "throw"](current);
-        else listener.next(current);
-      }
-    },
-    on(listener, temp = 0) {
-      let subscribed = alive;
-      if (alive) {
-        for (temp = 0; temp < count; temp++) if (!listeners[temp]) break;
-        if (temp === count) count++;
-        listeners[temp] = listener;
-      }
-      internal.up(listener);
-      return () => {
-        if (alive && subscribed) {
-          subscribed = false;
-          listeners[temp] = void 0;
-          while (count > 0 && !listeners[count - 1]) count--;
-          listeners.length = count;
-        }
-      };
-    }
-  };
-  return {
-    __SEROVAL_STREAM__: true,
-    on(listener) {
-      return internal.on(listener);
-    },
-    next(value) {
-      if (alive) {
-        buffer.push(value);
-        internal.flush(value, "next");
-      }
-    },
-    throw(value) {
-      if (alive) {
-        buffer.push(value);
-        internal.flush(value, "throw");
-        alive = false;
-        success = false;
-        listeners.length = 0;
-      }
-    },
-    return(value) {
-      if (alive) {
-        buffer.push(value);
-        internal.flush(value, "return");
-        alive = false;
-        success = true;
-        listeners.length = 0;
-      }
-    }
-  };
-};
 var ITERATOR_CONSTRUCTOR = (symbol) => (sequence) => () => {
   let index = 0;
   const instance = {
@@ -3210,23 +3316,25 @@ var ARRAY_BUFFER_CONSTRUCTOR = (b64) => {
   for (let i = 0; i < length; i++) arr[i] = decoded.charCodeAt(i);
   return arr.buffer;
 };
+var Sequence = class {
+  constructor(values, throwAt, doneAt) {
+    this.v = values;
+    this.t = throwAt;
+    this.d = doneAt;
+  }
+};
 function isSequence(value) {
-  return "__SEROVAL_SEQUENCE__" in value;
+  return value instanceof Sequence;
 }
 function createSequence(values, throwAt, doneAt) {
-  return {
-    __SEROVAL_SEQUENCE__: true,
-    v: values,
-    t: throwAt,
-    d: doneAt
-  };
+  return new Sequence(values, throwAt, doneAt);
 }
 function createSequenceFromIterable(source) {
   const values = [];
   let throwsAt = -1;
   let doneAt = -1;
   const iterator = source[SYM_ITERATOR]();
-  while (true) try {
+  for (; ; ) try {
     const value = iterator.next();
     values.push(value.value);
     if (value.done) {
@@ -3235,11 +3343,13 @@ function createSequenceFromIterable(source) {
     }
   } catch (error) {
     throwsAt = values.length;
+    doneAt = throwsAt;
     values.push(error);
+    break;
   }
   return createSequence(values, throwsAt, doneAt);
 }
-var createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
+var createIterator = /* @__PURE__ */ ITERATOR_CONSTRUCTOR(SYM_ITERATOR);
 function sequenceToIterator(sequence) {
   return createIterator(sequence);
 }
@@ -3253,49 +3363,87 @@ var SPECIAL_REFS = {
   [4]: {},
   [5]: {}
 };
-function isStream2(value) {
-  return "__SEROVAL_STREAM__" in value;
-}
-function createStream2() {
-  return STREAM_CONSTRUCTOR();
-}
-function createStreamFromAsyncIterable(iterable, cleanups) {
-  const stream = createStream2();
-  const iterator = iterable[SYM_ASYNC_ITERATOR]();
-  let cancelled = false;
-  let done = false;
-  cleanups === null || cleanups === void 0 || cleanups.push(() => {
-    if (!(done || cancelled)) {
-      cancelled = true;
-      Promise.resolve().then(() => {
-        var _iterator$return;
-        return (_iterator$return = iterator.return) === null || _iterator$return === void 0 ? void 0 : _iterator$return.call(iterator);
-      }).catch(() => {
-      });
+var Stream = class {
+  constructor(live) {
+    this.buffer = [];
+    this.listeners = [];
+    this.alive = true;
+    this.success = false;
+    this.count = 0;
+    this.live = live;
+  }
+  flush(value, mode) {
+    this.live > 1 || this.buffer.push(value);
+    for (let x = 0; x < this.count; x++) this.listeners[x]?.[mode](value);
+  }
+  replay(listener) {
+    for (let x = 0, z = this.buffer.length; x < z; x++) {
+      const current = this.buffer[x];
+      if (!this.alive && x === z - 1) listener[this.success ? "return" : "throw"](current);
+      else listener.next(current);
     }
-  });
-  async function push() {
-    try {
-      while (!cancelled) {
-        const value = await iterator.next();
-        if (cancelled) return;
-        if (value.done) {
-          done = true;
-          stream.return(value.value);
-          break;
-        }
-        stream.next(value.value);
+  }
+  on(listener) {
+    if (this.live > 1) throw new Error("Stream consumed");
+    let subscribed = this.alive;
+    let temp = 0;
+    if (subscribed) {
+      for (; temp < this.count; temp++) if (!this.listeners[temp]) break;
+      if (temp === this.count) this.count++;
+      this.listeners[temp] = listener;
+    }
+    this.replay(listener);
+    if (this.live) {
+      this.live = 2;
+      this.buffer.length = 0;
+    }
+    return () => {
+      if (this.alive && subscribed) {
+        subscribed = false;
+        this.listeners[temp] = void 0;
+        while (this.count > 0 && !this.listeners[this.count - 1]) this.count--;
+        this.listeners.length = this.count;
       }
-    } catch (error) {
-      done = true;
-      if (!cancelled) stream.throw(error);
+    };
+  }
+  /**
+  * Returns the events of a stream that has ended, without subscribing, so a
+  * live receiver is not consumed. The last value is the `return` or `throw`
+  * value. Returns `undefined` while the stream is open, or when a live
+  * receiver was already consumed and has no events left.
+  * @internal
+  */
+  endedEvents() {
+    if (this.alive || this.live > 1) return void 0;
+    return {
+      values: this.buffer.slice(),
+      success: this.success
+    };
+  }
+  next(value) {
+    if (this.alive) this.flush(value, "next");
+  }
+  throw(value) {
+    if (this.alive) {
+      this.flush(value, "throw");
+      this.alive = false;
+      this.success = false;
+      this.listeners.length = 0;
     }
   }
-  push().catch(() => {
-  });
-  return stream;
+  return(value) {
+    if (this.alive) {
+      this.flush(value, "return");
+      this.alive = false;
+      this.success = true;
+      this.listeners.length = 0;
+    }
+  }
+};
+function isStream(value) {
+  return value instanceof Stream || isLiveStream(value);
 }
-var createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(SYM_ASYNC_ITERATOR, PROMISE_CONSTRUCTOR);
+var createAsyncIterable = /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR(SYM_ASYNC_ITERATOR, PROMISE_CONSTRUCTOR);
 function streamToAsyncIterable(stream) {
   return createAsyncIterable(stream);
 }
@@ -3306,138 +3454,275 @@ async function promiseToResult(current) {
     return [0, e];
   }
 }
-function createBaseParserContext(mode, options) {
-  var _options$compactArray;
-  return {
-    plugins: options.plugins,
-    mode,
-    marked: /* @__PURE__ */ new Set(),
-    features: 127 ^ (options.disabledFeatures || 0),
-    refs: options.refs || /* @__PURE__ */ new Map(),
-    depthLimit: options.depthLimit || 1e3,
-    compactArrayBufferViews: (_options$compactArray = options.compactArrayBufferViews) !== null && _options$compactArray !== void 0 ? _options$compactArray : false
-  };
+function encodeArrayBuffer$1(current) {
+  const bytes = new Uint8Array(current);
+  if (typeof bytes.toBase64 === "function") return bytes.toBase64();
+  let result = "";
+  for (let i = 0, len = bytes.length; i < len; i++) result += String.fromCharCode(bytes[i]);
+  return btoa(result);
 }
-function markParserRef(ctx, id) {
-  ctx.marked.add(id);
+var MIN_NATIVE_BASE64_LENGTH = 512;
+function encodeArrayBuffer(current) {
+  if (typeof Buffer !== "undefined") return Buffer.from(current).toString("base64");
+  return encodeArrayBuffer$1(current);
 }
-function createIndexForValue(ctx, current) {
-  const id = ctx.refs.size;
-  ctx.refs.set(current, id);
-  return id;
+function decodeArrayBuffer(source) {
+  if (source.length < MIN_NATIVE_BASE64_LENGTH || typeof Buffer === "undefined") return ARRAY_BUFFER_CONSTRUCTOR(source);
+  const decoded = atob(source);
+  const buffer = new ArrayBuffer(decoded.length);
+  Buffer.from(buffer).write(decoded, "latin1");
+  return buffer;
 }
-function getNodeForIndexedValue(ctx, current) {
-  const registeredId = ctx.refs.get(current);
-  if (registeredId != null) {
-    markParserRef(ctx, registeredId);
-    return {
-      type: 1,
-      value: createIndexedValueNode(registeredId)
-    };
-  }
-  return {
-    type: 0,
-    value: createIndexForValue(ctx, current)
+function dedupePlugins(deduped, plugins) {
+  for (let i = 0, len = plugins.length; i < len; i++) {
+    const current = plugins[i];
+    if (!deduped.has(current)) {
+      deduped.add(current);
+      if (current.extends) dedupePlugins(deduped, current.extends);
+    }
+  }
+}
+var RESOLVED_PLUGINS = /* @__PURE__ */ new WeakMap();
+function matchResolved(resolved, plugins, added) {
+  for (let i = 0, len = plugins.length; i < len; i++) {
+    const current = plugins[i];
+    if (current === resolved[added]) {
+      added++;
+      if (current.extends) {
+        added = matchResolved(resolved, current.extends, added);
+        if (added === -1) return -1;
+      }
+    } else {
+      const index = resolved.indexOf(current);
+      if (index === -1 || index >= added) return -1;
+    }
+  }
+  return added;
+}
+function resolvePlugins(plugins) {
+  if (plugins) {
+    const cached = RESOLVED_PLUGINS.get(plugins);
+    if (cached && matchResolved(cached, plugins, 0) === cached.length) return cached;
+    const deduped = /* @__PURE__ */ new Set();
+    dedupePlugins(deduped, plugins);
+    const resolved = [...deduped];
+    RESOLVED_PLUGINS.set(plugins, resolved);
+    return resolved;
+  }
+}
+function getPlainObjectPlugins(plugins) {
+  if (plugins) {
+    for (let i = 0, len = plugins.length; i < len; i++) if (plugins[i].skipPlainObjects) {
+      const result = plugins.filter((plugin) => !plugin.skipPlainObjects);
+      return result.length ? result : void 0;
+    }
+  }
+  return plugins;
+}
+var REFERENCE = /* @__PURE__ */ new Map();
+var INV_REFERENCE = /* @__PURE__ */ new Map();
+function hasReference(id) {
+  return INV_REFERENCE.has(id);
+}
+function getReferenceID(value) {
+  return REFERENCE.get(value);
+}
+function getReference(id) {
+  if (hasReference(id)) return INV_REFERENCE.get(id);
+  throw new SerovalMissingReferenceForIdError(id);
+}
+function createBaseParserContext(options) {
+  return {
+    plugins: options.plugins,
+    plainObjectPlugins: getPlainObjectPlugins(options.plugins),
+    marked: /* @__PURE__ */ new Set(),
+    features: 127 ^ (options.disabledFeatures ?? 0),
+    refs: options.refs ?? /* @__PURE__ */ new Map(),
+    depthLimit: options.depthLimit || 1e3,
+    compactArrayBufferViews: options.compactArrayBufferViews ?? false
   };
 }
+function getObjectPlugins(ctx, current, currentClass) {
+  return currentClass === Object && Object.getPrototypeOf(current) === Object.prototype ? ctx.plainObjectPlugins : ctx.plugins;
+}
+function markParserRef(ctx, id) {
+  ctx.marked.add(id);
+}
+function createIndexForValue(ctx, current) {
+  const id = ctx.refs.size;
+  ctx.refs.set(current, id);
+  return id;
+}
+function getNodeForIndexedValue(ctx, current) {
+  const registeredId = ctx.refs.get(current);
+  if (registeredId != null) {
+    markParserRef(ctx, registeredId);
+    return createIndexedValueNode(registeredId);
+  }
+  return createIndexForValue(ctx, current);
+}
 function getReferenceNode(ctx, current) {
   const indexed = getNodeForIndexedValue(ctx, current);
-  if (indexed.type === 1) return indexed;
-  if (hasReferenceID(current)) return {
-    type: 2,
-    value: createReferenceNode(indexed.value, current)
-  };
-  return indexed;
+  if (typeof indexed !== "number") return indexed;
+  const referenceId = getReferenceID(current);
+  return referenceId === void 0 ? indexed : createReferenceNode(indexed, referenceId);
 }
 function parseWellKnownSymbol(ctx, current) {
   const ref = getReferenceNode(ctx, current);
-  if (ref.type !== 0) return ref.value;
-  if (current in INV_SYMBOL_REF) return createWKSymbolNode(ref.value, current);
+  if (typeof ref !== "number") return ref;
+  if (current in INV_SYMBOL_REF) return createWKSymbolNode(ref, current);
   throw new SerovalUnsupportedTypeError(current);
 }
 function parseSpecialReference(ctx, ref) {
   const result = getNodeForIndexedValue(ctx, SPECIAL_REFS[ref]);
-  if (result.type === 1) return result.value;
-  return createSerovalNode(26, result.value, ref, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0, void 0);
+  if (typeof result !== "number") return result;
+  return createSerovalNode(26, result, ref);
 }
 function parseIteratorFactory(ctx) {
   const result = getNodeForIndexedValue(ctx, ITERATOR);
-  if (result.type === 1) return result.value;
-  return createSerovalNode(27, result.value, void 0, void 0, void 0, void 0, void 0, void 0, parseWellKnownSymbol(ctx, SYM_ITERATOR), void 0, void 0, void 0);
+  if (typeof result !== "number") return result;
+  return createSerovalNode(27, result, void 0, void 0, void 0, void 0, void 0, void 0, parseWellKnownSymbol(ctx, SYM_ITERATOR));
 }
 function parseAsyncIteratorFactory(ctx) {
   const result = getNodeForIndexedValue(ctx, ASYNC_ITERATOR);
-  if (result.type === 1) return result.value;
-  return createSerovalNode(29, result.value, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(ctx, 1), parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR)], void 0, void 0, void 0, void 0);
+  if (typeof result !== "number") return result;
+  return createSerovalNode(29, result, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(ctx, 1), parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR)]);
+}
+function getTemporalType(currentClass) {
+  switch (currentClass) {
+    case Temporal.Instant:
+      return 0;
+    case Temporal.Duration:
+      return 1;
+    case Temporal.PlainDate:
+      return 2;
+    case Temporal.PlainDateTime:
+      return 3;
+    case Temporal.PlainMonthDay:
+      return 4;
+    case Temporal.PlainTime:
+      return 5;
+    case Temporal.PlainYearMonth:
+      return 6;
+    case Temporal.ZonedDateTime:
+      return 7;
+    default:
+      return;
+  }
+}
+function getObjectClass(current) {
+  const currentClass = current.constructor;
+  if (currentClass !== void 0 && typeof currentClass !== "function") {
+    const proto = Object.getPrototypeOf(current);
+    return proto === null ? void 0 : proto.constructor;
+  }
+  return currentClass;
+}
+function getObjectKind(current, currentClass, features) {
+  switch (currentClass) {
+    case Object:
+      return 1;
+    case void 0:
+      return 2;
+    case Date:
+      return 3;
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return 4;
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+      return 6;
+    case ArrayBuffer:
+      return 7;
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return 8;
+    case DataView:
+      return 10;
+    case Map:
+      return 11;
+    case Set:
+      return 12;
+  }
+  if (currentClass === Promise || current instanceof Promise) return 13;
+  if (features & 32 && currentClass === RegExp) return 14;
+  if (features & 16 && (currentClass === BigInt64Array || currentClass === BigUint64Array)) return 9;
+  if (features & 1 && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) return 5;
+  if (features & 64 && typeof Temporal !== "undefined" && getTemporalType(currentClass) != null) return 15;
+  if (current instanceof Error) return 4;
+  if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) return 16;
+  return 0;
 }
 function createObjectNode(id, current, empty, record) {
-  return createSerovalNode(empty ? 11 : 10, id, void 0, void 0, void 0, record, void 0, void 0, void 0, void 0, getObjectFlag(current), void 0);
+  return createSerovalNode(empty ? 11 : 10, id, void 0, void 0, void 0, record, void 0, void 0, void 0, void 0, getObjectFlag(current));
+}
+function parseMapSentinel(ctx) {
+  return parseSpecialReference(ctx, 0);
 }
-function createMapNode(ctx, id, k, v) {
+function createMapNode(id, sentinel, k, v) {
   return createSerovalNode(8, id, void 0, void 0, void 0, void 0, {
     k,
     v
-  }, void 0, parseSpecialReference(ctx, 0), void 0, void 0, void 0);
+  }, void 0, sentinel);
 }
 function createPromiseConstructorNode(ctx, id, resolver) {
-  return createSerovalNode(22, id, resolver, void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 1), void 0, void 0, void 0);
+  return createSerovalNode(22, id, resolver, void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 1));
 }
 function getArrayBufferView(ctx, current) {
   if (!ctx.compactArrayBufferViews) return current;
   const buffer = new Uint8Array(current.buffer, current.byteOffset, current.byteLength).slice().buffer;
-  const Constructor = current.constructor;
-  return new Constructor(buffer);
-}
-function encodeArrayBuffer(current) {
-  if (typeof Buffer !== "undefined") return Buffer.from(current).toString("base64");
-  const bytes = new Uint8Array(current);
-  if (typeof bytes.toBase64 === "function") return bytes.toBase64();
-  let result = "";
-  for (let i = 0, len = bytes.length; i < len; i++) result += String.fromCharCode(bytes[i]);
-  return btoa(result);
+  return new (current instanceof DataView ? DataView : getTypedArrayConstructor(getTypedArrayName(current)))(buffer);
 }
 function createArrayBufferNode(ctx, id, current) {
-  return createSerovalNode(19, id, encodeArrayBuffer(current), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5), void 0, void 0, void 0);
+  return createSerovalNode(19, id, encodeArrayBuffer(current), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5));
 }
-function createAsyncParserContext(mode, options) {
-  return {
-    base: createBaseParserContext(mode, options),
-    child: void 0
-  };
+function createAsyncParserContext(options) {
+  return { base: createBaseParserContext(options) };
 }
-var AsyncParsePluginContext = class {
-  constructor(_p, depth) {
-    this._p = _p;
-    this.depth = depth;
-  }
-  parse(current) {
-    return parseAsync(this._p, this.depth, current);
-  }
-};
 async function parseItems$1(ctx, depth, current) {
-  const nodes = [];
-  for (let i = 0, len = current.length; i < len; i++) if (i in current) nodes[i] = await parseAsync(ctx, depth, current[i]);
-  else nodes[i] = 0;
+  const len = current.length;
+  const nodes = new Array(len);
+  for (let i = 0, node; i < len; i++) if (i in current) {
+    node = parseValueAsync(ctx, depth, current[i]);
+    nodes[i] = node instanceof Promise ? await node : node;
+  } else nodes[i] = 0;
   return nodes;
 }
 async function parseArray$1(ctx, depth, id, current) {
   return createArrayNode(id, current, await parseItems$1(ctx, depth, current));
 }
 async function parseProperties$1(ctx, depth, properties) {
-  const entries = Object.entries(properties);
-  const keyNodes = [];
-  const valueNodes = [];
-  for (let i = 0, len = entries.length; i < len; i++) {
-    keyNodes.push(serializeString(entries[i][0]));
-    valueNodes.push(await parseAsync(ctx, depth, entries[i][1]));
+  const keys = Object.keys(properties);
+  const len = keys.length;
+  const keyNodes = new Array(len);
+  const valueNodes = new Array(len);
+  for (let i = 0, key, node; i < len; i++) {
+    key = keys[i];
+    keyNodes[i] = serializeString(key);
+    node = parseValueAsync(ctx, depth, properties[key]);
+    valueNodes[i] = node instanceof Promise ? await node : node;
   }
   if (SYM_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
-    valueNodes.push(createIteratorFactoryInstanceNode(parseIteratorFactory(ctx.base), await parseAsync(ctx, depth, createSequenceFromIterable(properties))));
+    valueNodes.push(createIteratorFactoryInstanceNode(28, parseIteratorFactory(ctx.base), await parseAsync(ctx, depth, createSequenceFromIterable(properties))));
   }
   if (SYM_ASYNC_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-    valueNodes.push(createAsyncIteratorFactoryInstanceNode(parseAsyncIteratorFactory(ctx.base), await parseAsync(ctx, depth, createStreamFromAsyncIterable(properties))));
+    valueNodes.push(createIteratorFactoryInstanceNode(30, parseAsyncIteratorFactory(ctx.base), await parseAsyncIterable$1(ctx, depth, properties)));
   }
   if (SYM_TO_STRING_TAG in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
@@ -3458,185 +3743,193 @@ async function parsePlainObject$1(ctx, depth, id, current, empty) {
 async function parseBoxed$1(ctx, depth, id, current) {
   return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));
 }
-async function parseTypedArray$1(ctx, depth, id, current) {
+async function parseView$1(ctx, depth, type, id, current) {
   current = getArrayBufferView(ctx.base, current);
-  return createTypedArrayNode(id, current, await parseAsync(ctx, depth, current.buffer));
+  return createViewNode(type, id, current, await parseAsync(ctx, depth, current.buffer));
 }
-async function parseBigIntTypedArray$1(ctx, depth, id, current) {
-  current = getArrayBufferView(ctx.base, current);
-  return createBigIntTypedArrayNode(id, current, await parseAsync(ctx, depth, current.buffer));
-}
-async function parseDataView$1(ctx, depth, id, current) {
-  current = getArrayBufferView(ctx.base, current);
-  return createDataViewNode(id, current, await parseAsync(ctx, depth, current.buffer));
-}
-async function parseError$1(ctx, depth, id, current) {
-  const options = getErrorOptions(current, ctx.base.features);
-  return createErrorNode(id, current, options ? await parseProperties$1(ctx, depth, options) : void 0);
-}
-async function parseAggregateError$1(ctx, depth, id, current) {
+async function parseError$1(ctx, depth, type, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
-  return createAggregateErrorNode(id, current, options ? await parseProperties$1(ctx, depth, options) : void 0);
+  return createErrorNode(type, id, current, options ? await parseProperties$1(ctx, depth, options) : void 0);
 }
 async function parseMap$1(ctx, depth, id, current) {
-  const keyNodes = [];
-  const valueNodes = [];
+  const sentinel = parseMapSentinel(ctx.base);
+  const keyNodes = new Array(current.size);
+  const valueNodes = new Array(current.size);
+  let node;
+  let i = 0;
   for (const [key, value] of current.entries()) {
-    keyNodes.push(await parseAsync(ctx, depth, key));
-    valueNodes.push(await parseAsync(ctx, depth, value));
+    node = parseValueAsync(ctx, depth, key);
+    keyNodes[i] = node instanceof Promise ? await node : node;
+    node = parseValueAsync(ctx, depth, value);
+    valueNodes[i] = node instanceof Promise ? await node : node;
+    i++;
   }
-  return createMapNode(ctx.base, id, keyNodes, valueNodes);
+  return createMapNode(id, sentinel, keyNodes, valueNodes);
 }
 async function parseSet$1(ctx, depth, id, current) {
-  const items = [];
-  for (const item of current.keys()) items.push(await parseAsync(ctx, depth, item));
+  const items = new Array(current.size);
+  let node;
+  let i = 0;
+  for (const item of current.keys()) {
+    node = parseValueAsync(ctx, depth, item);
+    items[i++] = node instanceof Promise ? await node : node;
+  }
   return createSetNode(id, items);
 }
-async function parsePlugin$1(ctx, depth, id, current) {
-  const currentPlugins = ctx.base.plugins;
+async function parsePlugin$1(ctx, depth, id, current, currentPlugins) {
   if (currentPlugins) for (let i = 0, len = currentPlugins.length; i < len; i++) {
     const plugin = currentPlugins[i];
-    if (plugin.parse.async && plugin.test(current)) return createPluginNode(id, plugin.tag, await plugin.parse.async(current, new AsyncParsePluginContext(ctx, depth), { id }));
+    if (plugin.parse.async && plugin.test(current)) return createPluginNode(id, plugin.tag, await plugin.parse.async(current, {
+      parse: (value) => parseAsync(ctx, depth, value),
+      parseStreamSource(source) {
+        if (depth >= ctx.base.depthLimit) throw new SerovalDepthLimitError(ctx.base.depthLimit);
+        return parseAsyncIterable$1(ctx, depth + 1, source);
+      }
+    }, { id }));
   }
 }
 async function parsePromise$1(ctx, depth, id, current) {
   const [status, result] = await promiseToResult(current);
-  return createSerovalNode(12, id, status, void 0, void 0, void 0, void 0, void 0, await parseAsync(ctx, depth, result), void 0, void 0, void 0);
+  return createSerovalNode(12, id, status, void 0, void 0, void 0, void 0, void 0, await parseAsync(ctx, depth, result));
 }
 function parseStreamHandle(depth, id, current, resolve, reject) {
   const sequence = [];
-  const cleanup = current.on({
-    next: (value) => {
-      markParserRef(this.base, id);
-      parseAsync(this, depth, value).then((data) => {
-        sequence.push(createStreamNextNode(id, data));
-      }, (data) => {
-        reject(data);
-        cleanup();
-      });
-    },
-    throw: (value) => {
-      markParserRef(this.base, id);
-      parseAsync(this, depth, value).then((data) => {
-        sequence.push(createStreamThrowNode(id, data));
-        resolve(sequence);
-        cleanup();
-      }, (data) => {
-        reject(data);
-        cleanup();
-      });
-    },
-    return: (value) => {
-      markParserRef(this.base, id);
-      parseAsync(this, depth, value).then((data) => {
-        sequence.push(createStreamReturnNode(id, data));
-        resolve(sequence);
-        cleanup();
-      }, (data) => {
-        reject(data);
-        cleanup();
-      });
+  let unparsed = 0;
+  let ended = false;
+  let settled = false;
+  const fail = (error) => {
+    if (!settled) {
+      settled = true;
+      try {
+        cleanup(error);
+      } catch {
+      }
+      reject(error);
     }
-  });
+  };
+  const handle = (type) => (value, accept) => {
+    if (settled) return;
+    markParserRef(this.base, id);
+    const slot = sequence.push(void 0) - 1;
+    unparsed++;
+    if (type !== 32) ended = true;
+    parseAsync(this, depth, value).then((data) => {
+      if (!settled) {
+        sequence[slot] = createStreamEventNode(type, id, data);
+        unparsed--;
+        accept?.();
+        if (ended && unparsed === 0) {
+          settled = true;
+          try {
+            cleanup();
+          } catch (error) {
+            reject(error);
+            return;
+          }
+          resolve(sequence);
+        }
+      }
+    }, fail);
+  };
+  const listener = {
+    next: handle(32),
+    throw: handle(33),
+    return: handle(34)
+  };
+  const cleanup = isLiveStream(current) ? current.pump(listener) : current.on(listener);
 }
 async function parseStream$1(ctx, depth, id, current) {
   return createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), await new Promise(parseStreamHandle.bind(ctx, depth, id, current)));
 }
+async function parseAsyncIterable$1(ctx, depth, current) {
+  const id = createIndexForValue(ctx.base, {});
+  const reference = parseSpecialReference(ctx.base, 4);
+  const iterator = current[SYM_ASYNC_ITERATOR]();
+  const sequence = [];
+  for (; ; ) {
+    let result;
+    try {
+      result = await iterator.next();
+    } catch (error) {
+      markParserRef(ctx.base, id);
+      sequence.push(createStreamEventNode(33, id, await parseAsync(ctx, depth, error)));
+      break;
+    }
+    markParserRef(ctx.base, id);
+    let parsed;
+    try {
+      parsed = await parseAsync(ctx, depth, result.value);
+    } catch (error) {
+      Promise.resolve().then(() => iterator.return?.()).catch(() => {
+      });
+      throw error;
+    }
+    sequence.push(createStreamEventNode(result.done ? 34 : 32, id, parsed));
+    if (result.done) break;
+  }
+  return createStreamConstructorNode(id, reference, sequence);
+}
 async function parseSequence$1(ctx, depth, id, current) {
-  const nodes = [];
-  for (let i = 0, len = current.v.length; i < len; i++) nodes[i] = await parseAsync(ctx, depth, current.v[i]);
+  const len = current.v.length;
+  const nodes = new Array(len);
+  for (let i = 0, node; i < len; i++) {
+    node = parseValueAsync(ctx, depth, current.v[i]);
+    nodes[i] = node instanceof Promise ? await node : node;
+  }
   return createSequenceNode(id, nodes, current.t, current.d);
 }
 async function parseObjectAsync(ctx, depth, id, current) {
   if (Array.isArray(current)) return parseArray$1(ctx, depth, id, current);
-  if (isStream2(current)) return parseStream$1(ctx, depth, id, current);
+  if (isStream(current)) return parseStream$1(ctx, depth, id, current);
   if (isSequence(current)) return parseSequence$1(ctx, depth, id, current);
-  let currentClass = current.constructor;
-  if (currentClass !== void 0 && typeof currentClass !== "function") {
-    const proto = Object.getPrototypeOf(current);
-    currentClass = proto === null ? void 0 : proto.constructor;
-  }
+  const currentClass = getObjectClass(current);
   if (currentClass === OpaqueReference) return parseAsync(ctx, depth, current.replacement);
-  const parsed = await parsePlugin$1(ctx, depth, id, current);
+  const parsed = await parsePlugin$1(ctx, depth, id, current, getObjectPlugins(ctx.base, current, currentClass));
   if (parsed) return parsed;
-  switch (currentClass) {
-    case Object:
-      return parsePlainObject$1(ctx, depth, id, current, false);
-    case void 0:
+  if (currentClass === Object) return parsePlainObject$1(ctx, depth, id, current, false);
+  switch (getObjectKind(current, currentClass, ctx.base.features)) {
+    case 2:
       return parsePlainObject$1(ctx, depth, id, current, true);
-    case Date:
+    case 3:
       return createDateNode(id, current);
-    case Error:
-    case EvalError:
-    case RangeError:
-    case ReferenceError:
-    case SyntaxError:
-    case TypeError:
-    case URIError:
-      return parseError$1(ctx, depth, id, current);
-    case Number:
-    case Boolean:
-    case String:
-    case BigInt:
+    case 4:
+      return parseError$1(ctx, depth, 13, id, current);
+    case 5:
+      return parseError$1(ctx, depth, 14, id, current);
+    case 6:
       return parseBoxed$1(ctx, depth, id, current);
-    case ArrayBuffer:
+    case 7:
       return createArrayBufferNode(ctx.base, id, current);
-    case Int8Array:
-    case Int16Array:
-    case Int32Array:
-    case Uint8Array:
-    case Uint16Array:
-    case Uint32Array:
-    case Uint8ClampedArray:
-    case Float32Array:
-    case Float64Array:
-      return parseTypedArray$1(ctx, depth, id, current);
-    case DataView:
-      return parseDataView$1(ctx, depth, id, current);
-    case Map:
+    case 8:
+      return parseView$1(ctx, depth, 15, id, current);
+    case 9:
+      return parseView$1(ctx, depth, 16, id, current);
+    case 10:
+      return parseView$1(ctx, depth, 20, id, current);
+    case 11:
       return parseMap$1(ctx, depth, id, current);
-    case Set:
+    case 12:
       return parseSet$1(ctx, depth, id, current);
+    case 13:
+      return parsePromise$1(ctx, depth, id, current);
+    case 14:
+      return createRegExpNode(id, current);
+    case 15:
+      return createTemporalNode(id, getTemporalType(currentClass), current);
+    case 16:
+      return parsePlainObject$1(ctx, depth, id, current, !!currentClass);
+    default:
+      throw new SerovalUnsupportedTypeError(current);
   }
-  if (currentClass === Promise || current instanceof Promise) return parsePromise$1(ctx, depth, id, current);
-  const currentFeatures = ctx.base.features;
-  if (currentFeatures & 32 && currentClass === RegExp) return createRegExpNode(id, current);
-  if (currentFeatures & 16) switch (currentClass) {
-    case BigInt64Array:
-    case BigUint64Array:
-      return parseBigIntTypedArray$1(ctx, depth, id, current);
-  }
-  if (currentFeatures & 1 && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) return parseAggregateError$1(ctx, depth, id, current);
-  if (currentFeatures & 64 && typeof Temporal !== "undefined") switch (currentClass) {
-    case Temporal.Instant:
-      return createTemporalNode(id, 0, current);
-    case Temporal.Duration:
-      return createTemporalNode(id, 1, current);
-    case Temporal.PlainDate:
-      return createTemporalNode(id, 2, current);
-    case Temporal.PlainDateTime:
-      return createTemporalNode(id, 3, current);
-    case Temporal.PlainMonthDay:
-      return createTemporalNode(id, 4, current);
-    case Temporal.PlainTime:
-      return createTemporalNode(id, 5, current);
-    case Temporal.PlainYearMonth:
-      return createTemporalNode(id, 6, current);
-    case Temporal.ZonedDateTime:
-      return createTemporalNode(id, 7, current);
-  }
-  if (current instanceof Error) return parseError$1(ctx, depth, id, current);
-  if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) return parsePlainObject$1(ctx, depth, id, current, !!currentClass);
-  throw new SerovalUnsupportedTypeError(current);
 }
 async function parseFunctionAsync(ctx, depth, current) {
   const ref = getReferenceNode(ctx.base, current);
-  if (ref.type !== 0) return ref.value;
-  const plugin = await parsePlugin$1(ctx, depth, ref.value, current);
+  if (typeof ref !== "number") return ref;
+  const plugin = await parsePlugin$1(ctx, depth, ref, current, ctx.base.plugins);
   if (plugin) return plugin;
   throw new SerovalUnsupportedTypeError(current);
 }
-async function parseAsync(ctx, depth, current) {
+function parseValueAsync(ctx, depth, current) {
   if (depth >= ctx.base.depthLimit) throw new SerovalDepthLimitError(ctx.base.depthLimit);
   switch (typeof current) {
     case "boolean":
@@ -3652,7 +3945,7 @@ async function parseAsync(ctx, depth, current) {
     case "object":
       if (current) {
         const ref = getReferenceNode(ctx.base, current);
-        return ref.type === 0 ? await parseObjectAsync(ctx, depth + 1, ref.value, current) : ref.value;
+        return typeof ref === "number" ? parseObjectAsync(ctx, depth + 1, ref, current) : ref;
       }
       return NULL_NODE;
     case "symbol":
@@ -3663,6 +3956,9 @@ async function parseAsync(ctx, depth, current) {
       throw new SerovalUnsupportedTypeError(current);
   }
 }
+async function parseAsync(ctx, depth, current) {
+  return await parseValueAsync(ctx, depth, current);
+}
 async function parseTopAsync(ctx, current) {
   try {
     return await parseAsync(ctx, 0, current);
@@ -3670,50 +3966,6 @@ async function parseTopAsync(ctx, current) {
     throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
   }
 }
-function dedupePlugins(deduped, plugins) {
-  for (let i = 0, len = plugins.length; i < len; i++) {
-    const current = plugins[i];
-    if (!deduped.has(current)) {
-      deduped.add(current);
-      if (current.extends) dedupePlugins(deduped, current.extends);
-    }
-  }
-}
-function resolvePlugins(plugins) {
-  if (plugins) {
-    const deduped = /* @__PURE__ */ new Set();
-    dedupePlugins(deduped, plugins);
-    return [...deduped];
-  }
-}
-function getTypedArrayConstructor(name) {
-  switch (name) {
-    case "Int8Array":
-      return Int8Array;
-    case "Int16Array":
-      return Int16Array;
-    case "Int32Array":
-      return Int32Array;
-    case "Uint8Array":
-      return Uint8Array;
-    case "Uint16Array":
-      return Uint16Array;
-    case "Uint32Array":
-      return Uint32Array;
-    case "Uint8ClampedArray":
-      return Uint8ClampedArray;
-    case "Float32Array":
-      return Float32Array;
-    case "Float64Array":
-      return Float64Array;
-    case "BigInt64Array":
-      return BigInt64Array;
-    case "BigUint64Array":
-      return BigUint64Array;
-    default:
-      throw new SerovalUnknownTypedArrayError(name);
-  }
-}
 function isValidKey(key) {
   switch (key) {
     case "constructor":
@@ -3740,7 +3992,6 @@ function isValidSymbol(symbol) {
   }
 }
 var DEFAULT_MAX_BASE64_LENGTH = 1e6;
-var MIN_NATIVE_BASE64_LENGTH = 512;
 var MAX_BIGINT_LENGTH = 1e4;
 var MAX_REGEXP_SOURCE_LENGTH = 2e4;
 function applyObjectFlag(obj, flag) {
@@ -3756,61 +4007,45 @@ function applyObjectFlag(obj, flag) {
   }
 }
 var DEFAULT_DEPTH_LIMIT = 1e3;
-function createBaseDeserializerContext(mode, options) {
-  var _options$maxBase64Len, _options$features;
-  const maxBase64Length = (_options$maxBase64Len = options.maxBase64Length) !== null && _options$maxBase64Len !== void 0 ? _options$maxBase64Len : DEFAULT_MAX_BASE64_LENGTH;
+function createBaseDeserializerContext(options) {
+  const maxBase64Length = options.maxBase64Length ?? DEFAULT_MAX_BASE64_LENGTH;
   if (!Number.isSafeInteger(maxBase64Length) || maxBase64Length < 0) throw new RangeError("maxBase64Length must be a non-negative safe integer");
-  const refs = options.refs || /* @__PURE__ */ new Map();
+  const refs = options.refs ?? /* @__PURE__ */ new Map();
   if (!("types" in refs)) Object.assign(refs, { types: /* @__PURE__ */ new Map() });
   return {
-    mode,
     plugins: options.plugins,
     refs,
-    features: (_options$features = options.features) !== null && _options$features !== void 0 ? _options$features : 127 ^ (options.disabledFeatures || 0),
+    features: options.features ?? 127 ^ (options.disabledFeatures ?? 0),
     depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,
     maxBase64Length
   };
 }
 function createVanillaDeserializerContext(options) {
   return {
-    mode: 1,
-    base: createBaseDeserializerContext(1, options),
-    child: void 0,
-    state: { marked: new Set(options.markedRefs) }
+    base: createBaseDeserializerContext(options),
+    marked: new Set(options.markedRefs)
   };
 }
-var DeserializePluginContext = class {
-  constructor(_p, depth) {
-    this._p = _p;
-    this.depth = depth;
-  }
-  deserialize(node) {
-    return deserialize$1(this._p, this.depth, node);
-  }
-};
 function guardIndexedValue(ctx, id) {
-  if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) throw new SerovalMalformedNodeError({
+  const node = {
     t: 4,
     i: id
-  });
-  if (ctx.refs.has(id)) throw new Error("Conflicted ref id: " + id);
+  };
+  if (id < 0 || !Number.isInteger(id)) throw new SerovalMalformedNodeError(node);
+  if (ctx.refs.has(id)) throw new SerovalConflictedNodeIdError(node);
 }
 function isThennable(value) {
-  return !!value && typeof value === "object" && "then" in value && typeof value.then === "function";
+  return !!value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function";
 }
-function assignIndexedValueVanilla(ctx, id, value) {
-  guardIndexedValue(ctx.base, id);
-  if (ctx.state.marked.has(id)) ctx.base.refs.set(id, value);
-  return value;
-}
-function assignIndexedValueCross(ctx, id, value) {
+var ignoreRejection = () => {
+};
+function assignIndexedValue$1(ctx, id, value) {
   guardIndexedValue(ctx.base, id);
-  ctx.base.refs.set(id, value);
+  if (ctx.base.pending && value instanceof Promise) value.catch(ignoreRejection);
+  const marked = ctx.marked;
+  if (!marked || marked.has(id)) ctx.base.refs.set(id, value);
   return value;
 }
-function assignIndexedValue$1(ctx, id, value) {
-  return ctx.mode === 1 ? assignIndexedValueVanilla(ctx, id, value) : assignIndexedValueCross(ctx, id, value);
-}
 function deserializeKnownValue(node, record, key) {
   if (Object.hasOwn(record, key)) return record[key];
   throw new SerovalMalformedNodeError(node);
@@ -3818,8 +4053,12 @@ function deserializeKnownValue(node, record, key) {
 function deserializeReference(ctx, node) {
   return assignIndexedValue$1(ctx, node.i, getReference(deserializeString(node.s)));
 }
+function validateNodeList(node, list) {
+  if (!Array.isArray(list)) throw new SerovalMalformedNodeError(node);
+}
 function deserializeArray(ctx, depth, node) {
   const items = node.a;
+  validateNodeList(node, items);
   const len = items.length;
   const result = assignIndexedValue$1(ctx, node.i, new Array(len));
   for (let i = 0, item; i < len; i++) {
@@ -3862,7 +4101,10 @@ function validateNodeType(ctx, node, id, type) {
 }
 function deserializeProperties(ctx, depth, node, result) {
   const keys = node.k;
-  if (keys.length > 0) for (let i = 0, vals = node.v, len = keys.length; i < len; i++) assignProperty(ctx, depth, result, keys[i], vals[i]);
+  validateNodeList(node, keys);
+  validateNodeList(node, node.v);
+  const len = keys.length;
+  if (len > 0) for (let i = 0, vals = node.v; i < len; i++) assignProperty(ctx, depth, result, keys[i], vals[i]);
   return result;
 }
 function deserializeObject(ctx, depth, node) {
@@ -3876,36 +4118,8 @@ function deserializeDate(ctx, node) {
 }
 function deserializeTemporal(ctx, node) {
   if (!(ctx.base.features & 64)) throw new SerovalUnsupportedNodeError(node);
-  let value;
-  switch (node.c) {
-    case 0:
-      value = Temporal.Instant.from(node.s);
-      break;
-    case 1:
-      value = Temporal.Duration.from(node.s);
-      break;
-    case 2:
-      value = Temporal.PlainDate.from(node.s);
-      break;
-    case 3:
-      value = Temporal.PlainDateTime.from(node.s);
-      break;
-    case 4:
-      value = Temporal.PlainMonthDay.from(node.s);
-      break;
-    case 5:
-      value = Temporal.PlainTime.from(node.s);
-      break;
-    case 6:
-      value = Temporal.PlainYearMonth.from(node.s);
-      break;
-    case 7:
-      value = Temporal.ZonedDateTime.from(node.s);
-      break;
-    default:
-      throw new SerovalMalformedNodeError(node);
-  }
-  return assignIndexedValue$1(ctx, node.i, value);
+  const construct = Temporal[deserializeKnownValue(node, TEMPORAL_TYPE_NAME, node.c)];
+  return assignIndexedValue$1(ctx, node.i, construct.from(node.s));
 }
 function deserializeRegExp(ctx, node) {
   if (ctx.base.features & 32) {
@@ -3917,43 +4131,29 @@ function deserializeRegExp(ctx, node) {
 }
 function deserializeSet(ctx, depth, node) {
   const result = assignIndexedValue$1(ctx, node.i, /* @__PURE__ */ new Set());
+  validateNodeList(node, node.a);
   for (let i = 0, items = node.a, len = items.length; i < len; i++) result.add(deserialize$1(ctx, depth, items[i]));
   return result;
 }
 function deserializeMap(ctx, depth, node) {
   const result = assignIndexedValue$1(ctx, node.i, /* @__PURE__ */ new Map());
+  validateNodeList(node, node.e.k);
+  validateNodeList(node, node.e.v);
   for (let i = 0, keys = node.e.k, vals = node.e.v, len = keys.length; i < len; i++) result.set(deserialize$1(ctx, depth, keys[i]), deserialize$1(ctx, depth, vals[i]));
   return result;
 }
 function deserializeArrayBuffer(ctx, node) {
   if (typeof node.s !== "string") throw new SerovalMalformedNodeError(node);
   if (node.s.length > ctx.base.maxBase64Length) throw new RangeError("ArrayBuffer exceeds maxBase64Length (" + ctx.base.maxBase64Length + ")");
-  const source = deserializeString(node.s);
-  let buffer;
-  if (source.length < MIN_NATIVE_BASE64_LENGTH || typeof Buffer === "undefined") buffer = ARRAY_BUFFER_CONSTRUCTOR(source);
-  else {
-    const decoded = atob(source);
-    buffer = new ArrayBuffer(decoded.length);
-    Buffer.from(buffer).write(decoded, "latin1");
-  }
+  const buffer = decodeArrayBuffer(deserializeString(node.s));
   return assignIndexedValue$1(ctx, node.i, buffer);
 }
-function deserializeTypedArray(ctx, depth, node) {
-  var _node$b;
-  const construct = getTypedArrayConstructor(node.c);
+function deserializeView(ctx, depth, node, construct) {
   const source = deserialize$1(ctx, depth, node.f);
   if (!(source instanceof ArrayBuffer)) throw new SerovalMalformedNodeError(node);
-  const offset = (_node$b = node.b) !== null && _node$b !== void 0 ? _node$b : 0;
+  const offset = node.b ?? 0;
   if (offset < 0 || offset > source.byteLength) throw new SerovalMalformedNodeError(node);
-  return assignIndexedValue$1(ctx, node.i, new construct(source, offset, node.l));
-}
-function deserializeDataView(ctx, depth, node) {
-  var _node$b2;
-  const source = deserialize$1(ctx, depth, node.f);
-  if (!(source instanceof ArrayBuffer)) throw new SerovalMalformedNodeError(node);
-  const offset = (_node$b2 = node.b) !== null && _node$b2 !== void 0 ? _node$b2 : 0;
-  if (offset < 0 || offset > source.byteLength) throw new SerovalMalformedNodeError(node);
-  return assignIndexedValue$1(ctx, node.i, new DataView(source, offset, node.l));
+  return assignIndexedValue$1(ctx, node.i, construct ? new construct(source, offset, node.l) : new DataView(source, offset, node.l));
 }
 function deserializeDictionary(ctx, depth, node, result) {
   if (node.p) {
@@ -3987,7 +4187,7 @@ function deserializePlugin(ctx, depth, node) {
     const tag = deserializeString(node.c);
     for (let i = 0, len = currentPlugins.length; i < len; i++) {
       const plugin = currentPlugins[i];
-      if (plugin.tag === tag) return assignIndexedValue$1(ctx, node.i, plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), { id: node.i }));
+      if (plugin.tag === tag) return assignIndexedValue$1(ctx, node.i, plugin.deserialize(node.s, { deserialize: (current) => deserialize$1(ctx, depth, current) }, { id: node.i }));
     }
   }
   throw new SerovalMissingPluginError(node.c);
@@ -3995,6 +4195,7 @@ function deserializePlugin(ctx, depth, node) {
 function deserializePromiseConstructor(ctx, node) {
   const value = assignIndexedValue$1(ctx, node.i, assignIndexedValue$1(ctx, node.s, PROMISE_CONSTRUCTOR()).p);
   assignNodeType(ctx, node.s, 22);
+  ctx.base.pending?.add(node.s);
   return value;
 }
 function deserializePromiseFulfill(ctx, depth, node) {
@@ -4005,6 +4206,7 @@ function deserializePromiseFulfill(ctx, depth, node) {
     if (isThennable(deserialized)) throw new SerovalMalformedNodeError(node.a[1]);
     if (node.t === 23) deferred.s(deserialized);
     else deferred.f(deserialized);
+    ctx.base.pending?.delete(node.i);
     return;
   }
   throw new SerovalMissingInstanceError("Promise");
@@ -4012,48 +4214,31 @@ function deserializePromiseFulfill(ctx, depth, node) {
 function deserializeIteratorFactoryInstance(ctx, depth, node) {
   deserialize$1(ctx, depth, node.a[0]);
   const source = deserialize$1(ctx, depth, node.a[1]);
-  validateNodeType(ctx, node, node.a[1].i, 35);
-  if (!source) throw new SerovalMalformedNodeError(node.a[1]);
+  if (!isSequence(source)) throw new SerovalMalformedNodeError(node.a[1]);
   return sequenceToIterator(source);
 }
 function deserializeAsyncIteratorFactoryInstance(ctx, depth, node) {
   deserialize$1(ctx, depth, node.a[0]);
   const source = deserialize$1(ctx, depth, node.a[1]);
-  validateNodeType(ctx, node, node.a[1].i, 31);
-  if (!source) throw new SerovalMalformedNodeError(node.a[1]);
+  if (!isStream(source)) throw new SerovalMalformedNodeError(node.a[1]);
   return streamToAsyncIterable(source);
 }
 function deserializeStreamConstructor(ctx, depth, node) {
-  const result = assignIndexedValue$1(ctx, node.i, createStream2());
+  const result = assignIndexedValue$1(ctx, node.i, new Stream(node.l === 1 ? 1 : void 0));
   assignNodeType(ctx, node.i, 31);
+  ctx.base.pending?.add(node.i);
   const items = node.a;
+  validateNodeList(node, items);
   const len = items.length;
   if (len) for (let i = 0; i < len; i++) deserialize$1(ctx, depth, items[i]);
   return result;
 }
-function deserializeStreamNext(ctx, depth, node) {
-  const deferred = ctx.base.refs.get(node.i);
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, 31);
-    deferred.next(deserialize$1(ctx, depth, node.f));
-    return;
-  }
-  throw new SerovalMissingInstanceError("Stream");
-}
-function deserializeStreamThrow(ctx, depth, node) {
-  const deferred = ctx.base.refs.get(node.i);
-  if (deferred) {
-    validateNodeType(ctx, node, node.i, 31);
-    deferred.throw(deserialize$1(ctx, depth, node.f));
-    return;
-  }
-  throw new SerovalMissingInstanceError("Stream");
-}
-function deserializeStreamReturn(ctx, depth, node) {
+function deserializeStreamCall(ctx, depth, node, method) {
   const deferred = ctx.base.refs.get(node.i);
   if (deferred) {
     validateNodeType(ctx, node, node.i, 31);
-    deferred.return(deserialize$1(ctx, depth, node.f));
+    deferred[method](deserialize$1(ctx, depth, node.f));
+    if (method !== "next") ctx.base.pending?.delete(node.i);
     return;
   }
   throw new SerovalMissingInstanceError("Stream");
@@ -4064,10 +4249,16 @@ function deserializeIteratorFactory(ctx, depth, node) {
 function deserializeAsyncIteratorFactory(ctx, depth, node) {
   deserialize$1(ctx, depth, node.a[1]);
 }
+function isSequenceIndex(value, size) {
+  return Number.isInteger(value) && value >= -1 && value < size;
+}
 function deserializeSequence(ctx, depth, node) {
+  validateNodeList(node, node.a);
+  const size = node.a.length;
+  if (!(isSequenceIndex(node.s, size) && isSequenceIndex(node.l, size))) throw new SerovalMalformedNodeError(node);
   const result = assignIndexedValue$1(ctx, node.i, createSequence([], node.s, node.l));
   assignNodeType(ctx, node.i, 35);
-  for (let i = 0, len = node.a.length; i < len; i++) result.v[i] = deserialize$1(ctx, depth, node.a[i]);
+  for (let i = 0; i < size; i++) result.v[i] = deserialize$1(ctx, depth, node.a[i]);
   return result;
 }
 function deserialize$1(ctx, depth, node) {
@@ -4104,9 +4295,9 @@ function deserialize$1(ctx, depth, node) {
       return deserializeArrayBuffer(ctx, node);
     case 16:
     case 15:
-      return deserializeTypedArray(ctx, depth, node);
+      return deserializeView(ctx, depth, node, getTypedArrayConstructor(node.c));
     case 20:
-      return deserializeDataView(ctx, depth, node);
+      return deserializeView(ctx, depth, node);
     case 14:
       return deserializeAggregateError(ctx, depth, node);
     case 13:
@@ -4131,11 +4322,11 @@ function deserialize$1(ctx, depth, node) {
     case 31:
       return deserializeStreamConstructor(ctx, depth, node);
     case 32:
-      return deserializeStreamNext(ctx, depth, node);
+      return deserializeStreamCall(ctx, depth, node, "next");
     case 33:
-      return deserializeStreamThrow(ctx, depth, node);
+      return deserializeStreamCall(ctx, depth, node, "throw");
     case 34:
-      return deserializeStreamReturn(ctx, depth, node);
+      return deserializeStreamCall(ctx, depth, node, "return");
     case 27:
       return deserializeIteratorFactory(ctx, depth, node);
     case 29:
@@ -4155,67 +4346,10 @@ function deserializeTop(ctx, node) {
     throw new SerovalDeserializationError(error);
   }
 }
-var SyncParsePluginContext = class {
-  constructor(_p, depth) {
-    this._p = _p;
-    this.depth = depth;
-  }
-  parse(current) {
-    return parseSOS(this._p, this.depth, current);
-  }
-};
-var StreamParsePluginContext = class {
-  constructor(_p, depth) {
-    this._p = _p;
-    this.depth = depth;
-  }
-  parse(current) {
-    return parseSOS(this._p, this.depth, current);
-  }
-  parseWithError(current) {
-    return parseWithError(this._p, this.depth, current);
-  }
-  isAlive() {
-    return this._p.state.alive;
-  }
-  pushPendingState() {
-    pushPendingState(this._p);
-  }
-  popPendingState() {
-    popPendingState(this._p);
-  }
-  onParse(node) {
-    onParse(this._p, node);
-  }
-  onError(error) {
-    onError(this._p, error);
-  }
-  addCleanup(callback) {
-    this._p.state.cleanups.push(callback);
-  }
-};
-function createStreamParserState(options) {
-  return {
-    alive: true,
-    pending: 0,
-    initial: true,
-    buffer: [],
-    onParse: options.onParse,
-    onError: options.onError,
-    onDone: options.onDone,
-    cleanups: []
-  };
-}
-function createStreamParserContext(options) {
-  return {
-    type: 2,
-    base: createBaseParserContext(2, options),
-    state: createStreamParserState(options)
-  };
-}
 function parseItems(ctx, depth, current) {
-  const nodes = [];
-  for (let i = 0, len = current.length; i < len; i++) if (i in current) nodes[i] = parseSOS(ctx, depth, current[i]);
+  const len = current.length;
+  const nodes = new Array(len);
+  for (let i = 0; i < len; i++) if (i in current) nodes[i] = parseSOS(ctx, depth, current[i]);
   else nodes[i] = 0;
   return nodes;
 }
@@ -4223,20 +4357,22 @@ function parseArray(ctx, depth, id, current) {
   return createArrayNode(id, current, parseItems(ctx, depth, current));
 }
 function parseProperties(ctx, depth, properties) {
-  const entries = Object.entries(properties);
-  const keyNodes = [];
-  const valueNodes = [];
-  for (let i = 0, len = entries.length; i < len; i++) {
-    keyNodes.push(serializeString(entries[i][0]));
-    valueNodes.push(parseSOS(ctx, depth, entries[i][1]));
+  const keys = Object.keys(properties);
+  const len = keys.length;
+  const keyNodes = new Array(len);
+  const valueNodes = new Array(len);
+  for (let i = 0, key; i < len; i++) {
+    key = keys[i];
+    keyNodes[i] = serializeString(key);
+    valueNodes[i] = parseSOS(ctx, depth, properties[key]);
   }
   if (SYM_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));
-    valueNodes.push(createIteratorFactoryInstanceNode(parseIteratorFactory(ctx.base), parseSOS(ctx, depth, createSequenceFromIterable(properties))));
+    valueNodes.push(createIteratorFactoryInstanceNode(28, parseIteratorFactory(ctx.base), parseSOS(ctx, depth, createSequenceFromIterable(properties))));
   }
   if (SYM_ASYNC_ITERATOR in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));
-    valueNodes.push(createAsyncIteratorFactoryInstanceNode(parseAsyncIteratorFactory(ctx.base), parseSOS(ctx, depth, ctx.type === 1 ? createStream2() : createStreamFromAsyncIterable(properties, ctx.state.cleanups))));
+    valueNodes.push(createIteratorFactoryInstanceNode(30, parseAsyncIteratorFactory(ctx.base), parseAsyncIterable(ctx, depth, properties)));
   }
   if (SYM_TO_STRING_TAG in properties) {
     keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));
@@ -4251,206 +4387,142 @@ function parseProperties(ctx, depth, properties) {
     v: valueNodes
   };
 }
+function parseAsyncIterable(ctx, depth, current) {
+  if (ctx.type !== 2) throw new SerovalUnsupportedTypeError(current);
+  const id = createIndexForValue(ctx.base, {});
+  const result = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), []);
+  ctx.state.iterable(ctx, depth, id, current);
+  return result;
+}
 function parsePlainObject(ctx, depth, id, current, empty) {
   return createObjectNode(id, current, empty, parseProperties(ctx, depth, current));
 }
 function parseBoxed(ctx, depth, id, current) {
   return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));
 }
-function parseTypedArray(ctx, depth, id, current) {
-  current = getArrayBufferView(ctx.base, current);
-  return createTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-function parseBigIntTypedArray(ctx, depth, id, current) {
+function parseView(ctx, depth, type, id, current) {
   current = getArrayBufferView(ctx.base, current);
-  return createBigIntTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-function parseDataView(ctx, depth, id, current) {
-  current = getArrayBufferView(ctx.base, current);
-  return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));
-}
-function parseError(ctx, depth, id, current) {
-  const options = getErrorOptions(current, ctx.base.features);
-  return createErrorNode(id, current, options ? parseProperties(ctx, depth, options) : void 0);
+  return createViewNode(type, id, current, parseSOS(ctx, depth, current.buffer));
 }
-function parseAggregateError(ctx, depth, id, current) {
+function parseError(ctx, depth, type, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
-  return createAggregateErrorNode(id, current, options ? parseProperties(ctx, depth, options) : void 0);
+  return createErrorNode(type, id, current, options ? parseProperties(ctx, depth, options) : void 0);
 }
 function parseMap(ctx, depth, id, current) {
-  const keyNodes = [];
-  const valueNodes = [];
+  const sentinel = parseMapSentinel(ctx.base);
+  const keyNodes = new Array(current.size);
+  const valueNodes = new Array(current.size);
+  let i = 0;
   for (const [key, value] of current.entries()) {
-    keyNodes.push(parseSOS(ctx, depth, key));
-    valueNodes.push(parseSOS(ctx, depth, value));
+    keyNodes[i] = parseSOS(ctx, depth, key);
+    valueNodes[i] = parseSOS(ctx, depth, value);
+    i++;
   }
-  return createMapNode(ctx.base, id, keyNodes, valueNodes);
+  return createMapNode(id, sentinel, keyNodes, valueNodes);
 }
 function parseSet(ctx, depth, id, current) {
-  const items = [];
-  for (const item of current.keys()) items.push(parseSOS(ctx, depth, item));
+  const items = new Array(current.size);
+  let i = 0;
+  for (const item of current.keys()) items[i++] = parseSOS(ctx, depth, item);
   return createSetNode(id, items);
 }
-function parseStream(ctx, depth, id, current) {
-  const result = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), []);
-  if (ctx.type === 1) return result;
-  pushPendingState(ctx);
-  current.on({
-    next: (value) => {
-      if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, depth, value);
-        if (parsed) onParse(ctx, createStreamNextNode(id, parsed));
-      }
-    },
-    throw: (value) => {
-      if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, depth, value);
-        if (parsed) onParse(ctx, createStreamThrowNode(id, parsed));
-      }
-      popPendingState(ctx);
-    },
-    return: (value) => {
-      if (ctx.state.alive) {
-        const parsed = parseWithError(ctx, depth, value);
-        if (parsed) onParse(ctx, createStreamReturnNode(id, parsed));
-      }
-      popPendingState(ctx);
-    }
-  });
-  return result;
+function parseEndedStream(ctx, depth, id, current) {
+  const events = current.endedEvents();
+  if (!events) throw new SerovalUnsupportedTypeError(current);
+  const values = events.values;
+  const last = values.length - 1;
+  const sequence = new Array(values.length);
+  if (last >= 0) markParserRef(ctx.base, id);
+  for (let i = 0; i <= last; i++) sequence[i] = createStreamEventNode(i < last ? 32 : events.success ? 34 : 33, id, parseSOS(ctx, depth, values[i]));
+  return sequence;
 }
-function handlePromiseSuccess(id, depth, data) {
-  if (this.state.alive) {
-    const parsed = parseWithError(this, depth, data);
-    if (parsed) onParse(this, createSerovalNode(23, id, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(this.base, 2), parsed], void 0, void 0, void 0, void 0));
-    popPendingState(this);
+function parseStream(ctx, depth, id, current) {
+  const reference = parseSpecialReference(ctx.base, 4);
+  if (ctx.type === 2) {
+    const result = createStreamConstructorNode(id, reference, []);
+    ctx.state.stream(ctx, depth, id, current);
+    return result;
   }
+  return createStreamConstructorNode(id, reference, parseEndedStream(ctx, depth, id, current));
 }
-function handlePromiseFailure(id, depth, data) {
-  if (this.state.alive) {
-    const parsed = parseWithError(this, depth, data);
-    if (parsed) onParse(this, createSerovalNode(24, id, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(this.base, 3), parsed], void 0, void 0, void 0, void 0));
-  }
-  popPendingState(this);
+function parseLiveStream(ctx, depth, id, current) {
+  if (ctx.type !== 2) throw new SerovalUnsupportedTypeError(current);
+  const result = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), [], 1);
+  ctx.state.live(ctx, depth, id, current);
+  return result;
 }
 function parsePromise(ctx, depth, id, current) {
+  if (ctx.type !== 2) throw new SerovalUnsupportedTypeError(current);
   const resolver = createIndexForValue(ctx.base, {});
-  if (ctx.type === 2) {
-    pushPendingState(ctx);
-    current.then(handlePromiseSuccess.bind(ctx, resolver, depth), handlePromiseFailure.bind(ctx, resolver, depth));
-  }
+  ctx.state.promise(ctx, resolver, depth, current);
   return createPromiseConstructorNode(ctx.base, id, resolver);
 }
 function parsePluginSync(ctx, depth, id, current, currentPlugins) {
   for (let i = 0, len = currentPlugins.length; i < len; i++) {
     const plugin = currentPlugins[i];
-    if (plugin.parse.sync && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.sync(current, new SyncParsePluginContext(ctx, depth), { id }));
-  }
-}
-function parsePluginStream(ctx, depth, id, current, currentPlugins) {
-  for (let i = 0, len = currentPlugins.length; i < len; i++) {
-    const plugin = currentPlugins[i];
-    if (plugin.parse.stream && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.stream(current, new StreamParsePluginContext(ctx, depth), { id }));
+    if (plugin.parse.sync && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.sync(current, { parse: (value) => parseSOS(ctx, depth, value) }, { id }));
   }
 }
-function parsePlugin(ctx, depth, id, current) {
-  const currentPlugins = ctx.base.plugins;
-  if (currentPlugins) return ctx.type === 1 ? parsePluginSync(ctx, depth, id, current, currentPlugins) : parsePluginStream(ctx, depth, id, current, currentPlugins);
+function parsePlugin(ctx, depth, id, current, currentPlugins) {
+  if (currentPlugins) return ctx.type === 1 ? parsePluginSync(ctx, depth, id, current, currentPlugins) : ctx.state.plugin(ctx, depth, id, current, currentPlugins);
 }
 function parseSequence(ctx, depth, id, current) {
-  const nodes = [];
-  for (let i = 0, len = current.v.length; i < len; i++) nodes[i] = parseSOS(ctx, depth, current.v[i]);
+  const len = current.v.length;
+  const nodes = new Array(len);
+  for (let i = 0; i < len; i++) nodes[i] = parseSOS(ctx, depth, current.v[i]);
   return createSequenceNode(id, nodes, current.t, current.d);
 }
 function parseObjectPhase2(ctx, depth, id, current, currentClass) {
-  switch (currentClass) {
-    case Object:
-      return parsePlainObject(ctx, depth, id, current, false);
-    case void 0:
+  if (currentClass === Object) return parsePlainObject(ctx, depth, id, current, false);
+  switch (getObjectKind(current, currentClass, ctx.base.features)) {
+    case 2:
       return parsePlainObject(ctx, depth, id, current, true);
-    case Date:
+    case 3:
       return createDateNode(id, current);
-    case Error:
-    case EvalError:
-    case RangeError:
-    case ReferenceError:
-    case SyntaxError:
-    case TypeError:
-    case URIError:
-      return parseError(ctx, depth, id, current);
-    case Number:
-    case Boolean:
-    case String:
-    case BigInt:
+    case 4:
+      return parseError(ctx, depth, 13, id, current);
+    case 5:
+      return parseError(ctx, depth, 14, id, current);
+    case 6:
       return parseBoxed(ctx, depth, id, current);
-    case ArrayBuffer:
+    case 7:
       return createArrayBufferNode(ctx.base, id, current);
-    case Int8Array:
-    case Int16Array:
-    case Int32Array:
-    case Uint8Array:
-    case Uint16Array:
-    case Uint32Array:
-    case Uint8ClampedArray:
-    case Float32Array:
-    case Float64Array:
-      return parseTypedArray(ctx, depth, id, current);
-    case DataView:
-      return parseDataView(ctx, depth, id, current);
-    case Map:
+    case 8:
+      return parseView(ctx, depth, 15, id, current);
+    case 9:
+      return parseView(ctx, depth, 16, id, current);
+    case 10:
+      return parseView(ctx, depth, 20, id, current);
+    case 11:
       return parseMap(ctx, depth, id, current);
-    case Set:
+    case 12:
       return parseSet(ctx, depth, id, current);
+    case 13:
+      return parsePromise(ctx, depth, id, current);
+    case 14:
+      return createRegExpNode(id, current);
+    case 15:
+      return createTemporalNode(id, getTemporalType(currentClass), current);
+    case 16:
+      return parsePlainObject(ctx, depth, id, current, !!currentClass);
+    default:
+      throw new SerovalUnsupportedTypeError(current);
   }
-  if (currentClass === Promise || current instanceof Promise) return parsePromise(ctx, depth, id, current);
-  const currentFeatures = ctx.base.features;
-  if (currentFeatures & 32 && currentClass === RegExp) return createRegExpNode(id, current);
-  if (currentFeatures & 16) switch (currentClass) {
-    case BigInt64Array:
-    case BigUint64Array:
-      return parseBigIntTypedArray(ctx, depth, id, current);
-  }
-  if (currentFeatures & 1 && typeof AggregateError !== "undefined" && (currentClass === AggregateError || current instanceof AggregateError)) return parseAggregateError(ctx, depth, id, current);
-  if (currentFeatures & 64 && typeof Temporal !== "undefined") switch (currentClass) {
-    case Temporal.Instant:
-      return createTemporalNode(id, 0, current);
-    case Temporal.Duration:
-      return createTemporalNode(id, 1, current);
-    case Temporal.PlainDate:
-      return createTemporalNode(id, 2, current);
-    case Temporal.PlainDateTime:
-      return createTemporalNode(id, 3, current);
-    case Temporal.PlainMonthDay:
-      return createTemporalNode(id, 4, current);
-    case Temporal.PlainTime:
-      return createTemporalNode(id, 5, current);
-    case Temporal.PlainYearMonth:
-      return createTemporalNode(id, 6, current);
-    case Temporal.ZonedDateTime:
-      return createTemporalNode(id, 7, current);
-  }
-  if (current instanceof Error) return parseError(ctx, depth, id, current);
-  if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) return parsePlainObject(ctx, depth, id, current, !!currentClass);
-  throw new SerovalUnsupportedTypeError(current);
 }
 function parseObject(ctx, depth, id, current) {
   if (Array.isArray(current)) return parseArray(ctx, depth, id, current);
-  if (isStream2(current)) return parseStream(ctx, depth, id, current);
+  if (isStream(current)) return isLiveStream(current) ? parseLiveStream(ctx, depth, id, current) : parseStream(ctx, depth, id, current);
   if (isSequence(current)) return parseSequence(ctx, depth, id, current);
-  let currentClass = current.constructor;
-  if (currentClass !== void 0 && typeof currentClass !== "function") {
-    const proto = Object.getPrototypeOf(current);
-    currentClass = proto === null ? void 0 : proto.constructor;
-  }
+  const currentClass = getObjectClass(current);
   if (currentClass === OpaqueReference) return parseSOS(ctx, depth, current.replacement);
-  const parsed = parsePlugin(ctx, depth, id, current);
+  const parsed = parsePlugin(ctx, depth, id, current, getObjectPlugins(ctx.base, current, currentClass));
   if (parsed) return parsed;
   return parseObjectPhase2(ctx, depth, id, current, currentClass);
 }
 function parseFunction(ctx, depth, current) {
   const ref = getReferenceNode(ctx.base, current);
-  if (ref.type !== 0) return ref.value;
-  const plugin = parsePlugin(ctx, depth, ref.value, current);
+  if (typeof ref !== "number") return ref;
+  const plugin = parsePlugin(ctx, depth, ref, current, ctx.base.plugins);
   if (plugin) return plugin;
   throw new SerovalUnsupportedTypeError(current);
 }
@@ -4470,7 +4542,7 @@ function parseSOS(ctx, depth, current) {
     case "object":
       if (current) {
         const ref = getReferenceNode(ctx.base, current);
-        return ref.type === 0 ? parseObject(ctx, depth + 1, ref.value, current) : ref.value;
+        return typeof ref === "number" ? parseObject(ctx, depth + 1, ref, current) : ref;
       }
       return NULL_NODE;
     case "symbol":
@@ -4481,61 +4553,400 @@ function parseSOS(ctx, depth, current) {
       throw new SerovalUnsupportedTypeError(current);
   }
 }
-function onParse(ctx, node) {
-  if (ctx.state.initial) ctx.state.buffer.push(node);
-  else onParseInternal(ctx, node, false);
+function createStreamParsePluginContext(ctx, depth) {
+  const state = ctx.state;
+  function parse(current) {
+    state.parsing++;
+    try {
+      return parseSOS(ctx, depth, current);
+    } finally {
+      state.parsing--;
+      if (!state.alive) releaseParserValues(ctx);
+    }
+  }
+  return {
+    parse,
+    parseStreamSource(current) {
+      state.parsing++;
+      try {
+        if (depth >= ctx.base.depthLimit) throw new SerovalDepthLimitError(ctx.base.depthLimit);
+        const id = createIndexForValue(ctx.base, {});
+        const node = createStreamConstructorNode(id, parseSpecialReference(ctx.base, 4), [], 1);
+        iterateAsync(ctx, depth + 1, id, current, true);
+        return node;
+      } finally {
+        state.parsing--;
+        if (!state.alive) releaseParserValues(ctx);
+      }
+    },
+    parseWithError(current) {
+      try {
+        return parse(current);
+      } catch (error) {
+        stopStreamParse(ctx, 1, error);
+        return;
+      }
+    },
+    isAlive: () => state.alive,
+    pushPendingState: () => {
+      pushPendingState(ctx);
+    },
+    popPendingState: () => {
+      popPendingState(ctx);
+    },
+    onParse(node) {
+      if (state.alive) {
+        state.queue.push({
+          node,
+          initial: false,
+          accept: void 0
+        });
+        drainOutput(ctx);
+      }
+    },
+    onError(error) {
+      stopStreamParse(ctx, 1, error);
+    },
+    addCleanup(callback) {
+      addCleanup(ctx, callback);
+    }
+  };
+}
+function getStreamParsePluginContext(ctx, depth) {
+  const contexts = ctx.state.pluginContexts;
+  return contexts[depth] ?? (contexts[depth] = createStreamParsePluginContext(ctx, depth));
+}
+function addCleanup(ctx, callback) {
+  if (ctx.state.alive) ctx.state.cleanups.push(callback);
+  else callback();
 }
-function onError(ctx, error) {
-  if (ctx.state.onError) ctx.state.onError(error);
-  else throw error instanceof SerovalParserError ? error : new SerovalParserError(error);
+function parsePluginStream(ctx, depth, id, current, currentPlugins) {
+  for (let i = 0, len = currentPlugins.length; i < len; i++) {
+    const plugin = currentPlugins[i];
+    if (plugin.parse.stream && plugin.test(current)) return createPluginNode(id, plugin.tag, plugin.parse.stream(current, getStreamParsePluginContext(ctx, depth), { id }));
+  }
 }
-function onDone(ctx) {
-  if (ctx.state.onDone) ctx.state.onDone();
-  for (let i = 0, len = ctx.state.cleanups.length; i < len; i++) ctx.state.cleanups[i]();
+function streamListener(ctx, depth, id, subscription) {
+  const handle = (type, terminal) => (value, accept) => {
+    let failure = void 0;
+    if (ctx.state.alive) try {
+      failure = parseEvent(ctx, depth, value, createStreamEventNode.bind(null, type, id), accept);
+    } catch (error) {
+      if (!subscription?.active) throw error;
+      subscription.failure ?? (subscription.failure = { value: error });
+      failure = error;
+    }
+    if (terminal && !accept) popPendingState(ctx);
+    return failure;
+  };
+  return {
+    next: handle(32, false),
+    throw: handle(33, true),
+    return: handle(34, true),
+    done() {
+      popPendingState(ctx);
+    },
+    error(reason) {
+      if (ctx.state.alive) stopStreamParse(ctx, 1, reason);
+    }
+  };
 }
-function onParseInternal(ctx, node, initial) {
+function subscribeStream(ctx, depth, id, current) {
+  pushPendingState(ctx);
+  const subscription = {
+    active: true,
+    failure: void 0
+  };
+  let cleanup;
   try {
-    ctx.state.onParse(node, initial);
+    cleanup = current.on(streamListener(ctx, depth, id, subscription));
+  } finally {
+    subscription.active = false;
+  }
+  try {
+    addCleanup(ctx, cleanup);
   } catch (error) {
-    onError(ctx, error);
+    subscription.failure ?? (subscription.failure = { value: error });
+  }
+  const failure = subscription.failure;
+  subscription.failure = void 0;
+  if (failure) throw failure.value;
+}
+function consumeLiveStream(ctx, depth, id, current) {
+  const cancel = current.pump(streamListener(ctx, depth, id));
+  pushPendingState(ctx);
+  addCleanup(ctx, () => {
+    cancel(ctx.state.reason);
+  });
+}
+function wrapPromiseResult(ctx, type, id, node) {
+  return createSerovalNode(type, id, void 0, void 0, void 0, void 0, void 0, [parseSpecialReference(ctx.base, type === 23 ? 2 : 3), node], void 0, void 0, void 0, void 0);
+}
+function handlePromise(type, id, depth, data) {
+  if (this.state.alive) parseEvent(this, depth, data, wrapPromiseResult.bind(null, this, type, id), void 0);
+  popPendingState(this);
+}
+function watchPromise(ctx, resolver, depth, current) {
+  pushPendingState(ctx);
+  current.then(handlePromise.bind(ctx, 23, resolver, depth), handlePromise.bind(ctx, 24, resolver, depth));
+}
+function returnIterator(iterator) {
+  Promise.resolve().then(() => iterator.return?.()).catch(() => {
+  });
+}
+function iterateAsync(ctx, depth, id, current, forwardReason) {
+  const iterator = current[SYM_ASYNC_ITERATOR]();
+  const listener = streamListener(ctx, depth, id);
+  let active = true;
+  function stop() {
+    if (active) {
+      active = false;
+      if (forwardReason) try {
+        Promise.resolve(iterator.return?.(ctx.state.reason)).catch(() => {
+        });
+      } catch {
+      }
+      else returnIterator(iterator);
+    }
+  }
+  function pull() {
+    if (active) iterator.next().then((result) => {
+      if (active) {
+        if (result.done) {
+          active = false;
+          listener.return(result.value, void 0);
+        } else if (listener.next(result.value, pull) !== void 0) {
+          stop();
+          listener.done();
+        }
+      }
+    }, (error) => {
+      if (active) {
+        active = false;
+        listener.throw(error, void 0);
+      }
+    });
   }
+  pushPendingState(ctx);
+  addCleanup(ctx, stop);
+  pull();
+}
+function createStreamParserState(options) {
+  return {
+    alive: true,
+    pending: 0,
+    parsing: 0,
+    queue: [],
+    writing: false,
+    inFlight: void 0,
+    reason: void 0,
+    onParse: options.onParse,
+    onError: options.onError,
+    onDone: options.onDone,
+    cleanups: [],
+    pluginContexts: [],
+    stream: subscribeStream,
+    live: consumeLiveStream,
+    promise: watchPromise,
+    iterable: iterateAsync,
+    plugin: parsePluginStream
+  };
+}
+function createStreamParserContext(options) {
+  return {
+    type: 2,
+    base: createBaseParserContext(options),
+    state: createStreamParserState(options)
+  };
 }
 function pushPendingState(ctx) {
-  ctx.state.pending++;
+  if (ctx.state.alive) ctx.state.pending++;
 }
 function popPendingState(ctx) {
-  if (--ctx.state.pending <= 0) onDone(ctx);
+  if (ctx.state.alive) {
+    ctx.state.pending--;
+    checkStreamParse(ctx);
+  }
 }
-function parseWithError(ctx, depth, current) {
+function parseEvent(ctx, depth, value, wrap, accept) {
+  const state = ctx.state;
+  const record = {
+    node: void 0,
+    initial: false,
+    accept
+  };
+  let failure;
+  state.queue.push(record);
+  state.parsing++;
   try {
-    return parseSOS(ctx, depth, current);
-  } catch (err) {
-    onError(ctx, err);
-    return;
+    record.node = wrap(parseSOS(ctx, depth, value));
+  } catch (error) {
+    failure = { value: error };
+  } finally {
+    state.parsing--;
+    if (!state.alive) releaseParserValues(ctx);
+  }
+  if (failure) stopStreamParse(ctx, 1, failure.value);
+  else drainOutput(ctx);
+  return failure?.value;
+}
+function drainOutput(ctx) {
+  const state = ctx.state;
+  if (state.writing || state.parsing > 0) return;
+  while (state.alive && state.queue.length > 0) {
+    const record = state.queue.shift();
+    if (!record.node) continue;
+    let pending;
+    state.writing = true;
+    state.inFlight = record;
+    state.parsing++;
+    try {
+      if (!state.onParse) throw new Error("Stream output callback is unavailable");
+      const result = state.onParse(record.node, record.initial);
+      if (result !== null && (typeof result === "object" || typeof result === "function")) {
+        const then = Reflect.get(result, "then");
+        if (typeof then === "function") pending = new Promise((resolve, reject) => {
+          Reflect.apply(then, result, [resolve, reject]);
+        });
+      }
+    } catch (error) {
+      releaseRecord(record);
+      stopStreamParse(ctx, 1, error);
+      return;
+    } finally {
+      state.parsing--;
+      if (!state.alive) releaseParserValues(ctx);
+    }
+    record.node = void 0;
+    if (pending) {
+      if (!state.alive) releaseRecord(record);
+      pending.then(() => {
+        state.writing = false;
+        state.inFlight = void 0;
+        if (state.alive) {
+          const accept2 = record.accept;
+          releaseRecord(record);
+          accept2?.();
+          drainOutput(ctx);
+        }
+      }, (error) => {
+        state.writing = false;
+        state.inFlight = void 0;
+        releaseRecord(record);
+        stopStreamParse(ctx, 1, error);
+      });
+      return;
+    }
+    if (!state.alive) {
+      releaseRecord(record);
+      return;
+    }
+    state.writing = false;
+    state.inFlight = void 0;
+    const accept = record.accept;
+    releaseRecord(record);
+    accept?.();
   }
+  checkStreamParse(ctx);
+}
+function checkStreamParse(ctx) {
+  const state = ctx.state;
+  if (state.alive && state.parsing === 0 && state.pending <= 0 && state.queue.length === 0 && !state.writing) stopStreamParse(ctx, 0);
 }
 function startStreamParse(ctx, current) {
-  const parsed = parseWithError(ctx, 0, current);
-  if (parsed) {
-    onParseInternal(ctx, parsed, true);
-    ctx.state.initial = false;
-    flushStreamParse(ctx, ctx.state);
-    if (ctx.state.pending <= 0) destroyStreamParse(ctx);
+  const state = ctx.state;
+  let parsed;
+  let failure;
+  state.parsing++;
+  try {
+    parsed = parseSOS(ctx, 0, current);
+  } catch (error) {
+    failure = { value: error };
+  } finally {
+    state.parsing--;
+    if (!state.alive) releaseParserValues(ctx);
+  }
+  if (failure) {
+    if (state.alive) stopStreamParse(ctx, 1, failure.value);
+    else throw failure.value;
+  } else if (parsed && state.alive) {
+    state.queue.unshift({
+      node: parsed,
+      initial: true,
+      accept: void 0
+    });
+    drainOutput(ctx);
+  }
+}
+function runCleanups(state) {
+  const cleanups = state.cleanups;
+  let failure;
+  state.cleanups = [];
+  for (const record of state.queue) releaseRecord(record);
+  state.queue.length = 0;
+  if (state.inFlight) releaseRecord(state.inFlight);
+  state.inFlight = void 0;
+  for (let i = 0, len = cleanups.length; i < len; i++) try {
+    cleanups[i]();
+  } catch (error) {
+    failure ?? (failure = { value: error });
+  }
+  if (failure) throw failure.value;
+}
+function releaseRecord(record) {
+  record.node = void 0;
+  record.accept = void 0;
+}
+function releaseParserValues(ctx) {
+  ctx.base.refs = /* @__PURE__ */ new Map();
+  ctx.base.marked.clear();
+  ctx.base.plugins = void 0;
+  ctx.base.plainObjectPlugins = void 0;
+  ctx.state.pluginContexts = [];
+  if (ctx.state.parsing === 0) ctx.state.reason = void 0;
+}
+function stopStreamParse(ctx, mode, reason) {
+  const state = ctx.state;
+  if (state.alive) {
+    state.alive = false;
+    const onError = state.onError;
+    const onDone = state.onDone;
+    if (mode === 1 && !onError && !(reason instanceof SerovalParserError)) reason = new SerovalParserError(reason);
+    state.reason = reason;
+    state.onParse = void 0;
+    state.onError = void 0;
+    state.onDone = void 0;
+    state.writing = false;
+    state.parsing++;
+    let failure;
+    try {
+      if (mode === 1) {
+        if (onError) onError(reason);
+        else throw reason;
+      } else if (mode === 0) onDone?.();
+    } catch (error) {
+      failure = { value: error };
+    }
+    try {
+      runCleanups(state);
+    } catch (error) {
+      failure ?? (failure = { value: error });
+    } finally {
+      state.parsing--;
+      releaseParserValues(ctx);
+      state.pending = 0;
+    }
+    if (failure) throw failure.value;
   }
 }
-function flushStreamParse(ctx, state) {
-  for (let i = 0, len = state.buffer.length; i < len; i++) onParseInternal(ctx, state.buffer[i], false);
-}
-function destroyStreamParse(ctx) {
-  if (ctx.state.alive) {
-    onDone(ctx);
-    ctx.state.alive = false;
-  }
+function destroyStreamParse(ctx, reason) {
+  stopStreamParse(ctx, 2, reason);
 }
 async function toCrossJSONAsync(source, options = {}) {
   const plugins = resolvePlugins(options.plugins);
-  return await parseTopAsync(createAsyncParserContext(2, {
+  return await parseTopAsync(createAsyncParserContext({
     compactArrayBufferViews: options.compactArrayBufferViews,
+    depthLimit: options.depthLimit,
     plugins,
     disabledFeatures: options.disabledFeatures,
     refs: options.refs
@@ -4557,11 +4968,11 @@ function toCrossJSONStream(source, options) {
   return destroyStreamParse.bind(null, ctx);
 }
 function fromJSON(source, options = {}) {
-  var _source$f;
   const plugins = resolvePlugins(options.plugins);
-  const disabledFeatures = options.disabledFeatures || 0;
-  const sourceFeatures = (_source$f = source.f) !== null && _source$f !== void 0 ? _source$f : 127;
+  const disabledFeatures = options.disabledFeatures ?? 0;
+  const sourceFeatures = source.f ?? 127;
   return deserializeTop(createVanillaDeserializerContext({
+    depthLimit: options.depthLimit,
     maxBase64Length: options.maxBase64Length,
     plugins,
     markedRefs: source.m,
@@ -4976,7 +5387,7 @@ function serializeResult(res, signal, plugins) {
   let initialParsed = false;
   let serializationFailure;
   let disposeSerialization;
-  let onParse2 = (value, initial) => {
+  let onParse = (value, initial) => {
     if (serializationFailure) return;
     initialParsed ||= initial;
     const record = encodeSerializationRecord(value);
@@ -4987,10 +5398,10 @@ function serializeResult(res, signal, plugins) {
     initialRecords.push(record);
     initialBytes += record.byteLength;
   };
-  let onDone2 = () => {
+  let onDone = () => {
     if (initialParsed) done = true;
   };
-  let onError2 = (error) => {
+  let onError = (error) => {
     serializationFailure ??= [error];
   };
   const rawStreamPlugin = createRawStreamRPCPlugin((id, stream) => {
@@ -5001,7 +5412,7 @@ function serializeResult(res, signal, plugins) {
     if (id > 1024) {
       const error = /* @__PURE__ */ new Error(`Too many raw streams in framed response (max ${MAX_FRAMED_STREAMS})`);
       cancelRawStream(stream, error);
-      onError2(error);
+      onError(error);
       return;
     }
     pendingRawStreams.push({
@@ -5013,13 +5424,13 @@ function serializeResult(res, signal, plugins) {
     refs: /* @__PURE__ */ new Map(),
     plugins: [rawStreamPlugin, ...plugins],
     onParse(value, initial) {
-      onParse2(value, initial);
+      onParse(value, initial);
     },
     onDone() {
-      onDone2();
+      onDone();
     },
     onError: (error) => {
-      onError2(error);
+      onError(error);
     }
   });
   if (serializationFailure) {
@@ -5084,7 +5495,7 @@ function serializeResult(res, signal, plugins) {
     if (json.byteLength > 16777216 || exceedsPendingSerializationLimit(json, pendingRecords.size, pendingBytes)) {
       const error = /* @__PURE__ */ new Error("Server function serialization exceeded its pending output limit");
       for (const registration of rawStreams) cancelRawStream(registration.stream, error);
-      onError2(error);
+      onError(error);
       return false;
     }
     pendingBytes += json.byteLength;
@@ -5103,17 +5514,17 @@ function serializeResult(res, signal, plugins) {
     });
     return true;
   };
-  onParse2 = (value) => {
+  onParse = (value) => {
     if (serializationFailure) return;
     writeRecord(encodeSerializationRecord(value), pendingRawStreams.splice(0));
   };
-  onDone2 = () => {
+  onDone = () => {
     if (serializationFailure) return;
     disposeSerialization = void 0;
     writer.close().catch(() => {
     });
   };
-  onError2 = (error) => {
+  onError = (error) => {
     abortRecordStream(error);
   };
   const initialRawStreams = pendingRawStreams.splice(0);
@@ -5126,7 +5537,7 @@ function serializeResult(res, signal, plugins) {
     }
   }
   initialRecords.length = 0;
-  if (done) onDone2();
+  if (done) onDone();
   writer.closed.catch((error) => {
     abortRecordStream(error);
   });
@@ -5722,7 +6133,7 @@ var getBaseManifest = getProdBaseManifest;
 var createEarlyHintsForRequest = createEarlyHintsCollector;
 async function loadEntries() {
   const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
-    import("./router-DBc-HYGW-CC6DTCFR.js").then((n) => n.t),
+    import("./router-DJDog9kJ-IHEFPUCH.js").then((n) => n.t),
     import("./start-2iP5edI6-7IIO7TA6.js"),
     import("./empty-plugin-adapters-CVykojMw-NXXTUYZA.js")
   ]);