@livekit/rtc-node 0.13.32 → 0.13.34

package/dist/rpc.d.ts

@@ -1,7 +1,6 @@
-import { RpcError as RpcError$1 } from '@livekit/rtc-ffi-bindings';
-
+import type { RpcError as RpcError_Proto } from '@livekit/rtc-ffi-bindings';
 /** Parameters for initiating an RPC call */
-interface PerformRpcParams {
+export interface PerformRpcParams {
     /** The `identity` of the destination participant */
     destinationIdentity: string;
     /** The method name to call */
@@ -14,7 +13,7 @@ interface PerformRpcParams {
 /**
  * Data passed to method handler for incoming RPC invocations
  */
-interface RpcInvocationData {
+export interface RpcInvocationData {
     /**
      * The unique request ID. Will match at both sides of the call, useful for debugging or logging.
      */
@@ -40,7 +39,7 @@ interface RpcInvocationData {
  *
  * Built-in types are included but developers may use any string, with a max length of 256 bytes.
  */
-declare class RpcError extends Error {
+export declare class RpcError extends Error {
     code: typeof RpcError.ErrorCode | number;
     data?: string;
     /**
@@ -51,8 +50,8 @@ declare class RpcError extends Error {
      * Error codes 1001-1999 are reserved for built-in errors (see RpcError.ErrorCode for their meanings).
      */
     constructor(code: number, message: string, data?: string);
-    static fromProto(proto: RpcError$1): RpcError;
-    toProto(): RpcError$1;
+    static fromProto(proto: RpcError_Proto): RpcError;
+    toProto(): RpcError_Proto;
     static ErrorCode: {
         readonly APPLICATION_ERROR: 1500;
         readonly CONNECTION_TIMEOUT: 1501;
@@ -76,5 +75,4 @@ declare class RpcError extends Error {
      */
     static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError;
 }
-
-export { type PerformRpcParams, RpcError, type RpcInvocationData };
+//# sourceMappingURL=rpc.d.ts.map

package/dist/tests/e2e_common.cjs

@@ -0,0 +1,157 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var e2e_common_exports = {};
+__export(e2e_common_exports, {
+  concatUint8: () => concatUint8,
+  connectTestRooms: () => connectTestRooms,
+  createJoinToken: () => createJoinToken,
+  describeE2E: () => describeE2E,
+  getTestEnv: () => getTestEnv,
+  hasE2EEnv: () => hasE2EEnv,
+  testTimeoutMs: () => testTimeoutMs,
+  waitFor: () => waitFor,
+  waitForRoomEvent: () => waitForRoomEvent,
+  withTimeout: () => withTimeout
+});
+module.exports = __toCommonJS(e2e_common_exports);
+var import_livekit_server_sdk = require("livekit-server-sdk");
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:timers/promises");
+var import_vitest = require("vitest");
+var import__ = require("../index.cjs");
+const hasE2EEnv = !!process.env.LIVEKIT_URL && !!process.env.LIVEKIT_API_KEY && !!process.env.LIVEKIT_API_SECRET;
+const describeE2E = hasE2EEnv ? import_vitest.describe : import_vitest.describe.skip;
+const testTimeoutMs = 1e4;
+function normalizeLiveKitUrl(url) {
+  if (url.startsWith("http://")) return `ws://${url.slice("http://".length)}`;
+  if (url.startsWith("https://")) return `wss://${url.slice("https://".length)}`;
+  return url;
+}
+function getTestEnv() {
+  if (!hasE2EEnv) {
+    throw new Error(
+      "Missing required env vars for e2e: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET"
+    );
+  }
+  return {
+    url: normalizeLiveKitUrl(process.env.LIVEKIT_URL),
+    apiKey: process.env.LIVEKIT_API_KEY,
+    apiSecret: process.env.LIVEKIT_API_SECRET
+  };
+}
+async function withTimeout(promise, timeoutMs, message) {
+  return await Promise.race([
+    promise,
+    (async () => {
+      await (0, import_promises.setTimeout)(timeoutMs);
+      throw new Error(message);
+    })()
+  ]);
+}
+async function waitFor(condition, opts) {
+  const intervalMs = opts.intervalMs ?? 50;
+  const deadline = Date.now() + opts.timeoutMs;
+  while (Date.now() < deadline) {
+    if (condition()) return;
+    await (0, import_promises.setTimeout)(intervalMs);
+  }
+  throw new Error(`Timed out waiting for condition${opts.debugName ? ` (${opts.debugName})` : ""}`);
+}
+async function createJoinToken(params) {
+  const token = new import_livekit_server_sdk.AccessToken(params.env.apiKey, params.env.apiSecret, {
+    identity: params.identity,
+    name: params.name,
+    ttl: "30m"
+  });
+  token.addGrant({
+    room: params.roomName,
+    roomJoin: true,
+    roomCreate: true,
+    canPublish: true,
+    canSubscribe: true
+  });
+  return await token.toJwt();
+}
+async function connectTestRooms(count, options) {
+  const env = getTestEnv();
+  const roomName = `test_room_${(0, import_node_crypto.randomUUID)()}`;
+  const rooms = await Promise.all(
+    Array.from({ length: count }, async (_, i) => {
+      const token = await createJoinToken({
+        env,
+        roomName,
+        identity: `p${i}`,
+        name: `Participant ${i}`
+      });
+      const room = new import__.Room();
+      await room.connect(env.url, token, {
+        autoSubscribe: true,
+        dynacast: false,
+        ...options
+      });
+      return room;
+    })
+  );
+  const start = Date.now();
+  await waitFor(() => rooms.every((r) => r.remoteParticipants.size === count - 1), {
+    timeoutMs: 5e3,
+    debugName: `participant visibility (${Date.now() - start}ms)`
+  });
+  return { roomName, rooms };
+}
+function waitForRoomEvent(room, event, timeoutMs, take, match) {
+  return withTimeout(
+    new Promise((resolve) => {
+      const handler = (...args) => {
+        if (match && !match(...args)) {
+          return;
+        }
+        room.off(event, handler);
+        resolve(take(...args));
+      };
+      room.on(event, handler);
+    }),
+    timeoutMs,
+    `Timed out waiting for ${event}`
+  );
+}
+function concatUint8(chunks) {
+  const len = chunks.reduce((acc, c) => acc + c.byteLength, 0);
+  const out = new Uint8Array(len);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  concatUint8,
+  connectTestRooms,
+  createJoinToken,
+  describeE2E,
+  getTestEnv,
+  hasE2EEnv,
+  testTimeoutMs,
+  waitFor,
+  waitForRoomEvent,
+  withTimeout
+});
+//# sourceMappingURL=e2e_common.cjs.map

package/dist/tests/e2e_common.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tests/e2e_common.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { AccessToken } from 'livekit-server-sdk';\nimport { randomUUID } from 'node:crypto';\nimport { setTimeout as delay } from 'node:timers/promises';\nimport { describe } from 'vitest';\nimport { Room, type RoomEvent, type RoomOptions } from '../index.js';\n\nexport const hasE2EEnv =\n  !!process.env.LIVEKIT_URL && !!process.env.LIVEKIT_API_KEY && !!process.env.LIVEKIT_API_SECRET;\n// Explicitly typed so declaration emit doesn't reference vitest's\n// non-exported internal suite types (TS4023).\nexport const describeE2E: typeof describe = hasE2EEnv\n  ? describe\n  : (describe.skip as typeof describe);\nexport const testTimeoutMs = 10_000;\n\nexport type TestEnv = {\n  url: string;\n  apiKey: string;\n  apiSecret: string;\n};\n\nfunction normalizeLiveKitUrl(url: string): string {\n  if (url.startsWith('http://')) return `ws://${url.slice('http://'.length)}`;\n  if (url.startsWith('https://')) return `wss://${url.slice('https://'.length)}`;\n  return url;\n}\n\nexport function getTestEnv(): TestEnv {\n  if (!hasE2EEnv) {\n    throw new Error(\n      'Missing required env vars for e2e: LIVEKIT_URL, LIVEKIT_API_KEY, LIVEKIT_API_SECRET',\n    );\n  }\n  return {\n    url: normalizeLiveKitUrl(process.env.LIVEKIT_URL!),\n    apiKey: process.env.LIVEKIT_API_KEY!,\n    apiSecret: process.env.LIVEKIT_API_SECRET!,\n  };\n}\n\nexport async function withTimeout<T>(\n  promise: Promise<T>,\n  timeoutMs: number,\n  message: string,\n): Promise<T> {\n  return await Promise.race([\n    promise,\n    (async () => {\n      await delay(timeoutMs);\n      throw new Error(message);\n    })(),\n  ]);\n}\n\nexport async function waitFor(\n  condition: () => boolean,\n  opts: { timeoutMs: number; intervalMs?: number; debugName?: string },\n): Promise<void> {\n  const intervalMs = opts.intervalMs ?? 50;\n  const deadline = Date.now() + opts.timeoutMs;\n  while (Date.now() < deadline) {\n    if (condition()) return;\n    await delay(intervalMs);\n  }\n  throw new Error(`Timed out waiting for condition${opts.debugName ? ` (${opts.debugName})` : ''}`);\n}\n\nexport async function createJoinToken(params: {\n  env: TestEnv;\n  roomName: string;\n  identity: string;\n  name: string;\n}): Promise<string> {\n  const token = new AccessToken(params.env.apiKey, params.env.apiSecret, {\n    identity: params.identity,\n    name: params.name,\n    ttl: '30m',\n  });\n  token.addGrant({\n    room: params.roomName,\n    roomJoin: true,\n    roomCreate: true,\n    canPublish: true,\n    canSubscribe: true,\n  });\n  return await token.toJwt();\n}\n\nexport async function connectTestRooms(\n  count: number,\n  /**\n   * Extra room options applied to every room, e.g. data stream limits or\n   * `encryption` to bring up the whole set with a shared e2ee key.\n   */\n  options?: Partial<RoomOptions>,\n): Promise<{ roomName: string; rooms: Room[] }> {\n  const env = getTestEnv();\n  const roomName = `test_room_${randomUUID()}`;\n  const rooms = await Promise.all(\n    Array.from({ length: count }, async (_, i) => {\n      const token = await createJoinToken({\n        env,\n        roomName,\n        identity: `p${i}`,\n        name: `Participant ${i}`,\n      });\n      const room = new Room();\n      await room.connect(env.url, token, {\n        autoSubscribe: true,\n        dynacast: false,\n        ...options,\n      });\n      return room;\n    }),\n  );\n\n  const start = Date.now();\n  await waitFor(() => rooms.every((r) => r.remoteParticipants.size === count - 1), {\n    timeoutMs: 5000,\n    debugName: `participant visibility (${Date.now() - start}ms)`,\n  });\n\n  return { roomName, rooms };\n}\n\nexport function waitForRoomEvent<R>(\n  room: Room,\n  event: RoomEvent,\n  timeoutMs: number,\n  take: (...args: any[]) => R,\n  /** Ignore emissions that don't match, e.g. events for another participant. */\n  match?: (...args: unknown[]) => boolean,\n): Promise<R> {\n  return withTimeout(\n    new Promise<R>((resolve) => {\n      const handler = (...args: any[]) => {\n        if (match && !match(...args)) {\n          return;\n        }\n        // typed-emitter doesn't expose `.once` in the type surface, so do manual once+cleanup.\n        room.off(event as any, handler as any);\n        resolve(take(...args));\n      };\n      room.on(event as any, handler as any);\n    }),\n    timeoutMs,\n    `Timed out waiting for ${event}`,\n  );\n}\n\nexport function concatUint8(chunks: Uint8Array[]): Uint8Array {\n  const len = chunks.reduce((acc, c) => acc + c.byteLength, 0);\n  const out = new Uint8Array(len);\n  let offset = 0;\n  for (const c of chunks) {\n    out.set(c, offset);\n    offset += c.byteLength;\n  }\n  return out;\n}\n"],"mappings":"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","names":["delay"]}

package/dist/tests/e2e_common.d.cts

@@ -0,0 +1,56 @@
+import { describe } from 'vitest';
+import '../ffi_client.cjs';
+import { m as RoomOptions, j as Room, l as RoomEvent } from '../audio_stream-BNVaONuH.cjs';
+import '@livekit/rtc-ffi-bindings';
+import '@livekit/typed-emitter';
+import 'node:stream/web';
+import '../audio_frame.cjs';
+import '../frame_processor.cjs';
+import '../video_frame.cjs';
+import '../audio_source.cjs';
+import '../types-f7wTlFjs.cjs';
+import '../e2ee.cjs';
+import '@livekit/mutex';
+import 'node:fs';
+import '../data_streams/stream_writer.cjs';
+import '../rpc.cjs';
+import '../transcription.cjs';
+import '../types.cjs';
+import '../video_source.cjs';
+
+declare const hasE2EEnv: boolean;
+declare const describeE2E: typeof describe;
+declare const testTimeoutMs = 10000;
+type TestEnv = {
+    url: string;
+    apiKey: string;
+    apiSecret: string;
+};
+declare function getTestEnv(): TestEnv;
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+declare function waitFor(condition: () => boolean, opts: {
+    timeoutMs: number;
+    intervalMs?: number;
+    debugName?: string;
+}): Promise<void>;
+declare function createJoinToken(params: {
+    env: TestEnv;
+    roomName: string;
+    identity: string;
+    name: string;
+}): Promise<string>;
+declare function connectTestRooms(count: number, 
+/**
+ * Extra room options applied to every room, e.g. data stream limits or
+ * `encryption` to bring up the whole set with a shared e2ee key.
+ */
+options?: Partial<RoomOptions>): Promise<{
+    roomName: string;
+    rooms: Room[];
+}>;
+declare function waitForRoomEvent<R>(room: Room, event: RoomEvent, timeoutMs: number, take: (...args: any[]) => R, 
+/** Ignore emissions that don't match, e.g. events for another participant. */
+match?: (...args: unknown[]) => boolean): Promise<R>;
+declare function concatUint8(chunks: Uint8Array[]): Uint8Array;
+
+export { type TestEnv, concatUint8, connectTestRooms, createJoinToken, describeE2E, getTestEnv, hasE2EEnv, testTimeoutMs, waitFor, waitForRoomEvent, withTimeout };

package/dist/tests/e2e_common.d.ts

@@ -0,0 +1,37 @@
+import { describe } from 'vitest';
+import { Room, type RoomEvent, type RoomOptions } from '../index.js';
+export declare const hasE2EEnv: boolean;
+export declare const describeE2E: typeof describe;
+export declare const testTimeoutMs = 10000;
+export type TestEnv = {
+    url: string;
+    apiKey: string;
+    apiSecret: string;
+};
+export declare function getTestEnv(): TestEnv;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T>;
+export declare function waitFor(condition: () => boolean, opts: {
+    timeoutMs: number;
+    intervalMs?: number;
+    debugName?: string;
+}): Promise<void>;
+export declare function createJoinToken(params: {
+    env: TestEnv;
+    roomName: string;
+    identity: string;
+    name: string;
+}): Promise<string>;
+export declare function connectTestRooms(count: number, 
+/**
+ * Extra room options applied to every room, e.g. data stream limits or
+ * `encryption` to bring up the whole set with a shared e2ee key.
+ */
+options?: Partial<RoomOptions>): Promise<{
+    roomName: string;
+    rooms: Room[];
+}>;
+export declare function waitForRoomEvent<R>(room: Room, event: RoomEvent, timeoutMs: number, take: (...args: any[]) => R, 
+/** Ignore emissions that don't match, e.g. events for another participant. */
+match?: (...args: unknown[]) => boolean): Promise<R>;
+export declare function concatUint8(chunks: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=e2e_common.d.ts.map

package/dist/tests/e2e_common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e_common.d.ts","sourceRoot":"","sources":["../../src/tests/e2e_common.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAErE,eAAO,MAAM,SAAS,SAC0E,CAAC;AAGjG,eAAO,MAAM,WAAW,EAAE,OAAO,QAEK,CAAC;AACvC,eAAO,MAAM,aAAa,QAAS,CAAC;AAEpC,MAAM,MAAM,OAAO,GAAG;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAQF,wBAAgB,UAAU,IAAI,OAAO,CAWpC;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,CAAC,CAQZ;AAED,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,EACxB,IAAI,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACnE,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,MAAM,CAAC,CAclB;AAED,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM;AACb;;;GAGG;AACH,OAAO,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAC7B,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,CA4B9C;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC;AAC3B,8EAA8E;AAC9E,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,GACtC,OAAO,CAAC,CAAC,CAAC,CAgBZ;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAS5D"}

package/dist/track.d.cts

@@ -1,6 +1,6 @@
 import '@livekit/rtc-ffi-bindings';
 import './audio_source.cjs';
-export { a as AudioTrack, L as LocalAudioTrack, c as LocalTrack, e as LocalVideoTrack, R as RemoteAudioTrack, g as RemoteTrack, i as RemoteVideoTrack, T as Track, V as VideoTrack } from './audio_stream-4M8XlO4-.cjs';
+export { a as AudioTrack, L as LocalAudioTrack, c as LocalTrack, e as LocalVideoTrack, R as RemoteAudioTrack, g as RemoteTrack, i as RemoteVideoTrack, T as Track, V as VideoTrack } from './audio_stream-BNVaONuH.cjs';
 import './ffi_client.cjs';
 import './video_source.cjs';
 import './audio_frame.cjs';
@@ -8,7 +8,7 @@ import 'node:stream/web';
 import './frame_processor.cjs';
 import './video_frame.cjs';
 import '@livekit/typed-emitter';
-import './types-_PdPVish.cjs';
+import './types-f7wTlFjs.cjs';
 import './e2ee.cjs';
 import '@livekit/mutex';
 import 'node:fs';

package/dist/track.d.ts

@@ -1,18 +1,67 @@
-import '@livekit/rtc-ffi-bindings';
-import './audio_source.js';
-export { a as AudioTrack, L as LocalAudioTrack, c as LocalTrack, e as LocalVideoTrack, R as RemoteAudioTrack, g as RemoteTrack, i as RemoteVideoTrack, T as Track, V as VideoTrack } from './audio_stream-CTyN1Ldy.js';
-import './ffi_client.js';
-import './video_source.js';
-import './audio_frame.js';
-import 'node:stream/web';
-import './frame_processor.js';
-import './video_frame.js';
-import '@livekit/typed-emitter';
-import './types-_PdPVish.js';
-import './e2ee.js';
-import '@livekit/mutex';
-import 'node:fs';
-import './data_streams/stream_writer.js';
-import './rpc.js';
-import './transcription.js';
-import './types.js';
+import type { OwnedTrack, StreamState, TrackInfo, TrackKind } from '@livekit/rtc-ffi-bindings';
+import type { AudioSource } from './audio_source.js';
+import type { AudioStreamSource } from './audio_stream.js';
+import { FfiHandle } from './ffi_client.js';
+import type { Room } from './room.js';
+import type { VideoSource } from './video_source.js';
+export declare abstract class Track {
+    /** @internal */
+    info?: TrackInfo;
+    /** @internal */
+    ffi_handle: FfiHandle;
+    private roomRef;
+    private audioStreams;
+    private streamFinalizationRegistry;
+    private onRoomTokenRefreshed;
+    constructor(owned: OwnedTrack);
+    /** @internal */
+    resolveRoom(): Room | null;
+    /** @internal */
+    setRoom(room: Room | null): void;
+    /** @internal */
+    registerAudioStream(stream: AudioStreamSource): void;
+    /** @internal */
+    unregisterAudioStream(stream: AudioStreamSource): void;
+    /**
+     * End every {@link AudioStream} attached to this track.
+     *
+     * @remarks
+     * The FFI keeps feeding an audio stream until the stream's own handle is
+     * dropped, so streams on a track that is no longer subscribed would otherwise
+     * go on delivering audio for the lifetime of the process.
+     *
+     * @internal
+     */
+    closeAudioStreams(): void;
+    private iterateStreams;
+    private pushProcessorMetadataToStream;
+    get sid(): string | undefined;
+    get name(): string | undefined;
+    get kind(): TrackKind | undefined;
+    get stream_state(): StreamState | undefined;
+    get muted(): boolean | undefined;
+    close(): Promise<void>;
+}
+export declare class LocalAudioTrack extends Track {
+    private source?;
+    constructor(owned: OwnedTrack, source?: AudioSource);
+    static createAudioTrack(name: string, source: AudioSource): LocalAudioTrack;
+    close(closeSource?: boolean): Promise<void>;
+}
+export declare class LocalVideoTrack extends Track {
+    private source?;
+    constructor(owned: OwnedTrack, source?: VideoSource);
+    static createVideoTrack(name: string, source: VideoSource): LocalVideoTrack;
+    close(closeSource?: boolean): Promise<void>;
+}
+export declare class RemoteVideoTrack extends Track {
+    constructor(owned: OwnedTrack);
+}
+export declare class RemoteAudioTrack extends Track {
+    constructor(owned: OwnedTrack);
+}
+export type LocalTrack = LocalVideoTrack | LocalAudioTrack;
+export type RemoteTrack = RemoteVideoTrack | RemoteAudioTrack;
+export type AudioTrack = LocalAudioTrack | RemoteAudioTrack;
+export type VideoTrack = LocalVideoTrack | RemoteVideoTrack;
+//# sourceMappingURL=track.d.ts.map

package/dist/track_publication.d.cts

@@ -1,5 +1,5 @@
 import '@livekit/rtc-ffi-bindings';
-export { d as LocalTrackPublication, h as RemoteTrackPublication, n as TrackPublication } from './audio_stream-4M8XlO4-.cjs';
+export { d as LocalTrackPublication, h as RemoteTrackPublication, o as TrackPublication } from './audio_stream-BNVaONuH.cjs';
 import 'node:stream/web';
 import './audio_frame.cjs';
 import './frame_processor.cjs';
@@ -7,7 +7,7 @@ import './video_frame.cjs';
 import './audio_source.cjs';
 import './ffi_client.cjs';
 import '@livekit/typed-emitter';
-import './types-_PdPVish.cjs';
+import './types-f7wTlFjs.cjs';
 import './e2ee.cjs';
 import '@livekit/mutex';
 import 'node:fs';

package/dist/track_publication.d.ts

@@ -1,18 +1,45 @@
-import '@livekit/rtc-ffi-bindings';
-export { d as LocalTrackPublication, h as RemoteTrackPublication, n as TrackPublication } from './audio_stream-CTyN1Ldy.js';
-import 'node:stream/web';
-import './audio_frame.js';
-import './frame_processor.js';
-import './video_frame.js';
-import './audio_source.js';
-import './ffi_client.js';
-import '@livekit/typed-emitter';
-import './types-_PdPVish.js';
-import './e2ee.js';
-import '@livekit/mutex';
-import 'node:fs';
-import './data_streams/stream_writer.js';
-import './rpc.js';
-import './transcription.js';
-import './types.js';
-import './video_source.js';
+import type { EncryptionType } from '@livekit/rtc-ffi-bindings';
+import type { OwnedTrackPublication, TrackKind, TrackPublicationInfo, TrackSource } from '@livekit/rtc-ffi-bindings';
+import { FfiHandle } from '@livekit/rtc-ffi-bindings';
+import type { Track } from './track.js';
+export declare abstract class TrackPublication {
+    /** @internal */
+    ffiHandle: FfiHandle;
+    /** @internal */
+    info?: TrackPublicationInfo;
+    track?: Track;
+    constructor(ownedInfo: OwnedTrackPublication);
+    get sid(): string | undefined;
+    get name(): string | undefined;
+    get kind(): TrackKind | undefined;
+    get source(): TrackSource | undefined;
+    get simulcasted(): boolean | undefined;
+    get width(): number | undefined;
+    get height(): number | undefined;
+    get mimeType(): string | undefined;
+    get muted(): boolean | undefined;
+    get encryptionType(): EncryptionType | undefined;
+    /**
+     * Update the publication's info in place. Used by the SDK when the
+     * server re-issues IDs / metadata for an existing publication (e.g.
+     * after a full reconnect). Application code holding a cached
+     * publication reference continues to read fresh values via the
+     * unchanged object identity.
+     * @internal
+     */
+    updateInfo(info: TrackPublicationInfo): void;
+}
+export declare class LocalTrackPublication extends TrackPublication {
+    private firstSubscription;
+    private firstSubscriptionResolver;
+    constructor(ownedInfo: OwnedTrackPublication);
+    waitForSubscription(): Promise<void>;
+    /** @internal */
+    resolveFirstSubscription(): void;
+}
+export declare class RemoteTrackPublication extends TrackPublication {
+    subscribed: boolean;
+    constructor(ownedInfo: OwnedTrackPublication);
+    setSubscribed(subscribed: boolean): void;
+}
+//# sourceMappingURL=track_publication.d.ts.map

package/dist/transcription.d.ts

@@ -1,4 +1,4 @@
-interface TranscriptionSegment {
+export interface TranscriptionSegment {
     id: string;
     text: string;
     startTime: bigint;
@@ -6,10 +6,9 @@ interface TranscriptionSegment {
     language: string;
     final: boolean;
 }
-interface Transcription {
+export interface Transcription {
     participantIdentity: string;
     trackSid: string;
     segments: TranscriptionSegment[];
 }
-
-export type { Transcription, TranscriptionSegment };
+//# sourceMappingURL=transcription.d.ts.map

package/dist/{types-_PdPVish.d.ts → types-f7wTlFjs.d.cts}

@@ -5,9 +5,34 @@ declare abstract class BaseStreamReader<T extends BaseStreamInfo> {
     protected totalByteSize?: number;
     protected _info: T;
     protected bytesReceived: number;
+    private closed;
+    private activeReader;
     get info(): T;
     constructor(info: T, stream: ReadableStream<DataStream_Chunk>, totalByteSize?: number);
-    protected abstract handleChunkReceived(chunk: DataStream_Chunk): void;
+    protected handleChunkReceived(chunk: DataStream_Chunk): void;
+    /** Takes the stream's reader for an iteration, remembering it so that
+     * close() can cancel a read that is still in flight. */
+    protected acquireReader(): ReadableStreamDefaultReader<DataStream_Chunk>;
+    /** Releases the stream lock after an iteration ended on its own — because a
+     * read reported end-of-stream, or because the stream itself errored. Either
+     * way the stream is in a terminal state and the FFI subscription behind it
+     * was already dropped by that terminal event, so there is nothing to cancel.
+     *
+     * An error raised *around* a read rather than by it — a chunk that failed to
+     * process — leaves the stream live, so it has to go through close() instead. */
+    protected finishIteration(reader: ReadableStreamDefaultReader<DataStream_Chunk>): void;
+    /**
+     * Stops receiving this stream and releases the resources behind it.
+     *
+     * A reader is subscribed to FFI events from the moment it is handed to a
+     * stream handler, and only unsubscribes once a read consumes the stream's
+     * end-of-stream event. So a reader that is abandoned part-way through, or
+     * that a handler never reads at all, has to be closed here or its
+     * subscription lives for the rest of the process. Reading to completion — or
+     * breaking out of a `for await` — closes the reader for you, and closing an
+     * already-closed reader is a no-op.
+     */
+    close(): Promise<void>;
     onProgress?: (progress: number | undefined) => void;
     abstract readAll(): Promise<string | Array<Uint8Array>>;
 }
@@ -15,10 +40,9 @@ declare abstract class BaseStreamReader<T extends BaseStreamInfo> {
  * A class to read chunks from a ReadableStream and provide them in a structured format.
  */
 declare class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
-    protected handleChunkReceived(chunk: DataStream_Chunk): void;
     [Symbol.asyncIterator](): {
         next: () => Promise<IteratorResult<Uint8Array>>;
-        return(): IteratorResult<Uint8Array>;
+        return: () => Promise<IteratorResult<Uint8Array>>;
     };
     readAll(): Promise<Array<Uint8Array>>;
 }
@@ -26,13 +50,6 @@ declare class ByteStreamReader extends BaseStreamReader<ByteStreamInfo> {
  * A class to read chunks from a ReadableStream and provide them in a structured format.
  */
 declare class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
-    private receivedChunks;
-    /**
-     * A TextStreamReader instance can be used as an AsyncIterator that returns the entire string
-     * that has been received up to the current point in time.
-     */
-    constructor(info: TextStreamInfo, stream: ReadableStream<DataStream_Chunk>, totalChunkCount?: number);
-    protected handleChunkReceived(chunk: DataStream_Chunk): void;
     /**
      * Async iterator implementation to allow usage of `for await...of` syntax.
      * Yields structured chunks from the stream.
@@ -40,7 +57,7 @@ declare class TextStreamReader extends BaseStreamReader<TextStreamInfo> {
      */
     [Symbol.asyncIterator](): {
         next: () => Promise<IteratorResult<string>>;
-        return(): IteratorResult<string>;
+        return: () => Promise<IteratorResult<string>>;
     };
     readAll(): Promise<string>;
 }
@@ -76,6 +93,12 @@ interface TextStreamOptions extends DataStreamOptions {
 interface ByteStreamOptions extends DataStreamOptions {
     name?: string;
     onProgress?: (progress: number) => void;
+    /**
+     * Whether the payload may be compressed on the wire. Defaults to true;
+     * compression is only applied when it actually reduces the payload size
+     * and every recipient supports it.
+     */
+    compress?: boolean;
 }
 type ByteStreamHandler = (reader: ByteStreamReader, participantInfo: {
     identity: string;

package/dist/types.d.ts

@@ -1,9 +1,8 @@
-interface ChatMessage {
+export interface ChatMessage {
     id: string;
     timestamp: number;
     message: string;
     editTimestamp?: number;
     generated?: boolean;
 }
-
-export type { ChatMessage };
+//# sourceMappingURL=types.d.ts.map

package/dist/utils.cjs

@@ -19,8 +19,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   bigIntToNumber: () => bigIntToNumber,
+  byteStreamInfoFromProto: () => byteStreamInfoFromProto,
   numberToBigInt: () => numberToBigInt,
-  splitUtf8: () => splitUtf8
+  splitUtf8: () => splitUtf8,
+  textStreamInfoFromProto: () => textStreamInfoFromProto
 });
 module.exports = __toCommonJS(utils_exports);
 function bigIntToNumber(value) {
@@ -52,10 +54,33 @@ function splitUtf8(s, n) {
   }
   return result;
 }
+function textStreamInfoFromProto(info) {
+  return {
+    streamId: info.streamId,
+    mimeType: info.mimeType,
+    topic: info.topic,
+    timestamp: bigIntToNumber(info.timestamp),
+    totalSize: info.totalLength ? bigIntToNumber(info.totalLength) : void 0,
+    attributes: info.attributes
+  };
+}
+function byteStreamInfoFromProto(info) {
+  return {
+    streamId: info.streamId,
+    name: info.name ?? "unknown",
+    mimeType: info.mimeType,
+    topic: info.topic,
+    timestamp: bigIntToNumber(info.timestamp),
+    totalSize: info.totalLength !== void 0 ? bigIntToNumber(info.totalLength) : void 0,
+    attributes: info.attributes
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   bigIntToNumber,
+  byteStreamInfoFromProto,
   numberToBigInt,
-  splitUtf8
+  splitUtf8,
+  textStreamInfoFromProto
 });
 //# sourceMappingURL=utils.cjs.map