livekit-client 2.18.9 → 2.19.0

package/src/room/rpc/server/RpcServerManager.ts

@@ -0,0 +1,293 @@
+import { DataPacket, DataPacket_Kind, RpcAck, RpcRequest, RpcResponse } from '@livekit/protocol';
+import EventEmitter from 'events';
+import type TypedEmitter from 'typed-emitter';
+import { type StructuredLogger } from '../../../logger';
+import { CLIENT_PROTOCOL_DATA_STREAM_RPC } from '../../../version';
+import { type TextStreamReader } from '../../data-stream/incoming/StreamReader';
+import type OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
+import type Participant from '../../participant/Participant';
+import {
+  MAX_V1_PAYLOAD_BYTES,
+  RPC_RESPONSE_DATA_STREAM_TOPIC,
+  RPC_VERSION_V2,
+  RpcError,
+  type RpcInvocationData,
+  RpcRequestAttrs,
+  byteLength,
+} from '../utils';
+import type { RpcServerManagerCallbacks } from './events';
+
+/**
+ * Manages the server (handler) side of RPC: processing incoming requests,
+ * managing registered method handlers, and sending responses.
+ * @internal
+ */
+export default class RpcServerManager extends (EventEmitter as new () => TypedEmitter<RpcServerManagerCallbacks>) {
+  private log: StructuredLogger;
+
+  private outgoingDataStreamManager: OutgoingDataStreamManager;
+
+  private getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number;
+
+  private rpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>> = new Map();
+
+  constructor(
+    log: StructuredLogger,
+    outgoingDataStreamManager: OutgoingDataStreamManager,
+    getRemoteParticipantClientProtocol: (identity: Participant['identity']) => number,
+  ) {
+    super();
+    this.log = log;
+    this.outgoingDataStreamManager = outgoingDataStreamManager;
+    this.getRemoteParticipantClientProtocol = getRemoteParticipantClientProtocol;
+  }
+
+  registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>) {
+    if (this.rpcHandlers.has(method)) {
+      throw Error(
+        `RPC handler already registered for method ${method}, unregisterRpcMethod before trying to register again`,
+      );
+    }
+    this.rpcHandlers.set(method, handler);
+  }
+
+  unregisterRpcMethod(method: string) {
+    this.rpcHandlers.delete(method);
+  }
+
+  /**
+   * Handle an incoming RPCRequest message containing a payload.
+   * This handles "version 1" of rpc requests.
+   * @internal
+   */
+  async handleIncomingRpcRequest(callerIdentity: string, rpcRequest: RpcRequest) {
+    this.publishRpcAck(callerIdentity, rpcRequest.id);
+
+    if (rpcRequest.version !== 1) {
+      this.publishRpcResponsePacket(
+        callerIdentity,
+        rpcRequest.id,
+        null,
+        RpcError.builtIn('UNSUPPORTED_VERSION'),
+      );
+      return;
+    }
+
+    const handler = this.rpcHandlers.get(rpcRequest.method);
+
+    if (!handler) {
+      this.publishRpcResponsePacket(
+        callerIdentity,
+        rpcRequest.id,
+        null,
+        RpcError.builtIn('UNSUPPORTED_METHOD'),
+      );
+      return;
+    }
+
+    let response;
+    try {
+      response = await handler({
+        requestId: rpcRequest.id,
+        callerIdentity,
+        payload: rpcRequest.payload,
+        responseTimeout: rpcRequest.responseTimeoutMs,
+      });
+    } catch (error) {
+      let responseError;
+      if (error instanceof RpcError) {
+        responseError = error;
+      } else {
+        this.log.warn(
+          `Uncaught error returned by RPC handler for ${rpcRequest.method}. Returning APPLICATION_ERROR instead.`,
+          error,
+        );
+        responseError = RpcError.builtIn(
+          'APPLICATION_ERROR',
+          `Uncaught error: ${(error as Error)?.message ?? error}`,
+          { cause: error },
+        );
+      }
+
+      this.publishRpcResponsePacket(callerIdentity, rpcRequest.id, null, responseError);
+      return;
+    }
+
+    await this.publishRpcResponse(callerIdentity, rpcRequest.id, response ?? '');
+  }
+
+  /**
+   * Handle an incoming data stream containing a RPC request payload.
+   * This handles "version 2" of rpc requests.
+   * @internal
+   */
+  async handleIncomingDataStream(
+    reader: TextStreamReader,
+    callerIdentity: Participant['identity'],
+    dataStreamAttrs: Record<string, string>,
+  ) {
+    const requestId = dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_ID];
+    const method = dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_METHOD];
+    const responseTimeout = parseInt(
+      dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_RESPONSE_TIMEOUT_MS],
+      10,
+    );
+    const version = parseInt(dataStreamAttrs[RpcRequestAttrs.RPC_REQUEST_VERSION], 10);
+
+    if (!requestId || !method || Number.isNaN(responseTimeout) || Number.isNaN(version)) {
+      this.log.warn(
+        `RPC data stream malformed: ${RpcRequestAttrs.RPC_REQUEST_ID} / ${RpcRequestAttrs.RPC_REQUEST_METHOD} / ${RpcRequestAttrs.RPC_REQUEST_RESPONSE_TIMEOUT_MS} / ${RpcRequestAttrs.RPC_REQUEST_VERSION} not set.`,
+      );
+      this.publishRpcResponsePacket(
+        callerIdentity,
+        requestId,
+        null,
+        RpcError.builtIn('APPLICATION_ERROR', 'RPC data stream malformed'),
+      );
+      return;
+    }
+
+    this.publishRpcAck(callerIdentity, requestId);
+
+    if (version !== RPC_VERSION_V2) {
+      this.publishRpcResponsePacket(
+        callerIdentity,
+        requestId,
+        null,
+        RpcError.builtIn('UNSUPPORTED_VERSION'),
+      );
+      return;
+    }
+
+    let payload: string;
+    try {
+      payload = await reader.readAll();
+    } catch (e) {
+      this.log.warn(`Error reading RPC request payload: ${e}`);
+      this.publishRpcResponsePacket(
+        callerIdentity,
+        requestId,
+        null,
+        RpcError.builtIn('APPLICATION_ERROR', 'Error reading RPC request payload', { cause: e }),
+      );
+      return;
+    }
+
+    const handler = this.rpcHandlers.get(method);
+
+    if (!handler) {
+      this.publishRpcResponsePacket(
+        callerIdentity,
+        requestId,
+        null,
+        RpcError.builtIn('UNSUPPORTED_METHOD'),
+      );
+      return;
+    }
+
+    let response;
+    try {
+      response = await handler({
+        requestId,
+        callerIdentity,
+        payload,
+        responseTimeout,
+      });
+    } catch (error) {
+      let responseError;
+      if (error instanceof RpcError) {
+        responseError = error;
+      } else {
+        this.log.warn(
+          `Uncaught error returned by RPC handler for ${method}. Returning APPLICATION_ERROR instead.`,
+          error,
+        );
+        responseError = RpcError.builtIn('APPLICATION_ERROR');
+      }
+
+      this.publishRpcResponsePacket(callerIdentity, requestId, null, responseError);
+      return;
+    }
+
+    await this.publishRpcResponse(callerIdentity, requestId, response ?? '');
+  }
+
+  private publishRpcAck(destinationIdentity: string, requestId: string) {
+    this.emit('sendDataPacket', {
+      packet: new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcAck',
+          value: new RpcAck({
+            requestId,
+          }),
+        },
+      }),
+    });
+  }
+
+  private publishRpcResponsePacket(
+    destinationIdentity: string,
+    requestId: string,
+    payload: string | null,
+    error: RpcError | null,
+  ) {
+    this.emit('sendDataPacket', {
+      packet: new DataPacket({
+        destinationIdentities: [destinationIdentity],
+        kind: DataPacket_Kind.RELIABLE,
+        value: {
+          case: 'rpcResponse',
+          value: new RpcResponse({
+            requestId,
+            value: error
+              ? { case: 'error', value: error.toProto() }
+              : { case: 'payload', value: payload ?? '' },
+          }),
+        },
+      }),
+    });
+  }
+
+  /**
+   * Send a successful RPC response payload, choosing the transport based on
+   * the caller's client protocol version.
+   */
+  private async publishRpcResponse(
+    destinationIdentity: string,
+    requestId: string,
+    payload: string,
+  ) {
+    const callerClientProtocol = this.getRemoteParticipantClientProtocol(destinationIdentity);
+
+    if (callerClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
+      // Send response as a data stream
+      const writer = await this.outgoingDataStreamManager.streamText({
+        topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
+        destinationIdentities: [destinationIdentity],
+        attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
+      });
+      await writer.write(payload);
+      await writer.close();
+      return;
+    }
+
+    // Legacy client: enforce size limit and send uncompressed payload inline
+    const responseBytes = byteLength(payload);
+    if (responseBytes > MAX_V1_PAYLOAD_BYTES) {
+      this.log.warn(
+        `RPC Response payload too large for request ${requestId}. To send larger responses, consider updating the sending client.`,
+      );
+      this.publishRpcResponsePacket(
+        destinationIdentity,
+        requestId,
+        null,
+        RpcError.builtIn('RESPONSE_PAYLOAD_TOO_LARGE'),
+      );
+      return;
+    }
+
+    this.publishRpcResponsePacket(destinationIdentity, requestId, payload, null);
+  }
+}

