@qredence/fleet 0.10.1 → 0.10.3

package/dist/web/server/{chunk-35RIM6VP.js → chunk-CPB76YQU.js}

@@ -4334,7 +4334,7 @@ function createSerializationAdapter(opts) {
   return opts;
 }
 
-// node_modules/.pnpm/seroval@1.6.7/node_modules/seroval/dist/index.js
+// node_modules/.pnpm/seroval@1.7.1/node_modules/seroval/dist/index.js
 var SYM_ASYNC_ITERATOR = Symbol.asyncIterator;
 var SYM_HAS_INSTANCE = Symbol.hasInstance;
 var SYM_IS_CONCAT_SPREADABLE = Symbol.isConcatSpreadable;
@@ -4348,36 +4348,43 @@ var SYM_SPLIT = Symbol.split;
 var SYM_TO_PRIMITIVE = Symbol.toPrimitive;
 var SYM_TO_STRING_TAG = Symbol.toStringTag;
 var SYM_UNSCOPABLES = Symbol.unscopables;
-var SYMBOL_STRING = {
-  [0]: "Symbol.asyncIterator",
-  [1]: "Symbol.hasInstance",
-  [2]: "Symbol.isConcatSpreadable",
-  [3]: "Symbol.iterator",
-  [4]: "Symbol.match",
-  [5]: "Symbol.matchAll",
-  [6]: "Symbol.replace",
-  [7]: "Symbol.search",
-  [8]: "Symbol.species",
-  [9]: "Symbol.split",
-  [10]: "Symbol.toPrimitive",
-  [11]: "Symbol.toStringTag",
-  [12]: "Symbol.unscopables"
+var TEMPORAL_TYPE_NAME = {
+  [0]: "Instant",
+  [1]: "Duration",
+  [2]: "PlainDate",
+  [3]: "PlainDateTime",
+  [4]: "PlainMonthDay",
+  [5]: "PlainTime",
+  [6]: "PlainYearMonth",
+  [7]: "ZonedDateTime"
 };
-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 SYMBOL_REF = {
+  [0]: SYM_ASYNC_ITERATOR,
+  [1]: SYM_HAS_INSTANCE,
+  [2]: SYM_IS_CONCAT_SPREADABLE,
+  [3]: SYM_ITERATOR,
+  [4]: SYM_MATCH,
+  [5]: SYM_MATCH_ALL,
+  [6]: SYM_REPLACE,
+  [7]: SYM_SEARCH,
+  [8]: SYM_SPECIES,
+  [9]: SYM_SPLIT,
+  [10]: SYM_TO_PRIMITIVE,
+  [11]: SYM_TO_STRING_TAG,
+  [12]: SYM_UNSCOPABLES
 };
+function createSymbolStringTable() {
+  const result = {};
+  for (let i = 0; i <= 12; i++) result[i] = SYMBOL_REF[i].description;
+  return result;
+}
+var SYMBOL_STRING = /* @__PURE__ */ createSymbolStringTable();
+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_STRING = {
   [2]: "!0",
   [3]: "!1",
@@ -4388,26 +4395,27 @@ var CONSTANT_STRING = {
   [6]: "-1/0",
   [7]: "0/0"
 };
-var CONSTANT_VAL = {
-  [2]: true,
-  [3]: false,
-  [1]: void 0,
-  [0]: null,
-  [4]: -0,
-  [5]: Number.POSITIVE_INFINITY,
-  [6]: Number.NEGATIVE_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,
+  [2]: RangeError,
+  [3]: ReferenceError,
+  [4]: SyntaxError,
+  [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,
@@ -4424,7 +4432,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);
@@ -4435,80 +4443,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 last2 = str.length - 1;
+  while (index !== -1 && index < last2) {
+    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,
@@ -4517,10 +4561,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;
   }
 };
@@ -4529,6 +4572,11 @@ var SerovalParserError = class extends SerovalError {
     super("parsing", cause);
   }
 };
+var SerovalSerializationError = class extends SerovalError {
+  constructor(cause) {
+    super("serialization", cause);
+  }
+};
 function getSpecificErrorMessage(code) {
   return `Seroval Error (specific: ${code})`;
 }
@@ -4548,96 +4596,73 @@ var SerovalMissingPluginError = class extends Error {
     super(getSpecificErrorMessage(3));
   }
 };
-var SerovalMissingReferenceError = class extends Error {
-  constructor(value) {
-    super(getSpecificErrorMessage(5));
-    this.value = value;
+var SerovalUnknownTypedArrayError = class extends Error {
+  constructor(name) {
+    super(getSpecificErrorMessage(7));
   }
 };
 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 GLOBAL_CONTEXT_R = `self.$R`;
-function getCrossReferenceHeader(id) {
-  if (id == null) return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
-  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(id)}"]=[]`;
-}
-var REFERENCE = /* @__PURE__ */ new Map();
-var INV_REFERENCE = /* @__PURE__ */ new Map();
-function hasReferenceID(value) {
-  return REFERENCE.has(value);
-}
-function getReferenceID(value) {
-  if (hasReferenceID(value)) return REFERENCE.get(value);
-  throw new SerovalMissingReferenceError(value);
-}
-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:
@@ -4647,85 +4672,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);
+  return createSerovalNode(7, id, void 0, void 0, void 0, void 0, void 0, items);
 }
