@callembed/sdk 0.0.0-stage → 0.1.0

package/dist/core/client.js

@@ -0,0 +1,157 @@
+import { CallSessionController } from "./call.js";
+import { CallEmbedError } from "./errors.js";
+import { isTerminal } from "./state-machine.js";
+/**
+ * Default locale when `options.locale` is omitted (X10).
+ * `navigator.language` starting with `zh` → `zh-TW`; otherwise `en`.
+ */
+export function defaultLocaleFromNavigator(language = typeof navigator !== "undefined"
+    ? navigator.language
+    : undefined) {
+    if (language && language.toLowerCase().startsWith("zh"))
+        return "zh-TW";
+    return "en";
+}
+/**
+ * Module-level SDK state.
+ *
+ * Reason: the embed script is a singleton per page (one publishable key /
+ * one active caller session). Keeping config here avoids forcing every
+ * integrator to thread a client instance through button handlers.
+ */
+let runtime = null;
+let active = null;
+/**
+ * Optional UI binder registered by `@callembed/sdk/ui` via
+ * {@link registerUiHooksFactory}. Core never imports the UI package.
+ * Loading `@callembed/sdk/ui` alone does **not** register this — call
+ * `enableDefaultUi()` or `mountButton()`.
+ */
+let uiHooksFactory = null;
+/**
+ * @internal Allow the UI package to attach panel hooks without core importing UI.
+ */
+export function registerUiHooksFactory(factory) {
+    uiHooksFactory = factory;
+}
+function requireConfig() {
+    if (!runtime) {
+        throw new CallEmbedError("not_initialized", "Call CallEmbed.init({ publishableKey, apiBaseUrl }) first.");
+    }
+    return runtime;
+}
+function assertPublishableKey(key) {
+    const trimmed = key.trim();
+    if (!trimmed) {
+        throw new CallEmbedError("invalid_config", "publishableKey is required.");
+    }
+    if (/^(sk_|ak_)/i.test(trimmed) || /service_role/i.test(trimmed)) {
+        throw new CallEmbedError("invalid_config", "Only publishable keys (pk_…) may be used in the browser SDK.");
+    }
+}
+function bindStartHandlers(call, handlers) {
+    if (!handlers)
+        return;
+    Object.keys(handlers).forEach((name) => {
+        const handler = handlers[name];
+        if (handler) {
+            call.on(name, handler);
+        }
+    });
+}
+/**
+ * Headless CallEmbed client.
+ *
+ * @example
+ * ```ts
+ * CallEmbed.init({ publishableKey: "pk_…", apiBaseUrl: "" });
+ * const call = await CallEmbed.startCall({
+ *   queue: "onboarding",
+ *   hidePanel: true,
+ *   on: {
+ *     statusChange: ({ status }) => { … },
+ *     ringing: () => { … },
+ *     error: ({ code }) => { … },
+ *   },
+ * });
+ * ```
+ */
+export const CallEmbed = {
+    /**
+     * Configure the SDK for this page.
+     * @throws {@link CallEmbedError} `invalid_config` when keys/URL are missing or unsafe.
+     */
+    init(options) {
+        assertPublishableKey(options.publishableKey);
+        if (options.apiBaseUrl === undefined || options.apiBaseUrl === null) {
+            throw new CallEmbedError("invalid_config", 'apiBaseUrl is required (use "" for same-origin).');
+        }
+        runtime = {
+            publishableKey: options.publishableKey.trim(),
+            apiBaseUrl: String(options.apiBaseUrl).trim().replace(/\/$/, ""),
+            // X10: zh* navigator → zh-TW; otherwise en (override via options.locale).
+            locale: options.locale ?? defaultLocaleFromNavigator(),
+            copyOverrides: options.copy ?? {},
+            branding: options.branding !== false,
+            debug: options.debug === true,
+        };
+    },
+    /**
+     * Start a call and resolve once the room is connected (`ringing`), or reject
+     * on startup failure. Register `options.on` to observe `connecting` / `ringing`
+     * / startup `error` during the await.
+     *
+     * Panel UI appears only when `enableDefaultUi()` or `mountButton()` was used
+     * and `hidePanel` is not true.
+     *
+     * @returns The active call (status is typically `ringing` on success).
+     */
+    async startCall(options) {
+        const cfg = requireConfig();
+        if (!options.queue?.trim()) {
+            throw new CallEmbedError("invalid_queue", "queue is required.");
+        }
+        if (options.queue.trim().length > 64) {
+            throw new CallEmbedError("invalid_queue", "queue must be at most 64 characters.");
+        }
+        if (options.displayName !== undefined && typeof options.displayName !== "string") {
+            throw new CallEmbedError("invalid_display_name", "displayName must be a string when provided.");
+        }
+        if (active && !isTerminal(active.status)) {
+            throw new CallEmbedError("call_in_progress", "A call is already in progress. Hang up before starting another.");
+        }
+        const call = new CallSessionController(cfg);
+        bindStartHandlers(call, options.on);
+        if (uiHooksFactory) {
+            call.setUiHooks(uiHooksFactory(call, options));
+        }
+        active = call;
+        try {
+            await call.start(options);
+            return call;
+        }
+        catch (err) {
+            if (active === call && call.status === "error") {
+                // Retain briefly so optional UI can show the error state.
+            }
+            else if (active === call) {
+                active = null;
+            }
+            throw err;
+        }
+    },
+    /** Currently active call, or `null`. */
+    getActiveCall() {
+        return active;
+    },
+    /** @internal Test helper — reset singleton state. */
+    _resetForTests() {
+        runtime = null;
+        active = null;
+        uiHooksFactory = null;
+    },
+    /** @internal Expose runtime for the UI package (locale / copy / debug). */
+    _getRuntime() {
+        return runtime;
+    },
+};

