livekit-client 2.15.7 → 2.15.8

package/dist/ts4.2/{src/room → room}/errors.d.ts

@@ -52,7 +52,8 @@ export declare enum DataStreamErrorReason {
     DecodeFailed = 2,
     LengthExceeded = 3,
     Incomplete = 4,
-    HandlerAlreadyRegistered = 7
+    HandlerAlreadyRegistered = 7,
+    EncryptionTypeMismatch = 8
 }
 export declare class DataStreamError extends LivekitError {
     reason: DataStreamErrorReason;

package/dist/ts4.2/{src/room → room}/participant/Participant.d.ts

@@ -1,5 +1,5 @@
 import type { SipDTMF } from '@livekit/protocol';
-import { DataPacket_Kind, ParticipantInfo, ParticipantInfo_Kind as ParticipantKind, ParticipantPermission, ConnectionQuality as ProtoQuality, SubscriptionError } from '@livekit/protocol';
+import { DataPacket_Kind, Encryption_Type, ParticipantInfo, ParticipantInfo_Kind as ParticipantKind, ParticipantPermission, ConnectionQuality as ProtoQuality, SubscriptionError } from '@livekit/protocol';
 import type TypedEmitter from 'typed-emitter';
 import type { StructuredLogger } from '../../logger';
 import type LocalTrackPublication from '../track/LocalTrackPublication';
@@ -124,7 +124,7 @@ export type ParticipantEventCallbacks = {
     localSenderCreated: (sender: RTCRtpSender, track: Track) => void;
     participantMetadataChanged: (prevMetadata: string | undefined, participant?: any) => void;
     participantNameChanged: (name: string) => void;
-    dataReceived: (payload: Uint8Array, kind: DataPacket_Kind) => void;
+    dataReceived: (payload: Uint8Array, kind: DataPacket_Kind, encryptionType?: Encryption_Type) => void;
     sipDTMFReceived: (dtmf: SipDTMF) => void;
     transcriptionReceived: (transcription: TranscriptionSegment[], publication?: TrackPublication) => void;
     isSpeakingChanged: (speaking: boolean) => void;

package/dist/ts4.2/room/token-source/TokenSource.d.ts

@@ -0,0 +1,71 @@
+import { TokenSourceResponse } from '@livekit/protocol';
+import type { TokenSourceFetchOptions, TokenSourceResponseObject } from './types';
+import { TokenSourceConfigurable, TokenSourceFixed } from './types';
+/** A TokenSourceCached is a TokenSource which caches the last {@link TokenSourceResponseObject} value and returns it
+ * until a) it expires or b) the {@link TokenSourceFetchOptions} provided to .fetch(...) change. */
+declare abstract class TokenSourceCached extends TokenSourceConfigurable {
+    private cachedFetchOptions;
+    private cachedResponse;
+    private fetchMutex;
+    private isSameAsCachedFetchOptions;
+    private shouldReturnCachedValueFromFetch;
+    getCachedResponseJwtPayload(): import("./types").TokenPayload | null;
+    fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+    protected abstract update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+type LiteralOrFn = TokenSourceResponseObject | (() => TokenSourceResponseObject | Promise<TokenSourceResponseObject>);
+export declare class TokenSourceLiteral extends TokenSourceFixed {
+    private literalOrFn;
+    constructor(literalOrFn: LiteralOrFn);
+    fetch(): Promise<TokenSourceResponseObject>;
+}
+type CustomFn = (options: TokenSourceFetchOptions) => TokenSourceResponseObject | Promise<TokenSourceResponseObject>;
+export declare class TokenSourceCustom extends TokenSourceCached {
+    private customFn;
+    constructor(customFn: CustomFn);
+    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+export type EndpointOptions = Omit<RequestInit, 'body'>;
+export declare class TokenSourceEndpoint extends TokenSourceCached {
+    private url;
+    private endpointOptions;
+    constructor(url: string, options?: EndpointOptions);
+    private createRequestFromOptions;
+    protected update(options: TokenSourceFetchOptions): Promise<TokenSourceResponse>;
+}
+export type SandboxTokenServerOptions = {
+    baseUrl?: string;
+};
+export declare class TokenSourceSandboxTokenServer extends TokenSourceEndpoint {
+    constructor(sandboxId: string, options: SandboxTokenServerOptions);
+}
+export declare const TokenSource: {
+    /** TokenSource.literal contains a single, literal set of {@link TokenSourceResponseObject}
+     * credentials, either provided directly or returned from a provided function. */
+    literal(literalOrFn: LiteralOrFn): TokenSourceLiteral;
+    /**
+     * TokenSource.custom allows a user to define a manual function which generates new
+     * {@link TokenSourceResponseObject} values on demand.
+     *
+     * Use this to get credentials from custom backends / etc.
+     */
+    custom(customFn: CustomFn): TokenSourceCustom;
+    /**
+     * TokenSource.endpoint creates a token source that fetches credentials from a given URL using
+     * the standard endpoint format:
+     * FIXME: add docs link here in the future!
+     */
+    endpoint(url: string, options?: EndpointOptions): TokenSourceEndpoint;
+    /**
+     * TokenSource.sandboxTokenServer queries a sandbox token server for credentials,
+     * which supports quick prototyping / getting started types of use cases.
+     *
+     * This token provider is INSECURE and should NOT be used in production.
+     *
+     * For more info:
+     * @see https://cloud.livekit.io/projects/p_/sandbox/templates/token-server
+     */
+    sandboxTokenServer(sandboxId: string, options?: SandboxTokenServerOptions): TokenSourceSandboxTokenServer;
+};
+export {};
+//# sourceMappingURL=TokenSource.d.ts.map

package/dist/ts4.2/room/token-source/types.d.ts

@@ -0,0 +1,68 @@
+import { RoomConfiguration, TokenSourceRequest, TokenSourceResponse } from '@livekit/protocol';
+import type { JWTPayload } from 'jose';
+import type { ValueToSnakeCase } from '../../utils/camelToSnakeCase';
+export type TokenSourceRequestObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceRequest>[0]>>;
+export type TokenSourceResponseObject = Required<NonNullable<ConstructorParameters<typeof TokenSourceResponse>[0]>>;
+/** The `TokenSource` request object sent to the server as part of fetching a configurable
+ * `TokenSource` like {@link TokenSourceEndpoint}.
+ *
+ * Use this as a type for your request body if implementing a server endpoint in node.js.
+ */
+export type TokenSourceRequestPayload = ValueToSnakeCase<TokenSourceRequestObject>;
+/** The `TokenSource` response object sent from the server as part of fetching a configurable
+ * `TokenSource` like {@link TokenSourceEndpoint}.
+ *
+ * Use this as a type for your response body if implementing a server endpoint in node.js.
+ */
+export type TokenSourceResponsePayload = ValueToSnakeCase<TokenSourceResponseObject>;
+/** The payload of a LiveKit JWT token. */
+export type TokenPayload = JWTPayload & {
+    name?: string;
+    metadata?: string;
+    attributes?: Record<string, string>;
+    video?: {
+        room?: string;
+        roomJoin?: boolean;
+        canPublish?: boolean;
+        canPublishData?: boolean;
+        canSubscribe?: boolean;
+    };
+    roomConfig?: RoomConfigurationObject;
+};
+export type RoomConfigurationObject = NonNullable<ConstructorParameters<typeof RoomConfiguration>[0]>;
+/** A Fixed TokenSource is a token source that takes no parameters and returns a completely
+ * independently derived value on each fetch() call.
+ *
+ * The most common downstream implementer is {@link TokenSourceLiteral}.
+ */
+export declare abstract class TokenSourceFixed {
+    abstract fetch(): Promise<TokenSourceResponseObject>;
+}
+export type TokenSourceFetchOptions = {
+    roomName?: string;
+    participantName?: string;
+    participantIdentity?: string;
+    participantMetadata?: string;
+    participantAttributes?: {
+        [key: string]: string;
+    };
+    agentName?: string;
+    agentMetadata?: string;
+};
+/** A Configurable TokenSource is a token source that takes a
+ * {@link TokenSourceFetchOptions} object as input and returns a deterministic
+ * {@link TokenSourceResponseObject} output based on the options specified.
+ *
+ * For example, if options.participantName is set, it should be expected that
+ * all tokens that are generated will have participant name field set to the
+ * provided value.
+ *
+ * A few common downstream implementers are {@link TokenSourceEndpoint}
+ * and {@link TokenSourceCustom}.
+ */
+export declare abstract class TokenSourceConfigurable {
+    abstract fetch(options: TokenSourceFetchOptions): Promise<TokenSourceResponseObject>;
+}
+/** A TokenSource is a mechanism for fetching credentials required to connect to a LiveKit Room. */
+export type TokenSourceBase = TokenSourceFixed | TokenSourceConfigurable;
+//# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/room/token-source/utils.d.ts

@@ -0,0 +1,5 @@
+import type { TokenSourceResponse } from '@livekit/protocol';
+import type { TokenPayload } from './types';
+export declare function isResponseExpired(response: TokenSourceResponse): boolean;
+export declare function decodeTokenPayload(token: string): TokenPayload;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/{src/room → room}/track/LocalTrack.d.ts

@@ -114,7 +114,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     /** @internal */
     stopPreConnectBuffer(): void;
     /** @internal */
-    getPreConnectBuffer(): ReadableStream<Uint8Array<ArrayBufferLike>> | undefined;
+    getPreConnectBuffer(): ReadableStream<Uint8Array> | undefined;
     getPreConnectBufferMimeType(): string | undefined;
     protected abstract monitorSender(): void;
 }

package/dist/ts4.2/{src/room → room}/track/options.d.ts

@@ -291,7 +291,12 @@ export interface AudioPreset {
     maxBitrate: number;
     priority?: RTCPriorityType;
 }
-declare const backupCodecs: readonly [
+export declare const audioCodecs: readonly [
+    "opus",
+    "red"
+];
+export type AudioCodec = (typeof audioCodecs)[number];
+declare const backupVideoCodecs: readonly [
     "vp8",
     "h264"
 ];
@@ -303,8 +308,10 @@ export declare const videoCodecs: readonly [
     "h265"
 ];
 export type VideoCodec = (typeof videoCodecs)[number];
-export type BackupVideoCodec = (typeof backupCodecs)[number];
-export declare function isBackupCodec(codec: string): codec is BackupVideoCodec;
+export type BackupVideoCodec = (typeof backupVideoCodecs)[number];
+export declare function isBackupVideoCodec(codec: string): codec is BackupVideoCodec;
+/** @deprecated Use {@link isBackupVideoCodec} instead */
+export declare const isBackupCodec: typeof isBackupVideoCodec;
 export declare enum BackupCodecPolicy {
     PREFER_REGRESSION = 0,
     SIMULCAST = 1,

package/dist/ts4.2/{src/room → room}/types.d.ts

@@ -101,6 +101,7 @@ export interface BaseStreamInfo {
     /** total size in bytes for finite streams and undefined for streams of unknown size */
     size?: number;
     attributes?: Record<string, string>;
+    encryptionType: Encryption_Type;
 }
 export interface ByteStreamInfo extends BaseStreamInfo {
     name: string;

package/dist/ts4.2/{src/room → room}/utils.d.ts

@@ -14,7 +14,7 @@ import type RemoteTrackPublication from './track/RemoteTrackPublication';
 import type RemoteVideoTrack from './track/RemoteVideoTrack';
 import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
-import type { VideoCodec } from './track/options';
+import type { AudioCodec, VideoCodec } from './track/options';
 import type { ChatMessage, TranscriptionSegment } from './types';
 export declare const ddExtensionURI = "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension";
 export declare function unpackStreamId(packed: string): string[];
@@ -106,6 +106,7 @@ export declare function createAudioAnalyser(track: LocalAudioTrack | RemoteAudio
     analyser: AnalyserNode;
     cleanup: () => Promise<void>;
 };
+export declare function isAudioCodec(maybeCodec: string): maybeCodec is AudioCodec;
 export declare function isVideoCodec(maybeCodec: string): maybeCodec is VideoCodec;
 export declare function unwrapConstraint(constraint: ConstrainDOMString): string;
 export declare function unwrapConstraint(constraint: ConstrainULong): number;

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

@@ -0,0 +1,8 @@
+export type CamelToSnakeCase<Str extends string> = Str extends `${infer First}${infer Rest}` ? `${First extends Capitalize<First> ? '_' : ''}${Lowercase<First>}${CamelToSnakeCase<Rest>}` : Str;
+type ArrayValuesToSnakeCase<Item> = Array<ValueToSnakeCase<Item>>;
+type ObjectKeysToSnakeCase<Obj> = {
+    [Key in keyof Obj as CamelToSnakeCase<string & Key>]: NonNullable<ValueToSnakeCase<Obj[Key]>>;
+};
+export type ValueToSnakeCase<Value> = Value extends Array<infer Item> ? ArrayValuesToSnakeCase<Item> : Value extends object ? ObjectKeysToSnakeCase<Value> : Value;
+export {};
+//# sourceMappingURL=camelToSnakeCase.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.15.7",
+  "version": "2.15.8",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -25,10 +25,10 @@
   "typesVersions": {
     "<4.8": {
       "./dist/src/index.d.ts": [
-        "./dist/ts4.2/src/index.d.ts"
+        "./dist/ts4.2/index.d.ts"
       ],
       "./dist/src/e2ee/worker/e2ee.worker.d.ts": [
-        "./dist/ts4.2/dist/src/e2ee/worker/e2ee.worker.d.ts"
+        "./dist/ts4.2/e2ee/worker/e2ee.worker.d.ts"
       ]
     }
   },
@@ -37,8 +37,9 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@livekit/mutex": "1.1.1",
-    "@livekit/protocol": "1.39.3",
+    "@livekit/protocol": "1.42.0",
     "events": "^3.3.0",
+    "jose": "^6.1.0",
     "loglevel": "^1.9.2",
     "sdp-transform": "^2.15.0",
     "ts-debounce": "^4.0.0",
@@ -50,10 +51,10 @@
     "@types/dom-mediacapture-record": "^1"
   },
   "devDependencies": {
-    "@babel/core": "7.28.3",
+    "@babel/core": "7.28.4",
     "@babel/preset-env": "7.28.3",
     "@bufbuild/protoc-gen-es": "^1.10.0",
-    "@changesets/cli": "2.29.5",
+    "@changesets/cli": "2.29.7",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.0.4",
     "@rollup/plugin-commonjs": "28.0.6",
@@ -78,14 +79,14 @@
     "happy-dom": "^17.2.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
-    "rollup": "4.46.2",
+    "rollup": "4.52.3",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
-    "typedoc": "0.28.10",
+    "typedoc": "0.28.13",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
-    "vite": "7.1.2",
+    "vite": "7.1.8",
     "vitest": "^3.0.0"
   },
   "scripts": {
@@ -103,7 +104,7 @@
     "format": "prettier --write src examples/**/*.ts",
     "format:check": "prettier --check src examples/**/*.ts",
     "ci:publish": "pnpm build:clean && pnpm compat && changeset publish",
-    "downlevel-dts": "downlevel-dts ./dist/ ./dist/ts4.2 --to=4.2",
+    "downlevel-dts": "downlevel-dts ./dist/src ./dist/ts4.2 --to=4.2",
     "compat": "eslint --no-eslintrc --config ./.eslintrc.dist.cjs ./dist/livekit-client.umd.js",
     "size-limit": "size-limit"
   }

package/src/connectionHelper/checks/publishVideo.ts

@@ -46,6 +46,11 @@ export class PublishVideoCheck extends Checker {
     const video = document.createElement('video');
     video.srcObject = stream;
     video.muted = true;
+    video.autoplay = true;
+    video.playsInline = true;
+    // For iOS Safari
+    video.setAttribute('playsinline', 'true');
+    document.body.appendChild(video);
 
     await new Promise<void>((resolve) => {
       video.onplay = () => {

package/src/e2ee/E2eeManager.ts

@@ -11,15 +11,19 @@ import type RemoteTrack from '../room/track/RemoteTrack';
 import type { Track } from '../room/track/Track';
 import type { VideoCodec } from '../room/track/options';
 import { mimeTypeToVideoCodecString } from '../room/track/utils';
-import { isLocalTrack, isSafariBased, isVideoTrack } from '../room/utils';
+import { Future, isLocalTrack, isSafariBased, isVideoTrack } from '../room/utils';
 import type { BaseKeyProvider } from './KeyProvider';
 import { E2EE_FLAG } from './constants';
 import { type E2EEManagerCallbacks, EncryptionEvent, KeyProviderEvent } from './events';
 import type {
+  DecryptDataRequestMessage,
+  DecryptDataResponseMessage,
   E2EEManagerOptions,
   E2EEWorkerMessage,
   EnableMessage,
   EncodeMessage,
+  EncryptDataRequestMessage,
+  EncryptDataResponseMessage,
   InitMessage,
   KeyInfo,
   RTPVideoMapMessage,
@@ -35,8 +39,17 @@ import { isE2EESupported, isScriptTransformSupported } from './utils';
 export interface BaseE2EEManager {
   setup(room: Room): void;
   setupEngine(engine: RTCEngine): void;
+  isEnabled: boolean;
+  isDataChannelEncryptionEnabled: boolean;
   setParticipantCryptorEnabled(enabled: boolean, participantIdentity: string): void;
   setSifTrailer(trailer: Uint8Array): void;
+  encryptData(data: Uint8Array): Promise<EncryptDataResponseMessage['data']>;
+  handleEncryptedData(
+    payload: Uint8Array,
+    iv: Uint8Array,
+    participantIdentity: string,
+    keyIndex: number,
+  ): Promise<DecryptDataResponseMessage['data']>;
   on<E extends keyof E2EEManagerCallbacks>(event: E, listener: E2EEManagerCallbacks[E]): this;
 }
 
@@ -55,11 +68,26 @@ export class E2EEManager
 
   private keyProvider: BaseKeyProvider;
 
-  constructor(options: E2EEManagerOptions) {
+  private decryptDataRequests: Map<string, Future<DecryptDataResponseMessage['data']>> = new Map();
+
+  private encryptDataRequests: Map<string, Future<EncryptDataResponseMessage['data']>> = new Map();
+
+  private dataChannelEncryptionEnabled: boolean;
+
+  constructor(options: E2EEManagerOptions, dcEncryptionEnabled: boolean) {
     super();
     this.keyProvider = options.keyProvider;
     this.worker = options.worker;
     this.encryptionEnabled = false;
+    this.dataChannelEncryptionEnabled = dcEncryptionEnabled;
+  }
+
+  get isEnabled(): boolean {
+    return this.encryptionEnabled;
+  }
+
+  get isDataChannelEncryptionEnabled(): boolean {
+    return this.isEnabled && this.dataChannelEncryptionEnabled;
   }
 
   /**
@@ -160,6 +188,19 @@ export class E2EEManager
           data.keyIndex,
         );
         break;
+
+      case 'decryptDataResponse':
+        const decryptFuture = this.decryptDataRequests.get(data.uuid);
+        if (decryptFuture?.resolve) {
+          decryptFuture.resolve(data);
+        }
+        break;
+      case 'encryptDataResponse':
+        const encryptFuture = this.encryptDataRequests.get(data.uuid);
+        if (encryptFuture?.resolve) {
+          encryptFuture.resolve(data as EncryptDataResponseMessage['data']);
+        }
+        break;
       default:
         break;
     }
@@ -250,6 +291,57 @@ export class E2EEManager
       );
   }
 
+  async encryptData(data: Uint8Array): Promise<EncryptDataResponseMessage['data']> {
+    if (!this.worker) {
+      throw Error('could not encrypt data, worker is missing');
+    }
+    const uuid = crypto.randomUUID();
+    const msg: EncryptDataRequestMessage = {
+      kind: 'encryptDataRequest',
+      data: {
+        uuid,
+        payload: data,
+        participantIdentity: this.room!.localParticipant.identity,
+      },
+    };
+    const future = new Future<EncryptDataResponseMessage['data']>();
+    future.onFinally = () => {
+      this.encryptDataRequests.delete(uuid);
+    };
+    this.encryptDataRequests.set(uuid, future);
+    this.worker.postMessage(msg);
+    return future!.promise!;
+  }
+
+  handleEncryptedData(
+    payload: Uint8Array,
+    iv: Uint8Array,
+    participantIdentity: string,
+    keyIndex: number,
+  ) {
+    if (!this.worker) {
+      throw Error('could not handle encrypted data, worker is missing');
+    }
+    const uuid = crypto.randomUUID();
+    const msg: DecryptDataRequestMessage = {
+      kind: 'decryptDataRequest',
+      data: {
+        uuid,
+        payload,
+        iv,
+        participantIdentity,
+        keyIndex,
+      },
+    };
+    const future = new Future<DecryptDataResponseMessage['data']>();
+    future.onFinally = () => {
+      this.decryptDataRequests.delete(uuid);
+    };
+    this.decryptDataRequests.set(uuid, future);
+    this.worker.postMessage(msg);
+    return future.promise;
+  }
+
   private postRatchetRequest(participantIdentity?: string, keyIndex?: number) {
     if (!this.worker) {
       throw Error('could not ratchet key, worker is missing');

package/src/e2ee/types.ts

@@ -109,6 +109,44 @@ export interface InitAck extends BaseMessage {
   };
 }
 
+export interface DecryptDataRequestMessage extends BaseMessage {
+  kind: 'decryptDataRequest';
+  data: {
+    uuid: string;
+    payload: Uint8Array;
+    iv: Uint8Array;
+    participantIdentity: string;
+    keyIndex: number;
+  };
+}
+
+export interface DecryptDataResponseMessage extends BaseMessage {
+  kind: 'decryptDataResponse';
+  data: {
+    uuid: string;
+    payload: Uint8Array;
+  };
+}
+
+export interface EncryptDataRequestMessage extends BaseMessage {
+  kind: 'encryptDataRequest';
+  data: {
+    uuid: string;
+    payload: Uint8Array;
+    participantIdentity: string;
+  };
+}
+
+export interface EncryptDataResponseMessage extends BaseMessage {
+  kind: 'encryptDataResponse';
+  data: {
+    uuid: string;
+    payload: Uint8Array;
+    iv: Uint8Array;
+    keyIndex: number;
+  };
+}
+
 export type E2EEWorkerMessage =
   | InitMessage
   | SetKeyMessage
@@ -121,7 +159,11 @@ export type E2EEWorkerMessage =
   | RatchetRequestMessage
   | RatchetMessage
   | SifTrailerMessage
-  | InitAck;
+  | InitAck
+  | DecryptDataRequestMessage
+  | DecryptDataResponseMessage
+  | EncryptDataRequestMessage
+  | EncryptDataResponseMessage;
 
 export type KeySet = { material: CryptoKey; encryptionKey: CryptoKey };
 
@@ -150,6 +192,7 @@ export type E2EEManagerOptions = {
   keyProvider: BaseKeyProvider;
   worker: Worker;
 };
+
 export type E2EEOptions =
   | E2EEManagerOptions
   | {

package/src/e2ee/utils.ts

@@ -1,3 +1,4 @@
+import { type DataPacket, EncryptedPacketPayload } from '@livekit/protocol';
 import { ENCRYPTION_ALGORITHM } from './constants';
 
 export function isE2EESupported() {
@@ -176,3 +177,18 @@ export function writeRbsp(data_in: Uint8Array): Uint8Array {
   }
   return new Uint8Array(dataOut);
 }
+
+export function asEncryptablePacket(packet: DataPacket): EncryptedPacketPayload | undefined {
+  if (
+    packet.value?.case !== 'sipDtmf' &&
+    packet.value?.case !== 'metrics' &&
+    packet.value?.case !== 'speaker' &&
+    packet.value?.case !== 'transcription' &&
+    packet.value?.case !== 'encryptedPacket'
+  ) {
+    return new EncryptedPacketPayload({
+      value: packet.value,
+    });
+  }
+  return undefined;
+}