package/src/room/rpc/server/events.ts

@@ -0,0 +1,9 @@
+import type { DataPacket } from '@livekit/protocol';
+
+export type EventSendDataPacket = {
+  packet: DataPacket;
+};
+
+export type RpcServerManagerCallbacks = {
+  sendDataPacket: (event: EventSendDataPacket) => void;
+};

package/src/room/{rpc.ts → rpc/utils.ts}

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
-//
-// SPDX-License-Identifier: Apache-2.0
 import { RpcError as RpcError_Proto } from '@livekit/protocol';
 
 /** Parameters for initiating an RPC call */
@@ -63,6 +60,9 @@ export class RpcError extends Error {
 
   data?: string;
 
+  // More info: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause
+  cause?: unknown;
+
   /**
    * Creates an error object with the given code and message, plus an optional data payload.
    *
@@ -70,11 +70,15 @@ export 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) {
+  constructor(code: number, message: string, data?: string, options?: { cause?: unknown }) {
     super(message);
     this.code = code;
     this.message = truncateBytes(message, RpcError.MAX_MESSAGE_BYTES);
     this.data = data ? truncateBytes(data, RpcError.MAX_DATA_BYTES) : undefined;
+
+    if (typeof options?.cause !== 'undefined') {
+      this.cause = options?.cause;
+    }
   }
 
   /**
@@ -133,16 +137,53 @@ export class RpcError extends Error {
    *
    * @internal
    */
-  static builtIn(key: keyof typeof RpcError.ErrorCode, data?: string): RpcError {
-    return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data);
+  static builtIn(
+    key: keyof typeof RpcError.ErrorCode,
+    data?: string,
+    options?: { cause?: unknown },
+  ): RpcError {
+    return new RpcError(RpcError.ErrorCode[key], RpcError.ErrorMessage[key], data, options);
   }
 }
 
 /*
- * Maximum payload size for RPC requests and responses. If a payload exceeds this size,
+ * Maximum payload size for RPC requests and responses for clients with a clientProtocol of less
+ * than CLIENT_PROTOCOL_DATA_STREAM_RPC.
+ *
+ * If a payload exceeds this size and the remote client does not support compression,
  * the RPC call will fail with a REQUEST_PAYLOAD_TOO_LARGE(1402) or RESPONSE_PAYLOAD_TOO_LARGE(1504) error.
  */
