@signalwire/js 4.0.0-beta.10 → 4.0.0-beta.11

package/dist/index.d.cts

@@ -1,81 +1,10 @@
 import { a as JSONRPCSuccessResponse, i as JSONRPCResponse, n as JSONRPCErrorResponse, r as JSONRPCRequest, t as EventChannel } from "./base-Cif20s3C.cjs";
+import { URL as URL$1 } from "node:url";
 import * as rxjs0 from "rxjs";
 import { BehaviorSubject, Observable, Observer, ReplaySubject, Subject, Subscription } from "rxjs";
-import { URL as URL$1 } from "node:url";
 
-//#region src/behaviors/Destroyable.d.ts
-declare abstract class Destroyable {
-  protected subscriptions: Subscription[];
-  protected subjects: Subject<unknown>[];
-  protected _destroyed$: Subject<void>;
-  private _observableCache?;
-  destroy(): void;
-  protected cachedObservable<T>(key: string, factory: () => Observable<T>): Observable<T>;
-  /**
-   * Like `cachedObservable`, but defers emissions to the microtask queue
-   * via `observeOn(asapScheduler)`.
-   *
-   * Use ONLY for public-facing observable getters that external consumers
-   * subscribe to. Prevents a class of bugs where `BehaviorSubject` or
-   * `ReplaySubject` replays synchronously during `subscribe()`, before
-   * the subscription variable is assigned in the caller's scope.
-   *
-   * Do NOT use for observables consumed internally by the SDK — internal
-   * code using `subscribeTo()`, `firstValueFrom()`, or `withLatestFrom()`
-   * depends on synchronous emission delivery.
-   */
-  protected publicCachedObservable<T>(key: string, factory: () => Observable<T>): Observable<T>;
-  /**
-   * Wraps an observable so emissions are deferred to the microtask queue.
-   *
-   * Use ONLY for public-facing getters that expose a subject via
-   * `.asObservable()` without going through `cachedObservable`.
-   *
-   * Do NOT use for observables consumed internally by the SDK.
-   */
-  protected deferEmission<T>(observable: Observable<T>): Observable<T>;
-  protected subscribeTo<T>(observable: Observable<T>, observerOrNext: Partial<Observer<T>> | ((value: T) => void) | undefined): void;
-  protected createSubject<T>(): Subject<T>;
-  protected createReplaySubject<T>(bufferSize?: number, windowTime?: number): ReplaySubject<T>;
-  protected createBehaviorSubject<T>(initialValue: T): BehaviorSubject<T>;
-  get $(): Observable<this>;
-  /**
-   * Observable that emits when the instance is destroyed
-   */
-  get destroyed$(): Observable<void>;
-}
-//#endregion
-//#region src/core/types/media.types.d.ts
-/** WebRTC transceiver direction for a single media kind. */
-type MediaDirection = RTCRtpTransceiverDirection;
-/** Audio and video directions "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped" */
-interface MediaDirections {
-  /** Audio direction */
-  audio: MediaDirection;
-  /** Video direction */
-  video: MediaDirection;
-}
-/** Options controlling which media tracks to send and receive. */
-interface MediaOptions {
-  /** Enable audio input. */
-  audio?: boolean;
-  /** Enable video input. */
-  video?: boolean;
-  /** Custom constraints for the audio input track. */
-  inputAudioDeviceConstraints?: MediaTrackConstraints;
-  /** Custom constraints for the video input track. */
-  inputVideoDeviceConstraints?: MediaTrackConstraints;
-  /** Pre-existing audio stream to use instead of `getUserMedia`. */
-  inputAudioStream?: MediaStream;
-  /** Pre-existing video stream to use instead of `getUserMedia`. */
-  inputVideoStream?: MediaStream;
-  /** Whether to receive remote audio. */
-  receiveAudio?: boolean;
-  /** Whether to receive remote video. */
-  receiveVideo?: boolean;
-}
-//#endregion
 //#region src/core/types/common.types.d.ts
+/** JSON-compatible value type for serializable data structures. */
 interface JSONSerializable {
   [key: string]: JSONSerializable | string | number | boolean | null | undefined | JSONSerializable[];
 }
@@ -124,6 +53,7 @@ interface HTTPResponse<T extends HttpBody = string> {
   /** Final URL after any redirects */
   url: string;
 }
