livekit-client 2.17.0 → 2.17.2

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

@@ -0,0 +1,98 @@
+import type { Throws } from '../../../utils/throws';
+import { DataTrackHandle } from '../handle';
+import { DataTrackTimestamp, U16_MAX_SIZE, WrapAroundUnsignedInt } from '../utils';
+import type { DataTrackDeserializeErrorAll, DataTrackSerializeErrorAll } from './errors';
+import { DataTrackSerializeError, DataTrackSerializeErrorReason } from './errors';
+import { DataTrackExtensions } from './extensions';
+import Serializable from './serializable';
+/** A class for serializing / deserializing data track packet header sections. */
+export declare class DataTrackPacketHeader extends Serializable {
+    marker: FrameMarker;
+    trackHandle: DataTrackHandle;
+    sequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+    frameNumber: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+    timestamp: DataTrackTimestamp<90000>;
+    extensions: DataTrackExtensions;
+    constructor(opts: {
+        marker: FrameMarker;
+        trackHandle: DataTrackHandle;
+        sequence: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+        frameNumber: WrapAroundUnsignedInt<typeof U16_MAX_SIZE>;
+        timestamp: DataTrackTimestamp<90000>;
+        extensions?: DataTrackExtensions;
+    });
+    private extensionsMetrics;
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeError<DataTrackSerializeErrorReason.TooSmallForHeader>>;
+    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
+        header: DataTrackPacketHeader,
+        byteLength: number
+    ], DataTrackDeserializeErrorAll>;
+    toJSON(): {
+        marker: FrameMarker;
+        trackHandle: number;
+        sequence: number;
+        frameNumber: number;
+        timestamp: number;
+        extensions: {
+            userTimestamp: {
+                tag: number;
+                lengthBytes: number;
+                timestamp: bigint;
+            } | null;
+            e2ee: {
+                tag: number;
+                lengthBytes: number;
+                keyIndex: number;
+                iv: Uint8Array<ArrayBufferLike>;
+            } | null;
+        };
+    };
+}
+/** Marker indicating a packet's position in relation to a frame. */
+export declare enum FrameMarker {
+    /** Packet is the first in a frame. */
+    Start = 0,
+    /** Packet is within a frame. */
+    Inter = 1,
+    /** Packet is the last in a frame. */
+    Final = 2,
+    /** Packet is the only one in a frame. */
+    Single = 3
+}
+/** A class for serializing / deserializing data track packets. */
+export declare class DataTrackPacket extends Serializable {
+    header: DataTrackPacketHeader;
+    payload: Uint8Array;
+    constructor(header: DataTrackPacketHeader, payload: Uint8Array);
+    toBinaryLengthBytes(): number;
+    toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeErrorAll>;
+    static fromBinary<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): Throws<[
+        packet: DataTrackPacket,
+        byteLength: number
+    ], DataTrackDeserializeErrorAll>;
+    toJSON(): {
+        header: {
+            marker: FrameMarker;
+            trackHandle: number;
+            sequence: number;
+            frameNumber: number;
+            timestamp: number;
+            extensions: {
+                userTimestamp: {
+                    tag: number;
+                    lengthBytes: number;
+                    timestamp: bigint;
+                } | null;
+                e2ee: {
+                    tag: number;
+                    lengthBytes: number;
+                    keyIndex: number;
+                    iv: Uint8Array<ArrayBufferLike>;
+                } | null;
+            };
+        };
+        payload: Uint8Array<ArrayBufferLike>;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { Throws } from '../../../utils/throws';
+import type { DataTrackSerializeErrorAll } from './errors';
+/** An abstract class implementing common behavior related to data track binary serialization. */
+export default abstract class Serializable {
+    /** Returns the expected length of the serialized output in bytes */
+    abstract toBinaryLengthBytes(): number;
+    /** Given a DataView, serialize the instance inside and return the number of bytes written. */
+    abstract toBinaryInto(dataView: DataView): Throws<number, DataTrackSerializeErrorAll>;
+    /** Encodes the instance as binary and returns the data as a Uint8Array. */
+    toBinary(): Throws<Uint8Array, DataTrackSerializeErrorAll>;
+}
+//# sourceMappingURL=serializable.d.ts.map

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

@@ -0,0 +1,43 @@
+import type { Throws } from '../../utils/throws';
+import { LivekitReasonedError } from '../errors';
+import type { DataTrackFrame } from './frame';
+import { DataTrackHandle } from './handle';
+import { DataTrackPacket, FrameMarker } from './packet';
+import { DataTrackTimestamp } from './utils';
+type PacketizeOptions = {
+    /** "now" timestamp to use as a base when generating new packet timestamps. If not specified,
+     * defaults to the return value of {@link DataTrackClock#now}. */
+    now?: DataTrackTimestamp<90000>;
+};
+export declare class DataTrackPacketizerError<Reason extends DataTrackPacketizerReason> extends LivekitReasonedError<Reason> {
+    readonly name = "DataTrackPacketizerError";
+    reason: Reason;
+    reasonName: string;
+    constructor(message: string, reason: Reason, options?: {
+        cause?: unknown;
+    });
+    static mtuTooShort(): DataTrackPacketizerError<DataTrackPacketizerReason>;
+}
+export declare enum DataTrackPacketizerReason {
+    MtuTooShort = 0
+}
+/** A packetizer takes a {@link DataTrackFrame} as input and generates a series
+ * of {@link DataTrackPacket}s for transmission to other clients over webrtc. */
+export declare class DataTrackPacketizer {
+    private handle;
+    private mtuSizeBytes;
+    private sequence;
+    private frameNumber;
+    private clock;
+    constructor(trackHandle: DataTrackHandle, mtuSizeBytes: number);
+    /** @internal */
+    static computeFrameMarker(index: number, packetCount: number): FrameMarker;
+    /** Generates a series of packets for the specified {@link DataTrackPacketizerFrame}.
+     *
+     * NOTE: The return value of this function is a generator, so it can be lazily ran if desired,
+     * or converted to an array with {@link Array.from}.
+     */
+    packetize(frame: DataTrackFrame, options?: PacketizeOptions): Throws<Generator<DataTrackPacket>, DataTrackPacketizerError<DataTrackPacketizerReason.MtuTooShort>>;
+}
+export {};
+//# sourceMappingURL=packetizer.d.ts.map

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

@@ -0,0 +1,60 @@
+export declare const U16_MAX_SIZE = 65535;
+export declare const U32_MAX_SIZE = 4294967295;
+/**
+ * A number of fields withing the data tracks packet specification assume wrap around behavior when
+ * an unsigned type is incremented beyond its max size (ie, the packet `sequence` field). This
+ * wrapper type manually reimplements this wrap around behavior given javascript's lack of fixed
+ * size integer types.
+ */
+export declare class WrapAroundUnsignedInt<MaxSize extends number> {
+    value: number;
+    private maxSize;
+    static u16(raw: number): WrapAroundUnsignedInt<65535>;
+    static u32(raw: number): WrapAroundUnsignedInt<4294967295>;
+    constructor(raw: number, maxSize: MaxSize);
+    /** Manually clamp the given containing value according to the wrap around max size bounds. Use
+     * this after out of bounds modification to the contained value by external code. */
+    clamp(): void;
+    clone(): WrapAroundUnsignedInt<MaxSize>;
+    /** When called, maps the containing value to a new containing value. After mapping, the wrap
+     * around external max size bounds are applied. Note that this is a mutative operation. */
+    update(updateFn: (value: number) => number): void;
+    /** Increments the given `n` to the inner value. Note that this is a mutative operation. */
+    increment(n?: number): void;
+    /** Decrements the given `n` from the inner value. Note that this is a mutative operation. */
+    decrement(n?: number): void;
+    getThenIncrement(): WrapAroundUnsignedInt<MaxSize>;
+    /** Returns true if {@link this} is before the passed other {@link WrapAroundUnsignedInt}. */
+    isBefore(other: WrapAroundUnsignedInt<MaxSize>): boolean;
+}
+export declare class DataTrackTimestamp<RateInHz extends number> {
+    rateInHz: RateInHz;
+    timestamp: WrapAroundUnsignedInt<typeof U32_MAX_SIZE>;
+    static fromRtpTicks(rtpTicks: number): DataTrackTimestamp<90000>;
+    /** Generates a timestamp initialized to a non cryptographically secure random value, so that
+     * different streams are more difficult to correlate in packet capture. */
+    static rtpRandom(): DataTrackTimestamp<90000>;
+    private constructor();
+    asTicks(): number;
+    clone(): DataTrackTimestamp<RateInHz>;
+    wrappingAdd(n: number): void;
+    /** Returns true if {@link this} is before the passed other {@link DataTrackTimestamp}. */
+    isBefore(other: DataTrackTimestamp<RateInHz>): boolean;
+}
+export declare class DataTrackClock<RateInHz extends number> {
+    epoch: Date;
+    base: DataTrackTimestamp<RateInHz>;
+    previous: DataTrackTimestamp<RateInHz>;
+    rateInHz: RateInHz;
+    private constructor();
+    static startingNow<RateInHz extends number>(base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
+    static startingAtTime<RateInHz extends number>(epoch: Date, base: DataTrackTimestamp<RateInHz>, rateInHz: RateInHz): DataTrackClock<RateInHz>;
+    static rtpStartingNow(base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
+    static rtpStartingAtTime(epoch: Date, base: DataTrackTimestamp<90000>): DataTrackClock<90000>;
+    now(): DataTrackTimestamp<RateInHz>;
+    at(timestamp: Date): DataTrackTimestamp<RateInHz>;
+    /** Convert a duration since the epoch into clock ticks. */
+    static durationInMsToTicks(durationMilliseconds: number, rateInHz: number): number;
+}
+export declare function coerceToDataView<Input extends DataView | ArrayBuffer | Uint8Array>(input: Input): DataView;
+//# sourceMappingURL=utils.d.ts.map

package/dist/ts4.2/room/errors.d.ts

@@ -1,7 +1,19 @@
 import { DisconnectReason, RequestResponse_Reason } from '@livekit/protocol';
+/** Base error that all LiveKit specific custom errors inherit from. */
 export declare class LivekitError extends Error {
     code: number;
-    constructor(code: number, message?: string);
+    cause?: unknown;
+    constructor(code: number, message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * LiveKit specific error type representing an error with an associated set of reasons.
+ * Use this to represent an error with multiple different but contextually related variants.
+ * */
+export declare abstract class LivekitReasonedError<Reason> extends LivekitError {
+    abstract reason: Reason;
+    abstract reasonName: string;
 }
 export declare class SimulatedError extends LivekitError {
     readonly name = "simulated";
@@ -61,7 +73,7 @@ type ServiceNotFound = {
     context: string;
 };
 type ConnectionErrorVariants = NotAllowed | ConnectionTimeout | LeaveRequest | InternalError | Cancelled | ServerUnreachable | WebSocket | ServiceNotFound;
-export declare class ConnectionError<Variant extends ConnectionErrorVariants = ConnectionErrorVariants> extends LivekitError {
+export declare class ConnectionError<Variant extends ConnectionErrorVariants = ConnectionErrorVariants> extends LivekitReasonedError<Variant['reason']> {
     status?: Variant['status'];
     context: Variant['context'];
     reason: Variant['reason'];
@@ -110,7 +122,7 @@ export declare class PublishTrackError extends LivekitError {
     constructor(message: string, status: number);
 }
 export type RequestErrorReason = Exclude<RequestResponse_Reason, RequestResponse_Reason.OK> | 'TimeoutError';
-export declare class SignalRequestError extends LivekitError {
+export declare class SignalRequestError extends LivekitReasonedError<RequestErrorReason> {
     readonly name = "SignalRequestError";
     reason: RequestErrorReason;
     reasonName: string;
@@ -125,7 +137,7 @@ export declare enum DataStreamErrorReason {
     HandlerAlreadyRegistered = 7,
     EncryptionTypeMismatch = 8
 }
-export declare class DataStreamError extends LivekitError {
+export declare class DataStreamError extends LivekitReasonedError<DataStreamErrorReason> {
     readonly name = "DataStreamError";
     reason: DataStreamErrorReason;
     reasonName: string;

package/dist/ts4.2/room/track/LocalTrack.d.ts

@@ -27,6 +27,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     protected manuallyStopped: boolean;
     protected localTrackRecorder: LocalTrackRecorder<typeof this> | undefined;
     protected trackChangeLock: Mutex;
+    protected pendingDeviceChange: boolean;
     /**
      *
      * @param mediaTrack

package/dist/ts4.2/room/types.d.ts

@@ -107,5 +107,6 @@ export interface ByteStreamInfo extends BaseStreamInfo {
     name: string;
 }
 export interface TextStreamInfo extends BaseStreamInfo {
+    attachedStreamIds?: Array<string>;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -2,6 +2,10 @@ type InferErrors<T> = T extends TypedPromise<any, infer E> ? E : never;
 export default class TypedPromise<T, E extends Error> extends Promise<T> {
     constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: E) => void) => void);
     catch<TResult = never>(onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined): TypedPromise<T | TResult, E>;
+    static resolve: {
+        (): TypedPromise<void, never>;
+        <V>(value: V): TypedPromise<Awaited<V>, never>;
+    };
     static reject<E extends Error>(reason: E): TypedPromise<never, E>;
     static all<T extends readonly unknown[] | [
     ]>(values: T): TypedPromise<{

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

@@ -0,0 +1,39 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.17.0",
+  "version": "2.17.2",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -37,7 +37,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@livekit/mutex": "1.1.1",
-    "@livekit/protocol": "1.42.2",
+    "@livekit/protocol": "1.44.0",
     "events": "^3.3.0",
     "jose": "^6.1.0",
     "loglevel": "^1.9.2",
@@ -51,11 +51,11 @@
     "@types/dom-mediacapture-record": "^1"
   },
   "devDependencies": {
-    "@babel/core": "7.28.5",
-    "@babel/preset-env": "7.28.5",
+    "@babel/core": "7.29.0",
+    "@babel/preset-env": "7.29.0",
     "@bufbuild/protoc-gen-es": "^1.10.0",
-    "@changesets/cli": "2.29.7",
-    "@eslint/js": "9.39.1",
+    "@changesets/cli": "2.29.8",
+    "@eslint/js": "9.39.2",
     "@livekit/changesets-changelog-github": "^0.0.4",
     "@rollup/plugin-babel": "6.1.0",
     "@rollup/plugin-commonjs": "28.0.9",
@@ -72,25 +72,26 @@
     "@typescript-eslint/eslint-plugin": "7.18.0",
     "@typescript-eslint/parser": "7.18.0",
     "downlevel-dts": "^0.11.0",
-    "eslint": "9.39.1",
+    "eslint": "9.39.2",
     "eslint-config-airbnb-extended": "^2.3.2",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-compat": "^6.0.2",
     "eslint-plugin-import-x": "^4.16.1",
     "eslint-plugin-prettier": "^5.5.4",
     "gh-pages": "6.3.0",
+    "glob": "^13.0.0",
     "happy-dom": "^17.2.0",
     "jsdom": "^26.1.0",
     "prettier": "^3.4.2",
-    "rollup": "4.53.2",
+    "rollup": "4.57.1",
     "rollup-plugin-delete": "^2.1.0",
     "rollup-plugin-typescript2": "0.36.0",
     "size-limit": "^11.2.0",
-    "typedoc": "0.28.14",
+    "typedoc": "0.28.16",
     "typedoc-plugin-no-inherit": "1.6.1",
     "typescript": "5.8.3",
     "typescript-eslint": "^8.47.0",
-    "vite": "7.2.2",
+    "vite": "7.3.1",
     "vitest": "^3.0.0"
   },
   "scripts": {
@@ -107,6 +108,7 @@
     "deploy": "gh-pages -d examples/demo/dist",
     "format": "prettier --write src examples/**/*.ts",
     "format:check": "prettier --check src examples/**/*.ts",
+    "throws:check": "pnpm dlx tsx ./throws-transformer/cli.ts 'src/!(*.test).ts' 'src/**/!(*.test).ts'",
     "ci:publish": "pnpm build:clean && pnpm compat && changeset publish",
     "downlevel-dts": "downlevel-dts ./dist/src ./dist/ts4.2 --to=4.2",
     "compat": "eslint --config ./eslint.config.dist.mjs --no-inline-config  ./dist/livekit-client.esm.mjs",

package/src/e2ee/KeyProvider.ts

@@ -91,8 +91,10 @@ export class ExternalE2EEKeyProvider extends BaseKeyProvider {
 
   /**
    * Accepts a passphrase that's used to create the crypto keys.
-   * When passing in a string, PBKDF2 is used.
-   * When passing in an Array buffer of cryptographically random numbers, HKDF is being used. (recommended)
+   * When passing in a string, PBKDF2 is used. (recommended for maximum compatibility across SDKs)
+   * When passing in an ArrayBuffer of cryptographically random numbers, HKDF is used.
+   *
+   * Note: Not all client SDKS support HKDF.
    * @param key
    */
   async setKey(key: string | ArrayBuffer) {

package/src/index.ts

@@ -9,11 +9,18 @@ import {
 import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
-import Room, { ConnectionState } from './room/Room';
-import type { RoomEventCallbacks } from './room/Room';
+import Room, { ConnectionState, type RoomEventCallbacks } from './room/Room';
 import * as attributes from './room/attribute-typings';
+// FIXME: remove this import in a follow up data track pull request.
+import './room/data-track/depacketizer';
+// FIXME: remove this import in a follow up data track pull request.
+import './room/data-track/packetizer';
 import LocalParticipant from './room/participant/LocalParticipant';
-import Participant, { ConnectionQuality, ParticipantKind } from './room/participant/Participant';
+import Participant, {
+  ConnectionQuality,
+  type ParticipantEventCallbacks,
+  ParticipantKind,
+} from './room/participant/Participant';
 import type { ParticipantTrackPermission } from './room/participant/ParticipantTrackPermission';
 import RemoteParticipant from './room/participant/RemoteParticipant';
 import type {
@@ -32,8 +39,8 @@ import RemoteTrack from './room/track/RemoteTrack';
 import RemoteTrackPublication from './room/track/RemoteTrackPublication';
 import type { ElementInfo } from './room/track/RemoteVideoTrack';
 import RemoteVideoTrack from './room/track/RemoteVideoTrack';
-import { TrackPublication } from './room/track/TrackPublication';
-import type { LiveKitReactNativeInfo } from './room/types';
+import { type PublicationEventCallbacks, TrackPublication } from './room/track/TrackPublication';
+import type { LiveKitReactNativeInfo, TextStreamInfo } from './room/types';
 import type { AudioAnalyserOptions } from './room/utils';
 import {
   compareVersions,
@@ -140,6 +147,7 @@ export type {
   AudioAnalyserOptions,
   ElementInfo,
   LiveKitReactNativeInfo,
+  TextStreamInfo,
   ParticipantTrackPermission,
   AudioReceiverStats,
   AudioSenderStats,
@@ -148,6 +156,14 @@ export type {
   ReconnectContext,
   ReconnectPolicy,
   RoomEventCallbacks,
+  ParticipantEventCallbacks,
+  PublicationEventCallbacks,
 };
+export { DataTrackPacket, type DataTrackPacketHeader } from './room/data-track/packet';
+export {
+  type DataTrackExtensions,
+  type DataTrackUserTimestampExtension,
+  type DataTrackE2eeExtension,
+} from './room/data-track/packet/extensions';
 
 export { LocalTrackRecorder } from './room/track/record';

package/src/logger.ts

@@ -21,6 +21,7 @@ export enum LoggerNames {
   PCManager = 'livekit-pc-manager',
   PCTransport = 'livekit-pc-transport',
   E2EE = 'lk-e2ee',
+  DataTracks = 'livekit-data-tracks',
 }
 
 type LogLevelString = keyof typeof LogLevel;

package/src/room/PCTransport.ts

@@ -278,6 +278,7 @@ export default class PCTransport extends EventEmitter {
           await this._pc.setRemoteDescription(currentSD);
         } else {
           this.renegotiate = true;
+          this.log.debug('requesting renegotiation', { ...this.logContext });
           return;
         }
       } else if (!this._pc || this._pc.signalingState === 'closed') {

package/src/room/PCTransportManager.ts

@@ -229,28 +229,46 @@ export class PCTransportManager {
 
   async negotiate(abortController: AbortController) {
     return new TypedPromise<void, NegotiationError | Error>(async (resolve, reject) => {
-      const negotiationTimeout = setTimeout(() => {
+      let negotiationTimeout = setTimeout(() => {
         reject(new NegotiationError('negotiation timed out'));
       }, this.peerConnectionTimeout);
 
-      const abortHandler = () => {
+      const cleanup = () => {
         clearTimeout(negotiationTimeout);
+        this.publisher.off(PCEvents.NegotiationStarted, onNegotiationStarted);
+        abortController.signal.removeEventListener('abort', abortHandler);
+      };
+
+      const abortHandler = () => {
+        cleanup();
         reject(new NegotiationError('negotiation aborted'));
       };
 
-      abortController.signal.addEventListener('abort', abortHandler);
-      this.publisher.once(PCEvents.NegotiationStarted, () => {
+      // Reset the timeout each time a renegotiation cycle starts. This
+      // prevents premature timeouts when the negotiation machinery is
+      // actively renegotiating (offers going out, answers coming back) but
+      // NegotiationComplete hasn't fired yet because new requirements keep
+      // arriving between offer/answer round-trips.
+      const onNegotiationStarted = () => {
         if (abortController.signal.aborted) {
           return;
         }
-        this.publisher.once(PCEvents.NegotiationComplete, () => {
-          clearTimeout(negotiationTimeout);
-          resolve();
-        });
+        clearTimeout(negotiationTimeout);
+        negotiationTimeout = setTimeout(() => {
+          cleanup();
+          reject(new NegotiationError('negotiation timed out'));
+        }, this.peerConnectionTimeout);
+      };
+
+      abortController.signal.addEventListener('abort', abortHandler);
+      this.publisher.on(PCEvents.NegotiationStarted, onNegotiationStarted);
+      this.publisher.once(PCEvents.NegotiationComplete, () => {
+        cleanup();
+        resolve();
       });
 
       await this.publisher.negotiate((e) => {
-        clearTimeout(negotiationTimeout);
+        cleanup();
         if (e instanceof Error) {
           reject(e);
         } else {

package/src/room/RTCEngine.ts

@@ -1477,8 +1477,11 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     if (!this.pcManager) {
       return false;
     }
-    // primary connection
-    if (this.pcManager.currentState !== PCTransportState.CONNECTED) {
+    const allowedConnectionStates: PCTransportState[] = [
+      PCTransportState.CONNECTING,
+      PCTransportState.CONNECTED,
+    ];
+    if (!allowedConnectionStates.includes(this.pcManager.currentState)) {
       return false;
     }
 
@@ -1521,6 +1524,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         reject(new NegotiationError('cannot negotiate on closed engine'));
       }
       this.on(EngineEvent.Closing, handleClosed);
+      this.on(EngineEvent.Restarting, handleClosed);
 
       this.pcManager.publisher.once(
         PCEvents.RTPVideoPayloadTypes,
@@ -1540,6 +1544,12 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         await this.pcManager.negotiate(abortController);
         resolve();
       } catch (e: unknown) {
+        if (abortController.signal.aborted) {
+          // negotiation was aborted due to engine close or restart, resolve
+          // cleanly to avoid triggering a cascading reconnect loop
+          resolve();
+          return;
+        }
         if (e instanceof NegotiationError) {
           this.fullReconnectOnNext = true;
         }
@@ -1551,6 +1561,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         }
       } finally {
         this.off(EngineEvent.Closing, handleClosed);
+        this.off(EngineEvent.Restarting, handleClosed);
       }
     });
   }

package/src/room/Room.ts

@@ -2307,7 +2307,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           engine: this.engine
             ? {
                 closed: this.engine.isClosed,
-                transportsConnected: this.engine.verifyTransport(),
+                transportsConnectedOrConnecting: this.engine.verifyTransport(),
               }
             : undefined,
         });

package/src/room/data-stream/incoming/IncomingDataStreamManager.ts

@@ -191,6 +191,7 @@ export default class IncomingDataStreamManager {
         timestamp: Number(streamHeader.timestamp),
         attributes: streamHeader.attributes,
         encryptionType,
+        attachedStreamIds: streamHeader.contentHeader.value.attachedStreamIds,
       };
 
       const stream = new ReadableStream<DataStream_Chunk>({

package/src/room/data-stream/outgoing/OutgoingDataStreamManager.ts

@@ -107,6 +107,7 @@ export default class OutgoingDataStreamManager {
       encryptionType: this.engine.e2eeManager?.isDataChannelEncryptionEnabled
         ? Encryption_Type.GCM
         : Encryption_Type.NONE,
+      attachedStreamIds: options?.attachedStreamIds,
     };
     const header = new DataStream_Header({
       streamId,
@@ -119,7 +120,7 @@ export default class OutgoingDataStreamManager {
         case: 'textHeader',
         value: new DataStream_TextHeader({
           version: options?.version,
-          attachedStreamIds: options?.attachedStreamIds,
+          attachedStreamIds: info.attachedStreamIds,
           replyToStreamId: options?.replyToStreamId,
           operationType:
             options?.type === 'update'