@mcpwarp/ws-mixer 0.6.0

package/dist/conn.d.ts

@@ -0,0 +1,328 @@
+/**
+ * MixerConn: the per-connection ws-mixer.v1 protocol engine. Owns the
+ * handshake, the read-dispatch loop, the control-priority + round-robin
+ * write scheduler (WIRE.md section 2.6 rule 3), keepalive and drain.
+ * The JS SDK is always the answering peer (client): it never calls
+ * OpenStream, only receives OPEN from the server.
+ *
+ * Mirrors `go/wsmixer/conn.go`, `dispatch.go`, `sched.go`, `keepalive.go` and
+ * `drain.go`, adapted to Node's single-threaded event loop (no goroutines:
+ * one write scheduler driven by a wake/notify queue instead of channels).
+ */
+import { EventEmitter } from "node:events";
+import { type AgentInfo, type ControlMessage, type DrainMsg, type WelcomeMsg } from "./control.js";
+import { WsMixerError } from "./errors.js";
+import { MixerStream } from "./stream.js";
+/** Structural subset of `ws`'s WebSocket that MixerConn depends on (keeps the transport swappable). */
+export interface WSLike {
+    readonly readyState: number;
+    send(data: Uint8Array, cb?: (err?: Error) => void): void;
+    close(code?: number, reason?: string): void;
+    terminate?(): void;
+    on(event: "message", listener: (data: Uint8Array | Buffer, isBinary: boolean) => void): void;
+    on(event: "close", listener: (code: number, reason: Buffer) => void): void;
+    on(event: "error", listener: (err: Error) => void): void;
+}
+export interface ConnOptions {
+    token: string;
+    agent: AgentInfo;
+    meta?: unknown;
+    window?: number;
+    maxStreams?: number;
+    capabilities?: string[];
+    /** Timeout waiting for `welcome` after sending `hello`. Default 10000ms per WIRE.md section 2.9. */
+    helloTimeoutMs?: number;
+}
+/**
+ * Fires (and clears) once for every welcome/close event; used for the
+ * `welcome`-then-timeout handshake race and to unblock `close()`'s grace wait.
+ */
+export declare interface MixerConn {
+    on(event: "welcome", listener: (welcome: WelcomeMsg) => void): this;
+    on(event: "stream", listener: (stream: MixerStream) => void): this;
+    on(event: "app", listener: (body: Record<string, unknown>) => void): this;
+    on(event: "drain", listener: (msg: DrainMsg) => void): this;
+    on(event: "pong", listener: (info: {
+        id: number;
+        rttMs: number;
+    }) => void): this;
+    on(event: "error", listener: (err: WsMixerError) => void): this;
+    on(event: "fatal", listener: (err: WsMixerError) => void): this;
+    on(event: "close", listener: (info: {
+        wsCode: number;
+        errorCode?: number;
+        message: string;
+        closeReason?: string;
+    }) => void): this;
+    /** Fires when a `'stream'`/`'app'`/`'drain'` listener throws or rejects; delivery continues with the next queued event regardless (see stats().handlerErrors). */
+    on(event: "handlerError", listener: (info: {
+        event: string;
+        error: Error;
+    }) => void): this;
+}
+/** One live, handshaken (or handshaking) ws-mixer connection. */
+export declare class MixerConn extends EventEmitter {
+    #private;
+    private readonly ws;
+    private readonly opts;
+    private closed;
+    private handshakeDone;
+    session: string;
+    peerWindow: number;
+    ourWindow: number;
+    maxStreams: number;
+    pingIntervalMs: number;
+    pingTimeoutMs: number;
+    welcomeMeta: unknown;
+    private draining;
+    /** The `last_stream_id` from the most recently received `drain`; set only once draining. */
+    private lastStreamId?;
+    private readonly streams;
+    private highestOpened;
+    /**
+     * Minimal "ignore and count" counters (item 11 of the review: full
+     * escalation/STREAM_LIMIT bucketing is intentionally out of scope for v1 --
+     * see README.md and docs/DESIGN.md). Exposed via `stats()`.
+     */
+    private readonly counters;
+    /** Snapshot of the counters above. */
+    stats(): Readonly<typeof this.counters>;
+    private readonly controlQueue;
+    private readonly rotation;
+    private readonly inRotation;
+    private readonly outbox;
+    private wakeWaiters;
+    private writerRunning;
+    /** Resolved once the stream table is empty; used by close() instead of polling. */
+    private idleWaiters;
+    private readonly deliveryQueue;
+    private deliveryRunning;
+    private readonly stream0Bucket;
+    private nextPingId;
+    /** Watermark: every id below this has been acked (or pruned as stale) at least once. Mirrors go/wsmixer's Conn.lowestUnacked. */
+    private lowestUnacked;
+    private lastPongAt;
+    private readonly outstandingPings;
+    private pingTimer;
+    private watchdogTimer;
+    private handshakeTimer;
+    private jitterTimer;
+    /**
+     * The most recent pre-welcome `'error'` event's message, recorded so
+     * `onSocketClose`'s report -- the sole reporter, see its own doc comment
+     * -- can use it as `message` when `ws`'s own close carries no reason of
+     * its own.
+     */
+    private pendingHandshakeErrorMessage;
+    constructor(ws: WSLike, opts: ConnOptions);
+    /** Sends `hello` and resolves once `welcome` is validated, or rejects (a WsMixerError, `fatal` set for UNSUPPORTED). */
+    handshake(): Promise<WelcomeMsg>;
+    private applyWelcome;
+    private onMessage;
+    private handleDispatchError;
+    private dispatchFrame;
+    private dispatchControl;
+    /**
+     * Queues one `'stream'`/`'app'`/`'drain'` event for in-order, async
+     * delivery, mirroring go/wsmixer's deliveryLoop: the read/dispatch path
+     * above never blocks on application code, but all three still fire in
+     * wire order, off a single loop, one at a time. Handlers registered via
+     * `on('stream'|'app'|'drain', ...)` must not block for long -- a handler
+     * that never returns/resolves permanently wedges this loop, exactly like
+     * the Go side. Throws ConnError(ENHANCE_YOUR_CALM) if the bounded queue
+     * (`max(128, max_streams + 64)`) is full, which the caller (dispatchFrame/
+     * dispatchControl, inside onMessage's try/catch) turns into fail().
+     *
+     * Refuses once `this.closed` (CLIENT-SDK.md's "Handler delivery" row):
+     * `dispatchFrame`/`dispatchControl` -- the only callers -- always run
+     * before whatever ends the connection sets `this.closed` (every
+     * fail()/close()/handlePeerError path runs teardownConn synchronously,
+     * `error` is always the last message on the wire), so nothing legitimate
+     * should ever reach here once closed; this is the defensive backstop that
+     * makes runDeliveryLoop's post-close drain below provably bounded and
+     * terminating regardless.
+     */
+    private enqueueDelivery;
+    /**
+     * Drains `deliveryQueue` until empty -- deliberately NOT gated on
+     * `!this.closed` (CLIENT-SDK.md's "Handler delivery" row): an event
+     * already queued when the connection ends is still owed to its handler
+     * (`error` is the last message on the wire, so a stream OPEN/`app`/`drain`
+     * queued ahead of it arrived before the connection ended), so this loop
+     * finishes flushing that backlog even after `teardownConn` has already set
+     * `this.closed` and emitted `'close'` -- a handler MAY therefore run
+     * shortly after `MixerClient.close()`/`MixerConn.close()`'s own promise has
+     * already resolved (see those methods' doc comments and README). `if
+     * (!ev) break` is what actually ends the loop; since `enqueueDelivery`
+     * above refuses once closed, the queue can only shrink from here, so this
+     * always terminates.
+     */
+    private runDeliveryLoop;
+    /**
+     * Invokes every listener for `event` in registration order, awaiting each
+     * one's return value before starting the next -- unlike EventEmitter's own
+     * synchronous `emit`, which fires listeners back to back without waiting
+     * for a returned Promise to settle.
+     *
+     * A listener that throws synchronously or returns a rejected promise is
+     * caught here, counted (stats().handlerErrors) and surfaced via a guarded
+     * `'handlerError'` emit -- never an unhandled rejection, and never fatal
+     * to delivery: the next queued stream/app/drain event still runs.
+     */
+    private emitOrdered;
+    /**
+     * Queues one control-channel frame and returns a promise that resolves
+     * once `ws.send`'s callback confirms it was actually written (or rejects
+     * with the connection's terminal error if the conn fails first) --
+     * mirroring how `sendData()`'s per-stream outbox already works.
+     */
+    private enqueueControl;
+    /**
+     * Sends a control message (hello/ping/pong/drain/app/error) as stream-0
+     * DATA, queued ahead of any DATA. Resolves once the frame is actually
+     * written to the socket.
+     */
+    sendControl(msg: ControlMessage): Promise<void>;
+    /**
+     * Sends a control message at the head of the control queue, ahead of
+     * anything already queued (item 6: "A pong MUST ... jump ahead of queued
+     * DATA" -- and ahead of other queued control frames too).
+     */
+    private sendControlPriority;
+    /** Backs `streamHost.sendControlFrame`: send a control-priority frame (WINDOW/CLOSE/RESET) immediately. */
+    private sendControlFrame;
+    /** Backs `streamHost.sendData`: enqueue a DATA chunk for round-robin transmission. */
+    private sendData;
+    /** Backs `streamHost.retireStream`: retire a fully-closed stream's id. */
+    private retireStream;
+    /** Resolves every pending close()'s wait for the stream table to empty, instead of polling. */
+    private notifyIdle;
+    private waitForEmpty;
+    private markReady;
+    private wake;
+    private waitForWork;
+    private nextChunk;
+    private startWriter;
+    private runWriter;
+    /**
+     * Writes one frame and resolves once `ws.send`'s callback reports it
+     * flushed. This is how rule 2 (§2.6, "gate the write loop on the socket
+     * send buffer") is satisfied without polling `bufferedAmount` on a timer:
+     * `ws`'s `send(data, cb)` callback fires only once the chunk has actually
+     * been handed to the socket, so awaiting it before writing the next frame
+     * already keeps exactly one write in flight and applies backpressure for
+     * free (runWriter's loop awaits writeRaw() before picking the next chunk).
+     */
+    private writeRaw;
+    /** Resolves once the `app` frame is actually written to the socket, or rejects with the connection's terminal error if it fails first. */
+    sendApp(body: Record<string, unknown>): Promise<void>;
+    private startKeepalive;
+    private sendPing;
+    /**
+     * Pong watermark scheme, mirroring go/wsmixer/dispatch.go's handlePong:
+     * every id below lowestUnacked has been acked (or pruned as stale) at
+     * least once, and no id >= nextPingId has ever been sent.
+     *  - id >= nextPingId: never sent -> PROTOCOL_ERROR, connection-fatal.
+     *  - id < lowestUnacked, or in-range but already absent from the map
+     *    (already acked, or pruned by the watchdog as stale/late): a
+     *    duplicate or late pong -- tolerated, just counted.
+     */
+    private handlePong;
+    private checkWatchdog;
+    /**
+     * Shared teardown: WS close `4000 + code`, reject everything outstanding,
+     * emit `'fatal'`/`'error'` (guarded) then `'close'`, synchronously and in
+     * that order every time. `sendErrorFrame` controls whether an
+     * `error{code,message}` control frame is sent first -- true for a
+     * locally-detected failure (fail()), false when the peer already sent its
+     * own `error` and WIRE.md section 2.7 forbids replying with another
+     * one (handlePeerError()). Either way `this.closed` is set *before*
+     * `ws.close()` is called, so the peer's echo of this close (or any close
+     * frame it happens to send around the same time) is ignored by
+     * onSocketClose below rather than reported as `closeReason` -- per
+     * CLIENT-SDK.md's `closeReason` row, an outgoing reason this side sent is
+     * never legitimate `closeReason` data, and there is nothing to gain by
+     * waiting for the peer's own close frame here: WIRE.md section 2.7
+     * already allows closing on `error` "without reading the close frame that
+     * followed".
+     */
+    private teardownConn;
+    /**
+     * Connection-fatal failure path: error{code,message} on stream 0, WS close
+     * 4000+code, teardown. Three steps, in order (WIRE.md section 2.8).
+     *
+     * `streamErrorFactory`, when given, overrides the error every live stream
+     * is torn down with (`err` is still used for the connection-level frame/
+     * close/rejects) -- used by MixerClient when it fails a *superseded*
+     * (drained) conn: the streams on it aren't erroring, the conn they were
+     * riding on is being replaced, so each gets a stream-scoped CANCEL
+     * ("connection drained") instead of the connection's own NO_ERROR.
+     *
+     * Synchronous, but any stream/app/drain event still queued for delivery at
+     * this point is not: runDeliveryLoop keeps flushing it after this returns
+     * (see close()'s doc comment above for why).
+     */
+    fail(err: WsMixerError, streamErrorFactory?: (streamId: number) => WsMixerError): void;
+    /**
+     * The peer sent `error{code,message}`: record it and close with
+     * `4000 + code` immediately, without waiting for the peer to do anything
+     * else -- mirrors go/wsmixer/dispatch.go's handlePeerError. `error` is
+     * always the last message on the wire (WIRE.md section 2.7), so
+     * there is nothing left to negotiate.
+     */
+    private handlePeerError;
+    /**
+     * Graceful client shutdown: drain{client_requested}, brief grace period,
+     * then close(NO_ERROR). This resolves once teardownConn's synchronous
+     * steps are done (frame/WS close/rejects/'close' emitted) -- it does NOT
+     * wait for runDeliveryLoop to finish flushing whatever stream/app/drain
+     * backlog was still queued at that point. A handler for an event received
+     * before this close MAY therefore still be invoked shortly after this
+     * promise (and 'close') has already resolved/fired (CLIENT-SDK.md's
+     * "Handler delivery" row).
+     */
+    close(graceMs?: number): Promise<void>;
+    /**
+     * A close frame this side actually *received* from `ws`'s 'close' event.
+     * `code`/`reason` here are always the peer's, per `ws`'s own contract
+     * (`receiverOnConclude` in `ws/lib/websocket.js` only ever updates
+     * `_closeCode`/`_closeMessage` from a frame it parsed off the wire, never
+     * from what this side sent via `.close()`) -- so whenever `this.closed` is
+     * already `true`, this is a close frame arriving after teardownConn()
+     * already ran and reported (never our own echoed close winning a race),
+     * and is correctly ignored rather than folded in after the fact.
+     *
+     * Pre-welcome, this is also the SOLE reporter for a transport failure
+     * before `welcome` -- measured against real `ws` (8.21): a TCP reset,
+     * half-close or peer close frame after the 101 delivers a bare 'close'
+     * with no 'error' at all, and a protocol-level failure `ws` itself
+     * detects (an invalid frame: 1002, an oversized message: 1009, ...)
+     * delivers 'error' immediately followed by 'close' a macrotask or more
+     * later -- 'close' is never racing 'error' for which one wins; it always
+     * arrives after it, if it arrives at all. `onSocketError` below therefore
+     * never finalizes anything itself, only records the error's message here
+     * for `message` to fall back on when the close carries no reason of its
+     * own -- so this always reports the *actual* close code `ws` delivers
+     * (1006, or whatever real close code it sent), never a wsCode fabricated
+     * for a close that never happened.
+     */
+    private onSocketClose;
+    /**
+     * Pre-welcome, `'error'` never arrives in the same microtask as (or after)
+     * a 'close' that never comes -- see onSocketClose's own doc comment for
+     * what real `ws` actually does. So this deliberately does NOT reject or
+     * finalize the handshake itself; it just records the error's message for
+     * onSocketClose (the sole reporter) to use as `message` when the close
+     * that follows carries no reason of its own. If `'close'` somehow never
+     * follows at all (a transport that violates `ws`'s own contract), nothing
+     * here is left waiting on it: `handshake()`'s own hello/welcome timeout
+     * (`handshakeTimer`, 10s default) still fires and produces the one report
+     * (`wsCode` 4001) regardless -- deliberately the only fallback for that
+     * case, not a second mechanism grafted on here.
+     */
+    private onSocketError;
+    private stopTimers;
+    private rejectOutstanding;
+    isDraining(): boolean;
+    liveStreamCount(): number;
+}