+/** Browser-compatible WebSocket client interface. */
 interface WebSocketClient {
   addEventListener: WebSocket['addEventListener'];
   removeEventListener: WebSocket['removeEventListener'];
@@ -131,6 +61,7 @@ interface WebSocketClient {
   close: WebSocket['close'];
   readyState: WebSocket['readyState'];
 }
+/** Node.js WebSocket client interface with event listener overloads. */
 interface NodeSocketClient extends WebSocketClient {
   addEventListener(method: 'open' | 'close' | 'error' | 'message', cb: (event: unknown) => void, options?: unknown): void;
   removeEventListener(method: 'open' | 'close' | 'error' | 'message', cb: (event: unknown) => void): void;
@@ -147,24 +78,52 @@ interface NodeSocketAdapter {
 }
 /** Browser-compatible WebSocket constructor type. */
 type WebSocketAdapter = new (url: string | URL, protocols?: string | string[]) => WebSocketClient;
-/** Authentication credentials for the SDK. */
+/**
+ * Authentication credentials for the SDK.
+ *
+ * At least one of `token` or `authorizationState` must be provided.
+ */
 interface SDKCredential {
-  /** JWT subscriber access token. */
+  /** JWT subscriber access token (SAT). */
   token?: string;
   /** Pre-authorized session state (alternative to token). */
   authorizationState?: string;
-  /** Token expiry timestamp in milliseconds since epoch. */
+  /** Token expiry timestamp in milliseconds since epoch. When set, the SDK attempts credential refresh before expiry. */
   expiry_at?: number;
 }
 /** Types of addressable resources in the fabric. */
 type ResourceType = 'app' | 'call' | 'room' | 'subscriber';
 //#endregion
 //#region src/dependencies/interfaces.d.ts
+/** Persistence scope: browser `localStorage` or `sessionStorage`. */
 type StorageScope = 'local' | 'session';
+/** Key-value storage interface for persisting SDK preferences and state. */
 interface Storage {
   setItem(key: string, value: string | null, scope: StorageScope): Promise<void>;
   getItem(key: string, scope: StorageScope): Promise<string | null>;
   removeItem(key: string, scope: StorageScope): Promise<void>;
+  /** Clears all keys in the given scope. Implementations may scope the clear to SDK keys only. */
+  clear(scope: StorageScope): Promise<void>;
+}
+/**
+ * Context provided by the SDK when calling {@link CredentialProvider.authenticate}.
+ *
+ * Contains optional parameters the SDK generates internally (e.g., DPoP fingerprint)
+ * that the implementor can forward to their server-side token endpoint.
+ */
+interface AuthenticateContext {
+  /**
+   * JWK Thumbprint (RFC 7638) of the SDK's ephemeral DPoP key pair.
+   *
+   * When present, the implementor should forward this value as the `fingerprint`
+   * parameter to the server-side SAT issuance endpoint alongside `scope: "sat:refresh"`.
+   * This enables the server to bind the SAT to the SDK's key pair, allowing
+   * automatic Client Bound SAT refresh without developer intervention.
+   *
+   * When absent (e.g., Web Crypto API not available), the implementor should
+   * proceed without DPoP binding.
+   */
+  fingerprint?: string;
 }
 /**
  * Provides authentication credentials to the SDK.
@@ -185,12 +144,14 @@ interface CredentialProvider {
    * Implementor responsibilities:
    * - Resolve with a valid {@link SDKCredential} on success.
    * - Reject (throw) on failure — this will cause client initialization to fail.
+   * - When `context.fingerprint` is provided, forward it to the server-side token
+   *   endpoint with `scope: "sat:refresh"` to enable automatic token refresh.
    *
    * SDK behavior:
    * - Awaits this method before establishing the WebSocket connection.
    * - On rejection, propagates the error to the caller of `SignalWire()`.
    */
-  authenticate(): Promise<SDKCredential>;
+  authenticate(context?: AuthenticateContext): Promise<SDKCredential>;
   /**
    * Obtains fresh credentials before the current ones expire. Optional.
    *
@@ -203,7 +164,10 @@ interface CredentialProvider {
    * - Scheduled automatically before expiry; implementors do not need to manage timing.
    * - On rejection, the refresh schedule stops and the session continues with the
    *   current credentials until they expire.
-   * - When not provided, the SDK uses the initial credentials for the entire session lifetime.
+   * - When not provided and the SAT includes a `sat:refresh` scope, the SDK
+   *   automatically refreshes via Client Bound SAT (DPoP) without developer intervention.
+   * - When not provided and no refresh scope is present, the SDK uses the initial
+   *   credentials for the entire session lifetime.
    */
   refresh?: () => Promise<SDKCredential>;
 }
@@ -285,6 +249,82 @@ declare class StorageManager {
    * @throws Error from underlying storage implementation
    */
   removeItem(key: string, scope?: StorageScope): Promise<void>;
+  /**
+   * Clears all SDK keys from both 'local' and 'session' scopes.
+   * @throws StorageWriteError if clearing fails
+   */
+  clearAll(): Promise<void>;
+}
+//#endregion
+//#region src/behaviors/Destroyable.d.ts
+declare abstract class Destroyable {
+  protected subscriptions: Subscription[];
+  protected subjects: Subject<unknown>[];
+  protected _destroyed$: Subject<void>;
+  private _observableCache?;
+  destroy(): void;
+  protected cachedObservable<T>(key: string, factory: () => Observable<T>): Observable<T>;
+  /**
+   * Like `cachedObservable`, but defers emissions to the microtask queue
+   * via `observeOn(asapScheduler)`.
+   *
+   * Use ONLY for public-facing observable getters that external consumers
+   * subscribe to. Prevents a class of bugs where `BehaviorSubject` or
+   * `ReplaySubject` replays synchronously during `subscribe()`, before
+   * the subscription variable is assigned in the caller's scope.
+   *
+   * Do NOT use for observables consumed internally by the SDK — internal
+   * code using `subscribeTo()`, `firstValueFrom()`, or `withLatestFrom()`
+   * depends on synchronous emission delivery.
+   */
+  protected publicCachedObservable<T>(key: string, factory: () => Observable<T>): Observable<T>;
+  /**
+   * Wraps an observable so emissions are deferred to the microtask queue.
+   *
+   * Use ONLY for public-facing getters that expose a subject via
+   * `.asObservable()` without going through `cachedObservable`.
+   *
+   * Do NOT use for observables consumed internally by the SDK.
+   */
+  protected deferEmission<T>(observable: Observable<T>): Observable<T>;
+  protected subscribeTo<T>(observable: Observable<T>, observerOrNext: Partial<Observer<T>> | ((value: T) => void) | undefined): void;
+  protected createSubject<T>(): Subject<T>;
+  protected createReplaySubject<T>(bufferSize?: number, windowTime?: number): ReplaySubject<T>;
+  protected createBehaviorSubject<T>(initialValue: T): BehaviorSubject<T>;
+  /**
+   * Observable that emits when the instance is destroyed
+   */
+  get destroyed$(): Observable<void>;
+}
+//#endregion
+//#region src/core/types/media.types.d.ts
+/** WebRTC transceiver direction for a single media kind. */
+type MediaDirection = RTCRtpTransceiverDirection;
+/** Audio and video directions "inactive" | "recvonly" | "sendonly" | "sendrecv" | "stopped" */
+interface MediaDirections {
+  /** Audio direction */
+  audio: MediaDirection;
+  /** Video direction */
+  video: MediaDirection;
+}
+/** Options controlling which media tracks to send and receive. */
+interface MediaOptions {
+  /** Enable audio input. Defaults to `true` when not specified. */
+  audio?: boolean;
+  /** Enable video input. Defaults to `false` when not specified. */
+  video?: boolean;
+  /** Custom constraints for the audio input track. */
+  inputAudioDeviceConstraints?: MediaTrackConstraints;
+  /** Custom constraints for the video input track. */
+  inputVideoDeviceConstraints?: MediaTrackConstraints;
+  /** Pre-existing audio stream to use instead of `getUserMedia`. */
+  inputAudioStream?: MediaStream;
+  /** Pre-existing video stream to use instead of `getUserMedia`. */
+  inputVideoStream?: MediaStream;
+  /** Whether to receive remote audio. */
+  receiveAudio?: boolean;
+  /** Whether to receive remote video. */
+  receiveVideo?: boolean;
 }
 //#endregion
 //#region src/containers/PreferencesContainer.d.ts
@@ -364,6 +404,108 @@ declare class ClientPreferences {
   /** Custom user variables attached to calls. */
   get userVariables(): Record<string, unknown>;
   set userVariables(value: Record<string, unknown>);
+  /** Stats polling interval in milliseconds. */
+  get statsPollingInterval(): number;
+  set statsPollingInterval(value: number);
+  /** Number of baseline samples for stats monitoring. */
+  get statsBaselineSamples(): number;
+  set statsBaselineSamples(value: number);
+  /** Duration in ms with no inbound packets before a critical issue is emitted. */
+  get statsNoPacketThreshold(): number;
+  set statsNoPacketThreshold(value: number);
+  /** Multiplier for RTT spike detection relative to baseline. */
+  get statsRttSpikeMultiplier(): number;
+  set statsRttSpikeMultiplier(value: number);
+  /** Packet loss fraction threshold (0-1) for issue detection. */
+  get statsPacketLossThreshold(): number;
+  set statsPacketLossThreshold(value: number);
+  /** Multiplier for jitter spike detection relative to baseline. */
+  get statsJitterSpikeMultiplier(): number;
+  set statsJitterSpikeMultiplier(value: number);
+  /** Number of seconds of metrics history to retain. */
+  get statsHistorySize(): number;
+  set statsHistorySize(value: number);
+  /** Maximum keyframe requests in a burst window. */
+  get keyframeMaxBurst(): number;
+  set keyframeMaxBurst(value: number);
+  /** Keyframe burst window duration in milliseconds. */
+  get keyframeBurstWindow(): number;
+  set keyframeBurstWindow(value: number);
+  /** Cooldown period in ms after keyframe burst limit is reached. */
+  get keyframeCooldown(): number;
+  set keyframeCooldown(value: number);
+  /** Minimum time in ms between re-INVITE attempts. */
+  get reinviteDebounceTime(): number;
+  set reinviteDebounceTime(value: number);
+  /** Maximum re-INVITE attempts per call. */
+  get reinviteMaxAttempts(): number;
+  set reinviteMaxAttempts(value: number);
+  /** Timeout in ms for a single re-INVITE attempt. */
+  get reinviteTimeout(): number;
+  set reinviteTimeout(value: number);
+  /** Recovery signal debounce window in seconds. */
+  get recoveryDebounceTime(): number;
+  set recoveryDebounceTime(seconds: number);
+  /** Cooldown period between recovery attempts in seconds. */
+  get recoveryCooldown(): number;
+  set recoveryCooldown(seconds: number);
+  /** Grace period before treating ICE 'disconnected' as failure, in seconds. */
+  get iceDisconnectedGracePeriod(): number;
+  set iceDisconnectedGracePeriod(seconds: number);
+  /** Timeout for a single ICE restart attempt in seconds. */
+  get iceRestartTimeout(): number;
+  set iceRestartTimeout(seconds: number);
+  /** Maximum recovery attempts before giving up. */
+  get maxRecoveryAttempts(): number;
+  set maxRecoveryAttempts(value: number);
+  /** Whether relay-only escalation is enabled as a last-resort recovery tier. */
+  get enableRelayFallback(): boolean;
+  set enableRelayFallback(value: boolean);
+  /** Whether browser network change detection (online/offline) is enabled. */
+  get enableNetworkChangeDetection(): boolean;
+  set enableNetworkChangeDetection(value: boolean);
+  /** Whether server-sent media-timeout hangups are intercepted for recovery. */
+  get enableServerHangupInterception(): boolean;
+  set enableServerHangupInterception(value: boolean);
+  /** Whether device selections are persisted to storage. */
+  get persistDeviceSelection(): boolean;
+  set persistDeviceSelection(value: boolean);
+  /** Whether device changes are auto-applied to active calls. */
+  get syncDevicesToActiveCalls(): boolean;
+  set syncDevicesToActiveCalls(value: boolean);
+  /** Whether to auto-mute video when the tab becomes hidden. */
+  get autoMuteVideoOnHidden(): boolean;
+  set autoMuteVideoOnHidden(value: boolean);
+  /** Whether to re-enumerate devices when the page becomes visible. */
+  get refreshDevicesOnVisible(): boolean;
+  set refreshDevicesOnVisible(value: boolean);
+  /** Whether to check peer connection health when the page becomes visible. */
+  get checkConnectionOnVisible(): boolean;
+  set checkConnectionOnVisible(value: boolean);
+  /** Default audio track constraints applied when no explicit constraints are provided. */
+  get defaultAudioConstraints(): MediaTrackConstraints | undefined;
+  set defaultAudioConstraints(value: MediaTrackConstraints | undefined);
+  /** Default video track constraints applied when video is enabled without explicit constraints. */
+  get defaultVideoConstraints(): MediaTrackConstraints | undefined;
+  set defaultVideoConstraints(value: MediaTrackConstraints | undefined);
+  /** Whether stereo Opus is enabled globally. */
+  get stereoAudio(): boolean;
+  set stereoAudio(value: boolean);
+  /** Whether automatic video degradation on low bandwidth is enabled. */
+  get enableAutoDegradation(): boolean;
+  set enableAutoDegradation(value: boolean);
+  /** Bitrate in kbps below which video is automatically disabled. */
+  get degradationBitrateThreshold(): number;
+  set degradationBitrateThreshold(value: number);
+  /** Bitrate in kbps above which video is automatically re-enabled. */
+  get degradationRecoveryThreshold(): number;
+  set degradationRecoveryThreshold(value: number);
+  /** Preferred video codecs in priority order. */
+  get preferredVideoCodecs(): string[];
+  set preferredVideoCodecs(value: string[]);
+  /** Preferred audio codecs in priority order. */
+  get preferredAudioCodecs(): string[];
+  set preferredAudioCodecs(value: string[]);
   /** Saves current preferences to storage (fire-and-forget). */
   private _saveToStorage;
   /** Loads preferences from storage and applies them to the container. */
@@ -380,11 +522,13 @@ interface HTTPRequestControllerOptions {
 }
 declare class HTTPRequestController {
   private baseURL;
-  private credential;
+  private readonly getCredential;
   private static readonly defaultMaxRetries;
   private static readonly defaultRetryDelayMinMs;
   private static readonly defaultRetryDelayMaxMs;
   private static readonly defaultRequestTimeoutMs;
+  /** Sensitive field names to mask in debug logs. */
+  private static readonly SENSITIVE_BODY_FIELDS;
   private readonly maxRetries;
   private readonly retryDelayMin;
   private readonly retryDelayMax;
@@ -392,7 +536,7 @@ declare class HTTPRequestController {
   private _responses$;
   private _errors$;
   private _status$;
-  constructor(baseURL: string, credential: SDKCredential, options?: HTTPRequestControllerOptions);
+  constructor(baseURL: string, getCredential: () => SDKCredential, options?: HTTPRequestControllerOptions);
   get status$(): Observable<HTTPRequestStatus>;
   get status(): HTTPRequestStatus;
   get responses$(): Observable<HTTPResponse>;
@@ -402,6 +546,10 @@ declare class HTTPRequestController {
   private executeRequest;
   private buildURL;
   private buildHeaders;
+  /**
+   * Sanitizes a request body for debug logging by masking sensitive fields.
+   */
+  private sanitizeBody;
   private convertResponse;
 }
 //#endregion
@@ -420,44 +568,105 @@ declare abstract class Fetchable<T = unknown> extends Destroyable {
  * Pure address-related types (no implementation dependencies)
  * Types that reference model implementations are in interfaces.ts
  */
+/** Raw address response from the SignalWire Fabric API. */
 interface GetAddressResponse {
+  /** Unique address identifier. */
   id: string;
+  /** Human-readable display name. */
   display_name: string;
+  /** Resource name (used as a URI for dialing). */
   name: string;
+  /** URL for an avatar or preview image. */
   preview_url?: string;
+  /** URL for a cover image. */
   cover_url?: string;
+  /** Underlying resource identifier. */
   resource_id: string;
+  /** Type of the underlying resource. */
   type: ResourceType;
+  /** Available communication channels for this address. */
   channels: {
+    /** Audio-only channel URI. */
     audio?: string;
+    /** Messaging channel URI. */
     messaging?: string;
+    /** Video channel URI. */
     video?: string;
   };
+  /** Whether the address resource is currently locked. */
   locked: boolean;
+  /** ISO 8601 timestamp when the address was created. */
   created_at: string;
 }
 //#endregion
+//#region src/core/types/crypto.types.d.ts
+/** Parameters for creating an HTTP DPoP proof (for Prime API endpoints). */
+interface DPoPHttpProofParams {
+  /** HTTP method (e.g., "POST"). */
+  readonly method: string;
+  /** Request URI — should be the full URL per RFC 9449 (e.g., "https://fabric.signalwire.com/api/..."). */
+  readonly uri: string;
+  /** Access token to bind via `ath` claim (SHA-256 hash). Used for resource endpoints, not token endpoints. */
+  readonly accessToken?: string;
+}
+/** Parameters for creating an RPC DPoP proof (for switchblade WebSocket methods). */
+interface DPoPRpcProofParams {
+  /** RPC method name (e.g., "signalwire.connect" or "signalwire.reauthenticate"). */
+  readonly method: string;
+}
+/** SAT claims returned by /api/fabric/subscriber/info. */
+interface SATClaims {
+  /** Token scopes (e.g., ["sat:refresh"]). */
+  scope?: string[];
+  /** Confirmation claim binding the token to a key. */
+  cnf?: {
+    jkt: string;
+  };
+  /** Token expiry timestamp in seconds since epoch. */
+  expires_at?: number;
+}
+//#endregion
 //#region src/core/types/subscriber.types.d.ts
+/** Raw subscriber profile response from the SignalWire Fabric API. */
 interface GetSubscriberInfoResponse {
+  /** Unique subscriber identifier. */
   id: string;
+  /** Subscriber's email address. */
   email: string;
+  /** Subscriber's first name. */
   first_name?: string;
+  /** Subscriber's last name. */
   last_name?: string;
+  /** Subscriber's display name. */
   display_name?: string;
+  /** Subscriber's job title. */
   job_title?: string;
+  /** Subscriber's time zone offset. */
   time_zone?: number;
+  /** Subscriber's country. */
   country?: string;
+  /** Subscriber's region or state. */
   region?: string;
+  /** Subscriber's company name. */
   company_name?: string;
+  /** Key for push notification delivery. */
   push_notification_key: string;
+  /** Application-level settings for this subscriber. */
   app_settings?: {
+    /** Display name configured at the application level. */
     display_name: string;
+    /** Permission scopes granted to this subscriber. */
     scopes: string[];
   };
+  /** Fabric addresses associated with this subscriber. */
   fabric_addresses: GetAddressResponse[];
+  /** Filtered SAT claims (scope, cnf, expires_at) returned when the token has special capabilities. */
+  sat_claims?: SATClaims;
 }
 //#endregion
 //#region src/core/entities/Subscriber.d.ts
+/** Subscriber online presence state. */
+type SubscriberPresence = 'online' | 'offline' | 'busy';
 /**
  * Authenticated subscriber profile.
  *
@@ -494,37 +703,84 @@ declare class Subscriber extends Fetchable<GetSubscriberInfoResponse> {
   };
   /** Fabric addresses associated with this subscriber. */
   addresses: GetAddressResponse[];
+  /** Filtered SAT claims when the token has special capabilities (e.g., refresh scope). */
+  satClaims?: SATClaims;
   constructor(http: HTTPRequestController);
   protected populateInstance(data: GetSubscriberInfoResponse): void;
 }
 //#endregion
 //#region src/core/types/call.types.d.ts
+/** SDP role for the peer connection negotiation. */
 type RTCPeerConnectionType = 'offer' | 'answer';
+/** Purpose of the peer connection (primary call, screen share, or additional device). */
 type RTCPeerConnectionPropose = 'main' | 'screenshare' | 'additional-device';
+/** States during call connection establishment. */
 type CallConnectStates = 'connecting' | 'connected';
+/** Lifecycle states of the signaling protocol for a call. */
 type SignalingCallStates = 'created' | 'ringing' | 'answered' | 'ending' | 'ended';
+/** Whether the call is inbound (received) or outbound (initiated). */
 type CallDirection = 'inbound' | 'outbound';
+/** Playback state of media being played into a call. */
 type CallPlayState = 'playing' | 'paused' | 'finished';
+/** Common parameters shared by all call device types. */
 interface CallDeviceCommonParams {
+  /** Optional SIP headers to include in the call setup. */
   headers?: unknown[];
 }
+/** Parameters for a WebRTC or SIP call device. */
 interface CallDeviceWebRTCOrSIPParams extends CallDeviceCommonParams {
+  /** Source address or URI for the call. */
   from: string;
+  /** Destination address or URI for the call. */
   to: string;
 }
+/** Parameters for a phone (PSTN) call device. */
 interface CallDevicePhoneParams extends CallDeviceCommonParams {
+  /** Caller phone number (E.164 format). */
   from_number: string;
+  /** Destination phone number (E.164 format). */
   to_number: string;
 }
+/** A WebRTC or SIP call device descriptor. */
 interface CallDeviceWebRTCOrSIP {
+  /** Transport type for the device. */
   type: 'webrtc' | 'sip';
+  /** Connection parameters for the device. */
   params: CallDeviceWebRTCOrSIPParams;
 }
+/** A phone (PSTN) call device descriptor. */
 interface CallDevicePhone {
+  /** Transport type for the device. */
   type: 'phone';
+  /** Connection parameters for the device. */
   params: CallDevicePhoneParams;
 }
+/** Discriminated union of call device types (WebRTC, SIP, or phone). */
 type CallDevice = CallDeviceWebRTCOrSIP | CallDevicePhone;
+/**
+ * Feature capability string that controls what actions a participant can perform.
+ *
+ * Capabilities are organized into categories:
+ * - **self.\*** — Actions the local participant can perform on themselves (mute, deaf, volume, position, meta).
+ * - **member.\*** — Actions that can be performed on other participants.
+ * - **layout.\*** — Layout management for the video canvas.
+ * - **digit.\*** — DTMF digit sending.
+ * - **vmuted.\*** — Visibility control for muted video participants.
+ * - **lock.\*** — Room lock/unlock control.
+ * - **device** / **screenshare** — Device and screen share capabilities.
+ * - **end** — Permission to end the call or room.
+ */
+type Capability = 'self' | 'self.mute' | 'self.mute.audio' | 'self.mute.audio.on' | 'self.mute.audio.off' | 'self.mute.video' | 'self.mute.video.on' | 'self.mute.video.off' | 'self.deaf' | 'self.deaf.on' | 'self.deaf.off' | 'self.microphone' | 'self.microphone.volume.set' | 'self.microphone.sensitivity.set' | 'self.speaker' | 'self.speaker.volume.set' | 'self.position.set' | 'self.meta' | 'self.audioflags.set' | 'member' | 'member.mute' | 'member.mute.audio' | 'member.mute.audio.on' | 'member.mute.audio.off' | 'member.mute.video' | 'member.mute.video.on' | 'member.mute.video.off' | 'member.deaf' | 'member.deaf.on' | 'member.deaf.off' | 'member.microphone' | 'member.microphone.volume.set' | 'member.microphone.sensitivity.set' | 'member.speaker' | 'member.speaker.volume.set' | 'member.position.set' | 'member.meta' | 'member.audioflags.set' | 'layout' | 'layout.set' | 'digit' | 'digit.send' | 'vmuted' | 'vmuted.hide' | 'vmuted.hide.on' | 'vmuted.hide.off' | 'lock' | 'lock.on' | 'lock.off' | 'device' | 'screenshare' | 'end';
+/**
+ * Position of a participant's video within the layout canvas.
+ *
+ * - `'auto'` — Automatically positioned by the layout engine.
+ * - `` `reserved-${number}` `` — A reserved slot in the layout (e.g., `'reserved-0'`).
+ * - `` `standard-${number}` `` — A standard slot in the layout (e.g., `'standard-1'`).
+ * - `'off-canvas'` — Participant is not visible in the layout.
+ * - `'playback'` — Playback position for media streams.
+ * - `'full-screen'` — Participant occupies the entire canvas.
+ */
 type VideoPosition = 'auto' | `reserved-${number}` | `standard-${number}` | 'off-canvas' | 'playback' | 'full-screen';
 //#endregion
 //#region src/core/RPCMessages/types/common.d.ts
@@ -674,6 +930,11 @@ interface CallUpdatedPayload {
   room_id: string;
   room_session_id: string;
 }
+interface RoomUpdatedPayload {
+  room_session: RoomSession;
+  room_id: string;
+  room_session_id: string;
+}
 interface CallStatePayload {
   call_id: string;
   node_id: string;
@@ -749,17 +1010,17 @@ declare class EntityCollection<T extends Entity = Entity> extends Destroyable im
   private fetchController;
   private update$;
   private readonly onError?;
-  loading$: rxjs0.BehaviorSubject<boolean>;
-  values$: ReplaySubject<T[]>;
   hasMore$: Observable<boolean>;
   private collectionData;
   private observablesRegistry;
-  private updateSubscription;
   private upsertData;
+  private _loading$;
+  private _values$;
   private _hasMore$;
-  private _destroy$;
   constructor(fetchController: FetchController<T>, update$: Observable<Partial<T>>, onError?: ((error: Error) => void) | undefined);
+  get loading$(): Observable<boolean>;
   get loading(): boolean;
+  get values$(): Observable<T[]>;
   get hasMore(): boolean;
   get updated$(): Observable<void>;
   get values(): T[];
@@ -789,6 +1050,35 @@ declare class EntityCollectionTransformed<O extends Entity = Entity, T extends E
   destroy(): void;
 }
 //#endregion
+//#region src/core/entities/types/participant.types.d.ts
+/** Options for selecting a media device. */
+interface SelectDeviceOptions {
+  savePreference?: boolean;
+}
+//#endregion
+//#region src/controllers/RTCStatsMonitor.d.ts
+interface NetworkIssue {
+  type: 'no_inbound_audio' | 'no_inbound_video' | 'high_rtt' | 'high_packet_loss' | 'high_jitter' | 'ice_disconnected';
+  severity: 'warning' | 'critical';
+  timestamp: number;
+  value?: number;
+  threshold?: number;
+}
+interface NetworkMetrics {
+  timestamp: number;
+  audio: {
+    packetsReceived: number;
+    packetsLost: number;
+    jitter: number;
+  };
+  video: {
+    packetsReceived: number;
+    packetsLost: number;
+  };
+  roundTripTime: number;
+  availableOutgoingBitrate?: number;
+}
+//#endregion
 //#region src/managers/types/verto-manager.types.d.ts
 type ScreenShareStatus = 'none' | 'starting' | 'started' | 'stopping';
 type SignalingStatus = Extract<CallStatus, 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnected' | 'failed'>;
@@ -861,19 +1151,306 @@ declare class MediaTrackError extends Error {
   originalError: unknown;
   constructor(operation: string, kind: string, originalError: unknown);
 }
+declare class DPoPInitError extends Error {
+  originalError: unknown;
+  constructor(originalError: unknown, message?: string);
+}
+/**
+ * Error thrown when a recovery attempt fails.
+ *
+ * Carries the recovery action and attempt number for diagnostic purposes.
+ */
+declare class RecoveryError extends Error {
+  action: string;
+  attempt: number;
+  originalError?: unknown | undefined;
+  constructor(action: string, attempt: number, originalError?: unknown | undefined);
+}
+/**
+ * Error thrown when getUserMedia fails with OverconstrainedError
+ * and all fallback levels have been exhausted.
+ */
+declare class OverconstrainedFallbackError extends Error {
+  deviceKind: string;
+  originalError?: unknown | undefined;
+  constructor(deviceKind: string, originalError?: unknown | undefined);
+}
+/**
+ * Error thrown when the preflight connectivity test fails.
+ */
+declare class PreflightError extends Error {
+  phase: string;
+  originalError?: unknown | undefined;
+  constructor(phase: string, originalError?: unknown | undefined);
+}
+declare class DeviceTokenError extends Error {
+  originalError?: unknown | undefined;
+  constructor(message: string, originalError?: unknown | undefined);
+}
+declare class TokenRefreshError extends Error {
+  originalError?: unknown | undefined;
+  constructor(message: string, originalError?: unknown | undefined);
+}
+//#endregion
+//#region src/core/types/resilience.types.d.ts
+/**
+ * Types for SDK resilience, recovery, diagnostics, and quality monitoring.
+ *
+ * These types support:
+ * - WebRTC stats monitoring (Section 1)
+ * - Tiered recovery system (Section 2)
+ * - Device recovery events (Section 5)
+ * - Tab visibility handling (Section 4)
+ * - Audio/video constraint management (Section 16)
+ * - Network resilience & recovery pipeline (Section 19)
+ * - Preflight connectivity test (Section 20)
+ * - Call quality score (Section 21)
+ * - Graceful degradation (Section 22)
+ * - Platform capability detection (Section 24)
+ * - Structured diagnostic log export (Section 26)
+ */
+/** Simplified quality level for UI indicators, derived from MOS score. */
+type QualityLevel = 'excellent' | 'good' | 'fair' | 'poor' | 'critical';
+/**
+ * Extended call status that includes the 'recovering' state.
+ *
+ * Used when the SDK is attempting to recover a call after a network
+ * disruption or media failure.
+ */
+type ResilienceCallStatus = 'new' | 'trying' | 'ringing' | 'connecting' | 'connected' | 'recovering' | 'disconnecting' | 'disconnected' | 'failed' | 'destroyed';
+type NetworkMetrics$1 = NetworkMetrics;
+/** Event emitted when a recovery action is taken on a call. */
+interface RecoveryEvent {
+  /** The recovery action that was taken. */
+  readonly action: 'keyframe_requested' | 'reinvite_started' | 'reinvite_succeeded' | 'reinvite_failed' | 'reinvite_timeout' | 'max_attempts_reached' | 'call_recovering' | 'call_recovered' | 'call_recovery_failed' | 'signal_reconnect' | 'full_reconnect' | 'video_disabled' | 'video_restored';
+  /** Human-readable description of why recovery was triggered. */
+  readonly reason: string;
+  /** Current attempt number (for multi-attempt recoveries). */
+  readonly attempt?: number;
+  /** Maximum number of attempts allowed. */
+  readonly maxAttempts?: number;
+  /** Timestamp when the event occurred (epoch ms). */
+  readonly timestamp: number;
+}
+/** State of the recovery pipeline state machine (Section 19.7). */
+type RecoveryState = 'idle' | 'debouncing' | 'recovering' | 'cooldown';
+/** Event emitted when the SDK auto-switches a device. */
+interface DeviceRecoveryEvent {
+  /** The kind of device that was switched. */
+  readonly kind: 'audioinput' | 'audiooutput' | 'videoinput';
+  /** The device that was previously selected (null if none). */
+  readonly previousDevice: MediaDeviceInfo | null;
+  /** The device that was selected as a replacement (null if none available). */
+  readonly newDevice: MediaDeviceInfo | null;
+  /** The reason for the device switch. */
+  readonly reason: 'device_disconnected' | 'device_reconnected' | 'session_restored' | 'fallback_to_default' | 'default_changed' | 'ambiguous_match';
+}
+/**
+ * Serializable subset of MediaDeviceInfo for persistence.
+ *
+ * The browser's MediaDeviceInfo interface is not serializable.
+ * This stores the fields needed for device recovery across sessions.
+ */
+interface StoredDevicePreference {
+  /** The device ID. */
+  readonly deviceId: string;
+  /** The human-readable label. */
+  readonly label: string;
+  /** The device kind. */
+  readonly kind: MediaDeviceKind;
+  /** The group ID (identifies the physical device). */
+  readonly groupId: string;
+}
+/** Result of a media permissions request (Section 5.10). */
+interface PermissionResult {
+  /** Whether audio permission was granted. */
+  readonly audio: boolean;
+  /** Whether video permission was granted. */
+  readonly video: boolean;
+  /** The audio device the user selected in the browser picker, if any. */
+  readonly selectedAudioDevice?: MediaDeviceInfo;
+  /** The video device the user selected in the browser picker, if any. */
+  readonly selectedVideoDevice?: MediaDeviceInfo;
+}
+/** Event emitted when getUserMedia falls back to looser constraints. */
+interface ConstraintFallbackEvent {
+  /** The kind of input device. */
+  readonly kind: 'audioinput' | 'videoinput';
+  /** The device that was originally requested. */
+  readonly requestedDevice: MediaDeviceInfo | null;
+  /** The device that the browser actually provided. */
+  readonly actualDevice: MediaDeviceInfo | null;
+  /** The constraint level that succeeded. */
+  readonly fallbackLevel: 'exact' | 'preferred' | 'default';
+}
+/** Browser/platform WebRTC capability flags. */
+interface PlatformCapabilities {
+  /** Whether screen sharing is supported. */
+  readonly screenShare: boolean;
+  /** Whether screen share can include system audio (Chrome-only). */
+  readonly screenShareAudio: boolean;
+  /** Whether simulcast is supported. */
+  readonly simulcast: boolean;
+  /** Whether insertable streams / encoded transforms are available. */
+  readonly insertableStreams: boolean;
+  /** Whether setSinkId (audio output selection) is supported. */
+  readonly audioOutputSelection: boolean;
+  /** List of supported video codecs. */
+  readonly videoCodecs: readonly string[];
+  /** List of supported audio codecs. */
+  readonly audioCodecs: readonly string[];
+  /** Whether the browser supports WebRTC at all. */
+  readonly webrtc: boolean;
+  /** Whether getUserMedia is available. */
+  readonly getUserMedia: boolean;
+  /** Whether getDisplayMedia is available. */
+  readonly getDisplayMedia: boolean;
+}
+/** Options for the preflight connectivity test. */
+interface PreflightOptions {
+  /** How long to run the media test in seconds (default: 10). */
+  readonly duration?: number;
+  /** Skip the media/bandwidth test, only test signaling + TURN + devices. */
+  readonly skipMediaTest?: boolean;
+  /** Test a specific audio device instead of the currently selected one. */
+  readonly audioDevice?: MediaDeviceInfo;
+  /** Test a specific video device instead of the currently selected one. */
+  readonly videoDevice?: MediaDeviceInfo;
+}
+/** Results of a preflight connectivity test. */
+interface PreflightResult {
+  /** Overall pass/fail. */
+  readonly ok: boolean;
+  /** Signaling server reachability. */
+  readonly signaling: {
+    readonly reachable: boolean;
+    readonly rttMs: number;
+  };
+  /** ICE/TURN connectivity. */
+  readonly connectivity: {
+    /** 'direct' = host/srflx worked, 'relay' = only TURN relay, 'failed' = nothing. */
+    readonly type: 'direct' | 'relay' | 'failed';
+    /** Whether TURN servers are reachable. */
+    readonly turnReachable: boolean;
+    /** Whether STUN servers are reachable. */
+    readonly stunReachable: boolean;
+    /** RTT to media server in ms. */
+    readonly rttMs: number;
+  };
+  /** Bandwidth estimation (null if skipMediaTest). */
+  readonly bandwidth: {
+    readonly uploadKbps: number;
+    readonly downloadKbps: number;
+  } | null;
+  /** Device test results. */
+  readonly devices: {
+    readonly audioInput: {
+      readonly working: boolean;
+      readonly device: MediaDeviceInfo | null;
+    };
+    readonly videoInput: {
+      readonly working: boolean;
+      readonly device: MediaDeviceInfo | null;
+    };
+    readonly audioOutput: {
+      readonly available: boolean;
+      readonly device: MediaDeviceInfo | null;
+    };
+  };
+  /** Human-readable warnings. */
+  readonly warnings: readonly string[];
+}
+/** Event emitted when audio constraints change on a call. */
+interface AudioConstraintsEvent {
+  /** The new constraints applied. */
+  readonly constraints: MediaTrackConstraints;
+  /** How the constraints were applied. */
+  readonly method: 'applyConstraints' | 'trackReplacement';
+  /** Timestamp when the event occurred (epoch ms). */
+  readonly timestamp: number;
+}
+/** Event emitted when server-pushed media params are applied. */
+interface MediaParamsEvent {
+  /** Audio constraints pushed by the server, if any. */
+  readonly audio?: MediaTrackConstraints;
+  /** Video constraints pushed by the server, if any. */
+  readonly video?: MediaTrackConstraints;
+  /** Timestamp when the event occurred (epoch ms). */
+  readonly timestamp: number;
+}
+/** Structured diagnostic bundle for a session. */
+interface SessionDiagnostics {
+  /** SDK version. */
+  readonly sdkVersion: string;
+  /** Browser/platform user agent string. */
+  readonly userAgent: string;
+  /** Platform capabilities detected at construction time. */
+  readonly capabilities: PlatformCapabilities;
+  /** Timeline of significant events during the session. */
+  readonly events: readonly DiagnosticEvent[];
+  /** Quality summary per call. */
+  readonly calls: readonly CallDiagnosticSummary[];
+  /** Device changes that occurred during the session. */
+  readonly deviceChanges: readonly DeviceRecoveryEvent[];
+  /** Current device list snapshot. */
+  readonly devices: {
+    readonly audioInput: readonly MediaDeviceInfo[];
+    readonly audioOutput: readonly MediaDeviceInfo[];
+    readonly videoInput: readonly MediaDeviceInfo[];
+  };
+}
+/** A single diagnostic event in the session timeline. */
+interface DiagnosticEvent {
+  /** Timestamp when the event occurred (epoch ms). */
+  readonly timestamp: number;
+  /** Category of the event. */
+  readonly category: 'connection' | 'call' | 'device' | 'recovery' | 'error';
+  /** Event description string. */
+  readonly event: string;
+  /** Additional details about the event. */
+  readonly details?: Readonly<Record<string, unknown>>;
+}
+/** Quality summary for a single call in the diagnostic bundle. */
+interface CallDiagnosticSummary {
+  /** Unique call ID. */
+  readonly callId: string;
+  /** Whether the call was inbound or outbound. */
+  readonly direction: 'inbound' | 'outbound';
+  /** The destination dialed, if outbound. */
+  readonly destination?: string;
+  /** Total call duration in seconds. */
+  readonly duration: number;
+  /** Final call status. */
+  readonly status: string;
+  /** Average MOS quality score over the call. */
+  readonly avgQualityScore: number;
+  /** Worst (minimum) MOS quality score during the call. */
+  readonly minQualityScore: number;
+  /** Number of recovery attempts made during the call. */
+  readonly recoveryAttempts: number;
+  /** ICE candidate types that were used. */
+  readonly iceCandidateTypes: readonly string[];
+  /** Final network metrics snapshot at call end. */
+  readonly finalMetrics: NetworkMetrics$1;
+}
 //#endregion
 //#region src/core/RPCMessages/RPCConnect.d.ts
 interface Authorization {
   jti: string;
   project_id: string;
+  data_zone?: string;
+  scope?: string[];
   fabric_subscriber: {
     version: number;
     expires_at: number;
     subscriber_id: string;
-    application_id: string;
+    application_id: string | null;
     project_id: string;
     space_id: string;
   };
+  cnf?: {
+    jkt: string;
+  };
 }
 //#endregion
 //#region src/core/utils.d.ts
@@ -1000,40 +1577,107 @@ declare class SelfCapabilities extends Destroyable {
   get state(): CallCapabilitiesState;
 }
 //#endregion
-//#region src/core/entities/types/participant.types.d.ts
-interface SelectDeviceOptions {
-  savePreference?: boolean;
-}
-//#endregion
 //#region src/interfaces/DeviceController.d.ts
 /**
- * Device interface for media device management
- * Provides access to media devices and device selection
+ * Interface for media device management.
+ *
+ * Provides reactive access to available media devices, device selection,
+ * and monitoring for device changes (connect/disconnect).
  */
 interface DeviceController {
+  /** Observable list of available audio input (microphone) devices. */
   readonly audioInputDevices$: Observable<MediaDeviceInfo[]>;
+  /** Observable list of available audio output (speaker) devices. */
   readonly audioOutputDevices$: Observable<MediaDeviceInfo[]>;
+  /** Observable list of available video input (camera) devices. */
   readonly videoInputDevices$: Observable<MediaDeviceInfo[]>;
+  /** Observable of the currently selected audio input device, or `null` if none. */
   readonly selectedAudioInputDevice$: Observable<MediaDeviceInfo | null>;
+  /** Observable of the currently selected audio output device, or `null` if none. */
   readonly selectedAudioOutputDevice$: Observable<MediaDeviceInfo | null>;
+  /** Observable of the currently selected video input device, or `null` if none. */
   readonly selectedVideoInputDevice$: Observable<MediaDeviceInfo | null>;
+  /** Currently selected audio input device, or `null` if none. */
   readonly selectedAudioInputDevice: MediaDeviceInfo | null;
+  /** Currently selected audio output device, or `null` if none. */
   readonly selectedAudioOutputDevice: MediaDeviceInfo | null;
+  /** Currently selected video input device, or `null` if none. */
   readonly selectedVideoInputDevice: MediaDeviceInfo | null;
+  /** Current snapshot of available audio input devices. */
   readonly audioInputDevices: MediaDeviceInfo[];
+  /** Current snapshot of available audio output devices. */
   readonly audioOutputDevices: MediaDeviceInfo[];
+  /** Current snapshot of available video input devices. */
   readonly videoInputDevices: MediaDeviceInfo[];
-  readonly selectedAudioInputDeviceConstraints: MediaTrackConstraints;
-  readonly selectedVideoInputDeviceConstraints: MediaTrackConstraints;
+  /** Media track constraints for the selected audio input device. Returns `false` when disabled. */
+  readonly selectedAudioInputDeviceConstraints: MediaTrackConstraints | boolean;
+  /** Media track constraints for the selected video input device. Returns `false` when disabled. */
+  readonly selectedVideoInputDeviceConstraints: MediaTrackConstraints | boolean;
+  /**
+   * Converts a {@link MediaDeviceInfo} to track constraints suitable for `getUserMedia`.
+   * @param deviceInfo - The device to convert, or `null` for default constraints.
+   */
   deviceInfoToConstraints(deviceInfo: MediaDeviceInfo | null): MediaTrackConstraints;
+  /**
+   * Sets the preferred audio input device for future calls.
+   * @param device - The device to select, or `null` to use the system default.
+   */
   selectAudioInputDevice(device: MediaDeviceInfo | null): void;
+  /**
+   * Sets the preferred video input device for future calls.
+   * @param device - The device to select, or `null` to use the system default.
+   */
   selectVideoInputDevice(device: MediaDeviceInfo | null): void;
+  /**
+   * Sets the preferred audio output device for future calls.
+   * @param device - The device to select, or `null` to use the system default.
+   */
   selectAudioOutputDevice(device: MediaDeviceInfo | null): void;
+  /** Starts monitoring for media device changes (connect/disconnect). */
   enableDeviceMonitoring(): void;
+  /** Stops monitoring for media device changes. */
   disableDeviceMonitoring(): void;
+  /**
+   * Returns the capabilities of a media device.
+   * @param deviceInfo - The device to query.
+   * @returns The device capabilities, or `null` if unavailable.
+   */
   getDeviceCapabilities(deviceInfo: MediaDeviceInfo): Promise<MediaTrackCapabilities | null>;
+  /**
+   * Checks whether a device is still available and usable.
+   * @param deviceInfo - The device to validate, or `null`.
+   * @returns `true` if the device is valid and available. Returns `false` for `null`, audio output devices, or unavailable devices.
+   */
   isValidDevice(deviceInfo: MediaDeviceInfo | null): Promise<boolean>;
+  /** Observable stream of errors from device enumeration and monitoring. */
   readonly errors$: Observable<Error>;
+  /**
+   * Observable that emits when the SDK auto-switches a device due to
+   * disconnect, reconnect, or recovery.
+   */
+  readonly deviceRecovered$: Observable<DeviceRecoveryEvent>;
+  /** Disables audio input (receive-only mode). No track will be acquired. */
+  disableAudioInput(): void;
+  /** Re-enables audio input, restoring the last selection or auto-selecting. */
+  enableAudioInput(): void;
+  /** Disables video input (receive-only mode). No track will be acquired. */
+  disableVideoInput(): void;
+  /** Re-enables video input, restoring the last selection or auto-selecting. */
+  enableVideoInput(): void;
+  /** Observable that emits `true` when video input is disabled (receive-only). */
+  readonly videoInputDisabled$: Observable<boolean>;
+  /** Observable that emits `true` when audio input is disabled (receive-only). */
+  readonly audioInputDisabled$: Observable<boolean>;
+  /** Whether video input is currently disabled. */
+  readonly videoInputDisabled: boolean;
+  /** Whether audio input is currently disabled. */
+  readonly audioInputDisabled: boolean;
+  /** Injects the storage manager for device persistence. */
+  setStorageManager(storageManager: StorageManager): void;
+  /** Clears all device state (history, selections, persisted prefs) and re-enumerates. */
+  clearDeviceState(): Promise<void>;
+  /** Force a device re-enumeration. */
+  enumerateDevices(): Promise<void>;
 }
 //#endregion
 //#region src/interfaces/VertoManager.d.ts
@@ -1085,45 +1729,45 @@ declare class Participant extends Destroyable implements CallParticipant {
   /** @internal */
   upnext(data: Partial<ParticipantState>): void;
   /** Observable of the participant's display name. */
-  get name$(): Observable<string>;
+  get name$(): Observable<string | undefined>;
   /** Observable of the participant type (e.g. `'member'`, `'screen'`). */
-  get type$(): Observable<string>;
+  get type$(): Observable<string | undefined>;
   /** Observable indicating whether the participant has raised their hand. */
-  get handraised$(): Observable<boolean>;
+  get handraised$(): Observable<boolean | undefined>;
   /** Observable indicating whether the participant is visible in the layout. */
-  get visible$(): Observable<boolean>;
+  get visible$(): Observable<boolean | undefined>;
   /** Observable indicating whether the participant's audio is muted. */
-  get audioMuted$(): Observable<boolean>;
+  get audioMuted$(): Observable<boolean | undefined>;
   /** Observable indicating whether the participant's video is muted. */
-  get videoMuted$(): Observable<boolean>;
+  get videoMuted$(): Observable<boolean | undefined>;
   /** Observable indicating whether the participant is deafened. */
-  get deaf$(): Observable<boolean>;
+  get deaf$(): Observable<boolean | undefined>;
   /** Observable of the participant's microphone input volume. */
-  get inputVolume$(): Observable<number>;
+  get inputVolume$(): Observable<number | undefined>;
   /** Observable of the participant's speaker output volume. */
-  get outputVolume$(): Observable<number>;
+  get outputVolume$(): Observable<number | undefined>;
   /** Observable of the microphone input sensitivity level. */
-  get inputSensitivity$(): Observable<number>;
+  get inputSensitivity$(): Observable<number | undefined>;
   /** Observable indicating whether echo cancellation is enabled. */
-  get echoCancellation$(): Observable<boolean>;
+  get echoCancellation$(): Observable<boolean | undefined>;
   /** Observable indicating whether auto-gain control is enabled. */
-  get autoGain$(): Observable<boolean>;
+  get autoGain$(): Observable<boolean | undefined>;
   /** Observable indicating whether noise suppression is enabled. */
-  get noiseSuppression$(): Observable<boolean>;
+  get noiseSuppression$(): Observable<boolean | undefined>;
   /** Observable indicating whether low-bitrate mode is active. */
-  get lowbitrate$(): Observable<boolean>;
+  get lowbitrate$(): Observable<boolean | undefined>;
   /** Observable indicating whether noise reduction is active. */
-  get denoise$(): Observable<boolean>;
+  get denoise$(): Observable<boolean | undefined>;
   /** Observable of custom metadata for this participant. */
-  get meta$(): Observable<Record<string, unknown>>;
+  get meta$(): Observable<Record<string, unknown> | undefined>;
   /** Observable of the participant's subscriber ID. */
-  get subscriberId$(): Observable<string>;
+  get subscriberId$(): Observable<string | undefined>;
   /** Observable of the participant's address ID. */
-  get addressId$(): Observable<string>;
+  get addressId$(): Observable<string | undefined>;
   /** Observable of the server node ID for this participant. */
-  get nodeId$(): Observable<string>;
+  get nodeId$(): Observable<string | undefined>;
   /** Observable indicating whether the participant is currently speaking. */
-  get isTalking$(): Observable<boolean>;
+  get isTalking$(): Observable<boolean | undefined>;
   /** Whether the participant is currently speaking. */
   get isTalking(): boolean;
   /** Observable of the participant's layout position. */
@@ -1136,22 +1780,39 @@ declare class Participant extends Destroyable implements CallParticipant {
   get name(): string | undefined;
   /** Participant type (e.g. `'member'`, `'screen'`). */
   get type(): string | undefined;
+  /** Whether the participant has raised their hand. */
   get handraised(): boolean;
+  /** Whether the participant is visible in the layout. */
   get visible(): boolean;
+  /** Whether the participant's audio is muted. */
   get audioMuted(): boolean;
+  /** Whether the participant's video is muted. */
   get videoMuted(): boolean;
+  /** Whether the participant is deafened (incoming audio muted). */
   get deaf(): boolean;
+  /** Current microphone input volume level, or `undefined` if not set. */
   get inputVolume(): number | undefined;
+  /** Current speaker output volume level, or `undefined` if not set. */
   get outputVolume(): number | undefined;
+  /** Current microphone input sensitivity level, or `undefined` if not set. */
   get inputSensitivity(): number | undefined;
+  /** Whether echo cancellation is enabled. */
   get echoCancellation(): boolean;
+  /** Whether automatic gain control is enabled. */
   get autoGain(): boolean;
+  /** Whether noise suppression is enabled. */
   get noiseSuppression(): boolean;
+  /** Whether low-bitrate mode is active. */
   get lowbitrate(): boolean;
+  /** Whether noise reduction (denoise) is active. */
   get denoise(): boolean;
+  /** Custom metadata for this participant, or `undefined` if not set. */
   get meta(): Record<string, unknown> | undefined;
+  /** Subscriber ID of this participant, or `undefined` if not available. */
   get subscriberId(): string | undefined;
+  /** Address ID of this participant, or `undefined` if not available. */
   get addressId(): string | undefined;
+  /** Server node ID for this participant, or `undefined` if not available. */
   get nodeId(): string | undefined;
   /** @internal */
   get value(): Partial<Member>;
@@ -1180,18 +1841,38 @@ declare class Participant extends Destroyable implements CallParticipant {
   toggleLowbitrate(): Promise<void>;
   /** Sets the microphone input sensitivity level. */
   setAudioInputSensitivity(value: number): Promise<void>;
-  /** Sets the microphone input volume level. */
+  /**
+   * Sets the microphone input volume level.
+   * @param value - Volume level (0-100).
+   */
   setAudioInputVolume(value: number): Promise<void>;
-  /** Sets the speaker output volume level. */
+  /**
+   * Sets the speaker output volume level.
+   * @param value - Volume level (0-100).
+   */
   setAudioOutputVolume(value: number): Promise<void>;
-  /** Sets the participant's position in the video layout. */
+  /**
+   * Sets the participant's position in the video layout.
+   * @param value - The {@link VideoPosition} to assign (e.g. `'auto'`, `'reserved-0'`).
+   */
   setPosition(value: VideoPosition): Promise<void>;
   /** Removes this participant from the call. */
   remove(): Promise<void>;
   /** Ends the call for this participant. */
   end(): Promise<void>;
+  /**
+   * Replaces custom metadata for this participant.
+   * @param _meta - Metadata object to set.
+   * @throws {UnimplementedError} Not yet implemented.
+   */
   setMeta(_meta: Record<string, unknown>): Promise<void>;
+  /**
+   * Merges values into custom metadata (unlike {@link setMeta} which replaces).
+   * @param _meta - Metadata to merge.
+   * @throws {UnimplementedError} Not yet implemented.
+   */
   updateMeta(_meta: Record<string, unknown>): Promise<void>;
+  /** Destroys the participant, releasing all subscriptions and references. */
   destroy(): void;
 }
 /**
@@ -1207,8 +1888,29 @@ declare class SelfParticipant extends Participant implements CallSelfParticipant
    * Contains all capability flags as both observables and values.
    */
   readonly capabilities: SelfCapabilities;
+  /**
+   * Studio audio mode state. When enabled, all audio processing
+   * (echo cancellation, noise suppression, auto gain control) is disabled
+   * to provide raw/unprocessed audio for musicians, podcasters, etc.
+   */
+  private _studioAudio$;
+  /** @internal */
   constructor(id: string, executeMethod: ExecuteMethod, vertoManager: VertoManager, deviceController: DeviceController);
   destroy(): void;
+  /** Observable indicating whether studio audio (raw/unprocessed audio) mode is enabled. */
+  get studioAudio$(): Observable<boolean>;
+  /** Whether studio audio (raw/unprocessed audio) mode is currently enabled. */
+  get studioAudio(): boolean;
+  /**
+   * Enables studio audio mode by disabling all audio processing.
+   * Sets echoCancellation, noiseSuppression, and autoGainControl to false.
+   */
+  enableStudioAudio(): Promise<void>;
+  /**
+   * Disables studio audio mode by restoring all audio processing to enabled.
+   * Sets echoCancellation, noiseSuppression, and autoGainControl to true.
+   */
+  disableStudioAudio(): Promise<void>;
   /** Starts sharing the local screen. */
   startScreenShare(): Promise<void>;
   /** Observable of the current screen share status. */
@@ -1254,9 +1956,24 @@ declare class SelfParticipant extends Participant implements CallSelfParticipant
   setVideoInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<void>;
   /** Selects the audio output device. Optionally saves as a preference. */
   selectAudioOutputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  /**
+   * Exits studio audio mode without restoring defaults.
+   * Called internally before individual audio flag toggles.
+   */
+  private exitStudioModeIfActive;
+  /** Toggles echo cancellation. Exits studio mode if active. */
+  toggleEchoCancellation(): Promise<void>;
+  /** Toggles automatic gain control. Exits studio mode if active. */
+  toggleAudioInputAutoGain(): Promise<void>;
+  /** Toggles noise suppression. Exits studio mode if active. */
+  toggleNoiseSuppression(): Promise<void>;
+  /** Mutes local audio. Falls back to local device mute if the server RPC fails. */
   mute(): Promise<void>;
+  /** Unmutes local audio. Falls back to local device unmute if the server RPC fails. */
   unmute(): Promise<void>;
+  /** Mutes local video. Falls back to local device mute if the server RPC fails. */
   muteVideo(): Promise<void>;
+  /** Unmutes local video. Falls back to local device unmute if the server RPC fails. */
   unmuteVideo(): Promise<void>;
 }
 /** Type guard that checks if a participant is the local {@link SelfParticipant}. */
@@ -1269,26 +1986,26 @@ declare const isSelfParticipant: (participant: Participant) => participant is Se
  */
 interface CallParticipant {
   readonly id: string;
-  readonly name$: Observable<string>;
-  readonly type$: Observable<string>;
-  readonly handraised$: Observable<boolean>;
-  readonly visible$: Observable<boolean>;
-  readonly audioMuted$: Observable<boolean>;
-  readonly videoMuted$: Observable<boolean>;
-  readonly deaf$: Observable<boolean>;
-  readonly inputVolume$: Observable<number>;
-  readonly outputVolume$: Observable<number>;
-  readonly inputSensitivity$: Observable<number>;
-  readonly echoCancellation$: Observable<boolean>;
-  readonly autoGain$: Observable<boolean>;
-  readonly noiseSuppression$: Observable<boolean>;
-  readonly lowbitrate$: Observable<boolean>;
-  readonly denoise$: Observable<boolean>;
-  readonly meta$: Observable<Record<string, unknown>>;
-  readonly subscriberId$: Observable<string>;
-  readonly addressId$: Observable<string>;
-  readonly nodeId$: Observable<string>;
-  readonly isTalking$: Observable<boolean>;
+  readonly name$: Observable<string | undefined>;
+  readonly type$: Observable<string | undefined>;
+  readonly handraised$: Observable<boolean | undefined>;
+  readonly visible$: Observable<boolean | undefined>;
+  readonly audioMuted$: Observable<boolean | undefined>;
+  readonly videoMuted$: Observable<boolean | undefined>;
+  readonly deaf$: Observable<boolean | undefined>;
+  readonly inputVolume$: Observable<number | undefined>;
+  readonly outputVolume$: Observable<number | undefined>;
+  readonly inputSensitivity$: Observable<number | undefined>;
+  readonly echoCancellation$: Observable<boolean | undefined>;
+  readonly autoGain$: Observable<boolean | undefined>;
+  readonly noiseSuppression$: Observable<boolean | undefined>;
+  readonly lowbitrate$: Observable<boolean | undefined>;
+  readonly denoise$: Observable<boolean | undefined>;
+  readonly meta$: Observable<Record<string, unknown> | undefined>;
+  readonly subscriberId$: Observable<string | undefined>;
+  readonly addressId$: Observable<string | undefined>;
+  readonly nodeId$: Observable<string | undefined>;
+  readonly isTalking$: Observable<boolean | undefined>;
   readonly position$: Observable<LayoutLayer | undefined>;
   readonly name: string | undefined;
   readonly type: string | undefined;
@@ -1338,13 +2055,34 @@ interface CallParticipant {
  * Extends CallParticipant with methods for controlling the local participant
  */
 interface CallSelfParticipant extends CallParticipant {
-  readonly screenShareStatus$: Observable<string>;
-  readonly screenShareStatus: string;
+  readonly screenShareStatus$: Observable<ScreenShareStatus>;
+  readonly screenShareStatus: ScreenShareStatus;
+  readonly studioAudio$: Observable<boolean>;
+  readonly studioAudio: boolean;
+  enableStudioAudio(): Promise<void>;
+  disableStudioAudio(): Promise<void>;
   startScreenShare(): Promise<void>;
   stopScreenShare(): Promise<void>;
-  selectAudioInputDevice(device: MediaDeviceInfo): void;
-  selectVideoInputDevice(device: MediaDeviceInfo): void;
-  selectAudioOutputDevice(device: MediaDeviceInfo): void;
+  selectAudioInputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  selectVideoInputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  selectAudioOutputDevice(device: MediaDeviceInfo, options?: SelectDeviceOptions): void;
+  addAdditionalDevice(options: MediaOptions): Promise<void>;
+  removeAdditionalDevice(id: string): Promise<void>;
+  addAudioInputDevice(options?: {
+    constraints?: MediaTrackConstraints;
+    stream?: MediaStream;
+  }): Promise<void>;
+  addVideoInputDevice(options?: {
+    constraints?: MediaTrackConstraints;
+    stream?: MediaStream;
+  }): Promise<void>;
+  addInputDevices(options?: MediaOptions): Promise<void>;
+  setAudioInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<void>;
+  setVideoInputDeviceConstraints(constraints: MediaTrackConstraints): Promise<void>;
+  setInputDevicesConstraints(constraints: {
+    audio: MediaTrackConstraints;
+    video: MediaTrackConstraints;
+  }): Promise<void>;
 }
 /**
  * Minimal interface for a collection with pagination
@@ -1366,7 +2104,7 @@ interface CallAddress {
   readonly textMessages$: Observable<CallTextMessageCollection | undefined>;
 }
 /** Lifecycle status of a call. */
-type CallStatus = 'new' | 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'failed' | 'destroyed';
+type CallStatus = 'new' | 'trying' | 'ringing' | 'connecting' | 'connected' | 'recovering' | 'disconnecting' | 'disconnected' | 'failed' | 'destroyed';
 /** Configuration options for creating a call. */
 interface CallOptions extends MediaOptions {
   /** Target server node ID. */
@@ -1389,6 +2127,12 @@ interface CallOptions extends MediaOptions {
   readonly displayDirection?: string;
   /** Custom user variables sent with the call invite. */
   readonly userVariables?: Record<string, unknown>;
+  /** Preferred video codecs for this call (overrides global preferences). */
+  readonly preferredVideoCodecs?: string[];
+  /** Preferred audio codecs for this call (overrides global preferences). */
+  readonly preferredAudioCodecs?: string[];
+  /** Enable stereo Opus for this call (overrides global preferences). */
+  readonly stereo?: boolean;
 }
 /** Observable state of a call (status, recording, participants, etc.). */
 interface CallState {
@@ -1417,23 +2161,26 @@ interface CallState {
  * and control actions (hangup, mute, transfer, etc.).
  */
 interface Call extends CallState {
-  readonly capabilities$: Observable<string[]>;
-  readonly capabilities: string[];
+  readonly capabilities$: Observable<Capability[]>;
+  readonly capabilities: Capability[];
   readonly mediaDirections$: Observable<MediaDirections>;
   readonly mediaDirections: MediaDirections;
   readonly self$: Observable<CallSelfParticipant | null>;
   readonly self: CallSelfParticipant | null;
   readonly to?: string;
-  readonly direction: 'inbound' | 'outbound';
+  readonly direction: CallDirection;
   readonly layouts$: Observable<string[]>;
   readonly layouts: string[];
   readonly layout$: Observable<string>;
   readonly layout?: string;
   readonly layoutLayers$: Observable<LayoutLayer[]>;
   readonly layoutLayers: LayoutLayer[];
-  readonly localStream$: Observable<MediaStream | null>;
+  /** Observable that emits only non-null MediaStreams (waits until the stream exists). */
+  readonly localStream$: Observable<MediaStream>;
+  /** Sync getter — returns null before the stream is created. */
   readonly localStream: MediaStream | null;
-  readonly remoteStream$: Observable<MediaStream | null>;
+  /** Observable that emits only non-null MediaStreams (waits until the stream exists). */
+  readonly remoteStream$: Observable<MediaStream>;
   readonly remoteStream: MediaStream | null;
   readonly rtcPeerConnection: RTCPeerConnection | undefined;
   readonly errors$: Observable<CallError>;
@@ -1442,6 +2189,21 @@ interface Call extends CallState {
   readonly address$: Observable<CallAddress | undefined>;
   userVariables?: Record<string, unknown>;
   readonly userVariables$: Observable<Record<string, unknown>>;
+  readonly networkIssues$: Observable<NetworkIssue[]>;
+  readonly networkIssues: NetworkIssue[];
+  readonly isNetworkHealthy$: Observable<boolean>;
+  readonly isNetworkHealthy: boolean;
+  readonly networkMetrics$: Observable<NetworkMetrics[]>;
+  readonly networkMetrics: NetworkMetrics[];
+  readonly qualityScore$: Observable<number>;
+  readonly qualityLevel$: Observable<QualityLevel>;
+  readonly recoveryState$: Observable<RecoveryState>;
+  readonly recoveryEvent$: Observable<RecoveryEvent>;
+  readonly bandwidthConstrained$: Observable<boolean>;
+  readonly mediaParamsUpdated$: Observable<MediaParamsEvent>;
+  requestKeyframe(): void;
+  requestIceRestart(): Promise<void>;
+  subscribe(eventType: string): Observable<Record<string, unknown>>;
   hangup(): Promise<void>;
   toggleLock(): Promise<void>;
   toggleHold(): Promise<void>;
@@ -1493,7 +2255,7 @@ interface CallManager extends Call {
  * This interface breaks the circular dependency between Address and Directory
  * by providing a minimal contract that Address needs from the Directory.
  *
- * @typeParam TAddress - The Address type, defaults to never to enforce explicit typing
+ * @template TAddress - The Address type, defaults to never to enforce explicit typing
  *
  * @remarks
  * Uses a generic type parameter to maintain type safety while avoiding
@@ -1514,7 +2276,7 @@ interface AddressProvider<TAddress = never> {
  * Address history entry from conversation messages
  * Contains a reference to the sender address as an observable
  *
- * @typeParam TAddress - The Address type, provided by the implementation
+ * @template TAddress - The Address type, provided by the implementation
  *
  * @remarks
  * Uses a generic type parameter to maintain type safety while avoiding
@@ -1532,7 +2294,7 @@ interface AddressHistory<TAddress = never> {
  * Text message from conversation
  * Contains a reference to the sender address as an observable
  *
- * @typeParam TAddress - The Address type, provided by the implementation
+ * @template TAddress - The Address type, provided by the implementation
  *
  * @remarks
  * Uses a generic type parameter to maintain type safety while avoiding
@@ -1675,11 +2437,35 @@ declare class Address extends Destroyable {
   get locked(): boolean;
   /** Observable indicating whether the address (room) is locked. */
   get locked$(): Observable<boolean>;
-  /** Sends a text message to this address. */
+  /**
+   * Sends a text message to this address.
+   *
+   * @param text - The message text to send.
+   *
+   * @example
+   * ```ts
+   * await address.sendText('Hello!');
+   * ```
+   */
   sendText(text: string): Promise<void>;
-  /** Collection of text messages for this address, with pagination support. */
+  /**
+   * Collection of text messages for this address, with pagination support.
+   *
+   * Returns `undefined` until {@link textMessages$} has been subscribed to (lazy-loaded).
+   * Filters to `'chat'` subtype messages from the conversation.
+   *
+   * @see {@link textMessages$} to trigger lazy loading.
+   * @see {@link sendText} to send a new message.
+   */
   get textMessage(): EntityCollectionTransformed<GetConversationMessageResponse, TextMessage<Address>> | undefined;
-  /** Collection of call history entries for this address, with pagination support. */
+  /**
+   * Collection of call history entries for this address, with pagination support.
+   *
+   * Returns `undefined` until {@link history$} has been subscribed to (lazy-loaded).
+   * Filters to `'log'` subtype messages including kind, status, start/end times.
+   *
+   * @see {@link history$} to trigger lazy loading.
+   */
   get history(): EntityCollectionTransformed<GetConversationMessageResponse, AddressHistory<Address>> | undefined;
   /** Observable of active call states for this address. @throws {UnimplementedError} Requires presence support. */
   get activity$(): Observable<CallState[]>;
@@ -1692,10 +2478,19 @@ interface AttachableCall {
   id: string;
   to?: string;
   mediaDirections: MediaDirections;
+  nodeId?: string;
 }
 interface OutboundCallProvider {
   createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
 }
+interface Attachment {
+  destination: string;
+  mediaDirections: MediaDirections;
+  audioInputDevice: MediaDeviceInfo | null;
+  videoInputDevice: MediaDeviceInfo | null;
+  nodeId?: string;
+  attachedAt: number;
+}
 declare class AttachManager {
   private readonly storage;
   private readonly deviceController;
@@ -1710,8 +2505,32 @@ declare class AttachManager {
   attach(call: AttachableCall): Promise<void>;
   detach(call: AttachableCall): Promise<void>;
   flush(): Promise<void>;
+  /**
+   * Reattach to previously active calls by sending verto.invite with
+   * reattaching: true.
+   *
+   * NOTE: This currently fails with INVALID_CALL_REFERENCE because the
+   * server's jsock UUID check rejects the new connection's UUID. A
+   * server-side fix is needed: when reattaching: true is explicitly set
+   * in dialogParams, FreeSWITCH's attempt_reattach() should update the
+   * call's jsock reference to the new connection's UUID instead of
+   * rejecting. Once that fix is deployed, this will work for both
+   * page reloads and WebSocket reconnects.
+   *
+   * Failed reattach attempts are handled gracefully — the stale call
+   * reference is cleaned up from storage.
+   */
   reattachCalls(): Promise<void>;
-  private buildCallOptions;
+  /**
+   * Build CallOptions from stored attachment data for a call being reattached.
+   * Also used by the session-level verto.attach handler.
+   */
+  buildCallOptions(attachment: Attachment): CallOptions;
+  /**
+   * Consume stored attachment data for a pending call (used by session-level
+   * verto.attach handler as a future path when server supports it).
+   */
+  consumePendingAttachment(_callId: string): CallOptions | undefined;
   private detachExpired;
 }
 //#endregion
@@ -1720,22 +2539,6 @@ declare class TransportManager extends Destroyable {
   private readonly storage;
   private readonly protocolKey;
   private readonly onError?;
-  /**
-   * Normalise a server event timestamp to epoch seconds.
-   *
-   * The server uses two formats:
-   *   - `webrtc.message`: float epoch seconds  (e.g. 1774372099.022817)
-   *   - all other events: int epoch microseconds (e.g. 1774372099925857)
-   *
-   * Values above 1e12 are treated as microseconds and divided by 1e6.
-   */
-  private static toEpochSeconds;
-  /**
-   * Extract the event timestamp from a signalwire.event message.
-   * Returns `null` for messages that have no timestamp
-   * (e.g. signalwire.authorization.state, RPC responses).
-   */
-  private static extractEventTimestamp;
   private initialized$;
   protocol$: rxjs0.ReplaySubject<string | undefined>;
   private isConnecting;
@@ -1743,29 +2546,21 @@ declare class TransportManager extends Destroyable {
   private ackEvent;
   private replySignalwirePing;
   /**
-   * Filter that drops events whose timestamp predates the current session.
+   * Filter that drops events from a previous session after reconnect.
    *
-   * On each new connection the session epoch is reset (see `resetSessionEpoch`).
-   * The first timestamped event after reset establishes the epoch.
-   * Subsequent events with timestamps older than the epoch are discarded —
-   * this guards against stale events replayed by the server after a reconnect.
-   *
-   * Events without a timestamp (e.g. signalwire.authorization.state) and
-   * non-event messages (RPC responses) always pass through.
+   * Compares the event's `event_channel` against the current protocol.
+   * Events whose channel doesn't contain the current protocol are from
+   * a stale session and are discarded. Events without an event_channel
+   * (auth state events, RPC responses) always pass through.
    */
   private discardStaleEvents;
-  private _sessionEpoch;
+  private _currentProtocol;
   private _outgoingMessages$;
   private _webSocketConnections;
   private _jsonRPCMessage$;
   private _jsonRPCResponse$;
   private _incomingEvent$;
   constructor(storage: StorageManager, protocolKey: string, webSocketConstructor: WebSocketAdapter | NodeSocketAdapter, relayHost: string, onError?: ((error: Error) => void) | undefined);
-  /**
-   * Reset the session epoch. Call this before each signalwire.connect
-   * so that the first event after authentication establishes the new baseline.
-   */
-  resetSessionEpoch(): void;
   setProtocol(protocol: string | undefined): Promise<void>;
   get incomingEvent$(): Observable<JSONRPCRequest | JSONRPCResponse>;
   get connectionStatus$(): Observable<string>;
@@ -1780,6 +2575,101 @@ declare class TransportManager extends Destroyable {
   private _init;
 }
 //#endregion
+//#region src/controllers/CryptoController.d.ts
+/**
+ * Controls DPoP (Demonstrating Proof-of-Possession) cryptographic operations.
+ *
+ * Generates an RSA-2048 key pair where the private key is non-extractable,
+ * computes the JWK Thumbprint (RFC 7638) as the fingerprint, and creates
+ * signed DPoP proof JWTs for both HTTP API requests and WebSocket RPC calls.
+ *
+ * The key pair is persisted in IndexedDB so the same fingerprint survives
+ * page reloads. This keeps the Client Bound SAT and stored authorization_state
+ * valid across reloads without needing to re-authenticate.
+ *
+ * @example
+ * ```typescript
+ * const crypto = new CryptoController();
+ * await crypto.init();
+ *
+ * // Get fingerprint for SAT issuance
+ * const fingerprint = crypto.fingerprint;
+ *
+ * // Create proof for HTTP endpoint
+ * const httpProof = await crypto.createHttpProof({
+ *   method: 'POST',
+ *   uri: '/api/fabric/subscriber/devices/token'
+ * });
+ *
+ * // Create proof for RPC call
+ * const rpcProof = await crypto.createRpcProof({
+ *   method: 'signalwire.connect'
+ * });
+ * ```
+ */
+declare class CryptoController {
+  private _keyPair;
+  private _publicJwk;
+  private _fingerprint;
+  private _initialized;
+  /**
+   * Initializes the DPoP key pair. Loads an existing key from IndexedDB
+   * if available, otherwise generates a new one and persists it.
+   *
+   * The private key is non-extractable — IndexedDB stores the CryptoKey
+   * handle via the structured clone algorithm without exposing key material.
+   *
+   * @returns The JWK Thumbprint (fingerprint) for the key.
+   */
+  init(): Promise<string>;
+  /**
+   * The JWK Thumbprint (RFC 7638) of the public key.
+   * Used as the `fingerprint` parameter when requesting scoped SATs.
+   *
+   * @throws {DPoPInitError} If {@link init} has not been called.
+   */
+  get fingerprint(): string;
+  /**
+   * Whether the controller has been initialized with a key pair.
+   */
+  get initialized(): boolean;
+  /**
+   * Creates a DPoP proof JWT for an HTTP API request.
+   *
+   * Used for Prime API endpoints like `/api/fabric/subscriber/devices/token`
+   * and `/api/fabric/subscriber/devices/refresh`.
+   *
+   * @param params - HTTP method and URI for the proof.
+   * @returns Signed DPoP proof JWT string.
+   */
+  createHttpProof(params: DPoPHttpProofParams): Promise<string>;
+  /**
+   * Creates a DPoP proof JWT for a WebSocket RPC call.
+   *
+   * Used for switchblade RPC methods like `signalwire.connect` and
+   * `signalwire.reauthenticate`.
+   *
+   * @param params - RPC method name for the proof.
+   * @returns Signed DPoP proof JWT string.
+   */
+  createRpcProof(params: DPoPRpcProofParams): Promise<string>;
+  /**
+   * Releases the key pair references and removes the persisted key from IndexedDB.
+   * After calling destroy, the controller must be re-initialized to be used again.
+   */
+  destroy(): void;
+  private get publicJwk();
+  private get privateKey();
+  private signProof;
+}
+//#endregion
+//#region src/controllers/NetworkMonitor.d.ts
+interface NetworkChangeEvent {
+  type: 'online' | 'offline' | 'connection_change';
+  timestamp: number;
+  networkType?: string;
+}
+//#endregion
 //#region src/core/entities/Directory.d.ts
 /**
  * Directory interface for managing addresses
@@ -1853,6 +2743,12 @@ interface ClientSession {
    * Used by VertoManager to configure RTCPeerConnection
    */
   readonly iceServers: RTCIceServer[] | undefined;
+  /**
+   * Emits true when the session is authenticated, false when not.
+   * Used by Call to detect WebSocket reconnections (skip(1) + filter(true)
+   * indicates a re-authentication after the initial connect).
+   */
+  readonly authenticated$: Observable<boolean>;
 }
 //#endregion
 //#region src/interfaces/SessionState.d.ts
@@ -1886,15 +2782,31 @@ interface SessionState extends ClientSession {
    * and `false` after disconnect.
    */
   readonly authenticated$: Observable<boolean>;
+  /**
+   * Current authentication state.
+   * Returns `true` if the session is currently authenticated.
+   */
+  readonly authenticated: boolean;
 }
 //#endregion
 //#region src/managers/ClientSessionManager.d.ts
+/**
+ * Discriminated union for session authentication state.
+ * clientBound is tracked separately via _wasClientBound (sticky flag)
+ * to avoid dual sources of truth.
+ */
+type SessionAuthState = {
+  kind: 'unauthenticated';
+} | {
+  kind: 'authenticated';
+};
 declare class ClientSessionManager extends Destroyable implements SessionState {
-  private credential;
+  private readonly getCredential;
   private readonly transport;
   private readonly storage;
   private readonly authorizationStateKey;
   private readonly attachManager;
+  private readonly dpopManager?;
   private callFactory;
   private callCreateTimeout;
   private readonly agent;
@@ -1902,14 +2814,22 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
   initialized$: Observable<boolean>;
   private authorizationState$;
   private connectVersion;
+  /**
+   * Optional hook called before a fresh connect on reconnect.
+   * Used by SignalWire to refresh expired credentials before re-authenticating.
+   * @internal
+   */
+  onBeforeReconnect?: () => Promise<void>;
   private _authorization$;
   private _errors$;
   private _directory?;
-  private _authenticated$;
+  private _authState$;
+  /** Sticky flag — once true, stays true for the session lifetime. */
+  private _wasClientBound;
   private _subscriberInfo$;
   private _calls$;
   private _iceServers$;
-  constructor(credential: SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager, webRTCApiProvider: WebRTCApiProvider);
+  constructor(getCredential: () => SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager, webRTCApiProvider: WebRTCApiProvider, dpopManager?: CryptoController | undefined, networkChange$?: Observable<NetworkChangeEvent>);
   get incomingCalls$(): Observable<Call[]>;
   get incomingCalls(): Call[];
   get subscriberInfo$(): Observable<Address | null>;
@@ -1922,6 +2842,15 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
   get errors$(): Observable<Error>;
   get authenticated$(): Observable<boolean>;
   get authenticated(): boolean;
+  /**
+   * Whether this session is client-bound (using a Client Bound SAT).
+   * When client-bound, DPoP proof creation failures are treated as
+   * authentication errors rather than silently degraded.
+   * @internal
+   */
+  get clientBound(): boolean;
+  /** @internal Current auth state for debugging/testing. */
+  get authState(): SessionAuthState;
   /**
    * Set the directory instance
    * Called by SignalWire after directory is created
@@ -2010,6 +2939,16 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
     params: CallConnectPayload;
   }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "room.updated";
+    event_channel: EventChannel;
+    timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: RoomUpdatedPayload;
+  }, "event_channel"> & {
+    event_channel: string;
   }) | Omit<{
     event_type: "member.updated";
     event_channel: EventChannel;
@@ -2076,6 +3015,7 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
     is_author: boolean;
   })>;
   private get vertoInvite$();
+  private get vertoAttach$();
   private get contexts();
   private get eventing();
   private get topics();
@@ -2084,10 +3024,22 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
   private handleAuthenticationError;
   cleanupStoredConnectionParams(): Promise<void>;
   protected updateAuthState(authorization_state: string): Promise<void>;
-  reauthenticate(token: string): Promise<void>;
+  reauthenticate(token: string, dpopToken?: string, options?: {
+    clientBound?: boolean;
+  }): Promise<void>;
   private authenticate;
   disconnect(): Promise<void>;
   private createInboundCall;
+  /**
+   * Handle a server-pushed verto.attach event at the session level.
+   *
+   * On page reload the server detects the reconnected session and pushes
+   * verto.attach for any active calls. If a call object already exists
+   * (network blip, no reload), the per-call handler in VertoManager deals
+   * with it. This method only creates a new call object when no existing
+   * one matches the callID.
+   */
+  private handleVertoAttach;
   createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
   private createCall;
   destroy(): void;
@@ -2172,6 +3124,16 @@ declare class ClientSessionWrapper implements SessionState {
     params: CallConnectPayload;
   }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "room.updated";
+    event_channel: EventChannel;
+    timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: RoomUpdatedPayload;
+  }, "event_channel"> & {
+    event_channel: string;
   }) | Omit<{
     event_type: "member.updated";
     event_channel: EventChannel;
@@ -2245,6 +3207,35 @@ declare class ClientSessionWrapper implements SessionState {
   get calls(): Call[];
 }
 //#endregion
+//#region src/utils/logger.d.ts
+/** Log level names supported by the SDK. */
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Logger interface that consumers can implement to replace the built-in logger.
+ * All methods accept variadic arguments matching the browser console API.
+ */
+interface SDKLogger {
+  error(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  trace(...args: unknown[]): void;
+}
+/** Debug options that control verbose SDK logging. */
+interface DebugOptions {
+  /** Log all WebSocket send/recv traffic to the console. */
+  logWsTraffic?: boolean;
+}
+/** Replace the built-in logger with a custom implementation. Pass `null` to restore defaults. */
+declare const setLogger: (logger: SDKLogger | null) => void;
+/** Configure debug options (e.g., `{ logWsTraffic: true }`). */
+declare const setDebugOptions: (options: DebugOptions | null) => void;
+/**
+ * Set the log level for the built-in logger.
+ * Has no effect when a custom logger is set via `setLogger()`.
+ */
+declare const setLogLevel: (level: LogLevel) => void;
+//#endregion
 //#region src/clients/SignalWire.d.ts
 /** Options for constructing a {@link SignalWire}. */
 interface SignalWireOptions {
@@ -2258,15 +3249,56 @@ interface SignalWireOptions {
   reconnectAttachedCalls?: boolean;
   /** Whether to save preferences. */
   savePreferences?: boolean;
+  /**
+   * Persist the session across page reloads.
+   *
+   * When `true`, credential, authorization state, and protocol are stored in
+   * `localStorage` (survives reload). The DPoP key pair is persisted in
+   * IndexedDB. On reload, the SDK restores the session from cache
+   * without calling `credentialProvider.authenticate()`.
+   *
+   * When `false` (default), session data lives in `sessionStorage` and is
+   * lost on reload.
+   *
+   * Call {@link SignalWire.destroy | destroy()} to clear all persisted state
+   * (explicit logout).
+   */
+  persistSession?: boolean;
   /** Custom storage implementation for persistence. */
   storageImplementation?: Storage;
   /** Custom WebSocket constructor */
   webSocketConstructor?: WebSocketAdapter | NodeSocketAdapter;
   /** Custom WebRTC API provider */
   webRTCApiProvider?: WebRTCApiProvider;
+  /**
+   * Custom logger implementation. Must implement the {@link SDKLogger} interface.
+   * Pass `null` to restore the built-in logger.
+   *
+   * **Note:** Logger configuration is global — setting it on one instance affects all instances.
+   */
+  logger?: SDKLogger | null;
+  /**
+   * Log level for the built-in logger.
+   * Default: `'warn'`. Set to `'debug'` for verbose SDK output.
+   * Has no effect when a custom `logger` is provided.
+   *
+   * **Note:** Logger configuration is global — setting it on one instance affects all instances.
+   */
+  logLevel?: LogLevel;
+  /** Debug options for verbose SDK diagnostics (e.g., `{ logWsTraffic: true }`). */
+  debug?: DebugOptions;
 }
 /** Options for {@link SignalWire.dial}. Extends {@link MediaOptions} with dial-specific settings. */
-interface DialOptions extends MediaOptions {}
+interface DialOptions extends MediaOptions {
+  /** Preferred video codecs for this call (overrides global preferences). */
+  preferredVideoCodecs?: string[];
+  /** Preferred audio codecs for this call (overrides global preferences). */
+  preferredAudioCodecs?: string[];
+  /** Enable stereo Opus for this call (overrides global preferences). */
+  stereo?: boolean;
+  /** Optional node ID for routing the call */
+  nodeId?: string;
+}
 /**
  * Main entry point for the SignalWire Browser SDK.
  *
@@ -2294,9 +3326,43 @@ declare class SignalWire extends Destroyable implements DeviceController {
   private _errors$;
   private _options;
   private _refreshTimerId?;
+  private _dpopManager?;
+  private _deviceTokenManager?;
+  private _credentialProvider?;
   private _deps;
-  constructor(credentialProvider: CredentialProvider, options?: SignalWireOptions);
+  private _networkMonitor?;
+  private _visibilityController?;
+  private _diagnosticsCollector?;
+  private _platformCapabilities?;
+  /**
+   * Creates a new SignalWire client and begins connecting.
+   *
+   * @param credentialProvider - Provider that supplies authentication credentials.
+   * @param options - Configuration options (connection, device monitoring, preferences).
+   */
+  constructor(credentialProvider: CredentialProvider | undefined, options?: SignalWireOptions);
+  /**
+   * Initializes DPoP if not already set up. Returns the fingerprint on success.
+   */
+  private initDPoP;
+  /**
+   * Resolves credentials using cache-first strategy when persistSession is enabled.
+   *
+   * 1. If persistSession → check localStorage for cached credential
+   * 2. If cached and not expired → use it (skip provider.authenticate())
+   * 3. If no cache or expired → call provider.authenticate()
+   * 4. If no provider AND no cache → throw
+   */
+  private resolveCredentials;
   private validateCredentials;
+  /**
+   * Schedules credential refresh with exponential backoff retry on failure.
+   * On success, resets attempt counter and schedules the next refresh.
+   * After exhausting retries, emits TokenRefreshError and disconnects.
+   */
+  private scheduleCredentialRefresh;
+  /** Persist credential to localStorage when persistSession is enabled. */
+  private persistCredential;
   private init;
   private handleAttachments;
   /**
@@ -2309,9 +3375,9 @@ declare class SignalWire extends Destroyable implements DeviceController {
    * unexpectedly (e.g. network change, server restart). Reconnection uses an
    * **exponential back-off** strategy:
    *
-   * - First retry after `reconnectDelayMin` (default **1 s**).
+   * - First retry after `reconnectDelayMin` (default **0.1 s**).
    * - Each subsequent retry doubles the delay up to `reconnectDelayMax`
-   *   (default **30 s**).
+   *   (default **3 s**).
    * - The delay resets to `reconnectDelayMin` once a connection succeeds.
    * - A per-attempt `connectionTimeout` (default **10 s**) aborts the
    *   attempt and schedules the next retry if the server does not respond.
@@ -2381,20 +3447,89 @@ declare class SignalWire extends Destroyable implements DeviceController {
   get ready$(): Observable<boolean>;
   /** Observable stream of errors from transport, authentication, and devices. */
   get errors$(): Observable<Error>;
-  /** Disconnects the WebSocket and tears down the session. */
+  /** Platform WebRTC capabilities detected at construction time. */
+  get platformCapabilities(): PlatformCapabilities;
+  /** Observable that emits when the SDK auto-switches a device. */
+  get deviceRecovered$(): Observable<DeviceRecoveryEvent>;
+  /**
+   * Export a structured diagnostic bundle for support/debugging.
+   * Includes connection events, call summaries, and device changes.
+   */
+  exportDiagnostics(): SessionDiagnostics;
+  /**
+   * Initialize resilience subsystems. Non-fatal: any failure is logged and
+   * the SDK continues working without the failing subsystem.
+   */
+  private initResilienceSubsystems;
+  /**
+   * Disconnects the WebSocket and tears down the current session.
+   *
+   * The client can be reconnected by calling {@link connect} again,
+   * which creates a fresh transport and session.
+   */
   disconnect(): Promise<void>;
   private waitAuthentication;
-  /** Registers the subscriber as online to receive inbound calls and events. */
+  /**
+   * Registers the subscriber as online to receive inbound calls and events.
+   *
+   * Waits for authentication to complete before sending the registration.
+   * If the initial attempt fails, reauthentication is attempted automatically.
+   *
+   * @throws {InvalidCredentialsError} If registration and reauthentication both fail.
+   */
   register(): Promise<void>;
-  /** Unregisters the subscriber, going offline for inbound calls. */
+  /**
+   * Unregisters the subscriber, going offline for inbound calls.
+   *
+   * The WebSocket connection remains open; use {@link disconnect} to fully close it.
+   */
   unregister(): Promise<void>;
   /**
    * Places an outbound call to the given destination.
-   * @param destination - Address URI string or {@link Address} instance to call.
-   * @param options - Media and dial options (audio/video, constraints).
+   *
+   * Waits for authentication before dialing. Media options are merged from
+   * saved preferences, destination query parameters (e.g. `?channel=video`),
+   * and the provided `options` (highest priority).
+   *
+   * Returns a {@link Call} in `'ringing'` state. Subscribe to {@link Call.status$}
+   * to track progression through `'connected'` → `'disconnected'`.
+   *
+   * @param destination - Address URI string (e.g. `'/public/my-room'`) or {@link Address} instance.
+   * @param options - Media and dial options (audio/video, device constraints). Overrides defaults.
    * @returns The created {@link Call} instance.
+   * @throws {Error} If authentication is not complete or call creation fails.
+   *
+   * @example
+   * ```ts
+   * const call = await client.dial('/public/conference', {
+   *   audio: true,
+   *   video: true,
+   * });
+   * call.status$.subscribe(status => console.log('Call:', status));
+   * ```
    */
   dial(destination: string | Address, options?: DialOptions): Promise<Call>;
+  /**
+   * Runs a multi-phase connectivity test against the given destination.
+   *
+   * The test checks:
+   *   1. **Signaling** -- WebSocket connected, RTT measurement
+   *   2. **Devices** -- getUserMedia succeeds with selected (or specified) devices
+   *   3. **ICE/TURN** -- gathers ICE candidates to verify STUN/TURN reachability
+   *   4. **Media/bandwidth** (unless `skipMediaTest`) -- dials the destination,
+   *      collects getStats() for `duration` seconds, computes bandwidth estimates
+   *
+   * @param destination - A destination to dial for the media test (e.g. `'/private/network-test'`).
+   * @param options - Preflight options (duration, skipMediaTest, device overrides).
+   * @returns A {@link PreflightResult} describing connectivity health.
+   *
+   * @example
+   * ```ts
+   * const result = await client.preflight('/private/network-test', { duration: 5 });
+   * if (!result.ok) console.warn('Connectivity issues:', result.warnings);
+   * ```
+   */
+  preflight(destination: string, options?: PreflightOptions): Promise<PreflightResult>;
   /** The underlying client session for advanced RPC operations. */
   get session(): ClientSessionWrapper;
   /** Observable list of available audio input (microphone) devices. */
@@ -2421,10 +3556,10 @@ declare class SignalWire extends Destroyable implements DeviceController {
   get selectedAudioOutputDevice(): MediaDeviceInfo | null;
   /** Currently selected video input device, or `null` if none. */
   get selectedVideoInputDevice(): MediaDeviceInfo | null;
-  /** Media track constraints for the selected audio input device. */
-  get selectedAudioInputDeviceConstraints(): MediaTrackConstraints;
-  /** Media track constraints for the selected video input device. */
-  get selectedVideoInputDeviceConstraints(): MediaTrackConstraints;
+  /** Media track constraints for the selected audio input device. Returns `false` when disabled. */
+  get selectedAudioInputDeviceConstraints(): MediaTrackConstraints | boolean;
+  /** Media track constraints for the selected video input device. Returns `false` when disabled. */
+  get selectedVideoInputDeviceConstraints(): MediaTrackConstraints | boolean;
   /** Converts a `MediaDeviceInfo` to track constraints suitable for `getUserMedia`. */
   deviceInfoToConstraints(deviceInfo: MediaDeviceInfo | null): MediaTrackConstraints;
   /** Sets the preferred audio input device. */
@@ -2437,8 +3572,60 @@ declare class SignalWire extends Destroyable implements DeviceController {
   enableDeviceMonitoring(): void;
   /** Stops monitoring for media device changes. */
   disableDeviceMonitoring(): void;
+  /**
+   * Returns the capabilities of a media device.
+   * @param deviceInfo - The device to query.
+   * @returns The device capabilities, or `null` if unavailable.
+   */
   getDeviceCapabilities(deviceInfo: MediaDeviceInfo): Promise<MediaTrackCapabilities | null>;
+  /**
+   * Checks whether a device is still available and usable.
+   * @param deviceInfo - The device to validate, or `null`.
+   * @returns `true` if the device is valid and available. Returns `false` for `null`, audio output devices, or unavailable devices.
+   */
   isValidDevice(deviceInfo: MediaDeviceInfo | null): Promise<boolean>;
+  /** Injects a storage manager into the device controller for persistence. */
+  setStorageManager(storageManager: StorageManager): void;
+  /** Clears all device state and re-enumerates. */
+  clearDeviceState(): Promise<void>;
+  /** Forces a device re-enumeration. */
+  enumerateDevices(): Promise<void>;
+  /** Disables audio input (receive-only mode). No audio track will be acquired. */
+  disableAudioInput(): void;
+  /** Re-enables audio input, restoring the last selection or auto-selecting. */
+  enableAudioInput(): void;
+  /** Disables video input (receive-only mode). No video track will be acquired. */
+  disableVideoInput(): void;
+  /** Re-enables video input, restoring the last selection or auto-selecting. */
+  enableVideoInput(): void;
+  /** Observable that emits `true` when video input is disabled (receive-only). */
+  get videoInputDisabled$(): Observable<boolean>;
+  /** Observable that emits `true` when audio input is disabled (receive-only). */
+  get audioInputDisabled$(): Observable<boolean>;
+  /** Whether video input is currently disabled. */
+  get videoInputDisabled(): boolean;
+  /** Whether audio input is currently disabled. */
+  get audioInputDisabled(): boolean;
+  /**
+   * Triggers the browser's media permission dialog and captures the user's device selections.
+   *
+   * @param options - Which permissions to request.
+   * @param options.audio - Whether to request audio permission.
+   * @param options.video - Whether to request video permission.
+   * @returns The permission result with selected devices.
+   */
+  requestMediaPermissions(options?: {
+    audio?: boolean;
+    video?: boolean;
+  }): Promise<PermissionResult>;
+  /**
+   * Clears all SDK-persisted state and resets to defaults.
+   *
+   * This clears device preferences, device history, authorization state,
+   * attached call IDs, and all SDK storage keys, then re-enumerates devices.
+   */
+  resetToDefaults(): Promise<void>;
+  /** Destroys the client, clearing timers and releasing all resources. */
   destroy(): void;
 }
 //#endregion
@@ -2495,6 +3682,12 @@ interface RTCPeerConnectionControllerOptions extends MediaOptions {
   iceCandidateTimeout?: number;
   iceGatheringTimeout?: number;
   webRTCApiProvider?: WebRTCApiProvider;
+  /** Per-call preferred video codecs (overrides global preferences). */
+  preferredVideoCodecs?: string[];
+  /** Per-call preferred audio codecs (overrides global preferences). */
+  preferredAudioCodecs?: string[];
+  /** Per-call stereo Opus setting (overrides global preferences). */
+  stereo?: boolean;
 }
 type RTCPeerConnectionControllerOptionsPartial = Partial<RTCPeerConnectionControllerOptions>;
 interface UpdateSDPStatusParams {
@@ -2623,6 +3816,22 @@ declare class RTCPeerConnectionController extends Destroyable {
   private setupEventListeners;
   private negotiationEnded;
   restarIce(): void;
+  /**
+   * Trigger an ICE restart through the existing negotiation pipeline.
+   *
+   * This creates an offer with iceRestart: true and goes through the full
+   * SDP pipeline (setLocalDescription → ICE gathering → localDescription$ emission).
+   * The caller should NOT send the SDP manually — the existing
+   * setupLocalDescriptionHandler in VertoManager will pick up the emission
+   * from localDescription$ and send it as a verto.modify.
+   *
+   * Unlike calling pc.createOffer/setLocalDescription directly, this method:
+   * - Sets _isNegotiating$ so ICEGatheringController arms its timers
+   * - Waits for ICE gathering to complete before localDescription$ emits
+   * - Goes through setLocalDescriptionBefore() for any SDP munging
+   */
+  triggerIceRestart(relayOnly?: boolean): Promise<void>;
+  private restoreIceTransportPolicy;
   /**
    * Setup track handling for remote tracks.
    */
@@ -2649,6 +3858,13 @@ declare class RTCPeerConnectionController extends Destroyable {
    */
   setLocalTrack(track: MediaStreamTrack): void;
   updateSendersConstraints(kind: 'audio' | 'video', constraints?: MediaTrackConstraints): Promise<void>;
+  /**
+   * Replace the current audio track with a new one using the given constraints.
+   * Used for server-pushed audio constraint changes where applyConstraints
+   * fails on iOS Safari. Stops the current track, acquires a new one via
+   * getUserMedia, and replaces the sender track.
+   */
+  replaceAudioTrackWithConstraints(constraints: MediaTrackConstraints): Promise<void>;
   /**
    * Clean up resources and close the peer connection.
    * Completes all observables to prevent memory leaks.
@@ -2687,10 +3903,19 @@ interface WebRTCVerto extends VertoManager {
   unhold(): Promise<void>;
   destroy(): void;
   transfer(options: TransferOptions): Promise<void>;
+  /** Request a video keyframe via verto.modify. */
+  requestKeyframe?: () => void;
+  /** Request an ICE restart via verto.modify with iceRestart offer. */
+  requestIceRestart?: (relayOnly?: boolean) => Promise<void>;
+  /** Request an ICE restart on all active peer connections (multi-leg). */
+  requestIceRestartAll?: (relayOnly?: boolean) => Promise<void>;
+  /** Request keyframes on all video-receiving legs (skips send-only screen share). */
+  requestKeyframeAll?: () => void;
 }
 //#endregion
 //#region src/managers/CallEventsManager.d.ts
 interface WebRTCCallEventManagerOptions {}
+/** @internal */
 declare class CallEventsManager extends Destroyable {
   protected webRtcCallSession: CallManager;
   protected options: WebRTCCallEventManagerOptions;
@@ -2716,7 +3941,7 @@ declare class CallEventsManager extends Destroyable {
   get raiseHandPriority$(): Observable<boolean>;
   get locked$(): Observable<boolean>;
   get meta$(): Observable<Record<string, unknown>>;
-  get capabilities$(): Observable<string[]>;
+  get capabilities$(): Observable<Capability[]>;
   get layout$(): Observable<string>;
   get layouts$(): Observable<string[]>;
   get layoutLayers$(): Observable<LayoutLayer[]>;
@@ -2729,7 +3954,7 @@ declare class CallEventsManager extends Destroyable {
   get meta(): Record<string, unknown>;
   get layout(): string | undefined;
   get layouts(): string[];
-  get capabilities(): string[];
+  get capabilities(): Capability[];
   isSessionEvent(id: string): boolean;
   protected initSubscriptions(): void;
   private updateParticipantPositions;
@@ -2742,6 +3967,27 @@ declare class CallEventsManager extends Destroyable {
   destroy(): void;
 }
 //#endregion
+//#region src/managers/CallRecoveryManager.d.ts
+type RecoveryState$1 = 'idle' | 'debouncing' | 'recovering' | 'cooldown';
+interface RecoveryEvent$1 {
+  action: 'keyframe_requested' | 'reinvite_started' | 'reinvite_succeeded' | 'reinvite_failed' | 'reinvite_timeout' | 'max_attempts_reached' | 'signal_reconnect' | 'full_reconnect' | 'video_disabled' | 'video_restored';
+  reason: string;
+  attempt?: number;
+  maxAttempts?: number;
+  timestamp: number;
+}
+//#endregion
+//#region src/utils/qualityScore.d.ts
+/**
+ * MOS (Mean Opinion Score) quality computation based on the simplified
+ * ITU-T G.107 E-model.
+ *
+ * Provides a single 1-5 number that applications can use for a
+ * green / yellow / red quality indicator without understanding raw
+ * jitter and packet-loss values.
+ */
+type QualityLevel$1 = 'excellent' | 'good' | 'fair' | 'poor' | 'critical';
+//#endregion
 //#region src/core/entities/Call.d.ts
 /**
  * Manager instances returned by initialization callback
@@ -2769,6 +4015,10 @@ interface CallInitialization {
    * Device controller for media device access
    */
   deviceController: DeviceController;
+  /**
+   * Network change events for feeding recovery pipeline
+   */
+  networkChange$?: Observable<NetworkChangeEvent>;
 }
 /**
  * Concrete WebRTC call implementation.
@@ -2795,6 +4045,19 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   private _answerMediaOptions?;
   private _holdState;
   private _userVariables$;
+  private _statsMonitor?;
+  private _recoveryManager?;
+  private _networkChange$?;
+  private _networkIssues$;
+  private _networkMetrics$;
+  private _isNetworkHealthy$;
+  private _qualityScore$;
+  private _qualityLevel$;
+  private _recoveryState$;
+  private _recoveryEvent$;
+  private _bandwidthConstrained$;
+  private _mediaParamsUpdated$;
+  private _customSubscriptions;
   constructor(clientSession: ClientSession, options: CallOptions, initialization: CallInitialization, address?: Address | undefined);
   /** Observable stream of errors from media, signaling, and peer connection layers. */
   get errors$(): Observable<CallError>;
@@ -2803,6 +4066,8 @@ declare class WebRTCCall extends Destroyable implements CallManager {
    * Fatal errors automatically transition the call to `'failed'` and destroy it.
    */
   emitError(callError: CallError): void;
+  /** Notify the recovery manager that a verto.modify signaling exchange failed. */
+  notifyModifyFailed(): void;
   /** Whether this call is `'inbound'` or `'outbound'`. */
   get direction(): CallDirection;
   /** Observable of the address associated with this call. */
@@ -2820,22 +4085,50 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   /** @internal Registers an additional call ID for event routing. */
   addCallId(callId: string): void;
   /** List of capabilities available in the current call. */
-  get capabilities(): string[];
+  get capabilities(): Capability[];
   /** Current snapshot of all participants in the call. */
   get participants(): CallParticipant[];
   /** The local participant, or `null` if not yet joined. */
   get self(): CallSelfParticipant | null;
+  /** Toggles the call lock state, preventing or allowing new participants from joining. */
   toggleLock(): Promise<void>;
+  /**
+   * Toggles the hold state of the call (pauses/resumes local media transmission).
+   *
+   * Distinct from {@link Participant.toggleMute} which mutes individual tracks.
+   */
   toggleHold(): Promise<void>;
+  /** @throws {UnimplementedError} Not yet implemented. Status tracked via {@link recording$}. */
   startRecording(): Promise<void>;
+  /** @throws {UnimplementedError} Not yet implemented. Status tracked via {@link streaming$}. */
   startStreaming(): Promise<void>;
+  /**
+   * Replaces the call's custom metadata.
+   * @param _meta - Metadata object to set.
+   * @throws {UnimplementedError} Not yet implemented.
+   */
   setMeta(_meta: Record<string, unknown>): Promise<void>;
+  /**
+   * Merges values into the call's custom metadata (unlike {@link setMeta} which replaces).
+   * @param _meta - Metadata to merge.
+   * @throws {UnimplementedError} Not yet implemented.
+   */
   updateMeta(_meta: Record<string, unknown>): Promise<void>;
   /** Observable of layout layer positions for all participants. */
   get layoutLayers$(): Observable<LayoutLayer[]>;
   /** Current snapshot of layout layers. */
   get layoutLayers(): LayoutLayer[];
-  /** Executes a Verto RPC method targeting a specific participant. */
+  /**
+   * Executes a Verto RPC method targeting a specific participant.
+   *
+   * Constructs call context (node_id, call_id, member_id) and sends the RPC request.
+   *
+   * @param target - Target member ID string, or a {@link MemberTarget} object.
+   * @param method - Verto method name (e.g. `'call.mute'`, `'call.member.remove'`).
+   * @param args - Parameters for the RPC method.
+   * @returns The RPC response.
+   * @throws {JSONRPCError} If the RPC call returns an error.
+   */
   executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string | MemberTarget, method: string, args: Record<string, unknown>): Promise<T>;
   private buildMethodParams;
   /** Observable of the current call status (e.g. `'ringing'`, `'connected'`). */
@@ -2855,7 +4148,7 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   /** Observable of custom metadata associated with the call. */
   get meta$(): Observable<Record<string, unknown>>;
   /** Observable of the call's capability flags. */
-  get capabilities$(): Observable<string[]>;
+  get capabilities$(): Observable<Capability[]>;
   /** Observable of the current layout name. */
   get layout$(): Observable<string>;
   /** Current call status. */
@@ -2890,6 +4183,49 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   get userVariables(): Record<string, unknown>;
   /** Merge current custom user variables of the call. */
   set userVariables(variables: Record<string, unknown>);
+  /** Observable of current network health issues (empty array = healthy). */
+  get networkIssues$(): Observable<NetworkIssue[]>;
+  /** Current snapshot of network issues. */
+  get networkIssues(): NetworkIssue[];
+  /** Simple boolean health indicator derived from stats monitor. */
+  get isNetworkHealthy$(): Observable<boolean>;
+  /** Whether the network is currently healthy. */
+  get isNetworkHealthy(): boolean;
+  /** Rolling history of raw network metrics (RTT, jitter, packet loss, bitrate). */
+  get networkMetrics$(): Observable<NetworkMetrics[]>;
+  /** Current snapshot of the metrics rolling window. */
+  get networkMetrics(): NetworkMetrics[];
+  /** Observable of MOS quality score (1-5) computed from stats metrics. */
+  get qualityScore$(): Observable<number>;
+  /** Observable of simplified quality level (excellent/good/fair/poor/critical). */
+  get qualityLevel$(): Observable<QualityLevel$1>;
+  /** Observable of the recovery pipeline state machine. */
+  get recoveryState$(): Observable<RecoveryState$1>;
+  /** Observable of recovery events (keyframe requested, ICE restart, etc.). */
+  get recoveryEvent$(): Observable<RecoveryEvent$1>;
+  /** Observable indicating whether the call is bandwidth-constrained. */
+  get bandwidthConstrained$(): Observable<boolean>;
+  /** Observable that emits when server-pushed media params are applied. */
+  get mediaParamsUpdated$(): Observable<MediaParamsEvent>;
+  /**
+   * @internal Emit a media params update event.
+   * Called by the VertoManager when server-pushed media params are applied.
+   */
+  emitMediaParamsUpdated(event: MediaParamsEvent): void;
+  /** Request a video keyframe via RTCP PLI/FIR. */
+  requestKeyframe(): void;
+  /** Force an ICE restart / re-INVITE. */
+  requestIceRestart(): Promise<void>;
+  /**
+   * @internal Initialize resilience subsystems when the call reaches 'connected'.
+   * Called from within the status subscription to wire stats and recovery.
+   */
+  private initResilienceSubsystems;
+  /**
+   * @internal Stop and destroy resilience subsystems (on disconnect/destroy).
+   * Clears references so they can be re-created on reconnect.
+   */
+  private stopResilienceSubsystems;
   /** @internal */
   createParticipant(memberId: string, selfId?: string | null): Participant | SelfParticipant;
   /** Observable of the current audio/video send/receive directions. */
@@ -2897,7 +4233,16 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   /** Current audio/video send/receive directions. */
   get mediaDirections(): MediaDirections;
   protected get participantsId$(): Observable<string[]>;
-  /** Executes a raw JSON-RPC request on the client session. */
+  /**
+   * Executes a raw JSON-RPC request on the client session.
+   *
+   * Lower-level than {@link executeMethod} — allows full control over the RPC request structure.
+   *
+   * @param request - Complete JSON-RPC request object.
+   * @param options - Optional RPC execution options (timeout, etc.).
+   * @returns The RPC response.
+   * @throws {JSONRPCError} If the RPC call returns an error response.
+   */
   execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
   /** Observable of the local participant's member ID. */
   get selfId$(): Observable<string | null>;
@@ -2911,9 +4256,9 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   private get callSessionEvents$();
   /** Observable of call-updated events. */
   get callUpdated$(): Observable<CallUpdatedPayload>;
-  /** Observable of member-joined events. */
+  /** Observable of member-joined events, emitted when a remote participant joins the call. */
   get memberJoined$(): Observable<MemberJoinedPayload>;
-  /** Observable of member-left events. */
+  /** Observable of member-left events, emitted when a participant leaves the call. */
   get memberLeft$(): Observable<MemberLeftPayload>;
   /** Observable of member-updated events (mute, volume, etc.). */
   get memberUpdated$(): Observable<MemberUpdatedPayload>;
@@ -2927,34 +4272,117 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   get rtcPeerConnection(): RTCPeerConnection | undefined;
   /** Observable of raw signaling events as plain objects. */
   get signalingEvent$(): Observable<Record<string, unknown>>;
-  /** Observable of WebRTC-specific signaling messages. */
+  /**
+   * Subscribe to a custom signaling event type on this call.
+   *
+   * Returns a cached observable that filters `callSessionEvents$` for events
+   * whose `event_type` matches the given string. The observable completes
+   * when the call is destroyed.
+   *
+   * Unlike `signalingEvent$` (which only emits known call-level event types),
+   * this method also matches custom/user-defined event types.
+   *
+   * The SDK does not validate event type strings --- the server decides
+   * whether a given type is valid.
+   *
+   * @param eventType - The event type to subscribe to (e.g. `'my.custom.event'`).
+   * @returns An observable that emits matching signaling events.
+   *
+   * @example
+   * ```ts
+   * call.subscribe('my.custom.event').subscribe(event => {
+   *   console.log('Custom event:', event);
+   * });
+   * ```
+   */
+  subscribe(eventType: string): Observable<Record<string, unknown>>;
   get webrtcMessages$(): Observable<WebrtcMessagePayload>;
-  /** Observable of call-level signaling events. */
-  get callEvent$(): Observable<WebrtcMessagePayload | CallJoinedPayload | CallLeftPayload | CallUpdatedPayload | CallStatePayload | CallPlayPayload | CallConnectPayload | MemberUpdatedPayload | MemberJoinedPayload | MemberLeftPayload | MemberTalkingPayload | LayoutChangedPayload | ConversationMessagePayload>;
-  /** Observable of layout-changed signaling events. */
+  get callEvent$(): Observable<WebrtcMessagePayload | CallJoinedPayload | CallLeftPayload | CallUpdatedPayload | CallStatePayload | CallPlayPayload | CallConnectPayload | RoomUpdatedPayload | MemberUpdatedPayload | MemberJoinedPayload | MemberLeftPayload | MemberTalkingPayload | LayoutChangedPayload | ConversationMessagePayload>;
   get layoutEvent$(): Observable<LayoutChangedPayload>;
-  /** Hangs up the call and releases all resources. */
+  /**
+   * Hangs up the call and releases all resources.
+   *
+   * Sends a Verto `bye` to the server, transitions status to `'disconnecting'`,
+   * then destroys the call. After this, the call instance is no longer usable.
+   *
+   * @example
+   * ```ts
+   * await call.hangup();
+   * ```
+   */
   hangup(): Promise<void>;
-  /** Sends DTMF digits (e.g. `'1234#'`) on the call. */
+  /**
+   * Sends DTMF digits on the call.
+   *
+   * @param dtmf - The digit string to send (e.g. `'1234#'`).
+   *
+   * @example
+   * ```ts
+   * await call.sendDigits('1234#');
+   * ```
+   */
   sendDigits(dtmf: string): Promise<void>;
-  /** Accepts an inbound call, optionally overriding media options for the answer. */
+  /** Observable of WebRTC-specific signaling messages. */
+  /** Observable of call-level signaling events. */
+  /** Observable of layout-changed signaling events. */
+  /**
+   * Accepts an inbound call, optionally overriding media options for the answer.
+   *
+   * @param options - Optional media constraints for the answer (audio/video).
+   *
+   * @example
+   * ```ts
+   * // Accept with defaults
+   * call.answer();
+   *
+   * // Accept audio-only
+   * call.answer({ audio: true, video: false });
+   * ```
+   * @see {@link reject} to decline the call instead.
+   * @see {@link answered$} to observe the acceptance state.
+   */
   answer(options?: MediaOptions): void;
   /** Media options provided when answering. Used internally by the VertoManager. */
   get answerMediaOptions(): MediaOptions | undefined;
-  /** Rejects an inbound call. */
+  /**
+   * Rejects an inbound call, preventing media negotiation.
+   *
+   * @see {@link answer} to accept the call instead.
+   * @see {@link answered$} to observe the rejection state.
+   */
   reject(): void;
   /** Observable that emits `true` when answered, `false` when rejected. */
   get answered$(): Observable<boolean>;
   /**
    * Sets the call layout and participant positions.
+   *
    * @param layout - Layout name (must be one of {@link layouts}).
-   * @param positions - Map of member IDs to video positions.
+   * @param positions - Map of member IDs to {@link VideoPosition} values.
+   * @throws {InvalidParams} If the layout is not in the available {@link layouts}.
+   *
+   * @example
+   * ```ts
+   * await call.setLayout('grid-responsive', {
+   *   [participantId]: 'reserved-0',
+   * });
+   * ```
    */
   setLayout(layout: string, positions: Record<string, VideoPosition>): Promise<void>;
-  /** Transfers the call to other participants. */
+  /**
+   * Transfers the call to another destination.
+   *
+   * @param options - Transfer configuration including the target destination.
+   * @see {@link status$} to observe the transfer progress.
+   */
   transfer(options: TransferOptions): Promise<void>;
   /** Destroys the call, releasing all resources and subscriptions. */
   destroy(): void;
+  /**
+   * @internal Send a verto.subscribe message to add an event type to the
+   * server's subscription list for this call. Best-effort — failures are
+   * logged but don't prevent the filtered observable from being returned.
+   */
+  private _sendVertoSubscribe;
 }
 //#endregion
 //#region src/index.d.ts
@@ -2969,5 +4397,5 @@ declare const version: string;
  */
 declare const ready: boolean;
 //#endregion
-export { Address, type AddressHistory, type Call, type CallAddress, type CallCapabilitiesState, CallCreateError, type CallError, type CallErrorKind, type CallOptions, type CallParticipant, type CallSelfParticipant, type CallState, type CallStatus, ClientPreferences, CollectionFetchError, type CredentialProvider, type DeviceController, type DialOptions, type Directory, type ExecuteMethod, InvalidCredentialsError, type JSONRPCErrorResponse, type JSONRPCRequest, type JSONRPCResponse, type JSONRPCSuccessResponse, type LayoutLayer, type MediaDirection, type MediaDirections, type MediaOptions, MediaTrackError, type MemberCapabilities, MessageParseError, type NodeSocketAdapter, type OnOffCapability, Participant, type PendingRPCOptions, type SDKCredential, SelfCapabilities, SelfParticipant, type SessionState, SignalWire, type SignalWireOptions, StaticCredentialProvider, type Storage, Subscriber, type TextMessage, type TransferOptions, UnexpectedError, VertoPongError, type VideoPosition, type WebRTCApiProvider, WebRTCCall, type WebRTCMediaDevices, type WebSocketAdapter, embeddableCall, isSelfParticipant, ready, version };
+export { Address, type AddressHistory, type AudioConstraintsEvent, type AuthenticateContext, type Call, type CallAddress, type CallCapabilitiesState, CallCreateError, type CallDiagnosticSummary, type CallDirection, type CallError, type CallErrorKind, type NetworkIssue as CallNetworkIssue, type NetworkIssue, type NetworkMetrics as CallNetworkMetrics, type NetworkMetrics, type CallOptions, type CallParticipant, type CallSelfParticipant, type CallState, type CallStatus, type Capability, ClientPreferences, CollectionFetchError, type ConstraintFallbackEvent, type CredentialProvider, DPoPInitError, type DebugOptions, type DeviceController, type DeviceRecoveryEvent, DeviceTokenError, type DiagnosticEvent, type DialOptions, type Directory, type ExecuteMethod, InvalidCredentialsError, type JSONRPCErrorResponse, type JSONRPCRequest, type JSONRPCResponse, type JSONRPCSuccessResponse, type LayoutLayer, type LogLevel, type MediaDirection, type MediaDirections, type MediaOptions, type MediaParamsEvent, MediaTrackError, type MemberCapabilities, MessageParseError, type NodeSocketAdapter, type OnOffCapability, OverconstrainedFallbackError, Participant, type PendingRPCOptions, type PermissionResult, type PlatformCapabilities, PreflightError, type PreflightOptions, type PreflightResult, type QualityLevel, RecoveryError, type RecoveryEvent, type RecoveryState, type ResilienceCallStatus, type SATClaims, type SDKCredential, type SDKLogger, type ScreenShareStatus, type SelectDeviceOptions, SelfCapabilities, SelfParticipant, type SessionDiagnostics, type SessionState, SignalWire, type SignalWireOptions, StaticCredentialProvider, type Storage, type StoredDevicePreference, Subscriber, type SubscriberPresence, type TextMessage, TokenRefreshError, type TransferOptions, UnexpectedError, VertoPongError, type VideoPosition, type WebRTCApiProvider, WebRTCCall, type WebRTCMediaDevices, type WebSocketAdapter, embeddableCall, isSelfParticipant, ready, setDebugOptions, setLogLevel, setLogger, version };
 //# sourceMappingURL=index.d.cts.map