madeonsol-x402 2.1.0 → 2.3.0

package/dist/stream.d.ts

@@ -7,26 +7,270 @@
  * not expire: `getToken()` is called on every (re)connect and returns the
  * same value until the subscription lapses or you explicitly rotate it.
  *
+ * Recovery (v1 resume): the client remembers a cursor `{instance, seq, ts}` —
+ * the last frame whose handlers finished — and on every reconnect asks the
+ * server to resume after it (`subscribe {…, resume}`); against an older server
+ * it falls back to `replay_since_seq` (same process) / `replay_since_ts`
+ * (restarted). Delivery is at-least-once, de-duplicated by event `id`; a
+ * `"gap"` event says what could NOT be recovered. `seq` gaps are normal and
+ * never mean loss. Close codes: 4001 re-fetches the token (bounded, then
+ * `"fatal"`), 4002 (connection limit) waits ≥ 60 s, 4003 stops with
+ * `"fatal"`, 4008 (slow consumer) reconnects and resumes.
+ *
  * Works in Node (uses the global `WebSocket` on Node 22+, else lazily imports
  * the optional `ws` package) and the browser (native WebSocket). Zero required
  * dependencies.
  */
 import type { StreamToken } from "./types.js";
-/** Channels you can subscribe to. */
-export type StreamChannel = "kol:trades" | "kol:coordination" | "kol:first_touches" | "deployer:alerts" | "wallet_tracker:events" | "copytrade:signals" | "price_alert:events" | "sniper:deploys" | "token:graduations" | "token:locks" | "token:fee_claims" | "token:surges";
+/** Channels you can subscribe to (mirrors the server registry, services/shared/stream-channels.mjs). */
+export type StreamChannel = "kol:trades" | "kol:coordination" | "kol:first_touches" | "deployer:alerts" | "wallet_tracker:events" | "copytrade:signals" | "price_alert:events" | "sniper:deploys" | "token:graduations" | "token:prices" | "token:locks" | "token:fee_claims" | "token:surges";
+/** Every Solana channel, in the server's order. */
+export declare const STREAM_CHANNELS: readonly StreamChannel[];
 /** Event names delivered on those channels (subscribe to a channel, receive these). */
-export type StreamEventName = "kol:trade" | "kol:coordination" | "kol:first_touch" | "deployer:alert" | "deployer:bond" | "wallet_tracker:event" | "copytrade:signal" | "price_alert:dip" | "price_alert:recovery" | "sniper:deploy" | "token:graduation" | "token:lock" | "token:fee_claim" | "token:surge" | "token:revival";
+export type StreamEventName = "kol:trade" | "kol:coordination" | "kol:first_touch" | "deployer:alert" | "deployer:bond" | "wallet_tracker:event" | "copytrade:signal" | "price_alert:dip" | "price_alert:recovery" | "sniper:deploy" | "token:graduation" | "token:price" | "token:lock" | "token:fee_claim" | "token:surge" | "token:revival";
 /** Lifecycle events you can also listen for. */
