livekit-client 2.22.2 → 2.22.4

package/dist/ts4.2/api/SignalClient.d.ts

@@ -1,185 +1,187 @@
-import { AddTrackRequest, AudioTrackFeature, ClientInfo_Capability, ConnectionQualityUpdate, DataTrackSubscriberHandles, JoinResponse, LeaveRequest, MediaSectionsRequirement, ParticipantInfo, PublishDataTrackResponse, ReconnectReason, ReconnectResponse, RequestResponse, Room, RoomMovedResponse, SessionDescription, SignalResponse, SignalTarget, SimulateScenario, SpeakerInfo, StreamStateUpdate, SubscribedQualityUpdate, SubscriptionPermissionUpdate, SubscriptionResponse, SyncState, TrackPermission, TrackPublishedResponse, TrackUnpublishedResponse, UnpublishDataTrackResponse, UpdateSubscription, UpdateTrackSettings, VideoLayer } from '@livekit/protocol';
-import type { DataTrackHandle } from '../room/data-track/handle';
-import type { DataTrackSid } from '../room/data-track/types';
-import type { LoggerOptions } from '../room/types';
-import { AsyncQueue } from '../utils/AsyncQueue';
-import { WebSocketStream } from './WebSocketStream';
-interface ConnectOpts extends SignalOptions {
-    /** internal */
-    reconnect?: boolean;
-    /** internal */
-    reconnectReason?: number;
-    /** internal */
-    sid?: string;
-}
-export interface SignalOptions {
-    autoSubscribe: boolean;
-    adaptiveStream?: boolean;
-    clientInfoCapabilities?: ClientInfo_Capability[];
-    maxRetries: number;
-    e2eeEnabled: boolean;
-    websocketTimeout: number;
-}
-export declare enum SignalConnectionState {
-    CONNECTING = 0,
-    CONNECTED = 1,
-    RECONNECTING = 2,
-    DISCONNECTING = 3,
-    DISCONNECTED = 4
-}
-/** @internal */
-export declare class SignalClient {
-    requestQueue: AsyncQueue;
-    queuedRequests: Array<() => Promise<void>>;
-    useJSON: boolean;
-    /** signal rtt in milliseconds */
-    rtt: number;
-    /** simulate signaling latency by delaying messages */
-    signalLatency?: number;
-    onClose?: (reason: string) => void;
-    onAnswer?: (sd: RTCSessionDescriptionInit, offerId: number, midToTrackId: {
-        [key: string]: string;
-    }) => void;
-    onOffer?: (sd: RTCSessionDescriptionInit, offerId: number, midToTrackId: {
-        [key: string]: string;
-    }) => void;
-    onTrickle?: (sd: RTCIceCandidateInit, target: SignalTarget) => void;
-    onParticipantUpdate?: (updates: ParticipantInfo[]) => void;
-    onLocalTrackPublished?: (res: TrackPublishedResponse) => void;
-    onNegotiateRequested?: () => void;
-    onSpeakersChanged?: (res: SpeakerInfo[]) => void;
-    onRemoteMuteChanged?: (trackSid: string, muted: boolean) => void;
-    onRoomUpdate?: (room: Room) => void;
-    onConnectionQuality?: (update: ConnectionQualityUpdate) => void;
-    onStreamStateUpdate?: (update: StreamStateUpdate) => void;
-    onSubscribedQualityUpdate?: (update: SubscribedQualityUpdate) => void;
-    onSubscriptionPermissionUpdate?: (update: SubscriptionPermissionUpdate) => void;
-    onSubscriptionError?: (update: SubscriptionResponse) => void;
-    onLocalTrackUnpublished?: (res: TrackUnpublishedResponse) => void;
-    onTokenRefresh?: (token: string) => void;
-    onLeave?: (leave: LeaveRequest) => void;
-    onRequestResponse?: (response: RequestResponse) => void;
-    onLocalTrackSubscribed?: (trackSid: string) => void;
-    onRoomMoved?: (res: RoomMovedResponse) => void;
-    onMediaSectionsRequirement?: (requirement: MediaSectionsRequirement) => void;
-    onPublishDataTrackResponse?: (event: PublishDataTrackResponse) => void;
-    onUnPublishDataTrackResponse?: (event: UnpublishDataTrackResponse) => void;
-    onDataTrackSubscriberHandles?: (event: DataTrackSubscriberHandles) => void;
-    onJoined?: (event: JoinResponse) => void;
-    connectOptions?: ConnectOpts;
-    ws?: WebSocketStream;
-    get currentState(): SignalConnectionState;
-    get isDisconnected(): boolean;
-    /** Runtime lifecycle state, finer grained than the public {@link currentState} projection. */
-    private get lifecycleState();
-    /** Id of the current connection attempt and of the transport it owns. */
-    private get attemptId();
-    /**
-     * Applies a lifecycle input and reports whether it moved the machine
-     */
-    private sendLifecycleInput;
-    /**
-     * Waits out a close that is already in flight. Establishing a session while one is tearing down
-     * would race it for the transport — the teardown can close the socket the new attempt just
-     * opened.
-     */
-    private settleInFlightClose;
-    private get isEstablishingConnection();
-    private getNextRequestId;
-    private options?;
-    private pingTimeout;
-    private pingTimeoutDuration;
-    private pingIntervalDuration;
-    private pingInterval;
-    private closingLock;
-    private machine;
-    private connectionLock;
-    private log;
-    private loggerContextCb?;
-    private _requestId;
-    private streamWriter;
-    private useV0SignalPath;
-    constructor(useJSON?: boolean, loggerOptions?: LoggerOptions);
-    private get logContext();
-    join(url: string, token: string, opts: SignalOptions, abortSignal?: AbortSignal, useV0Path?: boolean, publisherOffer?: SessionDescription): Promise<JoinResponse>;
-    reconnect(url: string, token: string, sid?: string, reason?: ReconnectReason): Promise<ReconnectResponse | undefined>;
-    private connect;
-    startReadingLoop(signalReader: ReadableStreamDefaultReader<string | ArrayBuffer>, firstMessage?: SignalResponse): Promise<void>;
-    /** @internal */
-    resetCallbacks: () => void;
-    close(updateState?: boolean, reason?: string): Promise<void>;
-    /**
-     * Releases the transport and everything tied to it, without touching the lifecycle state. Used
-     * both by {@link close} and by paths that replace the transport under a live lifecycle (a new
-     * attempt, or an unexpected close that leaves the client in `offline`).
-     */
-    private teardownTransport;
-    sendOffer(offer: RTCSessionDescriptionInit, offerId: number): void;
-    sendAnswer(answer: RTCSessionDescriptionInit, offerId: number): Promise<void>;
-    sendIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget): Promise<void>;
-    sendMuteTrack(trackSid: string, muted: boolean): Promise<void>;
-    sendAddTrack(req: AddTrackRequest): Promise<void>;
-    sendUpdateLocalMetadata(metadata: string, name: string, attributes?: Record<string, string>): Promise<number>;
-    sendUpdateTrackSettings(settings: UpdateTrackSettings): void;
-    sendUpdateSubscription(sub: UpdateSubscription): Promise<void>;
-    sendSyncState(sync: SyncState): Promise<void>;
-    sendUpdateVideoLayers(trackSid: string, layers: VideoLayer[]): Promise<void>;
-    sendUpdateSubscriptionPermissions(allParticipants: boolean, trackPermissions: TrackPermission[]): Promise<void>;
-    sendSimulateScenario(scenario: SimulateScenario): Promise<void>;
-    sendPing(): Promise<[
-        void,
-        void
-    ]>;
-    sendUpdateLocalAudioTrack(trackSid: string, features: AudioTrackFeature[]): Promise<void>;
-    sendLeave(): Promise<void>;
-    sendPublishDataTrackRequest(handle: DataTrackHandle, name: string, usesE2ee: boolean): Promise<void>;
-    sendUnPublishDataTrackRequest(handle: DataTrackHandle): Promise<void>;
-    sendUpdateDataSubscription(sid: DataTrackSid, subscribe: boolean): Promise<void>;
-    private sendRequest;
-    private handleSignalResponse;
-    setReconnected(): void;
-    /**
-     * Handles a transport we lost without asking to. The client goes to `offline` rather than
-     * `closed`: whether this session gets resumed, restarted or given up on is the engine's call.
-     */
-    private handleOnClose;
-    private handleWSError;
-    /**
-     * Resets the ping timeout and starts a new timeout.
-     * Call this after receiving a pong message
-     */
-    private resetPingTimeout;
-    /**
-     * Clears ping timeout (does not start a new timeout)
-     */
-    private clearPingTimeout;
-    private startPingInterval;
-    private clearPingInterval;
-    /**
-     * Handles the successful connection to the signal server
-     * @param connection The WebSocket connection
-     * @param timeoutHandle The timeout handle to clear
-     * @param firstMessage Optional first message to process
-     * @internal
-     */
-    private handleSignalConnected;
-    /**
-     * Validates the first message received from the signal server
-     * @param firstSignalResponse The first signal response received
-     * @param isReconnect Whether this is a reconnection attempt
-     * @returns Validation result with response or error
-     * @internal
-     */
-    private validateFirstMessage;
-    /**
-     * Handles WebSocket connection errors by validating with the server
-     * @param reason The error that occurred
-     * @param validateUrl The URL to validate the connection with
-     * @returns A ConnectionError with appropriate reason and status
-     * @internal
-     */
-    private handleConnectionError;
-}
-export declare function toProtoSessionDescription(rsd: RTCSessionDescription | RTCSessionDescriptionInit, id?: number): SessionDescription;
-export {};
-//# sourceMappingURL=SignalClient.d.ts.map
+import { AddTrackRequest, AudioTrackFeature, ClientInfo_Capability, ConnectionQualityUpdate, DataTrackSubscriberHandles, JoinResponse, LeaveRequest, MediaSectionsRequirement, ParticipantInfo, PublishDataTrackResponse, ReconnectReason, ReconnectResponse, RequestResponse, Room, RoomMovedResponse, SessionDescription, SignalTarget, SimulateScenario, SpeakerInfo, StreamStateUpdate, SubscribedQualityUpdate, SubscriptionPermissionUpdate, SubscriptionResponse, SyncState, TrackPermission, TrackPublishedResponse, TrackUnpublishedResponse, UnpublishDataTrackResponse, UpdateSubscription, UpdateTrackSettings, VideoLayer } from '@livekit/protocol';
+import type { DataTrackHandle } from '../room/data-track/handle';
+import type { DataTrackSid } from '../room/data-track/types';
+import type { LoggerOptions } from '../room/types';
+import { AsyncQueue } from '../utils/AsyncQueue';
+import { WebSocketStream } from './WebSocketStream';
+interface ConnectOpts extends SignalOptions {
+    /** internal */
+    reconnect?: boolean;
+    /** internal */
+    reconnectReason?: number;
+    /** internal */
+    sid?: string;
+}
+export interface SignalOptions {
+    autoSubscribe: boolean;
+    adaptiveStream?: boolean;
+    disableIceLite?: boolean;
+    subscriberAllowPause?: boolean;
+    clientInfoCapabilities?: ClientInfo_Capability[];
+    maxRetries: number;
+    e2eeEnabled: boolean;
+    websocketTimeout: number;
+}
+export declare enum SignalConnectionState {
+    CONNECTING = 0,
+    CONNECTED = 1,
+    RECONNECTING = 2,
+    DISCONNECTING = 3,
+    DISCONNECTED = 4
+}
+/** @internal */
+export declare class SignalClient {
+    requestQueue: AsyncQueue;
+    queuedRequests: Array<() => Promise<void>>;
+    useJSON: boolean;
+    /** signal rtt in milliseconds */
+    rtt: number;
+    /** simulate signaling latency by delaying messages */
+    signalLatency?: number;
+    onClose?: (reason: string) => void;
+    onAnswer?: (sd: RTCSessionDescriptionInit, offerId: number, midToTrackId: {
+        [key: string]: string;
+    }) => void;
+    onOffer?: (sd: RTCSessionDescriptionInit, offerId: number, midToTrackId: {
+        [key: string]: string;
+    }) => void;
+    onTrickle?: (sd: RTCIceCandidateInit, target: SignalTarget) => void;
+    onParticipantUpdate?: (updates: ParticipantInfo[]) => void;
+    onLocalTrackPublished?: (res: TrackPublishedResponse) => void;
+    onNegotiateRequested?: () => void;
+    onSpeakersChanged?: (res: SpeakerInfo[]) => void;
+    onRemoteMuteChanged?: (trackSid: string, muted: boolean) => void;
+    onRoomUpdate?: (room: Room) => void;
+    onConnectionQuality?: (update: ConnectionQualityUpdate) => void;
+    onStreamStateUpdate?: (update: StreamStateUpdate) => void;
+    onSubscribedQualityUpdate?: (update: SubscribedQualityUpdate) => void;
+    onSubscriptionPermissionUpdate?: (update: SubscriptionPermissionUpdate) => void;
+    onSubscriptionError?: (update: SubscriptionResponse) => void;
+    onLocalTrackUnpublished?: (res: TrackUnpublishedResponse) => void;
+    onTokenRefresh?: (token: string) => void;
+    onLeave?: (leave: LeaveRequest) => void;
+    onRequestResponse?: (response: RequestResponse) => void;
+    onLocalTrackSubscribed?: (trackSid: string) => void;
+    onRoomMoved?: (res: RoomMovedResponse) => void;
+    onMediaSectionsRequirement?: (requirement: MediaSectionsRequirement) => void;
+    onPublishDataTrackResponse?: (event: PublishDataTrackResponse) => void;
+    onUnPublishDataTrackResponse?: (event: UnpublishDataTrackResponse) => void;
+    onDataTrackSubscriberHandles?: (event: DataTrackSubscriberHandles) => void;
+    onJoined?: (event: JoinResponse) => void;
+    connectOptions?: ConnectOpts;
+    ws?: WebSocketStream;
+    get currentState(): SignalConnectionState;
+    get isDisconnected(): boolean;
+    /** Runtime lifecycle state, finer grained than the public {@link currentState} projection. */
+    private get lifecycleState();
+    /** Id of the current connection attempt and of the transport it owns. */
+    private get attemptId();
+    /**
+     * Applies a lifecycle input and reports whether it moved the machine
+     */
+    private sendLifecycleInput;
+    /**
+     * Waits out a close that is already in flight. Establishing a session while one is tearing down
+     * would race it for the transport — the teardown can close the socket the new attempt just
+     * opened.
+     */
+    private settleInFlightClose;
+    private get isEstablishingConnection();
+    private getNextRequestId;
+    private options?;
+    private pingTimeout;
+    private pingTimeoutDuration;
+    private pingIntervalDuration;
+    private pingInterval;
+    private closingLock;
+    private machine;
+    private connectionLock;
+    private log;
+    private loggerContextCb?;
+    private _requestId;
+    private streamWriter;
+    private useV0SignalPath;
+    constructor(useJSON?: boolean, loggerOptions?: LoggerOptions);
+    private get logContext();
+    join(url: string, token: string, opts: SignalOptions, abortSignal?: AbortSignal, useV0Path?: boolean, publisherOffer?: SessionDescription): Promise<JoinResponse>;
+    reconnect(url: string, token: string, sid?: string, reason?: ReconnectReason): Promise<ReconnectResponse | undefined>;
+    private connect;
+    startReadingLoop(signalReader: ReadableStreamDefaultReader<string | ArrayBuffer>): Promise<void>;
+    /** @internal */
+    resetCallbacks: () => void;
+    close(updateState?: boolean, reason?: string): Promise<void>;
+    /**
+     * Releases the transport and everything tied to it, without touching the lifecycle state. Used
+     * both by {@link close} and by paths that replace the transport under a live lifecycle (a new
+     * attempt, or an unexpected close that leaves the client in `offline`).
+     */
+    private teardownTransport;
+    sendOffer(offer: RTCSessionDescriptionInit, offerId: number): void;
+    sendAnswer(answer: RTCSessionDescriptionInit, offerId: number): Promise<void>;
+    sendIceCandidate(candidate: RTCIceCandidateInit, target: SignalTarget): Promise<void>;
+    sendMuteTrack(trackSid: string, muted: boolean): Promise<void>;
+    sendAddTrack(req: AddTrackRequest): Promise<void>;
+    sendUpdateLocalMetadata(metadata: string, name: string, attributes?: Record<string, string>): Promise<number>;
+    sendUpdateTrackSettings(settings: UpdateTrackSettings): void;
+    sendUpdateSubscription(sub: UpdateSubscription): Promise<void>;
+    sendSyncState(sync: SyncState): Promise<void>;
+    sendUpdateVideoLayers(trackSid: string, layers: VideoLayer[]): Promise<void>;
+    sendUpdateSubscriptionPermissions(allParticipants: boolean, trackPermissions: TrackPermission[]): Promise<void>;
+    sendSimulateScenario(scenario: SimulateScenario): Promise<void>;
+    sendPing(): Promise<[
+        void,
+        void
+    ]>;
+    sendUpdateLocalAudioTrack(trackSid: string, features: AudioTrackFeature[]): Promise<void>;
+    sendLeave(): Promise<void>;
+    sendPublishDataTrackRequest(handle: DataTrackHandle, name: string, usesE2ee: boolean): Promise<void>;
+    sendUnPublishDataTrackRequest(handle: DataTrackHandle): Promise<void>;
+    sendUpdateDataSubscription(sid: DataTrackSid, subscribe: boolean): Promise<void>;
+    private sendRequest;
+    private handleSignalResponse;
+    setReconnected(): void;
+    /**
+     * Handles a transport we lost without asking to. The client goes to `offline` rather than
+     * `closed`: whether this session gets resumed, restarted or given up on is the engine's call.
+     */
+    private handleOnClose;
+    private handleWSError;
+    /**
+     * Resets the ping timeout and starts a new timeout.
+     * Call this after receiving a pong message
+     */
+    private resetPingTimeout;
+    /**
+     * Clears ping timeout (does not start a new timeout)
+     */
+    private clearPingTimeout;
+    private startPingInterval;
+    private clearPingInterval;
+    /**
+     * Handles the successful connection to the signal server
+     * @param connection The WebSocket connection
+     * @param timeoutHandle The timeout handle to clear
+     * @param firstMessage Optional first message to process
+     * @internal
+     */
+    private handleSignalConnected;
+    /**
+     * Validates the first message received from the signal server
+     * @param firstSignalResponse The first signal response received
+     * @param isReconnect Whether this is a reconnection attempt
+     * @returns Validation result with response or error
+     * @internal
+     */
+    private validateFirstMessage;
+    /**
+     * Handles WebSocket connection errors by validating with the server
+     * @param reason The error that occurred
+     * @param validateUrl The URL to validate the connection with
+     * @returns A ConnectionError with appropriate reason and status
+     * @internal
+     */
+    private handleConnectionError;
+}
+export declare function toProtoSessionDescription(rsd: RTCSessionDescription | RTCSessionDescriptionInit, id?: number): SessionDescription;
+export {};
+//# sourceMappingURL=SignalClient.d.ts.map

