@signalwire/js 4.0.0-rc.1 → 4.0.0-rc.3

package/dist/operators-BVxi3KpN.mjs

@@ -0,0 +1,731 @@
+import { filter, map, pipe } from "rxjs";
+import log from "loglevel";
+import { filter as filter$1, map as map$1 } from "rxjs/operators";
+
+//#region src/core/constants.ts
+const INVITE_VERSION = 1e3;
+const DEFAULT_ICE_CANDIDATE_TIMEOUT_MS = 600;
+const DEFAULT_ICE_GATHERING_TIMEOUT_MS = 6e3;
+const DEFAULT_RECONNECT_CALLS_TIMEOUT_MS = 300 * 1e3;
+const DEFAULT_CONNECTION_TIMEOUT_MS = 1e4;
+/**
+* How long call setup may wait for the network, measured from local media
+* settling until the member id arrives.
+*
+* Local media acquisition is deliberately NOT inside this: a permission prompt
+* or a device picker is human time, and a human may take as long as they like
+* without spending the server's budget. The clock starts when acquisition ends.
+*
+* Must exceed `iceGatheringTimeout + the RPC timeout`, which both run inside it.
+*/
+const DEFAULT_CALL_SIGNALING_TIMEOUT_MS = 12e3;
+/**
+* How long an auxiliary leg (screen share, additional device) may take to
+* connect once its media is in hand.
+*
+* One bound for both: the picker is human time and sits outside it. What remains
+* — offer, ICE, invite, answer, DTLS — is the same work for either leg kind.
+*/
+const DEFAULT_AUX_LEG_CONNECT_TIMEOUT_MS = 15e3;
+const DEFAULT_RECONNECT_DELAY_MIN_MS = 100;
+const DEFAULT_RECONNECT_DELAY_MAX_MS = 3e3;
+const DEFAULT_DEVICE_DEBOUNCE_TIME_MS = 1500;
+const DEFAULT_DEVICE_POLLING_INTERVAL_MS = 0;
+const PREFERENCES_STORAGE_KEY = "sw:preferences";
+/** Scope value that enables automatic token refresh. */
+const SAT_REFRESH_SCOPE = "sat:refresh";
+/** API endpoints for device token operations. */
+const DEVICE_TOKEN_ENDPOINT = "/api/fabric/subscriber/devices/token";
+const DEVICE_REFRESH_ENDPOINT = "/api/fabric/subscriber/devices/refresh";
+/** Default device token TTL in seconds (15 minutes). */
+const DEVICE_TOKEN_DEFAULT_EXPIRE_IN = 900;
+/** Buffer time in milliseconds before expiry to trigger refresh. */
+const DEVICE_TOKEN_REFRESH_BUFFER_MS = 3e4;
+/** Maximum retry attempts for device token refresh on transient failure. */
+const DEVICE_TOKEN_REFRESH_MAX_RETRIES = 3;
+/** Base delay in milliseconds for exponential backoff on refresh retry. */
+const DEVICE_TOKEN_REFRESH_RETRY_BASE_MS = 1e3;
+/** Maximum retry attempts for developer credential refresh on transient failure. */
+const CREDENTIAL_REFRESH_MAX_RETRIES = 5;
+/** Base delay in milliseconds for exponential backoff on credential refresh retry. */
+const CREDENTIAL_REFRESH_RETRY_BASE_MS = 1e3;
+/** Maximum delay in milliseconds for credential refresh backoff. */
+const CREDENTIAL_REFRESH_MAX_DELAY_MS = 3e4;
+/** Buffer in milliseconds before token expiry to trigger refresh. */
+const CREDENTIAL_REFRESH_BUFFER_MS = 5e3;
+/**
+* Clock-skew allowance (ms) for treating an in-memory credential as expired
+* when deciding whether a fresh (re)connect must re-mint the token before
+* authenticating. A token within this window of its `expiry_at` is treated as
+* stale so the reconnect re-mints via the credential provider instead of
+* replaying a dead token (which the server rejects with -32003).
+*/
+const CREDENTIAL_EXPIRY_SKEW_MS = 3e4;
+/**
+* Maximum time the coordinator will wait for `DeviceTokenManager.activate()`
+* to resolve before treating the activation as failed and falling back to
+* the developer-provided refresh path. Prevents a wedged HTTP layer from
+* leaving the session with no active refresh mechanism.
+*/
+const CREDENTIAL_ACTIVATE_TIMEOUT_MS = 3e4;
+/** JSON-RPC error code for requester validation failure (corrupted auth state). */
+const RPC_ERROR_REQUESTER_VALIDATION_FAILED = -32003;
+/** JSON-RPC error code for invalid params (e.g., missing authentication block). */
+const RPC_ERROR_INVALID_PARAMS = -32602;
+/** JSON-RPC error code for authentication failure (invalid token, missing DPoP, etc.). */
+const RPC_ERROR_AUTHENTICATION_FAILED = -32002;
+/** Error names browsers use for a media permission denial (user or policy). */
+const MEDIA_ACCESS_DENIAL_NAMES = [
+	"NotAllowedError",
+	"SecurityError",
+	"PermissionDeniedError"
+];
+/** Error names browsers use when the capture hardware is already held exclusively. */
+const MEDIA_DEVICE_IN_USE_NAMES = ["NotReadableError", "TrackStartError"];
+/** Default polling interval for RTCPeerConnection.getStats() in milliseconds. */
+const DEFAULT_STATS_POLLING_INTERVAL_MS = 1e3;
+/** Number of initial samples used to build a baseline for spike detection. */
+const DEFAULT_STATS_BASELINE_SAMPLES = 10;
+/** Duration in ms with no inbound audio packets before emitting a critical issue. */
+const DEFAULT_STATS_NO_PACKET_THRESHOLD_MS = 2e3;
+/** Multiplier applied to baseline RTT to detect a warning-level RTT spike. */
+const DEFAULT_STATS_RTT_SPIKE_MULTIPLIER = 3;
+/** Packet loss fraction (0-1) above which a warning is emitted. */
+const DEFAULT_STATS_PACKET_LOSS_THRESHOLD = .05;
+/** Multiplier applied to baseline jitter to detect a jitter spike. */
+const DEFAULT_STATS_JITTER_SPIKE_MULTIPLIER = 4;
+/** Number of seconds of metrics history to retain. */
+const DEFAULT_STATS_HISTORY_SIZE = 30;
+/** Maximum keyframe requests allowed within a single burst window. */
+const DEFAULT_KEYFRAME_MAX_BURST = 3;
+/** Duration of the keyframe burst window in milliseconds. */
+const DEFAULT_KEYFRAME_BURST_WINDOW_MS = 3e3;
+/** Cooldown period in ms after burst limit is reached before allowing more keyframes. */
+const DEFAULT_KEYFRAME_COOLDOWN_MS = 1e4;
+/** Minimum time between re-INVITE attempts in milliseconds. */
+const DEFAULT_REINVITE_DEBOUNCE_TIME_MS = 1e4;
+/** Maximum number of re-INVITE attempts per call. */
+const DEFAULT_REINVITE_MAX_ATTEMPTS = 3;
+/** Timeout for a single re-INVITE attempt in milliseconds. */
+const DEFAULT_REINVITE_TIMEOUT_MS = 5e3;
+/** Debounce window in ms to collapse multiple detection signals into one trigger. */
+const DEFAULT_RECOVERY_DEBOUNCE_TIME_MS = 2e3;
+/** Cooldown period in ms between recovery attempts. */
+const DEFAULT_RECOVERY_COOLDOWN_MS = 1e4;
+/** Grace period in ms before treating ICE 'disconnected' as a failure. */
+const DEFAULT_ICE_DISCONNECTED_GRACE_PERIOD_MS = 3e3;
+/** Timeout for a single ICE restart attempt in milliseconds. */
+const DEFAULT_ICE_RESTART_TIMEOUT_MS = 5e3;
+/** Maximum recovery attempts before emitting 'max_attempts_reached'. */
+const DEFAULT_MAX_RECOVERY_ATTEMPTS = 3;
+/** Upper bound in ms for waiting on iceGatheringState === 'complete' after an ICE restart. */
+const ICE_GATHERING_COMPLETE_TIMEOUT_MS = 1e4;
+/** Upper bound in ms for waiting on RTCPeerConnection.connectionState === 'connected' after a recovery ICE restart. */
+const PEER_CONNECTION_RECOVERY_WAIT_MS = 5e3;
+/** Polling interval in ms while waiting for RTCPeerConnection.connectionState to transition. */
+const PEER_CONNECTION_RECOVERY_POLL_MS = 100;
+/** Polling interval for LocalAudioPipeline.level$ (ms). ~30fps is smooth for meters. */
+const AUDIO_LEVEL_POLL_INTERVAL_MS = 33;
+/** RMS level threshold (0..1) above which the local participant is considered speaking. */
+const VAD_THRESHOLD = .03;
+/** Hold window in ms below the threshold before speaking$ flips back to false. */
+const VAD_HOLD_MS = 250;
+/** Whether to persist device selections to storage by default. */
+const DEFAULT_PERSIST_DEVICE_SELECTION = true;
+/** Whether to auto-apply device changes to active calls by default. */
+const DEFAULT_SYNC_DEVICES_TO_ACTIVE_CALLS = true;
+/** Storage keys for persisted device selections. */
+const DEVICE_STORAGE_KEY_AUDIO_INPUT = "sw:device:audioinput";
+const DEVICE_STORAGE_KEY_AUDIO_OUTPUT = "sw:device:audiooutput";
+const DEVICE_STORAGE_KEY_VIDEO_INPUT = "sw:device:videoinput";
+/** Whether to auto-mute video when the tab becomes hidden. */
+const DEFAULT_AUTO_MUTE_VIDEO_ON_HIDDEN = false;
+/** Whether to re-enumerate devices when the page becomes visible. */
+const DEFAULT_REFRESH_DEVICES_ON_VISIBLE = true;
+/** Whether to check peer connection health when the page becomes visible. */
+const DEFAULT_CHECK_CONNECTION_ON_VISIBLE = true;
+/** Whether automatic video degradation on low bandwidth is enabled. */
+const DEFAULT_ENABLE_AUTO_DEGRADATION = true;
+/** Bitrate in kbps below which video is automatically disabled. */
+const DEFAULT_DEGRADATION_BITRATE_THRESHOLD_KBPS = 150;
+/** Bitrate in kbps above which video is automatically re-enabled (hysteresis). */
+const DEFAULT_DEGRADATION_RECOVERY_THRESHOLD_KBPS = 300;
+/** Whether relay-only escalation is enabled as a last-resort recovery tier. */
+const DEFAULT_ENABLE_RELAY_FALLBACK = true;
+/** Whether to listen for browser online/offline/connection events. */
+const DEFAULT_ENABLE_NETWORK_CHANGE_DETECTION = true;
+/** Whether to intercept server-sent media-timeout hangups and attempt recovery. */
+const DEFAULT_ENABLE_SERVER_HANGUP_INTERCEPTION = true;
+/** Default video track constraints applied when video is enabled without explicit constraints. */
+const DEFAULT_VIDEO_CONSTRAINTS = {
+	width: { ideal: 1280 },
+	height: { ideal: 720 },
+	aspectRatio: 16 / 9
+};
+/** Whether stereo Opus is enabled by default. */
+const DEFAULT_STEREO_AUDIO = false;
+/** Max average bitrate for stereo Opus in bits per second. */
+const DEFAULT_STEREO_MAX_AVERAGE_BITRATE = 51e4;
+
+//#endregion
+//#region src/core/errors.ts
+var UnexpectedError = class extends Error {
+	constructor(at, options) {
+		super(`Unexpected Error${at ? ` at ${at}` : ""}`, options);
+		this.at = at;
+		this.name = "UnexpectedError";
+	}
+};
+var UnimplementedError = class extends Error {
+	constructor(reason = "Not Implemented", options) {
+		super(reason, options);
+		this.reason = reason;
+		this.name = "UnimplementedError";
+	}
+};
+var InvalidCredentialsError = class extends Error {
+	constructor(reason = "Invalid Credentials", options) {
+		super(reason, options);
+		this.reason = reason;
+		this.name = "InvalidCredentialsError";
+	}
+};
+var WebSocketConnectionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "WebSocketConnectionError";
+	}
+};
+var TransportConnectionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "TransportConnectionError";
+	}
+};
+var WebSocketTimeoutError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "WebSocketTimeoutError";
+	}
+};
+var RequestTimeoutError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "RequestTimeoutError";
+	}
+};
+var RequestError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "RequestError";
+	}
+};
+var RPCTimeoutError = class extends Error {
+	constructor(requestId, timeoutMs, options) {
+		super(`RPC request ${requestId} timed out after ${timeoutMs}ms`, options);
+		this.requestId = requestId;
+		this.timeoutMs = timeoutMs;
+		this.name = "RPCTimeoutError";
+	}
+};
+var AuthStateHandlerError = class extends Error {
+	constructor(error = null, options) {
+		super("Error handling authorization state update", {
+			...options,
+			cause: options?.cause ?? (error instanceof Error ? error : void 0)
+		});
+		this.error = error;
+		this.name = "AuthStateHandlerError";
+	}
+};
+var StorageNotAvailableError = class extends Error {
+	constructor(storageType = "localStorage", options) {
+		super(`${storageType} is not available in this environment`, options);
+		this.storageType = storageType;
+		this.name = "StorageNotAvailableError";
+	}
+};
+var SerializationError = class extends Error {
+	constructor(key, originalError) {
+		super(`Failed to serialize value for key "${key}": ${originalError.message}`, { cause: originalError });
+		this.key = key;
+		this.originalError = originalError;
+		this.name = "SerializationError";
+	}
+};
+var DeserializationError = class extends Error {
+	constructor(key, originalError) {
+		super(`Failed to deserialize value for key "${key}": ${originalError.message}`, { cause: originalError });
+		this.key = key;
+		this.originalError = originalError;
+		this.name = "DeserializationError";
+	}
+};
+var StorageWriteError = class extends Error {
+	constructor(key, originalError) {
+		super(`Failed to write to storage for key "${key}": ${originalError.message}`, { cause: originalError });
+		this.key = key;
+		this.originalError = originalError;
+		this.name = "StorageWriteError";
+	}
+};
+var StorageReadError = class extends Error {
+	constructor(key, originalError) {
+		super(`Failed to read from storage "${key}": ${originalError.message}`, { cause: originalError });
+		this.key = key;
+		this.originalError = originalError;
+		this.name = "StorageReadError";
+	}
+};
+var DependencyError = class extends Error {
+	constructor(description, options) {
+		super(`Dependency ${description} is not set or available.`, options);
+		this.description = description;
+		this.name = "DependencyError";
+	}
+};
+var CallCreateError = class extends Error {
+	constructor(message, error = null, direction = "outbound", options) {
+		super(message, {
+			...options,
+			cause: options?.cause ?? (error instanceof Error ? error : void 0)
+		});
+		this.message = message;
+		this.error = error;
+		this.direction = direction;
+		this.name = "CallCreateError";
+	}
+};
+var CallNotReadyError = class extends Error {
+	constructor(callId, options) {
+		super(`Call "${callId}" has no self member context yet: selfId/nodeId have not been received from the server`, options);
+		this.callId = callId;
+		this.name = "CallNotReadyError";
+	}
+};
+var ParticipantNotReadyError = class extends Error {
+	constructor(memberId, options) {
+		super(`Participant "${memberId}" has no call context yet: its member state (call_id/node_id) has not been received from the server`, options);
+		this.memberId = memberId;
+		this.name = "ParticipantNotReadyError";
+	}
+};
+var JSONRPCError = class extends Error {
+	constructor(code, message, data, options, requestId) {
+		super(message, options);
+		this.code = code;
+		this.data = data;
+		this.requestId = requestId;
+		this.name = "JSONRPCError";
+	}
+};
+var InvalidParams = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.message = message;
+		this.name = "InvalidParams";
+	}
+};
+var ConversationError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.message = message;
+		this.name = "ConversationError";
+	}
+};
+var VertoInviteHandlerError = class extends Error {
+	constructor(error = null, options) {
+		super("Error handling Verto invite", {
+			...options,
+			cause: options?.cause ?? (error instanceof Error ? error : void 0)
+		});
+		this.error = error;
+		this.name = "VertoInviteHandlerError";
+	}
+};
+var VertoAttachHandlerError = class extends Error {
+	constructor(error = null, options) {
+		super("Error handling Verto attach", {
+			...options,
+			cause: options?.cause ?? (error instanceof Error ? error : void 0)
+		});
+		this.error = error;
+		this.name = "VertoAttachHandlerError";
+	}
+};
+var ValidationError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ValidationError";
+	}
+};
+var VertoPongError = class extends Error {
+	constructor(originalError) {
+		super("Failed to send Verto pong - call may disconnect", { cause: originalError instanceof Error ? originalError : void 0 });
+		this.originalError = originalError;
+		this.name = "VertoPongError";
+	}
+};
+var MessageParseError = class extends Error {
+	constructor(originalError) {
+		super("Failed to parse incoming WebSocket message", { cause: originalError instanceof Error ? originalError : void 0 });
+		this.originalError = originalError;
+		this.name = "MessageParseError";
+	}
+};
+var CollectionFetchError = class extends Error {
+	constructor(operation, originalError) {
+		super(`Collection fetch failed during ${operation}`, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.operation = operation;
+		this.originalError = originalError;
+		this.name = "CollectionFetchError";
+	}
+};
+/**
+* An auxiliary leg did not connect within its budget. Typed rather than a bare
+* RxJS `TimeoutError` so the leg and cause survive.
+*/
+var AuxiliaryLegTimeoutError = class extends Error {
+	constructor(leg, originalError) {
+		super(`Timed out waiting for the ${leg} connection to be established`, { cause: originalError });
+		this.leg = leg;
+		this.originalError = originalError;
+		this.name = "AuxiliaryLegTimeoutError";
+	}
+};
+/**
+* An auxiliary leg was removed before it finished connecting.
+*
+* Typed rather than a bare resolve so a caller awaiting the start can tell a
+* cancel apart from a share that actually came up — the public methods return
+* `void`, so the promise is the only signal they have.
+*/
+var AuxiliaryLegCancelledError = class extends Error {
+	constructor(leg) {
+		super(`The ${leg} leg was removed before it finished connecting`);
+		this.leg = leg;
+		this.name = "AuxiliaryLegCancelledError";
+	}
+};
+var MediaTrackError = class extends Error {
+	constructor(operation, kind, originalError) {
+		super(`Media track ${operation} failed for ${kind}`, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.operation = operation;
+		this.kind = kind;
+		this.originalError = originalError;
+		this.name = "MediaTrackError";
+	}
+};
+/** True when a `getUserMedia`/`getDisplayMedia` rejection is a permission denial. */
+function isMediaAccessDenial(originalError) {
+	return originalError instanceof Error && MEDIA_ACCESS_DENIAL_NAMES.includes(originalError.name);
+}
+/** True when a `getUserMedia` rejection means the hardware is already held exclusively. */
+function isMediaDeviceInUse(originalError) {
+	return originalError instanceof Error && MEDIA_DEVICE_IN_USE_NAMES.includes(originalError.name);
+}
+/**
+* Failure to acquire local media (camera, microphone, or screen capture)
+* via `getUserMedia`/`getDisplayMedia`.
+*
+* Non-fatal by default: screenshare and additional-device failures never
+* end the call, and main-connection failures degrade to receive-only when
+* possible. The wrapping site sets `fatal` to `true` only when the call
+* cannot continue (receive-only fallback disabled or no receive intent).
+*/
+var MediaAccessError = class extends Error {
+	constructor(operation, media, originalError, fatal = false) {
+		super(`Media access ${isMediaAccessDenial(originalError) ? "denied" : "failed"} for ${operation} (${media})`, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.operation = operation;
+		this.media = media;
+		this.originalError = originalError;
+		this.fatal = fatal;
+		this.name = "MediaAccessError";
+	}
+	/** True when the underlying failure is a permission denial (user or policy). */
+	get denied() {
+		return isMediaAccessDenial(this.originalError);
+	}
+};
+/**
+* Thrown by `startScreenShare()` when the call is already sharing a screen.
+*
+* A call carries at most one screen share. Accepting a second one would
+* overwrite the only reference the SDK holds to the first, leaving it
+* capturing and sending with no way to stop it — so the second request is
+* rejected and the live share is left untouched. Call `stopScreenShare()`
+* first to replace it.
+*/
+var ScreenShareAlreadyActiveError = class extends Error {
+	constructor(screenShareId, options) {
+		super(`A screen share is already active on this call (${screenShareId}). Call stopScreenShare() before starting another one.`, options);
+		this.screenShareId = screenShareId;
+		this.name = "ScreenShareAlreadyActiveError";
+	}
+};
+var DPoPInitError = class extends Error {
+	constructor(originalError, message = "Failed to initialize DPoP key pair") {
+		super(message, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.originalError = originalError;
+		this.name = "DPoPInitError";
+	}
+};
+/**
+* Error thrown when a recovery attempt fails.
+*
+* Carries the recovery action and attempt number for diagnostic purposes.
+*/
+var RecoveryError = class extends Error {
+	constructor(action, attempt, originalError) {
+		super(`Recovery failed: ${action} (attempt ${attempt})`, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.action = action;
+		this.attempt = attempt;
+		this.originalError = originalError;
+		this.name = "RecoveryError";
+	}
+};
+/**
+* Error thrown when getUserMedia fails with OverconstrainedError
+* and all fallback levels have been exhausted.
+*/
+var OverconstrainedFallbackError = class extends Error {
+	constructor(deviceKind, originalError) {
+		super(`All constraint fallback levels exhausted for ${deviceKind}`, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.deviceKind = deviceKind;
+		this.originalError = originalError;
+		this.name = "OverconstrainedFallbackError";
+	}
+};
+/**
+* Error thrown when the preflight connectivity test fails.
+*/
+var PreflightError = class extends Error {
+	constructor(phase, originalError) {
+		super(`Preflight test failed during ${phase}`, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.phase = phase;
+		this.originalError = originalError;
+		this.name = "PreflightError";
+	}
+};
+var DeviceTokenError = class extends Error {
+	constructor(message, originalError) {
+		super(message, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.originalError = originalError;
+		this.name = "DeviceTokenError";
+	}
+};
+var TokenRefreshError = class extends Error {
+	constructor(message, originalError) {
+		super(message, { cause: originalError instanceof Error ? originalError : void 0 });
+		this.originalError = originalError;
+		this.name = "TokenRefreshError";
+	}
+};
+
+//#endregion
+//#region src/utils/logger.ts
+const datetime = () => (/* @__PURE__ */ new Date()).toISOString();
+const defaultLogger = log.getLogger("signalwire");
+const originalFactory = defaultLogger.methodFactory;
+defaultLogger.methodFactory = (methodName, logLevel, loggerName) => {
+	const rawMethod = originalFactory(methodName, logLevel, loggerName);
+	return function(...args) {
+		const prefixed = [
+			datetime(),
+			"-",
+			...args
+		];
+		rawMethod.apply(void 0, prefixed);
+	};
+};
+const defaultLoggerLevel = defaultLogger.levels.WARN;
+defaultLogger.setLevel(defaultLoggerLevel);
+let userLogger = null;
+/** Replace the built-in logger with a custom implementation. Pass `null` to restore defaults. */
+const setLogger = (logger$1) => {
+	userLogger = logger$1;
+};
+let debugOptions = {};
+/** Configure debug options (e.g., `{ logWsTraffic: true }`). */
+const setDebugOptions = (options) => {
+	if (options == null) {
+		debugOptions = {};
+		return;
+	}
+	debugOptions = {
+		...debugOptions,
+		...options
+	};
+};
+/**
+* Set the log level for the built-in logger.
+* Has no effect when a custom logger is set via `setLogger()`.
+*/
+const setLogLevel = (level) => {
+	defaultLogger.setLevel(level);
+};
+const getLoggerInstance = () => {
+	return userLogger ?? defaultLogger;
+};
+const shouldStringify = (payload) => {
+	if (payload != null && typeof payload === "object" && "method" in payload) return payload.method !== "signalwire.ping";
+	return true;
+};
+const wsTraffic = (options) => {
+	const { logWsTraffic } = debugOptions;
+	if (!logWsTraffic) return;
+	const loggerInstance = getLoggerInstance();
+	let payload;
+	if ("raw" in options) try {
+		payload = JSON.parse(options.raw);
+	} catch {
+		loggerInstance.debug(`[WebSocket] ${options.type.toUpperCase()}: non-JSON message`);
+		return;
+	}
+	else ({payload} = options);
+	const msg = shouldStringify(payload) ? JSON.stringify(payload, null, 2) : payload;
+	loggerInstance.debug(`${options.type.toUpperCase()}: \n`, msg, "\n");
+};
+const getLogger = () => {
+	const logger$1 = getLoggerInstance();
+	return new Proxy(logger$1, { get(_target, prop, _receiver) {
+		if (prop === "wsTraffic") return wsTraffic;
+		const instance = getLoggerInstance();
+		const value = Reflect.get(instance, prop);
+		if (typeof value === "function") return value.bind(instance);
+		return value;
+	} });
+};
+
+//#endregion
+//#region src/operators/filterNull.ts
+/**
+* RxJS operator that filters out `null` and `undefined` values with type narrowing.
+*
+* @example
+* ```ts
+* source$.pipe(filterNull()).subscribe(value => {
+*   // value is guaranteed non-null
+* });
+* ```
+*/
+function filterNull() {
+	return filter((value) => value != null);
+}
+
+//#endregion
+//#region src/utils/getValueFrom.ts
+const getValueFrom = (obj, path, defaultValue) => {
+	const keys = path.split(".");
+	let result = obj;
+	for (const key of keys) if (result && typeof result === "object" && key in result) result = result[key];
+	else return defaultValue;
+	return result === void 0 ? defaultValue : result;
+};
+
+//#endregion
+//#region src/operators/filterEventAs.ts
+/**
+* RxJS operator that filters events based on a predicate and maps matching events.
+*
+* This operator combines filter and map operations:
+* 1. Only events that match the predicate are emitted
+* 2. Matching events are transformed using the map function
+*
+* @template TInput - The type of input events
+* @template TOutput - The type of output after mapping
+* @param predicate - Function to test each event. Returns true to include the event.
+* @param mapFn - Function to transform matching events
+* @returns An operator function that filters and maps events
+*
+* @example
+* ```typescript
+* interface CallEvent {
+*   type: 'call.started' | 'call.ended';
+*   id: string;
+*   timestamp: number;
+* }
+*
+* events$.pipe(
+*   isEvent(
+*     (event: CallEvent) => event.type === 'call.started',
+*     (event: CallEvent) => ({ id: event.id, timestamp: event.timestamp })
+*   )
+* ).subscribe(startEvent => {
+*   console.log('Call started:', startEvent);
+* });
+* ```
+*/
+function ifIsMap(predicate, mapFn) {
+	return pipe(filter$1(predicate), map$1(mapFn));
+}
+/**
+* Generic RxJS operator that filters events using a type guard and extracts a property.
+*
+* This is the generic version that works with any type, not just JSONRPCRequest.
+* Use this when you need to filter and extract properties from already-narrowed types.
+*
+* **Type inference**: The output type is automatically inferred from the input type and path!
+*
+* @template TInput - The type to narrow to (via type guard)
+* @template TPath - The dot-notation path to extract (inferred from parameter)
+* @param predicate - Type guard function to filter events
+* @param resultPath - Dot-notation path to extract (e.g., 'params', 'params.data')
+* @returns An operator function that filters and extracts
+*
+* @example
+* ```typescript
+* interface EventParams {
+*   event_type: string;
+*   data: { value: number };
+* }
+*
+* const isAuthEvent = (e: unknown): e is EventParams =>
+*   typeof e === 'object' && e !== null && 'event_type' in e;
+*
+* // Type of 'data' is automatically inferred as { value: number }
+* params$.pipe(
+*   filterAs(isAuthEvent, 'data')
+* ).subscribe(data => {
+*   console.log('Event data:', data.value); // TypeScript knows about .value!
+* });
+*
+* // Deeply nested properties are also inferred
+* params$.pipe(
+*   filterAs(isAuthEvent, 'data.value')
+* ).subscribe(value => {
+*   console.log(value); // Type is 'number'
+* });
+* ```
+*/
+function filterAs(predicate, resultPath) {
+	return pipe(ifIsMap(predicate, (event) => {
+		return getValueFrom(event, resultPath);
+	}), filter$1((value) => value !== void 0));
+}
+
+//#endregion
+//#region src/operators/throwOnRPCError.ts
+const logger = getLogger();
+/**
+* RxJS operator that throws a {@link JSONRPCError} when the RPC response contains an error.
+* Passes successful responses through unchanged.
+*/
+function throwOnRPCError() {
+	return map((response) => {
+		if (response.error) {
+			logger.error("[throwOnRPCError] RPC error response:", {
+				code: response.error.code,
+				message: response.error.message,
+				data: response.error.data
+			});
+			throw new JSONRPCError(response.error.code, response.error.message, response.error.data);
+		}
+		logger.debug("[throwOnRPCError] RPC successful response:", response);
+		return response;
+	});
+}
+
+//#endregion
+export { CREDENTIAL_REFRESH_BUFFER_MS as $, ICE_GATHERING_COMPLETE_TIMEOUT_MS as $t, RPCTimeoutError as A, DEFAULT_REFRESH_DEVICES_ON_VISIBLE as At, TransportConnectionError as B, DEFAULT_STATS_RTT_SPIKE_MULTIPLIER as Bt, JSONRPCError as C, DEFAULT_MAX_RECOVERY_ATTEMPTS as Ct, OverconstrainedFallbackError as D, DEFAULT_RECONNECT_DELAY_MIN_MS as Dt, MessageParseError as E, DEFAULT_RECONNECT_DELAY_MAX_MS as Et, SerializationError as F, DEFAULT_STATS_HISTORY_SIZE as Ft, VertoInviteHandlerError as G, DEVICE_STORAGE_KEY_AUDIO_INPUT as Gt, UnimplementedError as H, DEFAULT_STEREO_MAX_AVERAGE_BITRATE as Ht, StorageNotAvailableError as I, DEFAULT_STATS_JITTER_SPIKE_MULTIPLIER as It, WebSocketTimeoutError as J, DEVICE_TOKEN_DEFAULT_EXPIRE_IN as Jt, VertoPongError as K, DEVICE_STORAGE_KEY_AUDIO_OUTPUT as Kt, StorageReadError as L, DEFAULT_STATS_NO_PACKET_THRESHOLD_MS as Lt, RequestError as M, DEFAULT_REINVITE_MAX_ATTEMPTS as Mt, RequestTimeoutError as N, DEFAULT_REINVITE_TIMEOUT_MS as Nt, ParticipantNotReadyError as O, DEFAULT_RECOVERY_COOLDOWN_MS as Ot, ScreenShareAlreadyActiveError as P, DEFAULT_STATS_BASELINE_SAMPLES as Pt, CREDENTIAL_EXPIRY_SKEW_MS as Q, DEVICE_TOKEN_REFRESH_RETRY_BASE_MS as Qt, StorageWriteError as R, DEFAULT_STATS_PACKET_LOSS_THRESHOLD as Rt, InvalidParams as S, DEFAULT_KEYFRAME_MAX_BURST as St, MediaTrackError as T, DEFAULT_RECONNECT_CALLS_TIMEOUT_MS as Tt, ValidationError as U, DEFAULT_SYNC_DEVICES_TO_ACTIVE_CALLS as Ut, UnexpectedError as V, DEFAULT_STEREO_AUDIO as Vt, VertoAttachHandlerError as W, DEVICE_REFRESH_ENDPOINT as Wt, AUDIO_LEVEL_POLL_INTERVAL_MS as X, DEVICE_TOKEN_REFRESH_BUFFER_MS as Xt, isMediaDeviceInUse as Y, DEVICE_TOKEN_ENDPOINT as Yt, CREDENTIAL_ACTIVATE_TIMEOUT_MS as Z, DEVICE_TOKEN_REFRESH_MAX_RETRIES as Zt, DPoPInitError as _, DEFAULT_ICE_DISCONNECTED_GRACE_PERIOD_MS as _t, filterNull as a, RPC_ERROR_INVALID_PARAMS as an, DEFAULT_CALL_SIGNALING_TIMEOUT_MS as at, DeviceTokenError as b, DEFAULT_KEYFRAME_BURST_WINDOW_MS as bt, setLogLevel as c, VAD_HOLD_MS as cn, DEFAULT_DEGRADATION_BITRATE_THRESHOLD_KBPS as ct, AuxiliaryLegCancelledError as d, DEFAULT_DEVICE_POLLING_INTERVAL_MS as dt, INVITE_VERSION as en, CREDENTIAL_REFRESH_MAX_DELAY_MS as et, AuxiliaryLegTimeoutError as f, DEFAULT_ENABLE_AUTO_DEGRADATION as ft, ConversationError as g, DEFAULT_ICE_CANDIDATE_TIMEOUT_MS as gt, CollectionFetchError as h, DEFAULT_ENABLE_SERVER_HANGUP_INTERCEPTION as ht, getValueFrom as i, RPC_ERROR_AUTHENTICATION_FAILED as in, DEFAULT_AUX_LEG_CONNECT_TIMEOUT_MS as it, RecoveryError as j, DEFAULT_REINVITE_DEBOUNCE_TIME_MS as jt, PreflightError as k, DEFAULT_RECOVERY_DEBOUNCE_TIME_MS as kt, setLogger as l, VAD_THRESHOLD as ln, DEFAULT_DEGRADATION_RECOVERY_THRESHOLD_KBPS as lt, CallNotReadyError as m, DEFAULT_ENABLE_RELAY_FALLBACK as mt, filterAs as n, PEER_CONNECTION_RECOVERY_WAIT_MS as nn, CREDENTIAL_REFRESH_RETRY_BASE_MS as nt, getLogger as o, RPC_ERROR_REQUESTER_VALIDATION_FAILED as on, DEFAULT_CHECK_CONNECTION_ON_VISIBLE as ot, CallCreateError as p, DEFAULT_ENABLE_NETWORK_CHANGE_DETECTION as pt, WebSocketConnectionError as q, DEVICE_STORAGE_KEY_VIDEO_INPUT as qt, ifIsMap as r, PREFERENCES_STORAGE_KEY as rn, DEFAULT_AUTO_MUTE_VIDEO_ON_HIDDEN as rt, setDebugOptions as s, SAT_REFRESH_SCOPE as sn, DEFAULT_CONNECTION_TIMEOUT_MS as st, throwOnRPCError as t, PEER_CONNECTION_RECOVERY_POLL_MS as tn, CREDENTIAL_REFRESH_MAX_RETRIES as tt, AuthStateHandlerError as u, DEFAULT_DEVICE_DEBOUNCE_TIME_MS as ut, DependencyError as v, DEFAULT_ICE_GATHERING_TIMEOUT_MS as vt, MediaAccessError as w, DEFAULT_PERSIST_DEVICE_SELECTION as wt, InvalidCredentialsError as x, DEFAULT_KEYFRAME_COOLDOWN_MS as xt, DeserializationError as y, DEFAULT_ICE_RESTART_TIMEOUT_MS as yt, TokenRefreshError as z, DEFAULT_STATS_POLLING_INTERVAL_MS as zt };
+//# sourceMappingURL=operators-BVxi3KpN.mjs.map