livekit-client 2.22.0 → 2.22.1

package/dist/src/utils/machineInspector.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Opt-in registry that lets a development tool observe the state machines driving the connection
+ * layer.
+ *
+ * The machines are private to the objects that own them and, more importantly, do not outlive them:
+ * a full reconnect replaces the whole engine along with its `SignalClient`, so anything watching a
+ * single machine reference goes blind exactly when the interesting part starts. Machines therefore
+ * announce themselves here as they are constructed, and a subscriber sees the whole succession.
+ *
+ * Nothing is recorded until {@link enableMachineInspector} is called, which no shipping code does —
+ * with the registry off, announcing is a comparison and a return.
+ */
+/**
+ * The slice of machina's `Fsm` surface an inspector needs. Structural rather than machina's own
+ * type so that any machine satisfies it regardless of its state and input unions.
+ */
+export interface InspectableMachine {
+    readonly id: string;
+    readonly initialState: string;
+    readonly states: Record<string, Record<string, unknown>>;
+    readonly context?: unknown;
+    currentState(): string;
+    canHandle(input: string): boolean;
+    on(eventName: string, callback: (data: any) => void): {
+        off(): void;
+    };
+}
+export interface MachineAnnouncement {
+    /** What the machine drives, e.g. `signal`. Not unique: each new `SignalClient` announces one. */
+    label: string;
+    /** How many machines have been announced before this one, so successive instances are tellable apart. */
+    seq: number;
+    /**
+     * When the machine was constructed. Carried on the announcement because subscribers receive the
+     * recorded ones on subscribe, and stamping those at replay time would date them all to whenever
+     * the tool happened to open.
+     */
+    at: number;
+    machine: InspectableMachine;
+}
+/**
+ * Starts recording machine announcements. Call before the machines of interest are constructed —
+ * for the signal machine that means before the `Room` is created.
+ */
+export declare function enableMachineInspector(): void;
+export declare function isMachineInspectorEnabled(): boolean;
+/** Announces a machine to whatever is watching. A no-op unless the inspector was enabled. */
+export declare function announceMachine(label: string, machine: InspectableMachine): void;
+/**
+ * Subscribes to machine announcements, replaying the ones already recorded so that a panel opened
+ * after connecting still sees the machine currently in charge. Returns an unsubscribe function.
+ */
+export declare function onMachineAnnounced(callback: (announcement: MachineAnnouncement) => void): () => void;
+//# sourceMappingURL=machineInspector.d.ts.map

package/dist/src/utils/machineInspector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machineInspector.d.ts","sourceRoot":"","sources":["../../../src/utils/machineInspector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,IAAI,MAAM,CAAC;IACvB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG;QAAE,GAAG,IAAI,IAAI,CAAA;KAAE,CAAC;CACvE;AAED,MAAM,WAAW,mBAAmB;IAClC,iGAAiG;IACjG,KAAK,EAAE,MAAM,CAAC;IACd,yGAAyG;IACzG,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,kBAAkB,CAAC;CAC7B;AASD;;;GAGG;AACH,wBAAgB,sBAAsB,SAErC;AAED,wBAAgB,yBAAyB,YAExC;AAED,6FAA6F;AAC7F,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,QAczE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,YAAY,EAAE,mBAAmB,KAAK,IAAI,cAQvF"}

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

