@16x/webphone-sdk 3.0.1

package/dist/SharedWorkerProtocol-BqUafs8d.js

@@ -0,0 +1,73 @@
+import { t as e } from "./CCBarError-DSbPw2dA.js";
+import { t } from "./redact-DB3CMbsK.js";
+var n = [
+	"new",
+	"dialing",
+	"ringing",
+	"connecting",
+	"active",
+	"held",
+	"ended",
+	"failed"
+];
+function r(e) {
+	if (!c(e) || typeof e.id != "string" || typeof e.destination != "string" || typeof e.incoming != "boolean" || !s(e.state)) throw u("Invalid call snapshot");
+	return {
+		id: e.id,
+		...typeof e.from == "string" ? { from: e.from } : {},
+		destination: e.destination,
+		state: e.state,
+		incoming: e.incoming,
+		...typeof e.ownerTabId == "string" ? { ownerTabId: e.ownerTabId } : {}
+	};
+}
+function i(t) {
+	return t instanceof e ? {
+		code: t.code,
+		category: t.category,
+		retryable: t.retryable,
+		...t.requestId === void 0 ? {} : { requestId: t.requestId },
+		...t.callId === void 0 ? {} : { callId: t.callId },
+		message: l(t.message)
+	} : {
+		code: "SDK_INTERNAL_ERROR",
+		category: "internal",
+		retryable: !1,
+		message: l(t instanceof Error ? t.message : String(t))
+	};
+}
+function a(e) {
+	if (!c(e)) throw u("Invalid worker message");
+	if (e.version !== 1) throw u("Unsupported worker protocol version");
+	if (e.type === "attach" || e.type === "detach") return o(e), e;
+	if (e.type === "command") {
+		if (o(e), typeof e.command != "string" || e.payload !== void 0 && !c(e.payload)) throw u("Invalid worker command");
+		return e;
+	}
+	if (e.type === "response") {
+		if (typeof e.requestId != "string" || typeof e.ok != "boolean") throw u("Invalid worker response");
+		return e;
+	}
+	if (e.type === "event") {
+		if (typeof e.event != "string" || !("payload" in e)) throw u("Invalid worker event");
+		return e;
+	}
+	throw u("Unknown worker message type");
+}
+function o(e) {
+	if (typeof e.requestId != "string" || typeof e.tabId != "string") throw u("Worker request requires requestId and tabId");
+}
+function s(e) {
+	return typeof e == "string" && n.includes(e);
+}
+function c(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function l(e) {
+	return t(e).replace(/(?:authorization|token|ticket|credential|password|secret)/gi, "[REDACTED]");
+}
+function u(t) {
+	return new e("SDK_INTERNAL_ERROR", "internal", !1, { cause: t });
+}
+//#endregion
+export { r as n, i as r, a as t };

package/dist/SharedWorkerProtocol-CYN0AprP.cjs

@@ -0,0 +1 @@
+const e=require("./CCBarError-CIqJE8zK.cjs"),t=require("./redact-Bq26pObO.cjs");var n=[`new`,`dialing`,`ringing`,`connecting`,`active`,`held`,`ended`,`failed`];function r(e){if(!c(e)||typeof e.id!=`string`||typeof e.destination!=`string`||typeof e.incoming!=`boolean`||!s(e.state))throw u(`Invalid call snapshot`);return{id:e.id,...typeof e.from==`string`?{from:e.from}:{},destination:e.destination,state:e.state,incoming:e.incoming,...typeof e.ownerTabId==`string`?{ownerTabId:e.ownerTabId}:{}}}function i(t){return t instanceof e.t?{code:t.code,category:t.category,retryable:t.retryable,...t.requestId===void 0?{}:{requestId:t.requestId},...t.callId===void 0?{}:{callId:t.callId},message:l(t.message)}:{code:`SDK_INTERNAL_ERROR`,category:`internal`,retryable:!1,message:l(t instanceof Error?t.message:String(t))}}function a(e){if(!c(e))throw u(`Invalid worker message`);if(e.version!==1)throw u(`Unsupported worker protocol version`);if(e.type===`attach`||e.type===`detach`)return o(e),e;if(e.type===`command`){if(o(e),typeof e.command!=`string`||e.payload!==void 0&&!c(e.payload))throw u(`Invalid worker command`);return e}if(e.type===`response`){if(typeof e.requestId!=`string`||typeof e.ok!=`boolean`)throw u(`Invalid worker response`);return e}if(e.type===`event`){if(typeof e.event!=`string`||!(`payload`in e))throw u(`Invalid worker event`);return e}throw u(`Unknown worker message type`)}function o(e){if(typeof e.requestId!=`string`||typeof e.tabId!=`string`)throw u(`Worker request requires requestId and tabId`)}function s(e){return typeof e==`string`&&n.includes(e)}function c(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function l(e){return t.t(e).replace(/(?:authorization|token|ticket|credential|password|secret)/gi,`[REDACTED]`)}function u(t){return new e.t(`SDK_INTERNAL_ERROR`,`internal`,!1,{cause:t})}Object.defineProperty(exports,"n",{enumerable:!0,get:function(){return r}}),Object.defineProperty(exports,"r",{enumerable:!0,get:function(){return i}}),Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return a}});