-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 createIteratorFactoryInstanceNode(type, factory, items) {
+  return createSerovalNode(type, void 0, void 0, void 0, void 0, void 0, void 0, [factory, items]);
 }
-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);
+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 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 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 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;
@@ -4757,7 +4921,7 @@ var PROMISE_FAILURE = (resolver, data) => {
 var SERIALIZED_PROMISE_CONSTRUCTOR = /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();
 var SERIALIZED_PROMISE_SUCCESS = /* @__PURE__ */ PROMISE_SUCCESS.toString();
 var SERIALIZED_PROMISE_FAILURE = /* @__PURE__ */ PROMISE_FAILURE.toString();
-var STREAM_CONSTRUCTOR = () => {
+var STREAM_CONSTRUCTOR = (live) => {
   const buffer = [];
   const listeners = [];
   let alive = true;
@@ -4765,6 +4929,7 @@ var STREAM_CONSTRUCTOR = () => {
   let count = 0;
   const internal = {
     flush(value, mode, x) {
+      live > 1 || buffer.push(value);
       for (x = 0; x < count; x++) {
         const listener = listeners[x];
         if (listener) listener[mode](value);
@@ -4778,6 +4943,7 @@ var STREAM_CONSTRUCTOR = () => {
       }
     },
     on(listener, temp = 0) {
+      if (live > 1) throw new Error("Stream consumed");
       let subscribed = alive;
       if (alive) {
         for (temp = 0; temp < count; temp++) if (!listeners[temp]) break;
@@ -4785,6 +4951,10 @@ var STREAM_CONSTRUCTOR = () => {
         listeners[temp] = listener;
       }
       internal.up(listener);
+      if (live) {
+        live = 2;
+        buffer.length = 0;
+      }
       return () => {
         if (alive && subscribed) {
           subscribed = false;
@@ -4801,14 +4971,10 @@ var STREAM_CONSTRUCTOR = () => {
       return internal.on(listener);
     },
     next(value) {
-      if (alive) {
-        buffer.push(value);
-        internal.flush(value, "next");
-      }
+      if (alive) internal.flush(value, "next");
     },
     throw(value) {
       if (alive) {
-        buffer.push(value);
         internal.flush(value, "throw");
         alive = false;
         success = false;
@@ -4817,7 +4983,6 @@ var STREAM_CONSTRUCTOR = () => {
     },
     return(value) {
       if (alive) {
-        buffer.push(value);
         internal.flush(value, "return");
         alive = false;
         success = true;
@@ -4935,23 +5100,25 @@ var ARRAY_BUFFER_CONSTRUCTOR = (b64) => {
   return arr.buffer;
 };
 var SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR = /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();
+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) {
@@ -4960,11 +5127,12 @@ 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 ITERATOR = {};
 var ASYNC_ITERATOR = {};
 var SPECIAL_REFS = {
@@ -4983,61 +5151,173 @@ var SPECIAL_REF_STRING = {
   [4]: SERIALIZED_STREAM_CONSTRUCTOR,
   [5]: SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR
 };
+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);
+    }
+  }
+  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;
+      }
+    };
+  }
+  /**
+  * 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;
+    }
+  }
+  return(value) {
+    if (this.alive) {
+      this.flush(value, "return");
+      this.alive = false;
+      this.success = true;
+      this.listeners.length = 0;
+    }
+  }
+};
 function isStream(value) {
-  return "__SEROVAL_STREAM__" in value;
+  return value instanceof Stream || isLiveStream(value);
 }
 function createStream() {
-  return STREAM_CONSTRUCTOR();
-}
-function createStreamFromAsyncIterable(iterable, cleanups) {
-  const stream = createStream();
-  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(() => {
-      });
+  return new Stream();
+}
+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 encodeArrayBuffer(current) {
+  if (typeof Buffer !== "undefined") return Buffer.from(current).toString("base64");
+  return encodeArrayBuffer$1(current);
+}
+function createPlugin(plugin) {
+  return plugin;
+}
+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);
     }
-  });
-  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);
+  }
+}
+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;
       }
-    } catch (error) {
-      done = true;
-      if (!cancelled) stream.throw(error);
+    } else {
+      const index = resolved.indexOf(current);
+      if (index === -1 || index >= added) return -1;
     }
   }
-  push().catch(() => {
-  });
-  return stream;
+  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 createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(SYM_ASYNC_ITERATOR, PROMISE_CONSTRUCTOR);
-function createBaseParserContext(mode, options) {
-  var _options$compactArray;
+var REFERENCES_KEY = "__SEROVAL_REFS__";
+var GLOBAL_CONTEXT_R = `self.$R`;
+function getCrossReferenceHeader(id) {
+  if (id == null) return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
+  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(id)}"]=[]`;
+}
+var REFERENCE = /* @__PURE__ */ new Map();
+function getReferenceID(value) {
+  return REFERENCE.get(value);
+}
+function createBaseParserContext(options) {
   return {
     plugins: options.plugins,
-    mode,
+    plainObjectPlugins: getPlainObjectPlugins(options.plugins),
     marked: /* @__PURE__ */ new Set(),
-    features: 127 ^ (options.disabledFeatures || 0),
-    refs: options.refs || /* @__PURE__ */ new Map(),
+    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
+    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);
 }
@@ -5050,111 +5330,141 @@ function getNodeForIndexedValue(ctx, current) {
   const registeredId = ctx.refs.get(current);
   if (registeredId != null) {
     markParserRef(ctx, registeredId);
-    return {
-      type: 1,
-      value: createIndexedValueNode(registeredId)
-    };
+    return createIndexedValueNode(registeredId);
   }
-  return {
-    type: 0,
-    value: createIndexForValue(ctx, current)
-  };
+  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);
-}
-function createPlugin(plugin) {
-  return plugin;
-}
-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 isValidKey(key) {
-  switch (key) {
-    case "constructor":
-    case "__proto__":
-    case "prototype":
-    case "__defineGetter__":
-    case "__defineSetter__":
-    case "__lookupGetter__":
-    case "__lookupSetter__":
-      return false;
-    default:
-      return true;
-  }
+  return createSerovalNode(19, id, encodeArrayBuffer(current), void 0, void 0, void 0, void 0, void 0, parseSpecialReference(ctx, 5));
 }
 var RETURN = () => T;
-var SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();
-var IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);
+var IS_MODERN = /* @__PURE__ */ (/* @__PURE__ */ RETURN.toString()).includes("=>");
 function createFunction(parameters, body) {
   if (IS_MODERN) return (parameters.length === 1 ? parameters[0] : "(" + parameters.join(",") + ")") + "=>" + (body.startsWith("{") ? "(" + body + ")" : body);
   return "function(" + parameters.join(",") + "){return " + body + "}";
@@ -5178,10 +5488,13 @@ function getIdentifier(index) {
   }
   return ref;
 }
-var IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;
 function isValidIdentifier(name) {
-  const char = name[0];
-  return (char === "$" || char === "_" || char >= "A" && char <= "Z" || char >= "a" && char <= "z") && IDENTIFIER_CHECK.test(name);
+  const len = name.length;
+  for (let i = 0; i < len; i++) {
+    const code = name.charCodeAt(i);
+    if (!(code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 && i > 0 || code === 95 || code === 36)) return false;
+  }
+  return len > 0;
 }
 function getAssignmentExpression(assignment) {
   switch (assignment.t) {
@@ -5197,51 +5510,32 @@ function getAssignmentExpression(assignment) {
       return "Object.defineProperty(" + assignment.s + ',"__proto__",{value:' + assignment.k + ",configurable:!0,enumerable:!0,writable:!0})";
   }
 }
-function mergeAssignments(assignments) {
-  const newAssignments = [];
-  let current = assignments[0];
-  for (let i = 1, len = assignments.length, item, prev = current; i < len; i++) {
-    item = assignments[i];
-    if (item.t === 0 && item.v === prev.v) current = {
-      t: 0,
-      s: item.s,
-      k: void 0,
-      v: getAssignmentExpression(current)
-    };
-    else if (item.t === 2 && item.s === prev.s) current = {
-      t: 2,
-      s: getAssignmentExpression(current),
-      k: item.k,
-      v: item.v
-    };
-    else if (item.t === 1 && item.s === prev.s) current = {
-      t: 1,
-      s: getAssignmentExpression(current),
-      k: void 0,
-      v: item.v
-    };
-    else if (item.t === 3 && item.s === prev.s) current = {
-      t: 3,
-      s: getAssignmentExpression(current),
-      k: item.k,
-      v: void 0
-    };
+var MAX_ASSIGNMENT_CHAIN_LENGTH = 100;
+function resolveAssignments(assignments) {
+  if (!assignments.length) return void 0;
+  let previous = assignments[0];
+  let expression = getAssignmentExpression(previous);
+  let result = "";
+  let chainLength = 1;
+  for (let index = 1, length = assignments.length; index < length; index++) {
+    const assignment = assignments[index];
+    if (chainLength === MAX_ASSIGNMENT_CHAIN_LENGTH) {
+      result += expression + ",";
+      expression = getAssignmentExpression(assignment);
+      chainLength = 0;
+    } else if (assignment.t === 0 && previous.t === 0 && assignment.v === previous.v) expression = assignment.s + "=" + expression;
+    else if (assignment.t === 2 && previous.t === 2 && assignment.s === previous.s) expression += ".set(" + assignment.k + "," + assignment.v + ")";
+    else if (assignment.t === 1 && previous.t === 1 && assignment.s === previous.s) expression += ".add(" + assignment.v + ")";
+    else if (assignment.t === 3 && previous.t === 2 && assignment.s === previous.s) expression += ".delete(" + assignment.k + ")";
     else {
-      newAssignments.push(current);
-      current = item;
+      result += expression + ",";
+      expression = getAssignmentExpression(assignment);
+      chainLength = 0;
     }
-    prev = item;
-  }
-  newAssignments.push(current);
-  return newAssignments;
-}
-function resolveAssignments(assignments) {
-  if (assignments.length) {
-    let result = "";
-    const merged = mergeAssignments(assignments);
-    for (let i = 0, len = merged.length; i < len; i++) result += getAssignmentExpression(merged[i]) + ",";
-    return result;
+    chainLength++;
+    previous = assignment;
   }
+  return result + expression + ",";
 }
 var NULL_CONSTRUCTOR = "Object.create(null)";
 var SET_CONSTRUCTOR = "new Set";
@@ -5259,28 +5553,20 @@ function createBaseSerializerContext(mode, options) {
     mode,
     plugins: options.plugins,
     features: options.features,
-    marked: new Set(options.markedRefs),
+    marked: Array.isArray(options.markedRefs) ? new Set(options.markedRefs) : options.markedRefs,
     stack: [],
     flags: [],
-    assignments: []
+    assignments: [],
+    assignAll: mode === 2 && !options.assignSharedRefsOnly
   };
 }
 function createCrossSerializerContext(options) {
   return {
     mode: 2,
     base: createBaseSerializerContext(2, options),
-    state: options,
-    child: void 0
+    state: options
   };
 }
-var SerializePluginContext = class {
-  constructor(_p) {
-    this._p = _p;
-  }
-  serialize(node) {
-    return serialize$1(this._p, node);
-  }
-};
 function getVanillaRefParam(state, index) {
   let actualIndex = state.valid.get(index);
   if (actualIndex == null) {
@@ -5368,7 +5654,7 @@ function createArrayAssign(ctx, ref, index, value) {
   createAssignment(ctx.base, getRefParam(ctx, ref) + "[" + index + "]", value);
 }
 function createObjectAssign(ctx, ref, key, value) {
-  if (!isValidKey(key)) {
+  if (key === "__proto__") {
     ctx.base.assignments.push({
       t: 4,
       s: getRefParam(ctx, ref),
@@ -5382,15 +5668,35 @@ function createObjectAssign(ctx, ref, key, value) {
 function createSequenceAssign(ctx, ref, index, value) {
   createAssignment(ctx.base, getRefParam(ctx, ref) + ".v[" + index + "]", value);
 }
+function getKeyKind(key) {
+  const first = key.charCodeAt(0);
+  if (first >= 48 && first <= 57) {
+    const check = Number(key);
+    return check >= 0 && check.toString() === key ? 2 : 0;
+  }
+  if (key === "Infinity") return 2;
+  return isValidIdentifier(key) ? 1 : 0;
+}
 function isIndexedValueInStack(ctx, node) {
   return node.t === 4 && ctx.stack.includes(node.i);
 }
+function hasMarkedNode(ctx, node) {
+  if (Array.isArray(node)) {
+    for (let i = 0, len = node.length; i < len; i++) if (hasMarkedNode(ctx, node[i])) return true;
+    return false;
+  }
+  if (node == null || typeof node !== "object") return false;
+  const current = node;
+  if (current.t !== 4 && typeof current.i === "number" && isSerializerRefMarked(ctx, current.i)) return true;
+  for (const key in current) if (hasMarkedNode(ctx, current[key])) return true;
+  return false;
+}
 function assignIndexedValue(ctx, index, value) {
-  if (ctx.mode === 1 && !isSerializerRefMarked(ctx.base, index)) return value;
+  if (!ctx.base.assignAll && !isSerializerRefMarked(ctx.base, index)) return value;
   return getRefParam(ctx, index) + "=" + value;
 }
 function serializeReference(node) {
-  return '__SEROVAL_REFS__.get("' + node.s + '")';
+  return REFERENCES_KEY + '.get("' + node.s + '")';
 }
 function serializeArrayItem(ctx, id, item, index) {
   if (item) {
@@ -5424,16 +5730,15 @@ function serializeArray(ctx, node) {
 }
 function serializeProperty(ctx, source, key, val) {
   if (typeof key === "string") {
-    const check = Number(key);
-    const isIdentifier = check >= 0 && check.toString() === key || isValidIdentifier(key);
+    const kind = getKeyKind(key);
     if (isIndexedValueInStack(ctx.base, val)) {
       const refParam = getRefParam(ctx, val.i);
       markSerializerRef(ctx.base, source.i);
-      if (isIdentifier && check !== check) createObjectAssign(ctx, source.i, key, refParam);
-      else createArrayAssign(ctx, source.i, isIdentifier ? key : '"' + key + '"', refParam);
+      if (kind === 1) createObjectAssign(ctx, source.i, key, refParam);
+      else createArrayAssign(ctx, source.i, kind === 2 ? key : '"' + key + '"', refParam);
       return "";
     }
-    if (isValidKey(key)) return (isIdentifier ? key : '"' + key + '"') + ":" + serialize$1(ctx, val);
+    if (key !== "__proto__") return (kind === 0 ? '"' + key + '"' : key) + ":" + serialize$1(ctx, val);
     return '["' + key + '"]:' + serialize$1(ctx, val);
   }
   return "[" + serialize$1(ctx, key) + "]:" + serialize$1(ctx, val);
@@ -5445,7 +5750,7 @@ function serializeProperties(ctx, source, record) {
     const values = record.v;
     ctx.base.stack.push(source.i);
     let result = serializeProperty(ctx, source, keys[0], values[0]);
-    for (let i = 1, item = result; i < len; i++) {
+    for (let i = 1, item; i < len; i++) {
       item = serializeProperty(ctx, source, keys[i], values[i]);
       result += (item && result && ",") + item;
     }
@@ -5466,18 +5771,14 @@ function serializeWithObjectAssign(ctx, source, value, serialized) {
 function serializeStringKeyAssignment(ctx, source, mainAssignments, key, value) {
   const base = ctx.base;
   const serialized = serialize$1(ctx, value);
-  const check = Number(key);
-  const isIdentifier = check >= 0 && check.toString() === key || isValidIdentifier(key);
-  if (isIndexedValueInStack(base, value)) {
-    if (isIdentifier && check !== check) createObjectAssign(ctx, source.i, key, serialized);
-    else createArrayAssign(ctx, source.i, isIdentifier ? key : '"' + key + '"', serialized);
-  } else {
-    const parentAssignment = base.assignments;
-    base.assignments = mainAssignments;
-    if (isIdentifier && check !== check) createObjectAssign(ctx, source.i, key, serialized);
-    else createArrayAssign(ctx, source.i, isIdentifier ? key : '"' + key + '"', serialized);
-    base.assignments = parentAssignment;
-  }
+  const parentAssignment = base.assignments;
+  if (!isIndexedValueInStack(base, value)) base.assignments = mainAssignments;
+  createKeyAssign(ctx, source.i, getKeyKind(key), key, serialized);
+  base.assignments = parentAssignment;
+}
+function createKeyAssign(ctx, ref, kind, key, value) {
+  if (kind === 1) createObjectAssign(ctx, ref, key, value);
+  else createArrayAssign(ctx, ref, kind === 2 ? key : '"' + key + '"', value);
 }
 function serializeAssignment(ctx, source, mainAssignments, key, value) {
   if (typeof key === "string") serializeStringKeyAssignment(ctx, source, mainAssignments, key, value);
@@ -5508,7 +5809,7 @@ function serializeAssignments(ctx, source, node) {
 function serializeDictionary(ctx, node, init) {
   if (node.p) {
     const base = ctx.base;
-    if (base.features & 8) init = serializeWithObjectAssign(ctx, node, node.p, init);
+    if (base.features & 8 && !node.p.k.includes("__proto__")) init = serializeWithObjectAssign(ctx, node, node.p, init);
     else {
       markSerializerRef(base, node.i);
       const assignments = serializeAssignments(ctx, node, node.p);
@@ -5524,22 +5825,15 @@ function serializeNullConstructor(ctx, node) {
 function serializeDate(node) {
   return 'new Date("' + node.s + '")';
 }
-var TEMPORAL_CONSTRUCTOR = {
-  [0]: "Temporal.Instant",
-  [1]: "Temporal.Duration",
-  [2]: "Temporal.PlainDate",
-  [3]: "Temporal.PlainDateTime",
-  [4]: "Temporal.PlainMonthDay",
-  [5]: "Temporal.PlainTime",
-  [6]: "Temporal.PlainYearMonth",
-  [7]: "Temporal.ZonedDateTime"
-};
 function serializeTemporal(ctx, node) {
-  if (ctx.base.features & 64) return TEMPORAL_CONSTRUCTOR[node.c] + '.from("' + node.s + '")';
+  if (ctx.base.features & 64) return "Temporal." + TEMPORAL_TYPE_NAME[node.c] + '.from("' + node.s + '")';
   throw new SerovalUnsupportedNodeError(node);
 }
 function serializeRegExp(ctx, node) {
-  if (ctx.base.features & 32) return "/" + deserializeString(node.c) + "/" + node.m;
+  if (ctx.base.features & 32) {
+    if (node.c.includes("\\x3C")) return 'new RegExp("' + node.c + '","' + node.m + '")';
+    return "/" + deserializeString(node.c) + "/" + node.m;
+  }
   throw new SerovalUnsupportedNodeError(node);
 }
 function serializeSetItem(ctx, id, item) {
@@ -5559,7 +5853,7 @@ function serializeSet(ctx, node) {
   if (size > 0) {
     ctx.base.stack.push(id);
     let result = serializeSetItem(ctx, id, items[0]);
-    for (let i = 1, item = result; i < size; i++) {
+    for (let i = 1, item; i < size; i++) {
       item = serializeSetItem(ctx, id, items[i]);
       result += (item && result && ",") + item;
     }
@@ -5568,7 +5862,7 @@ function serializeSet(ctx, node) {
   }
   return serialized;
 }
-function serializeMapEntry(ctx, id, key, val, sentinel) {
+function serializeMapEntry(ctx, id, key, val, getSentinel) {
   const base = ctx.base;
   if (isIndexedValueInStack(base, key)) {
     const keyRef = getRefParam(ctx, key.i);
@@ -5577,7 +5871,9 @@ function serializeMapEntry(ctx, id, key, val, sentinel) {
       createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));
       return "";
     }
-    if (val.t !== 4 && val.i != null && isSerializerRefMarked(base, val.i)) {
+    if (val.t !== 4 && val.i != null && hasMarkedNode(base, val)) {
+      markSerializerRef(base, val.i);
+      const sentinel = getSentinel();
       const serialized = "(" + serialize$1(ctx, val) + ",[" + sentinel + "," + sentinel + "])";
       createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));
       createDeleteAssignment(ctx, id, sentinel);
@@ -5592,7 +5888,9 @@ function serializeMapEntry(ctx, id, key, val, sentinel) {
   if (isIndexedValueInStack(base, val)) {
     const valueRef = getRefParam(ctx, val.i);
     markSerializerRef(base, id);
-    if (key.t !== 4 && key.i != null && isSerializerRefMarked(base, key.i)) {
+    if (key.t !== 4 && key.i != null && hasMarkedNode(base, key)) {
+      markSerializerRef(base, key.i);
+      const sentinel = getSentinel();
       const serialized = "(" + serialize$1(ctx, key) + ",[" + sentinel + "," + sentinel + "])";
       createSetAssignment(ctx, id, getRefParam(ctx, key.i), valueRef);
       createDeleteAssignment(ctx, id, sentinel);
@@ -5612,20 +5910,27 @@ function serializeMap(ctx, node) {
   const size = keys.length;
   const id = node.i;
   const sentinel = node.f;
-  const sentinelId = getRefParam(ctx, sentinel.i);
+  let sentinelRef;
+  const getSentinel = () => {
+    if (sentinelRef == null) {
+      sentinelRef = getRefParam(ctx, sentinel.i);
+      if (ctx.mode === 1) ctx.state.sentinels.add(ctx.state.valid.get(sentinel.i));
+    }
+    return sentinelRef;
+  };
   const base = ctx.base;
   if (size > 0) {
     const vals = node.e.v;
     base.stack.push(id);
-    let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);
-    for (let i = 1, item = result; i < size; i++) {
-      item = serializeMapEntry(ctx, id, keys[i], vals[i], sentinelId);
+    let result = serializeMapEntry(ctx, id, keys[0], vals[0], getSentinel);
+    for (let i = 1, item; i < size; i++) {
+      item = serializeMapEntry(ctx, id, keys[i], vals[i], getSentinel);
       result += (item && result && ",") + item;
     }
     base.stack.pop();
     if (result) serialized += "([" + result + "])";
   }
-  if (sentinel.t === 26) {
+  if (ctx.mode === 2 && sentinel.t === 26) {
     markSerializerRef(base, sentinel.i);
     serialized = "(" + serialize$1(ctx, sentinel) + "," + serialized + ")";
   }
@@ -5634,11 +5939,8 @@ function serializeMap(ctx, node) {
 function serializeArrayBuffer(ctx, node) {
   return getConstructor(ctx, node.f) + '("' + node.s + '")';
 }
-function serializeTypedArray(ctx, node) {
-  return "new " + node.c + "(" + serialize$1(ctx, node.f) + "," + node.b + "," + node.l + ")";
-}
-function serializeDataView(ctx, node) {
-  return "new DataView(" + serialize$1(ctx, node.f) + "," + node.b + "," + node.l + ")";
+function serializeView(ctx, node) {
+  return "new " + (node.t === 20 ? "DataView" : node.c) + "(" + serialize$1(ctx, node.f) + "," + node.b + "," + node.l + ")";
 }
 function serializeAggregateError(ctx, node) {
   const id = node.i;
@@ -5678,11 +5980,7 @@ function serializePromiseConstructor(ctx, node) {
   if (ctx.mode === 1) throw new SerovalUnsupportedNodeError(node);
   return "(" + assignIndexedValue(ctx, node.s, getConstructor(ctx, node.f) + "()") + ").p";
 }
-function serializePromiseResolve(ctx, node) {
-  if (ctx.mode === 1) throw new SerovalUnsupportedNodeError(node);
-  return getConstructor(ctx, node.a[0]) + "(" + getRefParam(ctx, node.i) + "," + serialize$1(ctx, node.a[1]) + ")";
-}
-function serializePromiseReject(ctx, node) {
+function serializePromiseResult(ctx, node) {
   if (ctx.mode === 1) throw new SerovalUnsupportedNodeError(node);
   return getConstructor(ctx, node.a[0]) + "(" + getRefParam(ctx, node.i) + "," + serialize$1(ctx, node.a[1]) + ")";
 }
@@ -5690,10 +5988,7 @@ function serializePlugin(ctx, node) {
   const currentPlugins = ctx.base.plugins;
   if (currentPlugins) for (let i = 0, len = currentPlugins.length; i < len; i++) {
     const plugin = currentPlugins[i];
-    if (plugin.tag === node.c) {
-      if (ctx.child == null) ctx.child = new SerializePluginContext(ctx);
-      return plugin.serialize(node.s, ctx.child, { id: node.i });
-    }
+    if (plugin.tag === node.c) return plugin.serialize(node.s, { serialize: (current) => serialize$1(ctx, current) }, { id: node.i });
   }
   throw new SerovalMissingPluginError(node.c);
 }
@@ -5730,11 +6025,8 @@ function serializeAsyncIteratorFactory(ctx, node) {
   if (result) return result + iterator + ")";
   return iterator;
 }
-function serializeAsyncIteratorFactoryInstance(ctx, node) {
-  return getConstructor(ctx, node.a[0]) + "(" + serialize$1(ctx, node.a[1]) + ")";
-}
 function serializeStreamConstructor(ctx, node) {
-  const result = assignIndexedValue(ctx, node.i, getConstructor(ctx, node.f) + "()");
+  const result = assignIndexedValue(ctx, node.i, getConstructor(ctx, node.f) + (node.l === 1 ? "(1)" : "()"));
   const len = node.a.length;
   if (len) {
     let values = serialize$1(ctx, node.a[0]);
@@ -5743,14 +6035,8 @@ function serializeStreamConstructor(ctx, node) {
   }
   return result;
 }
-function serializeStreamNext(ctx, node) {
-  return getRefParam(ctx, node.i) + ".next(" + serialize$1(ctx, node.f) + ")";
-}
-function serializeStreamThrow(ctx, node) {
-  return getRefParam(ctx, node.i) + ".throw(" + serialize$1(ctx, node.f) + ")";
-}
-function serializeStreamReturn(ctx, node) {
-  return getRefParam(ctx, node.i) + ".return(" + serialize$1(ctx, node.f) + ")";
+function serializeStreamCall(ctx, node, method) {
+  return getRefParam(ctx, node.i) + "." + method + "(" + serialize$1(ctx, node.f) + ")";
 }
 function serializeSequenceItem(ctx, id, index, item) {
   const base = ctx.base;
@@ -5768,7 +6054,7 @@ function serializeSequence(ctx, node) {
   if (size > 0) {
     ctx.base.stack.push(id);
     let result = serializeSequenceItem(ctx, id, 0, items[0]);
-    for (let i = 1, item = result; i < size; i++) {
+    for (let i = 1, item; i < size; i++) {
       item = serializeSequenceItem(ctx, id, i, items[i]);
       result += (item && result && ",") + item;
     }
@@ -5801,9 +6087,8 @@ function serializeAssignable(ctx, node) {
       return serializeArrayBuffer(ctx, node);
     case 16:
     case 15:
-      return serializeTypedArray(ctx, node);
     case 20:
-      return serializeDataView(ctx, node);
+      return serializeView(ctx, node);
     case 14:
       return serializeAggregateError(ctx, node);
     case 13:
@@ -5839,30 +6124,28 @@ function serialize$1(ctx, node) {
     case 4:
       return getRefParam(ctx, node.i);
     case 23:
-      return serializePromiseResolve(ctx, node);
     case 24:
-      return serializePromiseReject(ctx, node);
+      return serializePromiseResult(ctx, node);
     case 27:
       return serializeIteratorFactory(ctx, node);
     case 28:
+    case 30:
       return serializeIteratorFactoryInstance(ctx, node);
     case 29:
       return serializeAsyncIteratorFactory(ctx, node);
-    case 30:
-      return serializeAsyncIteratorFactoryInstance(ctx, node);
     case 31:
       return serializeStreamConstructor(ctx, node);
     case 32:
-      return serializeStreamNext(ctx, node);
+      return serializeStreamCall(ctx, node, "next");
     case 33:
-      return serializeStreamThrow(ctx, node);
+      return serializeStreamCall(ctx, node, "throw");
     case 34:
-      return serializeStreamReturn(ctx, node);
+      return serializeStreamCall(ctx, node, "return");
     default:
       return assignIndexedValue(ctx, node.i, serializeAssignable(ctx, node));
   }
 }
-function serializeTopCross(ctx, tree) {
+function serializeCross(ctx, tree) {
   const result = serialize$1(ctx, tree);
   const id = tree.i;
   if (id == null) return result;
@@ -5870,7 +6153,11 @@ function serializeTopCross(ctx, tree) {
   const ref = getRefParam(ctx, id);
   const scopeId = ctx.state.scopeId;
   const params = scopeId == null ? "" : "$R";
-  const body = patches ? "(" + result + "," + patches + ref + ")" : result;
+  let body = result;
+  if (patches) {
+    if (!ctx.base.assignAll && !result.startsWith(ref + "=")) body = ref + "=" + result;
+    body = "(" + body + "," + patches + ref + ")";
+  }
   if (params === "") {
     if (tree.t === 10 && !patches) return "(" + body + ")";
     return body;
@@ -5878,67 +6165,20 @@ function serializeTopCross(ctx, tree) {
   const args = scopeId == null ? "()" : '($R["' + serializeString(scopeId) + '"])';
   return "(" + createFunction([params], body) + ")" + args;
 }
-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 wrapSerializationError(error) {
+  return error instanceof SerovalSerializationError ? error : new SerovalSerializationError(error);
 }
-function createStreamParserContext(options) {
-  return {
-    type: 2,
-    base: createBaseParserContext(2, options),
-    state: createStreamParserState(options)
-  };
+function serializeTopCross(ctx, tree) {
+  try {
+    return serializeCross(ctx, tree);
+  } catch (error) {
+    throw wrapSerializationError(error);
+  }
 }
 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;
 }
@@ -5946,20 +6186,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 ? createStream() : 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));
@@ -5974,206 +6216,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) {
+function parseView(ctx, depth, type, id, current) {
   current = getArrayBufferView(ctx.base, current);
-  return createTypedArrayNode(id, current, parseSOS(ctx, depth, current.buffer));
+  return createViewNode(type, id, current, parseSOS(ctx, depth, current.buffer));
 }
-function parseBigIntTypedArray(ctx, depth, 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) {
+function parseError(ctx, depth, type, id, current) {
   const options = getErrorOptions(current, ctx.base.features);
-  return createErrorNode(id, current, options ? parseProperties(ctx, depth, options) : void 0);
-}
-function parseAggregateError(ctx, depth, 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 last2 = values.length - 1;
+  const sequence = new Array(values.length);
+  if (last2 >= 0) markParserRef(ctx.base, id);
+  for (let i = 0; i <= last2; i++) sequence[i] = createStreamEventNode(i < last2 ? 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 (isStream(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);
 }
@@ -6193,7 +6371,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":
@@ -6204,61 +6382,402 @@ 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 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 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 destroyStreamParse(ctx, reason) {
+  stopStreamParse(ctx, 2, reason);
+}
 function crossSerializeStream(source, options) {
   const plugins = resolvePlugins(options.plugins);
+  const onSerialize = options.onSerialize;
+  const scopeId = options.scopeId;
   const ctx = createStreamParserContext({
     compactArrayBufferViews: options.compactArrayBufferViews,
+    depthLimit: options.depthLimit,
     plugins,
     refs: options.refs,
     disabledFeatures: options.disabledFeatures,
@@ -6266,17 +6785,10 @@ function crossSerializeStream(source, options) {
       const serial = createCrossSerializerContext({
         plugins,
         features: ctx.base.features,
-        scopeId: options.scopeId,
+        scopeId,
         markedRefs: ctx.base.marked
       });
-      let serialized;
-      try {
-        serialized = serializeTopCross(serial, node);
-      } catch (err) {
-        if (options.onError) options.onError(err);
-        return;
-      }
-      options.onSerialize(serialized, initial);
+      return onSerialize(serializeTopCross(serial, node), initial);
     },
     onError: options.onError,
     onDone: options.onDone
@@ -8211,10 +8723,9 @@ export {
   createInlineCssStyleAsset,
   createInlineCssPlaceholderAsset,
   createSerializationAdapter,
-  getCrossReferenceHeader,
-  isStream,
   createStream,
   createPlugin,
+  getCrossReferenceHeader,
   crossSerializeStream,
   makeSerovalPlugin,
   RawStream,