seroval 0.12.4 → 0.13.1

package/dist/types/core/utils/promise-to-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-to-result.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/promise-to-result.ts"],"names":[],"mappings":"AAAA,wBAA8B,eAAe,CAC3C,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GACxB,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC,CAM3B"}

package/dist/types/core/utils/typed-array.d.ts

@@ -0,0 +1,4 @@
+type TypedArrayConstructor = Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor | Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor | Uint8ClampedArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor | BigInt64ArrayConstructor | BigUint64ArrayConstructor;
+export declare function getTypedArrayConstructor(name: string): TypedArrayConstructor;
+export {};
+//# sourceMappingURL=typed-array.d.ts.map

package/dist/types/core/utils/typed-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-array.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/typed-array.ts"],"names":[],"mappings":"AAAA,KAAK,qBAAqB,GACtB,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,sBAAsB,GACtB,4BAA4B,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,wBAAwB,GACxB,yBAAyB,CAAC;AAE9B,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAgB5E"}

package/dist/types/core/web-api.d.ts

@@ -1,5 +1,8 @@
-import type { SerovalDOMExceptionNode, SerovalURLNode, SerovalURLSearchParamsNode } from './types';
+import type { SerovalCustomEventNode, SerovalDOMExceptionNode, SerovalEventNode, SerovalNode, SerovalReadableStreamNode, SerovalURLNode, SerovalURLSearchParamsNode } from './types';
 export declare function createURLNode(id: number, current: URL): SerovalURLNode;
 export declare function createURLSearchParamsNode(id: number, current: URLSearchParams): SerovalURLSearchParamsNode;
 export declare function createDOMExceptionNode(id: number, current: DOMException): SerovalDOMExceptionNode;
+export declare function createEventNode(id: number, type: string, options: SerovalNode): SerovalEventNode;
+export declare function createCustomEventNode(id: number, type: string, options: SerovalNode): SerovalCustomEventNode;
+export declare function createReadableStreamNode(id: number, factory: SerovalNode, items: SerovalNode): SerovalReadableStreamNode;
 //# sourceMappingURL=web-api.d.ts.map

