livekit-client 2.22.3 → 2.23.0

package/dist/ts4.2/room/attribute-typings.d.ts

@@ -1,35 +1,35 @@
-export interface AgentAttributes {
-    'lk.agent.inputs'?: AgentInput[];
-    'lk.agent.outputs'?: AgentOutput[];
-    'lk.agent.state'?: AgentState;
-    'lk.publish_on_behalf'?: string;
-    [property: string]: any;
-}
-export type AgentInput = 'audio' | 'video' | 'text';
-export type AgentOutput = 'transcription' | 'audio';
-export type AgentState = 'idle' | 'initializing' | 'listening' | 'thinking' | 'speaking';
-/**
- * Schema for transcription-related attributes
- */
-export interface TranscriptionAttributes {
-    /**
-     * The segment id of the transcription
-     */
-    'lk.segment_id'?: string;
-    /**
-     * The associated track id of the transcription
-     */
-    'lk.transcribed_track_id'?: string;
-    /**
-     * Whether the transcription is final
-     */
-    'lk.transcription_final'?: boolean;
-    [property: string]: any;
-}
-export declare class Convert {
-    static toAgentAttributes(json: string): AgentAttributes;
-    static agentAttributesToJson(value: AgentAttributes): string;
-    static toTranscriptionAttributes(json: string): TranscriptionAttributes;
-    static transcriptionAttributesToJson(value: TranscriptionAttributes): string;
-}
-//# sourceMappingURL=attribute-typings.d.ts.map
+export interface AgentAttributes {
+    'lk.agent.inputs'?: AgentInput[];
+    'lk.agent.outputs'?: AgentOutput[];
+    'lk.agent.state'?: AgentState;
+    'lk.publish_on_behalf'?: string;
+    [property: string]: any;
+}
+export type AgentInput = 'audio' | 'video' | 'text';
+export type AgentOutput = 'transcription' | 'audio';
+export type AgentState = 'idle' | 'initializing' | 'listening' | 'thinking' | 'speaking';
+/**
+ * Schema for transcription-related attributes
+ */
+export interface TranscriptionAttributes {
+    /**
+     * The segment id of the transcription
+     */
+    'lk.segment_id'?: string;
+    /**
+     * The associated track id of the transcription
+     */
+    'lk.transcribed_track_id'?: string;
+    /**
+     * Whether the transcription is final
+     */
+    'lk.transcription_final'?: boolean;
+    [property: string]: any;
+}
+export declare class Convert {
+    static toAgentAttributes(json: string): AgentAttributes;
+    static agentAttributesToJson(value: AgentAttributes): string;
+    static toTranscriptionAttributes(json: string): TranscriptionAttributes;
+    static transcriptionAttributesToJson(value: TranscriptionAttributes): string;
+}
+//# sourceMappingURL=attribute-typings.d.ts.map

package/dist/ts4.2/room/data-channel/DataChannelManager.d.ts

