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

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { n as JSONRPCRequest, r as JSONRPCResponse, t as EventChannel } from "./base-aVtoG8Wk.mjs";
+import { a as JSONRPCSuccessResponse, i as JSONRPCResponse, n as JSONRPCErrorResponse, r as JSONRPCRequest, t as EventChannel } from "./base-CQPEW1lJ.mjs";
 import * as rxjs0 from "rxjs";
 import { BehaviorSubject, Observable, Observer, ReplaySubject, Subject, Subscription } from "rxjs";
 import { URL as URL$1 } from "node:url";
@@ -8,7 +8,32 @@ 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>;
@@ -182,6 +207,50 @@ interface CredentialProvider {
    */
   refresh?: () => Promise<SDKCredential>;
 }
+/**
+ * Provides custom WebRTC API implementations for non-standard environments.
+ *
+ * Use this when the standard browser WebRTC APIs are not available or need
+ * to be replaced (e.g., Citrix HDX, React Native, Electron).
+ *
+ * @example
+ * ```typescript
+ * import { SignalWire, type WebRTCApiProvider } from '@signalwire/js';
+ *
+ * const provider: WebRTCApiProvider = {
+ *   RTCPeerConnection: CustomRTCPeerConnection,
+ *   mediaDevices: {
+ *     getUserMedia: (constraints) => customGetUserMedia(constraints),
+ *     enumerateDevices: () => customEnumerateDevices(),
+ *     addEventListener: (type, listener) => { ... },
+ *     removeEventListener: (type, listener) => { ... },
+ *   }
+ * };
+ *
+ * const client = new SignalWire(credentialProvider, { webRTCApiProvider: provider });
+ * ```
+ */
+interface WebRTCApiProvider {
+  /** Custom RTCPeerConnection constructor. */
+  RTCPeerConnection: typeof RTCPeerConnection;
+  /** Custom media device access. Only the methods used by the SDK are required. */
+  mediaDevices: WebRTCMediaDevices;
+}
+/**
+ * Subset of the `MediaDevices` interface actually used by the SDK.
+ *
+ * Implementations only need to provide these methods — the full browser
+ * `MediaDevices` type is intentionally not required so that React Native
+ * and other non-browser environments can conform without polyfilling
+ * unused APIs.
+ */
+interface WebRTCMediaDevices {
+  getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
+  getDisplayMedia?(options: DisplayMediaStreamOptions): Promise<MediaStream>;
+  enumerateDevices(): Promise<MediaDeviceInfo[]>;
+  addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
+  removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
+}
 //#endregion
 //#region src/managers/StorageManager.d.ts
 declare class StorageManager {
@@ -459,6 +528,11 @@ type CallDevice = CallDeviceWebRTCOrSIP | CallDevicePhone;
 type VideoPosition = 'auto' | `reserved-${number}` | `standard-${number}` | 'off-canvas' | 'playback' | 'full-screen';
 //#endregion
 //#region src/core/RPCMessages/types/common.d.ts
+interface MemberTarget {
+  member_id: string;
+  call_id: string;
+  node_id: string;
+}
 interface Member {
   room_session_id: string;
   room_id: string;
@@ -535,56 +609,10 @@ interface ConversationDetails {
   start_time: number;
   end_time?: number;
 }
-interface PartialDialogParams {
-  callID: string;
-}
-interface AudioMediaParams {
-  autoGainControl: boolean;
-  echoCancellation: boolean;
-  noiseSuppression: boolean;
-}
-interface FrameRateConstraint {
-  min: number;
-  ideal: number;
-  max: number;
-}
-interface AspectRatioConstraint {
-  exact: number;
-}
-interface DimensionConstraint {
-  min: number;
-  ideal: number;
-}
-interface VideoAdvancedConstraint {
-  width: DimensionConstraint;
-  height: DimensionConstraint;
-  frameRate: FrameRateConstraint;
-}
-interface VideoMediaParams {
-  frameRate: FrameRateConstraint;
-  aspectRatio: AspectRatioConstraint;
-  width: DimensionConstraint;
-  height: DimensionConstraint;
-  advanced: VideoAdvancedConstraint[];
-  resizeMode: string;
-}
-interface MediaParams {
-  audio?: AudioMediaParams;
-  video?: VideoMediaParams;
-}
 //#endregion
 //#region src/core/RPCMessages/types/verto.d.ts
-interface VertoAnswerParams {
-  callID: string;
-  sdp: string;
-}
-interface VertoMediaParamsParams {
-  callID: string;
-  mediaParams: MediaParams;
-}
-interface VertoPingParams {
-  callID: string;
-  dialogParams: PartialDialogParams;
+interface VertoParams {
+  userVariables?: Record<string, unknown>;
 }
 //#endregion
 //#region src/core/RPCMessages/types/events.d.ts
@@ -595,7 +623,7 @@ interface WebrtcMessagePayload {
   jsonrpc: '2.0';
   id: number;
   method: string;
-  params: VertoAnswerParams | VertoMediaParamsParams | VertoPingParams;
+  params: VertoParams;
 }
 interface CallJoinedPayload {
   room_session: RoomSession;
@@ -692,7 +720,6 @@ interface ConversationMessagePayload {
   conversation_name: string;
   user_name: string;
 }
-type ConversationMessageUpdatedPayload = ConversationMessagePayload;
 //#endregion
 //#region src/behaviors/types/collection.types.d.ts
 interface Entity {
@@ -729,6 +756,7 @@ declare class EntityCollection<T extends Entity = Entity> extends Destroyable im
   private observablesRegistry;
   private updateSubscription;
   private upsertData;
+  private _hasMore$;
   private _destroy$;
   constructor(fetchController: FetchController<T>, update$: Observable<Partial<T>>, onError?: ((error: Error) => void) | undefined);
   get loading(): boolean;
@@ -747,6 +775,7 @@ declare class EntityCollectionTransformed<O extends Entity = Entity, T extends E
   private originalCollection;
   private filter;
   private mapper;
+  private _values$?;
   constructor(originalCollection: EntityCollection<O>, filter?: (i: unknown) => i is O, mapper?: (item: O) => T);
   get loading$(): Observable<boolean>;
   get loading(): boolean;
@@ -762,11 +791,77 @@ declare class EntityCollectionTransformed<O extends Entity = Entity, T extends E
 //#endregion
 //#region src/managers/types/verto-manager.types.d.ts
 type ScreenShareStatus = 'none' | 'starting' | 'started' | 'stopping';
-type SignalingStatus = 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnected' | 'failed';
+type SignalingStatus = Extract<CallStatus, 'trying' | 'ringing' | 'connecting' | 'connected' | 'disconnected' | 'failed'>;
 interface TransferOptions {
   destination: string;
 }
 //#endregion
+//#region src/core/errors.d.ts
+declare class UnexpectedError extends Error {
+  at?: string | undefined;
+  constructor(at?: string | undefined, options?: ErrorOptions);
+}
+declare class InvalidCredentialsError extends Error {
+  reason: string;
+  constructor(reason?: string, options?: ErrorOptions);
+}
+/**
+ * Semantic category of a call-lifecycle error.
+ *
+ * - `'media'`     – RTCPeerConnection / media device failure
+ * - `'signaling'` – Verto / JSON-RPC protocol error
+ * - `'timeout'`   – Call setup timed out waiting for a response
+ * - `'rejected'`  – Remote side rejected the call
+ * - `'network'`   – Transport lost during an active call
+ * - `'internal'`  – Unexpected / unknown error
+ */
+type CallErrorKind = 'media' | 'signaling' | 'timeout' | 'rejected' | 'network' | 'internal';
+/**
+ * Structured error emitted on `call.errors$`.
+ *
+ * Provides actionable metadata so consumers can react without
+ * resorting to `instanceof` checks on raw `Error` objects.
+ */
+interface CallError {
+  /** Semantic category of the error. */
+  readonly kind: CallErrorKind;
+  /**
+   * Whether the error terminates the call.
+   * When `true`, the call will automatically transition to `'failed'`
+   * and be destroyed — no further action is needed from the consumer.
+   */
+  readonly fatal: boolean;
+  /** The underlying error. */
+  readonly error: Error;
+  /** ID of the call that produced this error. */
+  readonly callId: string;
+}
+declare class CallCreateError extends Error {
+  message: string;
+  error: unknown;
+  direction: 'inbound' | 'outbound';
+  constructor(message: string, error?: unknown, direction?: 'inbound' | 'outbound', options?: ErrorOptions);
+}
+declare class VertoPongError extends Error {
+  originalError: unknown;
+  constructor(originalError: unknown);
+}
+declare class MessageParseError extends Error {
+  originalError: unknown;
+  constructor(originalError: unknown);
+}
+declare class CollectionFetchError extends Error {
+  operation: string;
+  originalError: unknown;
+  constructor(operation: string, originalError: unknown);
+}
+declare class MediaTrackError extends Error {
+  operation: string;
+  kind: string;
+  originalError: unknown;
+  constructor(operation: string, kind: string, originalError: unknown);
+}
+//#endregion
 //#region src/core/RPCMessages/RPCConnect.d.ts
 interface Authorization {
   jti: string;
@@ -969,7 +1064,7 @@ interface VertoManager {
  * Callback type for executing call methods
  * Injected to avoid circular dependency with Call class
  */
-type ExecuteMethod = <T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>) => Promise<T>;
+type ExecuteMethod = <T extends JSONRPCResponse = JSONRPCResponse>(target: string | MemberTarget, method: string, args: Record<string, unknown>) => Promise<T>;
 type ParticipantState = Member & {
   position: LayoutLayer;
 };
@@ -1341,10 +1436,12 @@ interface Call extends CallState {
   readonly remoteStream$: Observable<MediaStream | null>;
   readonly remoteStream: MediaStream | null;
   readonly rtcPeerConnection: RTCPeerConnection | undefined;
-  readonly errors$: Observable<Error>;
+  readonly errors$: Observable<CallError>;
   readonly signalingEvent$: Observable<Record<string, unknown>>;
   readonly address?: CallAddress;
   readonly address$: Observable<CallAddress | undefined>;
+  userVariables?: Record<string, unknown>;
+  readonly userVariables$: Observable<Record<string, unknown>>;
   hangup(): Promise<void>;
   toggleLock(): Promise<void>;
   toggleHold(): Promise<void>;
@@ -1354,10 +1451,11 @@ interface Call extends CallState {
   transfer(options: TransferOptions): Promise<void>;
   toggleIncomingVideo(): Promise<void>;
   toggleIncomingAudio(): Promise<void>;
-  answer(): void;
+  answer(options?: MediaOptions): void;
   reject(): void;
   sendDigits(digits: string): Promise<void>;
   executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>): Promise<T>;
+  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
 }
 /**
  * Extended Call interface with internal management capabilities
@@ -1373,6 +1471,7 @@ interface CallManager extends Call {
   readonly nodeId$: Observable<string | null>;
   readonly nodeId: string | null;
   readonly answered$: Observable<boolean>;
+  readonly answerMediaOptions?: MediaOptions;
   readonly callUpdated$: Observable<CallUpdatedPayload>;
   readonly memberJoined$: Observable<MemberJoinedPayload>;
   readonly memberLeft$: Observable<MemberLeftPayload>;
@@ -1384,7 +1483,6 @@ interface CallManager extends Call {
   addCallId(callId: string): void;
   /** @internal */
   createParticipant(memberId: string, selfId?: string | null): Participant | SelfParticipant;
-  execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
   destroy(): void;
 }
 //#endregion
@@ -1622,18 +1720,52 @@ 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;
   private isConnected;
   private ackEvent;
   private replySignalwirePing;
+  /**
+   * Filter that drops events whose timestamp predates the current session.
+   *
+   * 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.
+   */
+  private discardStaleEvents;
+  private _sessionEpoch;
   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>;
@@ -1723,8 +1855,41 @@ interface ClientSession {
   readonly iceServers: RTCIceServer[] | undefined;
 }
 //#endregion
+//#region src/interfaces/SessionState.d.ts
+/**
+ * Extended session interface that adds call management and authentication
+ * state on top of the narrow ClientSession contract.
+ *
+ * Accessible via `client.session`. Call and CallFactory continue to depend
+ * only on the narrow ClientSession interface.
+ */
+interface SessionState extends ClientSession {
+  /**
+   * Observable stream of currently active inbound calls.
+   * Filters `calls$` to only include calls with `direction === 'inbound'`.
+   */
+  readonly incomingCalls$: Observable<Call[]>;
+  /**
+   * Current snapshot of active inbound calls.
+   */
+  readonly incomingCalls: Call[];
+  /**
+   * Observable stream of all currently active calls (both inbound and outbound).
+   */
+  readonly calls$: Observable<Call[]>;
+  /**
+   * Current snapshot of all active calls.
+   */
+  readonly calls: Call[];
+  /**
+   * Observable that emits `true` once the session has been authenticated,
+   * and `false` after disconnect.
+   */
+  readonly authenticated$: Observable<boolean>;
+}
+//#endregion
 //#region src/managers/ClientSessionManager.d.ts
-declare class ClientSessionManager extends Destroyable implements ClientSession {
+declare class ClientSessionManager extends Destroyable implements SessionState {
   private credential;
   private readonly transport;
   private readonly storage;
@@ -1735,16 +1900,16 @@ declare class ClientSessionManager extends Destroyable implements ClientSession
   private readonly agent;
   private readonly eventAcks;
   initialized$: Observable<boolean>;
-  authorization$: rxjs0.Subject<Authorization>;
   private authorizationState$;
   private connectVersion;
+  private _authorization$;
   private _errors$;
   private _directory?;
   private _authenticated$;
   private _subscriberInfo$;
   private _calls$;
   private _iceServers$;
-  constructor(credential: SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager);
+  constructor(credential: SDKCredential, transport: TransportManager, storage: StorageManager, authorizationStateKey: string, deviceController: DeviceController, attachManager: AttachManager, webRTCApiProvider: WebRTCApiProvider);
   get incomingCalls$(): Observable<Call[]>;
   get incomingCalls(): Call[];
   get subscriberInfo$(): Observable<Address | null>;
@@ -1752,6 +1917,8 @@ declare class ClientSessionManager extends Destroyable implements ClientSession
   get calls$(): Observable<Call[]>;
   get calls(): Call[];
   get iceServers(): RTCIceServer[] | undefined;
+  get authorization$(): Observable<Authorization | undefined>;
+  get authorization(): Authorization | undefined;
   get errors$(): Observable<Error>;
   get authenticated$(): Observable<boolean>;
   get authenticated(): boolean;
@@ -1768,84 +1935,146 @@ declare class ClientSessionManager extends Destroyable implements ClientSession
   private loadAuthorizationStateFromStorage;
   private updateAuthorizationStateInStorage;
   private get authStateEvent$();
-  get signalingEvent$(): Observable<{
+  get signalingEvent$(): Observable<(Omit<{
     event_type: "webrtc.message";
-    event_channel: string;
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: WebrtcMessagePayload;
+  }, "event_channel" | "project_id" | "node_id"> & {
+    event_channel: string;
     project_id: string;
     node_id: string;
-    params: WebrtcMessagePayload;
-  } | {
+  }) | {
     event_type: "signalwire.authorization.state";
     params: SignalwireAuthorizationStatePayload;
-  } | {
+  } | (Omit<{
     event_type: "call.joined";
-    event_channel: string;
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallJoinedPayload;
-  } | {
-    event_type: "call.left";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.left";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallLeftPayload;
-  } | {
-    event_type: "call.updated";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.updated";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallUpdatedPayload;
-  } | {
-    event_type: "call.state";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.state";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallStatePayload;
-  } | {
-    event_type: "call.play";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.play";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallPlayPayload;
-  } | {
-    event_type: "call.connect";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.connect";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallConnectPayload;
-  } | {
+  }, "event_channel"> & {
+    event_channel: string;
+  }) | Omit<{
     event_type: "member.updated";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberUpdatedPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "member.joined";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberJoinedPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "member.left";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberLeftPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "member.talking";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberTalkingPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "layout.changed";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: LayoutChangedPayload;
-  } | {
+  }, never> | (Omit<{
     event_type: "conversation.message";
+    event_channel: EventChannel;
+    timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: ConversationMessagePayload;
+  }, "event_channel" | "timestamp" | "is_author"> & {
     event_channel: string;
     timestamp: string;
     is_author: boolean;
-    params: ConversationMessagePayload;
-  } | {
+  }) | (Omit<{
     event_type: "conversation.message.updated";
+    event_channel: EventChannel;
+    timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: ConversationMessagePayload;
+  }, "event_channel" | "timestamp" | "is_author"> & {
     event_channel: string;
     timestamp: string;
     is_author: boolean;
-    params: ConversationMessageUpdatedPayload;
-  }>;
+  })>;
   private get vertoInvite$();
   private get contexts();
   private get eventing();
@@ -1855,6 +2084,7 @@ declare class ClientSessionManager extends Destroyable implements ClientSession
   private handleAuthenticationError;
   cleanupStoredConnectionParams(): Promise<void>;
   protected updateAuthState(authorization_state: string): Promise<void>;
+  reauthenticate(token: string): Promise<void>;
   private authenticate;
   disconnect(): Promise<void>;
   private createInboundCall;
@@ -1862,89 +2092,152 @@ declare class ClientSessionManager extends Destroyable implements ClientSession
   private createCall;
   destroy(): void;
 }
-declare class ClientSessionWrapper {
+declare class ClientSessionWrapper implements SessionState {
   private clientSessionManager;
   constructor(clientSessionManager: ClientSessionManager);
   get authenticated$(): Observable<boolean>;
   get authenticated(): boolean;
-  get signalingEvent$(): Observable<{
+  get signalingEvent$(): Observable<(Omit<{
     event_type: "webrtc.message";
-    event_channel: string;
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: WebrtcMessagePayload;
+  }, "event_channel" | "project_id" | "node_id"> & {
+    event_channel: string;
     project_id: string;
     node_id: string;
-    params: WebrtcMessagePayload;
-  } | {
+  }) | {
     event_type: "signalwire.authorization.state";
     params: SignalwireAuthorizationStatePayload;
-  } | {
+  } | (Omit<{
     event_type: "call.joined";
-    event_channel: string;
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallJoinedPayload;
-  } | {
-    event_type: "call.left";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.left";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallLeftPayload;
-  } | {
-    event_type: "call.updated";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.updated";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallUpdatedPayload;
-  } | {
-    event_type: "call.state";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.state";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallStatePayload;
-  } | {
-    event_type: "call.play";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.play";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallPlayPayload;
-  } | {
-    event_type: "call.connect";
+  }, "event_channel"> & {
     event_channel: string;
+  }) | (Omit<{
+    event_type: "call.connect";
+    event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: CallConnectPayload;
-  } | {
+  }, "event_channel"> & {
+    event_channel: string;
+  }) | Omit<{
     event_type: "member.updated";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberUpdatedPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "member.joined";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberJoinedPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "member.left";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberLeftPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "member.talking";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: MemberTalkingPayload;
-  } | {
+  }, never> | Omit<{
     event_type: "layout.changed";
     event_channel: EventChannel;
     timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
     params: LayoutChangedPayload;
-  } | {
+  }, never> | (Omit<{
     event_type: "conversation.message";
+    event_channel: EventChannel;
+    timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: ConversationMessagePayload;
+  }, "event_channel" | "timestamp" | "is_author"> & {
     event_channel: string;
     timestamp: string;
     is_author: boolean;
-    params: ConversationMessagePayload;
-  } | {
+  }) | (Omit<{
     event_type: "conversation.message.updated";
+    event_channel: EventChannel;
+    timestamp: number;
+    project_id?: string;
+    node_id?: string;
+    is_author?: boolean;
+    params: ConversationMessagePayload;
+  }, "event_channel" | "timestamp" | "is_author"> & {
     event_channel: string;
     timestamp: string;
     is_author: boolean;
-    params: ConversationMessageUpdatedPayload;
-  }>;
+  })>;
+  get iceServers(): RTCIceServer[] | undefined;
   execute<T extends JSONRPCResponse = JSONRPCResponse>(request: JSONRPCRequest, options?: PendingRPCOptions): Promise<T>;
   get incomingCalls$(): Observable<Call[]>;
   get incomingCalls(): Call[];
@@ -1959,8 +2252,6 @@ interface SignalWireOptions {
   skipConnection?: boolean;
   /** Skip automatic subscriber registration on construction. */
   skipRegister?: boolean;
-  /** Skip reconnecting to previously attached calls. */
-  skipReconnect?: boolean;
   /** Skip monitoring media device changes. */
   skipDeviceMonitoring?: boolean;
   /** Whether to reconnect to previously attached calls. */
@@ -1971,6 +2262,8 @@ interface SignalWireOptions {
   storageImplementation?: Storage;
   /** Custom WebSocket constructor */
   webSocketConstructor?: WebSocketAdapter | NodeSocketAdapter;
+  /** Custom WebRTC API provider */
+  webRTCApiProvider?: WebRTCApiProvider;
 }
 /** Options for {@link SignalWire.dial}. Extends {@link MediaOptions} with dial-specific settings. */
 interface DialOptions extends MediaOptions {}
@@ -2188,38 +2481,9 @@ declare class StaticCredentialProvider implements CredentialProvider {
   authenticate(): Promise<SDKCredential>;
 }
 //#endregion
-//#region src/core/errors.d.ts
-declare class CallCreateError extends Error {
-  message: string;
-  error: unknown;
-  constructor(message: string, error?: unknown, options?: ErrorOptions);
-}
-declare class VertoPongError extends Error {
-  originalError: unknown;
-  constructor(originalError: unknown);
-}
-declare class MessageParseError extends Error {
-  originalError: unknown;
-  constructor(originalError: unknown);
-}
-declare class CollectionFetchError extends Error {
-  operation: string;
-  originalError: unknown;
-  constructor(operation: string, originalError: unknown);
-}
-declare class MediaTrackError extends Error {
-  operation: string;
-  kind: string;
-  originalError: unknown;
-  constructor(operation: string, kind: string, originalError: unknown);
-}
-//#endregion
 //#region src/controllers/RTCPeerConnectionController.d.ts
 interface RTCPeerConnectionControllerOptions extends MediaOptions {
   callId?: string;
-  WebRTCPeerConnectionConstructor?: typeof RTCPeerConnection;
-  getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
-  getDisplayMedia?: (options: DisplayMediaStreamOptions) => Promise<MediaStream>;
   rtcConfiguration?: RTCConfiguration;
   simulcast?: boolean;
   sfu?: boolean;
@@ -2230,6 +2494,7 @@ interface RTCPeerConnectionControllerOptions extends MediaOptions {
   relayOnly?: boolean;
   iceCandidateTimeout?: number;
   iceGatheringTimeout?: number;
+  webRTCApiProvider?: WebRTCApiProvider;
 }
 type RTCPeerConnectionControllerOptionsPartial = Partial<RTCPeerConnectionControllerOptions>;
 interface UpdateSDPStatusParams {
@@ -2269,6 +2534,7 @@ declare class RTCPeerConnectionController extends Destroyable {
   private _initialized$;
   private _remoteDescription$;
   private _remoteStream$;
+  private _remoteOfferMediaDirections;
   constructor(options?: RTCPeerConnectionControllerOptionsPartial, remoteSessionDescription?: string, deviceController?: DeviceController);
   private get iceGatheringController();
   private get shouldEmitLocalDescription();
@@ -2336,6 +2602,12 @@ declare class RTCPeerConnectionController extends Destroyable {
     status,
     sdp
   }: UpdateSDPStatusParams): Promise<void>;
+  /**
+   * Accept an inbound call by creating the SDP answer.
+   * Optionally override media options before the answer is generated.
+   * Must be called after initialization for inbound (answer-type) connections.
+   */
+  acceptInbound(mediaOverrides?: MediaOptions): Promise<void>;
   private handleOfferReceived;
   private readyToConnect;
   private setRemoteDescriptionBefore;
@@ -2426,15 +2698,13 @@ declare class CallEventsManager extends Destroyable {
   private originCallId?;
   private callIds;
   private roomSessionIds;
-  private _status$;
   private _participants$;
   private _self$;
   private _sessionState$;
   constructor(webRtcCallSession: CallManager, options?: WebRTCCallEventManagerOptions);
   get participants$(): Observable<CallParticipant[]>;
+  get participants(): CallParticipant[];
   get self$(): Observable<CallSelfParticipant>;
-  get status$(): Observable<CallStatus>;
-  get status(): CallStatus;
   isRoomSessionIdValid(roomSessionId: string): boolean;
   addCallId(callId: string): void;
   isCallIdValid(callId: string): boolean;
@@ -2515,19 +2785,24 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   readonly id: string;
   /** Destination URI this call was placed to. */
   to?: string;
-  protected readonly participantsMap: Map<string, Participant>;
   private vertoManager;
   private callEventsManager;
   private participantFactory;
   private _errors$;
   private _status$;
+  private _lastMergedStatus;
   private _answered$;
+  private _answerMediaOptions?;
   private _holdState;
+  private _userVariables$;
   constructor(clientSession: ClientSession, options: CallOptions, initialization: CallInitialization, address?: Address | undefined);
   /** Observable stream of errors from media, signaling, and peer connection layers. */
-  get errors$(): Observable<Error>;
-  /** @internal Push an error to the call's error stream. */
-  emitError(error: Error): void;
+  get errors$(): Observable<CallError>;
+  /**
+   * @internal Push an error to the call's error stream.
+   * Fatal errors automatically transition the call to `'failed'` and destroy it.
+   */
+  emitError(callError: CallError): void;
   /** Whether this call is `'inbound'` or `'outbound'`. */
   get direction(): CallDirection;
   /** Observable of the address associated with this call. */
@@ -2561,7 +2836,7 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   /** Current snapshot of layout layers. */
   get layoutLayers(): LayoutLayer[];
   /** Executes a Verto RPC method targeting a specific participant. */
-  executeMethod<T extends JSONRPCResponse = JSONRPCResponse>(target: string, method: string, args: Record<string, unknown>): Promise<T>;
+  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'`). */
   get status$(): Observable<CallStatus>;
@@ -2609,6 +2884,12 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   get remoteStream$(): Observable<MediaStream>;
   /** Current remote media stream, or `null` if not available. */
   get remoteStream(): MediaStream | null;
+  /** Observable of custom user variables associated with the call. */
+  get userVariables$(): Observable<Record<string, unknown>>;
+  /** a copy of the current custom user variables of the call. */
+  get userVariables(): Record<string, unknown>;
+  /** Merge current custom user variables of the call. */
+  set userVariables(variables: Record<string, unknown>);
   /** @internal */
   createParticipant(memberId: string, selfId?: string | null): Participant | SelfParticipant;
   /** Observable of the current audio/video send/receive directions. */
@@ -2656,8 +2937,10 @@ declare class WebRTCCall extends Destroyable implements CallManager {
   hangup(): Promise<void>;
   /** Sends DTMF digits (e.g. `'1234#'`) on the call. */
   sendDigits(dtmf: string): Promise<void>;
-  /** Accepts an inbound call. */
-  answer(): void;
+  /** Accepts an inbound call, optionally overriding media options for the answer. */
+  answer(options?: MediaOptions): void;
+  /** Media options provided when answering. Used internally by the VertoManager. */
+  get answerMediaOptions(): MediaOptions | undefined;
   /** Rejects an inbound call. */
   reject(): void;
   /** Observable that emits `true` when answered, `false` when rejected. */
@@ -2686,5 +2969,5 @@ declare const version: string;
  */
 declare const ready: boolean;
 //#endregion
-export { Address, type AddressHistory, type Call, type CallAddress, CallCreateError, type CallOptions, type CallParticipant, type CallSelfParticipant, type CallState, type CallStatus, ClientPreferences, CollectionFetchError, type DialOptions, type Directory, type ExecuteMethod, type LayoutLayer, type MediaDirection, type MediaDirections, type MediaOptions, MediaTrackError, MessageParseError, type NodeSocketAdapter, Participant, type SDKCredential, SelfParticipant, SignalWire, type SignalWireOptions, StaticCredentialProvider, Subscriber, type TextMessage, VertoPongError, WebRTCCall, type WebSocketAdapter, embeddableCall, isSelfParticipant, ready, version };
+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 };
 //# sourceMappingURL=index.d.mts.map