seroval 1.6.12 → 1.7.1

package/dist/index.d.cts

@@ -1,11 +1,14 @@
 //#region src/core/compat.d.ts
 /**
- * References
- * - https://compat-table.github.io/compat-table/es6/
- * - MDN
+ * Public feature bits for `disabledFeatures`. Stays a runtime `enum` so the
+ * published declaration is unchanged for consumers. Its values must match
+ * the internal bits (checked by test/feature.test.ts).
  */
-declare enum Feature {
+export declare enum Feature {
   AggregateError = 1,
+  /**
+   * @deprecated Has no effect. Output always uses arrow functions.
+   */
   ArrowFunction = 2,
   ErrorPrototypeStack = 4,
   ObjectAssign = 8,
@@ -323,6 +326,7 @@ interface SerovalStreamConstructorNode extends SerovalBaseNode {
   i: number;
   a: SerovalNode[];
   f: SerovalNodeWithID;
+  l: 1 | undefined;
 }
 interface SerovalStreamNextNode extends SerovalBaseNode {
   t: SerovalNodeType.StreamNext;
@@ -362,185 +366,189 @@ interface BaseDeserializerContextOptions extends PluginAccessOptions {
   /** Maximum encoded characters per ArrayBuffer. Defaults to 1,000,000. */
   maxBase64Length?: number;
 }
-interface BaseDeserializerContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-  /**
-   * Mapping ids to values
-   */
-  refs: Map<number, unknown> & {
-    types: Map<number, SerovalNodeType>;
-  };
-  features: number;
-  depthLimit: number;
-  maxBase64Length: number;
-}
 interface VanillaDeserializerContextOptions extends Omit<BaseDeserializerContextOptions, 'refs'> {
   markedRefs: number[] | Set<number>;
 }
-interface VanillaDeserializerState {
-  marked: Set<number>;
-}
-interface VanillaDeserializerContext {
-  mode: SerovalMode.Vanilla;
-  base: BaseDeserializerContext;
-  child: DeserializePluginContext | undefined;
-  state: VanillaDeserializerState;
-}
-interface CrossDeserializerContext {
-  mode: SerovalMode.Cross;
-  base: BaseDeserializerContext;
-  child: DeserializePluginContext | undefined;
-}
 type CrossDeserializerContextOptions = BaseDeserializerContextOptions;
-type DeserializerContext = VanillaDeserializerContext | CrossDeserializerContext;
-declare class DeserializePluginContext {
-  private _p;
-  private depth;
-  constructor(_p: DeserializerContext, depth: number);
+interface DeserializePluginContext {
   deserialize<T>(node: SerovalNode): T;
 }
 //#endregion
 //#region src/core/context/serializer.d.ts
-declare const enum AssignmentType {
-  Index = 0,
-  Add = 1,
-  Set = 2,
-  Delete = 3,
-  Define = 4
-}
-interface IndexAssignment {
-  t: AssignmentType.Index;
-  s: string;
-  k: undefined;
-  v: string;
-}
-interface SetAssignment {
-  t: AssignmentType.Set;
-  s: string;
-  k: string;
-  v: string;
-}
-interface AddAssignment {
-  t: AssignmentType.Add;
-  s: string;
-  k: undefined;
-  v: string;
-}
-interface DeleteAssignment {
-  t: AssignmentType.Delete;
-  s: string;
-  k: string;
-  v: undefined;
-}
-interface DefineAssignment {
-  t: AssignmentType.Define;
-  s: string;
-  k: string;
-  v: undefined;
-}
-type Assignment = IndexAssignment | AddAssignment | SetAssignment | DeleteAssignment | DefineAssignment;
-interface FlaggedObject {
-  type: SerovalObjectFlags;
-  value: string;
-}
 interface BaseSerializerContextOptions extends PluginAccessOptions {
   features: number;
   markedRefs: number[] | Set<number>;
-}
-interface BaseSerializerContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-  features: number;
-  stack: number[];
-  /**
-   * Array of object mutations
-   */
-  flags: FlaggedObject[];
-  /**
-   * Array of assignments to be done (used for recursion)
-   */
-  assignments: Assignment[];
-  /**
-   * Refs that are...referenced
-   */
-  marked: Set<number>;
+  assignSharedRefsOnly?: boolean;
 }
 interface CrossContextOptions {
   scopeId?: string;
 }
-interface VanillaSerializerState {
-  valid: Map<number, number>;
-  vars: string[];
-}
-interface VanillaSerializerContext {
-  mode: SerovalMode.Vanilla;
-  base: BaseSerializerContext;
-  state: VanillaSerializerState;
-  child: SerializePluginContext | undefined;
-}
 type VanillaSerializerContextOptions = BaseSerializerContextOptions;
-interface CrossSerializerContext {
-  mode: SerovalMode.Cross;
-  base: BaseSerializerContext;
-  state: CrossContextOptions;
-  child: SerializePluginContext | undefined;
-}
 interface CrossSerializerContextOptions extends BaseSerializerContextOptions, CrossContextOptions {}
-type SerializerContext = VanillaSerializerContext | CrossSerializerContext;
-declare class SerializePluginContext {
-  private _p;
-  constructor(_p: SerializerContext);
+interface SerializePluginContext {
   serialize(node: SerovalNode): string;
 }
 //#endregion
-//#region src/core/context/parser.d.ts
-interface BaseParserContextOptions extends PluginAccessOptions {
-  disabledFeatures?: number;
-  refs?: Map<unknown, number>;
-  depthLimit?: number;
-  /** Copy each typed array or DataView's visible bytes into its own buffer. */
-  compactArrayBufferViews?: boolean;
+//#region src/core/stream.d.ts
+interface StreamListener<T> {
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
 }
-interface BaseParserContext extends PluginAccessOptions {
-  readonly mode: SerovalMode;
-  marked: Set<number>;
-  refs: Map<unknown, number>;
-  features: number;
-  depthLimit: number;
-  compactArrayBufferViews: boolean;
+/**
+ * An internal class rather than a tagged POJO: identity is checked with
+ * `instanceof`, which untrusted input cannot forge. The class is exported
+ * because bundlers cannot drop an unexported top-level class.
+ *
+ * The behavior is intentionally duplicated from `STREAM_CONSTRUCTOR`. That
+ * constructor's source is embedded verbatim into the eval-based `deserialize`
+ * output, which has no access to this class, so the two cannot be shared. A
+ * stream read back through `deserialize` is therefore a plain POJO and, by
+ * design, is not treated as a genuine Stream on re-serialization. Keep the two
+ * implementations in sync.
+ */
+export declare class Stream<T> {
+  private buffer;
+  private listeners;
+  private alive;
+  private success;
+  private count;
+  private live;
+  constructor(live?: number);
+  private flush;
+  private replay;
+  on(listener: StreamListener<T>): () => void;
+  /**
+   * 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(): {
+    values: unknown[];
+    success: boolean;
+  } | undefined;
+  next(value: T): void;
+  throw(value: unknown): void;
+  return(value: T): void;
 }
+export declare function isStream<T>(value: unknown): value is Stream<T> | LiveStream<T>;
+export declare function createStream<T>(): Stream<T>;
+//#endregion
+//#region src/core/live-stream.d.ts
+type LiveStreamEvent<T> = {
+  type: 'next';
+  value: T;
+} | {
+  type: 'return';
+  value: T;
+} | {
+  type: 'throw';
+  error: unknown;
+};
+interface LiveStreamDelivery<T> {
+  event: LiveStreamEvent<T>;
+  /**
+   * Release the event and resolve the producer operation that sent it.
+   * Call it only after the serialized record for the event has been
+   * accepted by its destination. Late or repeated calls are ignored.
+   */
+  accept(): void;
+}
+interface LiveStreamConsumer<T> {
+  read(): Promise<LiveStreamDelivery<T>>;
+  cancel(reason?: unknown): void;
+}
+interface LiveStreamProducer<T> {
+  write(value: T): Promise<void>;
+  close(value: T): Promise<void>;
+  fail(error: unknown): Promise<void>;
+}
+/**
+ * Receives events from `LiveStream.pump`. Each handler gets the event value
+ * and the accept function for it, and returns `undefined` to keep going or
+ * the error that stopped the sink. `error` runs if the stream is cancelled
+ * while a read is pending.
+ */
+interface LiveStreamSink<T> {
+  next(value: T, accept: () => void): unknown;
+  throw(value: unknown, accept: () => void): unknown;
+  return(value: T, accept: () => void): unknown;
+  /** Runs once after the terminal event, or after a handler failed. */
+  done?(): void;
+  /** Runs if the stream is cancelled while a read is pending. */
+  error?(reason: unknown): void;
+}
+interface LiveStreamOptions {
+  onCancel?: (reason: unknown) => void;
+}
+export declare function isLiveStream<T>(value: unknown): value is LiveStream<T>;
+/**
+ * A single-consumer stream for incremental serialization. Unlike
+ * `createStream`, it keeps no history: at most one event is held, and the
+ * producer operation that sent it settles only when the consumer accepts it.
+ *
+ * An internal class rather than a tagged POJO: identity is checked with
+ * `instanceof`, which untrusted input cannot forge. The class is exported
+ * because bundlers cannot drop an unexported top-level class.
+ */
+export declare class LiveStream<T> {
+  private pending;
+  private waiting;
+  private consumed;
+  private closed;
+  private cancelled;
+  private cancelReason;
+  private options;
+  constructor(options?: LiveStreamOptions);
+  private deliver;
+  /** @internal */
+  push(event: LiveStreamEvent<T>): Promise<void>;
+  private cancel;
+  private read;
+  consume(): LiveStreamConsumer<T>;
+  /**
+   * 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: StreamListener<T>): () => void;
+  /**
+   * Consumes the stream into a sink that controls acceptance. Returns the
+   * cancel function.
+   * @internal
+   */
+  pump(sink: LiveStreamSink<T>): (reason?: unknown) => void;
+}
+/**
+ * Creates a live stream and the producer that writes to it.
+ */
+export declare function createLiveStream<T>(options?: LiveStreamOptions): {
+  stream: LiveStream<T>;
+  producer: LiveStreamProducer<T>;
+};
 //#endregion
 //#region src/core/context/sync-parser.d.ts
 type SyncParserContextOptions = BaseParserContextOptions;
-declare const enum ParserMode {
-  Sync = 1,
-  Stream = 2
-}
-interface SyncParserContext {
-  type: ParserMode.Sync;
-  base: BaseParserContext;
-  child: SyncParsePluginContext | undefined;
-}
-declare class SyncParsePluginContext {
-  private _p;
-  private depth;
-  constructor(_p: SyncParserContext, depth: number);
+interface SyncParsePluginContext {
   parse<T>(current: T): SerovalNode;
 }
 interface StreamParserContextOptions extends SyncParserContextOptions {
-  onParse: (node: SerovalNode, initial: boolean) => void;
+  /**
+   * Receives each parsed record. Returning a promise defers the next record,
+   * and the acceptance of the source event that produced it, until the
+   * promise settles.
+   */
+  onParse: (node: SerovalNode, initial: boolean) => void | PromiseLike<void>;
   onError?: (error: unknown) => void;
   onDone?: () => void;
 }
-interface StreamParserContext {
-  type: ParserMode.Stream;
-  base: BaseParserContext;
-  state: StreamParserState;
-}
-declare class StreamParsePluginContext {
-  private _p;
-  private depth;
-  constructor(_p: StreamParserContext, depth: number);
+//#endregion
+//#region src/core/context/stream-parser.d.ts
+interface StreamParsePluginContext {
   parse<T>(current: T): SerovalNode;
+  parseStreamSource(current: AsyncIterable<unknown>): SerovalNode;
   parseWithError<T>(current: T): SerovalNode | undefined;
   isAlive(): boolean;
   pushPendingState(): void;
@@ -549,29 +557,19 @@ declare class StreamParsePluginContext {
   onError(error: unknown): void;
   addCleanup(callback: () => void): void;
 }
-interface StreamParserState {
-  alive: boolean;
-  pending: number;
-  initial: boolean;
-  buffer: SerovalNode[];
-  onParse: (node: SerovalNode, initial: boolean) => void;
-  onError?: (error: unknown) => void;
-  onDone?: () => void;
-  cleanups: (() => void)[];
-}
 //#endregion
 //#region src/core/plugin.d.ts
-declare const enum SerovalMode {
+export declare const enum SerovalMode {
   Vanilla = 1,
   Cross = 2
 }
-interface PluginData {
+export interface PluginData {
   id: number;
 }
-type PluginInfo = {
+export type PluginInfo = {
   [key: string]: SerovalNode;
 };
-interface Plugin<Value, Info extends PluginInfo> {
+export interface Plugin<Value, Info extends PluginInfo> {
   /**
    * A unique string that helps idenfity the plugin
    */
@@ -585,6 +583,13 @@ interface Plugin<Value, Info extends PluginInfo> {
    * @param value
    */
   test(value: unknown): boolean;
+  /**
+   * Set to `true` if `test` never returns `true` for a plain object, whose
+   * prototype is `Object.prototype`, such as an object literal. The parsers
+   * then skip this plugin for those objects. Leave it unset if unsure. A
+   * plugin that sets it is never applied to such objects.
+   */
+  skipPlainObjects?: boolean;
   /**
    * Parsing modes
    */
@@ -602,105 +607,149 @@ interface Plugin<Value, Info extends PluginInfo> {
    */
   deserialize(node: Info, ctx: DeserializePluginContext, data: PluginData): Value;
 }
-declare function createPlugin<Value, Info extends PluginInfo>(plugin: Plugin<Value, Info>): Plugin<Value, Info>;
-interface PluginAccessOptions {
+export declare function createPlugin<Value, Info extends PluginInfo>(plugin: Plugin<Value, Info>): Plugin<Value, Info>;
+export interface PluginAccessOptions {
   plugins?: Plugin<any, any>[];
 }
-declare function resolvePlugins(plugins?: Plugin<any, any>[]): Plugin<any, any>[] | undefined;
+export declare function resolvePlugins(plugins?: Plugin<any, any>[]): Plugin<any, any>[] | undefined;
+/**
+ * Returns the plugins that are tested for plain objects. It is the same array
+ * when no plugin sets `skipPlainObjects`.
+ */
+export declare function getPlainObjectPlugins(plugins: Plugin<any, any>[] | undefined): Plugin<any, any>[] | undefined;
+//#endregion
+//#region src/core/context/parser.d.ts
+interface BaseParserContextOptions extends PluginAccessOptions {
+  disabledFeatures?: number;
+  refs?: Map<unknown, number>;
+  depthLimit?: number;
+  /** Copy each typed array or DataView's visible bytes into its own buffer. */
+  compactArrayBufferViews?: boolean;
+}
 //#endregion
 //#region src/core/context/async-parser.d.ts
 type AsyncParserContextOptions = BaseParserContextOptions;
-interface AsyncParserContext {
-  base: BaseParserContext;
-  child: AsyncParsePluginContext | undefined;
-}
-declare class AsyncParsePluginContext {
-  private _p;
-  private depth;
-  constructor(_p: AsyncParserContext, depth: number);
+interface AsyncParsePluginContext {
   parse<T>(current: T): Promise<SerovalNode>;
+  parseStreamSource(current: AsyncIterable<unknown>): Promise<SerovalNode>;
 }
 //#endregion
 //#region src/core/cross/index.d.ts
-interface CrossSerializeOptions extends SyncParserContextOptions, CrossContextOptions {}
-declare function crossSerialize<T>(source: T, options?: CrossSerializeOptions): string;
-interface CrossSerializeAsyncOptions extends AsyncParserContextOptions, CrossContextOptions {}
-declare function crossSerializeAsync<T>(source: T, options?: CrossSerializeAsyncOptions): Promise<string>;
-type ToCrossJSONOptions = SyncParserContextOptions;
-declare function toCrossJSON<T>(source: T, options?: ToCrossJSONOptions): SerovalNode;
-type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
-declare function toCrossJSONAsync<T>(source: T, options?: ToCrossJSONAsyncOptions): Promise<SerovalNode>;
-interface CrossSerializeStreamOptions extends Omit<StreamParserContextOptions, 'onParse'>, CrossContextOptions {
-  onSerialize: (data: string, initial: boolean) => void;
-}
-declare function crossSerializeStream<T>(source: T, options: CrossSerializeStreamOptions): () => void;
-type ToCrossJSONStreamOptions = StreamParserContextOptions;
-declare function toCrossJSONStream<T>(source: T, options: ToCrossJSONStreamOptions): () => void;
-type FromCrossJSONOptions = CrossDeserializerContextOptions;
-declare function fromCrossJSON<T>(source: SerovalNode, options: FromCrossJSONOptions): T;
+export interface CrossAssignmentOptions {
+  /**
+   * Only assign `$R[n]` for values that the output reads more than once,
+   * such as shared references and cycles. The output is shorter, but later
+   * scripts cannot read the other values from `$R`. Only use it when no
+   * later output that shares the same references refers back to this one.
+   */
+  assignSharedRefsOnly?: boolean;
+}
+export interface CrossSerializeOptions extends SyncParserContextOptions, CrossContextOptions, CrossAssignmentOptions {}
+export declare function crossSerialize<T>(source: T, options?: CrossSerializeOptions): string;
+export interface CrossSerializeAsyncOptions extends AsyncParserContextOptions, CrossContextOptions, CrossAssignmentOptions {}
+export declare function crossSerializeAsync<T>(source: T, options?: CrossSerializeAsyncOptions): Promise<string>;
+export type ToCrossJSONOptions = SyncParserContextOptions;
+export declare function toCrossJSON<T>(source: T, options?: ToCrossJSONOptions): SerovalNode;
+export type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
+export declare function toCrossJSONAsync<T>(source: T, options?: ToCrossJSONAsyncOptions): Promise<SerovalNode>;
+export interface CrossSerializeStreamOptions extends Omit<StreamParserContextOptions, 'onParse'>, CrossContextOptions {
+  /**
+   * Receives each serialized record. Returning a promise defers the next
+   * record, and the acceptance of the live stream event behind this one,
+   * until the promise settles.
+   */
+  onSerialize: (data: string, initial: boolean) => void | PromiseLike<void>;
+}
+export declare function crossSerializeStream<T>(source: T, options: CrossSerializeStreamOptions): (reason?: unknown) => void;
+export type ToCrossJSONStreamOptions = StreamParserContextOptions;
+export declare function toCrossJSONStream<T>(source: T, options: ToCrossJSONStreamOptions): (reason?: unknown) => void;
+export type FromCrossJSONOptions = CrossDeserializerContextOptions;
+export declare function fromCrossJSON<T>(source: SerovalNode, options: FromCrossJSONOptions): T;
+export interface CrossDeserializer {
+  /** Deserializes one streamed record. Records share references. */
+  deserialize<T>(node: SerovalNode): T;
+  /** Deferred values (promises, streams) created but not yet settled. */
+  readonly pending: number;
+  /** Rejects pending promises and throws into open streams; idempotent. */
+  abort(reason: unknown): void;
+}
+export type CrossDeserializerOptions = FromCrossJSONOptions;
+export declare function createCrossDeserializer(options: CrossDeserializerOptions): CrossDeserializer;
 //#endregion
 //#region src/core/errors.d.ts
-declare class SerovalError extends Error {
+export declare class SerovalError extends Error {
   cause: unknown;
   constructor(type: string, cause: unknown);
 }
-declare class SerovalParserError extends SerovalError {
+export declare class SerovalParserError extends SerovalError {
   constructor(cause: unknown);
 }
-declare class SerovalSerializationError extends SerovalError {
+export declare class SerovalSerializationError extends SerovalError {
   constructor(cause: unknown);
 }
-declare class SerovalDeserializationError extends SerovalError {
+export declare class SerovalDeserializationError extends SerovalError {
   constructor(cause: unknown);
 }
-declare class SerovalUnsupportedTypeError extends Error {
+export declare class SerovalUnsupportedTypeError extends Error {
   value: unknown;
   constructor(value: unknown);
 }
-declare class SerovalUnsupportedNodeError extends Error {
+export declare class SerovalUnsupportedNodeError extends Error {
   constructor(node: SerovalNode);
 }
-declare class SerovalMissingPluginError extends Error {
+export declare class SerovalMissingPluginError extends Error {
   constructor(tag: string);
 }
-declare class SerovalMissingInstanceError extends Error {
+export declare class SerovalMissingInstanceError extends Error {
   constructor(tag: string);
 }
-declare class SerovalMissingReferenceError extends Error {
+/**
+ * @deprecated Not thrown by seroval. A missing `createReference` key throws
+ * {@link SerovalMissingReferenceForIdError} instead.
+ */
+export declare class SerovalMissingReferenceError extends Error {
   value: unknown;
   constructor(value: unknown);
 }
-declare class SerovalMissingReferenceForIdError extends Error {
+export declare class SerovalMissingReferenceForIdError extends Error {
   constructor(id: string);
 }
-declare class SerovalUnknownTypedArrayError extends Error {
+export declare class SerovalUnknownTypedArrayError extends Error {
   constructor(name: string);
 }
-declare class SerovalMalformedNodeError extends Error {
+export declare class SerovalMalformedNodeError extends Error {
   constructor(node: SerovalNode);
 }
-declare class SerovalConflictedNodeIdError extends Error {
+export declare class SerovalConflictedNodeIdError extends Error {
   constructor(node: SerovalNode);
 }
-declare class SerovalDepthLimitError extends Error {
+export declare class SerovalDepthLimitError extends Error {
   constructor(limit: number);
 }
+export declare class SerovalAbortedError extends Error {
+  constructor();
+}
+export type LiveStreamErrorReason = 'consumed' | 'pending' | 'reading' | 'closed';
+export declare class SerovalLiveStreamError extends Error {
+  reason: LiveStreamErrorReason;
+  constructor(reason: LiveStreamErrorReason);
+}
 //#endregion
 //#region src/core/keys.d.ts
-declare function getCrossReferenceHeader(id?: string): string;
+export declare function getCrossReferenceHeader(id?: string): string;
 //#endregion
 //#region src/core/opaque-reference.d.ts
 /**
  * An opaque reference allows hiding values from the serializer.
  */
-declare class OpaqueReference<V, R = undefined> {
+export declare class OpaqueReference<V, R = undefined> {
   readonly value: V;
   readonly replacement?: R | undefined;
   constructor(value: V, replacement?: R | undefined);
 }
 //#endregion
 //#region src/core/reference.d.ts
-declare function createReference<T>(id: string, value: T): T;
+export declare function createReference<T>(id: string, value: T): T;
 //#endregion
 //#region src/core/Serializer.d.ts
 interface SerializerOptions extends PluginAccessOptions {
@@ -708,79 +757,75 @@ interface SerializerOptions extends PluginAccessOptions {
   scopeId?: string;
   disabledFeatures?: number;
   compactArrayBufferViews?: boolean;
+  depthLimit?: number;
   onData: (result: string) => void;
   onError: (error: unknown) => void;
   onDone?: () => void;
 }
 declare class Serializer {
-  private options;
   private alive;
   private flushed;
   private done;
   private pending;
   private cleanups;
-  private refs;
+  private readonly refs;
   private plugins?;
+  private options;
   constructor(options: SerializerOptions);
   keys: Set<string>;
   write(key: string, value: unknown): void;
+  private finishWrite;
   ids: number;
   private getNextID;
   push(value: unknown): string;
   flush(): void;
   close(): void;
+  private finish;
 }
 //#endregion
-//#region src/core/stream.d.ts
-interface StreamListener<T> {
-  next(value: T): void;
-  throw(value: unknown): void;
-  return(value: T): void;
-}
+//#region src/core/sequence.d.ts
 /**
  * An internal class rather than a tagged POJO: identity is checked with
- * `instanceof`, which untrusted input cannot forge (the class is not exported).
- *
- * The behavior is intentionally duplicated from `STREAM_CONSTRUCTOR`. That
- * constructor's source is embedded verbatim into the eval-based `deserialize`
- * output, which has no access to this class, so the two cannot be shared. A
- * stream read back through `deserialize` is therefore a plain POJO and, by
- * design, is not treated as a genuine Stream on re-serialization. Keep the two
- * implementations in sync.
+ * `instanceof`, which untrusted input cannot forge. The class is exported
+ * because bundlers cannot drop an unexported top-level class.
+ * The eval-based `deserialize` path still rebuilds a `{__SEROVAL_SEQUENCE__…}`
+ * POJO from embedded source - it has no access to this class - so a value read
+ * back through `deserialize` is not an instance and, by design, is not treated
+ * as a genuine Sequence on re-serialization.
  */
-declare class Stream<T> {
-  private buffer;
-  private listeners;
-  private alive;
-  private success;
-  private count;
-  private flush;
-  private replay;
-  on(listener: StreamListener<T>): () => void;
-  next(value: T): void;
-  throw(value: unknown): void;
-  return(value: T): void;
+export declare class Sequence {
+  v: unknown[];
+  t: number;
+  d: number;
+  constructor(values: unknown[], throwAt: number, doneAt: number);
 }
-declare function isStream<T>(value: unknown): value is Stream<T>;
-declare function createStream<T>(): Stream<T>;
 //#endregion
 //#region src/core/tree/index.d.ts
-type SyncParserContextOptions$1 = Omit<BaseParserContextOptions, 'refs'>;
-type AsyncParserContextOptions$1 = Omit<BaseParserContextOptions, 'refs'>;
-declare function serialize<T>(source: T, options?: SyncParserContextOptions$1): string;
-declare function serializeAsync<T>(source: T, options?: AsyncParserContextOptions$1): Promise<string>;
-declare function deserialize<T>(source: string): T;
-interface SerovalJSON {
+/**
+ * Options for `serialize`. The same as the parser options, without `refs`:
+ * the output is self-contained, so there is nothing to share between calls.
+ */
+export type SerializeOptions = Omit<BaseParserContextOptions, 'refs'>;
+/** Options for `serializeAsync`. */
+export type SerializeAsyncOptions = Omit<BaseParserContextOptions, 'refs'>;
+/** Options for `toJSON`. */
+export type ToJSONOptions = SerializeOptions;
+/** Options for `toJSONAsync`. */
+export type ToJSONAsyncOptions = SerializeAsyncOptions;
+export declare function serialize<T>(source: T, options?: SerializeOptions): string;
+export declare function serializeAsync<T>(source: T, options?: SerializeAsyncOptions): Promise<string>;
+export declare function deserialize<T>(source: string): T;
+export interface SerovalJSON {
   t: SerovalNode;
   f: number;
   m: number[];
 }
-interface FromJSONOptions extends PluginAccessOptions, Pick<BaseDeserializerContextOptions, 'maxBase64Length'> {
+export interface FromJSONOptions extends PluginAccessOptions, Pick<BaseDeserializerContextOptions, 'depthLimit' | 'maxBase64Length'> {
   disabledFeatures?: number;
 }
-declare function toJSON<T>(source: T, options?: SyncParserContextOptions$1): SerovalJSON;
-declare function toJSONAsync<T>(source: T, options?: AsyncParserContextOptions$1): Promise<SerovalJSON>;
-declare function compileJSON(source: SerovalJSON, options?: PluginAccessOptions): string;
-declare function fromJSON<T>(source: SerovalJSON, options?: FromJSONOptions): T;
+export declare function toJSON<T>(source: T, options?: ToJSONOptions): SerovalJSON;
+export declare function toJSONAsync<T>(source: T, options?: ToJSONAsyncOptions): Promise<SerovalJSON>;
+export declare function compileJSON(source: SerovalJSON, options?: PluginAccessOptions): string;
+export declare function fromJSON<T>(source: SerovalJSON, options?: FromJSONOptions): T;
 //#endregion
-export { type AsyncParsePluginContext, AsyncParserContextOptions, type BaseDeserializerContextOptions, type BaseParserContextOptions, type BaseSerializerContextOptions, type CrossContextOptions, type CrossDeserializerContextOptions, CrossSerializeAsyncOptions, CrossSerializeOptions, CrossSerializeStreamOptions, type CrossSerializerContextOptions, type DeserializePluginContext, Feature, FromCrossJSONOptions, FromJSONOptions, OpaqueReference, Plugin, PluginAccessOptions, PluginData, PluginInfo, type SerializePluginContext, Serializer, SerovalConflictedNodeIdError, SerovalDepthLimitError, SerovalDeserializationError, SerovalError, SerovalJSON, SerovalMalformedNodeError, SerovalMissingInstanceError, SerovalMissingPluginError, SerovalMissingReferenceError, SerovalMissingReferenceForIdError, SerovalMode, type SerovalNode, SerovalParserError, SerovalSerializationError, SerovalUnknownTypedArrayError, SerovalUnsupportedNodeError, SerovalUnsupportedTypeError, type Stream, type StreamListener, type StreamParsePluginContext, type StreamParserContextOptions, type SyncParsePluginContext, SyncParserContextOptions, ToCrossJSONAsyncOptions, ToCrossJSONOptions, ToCrossJSONStreamOptions, type VanillaDeserializerContextOptions, type VanillaSerializerContextOptions, compileJSON, createPlugin, createReference, createStream, crossSerialize, crossSerializeAsync, crossSerializeStream, deserialize, fromCrossJSON, fromJSON, getCrossReferenceHeader, isStream, resolvePlugins, serialize, serializeAsync, toCrossJSON, toCrossJSONAsync, toCrossJSONStream, toJSON, toJSONAsync };
+export { type AsyncParsePluginContext, type AsyncParserContextOptions, type BaseDeserializerContextOptions, type BaseParserContextOptions, type BaseSerializerContextOptions, type CrossContextOptions, type CrossDeserializerContextOptions, type CrossSerializerContextOptions, type DeserializePluginContext, type LiveStreamConsumer, type LiveStreamDelivery, type LiveStreamEvent, type LiveStreamOptions, type LiveStreamProducer, type SerializePluginContext, Serializer, type SerovalNode, type StreamListener, type StreamParsePluginContext, type StreamParserContextOptions, type SyncParsePluginContext, type SyncParserContextOptions, type VanillaDeserializerContextOptions, type VanillaSerializerContextOptions };