@@ -70,6 +70,20 @@ export declare class SignalClient {
     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?;
@@ -78,7 +92,7 @@ export declare class SignalClient {
     private pingIntervalDuration;
     private pingInterval;
     private closingLock;
-    private state;
+    private machine;
     private connectionLock;
     private log;
     private loggerContextCb?;
@@ -94,6 +108,12 @@ export declare class SignalClient {
     /** @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>;
@@ -118,6 +138,10 @@ export declare class SignalClient {
     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;
     /**

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

@@ -0,0 +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

package/dist/ts4.2/index.d.ts

@@ -29,7 +29,7 @@ import type { PublicationEventCallbacks } from './room/track/TrackPublication';
 import { TrackPublication } from './room/track/TrackPublication';
 import type { LiveKitReactNativeInfo, TextStreamInfo } from './room/types';
 import type { AudioAnalyserOptions } from './room/utils';
-import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isAudioCodec, isAudioTrack, isBrowserSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isVideoCodec, isVideoTrack, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9 } from './room/utils';
+import { compareVersions, createAudioAnalyser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, isAudioCodec, isAudioTrack, isBrowserSupported, isLocalParticipant, isLocalTrack, isRemoteParticipant, isRemoteTrack, isSVCCodec, isVideoCodec, isVideoTrack, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsH265, supportsVP9 } from './room/utils';
 import { getBrowser } from './utils/browserParser';
 export type { RpcInvocationData, PerformRpcParams } from './room/rpc';
 export { RpcError } from './room/rpc';
@@ -63,8 +63,9 @@ export type { DataPublishOptions, SimulationScenario, TranscriptionSegment, Chat
 export * from './version';
 export { 
 /** @internal */
-attributes, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, Encryption_Type, DefaultReconnectPolicy, DisconnectReason, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, Participant, RemoteAudioTrack, RemoteParticipant, ParticipantKind, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, SubscriptionError, TrackPublication, TrackType, compareVersions, createAudioAnalyser, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, isBrowserSupported, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsVP9, Mutex, isAudioCodec, isAudioTrack, isLocalTrack, isRemoteTrack, isVideoCodec, isVideoTrack, isLocalParticipant, isRemoteParticipant, LocalDataTrack, RemoteDataTrack, };
+attributes, ConnectionQuality, ConnectionState, CriticalTimers, DataPacket_Kind, Encryption_Type, DefaultReconnectPolicy, DisconnectReason, LocalAudioTrack, LocalParticipant, LocalTrack, LocalTrackPublication, LocalVideoTrack, LogLevel, LoggerNames, Participant, RemoteAudioTrack, RemoteParticipant, ParticipantKind, RemoteTrack, RemoteTrackPublication, RemoteVideoTrack, Room, SubscriptionError, TrackPublication, TrackType, compareVersions, createAudioAnalyser, getBrowser, getEmptyAudioStreamTrack, getEmptyVideoStreamTrack, getLogger, isBrowserSupported, setLogExtension, setLogLevel, supportsAV1, supportsAdaptiveStream, supportsAudioOutputSelection, supportsDynacast, supportsH265, supportsVP9, Mutex, isAudioCodec, isAudioTrack, isLocalTrack, isRemoteTrack, isSVCCodec, isVideoCodec, isVideoTrack, isLocalParticipant, isRemoteParticipant, LocalDataTrack, RemoteDataTrack, };
 export type { AudioAnalyserOptions, ElementInfo, LiveKitReactNativeInfo, TextStreamInfo, ParticipantTrackPermission, AudioReceiverStats, AudioSenderStats, VideoReceiverStats, VideoSenderStats, ReconnectContext, ReconnectPolicy, RoomEventCallbacks, ParticipantEventCallbacks, PublicationEventCallbacks, DataTrackSubscribeOptions, RemoteDataTrackPipelineOptions, };
+export type { DataTrackFrame } from './room/data-track/frame';
 export type { DataTrackPacketHeader } from './room/data-track/packet';
 export { DataTrackPacket } from './room/data-track/packet';
 export type { DataTrackExtensions, DataTrackUserTimestampExtension, DataTrackE2eeExtension } from './room/data-track/packet/extensions';

package/dist/ts4.2/logger.d.ts

@@ -21,7 +21,8 @@ export declare enum LoggerNames {
     E2EE = "lk-e2ee",
     DataTracks = "livekit-data-tracks",
     Region = "livekit-region",
-    ICE = "livekit-ice"
+    ICE = "livekit-ice",
+    Stats = "livekit-stats"
 }
 type LogLevelString = keyof typeof LogLevel;
 export type StructuredLogger = log.Logger & {

package/dist/ts4.2/options.d.ts

@@ -96,6 +96,28 @@ export interface InternalRoomOptions {
      * @default true
      */
     singlePeerConnection: boolean;
+    /**
+     * Options controlling data stream behavior for this room.
+     */
+    dataStream?: RoomDataStreamOptions;
+}
+/**
+ * Options controlling data stream behavior for a room.
+ */
+export interface RoomDataStreamOptions {
+    /**
+     * Maximum size, in bytes, of the payload this client accepts from a single incoming data stream.
+     *
+     * A compressed stream can inflate to an arbitrarily large payload, so the decompressed output is
+     * bounded rather than trusting the size declared on the wire. An incoming stream that exceeds the
+     * cap fails with a `DataStreamErrorReason.PayloadTooLarge` error on the next read instead of
+     * buffering without bound.
+     *
+     * This is enforced on the receiving side only: raising it on a sender has no effect.
+     *
+     * @default 5_000_000_000 (5 GB)
+     */
+    maxPayloadByteLength?: number;
 }
 /**
  * Options for when creating a new room

package/dist/ts4.2/room/PCTransport.d.ts

@@ -91,7 +91,8 @@ export default class PCTransport extends PCTransport_base {
     getSenders(): RTCRtpSender[];
     getLocalDescription(): RTCSessionDescription | null | undefined;
     getRemoteDescription(): RTCSessionDescription | null;
-    getStats(): Promise<RTCStatsReport>;
+    /** stats of the underlying connection, `undefined` when there is none */
+    getStats(): Promise<RTCStatsReport> | undefined;
     getMaxMessageSize(): number | undefined;
     getConnectedAddress(): Promise<string | undefined>;
     close: () => void;

package/dist/ts4.2/room/RTCEngine.d.ts

@@ -98,10 +98,15 @@ export default class RTCEngine extends RTCEngine_base {
         joinResponse: JoinResponse;
         serverInfo: Partial<ServerInfo>;
     }>;
-    close(): Promise<void>;
+    /**
+     * @param reason why the session is ending, recorded by the signal lifecycle. Worth passing
+     * wherever the caller knows more than "someone called close" — the server's leave reason, or
+     * having given up on reconnecting.
+     */
+    close(reason?: string): Promise<void>;
     cleanupPeerConnections(): Promise<void>;
     cleanupLossyDataStats(): void;
-    cleanupClient(): Promise<void>;
+    cleanupClient(reason?: string): Promise<void>;
     addTrack(req: AddTrackRequest): Promise<TrackInfo>;
     /**
      * Removes sender from PeerConnection, returning true if it was removed successfully

package/dist/ts4.2/room/Room.d.ts

@@ -72,10 +72,12 @@ declare class Room extends Room_base {
     private frameMetadataManager;
     private e2eeStateMutex;
     private connectionReconcileInterval?;
+    private statsLogInterval?;
     private regionUrlProvider?;
     private regionUrl?;
     private isVideoPlaybackBlocked;
     private log;
+    private statsLog;
     private bufferedEvents;
     private isResuming;
     private pendingTrackAddedCallbacks;
@@ -276,6 +278,11 @@ declare class Room extends Room_base {
     private getRemoteParticipantCapabilities;
     private getAllRemoteParticipantIdentities;
     private registerRpcDataStreamHandler;
+    private setStatsLogging;
+    /**
+     * Dumps stats of both peer connections.
+     */
+    private logWebRTCStats;
     private registerConnectionReconcile;
     private clearConnectionReconcile;
     private setAndEmitConnectionState;
@@ -313,7 +320,7 @@ export type RoomEventCallbacks = {
     moved: (name: string) => void;
     mediaDevicesChanged: () => void;
     participantConnected: (participant: RemoteParticipant) => void;
-    participantDisconnected: (participant: RemoteParticipant) => void;
+    participantDisconnected: (participant: RemoteParticipant, disconnectReason?: DisconnectReason) => void;
     trackPublished: (publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
     trackSubscribed: (track: RemoteTrack, publication: RemoteTrackPublication, participant: RemoteParticipant) => void;
     trackSubscriptionFailed: (trackSid: string, participant: RemoteParticipant, reason?: SubscriptionError) => void;

package/dist/ts4.2/room/events.d.ts

@@ -70,7 +70,7 @@ export declare enum RoomEvent {
      * When a [[RemoteParticipant]] leaves *after* the local
      * participant has joined.
      *
-     * args: ([[RemoteParticipant]])
+     * args: ([[RemoteParticipant]], [[DisconnectReason]] | undefined)
      */
     ParticipantDisconnected = "participantDisconnected",
     /**

package/dist/ts4.2/room/statsSummary.d.ts

@@ -0,0 +1,13 @@
+/** one summarised stats entry; keys without a value are dropped */
+type Summary = Record<string, unknown>;
+/**
+ * Picks the interesting fields out of a `getStats()` report and groups them by
+ * RTP stream, so a stats dump can be read without unfolding the raw report.
+ */
+export declare function summarizeStatsReport(report: RTCStatsReport): {
+    connection: Summary | undefined;
+    outbound: Summary[] | undefined;
+    inbound: Summary[] | undefined;
+};
+export {};
+//# sourceMappingURL=statsSummary.d.ts.map

package/dist/ts4.2/room/track/Track.d.ts

@@ -42,6 +42,7 @@ export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> e
     protected timeSyncHandle: number | undefined;
     protected _currentBitrate: number;
     protected monitorInterval?: ReturnType<typeof setInterval>;
+    private finalStatsLogged;
     protected log: StructuredLogger;
     protected constructor(mediaTrack: MediaStreamTrack, kind: TrackKind, loggerOptions?: LoggerOptions);
     protected get logContext(): {
@@ -78,7 +79,16 @@ export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> e
     protected enable(): void;
     protected disable(): void;
     abstract startMonitor(signalClient?: SignalClient): void;
+    /**
+     * Raw stats of the sender or receiver this track is attached to.
+     */
+    abstract getRTCStatsReport(): Promise<RTCStatsReport | undefined>;
     stopMonitor(): void;
+    /**
+     * Dumps the raw stats of the track as it ends, once: a track that stops
+     * between two of the room's stats dumps is gone by the time the next one runs.
+     */
+    private logFinalStats;
     /** @internal */
     updateLoggerOptions(loggerOptions: LoggerOptions): void;
     private recycleElement;

package/dist/ts4.2/utils/machineInspector.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Opt-in registry that lets a development tool observe the state machines driving the connection
+ * layer.
+ *
+ * The machines are private to the objects that own them and, more importantly, do not outlive them:
+ * a full reconnect replaces the whole engine along with its `SignalClient`, so anything watching a
+ * single machine reference goes blind exactly when the interesting part starts. Machines therefore
+ * announce themselves here as they are constructed, and a subscriber sees the whole succession.
+ *
+ * Nothing is recorded until {@link enableMachineInspector} is called, which no shipping code does —
+ * with the registry off, announcing is a comparison and a return.
+ */
+/**
+ * The slice of machina's `Fsm` surface an inspector needs. Structural rather than machina's own
+ * type so that any machine satisfies it regardless of its state and input unions.
+ */
+export interface InspectableMachine {
+    readonly id: string;
+    readonly initialState: string;
+    readonly states: Record<string, Record<string, unknown>>;
+    readonly context?: unknown;
+    currentState(): string;
+    canHandle(input: string): boolean;
+    on(eventName: string, callback: (data: any) => void): {
+        off(): void;
+    };
+}
+export interface MachineAnnouncement {
+    /** What the machine drives, e.g. `signal`. Not unique: each new `SignalClient` announces one. */
+    label: string;
+    /** How many machines have been announced before this one, so successive instances are tellable apart. */
+    seq: number;
+    /**
+     * When the machine was constructed. Carried on the announcement because subscribers receive the
+     * recorded ones on subscribe, and stamping those at replay time would date them all to whenever
+     * the tool happened to open.
+     */
+    at: number;
+    machine: InspectableMachine;
+}
+/**
+ * Starts recording machine announcements. Call before the machines of interest are constructed —
+ * for the signal machine that means before the `Room` is created.
+ */
+export declare function enableMachineInspector(): void;
+export declare function isMachineInspectorEnabled(): boolean;
+/** Announces a machine to whatever is watching. A no-op unless the inspector was enabled. */
+export declare function announceMachine(label: string, machine: InspectableMachine): void;
+/**
+ * Subscribes to machine announcements, replaying the ones already recorded so that a panel opened
+ * after connecting still sees the machine currently in charge. Returns an unsubscribe function.
+ */
+export declare function onMachineAnnounced(callback: (announcement: MachineAnnouncement) => void): () => void;
+//# sourceMappingURL=machineInspector.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.22.0",
+  "version": "2.22.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -54,6 +54,7 @@
     "events": "^3.3.0",
     "jose": "^6.1.0",
     "loglevel": "^1.9.2",
+    "machina": "^7.0.0",
     "sdp-transform": "^2.15.0",
     "tslib": "2.8.1",
     "typed-emitter": "^2.1.0",
@@ -92,12 +93,16 @@
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-compat": "^6.0.2",
     "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-machina": "^0.1.4",
     "eslint-plugin-prettier": "^5.5.4",
     "gh-pages": "6.3.0",
     "glob": "^13.0.6",
     "happy-dom": "^20.0.0",
     "jsdom": "^26.1.0",
     "livekit-server-sdk": "^2.17.0",
+    "machina-inspect": "^4.0.0",
+    "machina-test": "^3.0.0",
+    "mermaid": "^11.16.1",
     "playwright": "^1.61.1",
     "prettier": "^3.4.2",
     "publint": "^0.3.21",
@@ -121,6 +126,7 @@
     "build-docs": "typedoc && mkdir -p docs/assets/github && cp .github/*.png docs/assets/github/ && find docs -name '*.html' -type f -exec sed -i.bak 's|=\"/.github/|=\"assets/github/|g' {} + && find docs -name '*.bak' -delete",
     "proto": "protoc --es_out src/proto --es_opt target=ts -I./protocol ./protocol/livekit_rtc.proto ./protocol/livekit_models.proto",
     "examples:demo": "vite examples/demo -c vite.config.mjs",
+    "examples:machine": "vite examples/state-machine -c vite.config.mjs",
     "dev": "pnpm examples:demo",
     "lint": "eslint src",
     "test": "vitest run src",