package/dist/api/WebPhoneApi.d.ts

@@ -0,0 +1,28 @@
+import { TokenProvider } from '../auth/TokenManager.js';
+import { AgentStatusRequest, CapabilitiesResponse, CreateSessionRequest, RefreshSessionRequest, WebPhoneSession } from './contracts.js';
+type Fetcher = typeof fetch;
+export interface WebPhoneApiOptions {
+    baseUrl: string;
+    tokenProvider: TokenProvider;
+    fetcher?: Fetcher;
+    timeoutMs?: number;
+}
+export declare class WebPhoneApi {
+    private readonly tokenManager;
+    private readonly fetcher;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    constructor(options: WebPhoneApiOptions);
+    invalidateToken(): void;
+    createSession(request: CreateSessionRequest): Promise<WebPhoneSession>;
+    refreshSession(sessionId: string, request?: RefreshSessionRequest): Promise<WebPhoneSession>;
+    deleteSession(sessionId: string): Promise<void>;
+    setAgentStatus(request: AgentStatusRequest): Promise<void>;
+    getCapabilities(): Promise<CapabilitiesResponse>;
+    private request;
+    private requireData;
+    private parseResponse;
+    private toCCBarError;
+    private mapStatus;
+}
+export {};

package/dist/api/contracts.d.ts

@@ -0,0 +1,94 @@
+export interface WebPhoneEnvelope<T> {
+    code: string;
+    message?: string;
+    requestId?: string;
+    data?: T | null;
+}
+export interface CreateSessionRequest {
+    sdkVersion: string;
+    platform: 'web' | 'mobile_web';
+    locale?: string;
+    requestedCapabilities?: string[];
+}
+export interface AgentStatusRequest {
+    status: 'available' | 'offline' | 'break';
+    reason: string;
+}
+export interface IceServer {
+    urls: string[];
+    username?: string;
+    credential?: string;
+}
+export interface WebPhoneSession {
+    sessionId: string;
+    expiresAt: number;
+    agent: {
+        id: string;
+        externalUserId: string;
+        displayName: string;
+        extension: string;
+        status: string;
+    };
+    sip: {
+        uri: string;
+        registrar: string;
+        registerTicket: string;
+        registerExpires: number;
+        ticketExpiresIn: number;
+    };
+    transport: {
+        wssUrl: string;
+        ticket: string;
+        ticketExpiresIn: number;
+    };
+    iceServers: IceServer[];
+    policy: {
+        maxConcurrentCalls: number;
+        incomingEnabled: boolean;
+        mobileIncomingEnabled: boolean;
+        backgroundCallingSupported: boolean;
+    };
+    capabilities: string[];
+}
+export type CallSessionEvent = 'progress' | 'accepted' | 'confirmed' | 'ended' | 'failed' | 'hold' | 'unhold';
+export interface CallAnswerOptions {
+    readonly iceServers: readonly IceServer[];
+    readonly pcConfig: {
+        readonly iceServers: readonly IceServer[];
+    };
+    readonly mediaConstraints?: MediaConstraints;
+}
+/** Public, serializable subset of media constraints; native media objects stay inside adapters. */
+export interface MediaConstraints {
+    readonly audio?: boolean | Record<string, unknown>;
+    readonly video?: boolean | Record<string, unknown>;
+}
+export type CallDestinationType = 'external' | 'extension';
+export interface CallDialOptions {
+    readonly iceServers: readonly IceServer[];
+    readonly extraHeaders: readonly string[];
+    readonly type?: CallDestinationType;
+}
+export interface CallTransportSession {
+    readonly id: string;
+    readonly from?: string;
+    answer(options: CallAnswerOptions): void;
+    terminate(): void;
+    hold(): Promise<void>;
+    unhold(): Promise<void>;
+    mute(): void;
+    unmute(): void;
+    sendDtmf(tone: string): void;
+    refer(target: string): void;
+    on(event: CallSessionEvent, handler: (payload: unknown) => void): () => void;
+}
+export interface CallTransport {
+    dial(target: string, options?: CallDialOptions): CallTransportSession;
+}
+export interface RefreshSessionRequest {
+    refresh?: Array<'sip_register_ticket' | 'wss_ticket' | 'turn_credentials'>;
+}
+export interface CapabilitiesResponse {
+    capabilities: string[];
+}
+export declare function parseSessionResponse(response: WebPhoneEnvelope<WebPhoneSession>): WebPhoneSession;