package/dist/core/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Error codes and {@link CallEmbedError} for the public SDK surface.
+ */
+/** Well-known SDK / API error codes (English, machine-readable). */
+export type ErrorCode = "not_initialized" | "invalid_config" | "invalid_queue" | "invalid_metadata" | "invalid_display_name" | "invalid_container" | "invalid_selector" | "call_in_progress" | "mic_permission_denied" | "no_microphone" | "connection_failed" | "call_failed" | "no_agent_online" | "no_answer" | "agent_busy" | "call_already_answered" | "invalid_end_token" | "quota_exceeded" | "origin_not_allowed" | "invalid_publishable_key" | "rate_limited" | "livekit_not_configured" | "unknown_queue";
+/**
+ * Thrown by CallEmbed SDK methods and surfaced via the `error` event.
+ */
+export declare class CallEmbedError extends Error {
+    readonly code: string;
+    readonly status: number;
+    /**
+     * @param code - Machine-readable English error code.
+     * @param message - Human-readable message (may be localized by the API).
+     * @param status - Optional HTTP status when the error came from the API.
+     */
+    constructor(code: string, message: string, status?: number);
+}
+/**
+ * Map browser / LiveKit failure reasons onto stable SDK error codes.
+ */
+export declare function mapMediaError(err: unknown): CallEmbedError;

package/dist/core/errors.js

@@ -0,0 +1,41 @@
+/**
+ * Error codes and {@link CallEmbedError} for the public SDK surface.
+ */
+/**
+ * Thrown by CallEmbed SDK methods and surfaced via the `error` event.
+ */
+export class CallEmbedError extends Error {
+    code;
+    status;
+    /**
+     * @param code - Machine-readable English error code.
+     * @param message - Human-readable message (may be localized by the API).
+     * @param status - Optional HTTP status when the error came from the API.
+     */
+    constructor(code, message, status = 400) {
+        super(message);
+        this.name = "CallEmbedError";
+        this.code = code;
+        this.status = status;
+    }
+}
+/**
+ * Map browser / LiveKit failure reasons onto stable SDK error codes.
+ */
+export function mapMediaError(err) {
+    const name = err && typeof err === "object" && "name" in err
+        ? String(err.name)
+        : "";
+    const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Media error";
+    if (name === "NotAllowedError" ||
+        name === "PermissionDeniedError" ||
+        /permission|denied|NotAllowed/i.test(message)) {
+        return new CallEmbedError("mic_permission_denied", "Microphone permission was denied.");
+    }
+    if (name === "NotFoundError" ||
+        name === "DevicesNotFoundError" ||
+        /Requested device not found|no microphone|NotFound/i.test(message)) {
+        return new CallEmbedError("no_microphone", "No microphone device was found.");
+    }
+    return new CallEmbedError("connection_failed", message || "Connection failed.");
+}