-export const MAX_PAYLOAD_BYTES = 15360; // 15 KB
+export const MAX_V1_PAYLOAD_BYTES = 15360; // 15 KB
+
+/**
+ * Topic used for v2 RPC request data streams.
+ * @internal
+ */
+export const RPC_REQUEST_DATA_STREAM_TOPIC = 'lk.rpc_request';
+
+/**
+ * Topic used for v2 RPC response data streams.
+ * @internal
+ */
+export const RPC_RESPONSE_DATA_STREAM_TOPIC = 'lk.rpc_response';
+
+/** @internal */
+export enum RpcRequestAttrs {
+  RPC_REQUEST_ID = 'lk.rpc_request_id',
+  RPC_REQUEST_METHOD = 'lk.rpc_request_method',
+  RPC_REQUEST_RESPONSE_TIMEOUT_MS = 'lk.rpc_request_response_timeout_ms',
+  RPC_REQUEST_VERSION = 'lk.rpc_request_version',
+}
+
+/** Initial version of rpc which uses RpcRequest / RpcResponse messages.
+ * @internal
+ **/
+export const RPC_VERSION_V1 = 1;
+
+/** Rpc version backed by data streams instead of RpcRequest / RpcResponse.
+ * @internal
+ **/
+export const RPC_VERSION_V2 = 2;
 
 /**
  * @internal

package/src/room/track/PacketTrailerExtractor.ts

@@ -0,0 +1,43 @@
+import type { PacketTrailerMetadata } from '../../packetTrailer/types';
+
+const MAX_ENTRIES = 300;
+
+/**
+ * Caches packet trailer metadata extracted from received video frames,
+ * keyed by RTP timestamp so it can be looked up when the frame is displayed.
+ *
+ * Metadata is populated either by the packet trailer worker managed by
+ * `PacketTrailerManager` (non-E2EE) or by the E2EE FrameCryptor worker
+ * after decryption (E2EE).
+ *
+ * @experimental
+ */
+export class PacketTrailerExtractor {
+  private metadataMap = new Map<number, PacketTrailerMetadata>();
+
+  private activeSsrc: number = 0;
+
+  storeMetadata(rtpTimestamp: number, ssrc: number, metadata: PacketTrailerMetadata) {
+    // Simulcast layer switch: SSRC changed, flush stale entries from old layer.
+    if (this.activeSsrc !== 0 && this.activeSsrc !== ssrc) {
+      this.metadataMap.clear();
+    }
+    this.activeSsrc = ssrc;
+
+    while (this.metadataMap.size >= MAX_ENTRIES) {
+      const evicted = this.metadataMap.keys().next().value!;
+      this.metadataMap.delete(evicted);
+    }
+
+    this.metadataMap.set(rtpTimestamp, metadata);
+  }
+
+  lookupMetadata(rtpTimestamp: number): PacketTrailerMetadata | undefined {
+    return this.metadataMap.get(rtpTimestamp);
+  }
+
+  dispose() {
+    this.metadataMap.clear();
+    this.activeSsrc = 0;
+  }
+}