package/dist/auth/TokenManager.d.ts

@@ -0,0 +1,22 @@
+export interface TokenRequest {
+    readonly extension?: string;
+}
+export type TokenProviderResult = string | {
+    accessToken: string;
+    expiresAt?: number;
+    extension?: string;
+};
+export type TokenProvider = (request?: TokenRequest) => Promise<TokenProviderResult>;
+export declare class TokenManager {
+    private readonly tokenProvider;
+    private cachedToken?;
+    private cachedRequestKey;
+    private refreshing?;
+    private generation;
+    constructor(tokenProvider: TokenProvider);
+    getValidToken(request?: TokenRequest): Promise<string>;
+    invalidate(): void;
+    private needsRefresh;
+    private refresh;
+    private clearRefresh;
+}

package/dist/core/CCBarCall.d.ts

@@ -0,0 +1,94 @@
+import { CallAnswerOptions, CallTransportSession } from '../api/contracts.js';
+import { CCBarError } from '../errors/CCBarError.js';
+import { CallState, CallStateEvent } from '../types.js';
+export type CallPlatform = 'web' | 'mobile-web';
+export type CallCapability = 'outbound' | 'inbound' | 'mute' | 'dtmf' | 'hold' | 'blind_transfer';
+export interface BlindTransferOptions {
+    readonly type: 'blind';
+    readonly target: string;
+}
+export type TransferOptions = BlindTransferOptions;
+export interface RejectOptions {
+    readonly reason?: string;
+}
+export interface CCBarCallOptions {
+    readonly id: string;
+    readonly destination: string;
+    readonly platform: CallPlatform;
+    readonly incoming?: boolean;
+    readonly capabilities?: ReadonlySet<string>;
+    readonly session: CallTransportSession;
+    readonly onStateChanged?: (event: CallStateEvent, payload?: unknown) => void;
+    readonly onError?: (error: CCBarError) => void;
+    readonly onDisposed?: () => void;
+}
+export declare class CCBarCall {
+    private readonly options;
+    private currentState;
+    private readonly sessionUnsubscribers;
+    private readonly capabilities;
+    private disposed;
+    private pendingOperation?;
+    private incomingOperation?;
+    private ownerTabId?;
+    private ownerLost;
+    readonly id: string;
+    readonly destination: string;
+    readonly platform: CallPlatform;
+    constructor(options: CCBarCallOptions);
+    get state(): CallState;
+    /** @internal Diagnostics exposes counts only; transport objects remain private. */
+    getResourceCounts(): {
+        readonly timers: number;
+        readonly listeners: number;
+    };
+    mute(tabId?: string): Promise<void>;
+    unmute(tabId?: string): Promise<void>;
+    answer(options: CallAnswerOptions, tabId?: string): Promise<void>;
+    reject(options?: RejectOptions, tabId?: string): Promise<void>;
+    hold(tabId?: string): Promise<void>;
+    resume(tabId?: string): Promise<void>;
+    sendDtmf(tone: string, tabId?: string): Promise<void>;
+    transfer(options: TransferOptions, tabId?: string): Promise<void>;
+    hangup(tabId?: string): Promise<void>;
+    beginOutbound(): void;
+    beginIncoming(): void;
+    /** @internal SharedWorker ownership is coordinated by CallManager. */
+    setOwnerTabId(tabId: string): void;
+    /** @internal SharedWorker ownership is coordinated by CallManager. */
+    clearOwnerTabId(options?: {
+        readonly lost?: boolean;
+    }): void;
+    getOwnerTabId(): string | undefined;
+    /** @internal CallManager validates tab-scoped active-call operations. */
+    assertOwnerForManager(tabId?: string): void;
+    /** @internal Only unconnected calls may be reclaimed after a port disconnect. */
+    canBeReclaimed(): boolean;
+    dispose(): void;
+    private handleSessionEvent;
+    private transitionToActive;
+    private transitionIfAllowed;
+    private transitionIfStillRinging;
+    private transitionTo;
+    private startPendingOperation;
+    private resolvePendingOperation;
+    private rejectPendingOperation;
+    private timeoutPendingOperation;
+    private clearPendingTimer;
+    private reportIllegalTransition;
+    private reportOperationError;
+    private finishFailedIncomingOperation;
+    private cleanupSessionListeners;
+    private assertState;
+    private assertMediaControlAllowed;
+    private assertHoldCapability;
+    private assertTransferCapability;
+    private assertIncomingCall;
+    private assertIncomingOperationAvailable;
+    private assertCapability;
+    private invoke;
+    private assertNotDisposed;
+    private assertOwner;
+    private capabilityError;
+    private operationError;
+}