package/dist/types/core/web-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-api.d.ts","sourceRoot":"","sources":["../../../src/core/web-api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,cAAc,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAEnG,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,GAAG,GACX,cAAc,CAehB;AAED,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,eAAe,GACvB,0BAA0B,CAe5B;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,YAAY,GACpB,uBAAuB,CAezB"}
+{"version":3,"file":"web-api.d.ts","sourceRoot":"","sources":["../../../src/core/web-api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,gBAAgB,EAChB,WAAW,EACX,yBAAyB,EACzB,cAAc,EACd,0BAA0B,EAC3B,MAAM,SAAS,CAAC;AAEjB,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,GAAG,GACX,cAAc,CAehB;AAED,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,eAAe,GACvB,0BAA0B,CAe5B;AAED,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,YAAY,GACpB,uBAAuB,CAezB;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,WAAW,GACnB,gBAAgB,CAelB;AAED,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,WAAW,GACnB,sBAAsB,CAexB;AAED,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,WAAW,GACjB,yBAAyB,CAkB3B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "seroval",
   "type": "module",
-  "version": "0.12.4",
+  "version": "0.13.1",
   "files": [
     "dist",
     "src"
@@ -20,7 +20,7 @@
     "eslint-config-lxsmnsyc": "^0.6.5",
     "pridepack": "2.5.1",
     "tslib": "^2.6.2",
-    "typescript": "^5.2.2",
+    "typescript": "^5.3.2",
     "vitest": "^0.34.6"
   },
   "scripts": {
@@ -66,5 +66,5 @@
   "typesVersions": {
     "*": {}
   },
-  "gitHead": "4040423d3d896c86679f5f129f8a3309752c9c7a"
+  "gitHead": "d977f4e777e01d1c449558c2d1b13d9e04db077c"
 }

package/src/core/base-primitives.ts

@@ -1,4 +1,5 @@
-import assert from './assert';
+import type { BigIntTypedArrayValue, TypedArrayValue } from '../types';
+import assert from './utils/assert';
 import type { WellKnownSymbols } from './constants';
 import { INV_SYMBOL_REF, SerovalNodeType } from './constants';
 import {
@@ -8,20 +9,34 @@ import {
   NEG_ZERO_NODE,
 } from './literals';
 import { getReferenceID } from './reference';
+import { getErrorConstructor } from './utils/error';
 import { serializeString } from './string';
 import type {
+  SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
+  SerovalArrayNode,
+  SerovalAsyncIteratorFactoryInstanceNode,
   SerovalBigIntNode,
+  SerovalBigIntTypedArrayNode,
+  SerovalBoxedNode,
   SerovalConstantNode,
+  SerovalDataViewNode,
   SerovalDateNode,
+  SerovalErrorNode,
   SerovalIndexedValueNode,
+  SerovalIteratorFactoryInstanceNode,
+  SerovalNode,
   SerovalNumberNode,
+  SerovalObjectRecordNode,
   SerovalPluginNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
+  SerovalSetNode,
   SerovalStringNode,
+  SerovalTypedArrayNode,
   SerovalWKSymbolNode,
 } from './types';
+import { getObjectFlag } from './utils/get-object-flag';
 
 export function createNumberNode(value: number): SerovalConstantNode | SerovalNumberNode {
   switch (value) {
@@ -228,3 +243,216 @@ export function createPluginNode(
     o: undefined,
   };
 }
+
+export function createArrayNode(
+  id: number,
+  current: unknown[],
+  parsedItems: SerovalNode[],
+): SerovalArrayNode {
+  return {
+    t: SerovalNodeType.Array,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: parsedItems,
+    f: undefined,
+    b: undefined,
+    o: getObjectFlag(current),
+  };
+}
+
+export function createBoxedNode(
+  id: number,
+  boxed: SerovalNode,
+): SerovalBoxedNode {
+  return {
+    t: SerovalNodeType.Boxed,
+    i: id,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: boxed,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createTypedArrayNode(
+  id: number,
+  current: TypedArrayValue,
+  buffer: SerovalNode,
+): SerovalTypedArrayNode {
+  return {
+    t: SerovalNodeType.TypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: buffer,
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createBigIntTypedArrayNode(
+  id: number,
+  current: BigIntTypedArrayValue,
+  buffer: SerovalNode,
+): SerovalBigIntTypedArrayNode {
+  return {
+    t: SerovalNodeType.BigIntTypedArray,
+    i: id,
+    s: undefined,
+    l: current.length,
+    c: current.constructor.name,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: buffer,
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createDataViewNode(
+  id: number,
+  current: DataView,
+  buffer: SerovalNode,
+): SerovalDataViewNode {
+  return {
+    t: SerovalNodeType.DataView,
+    i: id,
+    s: undefined,
+    l: current.byteLength,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: undefined,
+    f: buffer,
+    b: current.byteOffset,
+    o: undefined,
+  };
+}
+
+export function createErrorNode(
+  id: number,
+  current: Error,
+  options: SerovalObjectRecordNode | undefined,
+): SerovalErrorNode {
+  return {
+    t: SerovalNodeType.Error,
+    i: id,
+    s: getErrorConstructor(current),
+    l: undefined,
+    c: undefined,
+    m: serializeString(current.message),
+    p: options,
+    e: undefined,
+    a: undefined,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createAggregateErrorNode(
+  id: number,
+  current: AggregateError,
+  options: SerovalObjectRecordNode | undefined,
+): SerovalAggregateErrorNode {
+  return {
+    t: SerovalNodeType.AggregateError,
+    i: id,
+    s: getErrorConstructor(current),
+    l: undefined,
+    c: undefined,
+    m: serializeString(current.message),
+    p: options,
+    e: undefined,
+    a: undefined,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createSetNode(
+  id: number,
+  size: number,
+  items: SerovalNode[],
+): SerovalSetNode {
+  return {
+    t: SerovalNodeType.Set,
+    i: id,
+    s: undefined,
+    l: size,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: items,
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createIteratorFactoryInstanceNode(
+  factory: SerovalNode,
+  items: SerovalNode,
+): SerovalIteratorFactoryInstanceNode {
+  return {
+    t: SerovalNodeType.IteratorFactoryInstance,
+    i: undefined,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: [
+      factory,
+      items,
+    ],
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}
+
+export function createAsyncIteratorFactoryInstanceNode(
+  factory: SerovalNode,
+  items: SerovalNode,
+): SerovalAsyncIteratorFactoryInstanceNode {
+  return {
+    t: SerovalNodeType.AsyncIteratorFactoryInstance,
+    i: undefined,
+    s: undefined,
+    l: undefined,
+    c: undefined,
+    m: undefined,
+    p: undefined,
+    e: undefined,
+    a: [
+      factory,
+      items,
+    ],
+    f: undefined,
+    b: undefined,
+    o: undefined,
+  };
+}

package/src/core/compat.ts

@@ -6,12 +6,10 @@
 
 export const enum Feature {
   AggregateError = 0x01,
-  ArrayPrototypeValues = 0x02,
   ArrowFunction = 0x04,
   BigInt = 0x08,
   ErrorPrototypeStack = 0x10,
   Map = 0x20,
-  MethodShorthand = 0x40,
   ObjectAssign = 0x80,
   Promise = 0x100,
   Set = 0x200,

package/src/core/constants.ts

@@ -51,6 +51,13 @@ export const enum SerovalNodeType {
   CustomEvent = 38,
   DOMException = 39,
   Plugin = 40,
+  MapSentinel = 41,
+  IteratorFactory = 42,
+  IteratorFactoryInstance = 43,
+  AsyncIteratorFactory = 44,
+  AsyncIteratorFactoryInstance = 45,
+  ReadableStream = 46,
+  ReadableStreamFactory = 47,
 }
 
 export const enum SerovalObjectFlags {
@@ -186,5 +193,3 @@ export const ERROR_CONSTRUCTOR: Record<ErrorConstructorTag, ErrorConstructors> =
   [ErrorConstructorTag.TypeError]: TypeError,
   [ErrorConstructorTag.URIError]: URIError,
 };
-
-export const UNIVERSAL_SENTINEL = Symbol('why');

package/src/core/{tree/deserialize.ts → context/deserializer.ts}

@@ -2,11 +2,11 @@
 import { deserializeString } from '../string';
 import type { BigIntTypedArrayValue, TypedArrayValue } from '../../types';
 import { getReference } from '../reference';
-import { getTypedArrayConstructor } from '../shared';
 import type {
   SerovalAggregateErrorNode,
   SerovalArrayBufferNode,
   SerovalArrayNode,
+  SerovalAsyncIteratorFactoryInstanceNode,
   SerovalBigIntTypedArrayNode,
   SerovalBlobNode,
   SerovalBoxedNode,
@@ -19,6 +19,7 @@ import type {
   SerovalFileNode,
   SerovalFormDataNode,
   SerovalHeadersNode,
+  SerovalIteratorFactoryInstanceNode,
   SerovalMapNode,
   SerovalNode,
   SerovalNullConstructorNode,
@@ -26,7 +27,15 @@ import type {
   SerovalObjectRecordKey,
   SerovalObjectRecordNode,
   SerovalPluginNode,
+  SerovalPromiseConstructorNode,
   SerovalPromiseNode,
+  SerovalPromiseRejectNode,
+  SerovalPromiseResolveNode,
+  SerovalReadableStreamCloseNode,
+  SerovalReadableStreamConstructorNode,
+  SerovalReadableStreamEnqueueNode,
+  SerovalReadableStreamErrorNode,
+  SerovalReadableStreamNode,
   SerovalReferenceNode,
   SerovalRegExpNode,
   SerovalRequestNode,
@@ -36,9 +45,6 @@ import type {
   SerovalURLNode,
   SerovalURLSearchParamsNode,
 } from '../types';
-import {
-  SerovalObjectRecordSpecialKey,
-} from '../types';
 import {
   CONSTANT_VAL,
   ERROR_CONSTRUCTOR,
@@ -46,7 +52,18 @@ import {
   SerovalNodeType,
   SerovalObjectFlags,
 } from '../constants';
-import type { Plugin, PluginAccessOptions } from '../plugin';
+import type { Plugin, PluginAccessOptions, SerovalMode } from '../plugin';
+import type { Sequence, SerializedAsyncIteratorResult } from '../utils/iterator-to-sequence';
+import {
+  readableStreamToAsyncIterator,
+  sequenceToAsyncIterator,
+  sequenceToIterator,
+  sequenceToReadableStream,
+} from '../utils/iterator-to-sequence';
+import { getTypedArrayConstructor } from '../utils/typed-array';
+import type { Deferred, DeferredStream } from '../utils/deferred';
+import { createDeferred, createDeferredStream } from '../utils/deferred';
+import assert from '../utils/assert';
 
 function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
   switch (flag) {
@@ -64,62 +81,30 @@ function applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {
 type AssignableValue = AggregateError | Error | Iterable<unknown>
 type AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;
 
-interface Deferred {
-  resolve(value: unknown): void;
-  reject(value: unknown): void;
-  promise: Promise<unknown>;
+export interface BaseDeserializerOptions extends PluginAccessOptions {
+  refs?: Map<number, unknown>;
 }
 
-function createDeferred(): Deferred {
-  let resolve: Deferred['resolve'];
-  let reject: Deferred['reject'];
-  return {
-    resolve(v): void {
-      resolve(v);
-    },
-    reject(v): void {
-      reject(v);
-    },
-    promise: new Promise((res, rej) => {
-      resolve = res as Deferred['resolve'];
-      reject = rej as Deferred['reject'];
-    }),
-  };
-}
+export default abstract class BaseDeserializerContext implements PluginAccessOptions {
+  abstract readonly mode: SerovalMode;
 
-export interface DeserializerOptions extends PluginAccessOptions {
-  markedRefs: number[] | Set<number>;
-}
-
-export default class VanillaDeserializerContext implements PluginAccessOptions {
   /**
    * Mapping ids to values
    * @private
    */
-  values: Map<number, unknown> = new Map();
-
-  /**
-   * Which refs are pre-marked
-   * @private
-   */
-  refs: Set<number>;
+  refs: Map<number, unknown>;
 
   plugins?: Plugin<any, any>[] | undefined;
 
-  constructor(options: DeserializerOptions) {
+  constructor(options: BaseDeserializerOptions) {
     this.plugins = options.plugins;
-    this.refs = new Set(options.markedRefs);
+    this.refs = options.refs || new Map<number, unknown>();
   }
 
-  assignIndexedValue<T>(
-    index: number,
+  protected abstract assignIndexedValue<T>(
+    id: number,
     value: T,
-  ): T {
-    if (this.refs.has(index)) {
-      this.values.set(index, value);
-    }
-    return value;
-  }
+  ): T;
 
   private deserializeReference(
     node: SerovalReferenceNode,
@@ -152,22 +137,14 @@ export default class VanillaDeserializerContext implements PluginAccessOptions {
   ): Record<string | symbol, unknown> {
     const len = node.s;
     if (len) {
-      let key: SerovalObjectRecordKey;
-      let value: unknown;
       const keys = node.k;
       const vals = node.v;
-      for (let i = 0; i < len; i++) {
+      for (let i = 0, key: SerovalObjectRecordKey; i < len; i++) {
         key = keys[i];
-        value = this.deserialize(vals[i]);
-        switch (key) {
-          case SerovalObjectRecordSpecialKey.SymbolIterator: {
-            const current = value as unknown[];
-            result[Symbol.iterator] = (): IterableIterator<unknown> => current.values();
-          }
-            break;
-          default:
-            result[deserializeString(key)] = value;
-            break;
+        if (typeof key === 'string') {
+          result[deserializeString(key)] = this.deserialize(vals[i]);
+        } else {
+          result[this.deserialize(key) as symbol] = this.deserialize(vals[i]);
         }
       }
     }
@@ -302,14 +279,14 @@ export default class VanillaDeserializerContext implements PluginAccessOptions {
     node: SerovalPromiseNode,
   ): Promise<unknown> {
     const deferred = createDeferred();
-    const result = this.assignIndexedValue(node.i, deferred.promise);
+    const result = this.assignIndexedValue(node.i, deferred);
     const deserialized = this.deserialize(node.f);
     if (node.s) {
       deferred.resolve(deserialized);
     } else {
       deferred.reject(deserialized);
     }
-    return result;
+    return result.promise;
   }
 
   private deserializeURL(
@@ -449,15 +426,107 @@ export default class VanillaDeserializerContext implements PluginAccessOptions {
       for (let i = 0, len = currentPlugins.length; i < len; i++) {
         const plugin = currentPlugins[i];
         if (plugin.tag === node.c) {
-          return plugin.deserialize(node.s, this, {
-            id: node.i,
-          });
+          return this.assignIndexedValue(
+            node.i,
+            plugin.deserialize(node.s, this, {
+              id: node.i,
+            }),
+          );
         }
       }
     }
     throw new Error('Missing plugin for tag "' + node.c + '".');
   }
 
+  private deserializePromiseConstructor(node: SerovalPromiseConstructorNode): unknown {
+    return this.assignIndexedValue(
+      node.i,
+      createDeferred(),
+    ).promise;
+  }
+
+  private deserializePromiseResolve(node: SerovalPromiseResolveNode): unknown {
+    const deferred = this.refs.get(node.i) as Deferred | undefined;
+    assert(deferred, new Error('Missing Promise instance.'));
+    deferred.resolve(
+      this.deserialize(node.f),
+    );
+    return undefined;
+  }
+
+  private deserializePromiseReject(node: SerovalPromiseRejectNode): unknown {
+    const deferred = this.refs.get(node.i) as Deferred | undefined;
+    assert(deferred, new Error('Missing Promise instance.'));
+    deferred.reject(
+      this.deserialize(node.f),
+    );
+    return undefined;
+  }
+
+  private deserializeReadableStreamConstructor(
+    node: SerovalReadableStreamConstructorNode,
+  ): unknown {
+    return this.assignIndexedValue(
+      node.i,
+      createDeferredStream(),
+    ).stream;
+  }
+
+  private deserializeReadableStreamEnqueue(node: SerovalReadableStreamEnqueueNode): unknown {
+    const deferred = this.refs.get(node.i) as DeferredStream | undefined;
+    assert(deferred, new Error('Missing ReadableStream instance.'));
+    deferred.enqueue(
+      this.deserialize(node.f),
+    );
+    return undefined;
+  }
+
+  private deserializeReadableStreamError(node: SerovalReadableStreamErrorNode): unknown {
+    const deferred = this.refs.get(node.i) as DeferredStream | undefined;
+    assert(deferred, new Error('Missing Promise instance.'));
+    deferred.error(
+      this.deserialize(node.f),
+    );
+    return undefined;
+  }
+
+  private deserializeReadableStreamClose(node: SerovalReadableStreamCloseNode): unknown {
+    const deferred = this.refs.get(node.i) as DeferredStream | undefined;
+    assert(deferred, new Error('Missing Promise instance.'));
+    deferred.close();
+    return undefined;
+  }
+
+  private deserializeIteratorFactoryInstance(
+    node: SerovalIteratorFactoryInstanceNode,
+  ): unknown {
+    const source = this.deserialize(node.a[1]);
+    return sequenceToIterator(source as Sequence);
+  }
+
+  private deserializeAsyncIteratorFactoryInstance(
+    node: SerovalAsyncIteratorFactoryInstanceNode,
+  ): unknown {
+    const source = this.deserialize(node.a[1]);
+    if ((source as object).constructor === ReadableStream) {
+      return readableStreamToAsyncIterator(
+        source as ReadableStream<SerializedAsyncIteratorResult<unknown>>,
+      );
+    }
+    return sequenceToAsyncIterator(source as Sequence);
+  }
+
+  private deserializeReadableStream(
+    node: SerovalReadableStreamNode,
+  ): unknown {
+    return this.assignIndexedValue(
+      node.i,
+      sequenceToReadableStream(
+        this.deserialize(node.a[1]) as Sequence,
+      ),
+    );
+  }
+
   deserialize(node: SerovalNode): unknown {
     switch (node.t) {
       case SerovalNodeType.Constant:
@@ -469,7 +538,7 @@ export default class VanillaDeserializerContext implements PluginAccessOptions {
       case SerovalNodeType.BigInt:
         return BigInt(node.s);
       case SerovalNodeType.IndexedValue:
-        return this.values.get(node.i);
+        return this.refs.get(node.i);
       case SerovalNodeType.Reference:
         return this.deserializeReference(node);
       case SerovalNodeType.Array:
@@ -526,6 +595,30 @@ export default class VanillaDeserializerContext implements PluginAccessOptions {
         return this.deserializeDOMException(node);
       case SerovalNodeType.Plugin:
         return this.deserializePlugin(node);
+      case SerovalNodeType.PromiseConstructor:
+        return this.deserializePromiseConstructor(node);
+      case SerovalNodeType.PromiseResolve:
+        return this.deserializePromiseResolve(node);
+      case SerovalNodeType.PromiseReject:
+        return this.deserializePromiseReject(node);
+      case SerovalNodeType.ReadableStreamConstructor:
+        return this.deserializeReadableStreamConstructor(node);
+      case SerovalNodeType.ReadableStreamEnqueue:
+        return this.deserializeReadableStreamEnqueue(node);
+      case SerovalNodeType.ReadableStreamError:
+        return this.deserializeReadableStreamError(node);
+      case SerovalNodeType.ReadableStreamClose:
+        return this.deserializeReadableStreamClose(node);
+      case SerovalNodeType.IteratorFactoryInstance:
+        return this.deserializeIteratorFactoryInstance(node);
+      case SerovalNodeType.AsyncIteratorFactoryInstance:
+        return this.deserializeAsyncIteratorFactoryInstance(node);
+      case SerovalNodeType.ReadableStream:
+        return this.deserializeReadableStream(node);
+      case SerovalNodeType.MapSentinel:
+      case SerovalNodeType.IteratorFactory:
+      case SerovalNodeType.AsyncIteratorFactory:
+      case SerovalNodeType.ReadableStreamFactory:
       default:
         throw new Error('invariant');
     }