package/dist/core/events.d.ts

@@ -0,0 +1,20 @@
+import type { CallEventHandler, CallEventMap, CallEventName } from "./types.js";
+/**
+ * Tiny typed pub/sub used by {@link ActiveCall}.
+ * Handlers run synchronously; exceptions are swallowed so one bad listener
+ * cannot break the call lifecycle.
+ */
+export declare class TypedEmitter {
+    private readonly listeners;
+    /**
+     * Register a handler for `event`.
+     * @returns Unsubscribe function.
+     */
+    on<E extends CallEventName>(event: E, handler: CallEventHandler<E>): () => void;
+    /** Remove a handler previously registered with {@link on}. */
+    off<E extends CallEventName>(event: E, handler: CallEventHandler<E>): void;
+    /** Emit `event` with a typed payload. */
+    emit<E extends CallEventName>(event: E, payload: CallEventMap[E]): void;
+    /** Drop all listeners (call teardown). */
+    clear(): void;
+}

package/dist/core/events.js

@@ -0,0 +1,43 @@
+/**
+ * Tiny typed pub/sub used by {@link ActiveCall}.
+ * Handlers run synchronously; exceptions are swallowed so one bad listener
+ * cannot break the call lifecycle.
+ */
+export class TypedEmitter {
+    listeners = new Map();
+    /**
+     * Register a handler for `event`.
+     * @returns Unsubscribe function.
+     */
+    on(event, handler) {
+        let set = this.listeners.get(event);
+        if (!set) {
+            set = new Set();
+            this.listeners.set(event, set);
+        }
+        set.add(handler);
+        return () => this.off(event, handler);
+    }
+    /** Remove a handler previously registered with {@link on}. */
+    off(event, handler) {
+        this.listeners.get(event)?.delete(handler);
+    }
+    /** Emit `event` with a typed payload. */
+    emit(event, payload) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const handler of [...set]) {
+            try {
+                handler(payload);
+            }
+            catch {
+                // Ignore listener failures
+            }
+        }
+    }
+    /** Drop all listeners (call teardown). */
+    clear() {
+        this.listeners.clear();
+    }
+}

package/dist/core/metadata.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Max UTF-8 / JSON size for `metadata` sent to `POST /v1/calls`.
+ * Backend stores metadata as JSON text without a tighter documented cap;
+ * the SDK enforces this shared client-side limit before the request leaves
+ * the browser.
+ */
+export declare const METADATA_MAX_BYTES = 4096;
+/**
+ * Validate `metadata` is a plain object within {@link METADATA_MAX_BYTES}.
+ *
+ * @throws {@link CallEmbedError} with code `invalid_metadata`
+ */
+export declare function assertValidMetadata(metadata: Record<string, unknown> | undefined): void;

package/dist/core/metadata.js

@@ -0,0 +1,38 @@
+import { CallEmbedError } from "./errors.js";
+/**
+ * Max UTF-8 / JSON size for `metadata` sent to `POST /v1/calls`.
+ * Backend stores metadata as JSON text without a tighter documented cap;
+ * the SDK enforces this shared client-side limit before the request leaves
+ * the browser.
+ */
+export const METADATA_MAX_BYTES = 4096;
+/**
+ * Validate `metadata` is a plain object within {@link METADATA_MAX_BYTES}.
+ *
+ * @throws {@link CallEmbedError} with code `invalid_metadata`
+ */
+export function assertValidMetadata(metadata) {
+    if (metadata === undefined)
+        return;
+    if (metadata === null ||
+        typeof metadata !== "object" ||
+        Array.isArray(metadata)) {
+        throw new CallEmbedError("invalid_metadata", "metadata must be a plain JSON object.");
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(metadata);
+    }
+    catch {
+        throw new CallEmbedError("invalid_metadata", "metadata must be JSON-serializable.");
+    }
+    if (serialized === undefined) {
+        throw new CallEmbedError("invalid_metadata", "metadata must be a plain JSON object.");
+    }
+    const bytes = typeof TextEncoder !== "undefined"
+        ? new TextEncoder().encode(serialized).length
+        : serialized.length;
+    if (bytes > METADATA_MAX_BYTES) {
+        throw new CallEmbedError("invalid_metadata", `metadata exceeds ${METADATA_MAX_BYTES} bytes.`);
+    }
+}