package/dist/core/CCBarClient.d.ts

@@ -0,0 +1,113 @@
+import { MediaConstraints, WebPhoneSession } from '../api/contracts.js';
+import { TokenProvider } from '../auth/TokenManager.js';
+import { CCBarEvents, MediaManager as PublicMedia, SharedWorkerOptions } from '../types.js';
+import { DialOptions } from './CallManager.js';
+import { CCBarCall, CallPlatform } from './CCBarCall.js';
+import { DiagnosticsOptions, DiagnosticsReport } from '../diagnostics/Diagnostics.js';
+export interface CCBarClientOptions {
+    readonly baseUrl?: string;
+    readonly tokenProvider: TokenProvider;
+    readonly locale?: string;
+    readonly platform?: CallPlatform;
+    readonly requestedCapabilities?: readonly string[];
+    readonly maxConcurrentCalls?: number;
+    readonly autoHoldPreviousCall?: boolean;
+    /** SharedWorker is attempted by the multi-tab integration when enabled is omitted or 'auto'. */
+    readonly sharedWorker?: SharedWorkerOptions;
+    /** @internal Test/integration dependency injection; not required by consumers. */
+    readonly api?: unknown;
+    /** @internal Test/integration dependency injection; not required by consumers. */
+    readonly sip?: unknown;
+}
+export declare class CCBarClient {
+    readonly media: PublicMedia;
+    private readonly options;
+    private readonly api;
+    private readonly suppliedSip?;
+    private sip?;
+    private readonly events;
+    private readonly mediaBridge;
+    private readonly reconnect;
+    private readonly diagnostics;
+    private callManager?;
+    private session?;
+    private state;
+    private initialized;
+    private disposed;
+    private intentionalDisconnect;
+    private deferredRebuild;
+    private detectedPlatform?;
+    private support?;
+    private acceptingEvents;
+    private connectOperation?;
+    private disconnectOperation?;
+    private refreshOperation?;
+    private disposeOperation?;
+    private refreshTimer?;
+    private lifecycleGeneration;
+    private managerUnsubscribers;
+    private sipUnsubscribe?;
+    private networkUnsubscribers;
+    private readonly sessionDeleteOperations;
+    private readonly deletedSessions;
+    private readonly ownedSessionIds;
+    private readonly terminalReleaseOperations;
+    private tokenRequest;
+    constructor(options: CCBarClientOptions);
+    static checkSupport(): Promise<import('../types.js').PlatformSupport>;
+    initialize(): Promise<void>;
+    connect(options?: {
+        readonly extension?: string;
+    }): Promise<void>;
+    disconnect(): Promise<void>;
+    dispose(): Promise<void>;
+    recover(): Promise<void>;
+    dial(options: DialOptions): Promise<CCBarCall>;
+    answer(callId: string, mediaConstraints?: MediaConstraints): Promise<void>;
+    setActiveCall(callId: string): Promise<void>;
+    getCalls(): readonly CCBarCall[];
+    getActiveCall(): CCBarCall | undefined;
+    getAgent(): WebPhoneSession['agent'] | undefined;
+    getDiagnostics(options?: DiagnosticsOptions): Promise<DiagnosticsReport>;
+    setAgentStatus(status: 'available' | 'offline' | 'break'): Promise<void>;
+    on<K extends keyof CCBarEvents>(event: K, handler: (payload: CCBarEvents[K]) => void): () => void;
+    off<K extends keyof CCBarEvents>(event: K, handler: (payload: CCBarEvents[K]) => void): void;
+    private performConnect;
+    private performDisconnect;
+    private createCallManager;
+    private rollbackConnect;
+    private performDispose;
+    private awaitMediaReleaseBarriers;
+    private detachSipListener;
+    private detachManagerListeners;
+    private bindManagerEvents;
+    private handleCallCreated;
+    private handleCallStateChanged;
+    private handleCallTerminal;
+    private startTerminalRelease;
+    private startDeferredRecovery;
+    private refreshAndRebuild;
+    private performRefreshAndRebuild;
+    private handleRefreshFailure;
+    private scheduleRefresh;
+    private recoverConnection;
+    private getSip;
+    private attachSipListener;
+    private attachNetworkListeners;
+    private detachNetworkListeners;
+    private getActiveMediaContext;
+    private hasNonTerminalCalls;
+    private clearRefreshTimer;
+    private createDiagnosticsSnapshot;
+    private getDiagnosticsResourceCounts;
+    private readMicrophonePermission;
+    private deleteSession;
+    private deleteOwnedSessions;
+    private resolvePlatform;
+    private setConnectionState;
+    private assertConnected;
+    private assertGeneration;
+    private isCurrentGeneration;
+    private assertNotDisposed;
+    private disposedError;
+}