@@ -1,62 +1,63 @@
-import type { PCTransportManager } from '../PCTransportManager';
-import { FlowControlledDataChannel } from './FlowControlledDataChannel';
-import { LossyDataChannel } from './LossyDataChannel';
-import { ReliableDataChannel } from './ReliableDataChannel';
-import { DataChannelKind } from './types';
-export interface DataChannelManagerOptions {
-    /** Whether the owning engine has been closed — a closed engine rejects headroom waiters. */
-    isEngineClosed: () => boolean;
-    /**
-     * Whether a reconnect attempt is underway: reliable sends defer to the resume replay and lossy
-     * sends are skipped while this is true.
-     */
-    isReconnecting: () => boolean;
-    onDataMessage: (message: MessageEvent) => void;
-    onDataTrackMessage: (message: MessageEvent) => void;
-    onDataError: (event: Event) => void;
-    onChannelClose: (kind: DataChannelKind) => void;
-    /** A channel's buffer crossed its low-water mark (debounced). Drives DCBufferStatusChanged. */
-    onBufferStatusChanged: (kind: DataChannelKind, isLow: boolean) => void;
-}
-/**
- * Owns the engine's data channels: the three flow-controlled publisher channel wrappers (which
- * live for the engine's lifetime and have RTCDataChannel handles attached/detached as peer
- * connections come and go) plus the subscriber-side receive handles adopted by label.
- *
- * Handle turnover goes through {@link FlowControlledDataChannel.attach}/`detach`, which reject
- * parked headroom waiters as a built-in — there is no separate invalidation step to forget.
- */
-export declare class DataChannelManager {
-    readonly reliable: ReliableDataChannel;
-    readonly lossy: LossyDataChannel;
-    readonly dataTrack: LossyDataChannel;
-    private reliableSub?;
-    private lossySub?;
-    private dataTrackSub?;
-    private opts;
-    constructor(opts: DataChannelManagerOptions);
-    /** The flow-control wrapper for `kind`. */
-    channelFor(kind: DataChannelKind): FlowControlledDataChannel;
-    /** The raw RTCDataChannel handle for `kind`, publisher side by default. */
-    getHandle(kind: DataChannelKind, subscriber?: boolean): RTCDataChannel | undefined;
-    get hasPublisherChannels(): boolean;
-    /**
-     * Creates the three publisher data channels on the given transport, wires their handlers, and
-     * attaches them to the wrappers — attaching rejects any waiters still parked on replaced
-     * channel objects.
-     */
-    createPublisherChannels(pcManager: PCTransportManager): void;
-    /**
-     * Adopts a subscriber-side data channel by label, wiring the matching receive handler.
-     * Returns false for labels this manager doesn't own.
-     */
-    adoptSubscriberChannel(channel: RTCDataChannel): boolean;
-    /**
-     * Tears down all channels for a peer-connection cleanup: rejects parked waiters (detach — the
-     * spec allows `pc.close()` to transition channels to 'closed' without firing events, so waiting
-     * for browser close events is not an option), strips handlers, closes the handles, and resets
-     * the reliable session state.
-     */
-    teardown(): void;
-}
-//# sourceMappingURL=DataChannelManager.d.ts.map
+import type { PCTransportManager } from '../PCTransportManager';
+import { FlowControlledDataChannel } from './FlowControlledDataChannel';
+import { LossyDataChannel } from './LossyDataChannel';
+import { ReliableDataChannel } from './ReliableDataChannel';
+import { DataChannelKind } from './types';
+export interface DataChannelManagerOptions {
+    /** Whether the owning engine has been closed — a closed engine rejects headroom waiters. */
+    isEngineClosed: () => boolean;
+    /**
+     * Whether a reconnect attempt is underway: reliable sends defer to the resume replay and lossy
+     * sends are skipped while this is true.
+     */
+    isReconnecting: () => boolean;
+    onDataMessage: (message: MessageEvent) => void;
+    onDataTrackMessage: (message: MessageEvent) => void;
+    onDataError: (event: Event) => void;
+    onChannelClose: (kind: DataChannelKind) => void;
+    /** A channel's buffer crossed its low-water mark (debounced). Drives DCBufferStatusChanged. */
+    onBufferStatusChanged: (kind: DataChannelKind, isLow: boolean) => void;
+}
+/**
+ * Owns the engine's data channels: the three flow-controlled publisher channel wrappers (which
+ * live for the engine's lifetime and have RTCDataChannel handles attached/detached as peer
+ * connections come and go) plus the subscriber-side receive handles adopted by label.
+ *
+ * Handle turnover goes through {@link FlowControlledDataChannel.attach}/`detach`, which close the
+ * released handle and reject parked headroom waiters as a built-in — there is no separate
+ * invalidation step to forget.
+ */
+export declare class DataChannelManager {
+    readonly reliable: ReliableDataChannel;
+    readonly lossy: LossyDataChannel;
+    readonly dataTrack: LossyDataChannel;
+    private reliableSub?;
+    private lossySub?;
+    private dataTrackSub?;
+    private opts;
+    constructor(opts: DataChannelManagerOptions);
+    /** The flow-control wrapper for `kind`. */
+    channelFor(kind: DataChannelKind): FlowControlledDataChannel;
+    /** The raw RTCDataChannel handle for `kind`, publisher side by default. */
+    getHandle(kind: DataChannelKind, subscriber?: boolean): RTCDataChannel | undefined;
+    get hasPublisherChannels(): boolean;
+    /**
+     * Creates the three publisher data channels on the given transport, wires their handlers, and
+     * attaches them to the wrappers — attaching closes any replaced channel objects and rejects the
+     * waiters still parked on them.
+     */
+    createPublisherChannels(pcManager: PCTransportManager): void;
+    /**
+     * Adopts a subscriber-side data channel by label, wiring the matching receive handler.
+     * Returns false for labels this manager doesn't own.
+     */
+    adoptSubscriberChannel(channel: RTCDataChannel): boolean;
+    /**
+     * Tears down all channels for a peer-connection cleanup: strips handlers, closes the handles,
+     * and resets the reliable session state. Detaching the publisher handles closes them and
+     * rejects parked waiters (the spec allows `pc.close()` to transition channels to 'closed'
+     * without firing events, so waiting for browser close events is not an option).
+     */
+    teardown(): void;
+}
+//# sourceMappingURL=DataChannelManager.d.ts.map