package/src/room/track/RemoteVideoTrack.ts

@@ -1,3 +1,4 @@
+import type { PacketTrailerMetadata } from '../../packetTrailer/types';
 import { debounce } from '../debounce';
 import { TrackEvent } from '../events';
 import type { VideoReceiverStats } from '../stats';
@@ -6,6 +7,7 @@ import CriticalTimers from '../timers';
 import type { LoggerOptions } from '../types';
 import type { ObservableMediaElement } from '../utils';
 import { getDevicePixelRatio, getIntersectionObserver, getResizeObserver, isWeb } from '../utils';
+import type { PacketTrailerExtractor } from './PacketTrailerExtractor';
 import RemoteTrack from './RemoteTrack';
 import { Track, attachToElement, detachTrack } from './Track';
 import type { AdaptiveStreamSettings } from './types';
@@ -23,6 +25,9 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
 
   private lastDimensions?: Track.Dimensions;
 
+  /** @internal */
+  packetTrailerExtractor?: PacketTrailerExtractor;
+
   constructor(
     mediaTrack: MediaStreamTrack,
     sid: string,
@@ -38,6 +43,23 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
     return this.adaptiveStreamSettings !== undefined;
   }
 
+  /**
+   * Look up frame-level metadata for a given RTP timestamp.
+   * Use with the `TrackEvent.TimeSyncUpdate` event to correlate displayed frames
+   * with their capture-time metadata.
+   *
+   * Requires the room to be configured with the `packetTrailer` worker option
+   * and the publishing track to have packet trailer features enabled.
+   *
+   */
+  lookupFrameMetadata({
+    rtpTimestamp,
+  }: {
+    rtpTimestamp: number;
+  }): PacketTrailerMetadata | undefined {
+    return this.packetTrailerExtractor?.lookupMetadata(rtpTimestamp);
+  }
+
   override setStreamState(value: Track.StreamState) {
     super.setStreamState(value);
     this.log.debug('setStreamState', value);
@@ -140,12 +162,11 @@ export default class RemoteVideoTrack extends RemoteTrack<Track.Kind.Video> {
   detach(): HTMLMediaElement[];
   detach(element: HTMLMediaElement): HTMLMediaElement;
   detach(element?: HTMLMediaElement): HTMLMediaElement | HTMLMediaElement[] {
-    let detachedElements: HTMLMediaElement[] = [];
     if (element) {
       this.stopObservingElement(element);
       return super.detach(element);
     }
-    detachedElements = super.detach();
+    const detachedElements = super.detach();
 
     for (const e of detachedElements) {
       this.stopObservingElement(e);

package/src/room/track/Track.ts

@@ -537,6 +537,6 @@ export type TrackEventCallbacks = {
   trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
   audioTrackFeatureUpdate: (track: any, feature: AudioTrackFeature, enabled: boolean) => void;
   timeSyncUpdate: (update: { timestamp: number; rtpTimestamp: number }) => void;
-  preConnectBufferFlushed: (buffer: Uint8Array[]) => void;
+  preConnectBufferFlushed: (buffer: NonSharedUint8Array[]) => void;
   cpuConstrained: () => void;
 };

package/src/room/track/create.ts

@@ -111,10 +111,6 @@ export async function createLocalTracks(
     return await Promise.all(
       stream.getTracks().map(async (mediaStreamTrack) => {
         const isAudio = mediaStreamTrack.kind === 'audio';
-        let trackOptions = isAudio ? opts!.audio : opts!.video;
-        if (typeof trackOptions === 'boolean' || !trackOptions) {
-          trackOptions = {};
-        }
         let trackConstraints: MediaTrackConstraints | undefined;
         const conOrBool = isAudio ? constraints.audio : constraints.video;
         if (typeof conOrBool !== 'boolean') {

package/src/room/track/options.ts

@@ -1,3 +1,4 @@
+import type { PacketTrailerPublishOptions } from '../../packetTrailer/types';
 import type { Track } from './Track';
 import type {
   AudioProcessorOptions,
@@ -128,6 +129,16 @@ export interface TrackPublishDefaults {
    * Defaults to false.
    */
   preConnectBuffer?: boolean;
+
+  /**
+   * Packet trailer metadata to append to published video frames.
+   *
+   * Requires either room-level packet trailer worker configuration or E2EE,
+   * because encoded frame transforms are used to write the trailer.
+   *
+   * @experimental
+   */
+  packetTrailer?: PacketTrailerPublishOptions;
 }
 
 /**

package/src/room/track/record.ts

@@ -51,7 +51,7 @@ export class LocalTrackRecorder<T extends LocalTrack> extends RecorderBase {
       start: (controller) => {
         streamController = controller;
         dataListener = async (event: BlobEvent) => {
-          let data: Uint8Array;
+          let data: NonSharedUint8Array;
 
           if (event.data.arrayBuffer) {
             const arrayBuffer = await event.data.arrayBuffer();

package/src/room/track/utils.ts

@@ -280,7 +280,10 @@ export function getLogContextFromTrack(track: Track | TrackPublication): Record<
 }
 
 export function supportsSynchronizationSources(): boolean {
-  return typeof RTCRtpReceiver !== 'undefined' && 'getSynchronizationSources' in RTCRtpReceiver;
+  return (
+    typeof RTCRtpReceiver !== 'undefined' &&
+    typeof RTCRtpReceiver.prototype.getSynchronizationSources === 'function'
+  );
 }
 
 export function diffAttributes(

package/src/room/utils.test.ts

@@ -1,5 +1,6 @@
+import { ClientInfo_Capability } from '@livekit/protocol';
 import { describe, expect, it } from 'vitest';
-import { extractMaxAgeFromRequestHeaders, splitUtf8, toWebsocketUrl } from './utils';
+import { extractMaxAgeFromRequestHeaders, getClientInfo, splitUtf8, toWebsocketUrl } from './utils';
 
 describe('toWebsocketUrl', () => {
   it('leaves wss urls alone', () => {
@@ -15,6 +16,18 @@ describe('toWebsocketUrl', () => {
   });
 });
 
+describe('getClientInfo', () => {
+  it('does not advertise packet trailer capability by default', () => {
+    expect(getClientInfo().capabilities).toEqual([]);
+  });
+
+  it('advertises packet trailer capability when provided', () => {
+    expect(getClientInfo([ClientInfo_Capability.CAP_PACKET_TRAILER]).capabilities).toEqual([
+      ClientInfo_Capability.CAP_PACKET_TRAILER,
+    ]);
+  });
+});
+
 describe('splitUtf8', () => {
   it('splits a string into chunks of the given size', () => {
     expect(splitUtf8('hello world', 5)).toEqual([

package/src/room/utils.ts

@@ -1,6 +1,7 @@
 import {
   ChatMessage as ChatMessageModel,
   ClientInfo,
+  ClientInfo_Capability,
   ClientInfo_SDK,
   DisconnectReason,
   Transcription as TranscriptionModel,
@@ -9,7 +10,7 @@ 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 { protocolVersion, version } from '../version';
+import { clientProtocol, protocolVersion, version } from '../version';
 import { type ConnectionError, ConnectionErrorReason } from './errors';
 import type LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';
@@ -179,6 +180,18 @@ export function isChromiumBased(): boolean {
   return !!browser && browser.name === 'Chrome' && browser.os !== 'iOS';
 }
 
+export function isScriptTransformSupportedForWorker(): boolean {
+  // Chrome occasionally throws an `InvalidState` error when using script transforms directly after introducing this API in 141.
+  // Disabling it for Chrome based browsers until the API has stabilized.
+  // @ts-ignore
+  return (
+    typeof window !== 'undefined' &&
+    // @ts-ignore
+    typeof window.RTCRtpScriptTransform !== 'undefined' &&
+    !isChromiumBased()
+  );
+}
+
 export function isSafari(): boolean {
   return getBrowser()?.name === 'Safari';
 }
@@ -364,10 +377,12 @@ export interface ObservableMediaElement extends HTMLMediaElement {
   handleVisibilityChanged: (entry: IntersectionObserverEntry) => void;
 }
 
-export function getClientInfo(): ClientInfo {
+export function getClientInfo(capabilities?: ClientInfo_Capability[]): ClientInfo {
   const info = new ClientInfo({
+    capabilities,
     sdk: ClientInfo_SDK.JS,
     protocol: protocolVersion,
+    clientProtocol,
     version,
   });
 
@@ -740,12 +755,12 @@ export function isRemoteParticipant(p: Participant): p is RemoteParticipant {
   return !p.isLocal;
 }
 
-export function splitUtf8(s: string, n: number): Uint8Array[] {
+export function splitUtf8(s: string, n: number): NonSharedUint8Array[] {
   if (n < 4) {
     throw new Error('n must be at least 4 due to utf8 encoding rules');
   }
   // adapted from https://stackoverflow.com/a/6043797
-  const result: Uint8Array[] = [];
+  const result: NonSharedUint8Array[] = [];
   let encoded = new TextEncoder().encode(s);
   while (encoded.length > n) {
     let k = n;

package/src/test/MockMediaStreamTrack.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 // @ts-ignore
 export default class MockMediaStreamTrack implements MediaStreamTrack {
   contentHint: string = '';

package/src/type-polyfills/non-shared-typed-arrays.d.ts

@@ -0,0 +1,6 @@
+// As of TS 5.7, `Uint8Array` is generic over its backing buffer (`Uint8Array<ArrayBufferLike>`),
+// which includes `SharedArrayBuffer`. Many Web APIs (WebCrypto, structured clone, RTCDataChannel)
+// only accept the non-shared variant `Uint8Array<ArrayBuffer>`. Using `ReturnType<typeof Uint8Array.from>`
+// resolves to that non-shared variant on TS versions that support the generic, while remaining
+// equivalent to plain `Uint8Array` on older versions — so this alias works across the range we support.
+type NonSharedUint8Array = ReturnType<typeof Uint8Array.from>;

package/src/utils/dataPacketBuffer.ts

@@ -1,5 +1,5 @@
 export interface DataPacketItem {
-  data: Uint8Array;
+  data: NonSharedUint8Array;
   sequence: number;
 }