@signalwire/js 4.0.0-dev-20260401154549 → 4.0.0-dev-20260410161202

package/dist/index.d.mts

@@ -3,78 +3,6 @@ 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. 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/core/types/common.types.d.ts
 /** JSON-compatible value type for serializable data structures. */
 interface JSONSerializable {
@@ -174,6 +102,8 @@ 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}.
@@ -319,6 +249,84 @@ 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?;
+  private _change$;
+  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. 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
@@ -398,6 +406,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. */
@@ -926,6 +1036,29 @@ declare class EntityCollectionTransformed<O extends Entity = Entity, T extends E
   destroy(): void;
 }
 //#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'>;
@@ -1002,6 +1135,34 @@ 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);
@@ -1011,6 +1172,248 @@ declare class TokenRefreshError extends Error {
   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;
@@ -1192,10 +1595,10 @@ interface DeviceController {
   readonly audioOutputDevices: MediaDeviceInfo[];
   /** Current snapshot of available video input devices. */
   readonly videoInputDevices: MediaDeviceInfo[];
-  /** Media track constraints for the selected audio input device. */
-  readonly selectedAudioInputDeviceConstraints: MediaTrackConstraints;
-  /** Media track constraints for the selected video input device. */
-  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.
@@ -1234,6 +1637,33 @@ interface DeviceController {
   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
@@ -1444,9 +1874,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. */
@@ -1492,6 +1942,17 @@ 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. */
@@ -1582,6 +2043,10 @@ interface CallParticipant {
 interface CallSelfParticipant extends CallParticipant {
   readonly screenShareStatus$: Observable<string>;
   readonly screenShareStatus: string;
+  readonly studioAudio$: Observable<boolean>;
+  readonly studioAudio: boolean;
+  enableStudioAudio(): Promise<void>;
+  disableStudioAudio(): Promise<void>;
   startScreenShare(): Promise<void>;
   stopScreenShare(): Promise<void>;
   selectAudioInputDevice(device: MediaDeviceInfo): void;
@@ -1608,7 +2073,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. */
@@ -1631,6 +2096,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 {
@@ -1684,6 +2155,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>;
@@ -1958,10 +2444,19 @@ interface AttachableCall {
   id: string;
   to?: string;
   mediaDirections: MediaDirections;
+  nodeId?: string | null;
 }
 interface OutboundCallProvider {
   createOutboundCall(destination: string | Address, options?: CallOptions): Promise<Call>;
 }
+interface Attachment {
+  destination: string;
+  mediaDirections: MediaDirections;
+  audioInputDevice: MediaDeviceInfo | null;
+  videoInputDevice: MediaDeviceInfo | null;
+  nodeId?: string | null;
+  attachedAt: number;
+}
 declare class AttachManager {
   private readonly storage;
   private readonly deviceController;
@@ -1976,8 +2471,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
@@ -1986,22 +2505,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;
@@ -2009,29 +2512,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>;
@@ -2050,10 +2545,13 @@ declare class TransportManager extends Destroyable {
 /**
  * Controls DPoP (Demonstrating Proof-of-Possession) cryptographic operations.
  *
- * Generates an ephemeral 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.
+ * 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
@@ -2081,12 +2579,13 @@ declare class CryptoController {
   private _fingerprint;
   private _initialized;
   /**
-   * Generates the ephemeral RSA key pair and computes the fingerprint.
+   * Initializes the DPoP key pair. Loads an existing key from IndexedDB
+   * if available, otherwise generates a new one and persists it.
    *
-   * Must be called before any other method. The private key is generated
-   * as non-extractable to prevent accidental exposure.
+   * 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 generated key.
+   * @returns The JWK Thumbprint (fingerprint) for the key.
    */
   init(): Promise<string>;
   /**
@@ -2121,7 +2620,7 @@ declare class CryptoController {
    */
   createRpcProof(params: DPoPRpcProofParams): Promise<string>;
   /**
-   * Releases the key pair references.
+   * 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;
@@ -2130,6 +2629,13 @@ declare class CryptoController {
   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
@@ -2203,6 +2709,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
@@ -2267,7 +2779,7 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
   private _subscriberInfo$;
   private _calls$;
   private _iceServers$;
-  constructor(getCredential: () => SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager, webRTCApiProvider: WebRTCApiProvider, dpopManager?: CryptoController | undefined);
+  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>;
@@ -2451,6 +2963,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();
@@ -2465,6 +2978,16 @@ declare class ClientSessionManager extends Destroyable implements SessionState {
   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;
@@ -2645,6 +3168,21 @@ 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 */
@@ -2653,7 +3191,14 @@ interface SignalWireOptions {
   webRTCApiProvider?: WebRTCApiProvider;
 }
 /** 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;
+}
 /**
  * Main entry point for the SignalWire Browser SDK.
  *
@@ -2685,18 +3230,33 @@ declare class SignalWire extends Destroyable implements DeviceController {
   private _deviceTokenManager?;
   private _credentialProvider?;
   private _deps;
+  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, options?: SignalWireOptions);
+  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;
+  /** Persist credential to localStorage when persistSession is enabled. */
+  private persistCredential;
   private init;
   private handleAttachments;
   /**
@@ -2781,6 +3341,20 @@ declare class SignalWire extends Destroyable implements DeviceController {
   get ready$(): Observable<boolean>;
   /** Observable stream of errors from transport, authentication, and devices. */
   get errors$(): Observable<Error>;
+  /** 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.
    *
@@ -2829,6 +3403,27 @@ declare class SignalWire extends Destroyable implements DeviceController {
    * ```
    */
   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. */
@@ -2855,10 +3450,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. */
@@ -2883,6 +3478,45 @@ declare class SignalWire extends Destroyable implements DeviceController {
    * @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.
+   * @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;
 }
@@ -2940,6 +3574,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 {
@@ -3068,6 +3708,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.
    */
@@ -3094,6 +3750,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.
@@ -3132,6 +3795,14 @@ 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
@@ -3188,6 +3859,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
@@ -3215,6 +3907,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.
@@ -3241,6 +3937,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>;
@@ -3364,6 +4073,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. */
@@ -3410,11 +4162,32 @@ 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 | RoomUpdatedPayload | MemberUpdatedPayload | MemberJoinedPayload | MemberLeftPayload | MemberTalkingPayload | LayoutChangedPayload | ConversationMessagePayload>;
-  /** Observable of layout-changed signaling events. */
   get layoutEvent$(): Observable<LayoutChangedPayload>;
   /**
    * Hangs up the call and releases all resources.
@@ -3439,6 +4212,9 @@ declare class WebRTCCall extends Destroyable implements CallManager {
    * ```
    */
   sendDigits(dtmf: string): Promise<void>;
+  /** 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.
    *
@@ -3491,6 +4267,12 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   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
@@ -3505,5 +4287,5 @@ declare const version: string;
  */
 declare const ready: boolean;
 //#endregion
-export { Address, type AddressHistory, type AuthenticateContext, 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, DPoPInitError, type DeviceController, DeviceTokenError, 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 SATClaims, type SDKCredential, SelfCapabilities, SelfParticipant, type SessionState, SignalWire, type SignalWireOptions, StaticCredentialProvider, type Storage, Subscriber, type TextMessage, TokenRefreshError, 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 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, ClientPreferences, CollectionFetchError, type ConstraintFallbackEvent, type CredentialProvider, DPoPInitError, 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 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, SelfCapabilities, SelfParticipant, type SessionDiagnostics, type SessionState, SignalWire, type SignalWireOptions, StaticCredentialProvider, type Storage, type StoredDevicePreference, Subscriber, type TextMessage, TokenRefreshError, type TransferOptions, UnexpectedError, VertoPongError, type VideoPosition, type WebRTCApiProvider, WebRTCCall, type WebRTCMediaDevices, type WebSocketAdapter, embeddableCall, isSelfParticipant, ready, version };
 //# sourceMappingURL=index.d.mts.map