package/dist/control.d.ts

@@ -0,0 +1,74 @@
+export interface AgentInfo {
+    sdk: string;
+    sdk_version: string;
+    runtime?: string;
+    os?: string;
+}
+export interface ServerInfo {
+    name?: string;
+    version?: string;
+    node?: string;
+}
+export interface HelloMsg {
+    t: "hello";
+    v: number;
+    token: string;
+    agent: AgentInfo;
+    window?: number;
+    max_streams?: number;
+    capabilities?: string[];
+    meta?: unknown;
+}
+export interface WelcomeMsg {
+    t: "welcome";
+    v: number;
+    session: string;
+    window: number;
+    max_streams: number;
+    ping_interval: number;
+    ping_timeout: number;
+    server?: ServerInfo;
+    capabilities?: string[];
+    meta?: unknown;
+}
+export interface PingMsg {
+    t: "ping";
+    id: number;
+    ts?: number;
+}
+export interface PongMsg {
+    t: "pong";
+    id: number;
+    ts?: number;
+}
+export interface DrainMsg {
+    t: "drain";
+    reason: string;
+    last_stream_id: number;
+    deadline_ms?: number;
+    retry_after_ms?: number;
+    message?: string;
+}
+export interface ErrorMsg {
+    t: "error";
+    code: number;
+    message: string;
+    stream_id?: number;
+    last_stream_id?: number;
+}
+export interface AppMsg {
+    t: "app";
+    body: Record<string, unknown>;
+}
+export type ControlMessage = HelloMsg | WelcomeMsg | PingMsg | PongMsg | DrainMsg | ErrorMsg | AppMsg;
+/** Reports whether reason is one of the documented drain reasons. An unknown reason is tolerated at runtime. */
+export declare function knownDrainReason(reason: string): boolean;
+/**
+ * Validates and decodes one stream-0 DATA payload (already UTF-8 decoded to
+ * a string). Implements WIRE.md section 2.7's envelope table plus every
+ * message type's per-field checks. Every validation failure is a ConnError
+ * with PROTOCOL_ERROR (or ENHANCE_YOUR_CALM for the oversize case).
+ */
+export declare function parseControl(raw: string | Uint8Array): ControlMessage;
+/** Serializes a control message to its stream-0 DATA payload bytes. */
+export declare function encodeControl(msg: ControlMessage): Uint8Array;

