livekit-client 2.17.3 → 2.18.1

package/src/room/participant/LocalParticipant.ts

@@ -27,8 +27,13 @@ import type { InternalRoomOptions } from '../../options';
 import TypedPromise from '../../utils/TypedPromise';
 import { PCTransportState } from '../PCTransportManager';
 import type RTCEngine from '../RTCEngine';
+import { DataChannelKind } from '../RTCEngine';
 import type OutgoingDataStreamManager from '../data-stream/outgoing/OutgoingDataStreamManager';
 import type { TextStreamWriter } from '../data-stream/outgoing/StreamWriter';
+import LocalDataTrack from '../data-track/LocalDataTrack';
+import type OutgoingDataTrackManager from '../data-track/outgoing/OutgoingDataTrackManager';
+import { DataTrackPublishError } from '../data-track/outgoing/errors';
+import type { DataTrackOptions } from '../data-track/outgoing/types';
 import { defaultVideoCodec } from '../defaults';
 import {
   DeviceUnsupportedError,
@@ -150,6 +155,8 @@ export default class LocalParticipant extends Participant {
 
   private roomOutgoingDataStreamManager: OutgoingDataStreamManager;
 
+  private roomOutgoingDataTrackManager: OutgoingDataTrackManager;
+
   private pendingSignalRequests: Map<
     number,
     {
@@ -179,6 +186,7 @@ export default class LocalParticipant extends Participant {
     options: InternalRoomOptions,
     roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>,
     roomOutgoingDataStreamManager: OutgoingDataStreamManager,
+    roomOutgoingDataTrackManager: OutgoingDataTrackManager,
   ) {
     super(sid, identity, undefined, undefined, undefined, {
       loggerName: options.loggerName,
@@ -198,6 +206,7 @@ export default class LocalParticipant extends Participant {
     this.pendingSignalRequests = new Map();
     this.rpcHandlers = roomRpcHandlers;
     this.roomOutgoingDataStreamManager = roomOutgoingDataStreamManager;
+    this.roomOutgoingDataTrackManager = roomOutgoingDataTrackManager;
   }
 
   get lastCameraError(): Error | undefined {
@@ -311,6 +320,35 @@ export default class LocalParticipant extends Participant {
       }
       this.pendingSignalRequests.delete(requestId);
     }
+
+    switch (response.request.case) {
+      case 'publishDataTrack': {
+        let error;
+        switch (response.reason) {
+          case RequestResponse_Reason.NOT_ALLOWED:
+            error = DataTrackPublishError.notAllowed(response.message);
+            break;
+          case RequestResponse_Reason.DUPLICATE_NAME:
+            error = DataTrackPublishError.duplicateName(response.message);
+            break;
+          case RequestResponse_Reason.INVALID_NAME:
+            error = DataTrackPublishError.invalidName(response.message);
+            break;
+          case RequestResponse_Reason.LIMIT_EXCEEDED:
+            error = DataTrackPublishError.limitReached(response.message);
+            break;
+          default:
+            error = DataTrackPublishError.unknown(response.reason, response.message);
+            return;
+        }
+
+        this.roomOutgoingDataTrackManager.receivedSfuPublishResponse(
+          response.request.value.pubHandle,
+          { type: 'error', error },
+        );
+        break;
+      }
+    }
   };
 
   private handleDataPacket = (packet: DataPacket) => {
@@ -1648,7 +1686,8 @@ export default class LocalParticipant extends Participant {
    * @param options optionally specify a `reliable`, `topic` and `destination`
    */
   async publishData(data: Uint8Array, options: DataPublishOptions = {}): Promise<void> {
-    const kind = options.reliable ? DataPacket_Kind.RELIABLE : DataPacket_Kind.LOSSY;
+    const kind = options.reliable ? DataChannelKind.RELIABLE : DataChannelKind.LOSSY;
+    const dataPacketKind = options.reliable ? DataPacket_Kind.RELIABLE : DataPacket_Kind.LOSSY;
     const destinationIdentities = options.destinationIdentities;
     const topic = options.topic;
 
@@ -1660,7 +1699,7 @@ export default class LocalParticipant extends Participant {
     });
 
     const packet = new DataPacket({
-      kind: kind,
+      kind: dataPacketKind,
       value: {
         case: 'user',
         value: userPacket,
@@ -1688,7 +1727,7 @@ export default class LocalParticipant extends Participant {
       },
     });
 
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
   }
 
   /** @deprecated Consider migrating to {@link sendText} */
@@ -1708,7 +1747,7 @@ export default class LocalParticipant extends Participant {
         }),
       },
     });
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
 
     this.emit(ParticipantEvent.ChatMessage, msg);
     return msg;
@@ -1731,7 +1770,7 @@ export default class LocalParticipant extends Participant {
         }),
       },
     });
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
     this.emit(ParticipantEvent.ChatMessage, msg);
     return msg;
   }