package/dist/core/CallManager.d.ts

@@ -0,0 +1,93 @@
+import { CallDestinationType, CallTransport, CallTransportSession, MediaConstraints, WebPhoneSession } from '../api/contracts.js';
+import { CCBarEvents } from '../types.js';
+import { CCBarCall, CallPlatform, RejectOptions } from './CCBarCall.js';
+export interface DialOptions {
+    readonly destination: string;
+    readonly type?: CallDestinationType;
+}
+export type CallManagerEvents = Pick<CCBarEvents, 'call.created' | 'call.incoming' | 'call.stateChanged' | 'call.activeChanged' | 'call.ownershipChanged' | 'call.ended' | 'call.failed' | 'error'>;
+type IncomingCallTransport = CallTransport & {
+    onIncoming(handler: (session: CallTransportSession) => void): () => void;
+};
+export interface CallManagerOptions {
+    readonly sip: IncomingCallTransport;
+    readonly platform: CallPlatform;
+    readonly session?: WebPhoneSession;
+    readonly maxConcurrentCalls?: number;
+    readonly autoHoldPreviousCall?: boolean;
+    /** @internal Client lifecycle hook for production media ownership. */
+    readonly onCallCreated?: (callId: string, session: CallTransportSession) => void;
+    /** @internal Called whenever a call state changes so adapters can become ready. */
+    readonly onCallStateChanged?: (callId: string, session: CallTransportSession) => void;
+    /** @internal Called exactly once for each call terminal/dispose path. */
+    readonly onCallTerminal?: (callId: string) => void | Promise<void>;
+}
+export declare class CallManager {
+    private readonly events;
+    private readonly calls;
+    private readonly options;
+    private readonly incomingUnsubscribe;
+    private activeCallId;
+    private incomingSessionSnapshot?;
+    private readonly callSessions;
+    private readonly callOwners;
+    private readonly ownerLostCalls;
+    private pendingDialCount;
+    private readonly pendingDestinations;
+    private activeOperationPromise;
+    private operationGeneration;
+    private automaticActiveTransition?;
+    private disposed;
+    private readonly terminalNotified;
+    private readonly terminalOperations;
+    private disposeOperation?;
+    constructor(options: CallManagerOptions);
+    on<K extends keyof CallManagerEvents>(event: K, handler: (payload: CallManagerEvents[K]) => void): () => void;
+    dial(options: DialOptions, session: WebPhoneSession): Promise<CCBarCall>;
+    answer(callId: string, session: WebPhoneSession, mediaConstraints?: MediaConstraints, tabId?: string): Promise<void>;
+    reject(callId: string, options?: RejectOptions, tabId?: string): Promise<void>;
+    getCalls(): readonly CCBarCall[];
+    hasNonTerminalCalls(): boolean;
+    /** @internal Diagnostics exposes counts only; call transports remain private. */
+    getResourceCounts(): {
+        readonly timers: number;
+        readonly listeners: number;
+    };
+    getActiveCall(): CCBarCall | undefined;
+    setActiveCall(callId: string, tabId?: string): Promise<void>;
+    claimCall(callId: string, tabId: string): Promise<void>;
+    releaseCall(callId: string, tabId: string): Promise<void>;
+    getCallOwner(callId: string): string | undefined;
+    /** @internal Called when a SharedWorker MessagePort is detached. */
+    releaseOwnedCalls(tabId: string): void;
+    dispose(options?: {
+        readonly terminateCalls?: boolean;
+    }): Promise<void>;
+    updateSession(session: WebPhoneSession): void;
+    private switchActiveCall;
+    private handleStateChanged;
+    private switchAutomaticActiveCall;
+    private restoreAutomaticActiveCall;
+    private handleDisposed;
+    private commitActive;
+    private handleIncoming;
+    private terminateUnsupportedIncoming;
+    private holdActiveCallForNewCall;
+    private enqueueActiveOperation;
+    private isManagedCall;
+    private isCurrentGeneration;
+    private assertGeneration;
+    private effectiveCapabilities;
+    private requireCapability;
+    private requireCall;
+    private emitOwnershipChanged;
+    private notifyCallTerminal;
+    private assertNotDisposed;
+    private callOperationError;
+    private capabilityError;
+    private compensationError;
+    private callLimit;
+    private dialOptions;
+    private dialError;
+}
+export {};