package/dist/ts4.2/api/SignalClientStateMachine.d.ts

@@ -1,85 +1,85 @@
-/**
- * Runtime lifecycle states of the signal connection.
- *
- * `offline` is the resting state after the transport was lost without an explicit close: no
- * attempt is in flight, but a resume is still legal. It is what makes retrying a failed resume
- * expressible — `closed` is only reached by an explicit close or by a terminal attempt failure.
- */
-export type SignalLifecycleState = 'new' | 'connecting' | 'connected' | 'offline' | 'reconnecting' | 'disconnecting' | 'closed';
-export interface SignalMachineContext {
-    /** Monotonic id of the current (re)connection attempt and of the transport it owns */
-    attemptId: number;
-    /** Error or reason that ended the last attempt, kept for diagnostics. */
-    lastError?: unknown;
-    /** Reason passed to the last close request. */
-    closeReason?: string;
-}
-export type SignalMachineInput = 
-/**
- * Start an initial session, or restart from scratch (full reconnect).
- *
- * Establishing is legal exactly where no transport and no attempt are in play: `new`, `offline`
- * and `closed`. `closed` is included because it means "no transport", not "session over" — a
- * deliberate close and an unexpected loss leave the session equally resumable, and the engine
- * recovers from both. Establishing over a live session, or over an attempt already in flight, is
- * a caller error; `disconnecting` is waited out rather than refused.
- */
-{
-    type: 'connect';
-}
-/**
- * Resume the existing session: legal wherever establishing is, minus `new` (nothing to resume
- * yet), plus `connected` — the peer connection can be severed while signalling stays up.
- */
- | {
-    type: 'reconnect';
-}
-/**
- * An attempt established its transport. Carries the attempt it belongs to: an attempt that a
- * newer one has already superseded must not declare the session live.
- */
- | {
-    type: 'connectComplete';
-    attemptId: number;
-} | {
-    type: 'connectFailed';
-    error?: unknown;
-} | {
-    type: 'reconnectComplete';
-    attemptId: number;
-}
-/**
- * A resume attempt ended. `recoverable` distinguishes "another resume may follow" (→ `offline`)
- * from a terminal outcome such as a server leave or an expired token (→ `closed`).
- */
- | {
-    type: 'reconnectFailed';
-    error?: unknown;
-    recoverable: boolean;
-}
-/** The transport identified by `attemptId` was lost (unexpected ws close, ping timeout). */
- | {
-    type: 'transportFailed';
-    attemptId: number;
-    reason: string;
-} | {
-    type: 'close';
-    reason: string;
-} | {
-    type: 'closeComplete';
-};
-/**
- * Lifecycle model of the signal connection.
- *
- * The machine deliberately does not own connection attempts: `SignalClient` performs the
- * asynchronous work and reports the outcome. It also does not decide *whether* to reconnect —
- * that policy (backoff, resume vs. full reconnect, region failover, giving up) belongs to
- * `RTCEngine`, so transport loss lands in `offline` rather than starting a reconnect on its own.
- *
- * Each client gets its own instance: the context is mutable and per-connection.
- */
-export declare function createSignalMachine(initialState?: SignalLifecycleState): import("machina").Fsm<SignalMachineContext, "new" | "connecting" | "connected" | "offline" | "reconnecting" | "disconnecting" | "closed", "connect" | "reconnect" | "connectComplete" | "connectFailed" | "reconnectComplete" | "reconnectFailed" | "transportFailed" | "close" | "closeComplete", never>;
-export type SignalMachine = ReturnType<typeof createSignalMachine>;
-/** All lifecycle states, derived from the machine itself so the two cannot drift. */
-export declare const signalLifecycleStates: Array<SignalLifecycleState>;
-//# sourceMappingURL=SignalClientStateMachine.d.ts.map
+/**
+ * Runtime lifecycle states of the signal connection.
+ *
+ * `offline` is the resting state after the transport was lost without an explicit close: no
+ * attempt is in flight, but a resume is still legal. It is what makes retrying a failed resume
+ * expressible — `closed` is only reached by an explicit close or by a terminal attempt failure.
+ */
+export type SignalLifecycleState = 'new' | 'connecting' | 'connected' | 'offline' | 'reconnecting' | 'disconnecting' | 'closed';
+export interface SignalMachineContext {
+    /** Monotonic id of the current (re)connection attempt and of the transport it owns */
+    attemptId: number;
+    /** Error or reason that ended the last attempt, kept for diagnostics. */
+    lastError?: unknown;
+    /** Reason passed to the last close request. */
+    closeReason?: string;
+}
+export type SignalMachineInput = 
+/**
+ * Start an initial session, or restart from scratch (full reconnect).
+ *
+ * Establishing is legal exactly where no transport and no attempt are in play: `new`, `offline`
+ * and `closed`. `closed` is included because it means "no transport", not "session over" — a
+ * deliberate close and an unexpected loss leave the session equally resumable, and the engine
+ * recovers from both. Establishing over a live session, or over an attempt already in flight, is
+ * a caller error; `disconnecting` is waited out rather than refused.
+ */
+{
+    type: 'connect';
+}
+/**
+ * Resume the existing session: legal wherever establishing is, minus `new` (nothing to resume
+ * yet), plus `connected` — the peer connection can be severed while signalling stays up.
+ */
+ | {
+    type: 'reconnect';
+}
+/**
+ * An attempt established its transport. Carries the attempt it belongs to: an attempt that a
+ * newer one has already superseded must not declare the session live.
+ */
+ | {
+    type: 'connectComplete';
+    attemptId: number;
+} | {
+    type: 'connectFailed';
+    error?: unknown;
+} | {
+    type: 'reconnectComplete';
+    attemptId: number;
+}
+/**
+ * A resume attempt ended. `recoverable` distinguishes "another resume may follow" (→ `offline`)
+ * from a terminal outcome such as a server leave or an expired token (→ `closed`).
+ */
+ | {
+    type: 'reconnectFailed';
+    error?: unknown;
+    recoverable: boolean;
+}
+/** The transport identified by `attemptId` was lost (unexpected ws close, ping timeout). */
+ | {
+    type: 'transportFailed';
+    attemptId: number;
+    reason: string;
+} | {
+    type: 'close';
+    reason: string;
+} | {
+    type: 'closeComplete';
+};
+/**
+ * Lifecycle model of the signal connection.
+ *
+ * The machine deliberately does not own connection attempts: `SignalClient` performs the
+ * asynchronous work and reports the outcome. It also does not decide *whether* to reconnect —
+ * that policy (backoff, resume vs. full reconnect, region failover, giving up) belongs to
+ * `RTCEngine`, so transport loss lands in `offline` rather than starting a reconnect on its own.
+ *
+ * Each client gets its own instance: the context is mutable and per-connection.
+ */
+export declare function createSignalMachine(initialState?: SignalLifecycleState): import("machina").Fsm<SignalMachineContext, "new" | "connecting" | "connected" | "offline" | "reconnecting" | "disconnecting" | "closed", "connect" | "reconnect" | "connectComplete" | "connectFailed" | "reconnectComplete" | "reconnectFailed" | "transportFailed" | "close" | "closeComplete", never>;
+export type SignalMachine = ReturnType<typeof createSignalMachine>;
+/** All lifecycle states, derived from the machine itself so the two cannot drift. */
+export declare const signalLifecycleStates: Array<SignalLifecycleState>;
+//# sourceMappingURL=SignalClientStateMachine.d.ts.map

