livekit-client 2.21.0 → 2.22.1

package/src/room/utils.ts

@@ -58,7 +58,7 @@ export function supportsAddTrack() {
 }
 
 export function supportsAdaptiveStream() {
-  return typeof ResizeObserver !== undefined && typeof IntersectionObserver !== undefined;
+  return typeof ResizeObserver !== 'undefined' && typeof IntersectionObserver !== 'undefined';
 }
 
 export function supportsDynacast() {
@@ -146,6 +146,45 @@ export function isSVCCodec(codec?: string): boolean {
   return codec === 'av1' || codec === 'vp9';
 }
 
+/**
+ * Opts `transceiver` into negotiating the AV1 dependency descriptor, reporting whether it will be.
+ *
+ * Chrome only offers the extension on transceivers that can send, so one we create to receive on
+ * never negotiates it — and Chrome 152 stopped decoding AV1 that arrives without it: frames get
+ * assembled, none ever decode, and the receiver asks for a keyframe forever. Asking through the
+ * transceiver rather than munging the extension into the SDP leaves the browser owning the
+ * extension id, which is what keeps that id consistent across the bundle and across
+ * renegotiations.
+ *
+ * A no-op where the browser offers no such control, or does not know the extension at all.
+ * @internal
+ */
+export function negotiateDependencyDescriptor(transceiver: RTCRtpTransceiver): boolean {
+  const extensions = transceiver.getHeaderExtensionsToNegotiate?.();
+  if (!extensions || !transceiver.setHeaderExtensionsToNegotiate) {
+    return false;
+  }
+  const dd = extensions.find((ext) => ext.uri === ddExtensionURI);
+  if (!dd) {
+    return false;
+  }
+  if (dd.direction !== 'stopped') {
+    return true;
+  }
+  // sendrecv rather than recvonly, so that the extension is written as a plain `a=extmap` line —
+  // the form the server already emits where it is the one offering — rather than one carrying a
+  // `/recvonly` suffix that its parser may not expect
+  dd.direction = 'sendrecv';
+  try {
+    transceiver.setHeaderExtensionsToNegotiate(extensions);
+    return true;
+  } catch (e) {
+    // a rejected direction throws. Negotiating without the extension is what happened before this
+    // existed, so it is not worth failing the connection over
+    return false;
+  }
+}
+
 export function supportsSetSinkId(elm?: HTMLMediaElement): boolean {
   if (!document || isSafariBased()) {
     return false;
@@ -867,3 +906,16 @@ export function isPublisherOfferWithJoinSupported() {
   // we have connectivity issue about publisher offer with join on firefox #1919
   return isCompressionStreamSupported() && !isFireFox();
 }
+
+export function extractTrackSid(
+  mediaTrack: MediaStreamTrack,
+  stream: MediaStream,
+): Track.SID | undefined {
+  const [, streamId] = unpackStreamId(stream.id);
+  if (streamId?.startsWith('TR')) {
+    return streamId;
+  }
+  if (mediaTrack.id.startsWith('TR')) {
+    return mediaTrack.id;
+  }
+}

package/src/test/promiseState.ts

@@ -0,0 +1,23 @@
+/**
+ * Test helper: resolves `true` if `promise` is still pending after `ms`
+ * (default: one macrotask), `false` if it has already settled — regardless of
+ * whether it resolved or rejected.
+ *
+ * Use to assert that something has *not* happened yet (e.g. an onClose callback
+ * that must stay silent), optionally within a timeout window. Preferable to
+ * `Promise.race([p, Promise.resolve(sentinel)])` when the "not yet" needs to
+ * hold for a duration rather than just the current microtask.
+ */
+export async function isPending(promise: Promise<unknown>, ms = 0): Promise<boolean> {
+  const pending = Symbol('pending');
+  // Swallow settlement (incl. rejection) so racing it can't raise unhandled
+  // rejections when the timer wins.
+  const settled = promise.then(
+    () => 'settled' as const,
+    () => 'settled' as const,
+  );
+  const timer = new Promise<typeof pending>((resolve) => {
+    setTimeout(() => resolve(pending), ms);
+  });
+  return (await Promise.race([settled, timer])) === pending;
+}

package/src/test/signalServerSetup.ts

@@ -2,6 +2,7 @@ import { type ChildProcess, execFileSync, spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { Socket, createServer } from 'node:net';
 import { join } from 'node:path';
+import { sleep } from '../room/utils';
 import { createToken } from './signalToken';
 
 /**
@@ -47,7 +48,7 @@ async function waitReady(serverUrl: string): Promise<boolean> {
     } catch {
       // not up yet
     }
-    await new Promise((r) => setTimeout(r, 200));
+    await sleep(200);
   }
   return false;
 }

package/src/test/signalToken.ts

@@ -1,4 +1,4 @@
-import { SignJWT } from 'jose';
+import { AccessToken } from 'livekit-server-sdk';
 
 /**
  * Mint a LiveKit access token for the mock test-server (HS256, dev secret).
@@ -33,24 +33,28 @@ export async function createToken(opts: TokenOptions = {}): Promise<string> {
     secret = 'secret',
     ttlSeconds = 600,
   } = opts;
-  const key = new TextEncoder().encode(secret);
-  const payload: Record<string, unknown> = {
-    video: { room, roomJoin: true, canPublish: true, canSubscribe: true, canPublishData: true },
-  };
+  const attributes: Record<string, string> = {};
   if (signal) {
     const control: Record<string, unknown> = { signal };
     if (leaveAction !== undefined) {
       control.leaveAction = leaveAction;
     }
-    payload.attributes = { 'lk.mock': JSON.stringify(control) };
+    attributes['lk.mock'] = JSON.stringify(control);
   }
-  return new SignJWT(payload)
-    .setProtectedHeader({ alg: 'HS256' })
-    .setIssuer(apiKey)
-    .setSubject(identity)
-    .setIssuedAt()
-    .setExpirationTime(`${ttlSeconds}s`)
-    .sign(key);
+  const token = new AccessToken(apiKey, secret, {
+    ttl: ttlSeconds,
+    identity,
+    attributes,
+  });
+  token.addGrant({
+    room,
+    roomJoin: true,
+    canPublish: true,
+    canSubscribe: true,
+    canPublishData: true,
+  });
+
+  return token.toJwt();
 }
 
 /** A syntactically-valid token signed with the WRONG secret — for 401 tests. */

package/src/type-polyfills/header-extensions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Per-transceiver control over which RTP header extensions get negotiated. Declared as optional
+ * because it is not in lib.dom yet and not every browser implements it.
+ * https://w3c.github.io/webrtc-extensions/#rtcrtptransceiver-interface-extensions
+ */
+interface RTCRtpTransceiver {
+  getHeaderExtensionsToNegotiate?(): RTCRtpHeaderExtensionCapability[];
+  setHeaderExtensionsToNegotiate?(extensions: RTCRtpHeaderExtensionCapability[]): void;
+}
+
+interface RTCRtpHeaderExtensionCapability {
+  direction?: 'sendrecv' | 'sendonly' | 'recvonly' | 'stopped';
+}

package/src/utils/AsyncQueue.ts

@@ -3,9 +3,9 @@ import { Mutex } from '@livekit/mutex';
 type QueueTask<T> = () => PromiseLike<T>;
 
 enum QueueTaskStatus {
-  'WAITING',
-  'RUNNING',
-  'COMPLETED',
+  WAITING,
+  RUNNING,
+  COMPLETED,
 }
 
 type QueueTaskInfo = {

package/src/utils/machineInspector.ts

@@ -0,0 +1,90 @@
+/**
+ * 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;
+}
+
+/** Kept small: enough for a panel opened mid-session to see how the connection got where it is. */
+const HISTORY_LIMIT = 16;
+
+let enabled = false;
+let announced: MachineAnnouncement[] = [];
+let subscribers: Array<(announcement: MachineAnnouncement) => void> = [];
+
+/**
+ * Starts recording machine announcements. Call before the machines of interest are constructed —
+ * for the signal machine that means before the `Room` is created.
+ */
+export function enableMachineInspector() {
+  enabled = true;
+}
+
+export function isMachineInspectorEnabled() {
+  return enabled;
+}
+
+/** Announces a machine to whatever is watching. A no-op unless the inspector was enabled. */
+export function announceMachine(label: string, machine: InspectableMachine) {
+  if (!enabled) {
+    return;
+  }
+  const announcement: MachineAnnouncement = {
+    label,
+    seq: announced.length,
+    at: Date.now(),
+    machine,
+  };
+  announced = [...announced.slice(-(HISTORY_LIMIT - 1)), announcement];
+  for (const subscriber of subscribers) {
+    subscriber(announcement);
+  }
+}
+
+/**
+ * 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 function onMachineAnnounced(callback: (announcement: MachineAnnouncement) => void) {
+  subscribers = [...subscribers, callback];
+  for (const announcement of announced) {
+    callback(announcement);
+  }
+  return () => {
+    subscribers = subscribers.filter((subscriber) => subscriber !== callback);
+  };
+}