package/dist/core/callId.d.ts

@@ -0,0 +1 @@
+export declare function createCallId(): string;

package/dist/core/mediaBridge.d.ts

@@ -0,0 +1,17 @@
+import { CallState, MediaManager as PublicMediaManager } from '../types.js';
+import { DiagnosticsResourceCounts } from '../diagnostics/Diagnostics.js';
+export interface ClientMediaBridge {
+    readonly publicMedia: PublicMediaManager;
+    registerCall(callId: string, session: unknown): void;
+    setCallOwnership(callId: string, state: 'owned' | 'released' | 'owner-lost'): Promise<void>;
+    contextFor(callId: string, state: CallState, capabilities?: ReadonlySet<string>): unknown;
+    releaseCall(callId: string): Promise<void>;
+    releaseAll(): Promise<void>;
+    dispose(): Promise<void>;
+    getResourceCounts(): Pick<DiagnosticsResourceCounts, 'listeners' | 'tracks' | 'peerConnections' | 'audioElements'>;
+}
+export interface ClientMediaBridgeOptions {
+    /** @internal SharedWorker mode delays native media binding until this tab owns the call. */
+    readonly ownershipRequired?: boolean;
+}
+export declare function createClientMediaBridge(getActiveContext: () => unknown, options?: ClientMediaBridgeOptions): ClientMediaBridge;