-export type StreamLifecycleEvent = "open" | "close" | "reconnect" | "subscribed" | "heartbeat" | "error";
+export type StreamLifecycleEvent = "open" | "close" | "reconnect" | "subscribed" | "updated" | "unsubscribed" | "heartbeat" | "warning" | "cursor" | "replay" | "gap" | "fatal" | "error";
+/**
+ * A server `type: "warning"` frame, surfaced as the `"warning"` lifecycle
+ * event. Known codes: `channels_rejected` (a subscribe named a channel that
+ * does not exist or that your tier cannot hold — each with a reason, plus the
+ * full list of channels it accepts) and `channels_revoked` (the server dropped
+ * channels you held, e.g. after a plan downgrade). A rejected or revoked
+ * channel is silent, so never ignore these.
+ */
+export interface StreamWarning {
+    /**
+     * Machine-readable code: `channels_rejected`, `channels_revoked`,
+     * `replay_in_progress`, and for named subscriptions `invalid_sub_id`,
+     * `too_many_subscriptions`, `unknown_sub_id`, `invalid_filters`; the client
+     * itself emits `named_subscriptions_unsupported` once when the server
+     * ignores `sub_id` (older deployment).
+     */
+    code?: string;
+    /** The named subscription the warning is about (absent for the default one). */
+    sub_id?: string;
+    /** Channels the server refused, each with a human-readable reason. */
+    rejected?: Array<{
+        channel: string;
+        reason: string;
+    }>;
+    /** Channels the server removed from this connection (channels_revoked). */
+    revoked?: Array<{
+        channel: string;
+        reason: string;
+    }> | string[];
+    /** Every channel the server accepts. */
+    valid_channels?: string[];
+    /** Optional human-readable message (not sent on every warning). */
+    message?: string;
+    /** Server timestamp (ms). */
+    ts?: number;
+    [key: string]: unknown;
+}
+/**
+ * Resume cursor = the last SAFE point: every event up to it has been
+ * processed ("processed" = every handler for that frame returned, or the
+ * promise it returned settled). Two positions are kept:
+ *  - `getProgress()` — what has been received and handled, including replayed frames;
+ *  - `getCursor()` — the COMMITTED cursor, the only one to persist and resume from.
+ * Live frames commit as they are processed. During a resume, replayed frames
+ * are delivered but do NOT commit (the server replays channel by channel): the
+ * cursor moves to the server's `last_seq` / `last_ts` only when
+ * `replay_end` says `complete: true` with no incomplete / best-effort
+ * channel. After an INCOMPLETE recovery (or a close mid-replay) it stays at
+ * the pre-resume point, and later live frames are delivered but not committed
+ * until a recovery completes — so the next reconnect re-requests the
+ * unrecovered range (duplicates are dropped by id). Call `acceptGap()` once
+ * you have backfilled (or decided to skip) the range. `instance` identifies the server process
+ * (seq restarts when it changes), `seq` is the server's global ordinal and
+ * `ts` the frame time in ms. Delivery is at-least-once: after a resume you may
+ * see a frame again — dedupe by `evt.id` (the client already drops ids it saw
+ * recently). Persist it (on the `"cursor"` event or via `getCursor()`) and pass
+ * it back as the `resume` option to continue after a process restart.
+ */
+export interface StreamCursor {
+    instance: string;
+    seq: number;
+    ts: number;
+}
+/**
+ * A named subscription (Phase 2): one socket can hold several, each with its
+ * own channels and filters. `subId` is client-chosen, 1-64 characters of
+ * `A-Z a-z 0-9 _ . -`. The plain `subscribe(channels, filters)` call is the
+ * connection's implicit `"default"` subscription; its frames carry no
+ * `sub_id`. An event that matches several subscriptions is delivered once
+ * per matching subscription, each frame stamped with its `sub_id`, and the
+ * client dedupes by (sub_id, id) — so the same event CAN reach two handlers
+ * legitimately. Tier caps (total per connection, the default one included):
+ * PRO 5, ULTRA 10, BUSINESS 20.
+ */
+export interface StreamSubscription {
+    subId: string;
+    channels: StreamChannel[];
+    filters: Record<string, unknown>;
+}
+/** Argument of `subscribe({ subId, channels, filters })`. */
+export interface StreamSubscribeOptions {
+    subId: string;
+    channels: StreamChannel[];
+    /** Filters scoped to THIS subscription only. Omitted = keep the ones it has. */
+    filters?: Record<string, unknown>;
+}
 export interface StreamEvent<T = unknown> {
     channel: StreamChannel;
     event: StreamEventName;
     data: T;
     ts: number;
+    /** The named subscription this frame was delivered under; absent for the default subscription. */
+    sub_id?: string;
+    /** Stable event id — the same event carries the same id live and in replay. Dedupe on it. */
+    id?: string;
+    /**
+     * Server-global ordinal. Gaps are NORMAL (it counts every channel and every
+     * user) and are never evidence of loss — only a `"gap"` event is.
+     */
+    seq?: number | null;
+    /** true when the frame was re-sent by a replay/backfill rather than live. */
+    replayed?: boolean;
+    /**
+     * Where a replayed frame came from: "ring" (the server's in-memory buffer) or
+     * "durable" (rebuilt from storage — `seq` is then null).
+     */
+    mode?: "ring" | "durable";
+    /** true when a durable frame could not reproduce every live field — see `missing`. */
+    partial?: boolean;
+    /** Live payload keys a durable frame could not reproduce (they are absent, never guessed). */
+    missing?: string[];
+    /** "bus" for a live-path frame the server re-sent after its own event-bus reconnect. */
+    recovered?: string;
+    /** true on a token:price state snapshot sent at resume time. */
+    snapshot?: boolean;
+}
+/** Outcome of a resume, emitted as `"replay"` after the server's `replay_end`. */
+export interface StreamReplayResult {
+    /** "resume" = the server answered the v1 `resume` request; "legacy" = the
+     *  client fell back to `replay_since_seq` / `replay_since_ts` (older server). */
+    protocol: "resume" | "legacy";
+    /** The cursor the client resumed from. */
+    from: StreamCursor | null;
+    /** The resume fields the client sent. */
+    request: Record<string, unknown>;
+    /** Replayed frames received. */
+    received: number;
+    /** Replayed frames handed to your handlers (received minus duplicates). */
+    delivered: number;
+    /** Replayed frames dropped because their id was already delivered. */
+    duplicates: number;
+    /** false when anything could not be recovered — a `"gap"` event follows. */
+    complete: boolean;
+    /** Server's replay mode ("ring" | "durable"), null on an older server. */
+    mode: string | null;
+    /** Why the server could not use its ring (e.g. "instance_changed", "ring_truncated"), or null. */
+    resumeReason: string | null;
+    /** Raw `replay_start` frame (null if none arrived). */
+    start: Record<string, unknown> | null;
+    /**
+     * Raw `replay_end` frame (null on a client-side timeout). With several
+     * named subscriptions this is the LAST one received; `ends` has them all.
+     */
+    end: Record<string, unknown> | null;
+    /**
+     * The subscriptions this recovery covered (`"default"` for the plain one).
+     * A client holding N named subscriptions resumes each of them: every
+     * subscribe of the reconnect carries the same cursor, the server serves the
+     * replays one after another and the cursor commits once ALL have ended,
+     * at the smallest `last_seq` / `last_ts` across them.
+     */
+    subscriptions: string[];
+    /** Raw `replay_end` frame per subscription. */
+    ends: Record<string, Record<string, unknown>>;
+}
+/**
+ * Part of a resume could not be recovered. It says what is KNOWN: which
+ * channels the server could not fully rebuild, the RANGE that may be
+ * incomplete (`skipped.from` → `skipped.to`, or from `from` onwards while the
+ * cursor stays), the server's reason and whether it is final, and the bounds
+ * the server reported (`limits`, and per-channel entries in `channels`:
+ * `time_basis`, `truncated_at_ts`, `retry_after_ms`, …). Events in that range
+ * MAY be missing — how many, nobody can say, so this never claims a count.
+ * Backfill the range from REST if you need certainty. `reasons` uses the
+ * server's vocabulary (`backpressure`, `closed`, `source_busy`,
+ * `source_error`, `late_ingest_possible`, `row_cap`, `ring_truncated`,
+ * `instance_changed`, `window_exceeded`, `not_reconstructable`) plus the
+ * client-side `replay_timeout`.
+ */
+export interface StreamGap {
+    /** The first reason (convenience). */
+    reason: string;
+    reasons: string[];
+    /**
+     * true when EVERY reason is permanent — asking again can never fill it
+     * (`not_reconstructable`, `state_stream`, `window_exceeded`, or an older
+     * server's `ring_truncated` / `instance_changed`). The client reports it
+     * once and commits as if complete. false = transient (`backpressure`,
+     * `row_cap`, `source_busy`, `source_error`, `late_ingest` / `best_effort`,
+     * `incomplete`, `replay_timeout`, …): the committed cursor stays and the
+     * range is requested again on the next reconnect.
+     */
+    permanent: boolean;
+    /**
+     * Per-channel entries the server reported as incomplete / not
+     * reconstructable, keyed by channel for the default subscription and by
+     * `"<sub_id>/<channel>"` for a named one.
+     */
+    channels: Record<string, unknown>;
+    /** The cursor the resume started from (the committed cursor stays there). */
+    from: StreamCursor | null;
+    /** true when the server says the gap is transient and worth asking again (`retryable`). */
+    retryable: boolean;
+    /** How long the server wants you to wait before resuming again (ms), when it says. */
+    retryAfterMs: number | null;
+    /** For `row_cap`: the ts to resume from next (the client uses it automatically). */
+    resumeTsHint: number | null;
+    /**
+     * true when the CLIENT decided to continue past this gap and move the
+     * committed cursor beyond it — the events in `skipped` are not coming back.
+     * This is the SDK's own decision (see `onUnrecoverableGap`), never a user
+     * approval. false = the cursor stayed put.
+     */
+    advancedPastGap: boolean;
+    /** "auto" = the client's own decision; "manual" = you called `acceptGap()`. */
+    source: "auto" | "manual";
+    /**
+     * The range that may be incomplete: the channels the server could not fully
+     * rebuild and the cursor positions the client jumped between (`to` is null
+     * when the cursor did not move). Events in that range may be missing.
+     */
+    skipped: {
+        channels: string[];
+        from: StreamCursor | null;
+        to: StreamCursor | null;
+    };
+    /** Bounds the server reported for this resume (max age, row caps, slack), when it sends them. */
+    limits: Record<string, unknown> | null;
+    /**
+     * true when this gap is retryable but the automatic re-resume budget
+     * (`maxResumeRetries`) is spent: the client stops asking again on this
+     * connection and the committed cursor stays put until the next reconnect
+     * resumes (or you call `acceptGap()`).
+     */
+    exhausted: boolean;
+    replay: StreamReplayResult;
+}
+/** The stream stopped and will not reconnect on its own. */
+export interface StreamFatal {
+    code: number | null;
+    reason: string;
+    /** The unrecoverable gap that stopped it (`onUnrecoverableGap: "stop"` only). */
+    gap?: StreamGap;
 }
 export interface StreamClientOptions {
-    /** Returns your stream token (the SDK wires this to getStreamToken()). Called on every
-     *  (re)connect; the token does not expire, so it returns the same value each time. */
+    /**
+     * Returns your stream token (the SDK wires this to the stream-token
+     * endpoint). Called on every (re)connect — including after a 4001 close,
+     * which is how a rotated/lapsed token gets replaced. Tokens never expire, so
+     * it is never called on a timer.
+     */
     getToken: () => Promise<StreamToken>;
     /** Reconnect automatically on drop (default: true). */
     autoReconnect?: boolean;
@@ -36,34 +280,200 @@ export interface StreamClientOptions {
     heartbeatTimeoutMs?: number;
     /** Override the WebSocket implementation (e.g. inject `ws` explicitly). */
     WebSocketImpl?: unknown;
+    /**
+     * A cursor you persisted earlier (from `getCursor()` or the `"cursor"`
+     * event). The first subscribe then asks the server to resume after it.
+     */
+    resume?: StreamCursor | null;
+    /** How many recent event ids to remember for de-duplication (default: 10000). */
+    dedupeSize?: number;
+    /** Consecutive 4001 closes (token rejected) before `"fatal"` (default: 3). */
+    maxAuthRetries?: number;
+    /** Minimum wait after a 4002 connection-limit close, in ms (default: 60000). */
+    connectionLimitBackoffMs?: number;
+    /**
+     * After a resume subscribe is acked, how long to wait for the server's
+     * `replay_start` before assuming an older server that does not understand
+     * `resume`, and retrying with `replay_since_seq` / `replay_since_ts`
+     * (default: 3000). A live event arriving first triggers the fallback at once.
+     */
+    resumeDetectMs?: number;
+    /** Give up waiting for a fallback replay's `replay_end` after this many ms (default: 15000). */
+    legacyReplayTimeoutMs?: number;
+    /**
+     * How often to resume again after a RETRYABLE gap before giving up on the
+     * automatic retry (default: 5). The next reconnect resumes again anyway.
+     */
+    maxResumeRetries?: number;
+    /** Wait before an automatic re-resume when the server names none (default: 30000 ms). */
+    resumeRetryDelayMs?: number;
+    /**
+     * What to do when the server reports a gap that asking again can never fill
+     * (`retryable: false`).
+     *  - `"advance"` (default): report it on the `"gap"` event with
+     *    `advancedPastGap: true` and the skipped range, commit past it and keep
+     *    streaming. The skipped events are not delivered — backfill them from
+     *    REST if you need them.
+     *  - `"stop"`: do not move the cursor, stop the stream and emit `"fatal"`
+     *    with the gap, so YOU decide. `acceptGap()` then `connect()` continues.
+     */
+    onUnrecoverableGap?: "advance" | "stop";
 }
-type Listener = (data: unknown, evt?: StreamEvent) => void;
+type Listener = (data: unknown, evt?: StreamEvent) => unknown;
 export declare class MadeOnSolStream {
     private opts;
     private ws;
     private listeners;
     private desired;
+    /** Named subscriptions (Phase 2), in creation order; the default one is `desired`. */
+    private named;
+    /** sub_ids of the subscribes sent on this connection whose `subscribed` ack is still due (acks arrive in order). */
+    private ackExpect;
+    private namedUnsupportedWarned;
+    private listWaiters;
     private closedByUser;
+    private stopped;
     private attempt;
+    private authFailures;
     private hbTimer;
     private reconnectTimer;
     private connecting;
+    /** Server process id of the CURRENT connection (from connected/subscribed). */
+    private serverInstance;
+    /** Whether this connection already sent its first subscribe (the only one that resumes). */
+    private firstSubscribeSent;
+    /** COMMITTED (safe) cursor — the one to persist and resume from. */
+    private cursor;
+    /** Received progress — every handled frame, including replayed ones. */
+    private progress;
+    /** true after an incomplete recovery: live frames are not committed until one completes. */
+    private unsafe;
+    private seen;
+    private inflight;
+    private recovery;
+    /** Automatic re-resume after a retryable gap. */
+    private retryTimer;
+    private resumeRetries;
+    /** The last gap reported (for acceptGap()'s report). */
+    private lastGap;
     constructor(opts: StreamClientOptions);
-    /** Register a handler. Use an event name, `"*"` for every event, or a lifecycle event. */
+    /** Register a handler. Use an event name, `"*"` for every event, or a lifecycle event.
+     *  An event handler may return a promise: the cursor only advances past a frame once
+     *  every handler for it (and for every earlier frame) has settled. */
+    on(event: "warning", fn: (warning: StreamWarning) => unknown): this;
+    on(event: "cursor", fn: (cursor: StreamCursor) => unknown): this;
+    on(event: "replay", fn: (result: StreamReplayResult) => unknown): this;
+    on(event: "gap", fn: (gap: StreamGap) => unknown): this;
+    on(event: "fatal", fn: (fatal: StreamFatal) => unknown): this;
     on(event: StreamEventName | StreamLifecycleEvent | "*", fn: Listener): this;
     /** Remove a handler (or all handlers for an event when `fn` is omitted). */
-    off(event: string, fn?: Listener): this;
+    off(event: string, fn?: (...args: never[]) => unknown): this;
+    /** The COMMITTED resume cursor (last safe point) — persist this one. Null before the first. */
+    getCursor(): StreamCursor | null;
+    /** Received progress: the last handled frame, replayed ones included (NOT safe to resume from). */
+    getProgress(): StreamCursor | null;
+    /** true while an incomplete recovery holds the committed cursor back. */
+    isRecoveryIncomplete(): boolean;
+    /**
+     * Accept the last reported gap: commit the received progress as the cursor
+     * and let live frames commit again. Call it after you backfilled the range
+     * the `"gap"` event named (or decided you do not need it). It re-reports the
+     * gap first, with `source: "manual"` and the range being skipped.
+     */
+    acceptGap(): void;
     private emit;
-    /** Subscribe to one or more channels (connects on first call). Optional server-side filters. */
+    /** Call every handler for a data frame; collect what they returned (for completion tracking). */
+    private callHandlers;
+    /**
+     * Subscribe to one or more channels (connects on first call). Optional
+     * server-side filters. `subscribe(channels, filters)` is the connection's
+     * default subscription; `subscribe({ subId, channels, filters })` opens (or
+     * extends) a NAMED subscription with its own channels and filters, whose
+     * frames carry `evt.sub_id` (see StreamSubscription).
+     */
     subscribe(channels: StreamChannel[], filters?: Record<string, unknown>): this;
-    /** Stop receiving the given channels. */
+    subscribe(opts: StreamSubscribeOptions): this;
+    /**
+     * Replace the filters of a subscription (`"default"` for the plain one).
+     * The server acks with an `updated` frame; a refused update (for example a
+     * `token:prices` subscription without valid `mints`) arrives as a `warning`
+     * with code `invalid_filters` and the previous filters stay.
+     */
+    updateSubscription(subId: string, filters: Record<string, unknown>): this;
+    /**
+     * `unsubscribe(channels)` stops those channels on the default subscription;
+     * `unsubscribe(subId)` removes a whole named subscription.
+     */
     unsubscribe(channels: StreamChannel[]): this;
-    /** Open the connection (also called implicitly by subscribe). */
+    unsubscribe(subId: string): this;
+    /** Every subscription this client asks for (local view, no round trip). */
+    getSubscriptions(): StreamSubscription[];
+    /**
+     * Ask the server what this connection holds (`list` → `subscriptions`).
+     * Resolves with the local view when not connected or when the server does
+     * not answer within `timeoutMs`.
+     */
+    listSubscriptions(timeoutMs?: number): Promise<StreamSubscription[]>;
+    /**
+     * A pre-Phase-2 server (ignores sub_id) answers every resume with ONE
+     * replay for the whole connection, reported without sub_id: only "default"
+     * can still be awaited. Finishes the recovery at once when that one has
+     * already ended.
+     */
+    private collapsePending;
+    /** A subscription removed while its replay was still awaited: stop waiting for it. */
+    private forgetPending;
+    /** Open the connection (also called implicitly by subscribe). Restarts a stream that went `"fatal"`. */
     connect(): Promise<void>;
     /** Close the connection and stop reconnecting. */
     close(): void;
+    private handleClose;
+    /** `onUnrecoverableGap: "stop"`: stop the stream and hand the decision to the caller. */
+    private haltForGap;
+    private fatal;
+    /** The subscribe frames for the given subscriptions (default first, then named in creation order). */
+    private subscribeFrames;
+    /**
+     * Send the subscribe(s). On a connection's FIRST subscribe (or an explicit
+     * retry after a retryable gap) every subscription is sent with the SAME
+     * resume cursor: the server serves one replay per subscription, one after
+     * another, and holds live frames until the last replay_end. A later
+     * subscribe adds channels live (no resume).
+     */
     private sendSubscribe;
+    /**
+     * The server did not answer `resume` (older deployment): retry with the
+     * legacy fields. Such a server has no named subscriptions either, so the
+     * one legacy replay covers the union of channels and resolves every pending
+     * subscription at once.
+     */
+    private fallbackToLegacy;
+    private dropRecovery;
+    /**
+     * A retryable gap: ask the server again on this connection after its
+     * retry_after_ms (row_cap resumes from resume_ts_hint). Bounded — the next
+     * reconnect resumes anyway.
+     */
+    private scheduleResumeRetry;
+    /**
+     * One `replay_end` per subscription → one aggregate the single-replay logic
+     * can run on unchanged: complete only when every subscription is; the
+     * commit position is the SMALLEST last_seq / last_ts across them (a later
+     * subscription's replay covered more, but the earlier one's live frames
+     * from that point on are still only in the live flush); channel entries
+     * keyed `"<sub_id>/<channel>"` for named subscriptions; `retryable` when
+     * any subscription says so.
+     */
+    private aggregateEnds;
+    private finishRecovery;
     private handleMessage;
+    /** Dedupe by id, hand the frame to the handlers, track completion for the cursor. */
+    private deliver;
+    private drainInflight;
+    /** Queue a position behind every frame still being handled (or apply it now). */
+    private enqueue;
+    /** Move `progress` (always) and the committed cursor (when `commit`) to `pos`. */
+    private apply;
     private scheduleReconnect;
     private resetHeartbeat;
     private clearHeartbeat;

package/dist/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,qCAAqC;AACrC,MAAM,MAAM,aAAa,GACrB,YAAY,GACZ,kBAAkB,GAClB,mBAAmB,GACnB,iBAAiB,GACjB,uBAAuB,GACvB,mBAAmB,GACnB,oBAAoB,GACpB,gBAAgB,GAChB,mBAAmB,GACnB,aAAa,GACb,kBAAkB,GAClB,cAAc,CAAC;AAEnB,uFAAuF;AACvF,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,kBAAkB,GAClB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,sBAAsB,GACtB,kBAAkB,GAClB,iBAAiB,GACjB,sBAAsB,GACtB,eAAe,GACf,kBAAkB,GAClB,YAAY,GACZ,iBAAiB,GACjB,aAAa,GACb,eAAe,CAAC;AAEpB,gDAAgD;AAChD,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,OAAO,GACP,WAAW,GACX,YAAY,GACZ,WAAW,GACX,OAAO,CAAC;AAEZ,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO;IACtC,OAAO,EAAE,aAAa,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,CAAC,CAAC;IACR,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,mBAAmB;IAClC;0FACsF;IACtF,QAAQ,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAC;IACrC,uDAAuD;IACvD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oDAAoD;IACpD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,2EAA2E;IAC3E,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,KAAK,QAAQ,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;AAsC3D,qBAAa,eAAe;IAC1B,OAAO,CAAC,IAAI,CAAoG;IAChH,OAAO,CAAC,EAAE,CAA8B;IACxC,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,OAAO,CAAkF;IACjG,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAA8C;IAC7D,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,UAAU,CAAS;gBAEf,IAAI,EAAE,mBAAmB;IAUrC,0FAA0F;IAC1F,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,oBAAoB,GAAG,GAAG,EAAE,EAAE,EAAE,QAAQ,GAAG,IAAI;IAM3E,4EAA4E;IAC5E,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,QAAQ,GAAG,IAAI;IAMvC,OAAO,CAAC,IAAI;IAKZ,gGAAgG;IAChG,SAAS,CAAC,QAAQ,EAAE,aAAa,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAQ7E,yCAAyC;IACzC,WAAW,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,IAAI;IAQ5C,iEAAiE;IAC3D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAmC9B,kDAAkD;IAClD,KAAK,IAAI,IAAI;IAeb,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,aAAa;IAmBrB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,cAAc;CAGvB"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"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"}