@@ -1946,7 +1985,7 @@ export default class LocalParticipant extends Participant {
       },
     });
 
-    await this.engine.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+    await this.engine.sendDataPacket(packet, DataChannelKind.RELIABLE);
   }
 
   /** @internal */
@@ -2235,4 +2274,16 @@ export default class LocalParticipant extends Participant {
       await sleep(20);
     }
   }
+
+  /** Publishes a data track.
+   *
+   * Returns the published data track if successful. Use {@link LocalDataTrack#tryPush}
+   * to send data frames on the track.
+   */
+  async publishDataTrack(options: DataTrackOptions): Promise<LocalDataTrack> {
+    const track = new LocalDataTrack(options, this.roomOutgoingDataTrackManager);
+    await track.publish();
+
+    return track;
+  }
 }

package/src/room/participant/RemoteParticipant.ts

@@ -5,6 +5,8 @@ import type {
   UpdateTrackSettings,
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
+import { DeferrableMap } from '../../utils/deferrable-map';
+import type RemoteDataTrack from '../data-track/RemoteDataTrack';
 import { ParticipantEvent, TrackEvent } from '../events';
 import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import type RemoteTrack from '../track/RemoteTrack';
@@ -27,6 +29,14 @@ export default class RemoteParticipant extends Participant {
 
   trackPublications: Map<string, RemoteTrackPublication>;
 
+  /** A map of data track name to the corresponding {@link RemoteDataTrack}.
+   * @example
+   * // An already existing data track:
+   * const track = remoteParticipant.dataTracks.get("data track name");
+   * // Wait for a data track which will be published soon:
+   * const track = await remoteParticipant.dataTracks.getDeferred("data track name"); */
+  dataTracks: DeferrableMap<RemoteDataTrack['info']['name'], RemoteDataTrack>;
+
   signalClient: SignalClient;
 
   private volumeMap: Map<Track.Source, number>;
@@ -54,7 +64,7 @@ export default class RemoteParticipant extends Participant {
   protected get logContext() {
     return {
       ...super.logContext,
-      rpID: this.sid,
+      remoteParticipantID: this.sid,
       remoteParticipant: this.identity,
     };
   }
@@ -75,6 +85,7 @@ export default class RemoteParticipant extends Participant {
     this.trackPublications = new Map();
     this.audioTrackPublications = new Map();
     this.videoTrackPublications = new Map();
+    this.dataTracks = new DeferrableMap();
     this.volumeMap = new Map();
   }
 
@@ -376,6 +387,20 @@ export default class RemoteParticipant extends Participant {
     await Promise.all(promises);
   }
 
+  /** @internal */
+  addRemoteDataTrack(remoteDataTrack: RemoteDataTrack) {
+    this.dataTracks.set(remoteDataTrack.info.name, remoteDataTrack);
+  }
+
+  /** @internal */
+  removeRemoteDataTrack(remoteDataTrackSid: RemoteDataTrack['info']['sid']) {
+    for (const [name, dataTrack] of this.dataTracks.entries()) {
+      if (remoteDataTrackSid === dataTrack.info.sid) {
+        this.dataTracks.delete(name);
+      }
+    }
+  }
+
   /** @internal */
   emit<E extends keyof ParticipantEventCallbacks>(
     event: E,

package/src/room/token-source/TokenSource.ts

@@ -59,7 +59,7 @@ abstract class TokenSourceCached extends TokenSourceConfigurable {
     if (!isResponseTokenValid(this.cachedResponse)) {
       return false;
     }
-    if (this.isSameAsCachedFetchOptions(fetchOptions)) {
+    if (!this.isSameAsCachedFetchOptions(fetchOptions)) {
       return false;
     }
     return true;
@@ -72,9 +72,15 @@ abstract class TokenSourceCached extends TokenSourceConfigurable {
     return decodeTokenPayload(this.cachedResponse.participantToken);
   }
 
-  async fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject> {
+  async fetch(
+    options: TokenSourceFetchOptions,
+    force?: boolean,
+  ): Promise<TokenSourceResponseObject> {
     const unlock = await this.fetchMutex.lock();
     try {
+      if (force) {
+        this.cachedResponse = null;
+      }
       if (this.shouldReturnCachedValueFromFetch(options)) {
         return this.cachedResponse!.toJson() as TokenSourceResponseObject;
       }

package/src/room/token-source/types.ts

@@ -78,6 +78,10 @@ export type TokenSourceFetchOptions = {
  */
 export abstract class TokenSourceConfigurable {
   abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+  abstract fetch(
+    options: TokenSourceFetchOptions,
+    force?: boolean,
+  ): Promise<TokenSourceResponseObject>;
 }
 
 /** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */

package/src/room/utils.ts

@@ -5,10 +5,10 @@ import {
   DisconnectReason,
   Transcription as TranscriptionModel,
 } from '@livekit/protocol';
+import { type Throws } from '@livekit/throws-transformer/throws';
 import TypedPromise from '../utils/TypedPromise';
 import { getBrowser } from '../utils/browserParser';
 import type { BrowserDetails } from '../utils/browserParser';
-import { type Throws } from '../utils/throws';
 import { protocolVersion, version } from '../version';
 import { type ConnectionError, ConnectionErrorReason } from './errors';
 import type LocalParticipant from './participant/LocalParticipant';
@@ -775,3 +775,7 @@ export function extractMaxAgeFromRequestHeaders(headers: Headers): number | unde
   }
   return undefined;
 }
+
+export function isCompressionStreamSupported() {
+  return typeof CompressionStream !== 'undefined';
+}

package/src/utils/abort-signal-polyfill.ts

@@ -0,0 +1,63 @@
+/**
+ * Implementation of AbortSignal.any
+ * Creates a signal that will be aborted when any of the given signals is aborted.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/any
+ */
+export function abortSignalAny(signals: Array<AbortSignal>): AbortSignal {
+  // Handle empty signals array
+  if (signals.length === 0) {
+    const controller = new AbortController();
+    return controller.signal;
+  }
+
+  // Fast path for single signal
+  if (signals.length === 1) {
+    return signals[0];
+  }
+
+  // Check if any signal is already aborted
+  for (const signal of signals) {
+    if (signal.aborted) {
+      return signal;
+    }
+  }
+
+  // Create a new controller for the combined signal
+  const controller = new AbortController();
+  const unlisteners: Array<() => void> = Array(signals.length);
+
+  // Function to clean up all event listeners
+  const cleanup = () => {
+    for (const unsubscribe of unlisteners) {
+      unsubscribe();
+    }
+  };
+
+  // Add event listeners to each signal
+  signals.forEach((signal, index) => {
+    const handler = () => {
+      controller.abort(signal.reason);
+      cleanup();
+    };
+
+    signal.addEventListener('abort', handler);
+    unlisteners[index] = () => signal.removeEventListener('abort', handler);
+  });
+
+  return controller.signal;
+}
+
+/**
+ * Implementation of AbortSignal.timeout
+ * Creates a signal that will be aborted after the specified timeout.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout
+ */
+export function abortSignalTimeout(ms: number): AbortSignal {
+  const controller = new AbortController();
+
+  setTimeout(() => {
+    controller.abort(new DOMException(`signal timed out after ${ms} ms`, 'TimeoutError'));
+  }, ms);
+
+  return controller.signal;
+}

package/src/utils/deferrable-map.ts

@@ -0,0 +1,109 @@
+import { type Throws } from '@livekit/throws-transformer/throws';
+import { Future } from '../room/utils';
+
+/** An error which is thrown if a {@link DeferrableMap#getDeferred} call is aborted midway
+ * through. */
+export class DeferrableMapAbortError extends DOMException {
+  reason: unknown;
+
+  constructor(message: string, reason?: unknown) {
+    super(message, 'AbortError');
+    this.reason = reason;
+  }
+}
+
+/**
+ * A Map-like container keyed by unique strings that supports the ability to wait
+ * for future keys to show up in the map.
+ *
+ * @example
+ * // An already existing key:
+ * const value = map.get("key");
+ * // Wait for a key which will be added soon:
+ * const value = await map.getDeferred("key");
+ */
+export class DeferrableMap<K, V> extends Map<K, V> {
+  private pending: Map<K, Array<Future<V, DeferrableMapAbortError>>> = new Map();
+
+  set(key: K, value: V): this {
+    super.set(key, value);
+
+    // Resolve any futures waiting on this key.
+    const futures = this.pending.get(key);
+    if (futures) {
+      for (const future of futures) {
+        if (!future.isResolved) {
+          future.resolve?.(value);
+        }
+      }
+      this.pending.delete(key);
+    }
+
+    return this;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'WaitableMap';
+  }
+
+  /**
+   * Returns the value for `key` immediately if it exists, otherwise returns a
+   * promise that resolves once `set(key, value)` is called.
+   *
+   * If an `AbortSignal` is provided and it is aborted before the key appears,
+   * the returned promise rejects with an {@link DeferrableMapAbortError}.
+   */
+  getDeferred(key: K): Promise<V>;
+  getDeferred(key: K, signal: AbortSignal): Promise<Throws<V, DeferrableMapAbortError>>;
+  async getDeferred(key: K, signal?: AbortSignal) {
+    const existing = this.get(key);
+    if (typeof existing !== 'undefined') {
+      return existing;
+    }
+
+    // Bail out immediately if the signal is already aborted.
+    if (signal?.aborted) {
+      throw new DeferrableMapAbortError('The operation was aborted.', signal.reason);
+    }
+
+    const future = new Future<V, DeferrableMapAbortError>(undefined, () => {
+      // Clean up the pending list when the future settles.
+      const futures = this.pending.get(key);
+      if (!futures) {
+        return;
+      }
+
+      const idx = futures.indexOf(future);
+      if (idx !== -1) {
+        futures.splice(idx, 1);
+      }
+      if (futures.length === 0) {
+        this.pending.delete(key);
+      }
+    });
+
+    const existingFutures = this.pending.get(key);
+    if (existingFutures) {
+      existingFutures.push(future);
+    } else {
+      this.pending.set(key, [future]);
+    }
+
+    // If a signal was provided, listen for abort and reject the future.
+    if (signal) {
+      const onAbort = () => {
+        if (!future.isResolved) {
+          future.reject?.(new DeferrableMapAbortError('The operation was aborted.', signal.reason));
+        }
+      };
+      signal.addEventListener('abort', onAbort, { once: true });
+
+      // Clean up the listener once the future settles (resolved or rejected).
+      future.promise.finally(() => {
+        signal.removeEventListener('abort', onAbort);
+      });
+    }
+
+    return future.promise;
+  }
+}

package/src/utils/subscribeToEvents.ts

@@ -42,7 +42,11 @@ export function subscribeToEvents<
     >(eventName: EventName): Promise<EventPayload> {
       // If an event is already buffered which hasn't been processed yet, pull that off the buffer
       // and use it.
-      const earliestBufferedEvent = buffers.get(eventName)!.shift();
+      const buffer = buffers.get(eventName);
+      if (!buffer) {
+        throw new Error(`No events were buffered / received for event "${eventName.toString()}".`);
+      }
+      const earliestBufferedEvent = buffer.shift();
       if (earliestBufferedEvent) {
         return earliestBufferedEvent as EventPayload;
       }
@@ -53,6 +57,19 @@ export function subscribeToEvents<
       const nextEvent = await future.promise;
       return nextEvent as EventPayload;
     },
+    /** Are there events of the given name which are waiting to be processed? Use this to assert
+     * that no unexpected events have been emitted. */
+    areThereBufferedEvents<
+      EventPayload extends Parameters<Callbacks[EventName]>[0],
+      EventName extends EventNames = EventNames,
+    >(eventName: EventName) {
+      const buffer = buffers.get(eventName);
+      if (buffer) {
+        return buffer.length > 0;
+      } else {
+        return false;
+      }
+    },
     /** Cleanup any lingering subscriptions. */
     unsubscribe: () => {
       for (const [eventName, onEvent] of eventHandlers) {

package/dist/src/room/data-track/e2ee.d.ts

@@ -1,12 +0,0 @@
-export type EncryptedPayload = {
-    payload: Uint8Array;
-    iv: Uint8Array;
-    keyIndex: number;
-};
-export type EncryptionProvider = {
-    encrypt(payload: Uint8Array): EncryptedPayload;
-};
-export type DecryptionProvider = {
-    decrypt(payload: Uint8Array, senderIdentity: string): Uint8Array;
-};
-//# sourceMappingURL=e2ee.d.ts.map

package/dist/src/room/data-track/e2ee.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"e2ee.d.ts","sourceRoot":"","sources":["../../../../src/room/data-track/e2ee.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,UAAU,CAAC;IACpB,EAAE,EAAE,UAAU,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAE/B,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,gBAAgB,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,GAAG,UAAU,CAAC;CAClE,CAAC"}

package/dist/src/room/data-track/track.d.ts

@@ -1,30 +0,0 @@
-import type { DataTrackFrame } from './frame';
-import { type DataTrackHandle } from './handle';
-import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
-export type DataTrackSid = string;
-/** Information about a published data track. */
-export type DataTrackInfo = {
-    sid: DataTrackSid;
-    pubHandle: DataTrackHandle;
-    name: String;
-    usesE2ee: boolean;
-};
-export declare class LocalDataTrack {
-    info: DataTrackInfo;
-    protected manager: OutgoingDataTrackManager;
-    constructor(info: DataTrackInfo, manager: OutgoingDataTrackManager);
-    /** The raw descriptor from the manager containing the internal state for this local track. */
-    protected get descriptor(): import("./outgoing/OutgoingDataTrackManager").Descriptor | null;
-    isPublished(): boolean;
-    /** Try pushing a frame to subscribers of the track.
-     *
-     * Pushing a frame can fail for several reasons:
-     *
-     * - The track has been unpublished by the local participant or SFU
-     * - The room is no longer connected
-     */
-    tryPush(payload: DataTrackFrame['payload']): void & {
-        readonly __throws?: import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped> | import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | undefined;
-    };
-}
-//# sourceMappingURL=track.d.ts.map

package/dist/src/room/data-track/track.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../../../../src/room/data-track/track.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,wBAAwB,MAAM,qCAAqC,CAAC;AAEhF,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC;AAElC,gDAAgD;AAChD,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,YAAY,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,qBAAa,cAAc;IACzB,IAAI,EAAE,aAAa,CAAC;IAEpB,SAAS,CAAC,OAAO,EAAE,wBAAwB,CAAC;gBAEhC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,wBAAwB;IAKlE,8FAA8F;IAC9F,SAAS,KAAK,UAAU,oEAEvB;IAED,WAAW;IAIX;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC;;;CAS3C"}

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

@@ -1,36 +0,0 @@
-type Primitives = null | undefined | string | number | bigint | boolean | symbol;
-/**
- * Branded type that encodes possible thrown errors in the return type.
- *
- * Usage:
- *   function fetchUser(id: string): Throws<User, NetworkError | NotFoundError> { ... }
- *
- * The actual runtime value is just T - the error types are phantom types
- * that exist only for static analysis.
- *
- * To indicate that a function shouldn't throw any errors, make it return `Throws<T, never>`.
- *
- * For more info about how this is checked, see ./throws-transformer at the root of this repo.
- */
-export type Throws<T, E extends Error> = (T & {
-    readonly __throws?: E;
-}) | Extract<T, Primitives>;
-/**
- * Extract the error types from a Throws type.
- */
-export type ExtractErrors<T> = T extends Throws<any, infer E> ? E : never;
-/**
- * Extract the success type from a Throws type.
- */
-export type ExtractSuccess<T> = T extends Throws<infer S, any> ? S : T;
-/**
- * Combine error types from multiple Throws types.
- */
-export type CombineErrors<T extends any[]> = T extends [infer First, ...infer Rest] ? ExtractErrors<First> | CombineErrors<Rest> : never;
-/**
- * Helper to propagate errors - use this when your function calls other
- * throwing functions and wants to propagate their errors.
- */
-export type PropagatesErrors<T, AdditionalErrors extends Error = never> = Throws<ExtractSuccess<T>, ExtractErrors<T> | AdditionalErrors>;
-export {};
-//# sourceMappingURL=throws.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"throws.d.ts","sourceRoot":"","sources":["../../../src/utils/throws.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAEjF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAElG;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,EAAE,GAAG,MAAM,IAAI,CAAC,GAC/E,aAAa,CAAC,KAAK,CAAC,GAAG,aAAa,CAAC,IAAI,CAAC,GAC1C,KAAK,CAAC;AAEV;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,gBAAgB,SAAS,KAAK,GAAG,KAAK,IAAI,MAAM,CAC9E,cAAc,CAAC,CAAC,CAAC,EACjB,aAAa,CAAC,CAAC,CAAC,GAAG,gBAAgB,CACpC,CAAC"}

package/dist/ts4.2/room/data-track/e2ee.d.ts

@@ -1,12 +0,0 @@
-export type EncryptedPayload = {
-    payload: Uint8Array;
-    iv: Uint8Array;
-    keyIndex: number;
-};
-export type EncryptionProvider = {
-    encrypt(payload: Uint8Array): EncryptedPayload;
-};
-export type DecryptionProvider = {
-    decrypt(payload: Uint8Array, senderIdentity: string): Uint8Array;
-};
-//# sourceMappingURL=e2ee.d.ts.map

package/dist/ts4.2/room/data-track/track.d.ts

@@ -1,30 +0,0 @@
-import type { DataTrackFrame } from './frame';
-import type { DataTrackHandle } from './handle';
-import type OutgoingDataTrackManager from './outgoing/OutgoingDataTrackManager';
-export type DataTrackSid = string;
-/** Information about a published data track. */
-export type DataTrackInfo = {
-    sid: DataTrackSid;
-    pubHandle: DataTrackHandle;
-    name: String;
-    usesE2ee: boolean;
-};
-export declare class LocalDataTrack {
-    info: DataTrackInfo;
-    protected manager: OutgoingDataTrackManager;
-    constructor(info: DataTrackInfo, manager: OutgoingDataTrackManager);
-    /** The raw descriptor from the manager containing the internal state for this local track. */
-    protected get descriptor(): import("./outgoing/OutgoingDataTrackManager").Descriptor | null;
-    isPublished(): boolean;
-    /** Try pushing a frame to subscribers of the track.
-     *
-     * Pushing a frame can fail for several reasons:
-     *
-     * - The track has been unpublished by the local participant or SFU
-     * - The room is no longer connected
-     */
-    tryPush(payload: DataTrackFrame['payload']): void & {
-        readonly __throws?: import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.Dropped> | import("./outgoing/errors").DataTrackPushFrameError<import("./outgoing/errors").DataTrackPushFrameErrorReason.TrackUnpublished> | undefined;
-    };
-}
-//# sourceMappingURL=track.d.ts.map

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

@@ -1,39 +0,0 @@
-type Primitives = null | undefined | string | number | bigint | boolean | symbol;
-/**
- * Branded type that encodes possible thrown errors in the return type.
- *
- * Usage:
- *   function fetchUser(id: string): Throws<User, NetworkError | NotFoundError> { ... }
- *
- * The actual runtime value is just T - the error types are phantom types
- * that exist only for static analysis.
- *
- * To indicate that a function shouldn't throw any errors, make it return `Throws<T, never>`.
- *
- * For more info about how this is checked, see ./throws-transformer at the root of this repo.
- */
-export type Throws<T, E extends Error> = (T & {
-    readonly __throws?: E;
-}) | Extract<T, Primitives>;
-/**
- * Extract the error types from a Throws type.
- */
-export type ExtractErrors<T> = T extends Throws<any, infer E> ? E : never;
-/**
- * Extract the success type from a Throws type.
- */
-export type ExtractSuccess<T> = T extends Throws<infer S, any> ? S : T;
-/**
- * Combine error types from multiple Throws types.
- */
-export type CombineErrors<T extends any[]> = T extends [
-    infer First,
-    ...infer Rest
-] ? ExtractErrors<First> | CombineErrors<Rest> : never;
-/**
- * Helper to propagate errors - use this when your function calls other
- * throwing functions and wants to propagate their errors.
- */
-export type PropagatesErrors<T, AdditionalErrors extends Error = never> = Throws<ExtractSuccess<T>, ExtractErrors<T> | AdditionalErrors>;
-export {};
-//# sourceMappingURL=throws.d.ts.map

package/src/room/data-track/e2ee.ts

@@ -1,14 +0,0 @@
-export type EncryptedPayload = {
-  payload: Uint8Array;
-  iv: Uint8Array; // NOTE: should be 12 bytes long
-  keyIndex: number;
-};
-
-export type EncryptionProvider = {
-  // FIXME: add in explicit `Throws<..., EncryptionError>`?
-  encrypt(payload: Uint8Array): EncryptedPayload;
-};
-
-export type DecryptionProvider = {
-  decrypt(payload: Uint8Array, senderIdentity: string): Uint8Array;
-};