package/dist/errors.d.ts

@@ -0,0 +1,96 @@
+/**
+ * ws-mixer.v1 error code table (WIRE.md section 2.8). Shared by stream
+ * RESET frames and the connection-level `error` control message.
+ *
+ * 0x0000_0000-0x0000_0fff is reserved for ws-mixer; codes >= 0x1000_0000 are
+ * free for the layer above and are never produced by this package. Unknown
+ * codes received on the wire are treated as INTERNAL_ERROR (see codeName).
+ */
+export declare const ErrorCode: {
+    readonly NO_ERROR: 0;
+    readonly PROTOCOL_ERROR: 1;
+    readonly INTERNAL_ERROR: 2;
+    readonly FLOW_CONTROL_ERROR: 3;
+    readonly FRAME_SIZE_ERROR: 4;
+    readonly STREAM_CLOSED: 5;
+    readonly REFUSED_STREAM: 6;
+    readonly CANCEL: 7;
+    readonly STREAM_LIMIT: 8;
+    readonly ENHANCE_YOUR_CALM: 9;
+    readonly UNSUPPORTED: 10;
+    readonly UNAUTHORIZED: 11;
+    readonly GOING_AWAY: 12;
+    readonly KEEPALIVE_TIMEOUT: 13;
+    readonly APPLICATION_CLOSE: 14;
+};
+export type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode];
+/** Renders an error code's wire name, e.g. "FLOW_CONTROL_ERROR". Unrecognized codes render "INTERNAL_ERROR". */
+export declare function codeName(code: number): string;
+/** Looks up an error code by its wire name (e.g. "STREAM_LIMIT"). Returns undefined if unknown. */
+export declare function parseErrorCode(name: string): number | undefined;
+/** ws_close = 4000 + error_code, with NO_ERROR mapping to 1000 (WIRE.md section 2.8). */
+export declare function closeCode(code: number): number;
+/**
+ * WsMixerError is the single error type this package throws or emits.
+ * `fatal` marks a close code the client SDK must never reconnect after
+ * (UNSUPPORTED always; UNAUTHORIZED once it's actually final -- after
+ * `welcome`, or before `welcome` once the one provider refresh-retry has
+ * already been spent (or immediately, with a static token that has nothing
+ * to refresh) -- see client.ts's connectOnce/dialAndHandshakeOnce; and the
+ * client's own auth/handshake failures).
+ */
+export declare class WsMixerError extends Error {
+    readonly code: number;
+    name: string;
+    readonly fatal: boolean;
+    readonly streamId?: number;
+    /**
+     * The peer's observed WS close-frame code, set only when this error was
+     * built from an actually-observed close frame (e.g. MixerConn.onSocketClose)
+     * rather than a locally-raised protocol violation.
+     */
+    readonly wsCode?: number;
+    /** The peer's observed WS close-frame reason, verbatim, under the same condition as `wsCode`. */
+    readonly closeReason?: string;
+    constructor(code: number, message: string, opts?: {
+        fatal?: boolean;
+        streamId?: number;
+        wsCode?: number;
+        closeReason?: string;
+    });
+    get codeName(): string;
+    toString(): string;
+}
+/** A connection-fatal error: desynchronizes shared connection state. Always error{code} + WS close. */
+export declare class ConnError extends WsMixerError {
+    readonly lastStreamId?: number;
+    constructor(code: number, message: string, opts?: {
+        streamId?: number;
+        lastStreamId?: number;
+        fatal?: boolean;
+    });
+}
+/** A stream-scoped error: produces RESET(code, message) on one stream; the connection stays up. */
+export declare class StreamError extends WsMixerError {
+    constructor(code: number, streamId: number, message: string);
+}
+/**
+ * A token provider's explicit signal that it could not OBTAIN a token for a
+ * temporary reason (a laptop waking before the network is back, the auth
+ * server briefly unreachable while refreshing an expired token) -- as
+ * opposed to a genuinely fatal provider failure (a malformed credential, a
+ * permanently revoked client). Throwing/rejecting with an instance of this
+ * (directly, or wrapped via `cause`) is how a provider opts a dial failure
+ * into client.ts's ordinary non-fatal dial-retry path instead of the
+ * fatal-by-default one every other provider throw/reject still gets --
+ * detection is `instanceof` only, deliberately not duck-typed on any
+ * property or method, so an accidental match on some unrelated library's
+ * error can never turn a genuinely fatal provider failure into an endless
+ * retry loop.
+ */
+export declare class TokenUnavailableError extends Error {
+    name: string;
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/frame.d.ts

@@ -0,0 +1,52 @@
+export declare const FrameType: {
+    readonly OPEN: 0;
+    readonly DATA: 1;
+    readonly WINDOW: 2;
+    readonly CLOSE: 3;
+    readonly RESET: 4;
+};
+export type FrameTypeValue = (typeof FrameType)[keyof typeof FrameType];
+/** Renders a frame type's wire name, or "UNKNOWN(0xNN)" outside the v1 set. */
+export declare function frameTypeName(t: number): string;
+/** Largest legal WebSocket message: 8-byte header plus a 64 KiB payload. */
+export declare const MAX_MESSAGE_SIZE: number;
+/** Control-channel (stream 0) message size cap. */
+export declare const MAX_STREAM_ZERO_PAYLOAD = 16384;
+/** Recommended DATA chunk size: a sender-side default, not a wire limit. */
+export declare const MAX_CHUNK = 16384;
+/** Largest legal cumulative send-credit window: 2^31-1 (WIRE.md section 2.6 decision 1). */
+export declare const MAX_SEND_WINDOW = 2147483647;
+/** One decoded ws-mixer mux frame: the 8-byte header plus its payload. */
+export interface Frame {
+    type: number;
+    flags: number;
+    streamId: number;
+    payload: Uint8Array;
+}
+/**
+ * Decodes one WebSocket message into a Frame per WIRE.md sections
+ * 2.2-2.4. Throws ConnError (connection-fatal) or StreamError (scoped to the
+ * frame's stream id).
+ */
+export declare function decodeFrame(msg: Uint8Array): Frame;
+/** Returns the 4-byte increment carried by a WINDOW frame. Caller must have checked f.type === FrameType.WINDOW. */
+export declare function windowIncrement(f: Frame): number;
+/** Returns the error code carried by a RESET frame. Caller must have checked f.type === FrameType.RESET. */
+export declare function resetCode(f: Frame): number;
+/**
+ * Returns the (UTF-8 sanitized) message carried by a RESET frame. Invalid
+ * UTF-8 is replaced with U+FFFD by TextDecoder, matching the wire spec's
+ * "replace chars, do not kill the connection" rule.
+ */
+export declare function resetMessage(f: Frame): string;
+/** Serializes a Frame to its wire form: 8-byte header followed by the payload. */
+export declare function encodeFrame(f: {
+    type: number;
+    streamId: number;
+    payload?: Uint8Array;
+}): Uint8Array;
+export declare function encodeOpen(streamId: number): Uint8Array;
+export declare function encodeData(streamId: number, payload: Uint8Array): Uint8Array;
+export declare function encodeWindow(streamId: number, increment: number): Uint8Array;
+export declare function encodeClose(streamId: number): Uint8Array;
+export declare function encodeReset(streamId: number, code: number, message?: string): Uint8Array;