package/dist/ts4.2/api/WebSocketStream.d.ts

@@ -1,33 +1,33 @@
-import { ConnectionError } from '../room/errors';
-import TypedPromise from '../utils/TypedPromise';
-export interface WebSocketConnection<T extends ArrayBuffer | string = ArrayBuffer | string> {
-    readable: ReadableStream<T>;
-    writable: WritableStream<T>;
-    protocol: string;
-    extensions: string;
-}
-export interface WebSocketCloseInfo {
-    closeCode?: number;
-    reason?: string;
-}
-export interface WebSocketStreamOptions {
-    protocols?: string[];
-    signal?: AbortSignal;
-}
-type WebsocketError = ReturnType<typeof ConnectionError.websocket>;
-/**
- * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
- *
- * @see https://web.dev/websocketstream/
- */
-export declare class WebSocketStream<T extends ArrayBuffer | string = ArrayBuffer | string> {
-    readonly url: string;
-    readonly opened: TypedPromise<WebSocketConnection<T>, WebsocketError>;
-    readonly closed: TypedPromise<WebSocketCloseInfo, WebsocketError>;
-    readonly close: (closeInfo?: WebSocketCloseInfo) => void;
-    get readyState(): number;
-    private ws;
-    constructor(url: string, options?: WebSocketStreamOptions);
-}
-export {};
-//# sourceMappingURL=WebSocketStream.d.ts.map
+import { ConnectionError } from '../room/errors';
+import TypedPromise from '../utils/TypedPromise';
+export interface WebSocketConnection<T extends ArrayBuffer | string = ArrayBuffer | string> {
+    readable: ReadableStream<T>;
+    writable: WritableStream<T>;
+    protocol: string;
+    extensions: string;
+}
+export interface WebSocketCloseInfo {
+    closeCode?: number;
+    reason?: string;
+}
+export interface WebSocketStreamOptions {
+    protocols?: string[];
+    signal?: AbortSignal;
+}
+type WebsocketError = ReturnType<typeof ConnectionError.websocket>;
+/**
+ * [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) with [Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API)
+ *
+ * @see https://web.dev/websocketstream/
+ */
+export declare class WebSocketStream<T extends ArrayBuffer | string = ArrayBuffer | string> {
+    readonly url: string;
+    readonly opened: TypedPromise<WebSocketConnection<T>, WebsocketError>;
+    readonly closed: TypedPromise<WebSocketCloseInfo, WebsocketError>;
+    readonly close: (closeInfo?: WebSocketCloseInfo) => void;
+    get readyState(): number;
+    private ws;
+    constructor(url: string, options?: WebSocketStreamOptions);
+}
+export {};
+//# sourceMappingURL=WebSocketStream.d.ts.map