package/dist/core/ring-watch.d.ts

@@ -0,0 +1,20 @@
+import { CallEmbedError } from "./errors.js";
+import type { RuntimeConfig } from "./types.js";
+export interface RingWatchHost {
+    cfg: RuntimeConfig;
+    getCallId: () => string;
+    getEndToken: () => string | null;
+    isRinging: () => boolean;
+    isHangUpStarted: () => boolean;
+    onNoAnswer: () => Promise<void>;
+}
+export declare class RingWatch {
+    private readonly host;
+    private timer;
+    constructor(host: RingWatchHost);
+    start(intervalMs?: number): void;
+    stop(): void;
+    checkAfterDisconnect(): Promise<boolean>;
+    private tick;
+}
+export declare function noAnswerError(): CallEmbedError;

package/dist/core/ring-watch.js

@@ -0,0 +1,46 @@
+/**
+ * While status is `ringing`, poll server status so ring-timeout `no_answer`
+ * surfaces as `error(no_answer)` even before LiveKit disconnects.
+ */
+import { apiGetCallStatus } from "./api.js";
+import { CallEmbedError } from "./errors.js";
+export class RingWatch {
+    host;
+    timer = null;
+    constructor(host) {
+        this.host = host;
+    }
+    start(intervalMs = 3_000) {
+        this.stop();
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, intervalMs);
+    }
+    stop() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async checkAfterDisconnect() {
+        if (!this.host.isRinging() || this.host.isHangUpStarted())
+            return false;
+        const info = await apiGetCallStatus(this.host.cfg, this.host.getCallId(), this.host.getEndToken());
+        if (info?.status === "failed" && info.failReason === "no_answer") {
+            await this.host.onNoAnswer();
+            return true;
+        }
+        return false;
+    }
+    async tick() {
+        if (!this.host.isRinging() || this.host.isHangUpStarted())
+            return;
+        const info = await apiGetCallStatus(this.host.cfg, this.host.getCallId(), this.host.getEndToken());
+        if (info?.status === "failed" && info.failReason === "no_answer") {
+            await this.host.onNoAnswer();
+        }
+    }
+}
+export function noAnswerError() {
+    return new CallEmbedError("no_answer", "沒有客服接聽，通話已結束。", 409);
+}

package/dist/core/room-events.d.ts

@@ -0,0 +1,13 @@
+import { Room, type RemoteParticipant, type RemoteTrack } from "livekit-client";
+import type { RemoteAudioHost } from "./audio.js";
+/** Callbacks used by {@link bindRoomEvents}. */
+export interface RoomEventHandlers {
+    onAgentAudio: (participant: RemoteParticipant, track: RemoteTrack) => void;
+    onAgentPresent: (participant: RemoteParticipant) => void;
+    onAgentLeft: () => void;
+    onDisconnected: () => void;
+}
+/**
+ * Wire LiveKit room events to call-lifecycle callbacks.
+ */
+export declare function bindRoomEvents(room: Room, audio: RemoteAudioHost, handlers: RoomEventHandlers): void;

package/dist/core/room-events.js

@@ -0,0 +1,29 @@
+import { RoomEvent, Track, } from "livekit-client";
+import { isAgentParticipant } from "./agent.js";
+/**
+ * Wire LiveKit room events to call-lifecycle callbacks.
+ */
+export function bindRoomEvents(room, audio, handlers) {
+    room.on(RoomEvent.TrackSubscribed, (track, _pub, participant) => {
+        if (track.kind === Track.Kind.Audio) {
+            audio.attach(track, participant.identity);
+            if (isAgentParticipant(participant)) {
+                handlers.onAgentAudio(participant, track);
+            }
+        }
+    });
+    room.on(RoomEvent.TrackUnsubscribed, (track) => {
+        audio.detachTrack(track);
+    });
+    room.on(RoomEvent.ParticipantConnected, (participant) => {
+        handlers.onAgentPresent(participant);
+    });
+    room.on(RoomEvent.ParticipantDisconnected, (participant) => {
+        if (isAgentParticipant(participant)) {
+            handlers.onAgentLeft();
+        }
+    });
+    room.on(RoomEvent.Disconnected, () => {
+        handlers.onDisconnected();
+    });
+}

