@telnyx/webrtc 2.26.0 → 2.26.1-beta.3

package/lib/{packages/js/src → src}/Modules/Verto/BaseSession.d.ts

@@ -24,6 +24,8 @@ export default abstract class BaseSession {
     protected _reconnectTimeout: any;
     protected _autoReconnect: boolean;
     protected _idle: boolean;
+    private _tokenExpiryTimeout;
+    private static readonly TOKEN_EXPIRY_WARNING_SECONDS;
     private _executeQueue;
     private _pong;
     private registerAgent;
@@ -35,12 +37,15 @@ export default abstract class BaseSession {
     execute(msg: BaseMessage): Promise<any>;
     executeRaw(text: string): void;
     validateOptions(): boolean;
-    broadcast(params: BroadcastParams): void;
+    broadcast(_params: BroadcastParams): void;
     disconnect(): Promise<void>;
     on(eventName: string, callback: Function): this;
     off(eventName: string, callback?: Function): this;
     connect(): Promise<void>;
     protected _handleLoginError(error: any): void;
+    private _checkTokenExpiry;
+    private _emitTokenExpiryWarning;
+    private _clearTokenExpiryTimeout;
     login({ creds, onSuccess, onError, }?: {
         creds?: ILoginParams;
         onSuccess?: () => void;
@@ -49,7 +54,7 @@ export default abstract class BaseSession {
     private _login;
     protected _onSocketOpen(): Promise<void>;
     onNetworkClose(): void;
-    protected _onSocketMessage(response: any): void;
+    protected _onSocketMessage(_response: any): void;
     protected _removeSubscription(protocol: string, channel?: string): void;
     protected _addSubscription(protocol: string, handler: Function, channel: string): void;
     _existsSubscription(protocol: string, channel?: string): boolean;

package/lib/src/Modules/Verto/util/constants/errorCodes.d.ts

@@ -0,0 +1,36 @@
+import type { SdkErrorCode } from './errors';
+import type { SdkWarningCode } from './warnings';
+export declare const SDP_CREATE_OFFER_FAILED: SdkErrorCode;
+export declare const SDP_CREATE_ANSWER_FAILED: SdkErrorCode;
+export declare const SDP_SET_LOCAL_DESCRIPTION_FAILED: SdkErrorCode;
+export declare const SDP_SET_REMOTE_DESCRIPTION_FAILED: SdkErrorCode;
+export declare const SDP_SEND_FAILED: SdkErrorCode;
+export declare const MEDIA_MICROPHONE_PERMISSION_DENIED: SdkErrorCode;
+export declare const MEDIA_DEVICE_NOT_FOUND: SdkErrorCode;
+export declare const MEDIA_GET_USER_MEDIA_FAILED: SdkErrorCode;
+export declare const HOLD_FAILED: SdkErrorCode;
+export declare const INVALID_CALL_PARAMETERS: SdkErrorCode;
+export declare const BYE_SEND_FAILED: SdkErrorCode;
+export declare const SUBSCRIBE_FAILED: SdkErrorCode;
+export declare const WEBSOCKET_CONNECTION_FAILED: SdkErrorCode;
+export declare const WEBSOCKET_ERROR: SdkErrorCode;
+export declare const RECONNECTION_EXHAUSTED: SdkErrorCode;
+export declare const GATEWAY_FAILED: SdkErrorCode;
+export declare const LOGIN_FAILED: SdkErrorCode;
+export declare const INVALID_CREDENTIALS: SdkErrorCode;
+export declare const AUTHENTICATION_REQUIRED: SdkErrorCode;
+export declare const NETWORK_OFFLINE: SdkErrorCode;
+export declare const HIGH_RTT: SdkWarningCode;
+export declare const HIGH_JITTER: SdkWarningCode;
+export declare const HIGH_PACKET_LOSS: SdkWarningCode;
+export declare const LOW_MOS: SdkWarningCode;
+export declare const LOW_BYTES_RECEIVED: SdkWarningCode;
+export declare const LOW_BYTES_SENT: SdkWarningCode;
+export declare const ICE_CONNECTIVITY_LOST: SdkWarningCode;
+export declare const ICE_GATHERING_TIMEOUT: SdkWarningCode;
+export declare const ICE_GATHERING_EMPTY: SdkWarningCode;
+export declare const PEER_CONNECTION_FAILED: SdkWarningCode;
+export declare const ONLY_HOST_ICE_CANDIDATES: SdkWarningCode;
+export declare const TOKEN_EXPIRING_SOON: SdkWarningCode;
+export declare const SESSION_NOT_REATTACHED: SdkWarningCode;
+export declare const HAS_NON_HOST_ICE_CANDIDATE_REGEX: RegExp;

package/lib/src/Modules/Verto/util/constants/errors.d.ts

@@ -0,0 +1,143 @@
+export declare const SDK_ERRORS: {
+    readonly 40001: {
+        readonly name: "SDP_CREATE_OFFER_FAILED";
+        readonly message: "Failed to create call offer";
+        readonly description: "The browser was unable to generate a local SDP offer. This typically indicates a WebRTC API error or invalid media constraints.";
+        readonly causes: readonly ["Browser WebRTC API error", "Missing or invalid media constraints"];
+        readonly solutions: readonly ["Check getUserMedia permissions", "Verify ICE server configuration"];
+    };
+    readonly 40002: {
+        readonly name: "SDP_CREATE_ANSWER_FAILED";
+        readonly message: "Failed to answer the call";
+        readonly description: "The browser was unable to generate a local SDP answer. The remote offer may be invalid or the browser state inconsistent.";
+        readonly causes: readonly ["Browser WebRTC API error", "Invalid remote SDP offer"];
+        readonly solutions: readonly ["Retry the call", "Check browser WebRTC compatibility"];
+    };
+    readonly 40003: {
+        readonly name: "SDP_SET_LOCAL_DESCRIPTION_FAILED";
+        readonly message: "Failed to apply local call settings";
+        readonly description: "setLocalDescription() was rejected by the browser. The generated SDP may be malformed or the browser state may be inconsistent.";
+        readonly causes: readonly ["Malformed SDP", "Browser state inconsistency"];
+        readonly solutions: readonly ["Retry the call"];
+    };
+    readonly 40004: {
+        readonly name: "SDP_SET_REMOTE_DESCRIPTION_FAILED";
+        readonly message: "Failed to apply remote call settings";
+        readonly description: "setRemoteDescription() was rejected by the browser. The remote SDP may be malformed or contain unsupported codecs.";
+        readonly causes: readonly ["Malformed remote SDP", "Browser codec mismatch"];
+        readonly solutions: readonly ["Retry the call", "Check codec configuration"];
+    };
+    readonly 40005: {
+        readonly name: "SDP_SEND_FAILED";
+        readonly message: "Failed to send call data to server";
+        readonly description: "The Invite or Answer message could not be delivered via the signaling WebSocket. The connection may have been lost.";
+        readonly causes: readonly ["WebSocket connection lost", "Server error"];
+        readonly solutions: readonly ["Check network connectivity", "Retry the call"];
+    };
+    readonly 42001: {
+        readonly name: "MEDIA_MICROPHONE_PERMISSION_DENIED";
+        readonly message: "Microphone access denied";
+        readonly description: "The user or operating system denied microphone permission. The browser permission prompt was dismissed or OS-level access is disabled.";
+        readonly causes: readonly ["User denied browser permission prompt", "OS-level microphone access disabled"];
+        readonly solutions: readonly ["Ask user to grant microphone permission in browser settings"];
+    };
+    readonly 42002: {
+        readonly name: "MEDIA_DEVICE_NOT_FOUND";
+        readonly message: "No microphone found";
+        readonly description: "The requested audio input device is not available. No microphone is connected, the device was disconnected, or an invalid deviceId was specified.";
+        readonly causes: readonly ["No microphone connected", "Device was disconnected", "Invalid deviceId"];
+        readonly solutions: readonly ["Check that a microphone is connected", "Select a valid audio input device"];
+    };
+    readonly 42003: {
+        readonly name: "MEDIA_GET_USER_MEDIA_FAILED";
+        readonly message: "Failed to access microphone";
+        readonly description: "getUserMedia() was rejected for an unexpected reason. The device may be in use by another application or the browser encountered an internal error.";
+        readonly causes: readonly ["Browser error", "Device in use by another application"];
+        readonly solutions: readonly ["Close other applications using the microphone", "Retry"];
+    };
+    readonly 44001: {
+        readonly name: "HOLD_FAILED";
+        readonly message: "Failed to hold the call";
+        readonly description: "The server rejected or did not respond to the hold request. The WebSocket connection may have been lost during the operation.";
+        readonly causes: readonly ["Server error", "WebSocket connection lost during hold"];
+        readonly solutions: readonly ["Retry the hold operation", "Check network connectivity"];
+    };
+    readonly 44002: {
+        readonly name: "INVALID_CALL_PARAMETERS";
+        readonly message: "Invalid call parameters";
+        readonly description: "The call could not be initiated because required parameters are missing or invalid. For example, no destination number was provided to newCall().";
+        readonly causes: readonly ["Missing destinationNumber in call options", "Invalid or empty call parameters"];
+        readonly solutions: readonly ["Provide a valid destinationNumber when calling newCall()", "Check the call options object for required fields"];
+    };
+    readonly 44003: {
+        readonly name: "BYE_SEND_FAILED";
+        readonly message: "Failed to hang up cleanly";
+        readonly description: "The hangup signal could not be delivered to the server. The call was terminated locally but the server may not be aware.";
+        readonly causes: readonly ["WebSocket connection lost before BYE sent"];
+        readonly solutions: readonly ["No action needed — call is terminated locally", "Check network connectivity"];
+    };
+    readonly 44004: {
+        readonly name: "SUBSCRIBE_FAILED";
+        readonly message: "Failed to subscribe to call events";
+        readonly description: "The Verto subscribe request for the call channel failed. This may prevent receiving call state updates from the server.";
+        readonly causes: readonly ["WebSocket connection lost during subscribe", "Server rejected the subscription request"];
+        readonly solutions: readonly ["Check network connectivity", "Retry the call"];
+    };
+    readonly 45001: {
+        readonly name: "WEBSOCKET_CONNECTION_FAILED";
+        readonly message: "Unable to connect to server";
+        readonly description: "The WebSocket connection to the signaling server could not be established. The server may be unreachable, the URL may be incorrect, or a firewall may be blocking the connection.";
+        readonly causes: readonly ["Server unreachable", "Incorrect WebSocket URL", "Firewall blocking WebSocket connections", "Network interruption"];
+        readonly solutions: readonly ["Check network connectivity", "Verify the signaling server URL", "Ensure WebSocket connections are not blocked by a firewall"];
+    };
+    readonly 45002: {
+        readonly name: "WEBSOCKET_ERROR";
+        readonly message: "Connection to server lost";
+        readonly description: "An error occurred on the WebSocket connection after it was established. The connection may have been dropped due to network issues or server-side closure.";
+        readonly causes: readonly ["Network interruption", "Server closed the connection", "Idle timeout"];
+        readonly solutions: readonly ["Check network connectivity", "SDK will attempt automatic reconnection if configured"];
+    };
+    readonly 45003: {
+        readonly name: "RECONNECTION_EXHAUSTED";
+        readonly message: "Unable to reconnect to server";
+        readonly description: "All automatic reconnection attempts have been exhausted. The SDK tried to re-establish the WebSocket connection multiple times but failed on every attempt.";
+        readonly causes: readonly ["Prolonged network outage", "Server unreachable", "Firewall or proxy blocking reconnection"];
+        readonly solutions: readonly ["Check network connectivity", "Call client.disconnect() and client.connect() to manually retry", "Notify the user that the connection was lost"];
+    };
+    readonly 45004: {
+        readonly name: "GATEWAY_FAILED";
+        readonly message: "Gateway connection failed";
+        readonly description: "The upstream gateway reported a FAILED or FAIL_WAIT state. The signaling server could not establish or maintain a connection to the gateway. When autoReconnect is disabled, this is immediately fatal. When enabled, the SDK will retry until RECONNECTION_EXHAUSTED.";
+        readonly causes: readonly ["Gateway down or unreachable", "Server-side infrastructure issue", "Network partition between signaling server and gateway"];
+        readonly solutions: readonly ["Wait for automatic reconnection (if autoReconnect is enabled)", "Call client.disconnect() and client.connect() to manually retry", "Check Telnyx service status"];
+    };
+    readonly 46001: {
+        readonly name: "LOGIN_FAILED";
+        readonly message: "Authentication failed";
+        readonly description: "The login request was rejected by the server. The credentials may be invalid, expired, or the account may be suspended.";
+        readonly causes: readonly ["Invalid credentials (username/password or token)", "Expired authentication token", "Account suspended or disabled"];
+        readonly solutions: readonly ["Verify credentials", "Generate a new authentication token", "Check account status"];
+    };
+    readonly 46002: {
+        readonly name: "INVALID_CREDENTIALS";
+        readonly message: "Invalid credential parameters";
+        readonly description: "The SDK rejected the login options before sending any request to the server. This is an internal client-side validation guard — the credentials object is missing required fields or has an invalid structure. No network request was made.";
+        readonly causes: readonly ["Missing login and password fields", "Missing or malformed authentication token", "Invalid combination of credential fields in the options object"];
+        readonly solutions: readonly ["Provide valid login/password or a valid authentication token", "Check the TelnyxRTC constructor options against the documentation", "Ensure the credential object matches one of the supported auth modes (credentials, token, or anonymous)"];
+    };
+    readonly 46003: {
+        readonly name: "AUTHENTICATION_REQUIRED";
+        readonly message: "Authentication required";
+        readonly description: "The server rejected a request because the session is not authenticated. This can happen when the client sends a message (e.g. Invite, Subscribe, or Ping) before login completes, after a token expires mid-session, or after the server drops the authenticated state for any reason.";
+        readonly causes: readonly ["Message sent before login completed", "Authentication token expired during the session", "Server-side session was invalidated", "WebSocket reconnected but re-authentication did not complete"];
+        readonly solutions: readonly ["Ensure the client is fully logged in before sending messages", "Re-authenticate using client.login() with fresh credentials", "Listen for telnyx.ready before making calls or sending requests"];
+    };
+    readonly 48001: {
+        readonly name: "NETWORK_OFFLINE";
+        readonly message: "Device is offline";
+        readonly description: "The browser reported that the device has lost network connectivity (navigator.onLine === false). All WebSocket and media connections will fail until the network is restored.";
+        readonly causes: readonly ["Wi-Fi or ethernet disconnected", "Airplane mode enabled", "Network interface went down"];
+        readonly solutions: readonly ["Check network connectivity", "Reconnect to Wi-Fi or ethernet", "Disable airplane mode"];
+    };
+};
+export declare type SdkErrorCode = keyof typeof SDK_ERRORS;

package/lib/{packages/js/src → src}/Modules/Verto/util/constants/index.d.ts

@@ -1,3 +1,4 @@
+export * from './errorCodes';
 export declare const STORAGE_PREFIX = "@telnyx:";
 export declare const ADD = "add";
 export declare const REMOVE = "remove";
@@ -46,6 +47,7 @@ export declare enum SwEvent {
     SpeedTest = "telnyx.internal.speedtest",
     Ready = "telnyx.ready",
     Error = "telnyx.error",
+    Warning = "telnyx.warning",
     Notification = "telnyx.notification",
     StatsFrame = "telnyx.stats.frame",
     StatsReport = "telnyx.stats.report",

package/lib/src/Modules/Verto/util/constants/warnings.d.ts

@@ -0,0 +1,103 @@
+export interface ITelnyxWarning {
+    code: SdkWarningCode;
+    name: string;
+    message: string;
+    description: string;
+    causes: string[];
+    solutions: string[];
+}
+export declare const SDK_WARNINGS: {
+    readonly 31001: {
+        readonly name: "HIGH_RTT";
+        readonly message: "High network latency detected";
+        readonly description: "Round-trip time (RTT) exceeded the threshold for multiple consecutive samples. High latency causes perceptible audio delays.";
+        readonly causes: readonly ["Poor network connection", "Geographic distance to media server", "Network congestion"];
+        readonly solutions: readonly ["Check network connectivity", "Use a wired connection instead of Wi-Fi", "Close bandwidth-heavy applications"];
+    };
+    readonly 31002: {
+        readonly name: "HIGH_JITTER";
+        readonly message: "High jitter detected";
+        readonly description: "Jitter (variability in packet arrival time) exceeded the threshold for multiple consecutive samples. High jitter causes crackling and choppy audio.";
+        readonly causes: readonly ["Network congestion", "Unstable Wi-Fi connection", "Overloaded network equipment"];
+        readonly solutions: readonly ["Use a wired connection instead of Wi-Fi", "Close bandwidth-heavy applications", "Check network equipment"];
+    };
+    readonly 31003: {
+        readonly name: "HIGH_PACKET_LOSS";
+        readonly message: "High packet loss detected";
+        readonly description: "Packet loss exceeded the threshold for multiple consecutive samples. High packet loss causes choppy audio or dropped calls.";
+        readonly causes: readonly ["Network congestion", "Unstable connection", "Firewall or QoS misconfiguration"];
+        readonly solutions: readonly ["Check network connectivity", "Use a wired connection", "Contact network administrator"];
+    };
+    readonly 31004: {
+        readonly name: "LOW_MOS";
+        readonly message: "Low call quality score";
+        readonly description: "Mean Opinion Score (MOS) dropped below the acceptable threshold for multiple consecutive samples. This is a composite indicator of overall call quality.";
+        readonly causes: readonly ["Combination of high latency, jitter, and/or packet loss", "Poor network conditions"];
+        readonly solutions: readonly ["Check network connectivity", "Use a wired connection", "Close bandwidth-heavy applications"];
+    };
+    readonly 32001: {
+        readonly name: "LOW_BYTES_RECEIVED";
+        readonly message: "No audio data received";
+        readonly description: "No bytes have been received from the remote party for multiple consecutive seconds. This may indicate a network interruption or remote-side issue.";
+        readonly causes: readonly ["Network interruption", "Remote party microphone issue", "Firewall blocking inbound media"];
+        readonly solutions: readonly ["Check network connectivity", "Ask remote party to check their microphone", "Check firewall rules for media ports"];
+    };
+    readonly 32002: {
+        readonly name: "LOW_BYTES_SENT";
+        readonly message: "No audio data being sent";
+        readonly description: "No bytes have been sent for multiple consecutive seconds. This may indicate a local microphone issue or network interruption.";
+        readonly causes: readonly ["Microphone muted or disconnected", "Network interruption", "Local media track ended"];
+        readonly solutions: readonly ["Check that the microphone is not muted", "Verify the microphone is still connected", "Check network connectivity"];
+    };
+    readonly 33001: {
+        readonly name: "ICE_CONNECTIVITY_LOST";
+        readonly message: "Connection interrupted";
+        readonly description: "The ICE connection transitioned to the disconnected state. The previously selected connection path was lost and renegotiation may be required. The connection may recover automatically.";
+        readonly causes: readonly ["Temporary network interruption", "Network interface change (e.g. Wi-Fi to cellular)", "NAT rebinding"];
+        readonly solutions: readonly ["Wait for automatic recovery", "Check network connectivity"];
+    };
+    readonly 33002: {
+        readonly name: "ICE_GATHERING_TIMEOUT";
+        readonly message: "ICE gathering timed out";
+        readonly description: "ICE candidate gathering did not complete within the safety timeout. This is typically caused by network restrictions blocking STUN/TURN. The call may still succeed if candidates arrive late.";
+        readonly causes: readonly ["Firewall blocking STUN/TURN", "Network unreachable", "STUN/TURN server not responding"];
+        readonly solutions: readonly ["Check STUN/TURN server reachability", "Ensure UDP traffic is not blocked", "Try forceRelayCandidate option"];
+    };
+    readonly 33003: {
+        readonly name: "ICE_GATHERING_EMPTY";
+        readonly message: "No ICE candidates gathered";
+        readonly description: "No ICE candidates were gathered after sending the initial SDP. This may indicate a firewall blocking all STUN/TURN traffic or no available network interface.";
+        readonly causes: readonly ["Firewall blocking all STUN/TURN traffic", "No network interface available", "VPN blocking UDP"];
+        readonly solutions: readonly ["Check STUN/TURN server reachability", "Ensure UDP traffic is not blocked", "Use forceRelayCandidate option"];
+    };
+    readonly 33004: {
+        readonly name: "PEER_CONNECTION_FAILED";
+        readonly message: "Connection failed";
+        readonly description: "RTCPeerConnection entered the failed state. This is a recoverable condition — the SDK may attempt ICE restart or the connection may recover. If it does not recover, the call will eventually be terminated.";
+        readonly causes: readonly ["ICE failure", "DTLS handshake failure", "Prolonged network interruption"];
+        readonly solutions: readonly ["Wait for automatic recovery", "Check network connectivity", "Verify TURN server credentials"];
+    };
+    readonly 33005: {
+        readonly name: "ONLY_HOST_ICE_CANDIDATES";
+        readonly message: "Only local network candidates available";
+        readonly description: "ICE gathering completed but only host (local network) candidates were collected — no server-reflexive (srflx) or relay (turn) candidates were found. This typically means the STUN/TURN servers are unreachable, which will prevent connections outside the local network.";
+        readonly causes: readonly ["STUN/TURN servers unreachable", "Firewall blocking UDP traffic to STUN/TURN servers", "Incorrect TURN server configuration or credentials", "Restrictive corporate network or VPN"];
+        readonly solutions: readonly ["Verify STUN/TURN server URLs and credentials", "Ensure UDP traffic to STUN/TURN ports is not blocked", "Check firewall or VPN settings", "Try using TCP-based TURN as a fallback"];
+    };
+    readonly 34001: {
+        readonly name: "TOKEN_EXPIRING_SOON";
+        readonly message: "Authentication token expiring soon";
+        readonly description: "The authentication token is approaching its expiration time. If the token expires the connection will be lost and calls will fail. A new token should be generated before expiration.";
+        readonly causes: readonly ["Token was issued with a limited lifetime"];
+        readonly solutions: readonly ["Generate a new authentication token", "Reconnect with fresh credentials before the token expires"];
+    };
+    readonly 35001: {
+        readonly name: "SESSION_NOT_REATTACHED";
+        readonly message: "Active call lost after reconnect";
+        readonly description: "The WebSocket reconnected successfully but the server returned an empty reattached_sessions list while the SDK still has an active call. The server no longer knows about the call, so any subsequent call-control operation (hangup, hold, etc.) will fail with CALL_DOES_NOT_EXIST.";
+        readonly causes: readonly ["Server-side session expired during the disconnection window", "Reconnect token was invalidated", "Backend restarted or lost in-memory call state"];
+        readonly solutions: readonly ["Terminate the local call and notify the user", "Start a new call", "Investigate why the session was not preserved on the server"];
+    };
+};
+export declare type SdkWarningCode = keyof typeof SDK_WARNINGS;
+export declare function createTelnyxWarning(code: SdkWarningCode, message?: string): ITelnyxWarning;

package/lib/src/Modules/Verto/util/errors.d.ts

@@ -0,0 +1,27 @@
+import { SDK_ERRORS, SdkErrorCode } from './constants/errors';
+import { SDK_WARNINGS, SdkWarningCode, ITelnyxWarning, createTelnyxWarning } from './constants/warnings';
+import { MEDIA_MICROPHONE_PERMISSION_DENIED, MEDIA_DEVICE_NOT_FOUND, MEDIA_GET_USER_MEDIA_FAILED } from './constants/errorCodes';
+export { SDK_ERRORS, SdkErrorCode };
+export { SDK_WARNINGS, SdkWarningCode, ITelnyxWarning, createTelnyxWarning };
+export interface ITelnyxError {
+    code: number;
+    name: string;
+    description: string;
+    message: string;
+    causes: string[];
+    solutions: string[];
+    originalError?: unknown;
+}
+export declare class TelnyxError extends Error implements ITelnyxError {
+    readonly code: number;
+    readonly description: string;
+    readonly causes: string[];
+    readonly solutions: string[];
+    readonly originalError?: unknown;
+    constructor(params: Omit<ITelnyxError, 'message'> & {
+        message?: string;
+    });
+    toJSON(): ITelnyxError;
+}
+export declare function classifyMediaErrorCode(error: unknown): typeof MEDIA_MICROPHONE_PERMISSION_DENIED | typeof MEDIA_DEVICE_NOT_FOUND | typeof MEDIA_GET_USER_MEDIA_FAILED;
+export declare function createTelnyxError(code: SdkErrorCode, originalError?: unknown, message?: string): TelnyxError;

package/lib/{packages/js/src → src}/Modules/Verto/util/interfaces.d.ts

@@ -21,6 +21,7 @@ export interface IVertoOptions {
     prefetchIceCandidates?: boolean;
     forceRelayCandidate?: boolean;
     trickleIce?: boolean;
+    singleInterfaceIce?: boolean;
     keepConnectionAliveOnSocketClose?: boolean;
     useCanaryRtcServer?: boolean;
     region?: string;

package/lib/{packages/js/src → src}/Modules/Verto/webrtc/BaseCall.d.ts

@@ -40,9 +40,11 @@ export default abstract class BaseCall implements IWebRTCCall {
     private _isRemoteDescriptionSet;
     private _signalingStateClosed;
     private _creatingPeer;
+    private _firstCandidateSent;
+    private _firstNonHostCandidateSent;
     private _isRecovering;
+    private _candidateFilter;
     constructor(session: BrowserSession, opts?: IVertoCallOptions);
-    private get performanceMetrics();
     get nodeId(): string;
     set nodeId(what: string);
     get isVideoCall(): boolean;
@@ -61,8 +63,8 @@ export default abstract class BaseCall implements IWebRTCCall {
     stopRingtone(): void;
     playRingback(): void;
     stopRingback(): void;
-    hangup(): void;
-    hangup(hangupParams: IHangupParams, hangupExecute: boolean): void;
+    hangup(): Promise<void>;
+    hangup(hangupParams: IHangupParams, hangupExecute: boolean): Promise<void>;
     hold(): Promise<any>;
     unhold(): Promise<any>;
     toggleHold(): Promise<any>;
@@ -102,6 +104,7 @@ export default abstract class BaseCall implements IWebRTCCall {
     private _addIceCandidate;
     private _addIceCandidateToPeer;
     private _sendEndOfCandidates;
+    private _trackCandidateMarks;
     private _resetTrickleIceCandidateState;
     private _flushPendingTrickleIceCandidates;
     private _registerPeerEvents;

package/lib/{packages/js/src → src}/Modules/Verto/webrtc/Call.d.ts

@@ -3,9 +3,9 @@ import { IVertoCallOptions } from './interfaces';
 export declare class Call extends BaseCall {
     screenShare: Call;
     private _statsInterval;
-    hangup(params?: any, execute?: boolean): void;
+    hangup(params?: any, execute?: boolean): Promise<void>;
     startScreenShare(opts?: IVertoCallOptions): Promise<Call>;
-    stopScreenShare(): void;
+    stopScreenShare(): Promise<void>;
     sendConversationMessage: (message: string, attachments?: string[]) => Promise<any>;
     setAudioOutDevice(deviceId: string): Promise<boolean>;
     protected _finalize(): void;

package/lib/src/Modules/Verto/webrtc/CallEstablishmentTimings.d.ts

@@ -0,0 +1,12 @@
+export interface ICallEstablishmentTimings {
+    mode: 'trickle' | 'non-trickle';
+    direction: 'outbound' | 'inbound';
+    steps: Array<{
+        label: string;
+        fromStart: number;
+        delta: number;
+    }>;
+}
+export declare function collectCallEstablishmentTimings(mode: 'trickle' | 'non-trickle', direction: 'outbound' | 'inbound'): ICallEstablishmentTimings;
+export declare function logCallEstablishmentTimings(timings: ICallEstablishmentTimings): void;
+export declare function clearCallMarks(): void;

package/lib/{packages/js/src → src}/Modules/Verto/webrtc/CallReportCollector.d.ts

@@ -1,4 +1,5 @@
 import { ILogEntry } from '../../../Modules/Verto/util/LogCollector';
+import { type ITelnyxWarning } from '../../../Modules/Verto/util/errors';
 interface ICECandidateInfo {
     address?: string;
     port?: number;
@@ -107,6 +108,18 @@ export declare class CallReportCollector {
     private static readonly STATS_FLUSH_THRESHOLD;
     private static readonly LOGS_FLUSH_THRESHOLD;
     onFlushNeeded: (() => void) | null;
+    onWarning: ((warning: ITelnyxWarning) => void) | null;
+    private static readonly CONSECUTIVE_BREACHES_REQUIRED;
+    private static readonly THRESHOLD_RTT_MS;
+    private static readonly THRESHOLD_JITTER_MS;
+    private static readonly THRESHOLD_PACKET_LOSS_PCT;
+    private static readonly THRESHOLD_MOS;
+    private _breachCounters;
+    private _activeWarnings;
+    private _lastWarningEmitted;
+    private static readonly WARNING_THROTTLE_MS;
+    private _prevPacketsReceived;
+    private _prevPacketsLost;
     private _segmentIndex;
     private _flushing;
     private static readonly RETRY_DELAY_MS;
@@ -121,6 +134,8 @@ export declare class CallReportCollector {
     getLogs(): ILogEntry[];
     cleanup(): void;
     private _collectStats;
+    private _checkQualityWarnings;
+    private _trackBreach;
     private _createStatsEntry;
     private _resolveCandidate;
     private _getOutboundAudioLevel;

package/lib/src/Modules/Verto/webrtc/CandidateFilter.d.ts

@@ -0,0 +1,14 @@
+export declare class CandidateFilter {
+    private _lockedInterface;
+    private _enabled;
+    private _onCandidate;
+    private _onEndOfCandidates;
+    private _filteredCount;
+    private _passedCount;
+    constructor(enabled: boolean, onCandidate: (candidate: RTCIceCandidate) => void, onEndOfCandidates: () => void);
+    add(event: RTCPeerConnectionIceEvent): void;
+    reset(): void;
+    private _extractRaddr;
+    private _extractNetworkId;
+    private _isTcpCandidate;
+}

package/lib/{packages/js/src → src}/Modules/Verto/webrtc/Peer.d.ts

@@ -16,6 +16,11 @@ export default class Peer {
     private _trickleIceSdpFn;
     private _registerPeerEvents;
     private _sleepWakeupIntervalId;
+    private _iceGatheringSafetyTimeout;
+    private _gatheredCandidatesCount;
+    private static readonly ICE_GATHERING_SAFETY_TIMEOUT_MS;
+    private _firstMediaTrackMarked;
+    private _timingsCollected;
     constructor(type: PeerType, options: IVertoCallOptions, session: BrowserSession, trickleIceSdpFn: (sdp: RTCSessionDescriptionInit) => void, registerPeerEvents: (instance: RTCPeerConnection) => void);
     get isOffer(): boolean;
     get isAnswer(): boolean;
@@ -26,14 +31,17 @@ export default class Peer {
     startNegotiation(): void;
     startTrickleIceNegotiation(): Promise<void>;
     private _logTransceivers;
-    private get trickleIcePerformanceMetrics();
     private handleSignalingStateChangeEvent;
     private handleNegotiationNeededEvent;
     private handleTrackEvent;
     private handleConnectionStateChange;
+    tryCollectTimings(): void;
     private createPeerConnection;
     private _handleIceConnectionStateChange;
     private _handleIceGatheringStateChange;
+    incrementGatheredCandidates(): void;
+    private _startIceGatheringSafetyTimeout;
+    private _clearIceGatheringSafetyTimeout;
     init(): Promise<void>;
     private _getSenderByKind;
     private _checkMediaToNegotiate;

package/lib/{packages/js/src → src}/Modules/Verto/webrtc/VertoHandler.d.ts

@@ -4,7 +4,6 @@ declare class VertoHandler {
     nodeId: string;
     retriedConnect: number;
     retriedRegister: number;
-    receivedAuthenticationRequired: number;
     constructor(session: BrowserSession);
     private _ack;
     private reconnectDelay;

package/lib/{packages/js/src → src}/Modules/Verto/webrtc/interfaces.d.ts

@@ -66,6 +66,7 @@ export interface IVertoCallOptions {
     prefetchIceCandidates?: boolean;
     forceRelayCandidate?: boolean;
     trickleIce?: boolean;
+    singleInterfaceIce?: boolean;
     keepConnectionAliveOnSocketClose?: boolean;
     mutedMicOnStart?: boolean;
     recoveredCallId?: string;
@@ -107,7 +108,7 @@ export interface IWebRTCCall {
     signalingStateClosed: boolean;
     invite: () => void;
     answer: (params: AnswerParams) => void;
-    hangup: (params: IHangupParams, execute: boolean) => void;
+    hangup: (params?: IHangupParams, execute?: boolean) => Promise<void>;
     hold: () => void;
     unhold: () => void;
     toggleHold: () => void;
@@ -132,7 +133,7 @@ export interface IWebRTCCall {
     _addChannel: (laChannel: any) => void;
     handleConferenceUpdate: (packet: any, pvtData: any) => Promise<string>;
     startScreenShare?: (opts?: object) => Promise<IWebRTCCall>;
-    stopScreenShare?: () => void;
+    stopScreenShare?: () => Promise<void>;
     setAudioOutDevice?: (deviceId: string) => Promise<boolean>;
     setSpeakerPhone?: (flag: boolean) => void;
 }

package/lib/{packages/js/src → src}/index.d.ts

@@ -4,4 +4,6 @@ import { SwEvent } from './Modules/Verto/util/constants';
 import { NOTIFICATION_TYPE, ERROR_TYPE } from './Modules/Verto/webrtc/constants';
 import Call from './Modules/Verto/webrtc/Call';
 export { Call, TelnyxRTC, IClientOptions, ICallOptions, ICredentials, INotification, SwEvent, NOTIFICATION_TYPE, ERROR_TYPE, };
+export type { ITelnyxError } from './Modules/Verto/util/errors';
+export type { ITelnyxWarning } from './Modules/Verto/util/constants/warnings';
 export * from './PreCallDiagnosis';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telnyx/webrtc",
-  "version": "2.26.0",
+  "version": "2.26.1-beta.3",
   "description": "Telnyx WebRTC Client",
   "keywords": [
     "telnyx",
@@ -17,7 +17,8 @@
   "module": "lib/bundle.mjs",
   "types": "lib/packages/js/src/index.d.ts",
   "files": [
-    "lib"
+    "lib",
+    "README.md"
   ],
   "scripts": {
     "build": "rollup -c",