package/dist/ts4.2/room/data-channel/FlowControlledDataChannel.d.ts

@@ -1,95 +1,107 @@
-import type { DataChannelKind } from './types';
-export interface FlowControlledDataChannelOptions {
-    kind: DataChannelKind;
-    /** Buffer level (bytes) at which blocked senders resume; armed as `bufferedAmountLowThreshold`. */
-    lowWaterMark: number;
-    /** Buffer level (bytes) above which senders block until the buffer drains to the low mark. */
-    highWaterMark: number;
-    /** Whether the owning engine has been closed — a closed engine rejects waiters immediately. */
-    isEngineClosed: () => boolean;
-    /**
-     * Notified when the buffer crosses the low-water mark in either direction (debounced: fires only
-     * on an actual change). Drives the engine's public DCBufferStatusChanged event.
-     */
-    onBufferStatusChanged?: (isLow: boolean) => void;
-}
-/**
- * Two-watermark flow control for one data channel kind.
- *
- * Owns the per-kind headroom gate: senders proceed freely while the buffer is at or below the
- * high-water mark and otherwise block — serialized FIFO through a mutex — until the browser's
- * `bufferedamountlow` event (armed at the low-water mark) signals the buffer has drained. The
- * serialization prevents woken senders from all refilling at once and overflowing the SCTP send
- * buffer (see livekit/client-sdk-js#1995).
- *
- * Waiters are parked on the channel object captured at wait entry. If that object stops being
- * current — replaced or torn down — its events may never fire again, so the owner must call
- * {@link invalidateWaiters}, which aborts parked waiters (releasing the gate); the next waiter
- * gets a fresh controller.
- */
-export declare class FlowControlledDataChannel {
-    readonly kind: DataChannelKind;
-    readonly lowWaterMark: number;
-    readonly highWaterMark: number;
-    protected isEngineClosed: () => boolean;
-    private onBufferStatusChanged?;
-    /** Last emitted low-water status; starts true (an empty buffer is below the mark). */
-    private bufferStatusLow;
-    private handle?;
-    private headroomLock;
-    /** Cancels parked headroom waiters when the handle is replaced or torn down. */
-    private waiterAbortController;
-    constructor(opts: FlowControlledDataChannelOptions);
-    /** The currently attached RTCDataChannel handle, if any. */
-    get channelHandle(): RTCDataChannel | undefined;
-    /**
-     * Attaches the channel handle this wrapper controls. Replacing an existing handle rejects
-     * parked waiters — their events would never fire again on the abandoned object — and installs a
-     * fresh controller, so queued senders re-check against the new channel. Wrappers outlive their
-     * handles: this is the one place handle turnover happens, which is what makes stranding a
-     * waiter structurally impossible.
-     */
-    attach(dc: RTCDataChannel): void;
-    /** Detaches the handle on teardown, rejecting parked waiters. */
-    detach(reason?: string): void;
-    protected getChannel(): RTCDataChannel | undefined;
-    /**
-     * Whether the send buffer has room to accept more data (the send gate). Senders proceed while
-     * this is true and block once it goes false. Callers resolve the handle (and decide what an
-     * absent one means) before asking.
-     */
-    isBelowHighWaterMark(dc: RTCDataChannel): boolean;
-    /**
-     * Whether the send buffer has drained to its low-water mark. Drives the engine's public
-     * DCBufferStatusChanged event.
-     */
-    isBelowLowWaterMark(dc: RTCDataChannel): boolean;
-    /**
-     * Acquires the headroom lock, resolving with the unlock function. Batch senders (the resume
-     * replay) hold it across all of their sends so no other sender can interleave, calling
-     * {@link waitForHeadroomWithoutLock} per message to respect flow control within the batch.
-     */
-    lockHeadroom(): Promise<() => void>;
-    /**
-     * Resolves once the caller may send on this channel: immediately while the send buffer is at or
-     * below its high-water mark, otherwise once the buffer has drained to the low-water mark (the
-     * `bufferedamountlow` event). Callers are serialized through the headroom lock so that, when
-     * the buffer drains, they refill it one at a time (up to the high-water mark) rather than all
-     * sending at once and overflowing the SCTP send buffer (see livekit/client-sdk-js#1995). The
-     * closed/buffer checks run inside the lock so queued callers proceed in FIFO order.
-     */
-    waitForHeadroomWithLock(): Promise<void>;
-    /** Core wait of {@link waitForHeadroomWithLock}. The caller must hold the headroom lock. */
-    waitForHeadroomWithoutLock(): Promise<void>;
-    /** Rejects all parked headroom waiters; the next waiter gets a fresh controller. */
-    invalidateWaiters(reason: string): void;
-    /**
-     * Recomputes whether the buffer has drained to the low-water mark and, if that changed since the
-     * last check, notifies the status listener. Two independent triggers land here: a send (which
-     * raises the buffer) and the `bufferedamountlow` drain event (which lowers it) — the latter has
-     * no send to hang the work off, which is why this is a shared entry point rather than a tail of
-     * `send`.
-     */
-    refreshBufferStatus(): void;
-}
-//# sourceMappingURL=FlowControlledDataChannel.d.ts.map
+import type { DataChannelKind } from './types';
+export interface FlowControlledDataChannelOptions {
+    kind: DataChannelKind;
+    /** Buffer level (bytes) at which blocked senders resume; armed as `bufferedAmountLowThreshold`. */
+    lowWaterMark: number;
+    /** Buffer level (bytes) above which senders block until the buffer drains to the low mark. */
+    highWaterMark: number;
+    /** Whether the owning engine has been closed — a closed engine rejects waiters immediately. */
+    isEngineClosed: () => boolean;
+    /**
+     * Notified when the buffer crosses the low-water mark in either direction (debounced: fires only
+     * on an actual change). Drives the engine's public DCBufferStatusChanged event.
+     */
+    onBufferStatusChanged?: (isLow: boolean) => void;
+}
+/**
+ * Two-watermark flow control for one data channel kind.
+ *
+ * Owns the per-kind headroom gate: senders proceed freely while the buffer is at or below the
+ * high-water mark and otherwise block — serialized FIFO through a mutex — until the browser's
+ * `bufferedamountlow` event (armed at the low-water mark) signals the buffer has drained. The
+ * serialization prevents woken senders from all refilling at once and overflowing the SCTP send
+ * buffer (see livekit/client-sdk-js#1995).
+ *
+ * Waiters are parked on the channel object captured at wait entry. If that object stops being
+ * current — replaced or torn down — its events may never fire again, so the owner must call
+ * {@link invalidateWaiters}, which aborts parked waiters (releasing the gate); the next waiter
+ * gets a fresh controller. {@link attach} and {@link detach} do this, and close the released
+ * handle, as part of handle turnover.
+ */
+export declare class FlowControlledDataChannel {
+    readonly kind: DataChannelKind;
+    readonly lowWaterMark: number;
+    readonly highWaterMark: number;
+    protected isEngineClosed: () => boolean;
+    private onBufferStatusChanged?;
+    /** Last emitted low-water status; starts true (an empty buffer is below the mark). */
+    private bufferStatusLow;
+    private handle?;
+    private headroomLock;
+    /** Cancels parked headroom waiters when the handle is replaced or torn down. */
+    private waiterAbortController;
+    constructor(opts: FlowControlledDataChannelOptions);
+    get channelHandle(): (RTCDataChannel | undefined);
+    /**
+     * Attaches the channel handle this wrapper controls. Replacing an existing handle closes it and
+     * rejects parked waiters — their events would never fire again on the abandoned object — and
+     * installs a fresh controller. Wrappers outlive their handles: this is the one place handle
+     * turnover happens, so a handle the wrapper lets go of is never left open, and stranding a
+     * waiter is structurally impossible.
+     */
+    attach(dc: RTCDataChannel): void;
+    /** Detaches and closes the handle on teardown, rejecting parked waiters. */
+    detach(reason?: string): void;
+    /**
+     * Closes a handle the wrapper no longer controls. `close()` moves it to `closing` synchronously,
+     * so senders still holding it (queued on the headroom lock) fail the open check once they get
+     * the lock. Parked waiters are aborted directly instead of relying on the `close` event, which
+     * fires asynchronously, if at all (the spec lets `pc.close()` skip it). Strip any handlers that
+     * must not observe the close before calling this.
+     */
+    private release;
+    protected getChannel(): RTCDataChannel | undefined;
+    /**
+     * Whether the send buffer has room to accept more data (the send gate). Senders proceed while
+     * this is true and block once it goes false. Callers resolve the handle (and decide what an
+     * absent one means) before asking.
+     */
+    isBelowHighWaterMark(dc: RTCDataChannel): boolean;
+    /**
+     * Whether the send buffer has drained to its low-water mark. Drives the engine's public
+     * DCBufferStatusChanged event.
+     */
+    isBelowLowWaterMark(dc: RTCDataChannel): boolean;
+    /**
+     * Acquires the headroom lock, resolving with the unlock function. Batch senders (the resume
+     * replay) hold it across all of their sends so no other sender can interleave, calling
+     * {@link waitForHeadroomWithoutLock} per message to respect flow control within the batch.
+     */
+    lockHeadroom(): Promise<() => void>;
+    /**
+     * Resolves once the caller may send on `dc`: immediately while its send buffer is at or below
+     * the high-water mark, otherwise once the buffer has drained to the low-water mark (the
+     * `bufferedamountlow` event). Callers are serialized through the headroom lock so that, when
+     * the buffer drains, they refill it one at a time (up to the high-water mark) rather than all
+     * sending at once and overflowing the SCTP send buffer (see livekit/client-sdk-js#1995). The
+     * checks run inside the lock so queued callers proceed in FIFO order.
+     *
+     * The caller passes the handle it resolved before queueing, and the wait is against that one
+     * handle throughout: if it was replaced meanwhile, it has been closed, so the wait rejects
+     * rather than letting the caller send on the replacement out of turn.
+     */
+    waitForHeadroomWithLock(dc: RTCDataChannel): Promise<void>;
+    /** Core wait of {@link waitForHeadroomWithLock}. The caller must hold the headroom lock. */
+    waitForHeadroomWithoutLock(dc: RTCDataChannel): Promise<void>;
+    /** Rejects all parked headroom waiters; the next waiter gets a fresh controller. */
+    invalidateWaiters(reason: string): void;
+    /**
+     * Recomputes whether the buffer has drained to the low-water mark and, if that changed since the
+     * last check, notifies the status listener. Two independent triggers land here: a send (which
+     * raises the buffer) and the `bufferedamountlow` drain event (which lowers it) — the latter has
+     * no send to hang the work off, which is why this is a shared entry point rather than a tail of
+     * `send`.
+     */
+    refreshBufferStatus(): void;
+}
+//# sourceMappingURL=FlowControlledDataChannel.d.ts.map