package/dist/core/state-machine.d.ts

@@ -0,0 +1,11 @@
+import type { CallStatus } from "./types.js";
+/**
+ * Transition `from` → `to`, or throw if illegal.
+ *
+ * @returns The new status (`to`).
+ */
+export declare function transition(from: CallStatus, to: CallStatus): CallStatus;
+/** Whether `status` is a terminal state. */
+export declare function isTerminal(status: CallStatus): boolean;
+/** Exported for unit tests. */
+export declare const LEGAL_TRANSITIONS: Record<CallStatus, ReadonlySet<CallStatus>>;

package/dist/core/state-machine.js

@@ -0,0 +1,44 @@
+import { CallEmbedError } from "./errors.js";
+/**
+ * Legal status transitions for a single call.
+ *
+ * ```
+ * idle → connecting → ringing → answered → ended
+ *                 ↘        ↘          ↘
+ *                  error    error      error
+ * connecting | ringing | answered → ended (hang-up / disconnect)
+ * ```
+ *
+ * Error codes that map to the `error` status (not separate statuses):
+ * - `no_answer` — server ring timeout while `ringing` → `error`
+ * - `agent_busy` — agent answer rejected (Inbox); callers typically never see this
+ * - `no_agent_online` / `call_failed` / media failures → `error` from `connecting`/`ringing`
+ */
+const ALLOWED = {
+    idle: new Set(["connecting"]),
+    connecting: new Set(["ringing", "error", "ended"]),
+    ringing: new Set(["answered", "error", "ended"]),
+    answered: new Set(["ended", "error"]),
+    ended: new Set(),
+    error: new Set(),
+};
+/**
+ * Transition `from` → `to`, or throw if illegal.
+ *
+ * @returns The new status (`to`).
+ */
+export function transition(from, to) {
+    if (from === to)
+        return to;
+    const allowed = ALLOWED[from];
+    if (!allowed.has(to)) {
+        throw new CallEmbedError("call_failed", `Illegal call status transition: ${from} → ${to}`);
+    }
+    return to;
+}
+/** Whether `status` is a terminal state. */
+export function isTerminal(status) {
+    return status === "ended" || status === "error";
+}
+/** Exported for unit tests. */
+export const LEGAL_TRANSITIONS = ALLOWED;

package/dist/core/teardown.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Hang-up / media teardown / pagehide helpers extracted from CallSessionController
+ * so `call.ts` stays within the ~300-line maintainability budget.
+ */
+import type { Room } from "livekit-client";
+import type { RemoteAudioHost } from "./audio.js";
+import type { TypedEmitter } from "./events.js";
+import type { CallStatus, RuntimeConfig } from "./types.js";
+/** Minimal UI hook shape used by teardown (avoids circular import with call.ts). */
+export interface CallUiHooksLike {
+    onStatus?: (status: CallStatus, message?: string) => void;
+    onMuteChange?: (muted: boolean) => void;
+    onTerminal?: () => void;
+}
+export interface TeardownHost {
+    cfg: RuntimeConfig;
+    emitter: TypedEmitter;
+    audio: RemoteAudioHost;
+    ui: CallUiHooksLike;
+    getCallId: () => string;
+    getStatus: () => CallStatus;
+    setStatusRaw: (status: CallStatus) => void;
+    getRoom: () => Room | null;
+    setRoom: (room: Room | null) => void;
+    getHangUpStarted: () => boolean;
+    setHangUpStarted: (v: boolean) => void;
+    getEndCallSent: () => boolean;
+    setEndCallSent: (v: boolean) => void;
+    getEndToken: () => string | null;
+    clearEndToken: () => void;
+    getPageHideHandler: () => (() => void) | null;
+    setPageHideHandler: (h: (() => void) | null) => void;
+}
+declare function setStatus(host: TeardownHost, next: CallStatus): void;
+/**
+ * Stop mic + disconnect LiveKit. Safe to fire-and-forget — hangUp must not
+ * wait on slow peer-connection teardown (often multi-second).
+ */
+export declare function teardownMedia(host: TeardownHost): Promise<void>;
+export declare function cleanupSession(host: TeardownHost): void;
+/**
+ * End the call promptly: mark ended + notify server, tear down media in the
+ * background. Double hangUp is a no-op via hangUpStarted.
+ */
+export declare function hangUpSession(host: TeardownHost): Promise<void>;
+/** @returns true when start() must stop (hang-up already in progress). */
+export declare function finishAfterHangUp(host: TeardownHost): Promise<boolean>;
+export declare function bindPageHide(host: TeardownHost): void;
+export { setStatus as applyStatusTransition };

package/dist/core/teardown.js

@@ -0,0 +1,107 @@
+import { apiEndCall, apiEndCallKeepalive } from "./api.js";
+import { isTerminal, transition } from "./state-machine.js";
+function setStatus(host, next) {
+    const previous = host.getStatus();
+    const status = transition(previous, next);
+    host.setStatusRaw(status);
+    if (previous !== status) {
+        host.emitter.emit("statusChange", {
+            status,
+            previousStatus: previous,
+        });
+    }
+}
+/**
+ * Stop mic + disconnect LiveKit. Safe to fire-and-forget — hangUp must not
+ * wait on slow peer-connection teardown (often multi-second).
+ */
+export async function teardownMedia(host) {
+    const room = host.getRoom();
+    host.setRoom(null);
+    if (room) {
+        try {
+            await room.localParticipant.setMicrophoneEnabled(false);
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            await room.disconnect();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    host.audio.destroy();
+}
+export function cleanupSession(host) {
+    const pageHideHandler = host.getPageHideHandler();
+    if (pageHideHandler && typeof window !== "undefined") {
+        window.removeEventListener("pagehide", pageHideHandler);
+        host.setPageHideHandler(null);
+    }
+    host.clearEndToken();
+    host.emitter.clear();
+}
+async function sendEndCallIfReady(host) {
+    if (host.getEndCallSent() || host.getCallId() === "pending")
+        return;
+    host.setEndCallSent(true);
+    const token = host.getEndToken();
+    await apiEndCall(host.cfg, host.getCallId(), token);
+}
+/**
+ * End the call promptly: mark ended + notify server, tear down media in the
+ * background. Double hangUp is a no-op via hangUpStarted.
+ */
+export async function hangUpSession(host) {
+    if (host.getHangUpStarted())
+        return;
+    host.setHangUpStarted(true);
+    // Do not await disconnect — it can take several seconds after the server ends.
+    void teardownMedia(host).catch(() => undefined);
+    if (!isTerminal(host.getStatus())) {
+        setStatus(host, "ended");
+        host.emitter.emit("ended", { callId: host.getCallId(), status: "ended" });
+        host.ui.onStatus?.("ended");
+    }
+    await sendEndCallIfReady(host);
+    host.ui.onTerminal?.();
+    cleanupSession(host);
+}
+/** @returns true when start() must stop (hang-up already in progress). */
+export async function finishAfterHangUp(host) {
+    if (!host.getHangUpStarted())
+        return false;
+    void teardownMedia(host).catch(() => undefined);
+    await sendEndCallIfReady(host);
+    if (!isTerminal(host.getStatus()))
+        host.setStatusRaw("ended");
+    return true;
+}
+export function bindPageHide(host) {
+    if (typeof window === "undefined")
+        return;
+    const pageHideHandler = () => {
+        if (host.getCallId() !== "pending" && !host.getEndCallSent()) {
+            host.setEndCallSent(true);
+            apiEndCallKeepalive(host.cfg, host.getCallId(), host.getEndToken());
+        }
+        void teardownMedia(host).catch(() => undefined);
+        if (!isTerminal(host.getStatus()) && !host.getHangUpStarted()) {
+            host.setHangUpStarted(true);
+            try {
+                setStatus(host, "ended");
+                host.emitter.emit("ended", { callId: host.getCallId(), status: "ended" });
+                host.ui.onStatus?.("ended");
+            }
+            catch {
+                host.setStatusRaw("ended");
+            }
+            cleanupSession(host);
+        }
+    };
+    host.setPageHideHandler(pageHideHandler);
+    window.addEventListener("pagehide", pageHideHandler);
+}
+export { setStatus as applyStatusTransition };