package/dist/ts4.2/room/data-channel/LossyDataChannel.d.ts

@@ -1,41 +1,41 @@
-import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
-import type { FlowControlledDataChannelOptions } from './FlowControlledDataChannel';
-import { FlowControlledDataChannel } from './FlowControlledDataChannel';
-export interface LossyDataChannelOptions extends FlowControlledDataChannelOptions {
-    /**
-     * What to do with a send while the buffer is full: `drop` discards it to keep latency bounded
-     * (the classic lossy channel), `wait` backpressures the producer until there is headroom (the
-     * data-track channel, whose producer decides what to skip at frame granularity).
-     */
-    bufferFullBehavior: 'drop' | 'wait';
-    /** Sends are silently discarded while this is true (a reconnect attempt is underway). */
-    shouldSkipSends: () => boolean;
-}
-/**
- * A lossy channel: flow control plus a per-instance full-buffer policy.
- *
- * Each instance owns its own byterate stat, drop counter, and (when tuning is started) the
- * dynamic `bufferedAmountLowThreshold` adjustment that keeps the drop gate at roughly 100ms of
- * buffered latency. Keeping these per instance is what prevents one channel's traffic from
- * steering another channel's policy.
- */
-export declare class LossyDataChannel extends FlowControlledDataChannel {
-    private bufferFullBehavior;
-    private shouldSkipSends;
-    private statCurrentBytes;
-    private statByterate;
-    private statInterval;
-    private dropCount;
-    constructor(opts: LossyDataChannelOptions);
-    /** Sends prepared bytes with this channel's full-buffer policy (drop or wait). */
-    send(msg: NonSharedUint8Array): Promise<void>;
-    /**
-     * Starts the once-per-second adjustment of the channel's `bufferedAmountLowThreshold` to the
-     * observed byterate, keeping the drop gate at roughly 100ms of buffered latency (clamped to
-     * the watermarks). Restarts cleanly if already running.
-     */
-    startThresholdTuning(): void;
-    /** Stops the threshold tuning and resets the stats and drop counter. */
-    stopThresholdTuning(): void;
-}
-//# sourceMappingURL=LossyDataChannel.d.ts.map
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
+import type { FlowControlledDataChannelOptions } from './FlowControlledDataChannel';
+import { FlowControlledDataChannel } from './FlowControlledDataChannel';
+export interface LossyDataChannelOptions extends FlowControlledDataChannelOptions {
+    /**
+     * What to do with a send while the buffer is full: `drop` discards it to keep latency bounded
+     * (the classic lossy channel), `wait` backpressures the producer until there is headroom (the
+     * data-track channel, whose producer decides what to skip at frame granularity).
+     */
+    bufferFullBehavior: 'drop' | 'wait';
+    /** Sends are silently discarded while this is true (a reconnect attempt is underway). */
+    shouldSkipSends: () => boolean;
+}
+/**
+ * A lossy channel: flow control plus a per-instance full-buffer policy.
+ *
+ * Each instance owns its own byterate stat, drop counter, and (when tuning is started) the
+ * dynamic `bufferedAmountLowThreshold` adjustment that keeps the drop gate at roughly 100ms of
+ * buffered latency. Keeping these per instance is what prevents one channel's traffic from
+ * steering another channel's policy.
+ */
+export declare class LossyDataChannel extends FlowControlledDataChannel {
+    private bufferFullBehavior;
+    private shouldSkipSends;
+    private statCurrentBytes;
+    private statByterate;
+    private statInterval;
+    private dropCount;
+    constructor(opts: LossyDataChannelOptions);
+    /** Sends prepared bytes with this channel's full-buffer policy (drop or wait). */
+    send(msg: NonSharedUint8Array): Promise<void>;
+    /**
+     * Starts the once-per-second adjustment of the channel's `bufferedAmountLowThreshold` to the
+     * observed byterate, keeping the drop gate at roughly 100ms of buffered latency (clamped to
+     * the watermarks). Restarts cleanly if already running.
+     */
+    startThresholdTuning(): void;
+    /** Stops the threshold tuning and resets the stats and drop counter. */
+    stopThresholdTuning(): void;
+}
+//# sourceMappingURL=LossyDataChannel.d.ts.map

package/dist/ts4.2/room/data-channel/ReliableDataChannel.d.ts

@@ -1,57 +1,57 @@
-import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
-import type { FlowControlledDataChannelOptions } from './FlowControlledDataChannel';
-import { FlowControlledDataChannel } from './FlowControlledDataChannel';
-export interface ReliableDataChannelOptions extends FlowControlledDataChannelOptions {
-    /**
-     * Whether sends should currently be deferred to the resume replay instead of hitting the wire
-     * (i.e. a reconnect attempt is underway). Read at send time so the reliable channel matches the
-     * engine's reconnect state without owning it.
-     */
-    isDeferringSends: () => boolean;
-}
-/**
- * The reliable channel: flow control plus delivery-across-resume semantics.
- *
- * Every packet gets a monotonic sequence (stamped into the protobuf by the caller before
- * serialization, via {@link nextSequence}) and is retained in a replay buffer until the channel's
- * `bufferedAmount` confirms it has been handed to the transport. Sends that land in a reconnect
- * window — or whose headroom wait is torn down transiently — are queued unsent and resolve;
- * {@link replay} delivers them (plus any unacked packets) after a resume. Only an engine close
- * rejects, because no replay is coming after that.
- */
-export declare class ReliableDataChannel extends FlowControlledDataChannel {
-    private messageBuffer;
-    private sequence;
-    private isDeferringSends;
-    constructor(opts: ReliableDataChannelOptions);
-    /**
-     * Claims the next packet sequence. The caller stamps it into the packet before serialization,
-     * then passes it back to {@link send} so the replay buffer stays keyed by wire sequence.
-     */
-    nextSequence(): number;
-    /**
-     * Sends prepared bytes with reliable semantics. Resolves once the packet has either been handed
-     * to the channel or queued for the resume replay; throws only when the engine is closed.
-     */
-    send(msg: NonSharedUint8Array, sequence: number): Promise<void>;
-    /**
-     * Replays the buffered backlog after a resume: drops everything the server acked
-     * (`lastMessageSeq`), then re-sends the rest in order. The headroom lock is held across the
-     * whole replay — releasing it between messages would let a concurrent send (whose newer
-     * sequence was already assigned before it queued on the lock) hit the wire mid-replay, and
-     * receivers would then discard the remaining lower-sequence resent messages as duplicates.
-     */
-    replay(lastMessageSeq: number): Promise<void>;
-    /**
-     * Before recomputing status, trim packets the transport has now delivered — a send or a drain
-     * may have acked buffered packets, and the replay buffer is keyed off the channel's buffered
-     * bytes.
-     */
-    refreshBufferStatus(): void;
-    /**
-     * Drops all replay state and restarts sequencing. Only valid on a full reconnect, where the
-     * session (and the receivers' sequence tracking) starts over.
-     */
-    reset(): void;
-}
-//# sourceMappingURL=ReliableDataChannel.d.ts.map
+import type { NonSharedUint8Array } from '../../type-polyfills/non-shared-typed-arrays';
+import type { FlowControlledDataChannelOptions } from './FlowControlledDataChannel';
+import { FlowControlledDataChannel } from './FlowControlledDataChannel';
+export interface ReliableDataChannelOptions extends FlowControlledDataChannelOptions {
+    /**
+     * Whether sends should currently be deferred to the resume replay instead of hitting the wire
+     * (i.e. a reconnect attempt is underway). Read at send time so the reliable channel matches the
+     * engine's reconnect state without owning it.
+     */
+    isDeferringSends: () => boolean;
+}
+/**
+ * The reliable channel: flow control plus delivery-across-resume semantics.
+ *
+ * Every packet gets a monotonic sequence (stamped into the protobuf by the caller before
+ * serialization, via {@link nextSequence}) and is retained in a replay buffer until the channel's
+ * `bufferedAmount` confirms it has been handed to the transport. Sends that land in a reconnect
+ * window — or whose headroom wait is torn down transiently — are queued unsent and resolve;
+ * {@link replay} delivers them (plus any unacked packets) after a resume. Only an engine close
+ * rejects, because no replay is coming after that.
+ */
+export declare class ReliableDataChannel extends FlowControlledDataChannel {
+    private messageBuffer;
+    private sequence;
+    private isDeferringSends;
+    constructor(opts: ReliableDataChannelOptions);
+    /**
+     * Claims the next packet sequence. The caller stamps it into the packet before serialization,
+     * then passes it back to {@link send} so the replay buffer stays keyed by wire sequence.
+     */
+    nextSequence(): number;
+    /**
+     * Sends prepared bytes with reliable semantics. Resolves once the packet has either been handed
+     * to the channel or queued for the resume replay; throws only when the engine is closed.
+     */
+    send(msg: NonSharedUint8Array, sequence: number): Promise<void>;
+    /**
+     * Replays the buffered backlog after a resume: drops everything the server acked
+     * (`lastMessageSeq`), then re-sends the rest in order. The headroom lock is held across the
+     * whole replay — releasing it between messages would let a concurrent send (whose newer
+     * sequence was already assigned before it queued on the lock) hit the wire mid-replay, and
+     * receivers would then discard the remaining lower-sequence resent messages as duplicates.
+     */
+    replay(lastMessageSeq: number): Promise<void>;
+    /**
+     * Before recomputing status, trim packets the transport has now delivered — a send or a drain
+     * may have acked buffered packets, and the replay buffer is keyed off the channel's buffered
+     * bytes.
+     */
+    refreshBufferStatus(): void;
+    /**
+     * Drops all replay state and restarts sequencing. Only valid on a full reconnect, where the
+     * session (and the receivers' sequence tracking) starts over.
+     */
+    reset(): void;
+}
+//# sourceMappingURL=ReliableDataChannel.d.ts.map