@convbased/sdk 0.1.0

package/dist/convbased-sdk.global.js

@@ -0,0 +1,1291 @@
+/**
+ * @convbased/sdk — bundled IIFE build.
+ *
+ * Auto-generated by scripts/bundle.mjs. Do not edit directly.
+ *
+ * Hosted at https://cdn.weights.chat/sdk/convbased-sdk.global.js — drop a
+ * classic script tag and read symbols from window.Convbased:
+ *
+ *   <script src="https://cdn.weights.chat/sdk/convbased-sdk.global.js"></script>
+ *   <script>
+ *     const client = new Convbased.ConvbasedClient({ apiKey });
+ *   </script>
+ */
+(function (globalThis) {
+	"use strict";
+// ===== events.js =====
+
+// Minimal typed event emitter; we avoid pulling Node's EventEmitter so the
+// SDK stays browser-first with no polyfill chain.
+class TypedEmitter {
+    constructor() {
+        this.listeners = {};
+    }
+    on(event, fn) {
+        var _a;
+        ((_a = this.listeners)[event] ?? (_a[event] = new Set())).add(fn);
+        return () => this.off(event, fn);
+    }
+    off(event, fn) {
+        this.listeners[event]?.delete(fn);
+    }
+    emit(event, payload) {
+        const set = this.listeners[event];
+        if (!set)
+            return;
+        for (const fn of set) {
+            try {
+                fn(payload);
+            }
+            catch (e) {
+                // Listeners shouldn't crash the emitter.
+                console.error(`[convbased-sdk] listener for "${String(event)}" threw:`, e);
+            }
+        }
+    }
+    removeAllListeners() {
+        for (const key of Object.keys(this.listeners)) {
+            delete this.listeners[key];
+        }
+    }
+}
+
+// ===== sdp.js =====
+
+// SDP mangling helpers. Mirrors `setAudioParameters` in Convbased-Web — we
+// rewrite the Opus `a=fmtp:` line so the offer requests our target bitrate,
+// stereo mode, and inband FEC. The signaling node passes the SDP through to
+// aiortc largely unchanged, so changes here directly shape the negotiated
+// audio.
+function applyOpusSdpOptions(sdp, opts) {
+    const lines = sdp.split("\r\n");
+    let payloadType = null;
+    for (const line of lines) {
+        const match = line.match(/a=rtpmap:(\d+) opus\/48000\/2/);
+        if (match) {
+            payloadType = match[1];
+            break;
+        }
+    }
+    if (!payloadType)
+        return sdp;
+    let fmtpIndex = lines.findIndex((line) => line.startsWith(`a=fmtp:${payloadType}`));
+    if (fmtpIndex === -1) {
+        lines.push(`a=fmtp:${payloadType}`);
+        fmtpIndex = lines.length - 1;
+    }
+    let fmtp = lines[fmtpIndex];
+    fmtp = fmtp.replace(/;\s*stereo=\d/, "");
+    fmtp = fmtp.replace(/;\s*maxaveragebitrate=\d+/, "");
+    if (opts.stereo)
+        fmtp += "; stereo=1";
+    fmtp += `; maxaveragebitrate=${opts.bitrateKbps * 1000}`;
+    if (!fmtp.includes("useinbandfec=1"))
+        fmtp += "; useinbandfec=1";
+    lines[fmtpIndex] = fmtp;
+    return lines.join("\r\n");
+}
+
+// ===== types.js =====
+
+// Wire-protocol types mirrored from ServerAPI / signaling.
+var RTCStatusCode;
+(function (RTCStatusCode) {
+    RTCStatusCode[RTCStatusCode["ERROR"] = 2000] = "ERROR";
+    RTCStatusCode[RTCStatusCode["GPU_INSUFFICIENT"] = 2001] = "GPU_INSUFFICIENT";
+    RTCStatusCode[RTCStatusCode["DUPLICATE_CONNECTION"] = 2002] = "DUPLICATE_CONNECTION";
+    RTCStatusCode[RTCStatusCode["MODEL_NOT_FOUND"] = 2003] = "MODEL_NOT_FOUND";
+    RTCStatusCode[RTCStatusCode["UNPAID_SERVICE"] = 2004] = "UNPAID_SERVICE";
+    RTCStatusCode[RTCStatusCode["REQUEST_TOO_FAST"] = 2005] = "REQUEST_TOO_FAST";
+    RTCStatusCode[RTCStatusCode["CONNECTED"] = 3000] = "CONNECTED";
+    RTCStatusCode[RTCStatusCode["REQUEST_RECEIVED"] = 3001] = "REQUEST_RECEIVED";
+    RTCStatusCode[RTCStatusCode["TRACK_READY"] = 3002] = "TRACK_READY";
+    RTCStatusCode[RTCStatusCode["RESPONSE_SENT"] = 3003] = "RESPONSE_SENT";
+    RTCStatusCode[RTCStatusCode["LOADING_MODEL"] = 3004] = "LOADING_MODEL";
+    RTCStatusCode[RTCStatusCode["SERVICE_READY"] = 3009] = "SERVICE_READY";
+    // File inference (voice-to-voice) task lifecycle codes.
+    RTCStatusCode[RTCStatusCode["TASK_PROGRESS"] = 3010] = "TASK_PROGRESS";
+    RTCStatusCode[RTCStatusCode["TASK_FINISHED"] = 3011] = "TASK_FINISHED";
+    RTCStatusCode[RTCStatusCode["TASK_ACK"] = 3012] = "TASK_ACK";
+    RTCStatusCode[RTCStatusCode["SHUTDOWN"] = 4000] = "SHUTDOWN";
+    RTCStatusCode[RTCStatusCode["SERVER_CLOSED"] = 5000] = "SERVER_CLOSED";
+})(RTCStatusCode || (RTCStatusCode = {}));
+
+// ===== endpoints.js =====
+
+// Production endpoints baked into the SDK. These mirror Convbased-Web's
+// `.env` (VITE_WS_ENDPOINT / VITE_API_BASE_URL) and are considered stable —
+// they're consumed by every Convbased client today. Override only for
+// self-hosted deployments or local development.
+const DEFAULT_SIGNALING_URL = "wss://api.weights.chat/api/signaling/ws";
+const DEFAULT_GRAPHQL_URL = "https://api.weights.chat/api/v1/graphql";
+
+// ===== graphql.js =====
+
+// Shared GraphQL transport for the Convbased service. Authentication mirrors
+// the server middleware: `x-api-key: <key>` for API keys, or
+// `Authorization: Bearer <jwt>` for access tokens.
+/**
+ * Issue a single GraphQL operation and return `data`. Throws on HTTP failure
+ * or when the response carries a non-empty `errors` array — the thrown
+ * `Error.message` is the first server-reported message (often an i18n key the
+ * caller can localize).
+ */
+async function graphqlRequest(args) {
+    const headers = {
+        "content-type": "application/json",
+    };
+    if (args.apiKey)
+        headers["x-api-key"] = args.apiKey;
+    else if (args.accessToken) {
+        headers["authorization"] = `Bearer ${args.accessToken}`;
+    }
+    const res = await fetch(args.graphqlUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ query: args.query, variables: args.variables }),
+        signal: args.signal,
+    });
+    if (!res.ok) {
+        throw new Error(`GraphQL request failed: HTTP ${res.status} ${res.statusText}`);
+    }
+    const json = (await res.json());
+    if (json.errors?.length) {
+        throw new Error(json.errors.map((e) => e.message).join("; "));
+    }
+    if (json.data === undefined || json.data === null) {
+        throw new Error("GraphQL response contained no data");
+    }
+    return json.data;
+}
+
+// ===== upload.js =====
+
+// Audio upload helpers shared by TTS (reference voice) and file inference
+// (source audio). Two steps mirror Convbased-Web: ask the GraphQL service for
+// a presigned PUT (`requestAudioUpload`), then PUT the bytes straight to object
+// storage. The returned COS `key` is what you hand to `submitTts` /
+// `startTask`.
+const REQUEST_AUDIO_UPLOAD = /* GraphQL */ `
+	mutation RequestAudioUpload($input: RequestUploadInput!) {
+		requestAudioUpload(input: $input) {
+			key
+			upload_url
+			method
+			expires_in
+			headers {
+				name
+				value
+			}
+			bucket
+			region
+			url
+		}
+	}
+`;
+/** Ask the service for a presigned PUT for an audio file. */
+async function requestAudioUpload(args) {
+    const data = await graphqlRequest({
+        graphqlUrl: args.graphqlUrl,
+        apiKey: args.apiKey,
+        accessToken: args.accessToken,
+        signal: args.signal,
+        query: REQUEST_AUDIO_UPLOAD,
+        variables: {
+            input: {
+                filename: args.filename,
+                content_type: args.contentType,
+                size: args.size,
+            },
+        },
+    });
+    return data.requestAudioUpload;
+}
+/** PUT raw bytes to a presigned upload target. */
+async function putToPresigned(presigned, body, signal) {
+    const headers = {};
+    for (const h of presigned.headers ?? []) {
+        if (h?.name)
+            headers[h.name] = h.value;
+    }
+    const res = await fetch(presigned.upload_url, {
+        method: presigned.method || "PUT",
+        headers,
+        body: body,
+        signal,
+    });
+    if (!res.ok) {
+        throw new Error(`Audio upload failed: HTTP ${res.status} ${res.statusText}`);
+    }
+}
+/**
+ * Upload an audio `Blob`/`File` end-to-end (presign + PUT) and resolve the COS
+ * `key`. Filename and content type are taken from the `File` when available;
+ * override via `opts` when uploading a bare `Blob`.
+ */
+async function uploadAudio(args) {
+    const maybeFile = args.file;
+    const filename = args.filename ?? maybeFile.name ?? "audio.wav";
+    const contentType = args.contentType ||
+        args.file.type ||
+        "application/octet-stream";
+    const presigned = await requestAudioUpload({
+        graphqlUrl: args.graphqlUrl,
+        apiKey: args.apiKey,
+        accessToken: args.accessToken,
+        signal: args.signal,
+        filename,
+        contentType,
+        size: args.file.size,
+    });
+    await putToPresigned(presigned, args.file, args.signal);
+    return { key: presigned.key };
+}
+
+// ===== signaling.js =====
+
+/**
+ * Thin WebSocket wrapper for the Convbased signaling endpoint. Builds the URL
+ * (`${base}/signaling/ws?api_key=…`), waits for `open`, and exposes JSON
+ * send/recv plus a 10s keepalive ping to match the server's expectations.
+ */
+class SignalingChannel {
+    constructor(opts) {
+        this.opts = opts;
+        this.ws = null;
+        this.pingTimer = null;
+        this.handlers = null;
+    }
+    get isOpen() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    async connect(handlers) {
+        if (this.ws) {
+            throw new Error("SignalingChannel is already connected");
+        }
+        this.handlers = handlers;
+        const url = this.buildUrl();
+        this.opts.logger.debug?.("[convbased-sdk] connecting signaling:", url);
+        const ws = new WebSocket(url);
+        this.ws = ws;
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                try {
+                    ws.close();
+                }
+                catch {
+                    /* ignore */
+                }
+                reject(new Error("Signaling WebSocket connect timeout"));
+            }, this.opts.connectTimeoutMs);
+            const onOpen = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (e) => {
+                cleanup();
+                reject(new Error(`Signaling WebSocket failed to open: ${describeEvent(e)}`));
+            };
+            const onClose = (e) => {
+                cleanup();
+                reject(new Error(`Signaling WebSocket closed before open (code=${e.code}, reason=${e.reason || "?"})`));
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                ws.removeEventListener("open", onOpen);
+                ws.removeEventListener("error", onError);
+                ws.removeEventListener("close", onClose);
+            };
+            ws.addEventListener("open", onOpen);
+            ws.addEventListener("error", onError);
+            ws.addEventListener("close", onClose);
+        });
+        ws.addEventListener("message", (e) => this.handleMessage(e));
+        ws.addEventListener("close", (e) => this.handleClose(e));
+        ws.addEventListener("error", (e) => this.handlers?.onError(e));
+        // The signaling server pings every 10s and expects us to keep the
+        // socket warm. We mirror that cadence rather than relying on TCP
+        // keepalive, which most browsers don't expose.
+        this.pingTimer = setInterval(() => {
+            if (this.isOpen)
+                this.send({ type: "ping" });
+        }, 10000);
+    }
+    send(msg) {
+        if (!this.isOpen) {
+            throw new Error("Signaling WebSocket is not open");
+        }
+        this.ws.send(JSON.stringify(msg));
+    }
+    close(code = 1000, reason = "client close") {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        if (this.ws && this.ws.readyState <= WebSocket.OPEN) {
+            try {
+                this.ws.close(code, reason);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.ws = null;
+    }
+    handleMessage(event) {
+        if (typeof event.data !== "string")
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(event.data);
+        }
+        catch (e) {
+            this.opts.logger.warn?.("[convbased-sdk] dropping non-JSON signaling frame:", event.data);
+            return;
+        }
+        this.handlers?.onMessage(parsed);
+    }
+    handleClose(event) {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        this.handlers?.onClose(event);
+    }
+    buildUrl() {
+        // `signalingUrl` may be:
+        //   - the full final URL ending in `/ws` (production default — used as-is)
+        //   - a bare host (e.g. `ws://localhost:3010`) — we append `/signaling/ws`
+        //   - something already containing `/signaling` — we append `/ws`
+        let base = this.opts.signalingUrl.trim();
+        if (base.endsWith("/"))
+            base = base.slice(0, -1);
+        let finalUrl;
+        if (/\/ws$/i.test(base)) {
+            finalUrl = base;
+        }
+        else if (/\/signaling$/i.test(base)) {
+            finalUrl = `${base}/ws`;
+        }
+        else {
+            finalUrl = `${base}/signaling/ws`;
+        }
+        const url = new URL(finalUrl);
+        if (this.opts.apiKey)
+            url.searchParams.set("api_key", this.opts.apiKey);
+        if (this.opts.accessToken && !this.opts.apiKey) {
+            url.searchParams.set("token", this.opts.accessToken);
+        }
+        return url.toString();
+    }
+}
+function describeEvent(e) {
+    if (e instanceof ErrorEvent && e.message)
+        return e.message;
+    return e.type || "unknown error";
+}
+
+// ===== rtcServers.js =====
+
+/**
+ * Fetch TURN credentials from the Convbased GraphQL service. The query matches
+ * the one used by Convbased-Web's `getRTCServers`. Authentication uses the
+ * same API key / access token passed to the SDK.
+ */
+async function fetchRTCServers(args) {
+    const data = await graphqlRequest({
+        graphqlUrl: args.graphqlUrl,
+        apiKey: args.apiKey,
+        accessToken: args.accessToken,
+        signal: args.signal,
+        query: /* GraphQL */ `
+			query {
+				rtcServers {
+					urls
+					username
+					credential
+				}
+			}
+		`,
+    });
+    if (!data.rtcServers) {
+        throw new Error("rtcServers returned an empty payload");
+    }
+    return data.rtcServers;
+}
+const DEFAULT_STUN_SERVERS = [
+    { urls: ["stun:stun.l.google.com:19302"] },
+];
+
+// ===== tts.js =====
+
+// Text-to-speech client for the Convbased IndexTTS2 service. This path is pure
+// GraphQL — it does not touch WebRTC or the signaling socket. Synthesis is
+// asynchronous: you submit a job, then poll until it reaches a terminal state.
+//
+// Typical flow:
+//   const tts = new TtsClient({ apiKey });
+//   const { key } = await tts.uploadReferenceAudio(file); // reference voice
+//   const result = await tts.synthesize({ referenceKey: key, text: "你好" });
+//   audio.src = result.url; // presigned, ~1h
+const JOB_FIELDS = /* GraphQL */ `
+	job_id
+	status
+	position
+	result {
+		key
+		url
+		token_count
+		audio_duration_sec
+		amount_charged
+		balance_after
+	}
+	error
+`;
+class TtsClient {
+    constructor(options) {
+        if (!options.apiKey && !options.accessToken) {
+            throw new Error("TtsClient requires either `apiKey` or `accessToken`");
+        }
+        this.graphqlUrl = options.graphqlUrl ?? DEFAULT_GRAPHQL_URL;
+        this.apiKey = options.apiKey;
+        this.accessToken = options.accessToken;
+        const provided = options.logger ?? {};
+        this.logger = {
+            debug: provided.debug ?? (() => { }),
+            info: provided.info ?? (() => { }),
+            warn: provided.warn ?? console.warn.bind(console),
+            error: provided.error ?? console.error.bind(console),
+        };
+    }
+    /** Upload a reference-voice `Blob`/`File` and resolve its COS key. */
+    async uploadReferenceAudio(file, opts) {
+        return uploadAudio({
+            graphqlUrl: this.graphqlUrl,
+            apiKey: this.apiKey,
+            accessToken: this.accessToken,
+            file,
+            filename: opts?.filename,
+            contentType: opts?.contentType,
+            signal: opts?.signal,
+        });
+    }
+    /** Current billing rule: `cost = max(tokens * pricePerToken, minCharge)`. */
+    async getPricing(signal) {
+        const data = await graphqlRequest({
+            graphqlUrl: this.graphqlUrl,
+            apiKey: this.apiKey,
+            accessToken: this.accessToken,
+            signal,
+            query: /* GraphQL */ `
+				query {
+					ttsPricing {
+						price_per_token
+						min_charge
+					}
+				}
+			`,
+        });
+        return {
+            pricePerToken: data.ttsPricing.price_per_token,
+            minCharge: data.ttsPricing.min_charge,
+        };
+    }
+    /** Enqueue a synthesis job; resolves immediately with the queued job. */
+    async submit(opts, signal) {
+        const data = await graphqlRequest({
+            graphqlUrl: this.graphqlUrl,
+            apiKey: this.apiKey,
+            accessToken: this.accessToken,
+            signal,
+            query: /* GraphQL */ `
+				mutation SubmitTts($input: SynthesizeTtsInput!) {
+					submitTts(input: $input) {
+						${JOB_FIELDS}
+					}
+				}
+			`,
+            variables: {
+                input: {
+                    reference_key: opts.referenceKey,
+                    text: opts.text,
+                    params: opts.params ?? null,
+                },
+            },
+        });
+        return toJob(data.submitTts);
+    }
+    /** Read the current status/result of a job. */
+    async getJob(jobId, signal) {
+        const data = await graphqlRequest({
+            graphqlUrl: this.graphqlUrl,
+            apiKey: this.apiKey,
+            accessToken: this.accessToken,
+            signal,
+            query: /* GraphQL */ `
+				query TtsJob($jobId: String!) {
+					ttsJob(jobId: $jobId) {
+						${JOB_FIELDS}
+					}
+				}
+			`,
+            variables: { jobId },
+        });
+        return toJob(data.ttsJob);
+    }
+    /** Cancel a job. Only effective while it is still `queued`. */
+    async cancel(jobId, signal) {
+        const data = await graphqlRequest({
+            graphqlUrl: this.graphqlUrl,
+            apiKey: this.apiKey,
+            accessToken: this.accessToken,
+            signal,
+            query: /* GraphQL */ `
+				mutation CancelTtsJob($jobId: String!) {
+					cancelTtsJob(jobId: $jobId) {
+						${JOB_FIELDS}
+					}
+				}
+			`,
+            variables: { jobId },
+        });
+        return toJob(data.cancelTtsJob);
+    }
+    /**
+     * One-call synthesis: (optionally upload the reference voice,) submit, then
+     * poll until the job finishes. Resolves with the `TtsResult` on success;
+     * rejects if the job fails/cancels, times out, or `signal` aborts.
+     */
+    async synthesize(opts) {
+        if (!opts.referenceKey && !opts.referenceAudio) {
+            throw new Error("synthesize() requires either `referenceKey` or `referenceAudio`");
+        }
+        const pollIntervalMs = opts.pollIntervalMs ?? 1500;
+        const timeoutMs = opts.timeoutMs ?? 300000;
+        const deadline = Date.now() + timeoutMs;
+        const referenceKey = opts.referenceKey ??
+            (await this.uploadReferenceAudio(opts.referenceAudio, {
+                signal: opts.signal,
+            })).key;
+        const submitted = await this.submit({ referenceKey, text: opts.text, params: opts.params }, opts.signal);
+        opts.onJob?.(submitted);
+        let job = submitted;
+        try {
+            while (job.status !== "done") {
+                if (opts.signal?.aborted) {
+                    throw new DOMException("Aborted", "AbortError");
+                }
+                if (job.status === "failed") {
+                    throw new Error(job.error || "TTS job failed");
+                }
+                if (job.status === "cancelled") {
+                    throw new Error("TTS job was cancelled");
+                }
+                if (Date.now() > deadline) {
+                    throw new Error(`Timed out waiting for TTS job ${job.jobId} after ${timeoutMs}ms`);
+                }
+                await delay(pollIntervalMs, opts.signal);
+                job = await this.getJob(job.jobId, opts.signal);
+                opts.onJob?.(job);
+            }
+        }
+        catch (err) {
+            // Best-effort: stop a still-queued job so we don't pay for a result
+            // nobody is waiting for.
+            if (opts.signal?.aborted) {
+                this.cancel(job.jobId).catch(() => { });
+            }
+            throw err;
+        }
+        if (!job.result) {
+            throw new Error("TTS job is done but carried no result");
+        }
+        return job.result;
+    }
+}
+function toJob(wire) {
+    return {
+        jobId: wire.job_id,
+        status: wire.status,
+        position: wire.position,
+        result: wire.result
+            ? {
+                key: wire.result.key,
+                url: wire.result.url,
+                tokenCount: wire.result.token_count,
+                audioDurationSec: wire.result.audio_duration_sec,
+                amountCharged: wire.result.amount_charged,
+                balanceAfter: wire.result.balance_after,
+            }
+            : null,
+        error: wire.error,
+    };
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new DOMException("Aborted", "AbortError"));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new DOMException("Aborted", "AbortError"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+
+// ===== client.js =====
+
+/**
+ * Real-time voice conversion client. Mirrors the flow used by Convbased-Web:
+ *
+ *  1. Open WebSocket to `${signalingUrl}/signaling/ws?api_key=…`.
+ *  2. Capture the microphone (or accept a user-provided `MediaStream`).
+ *  3. Build an `RTCPeerConnection`, attach the mic track, mangle the offer's
+ *     Opus parameters, and send `{type: "offer", sdp, preferences}` over the
+ *     signaling socket.
+ *  4. Apply the `answer` and `ice_candidate` messages from the server, fire
+ *     local ICE candidates back over signaling.
+ *  5. When the server sends `{code: SERVICE_READY}` the processed track is
+ *     emitted via the `track` event — wire it to an `<audio>` element to hear
+ *     converted audio.
+ *
+ * The client is single-use: call `connect()` once, then `disconnect()` to
+ * tear everything down. Create a fresh instance for a new session.
+ */
+class ConvbasedClient extends TypedEmitter {
+    constructor(options) {
+        super();
+        this.state = "idle";
+        this.signaling = null;
+        this.pc = null;
+        this.localStream = null;
+        this.convertedStream = null;
+        this.serviceReadyTimer = null;
+        this.offerInFlight = false;
+        if (!options.apiKey && !options.accessToken) {
+            throw new Error("ConvbasedClient requires either `apiKey` or `accessToken`");
+        }
+        this.opts = {
+            iceTransportPolicy: "all",
+            bitrate: 64,
+            stereo: false,
+            signalingTimeoutMs: 120000,
+            connectTimeoutMs: 20000,
+            ...options,
+            // Endpoints fall back to the baked-in Convbased production URLs.
+            signalingUrl: options.signalingUrl ?? DEFAULT_SIGNALING_URL,
+            graphqlUrl: options.graphqlUrl === false
+                ? false
+                : (options.graphqlUrl ?? DEFAULT_GRAPHQL_URL),
+        };
+        const provided = options.logger ?? {};
+        this.logger = {
+            debug: provided.debug ?? (() => { }),
+            info: provided.info ?? (() => { }),
+            warn: provided.warn ?? console.warn.bind(console),
+            error: provided.error ?? console.error.bind(console),
+        };
+    }
+    getState() {
+        return this.state;
+    }
+    /** The converted (voice-changed) audio stream returned from the inference node. */
+    getConvertedStream() {
+        return this.convertedStream;
+    }
+    getPeerConnection() {
+        return this.pc;
+    }
+    /**
+     * Open the signaling socket, capture audio, and run WebRTC negotiation.
+     * Resolves when the server emits SERVICE_READY (audio is flowing both ways).
+     * Rejects on auth failures, signaling errors, or negotiation timeouts.
+     */
+    async connect(opts) {
+        if (this.state !== "idle") {
+            throw new Error(`ConvbasedClient.connect() called from invalid state "${this.state}"`);
+        }
+        if (!opts.modelId) {
+            throw new Error("ConnectOptions.modelId is required");
+        }
+        this.setState("signaling");
+        try {
+            await this.openSignaling();
+            const iceServers = await this.resolveIceServers();
+            this.setState("negotiating");
+            await this.openPeer(opts, iceServers);
+            await this.waitForServiceReady();
+            this.setState("connected");
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            this.emit("error", error);
+            await this.disconnect().catch(() => { });
+            this.setState("error");
+            throw error;
+        }
+    }
+    /**
+     * Send a runtime config update to the inference node. Equivalent to the
+     * pitch / formant / RMS sliders in Convbased-Web — only the fields you set
+     * are forwarded.
+     */
+    updateConfig(preferences) {
+        if (!this.signaling?.isOpen) {
+            throw new Error("Cannot updateConfig: signaling channel is closed");
+        }
+        this.signaling.send({ type: "config", preferences });
+    }
+    // ---------------------------------------------------------------------
+    // File inference (voice-to-voice) — convert an uploaded audio file within
+    // the current live session. Requires the client to be `connected` first;
+    // the inference node is provisioned by `connect()`.
+    // ---------------------------------------------------------------------
+    /**
+     * Upload a source-audio `Blob`/`File` and resolve its COS key, ready to pass
+     * to `startTask` / `runFileInference`. Requires `graphqlUrl` (the default
+     * production endpoint, or a self-hosted override — not `false`).
+     */
+    async uploadAudio(file, opts) {
+        if (typeof this.opts.graphqlUrl !== "string") {
+            throw new Error("uploadAudio requires a GraphQL endpoint; do not set `graphqlUrl: false`");
+        }
+        return uploadAudio({
+            graphqlUrl: this.opts.graphqlUrl,
+            apiKey: this.opts.apiKey,
+            accessToken: this.opts.accessToken,
+            file,
+            filename: opts?.filename,
+            contentType: opts?.contentType,
+            signal: opts?.signal,
+        });
+    }
+    /**
+     * Submit a file-inference task over the signaling channel and return its
+     * task id. The client must be `connected`. Results arrive asynchronously via
+     * the `taskAck` / `taskProgress` / `taskFinished` events — use
+     * `runFileInference` for a promise-based wrapper.
+     */
+    startTask(opts) {
+        if (this.state !== "connected") {
+            throw new Error(`startTask requires a connected session (current state "${this.state}")`);
+        }
+        if (!this.signaling?.isOpen) {
+            throw new Error("Cannot startTask: signaling channel is closed");
+        }
+        if (!opts.audioKey) {
+            throw new Error("StartTaskOptions.audioKey is required");
+        }
+        const taskId = opts.taskId ?? generateTaskId();
+        this.signaling.send({
+            type: "task_start",
+            task_id: taskId,
+            audio_key: opts.audioKey,
+            generate_name: opts.generateName ?? "output",
+            format: opts.format ?? "wav",
+            preferences: opts.preferences,
+        });
+        return taskId;
+    }
+    /** Cancel a file-inference task. Omit `taskId` to stop the current one. */
+    stopTask(taskId) {
+        if (!this.signaling?.isOpen) {
+            throw new Error("Cannot stopTask: signaling channel is closed");
+        }
+        this.signaling.send({ type: "task_stop", task_id: taskId });
+    }
+    /**
+     * Promise-based file inference: (optionally upload the source audio,) start
+     * the task, and resolve with the `taskFinished` event on success. Rejects on
+     * task failure/cancellation, timeout, signaling close, or `signal` abort.
+     */
+    async runFileInference(opts) {
+        if (!opts.audioKey && !opts.audio) {
+            throw new Error("runFileInference requires either `audioKey` or `audio`");
+        }
+        const audioKey = opts.audioKey ??
+            (await this.uploadAudio(opts.audio, { signal: opts.signal })).key;
+        const timeoutMs = opts.timeoutMs ?? 300000;
+        return new Promise((resolve, reject) => {
+            let taskId;
+            let timer = null;
+            const cleanup = () => {
+                offAck();
+                offProgress();
+                offFinished();
+                offErr();
+                offClosed();
+                if (timer)
+                    clearTimeout(timer);
+                if (opts.signal)
+                    opts.signal.removeEventListener("abort", onAbort);
+            };
+            const settleErr = (err) => {
+                cleanup();
+                reject(err);
+            };
+            const onAbort = () => {
+                try {
+                    this.stopTask(taskId);
+                }
+                catch {
+                    /* ignore */
+                }
+                settleErr(new DOMException("Aborted", "AbortError"));
+            };
+            const offAck = this.on("taskAck", (e) => {
+                if (e.taskId === taskId)
+                    opts.onAck?.(e);
+            });
+            const offProgress = this.on("taskProgress", (e) => {
+                if (e.taskId === taskId)
+                    opts.onProgress?.(e);
+            });
+            const offFinished = this.on("taskFinished", (e) => {
+                if (e.taskId !== taskId)
+                    return;
+                if (e.status === "success") {
+                    cleanup();
+                    resolve(e);
+                }
+                else {
+                    settleErr(new Error(e.error || `File inference task ${e.status}`));
+                }
+            });
+            const offErr = this.on("error", (err) => settleErr(err));
+            const offClosed = this.on("closed", () => settleErr(new Error("Session closed before task finished")));
+            if (opts.signal?.aborted) {
+                offAck();
+                offProgress();
+                offFinished();
+                offErr();
+                offClosed();
+                reject(new DOMException("Aborted", "AbortError"));
+                return;
+            }
+            opts.signal?.addEventListener("abort", onAbort, { once: true });
+            timer = setTimeout(() => {
+                settleErr(new Error(`Timed out waiting for file inference task after ${timeoutMs}ms`));
+            }, timeoutMs);
+            try {
+                taskId = this.startTask({
+                    audioKey,
+                    taskId: opts.taskId,
+                    generateName: opts.generateName,
+                    format: opts.format,
+                    preferences: opts.preferences,
+                });
+            }
+            catch (err) {
+                settleErr(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    /** Mute / unmute the local mic by toggling the captured audio track. */
+    setMuted(muted) {
+        const track = this.localStream?.getAudioTracks()[0];
+        if (track)
+            track.enabled = !muted;
+    }
+    /** Replace the local input stream (mic) with a different `MediaStream` (hot-swap). */
+    async replaceLocalStream(newStream) {
+        if (!this.pc)
+            throw new Error("PeerConnection is not active");
+        const newTrack = newStream.getAudioTracks()[0];
+        if (!newTrack)
+            throw new Error("Replacement stream has no audio track");
+        const sender = this.pc
+            .getSenders()
+            .find((s) => s.track?.kind === "audio");
+        if (!sender)
+            throw new Error("No audio sender on PeerConnection");
+        await sender.replaceTrack(newTrack);
+        this.stopTracks(this.localStream);
+        this.localStream = newStream;
+    }
+    /** Snapshot of jitter / loss / RTT (sampled from `RTCPeerConnection.getStats`). */
+    async getStats() {
+        if (!this.pc || this.pc.connectionState !== "connected")
+            return null;
+        const report = await this.pc.getStats();
+        const stats = { rttMs: 0, jitter: 0, packetsLost: 0 };
+        report.forEach((entry) => {
+            if (entry.type === "candidate-pair" &&
+                entry.state === "succeeded" &&
+                typeof entry.currentRoundTripTime === "number") {
+                stats.rttMs = Math.round(entry.currentRoundTripTime * 1000);
+            }
+            if (entry.type === "inbound-rtp" && entry.kind === "audio") {
+                if (typeof entry.jitter === "number")
+                    stats.jitter = entry.jitter;
+                if (typeof entry.packetsLost === "number") {
+                    stats.packetsLost = entry.packetsLost;
+                }
+            }
+        });
+        return stats;
+    }
+    /** Gracefully end the session — notifies the server, closes the PC. */
+    async disconnect() {
+        if (this.state === "closed" || this.state === "closing")
+            return;
+        this.setState("closing");
+        this.clearServiceReadyTimer();
+        try {
+            if (this.signaling?.isOpen) {
+                try {
+                    this.signaling.send({ type: "exit" });
+                    // Give the frame a tick to flush before we yank the socket.
+                    await new Promise((r) => setTimeout(r, 25));
+                }
+                catch {
+                    /* socket already gone */
+                }
+            }
+        }
+        finally {
+            this.tearDownPeer();
+            this.signaling?.close();
+            this.signaling = null;
+            this.setState("closed");
+            this.emit("closed", {});
+        }
+    }
+    // ---------------------------------------------------------------------
+    // Internal
+    // ---------------------------------------------------------------------
+    async openSignaling() {
+        const channel = new SignalingChannel({
+            signalingUrl: this.opts.signalingUrl,
+            apiKey: this.opts.apiKey,
+            accessToken: this.opts.accessToken,
+            connectTimeoutMs: this.opts.connectTimeoutMs,
+            logger: this.logger,
+        });
+        await channel.connect({
+            onMessage: (msg) => this.handleSignalingMessage(msg),
+            onClose: (e) => this.handleSignalingClose(e),
+            onError: (e) => this.logger.warn?.("[convbased-sdk] signaling error event", e),
+        });
+        this.signaling = channel;
+    }
+    async resolveIceServers() {
+        if (this.opts.iceServers?.length)
+            return this.opts.iceServers;
+        if (typeof this.opts.graphqlUrl === "string") {
+            try {
+                const cfg = await fetchRTCServers({
+                    graphqlUrl: this.opts.graphqlUrl,
+                    apiKey: this.opts.apiKey,
+                    accessToken: this.opts.accessToken,
+                });
+                if (cfg.urls?.length)
+                    return [cfg];
+            }
+            catch (e) {
+                this.logger.warn?.("[convbased-sdk] fetchRTCServers failed, falling back to STUN:", e);
+            }
+        }
+        return DEFAULT_STUN_SERVERS;
+    }
+    async openPeer(opts, iceServers) {
+        const pc = new RTCPeerConnection({
+            iceServers: iceServers,
+            iceTransportPolicy: this.opts.iceTransportPolicy,
+        });
+        this.pc = pc;
+        pc.onicecandidate = (event) => {
+            if (event.candidate && this.signaling?.isOpen) {
+                this.signaling.send({
+                    type: "ice_candidate",
+                    candidate: event.candidate.toJSON(),
+                });
+            }
+        };
+        pc.ontrack = (event) => {
+            const stream = event.streams[0] ?? new MediaStream([event.track]);
+            this.convertedStream = stream;
+            this.emit("track", { stream, track: event.track });
+        };
+        pc.onconnectionstatechange = () => {
+            const cs = pc.connectionState;
+            this.logger.debug?.("[convbased-sdk] pc state:", cs);
+            if (cs === "connecting") {
+                if (this.state === "negotiating")
+                    this.setState("connecting");
+            }
+            else if (cs === "failed" || cs === "disconnected" || cs === "closed") {
+                if (this.state !== "closing" && this.state !== "closed") {
+                    this.emit("error", new Error(`PeerConnection entered "${cs}" state`));
+                    void this.disconnect();
+                }
+            }
+        };
+        this.localStream = await this.acquireLocalStream(opts.audio);
+        for (const track of this.localStream.getAudioTracks()) {
+            pc.addTrack(track, this.localStream);
+        }
+        const offer = await pc.createOffer({ offerToReceiveAudio: true });
+        offer.sdp = applyOpusSdpOptions(offer.sdp ?? "", {
+            bitrateKbps: this.opts.bitrate,
+            stereo: this.opts.stereo,
+        });
+        await pc.setLocalDescription(offer);
+        const sampleRate = opts.sampleRate ??
+            detectSampleRate(this.localStream) ??
+            48000;
+        const preferences = {
+            ...(opts.preferences ?? {}),
+            model_id: opts.modelId,
+            sample_rate: sampleRate,
+        };
+        if (!this.signaling?.isOpen) {
+            throw new Error("Signaling channel closed before offer was sent");
+        }
+        this.offerInFlight = true;
+        this.signaling.send({ type: "offer", sdp: offer.sdp, preferences });
+    }
+    async acquireLocalStream(audio) {
+        if (audio instanceof MediaStream)
+            return audio;
+        const constraints = {
+            audio: audio === undefined ? true : audio,
+            video: false,
+        };
+        if (typeof navigator === "undefined" ||
+            !navigator.mediaDevices?.getUserMedia) {
+            throw new Error("navigator.mediaDevices.getUserMedia is unavailable — pass a MediaStream via `audio`");
+        }
+        return navigator.mediaDevices.getUserMedia(constraints);
+    }
+    waitForServiceReady() {
+        return new Promise((resolve, reject) => {
+            const off = this.on("ready", () => {
+                cleanup();
+                resolve();
+            });
+            const offErr = this.on("error", (err) => {
+                cleanup();
+                reject(err);
+            });
+            const offClosed = this.on("closed", () => {
+                cleanup();
+                reject(new Error("Signaling closed before SERVICE_READY"));
+            });
+            this.serviceReadyTimer = setTimeout(() => {
+                cleanup();
+                reject(new Error(`Timed out waiting for SERVICE_READY after ${this.opts.signalingTimeoutMs}ms`));
+            }, this.opts.signalingTimeoutMs);
+            const cleanup = () => {
+                off();
+                offErr();
+                offClosed();
+                this.clearServiceReadyTimer();
+            };
+        });
+    }
+    clearServiceReadyTimer() {
+        if (this.serviceReadyTimer) {
+            clearTimeout(this.serviceReadyTimer);
+            this.serviceReadyTimer = null;
+        }
+    }
+    handleSignalingMessage(msg) {
+        const type = msg.type;
+        this.emit("message", {
+            code: msg.code,
+            message: msg.message,
+            raw: msg,
+        });
+        switch (type) {
+            case "answer":
+                void this.applyAnswer(msg);
+                break;
+            case "ice_candidate":
+                void this.applyRemoteCandidate(msg);
+                break;
+            case "task_ack": {
+                const m = msg;
+                this.emit("taskAck", {
+                    taskId: m.task_id,
+                    status: m.status,
+                    queuePosition: m.queue_position,
+                    code: m.code,
+                });
+                break;
+            }
+            case "task_progress": {
+                const m = msg;
+                this.emit("taskProgress", {
+                    taskId: m.task_id,
+                    progress: m.progress,
+                    code: m.code,
+                });
+                break;
+            }
+            case "task_finished": {
+                const m = msg;
+                this.emit("taskFinished", {
+                    taskId: m.task_id,
+                    status: m.status,
+                    resultKey: m.result_key,
+                    downloadUrl: m.download_url,
+                    error: m.error,
+                    code: m.code,
+                });
+                break;
+            }
+            case "message": {
+                const code = msg.code;
+                const text = msg.message;
+                if (code === RTCStatusCode.SERVICE_READY) {
+                    this.emit("ready", { code, message: text });
+                }
+                else if (code === RTCStatusCode.ERROR ||
+                    code === RTCStatusCode.GPU_INSUFFICIENT ||
+                    code === RTCStatusCode.UNPAID_SERVICE ||
+                    code === RTCStatusCode.MODEL_NOT_FOUND ||
+                    code === RTCStatusCode.DUPLICATE_CONNECTION ||
+                    code === RTCStatusCode.REQUEST_TOO_FAST) {
+                    this.emit("error", new Error(text || `Server reported error code ${code}`));
+                }
+                else if (code === RTCStatusCode.SHUTDOWN) {
+                    void this.disconnect();
+                }
+                break;
+            }
+            case "shutdown":
+            case "error": {
+                const text = msg.message;
+                this.emit("error", new Error(text || `Server sent "${type}"`));
+                void this.disconnect();
+                break;
+            }
+            case "ping":
+                if (this.signaling?.isOpen)
+                    this.signaling.send({ type: "pong" });
+                break;
+            case "pong":
+            default:
+                // task_* and other passthrough messages are surfaced via the
+                // generic "message" event above.
+                break;
+        }
+    }
+    async applyAnswer(msg) {
+        if (!this.pc)
+            return;
+        try {
+            await this.pc.setRemoteDescription({ type: "answer", sdp: msg.sdp });
+            this.offerInFlight = false;
+        }
+        catch (e) {
+            this.emit("error", new Error(`Failed to apply remote answer: ${describeErr(e)}`));
+        }
+    }
+    async applyRemoteCandidate(msg) {
+        if (!this.pc)
+            return;
+        try {
+            await this.pc.addIceCandidate(msg.candidate);
+        }
+        catch (e) {
+            this.logger.warn?.("[convbased-sdk] addIceCandidate failed:", e);
+        }
+    }
+    handleSignalingClose(event) {
+        if (this.state === "closing" || this.state === "closed")
+            return;
+        this.emit("closed", { code: event.code, reason: event.reason });
+        // 1008 is what the server sends for auth + balance failures.
+        if (event.code === 1008) {
+            this.emit("error", new Error(`Signaling rejected the connection: ${event.reason || "policy violation"}`));
+        }
+        else if (event.code !== 1000) {
+            this.emit("error", new Error(`Signaling closed unexpectedly (code=${event.code}, reason=${event.reason || "?"})`));
+        }
+        this.tearDownPeer();
+        this.setState("closed");
+    }
+    tearDownPeer() {
+        if (this.pc) {
+            try {
+                this.pc.onicecandidate = null;
+                this.pc.ontrack = null;
+                this.pc.onconnectionstatechange = null;
+                this.pc.close();
+            }
+            catch {
+                /* ignore */
+            }
+            this.pc = null;
+        }
+        this.stopTracks(this.localStream);
+        this.localStream = null;
+        this.convertedStream = null;
+    }
+    stopTracks(stream) {
+        stream?.getTracks().forEach((t) => {
+            try {
+                t.stop();
+            }
+            catch {
+                /* ignore */
+            }
+        });
+    }
+    setState(next) {
+        if (next === this.state)
+            return;
+        const previous = this.state;
+        this.state = next;
+        this.emit("state", { state: next, previous });
+    }
+}
+function generateTaskId() {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now()}_${Math.random().toString(16).slice(2)}`;
+}
+function detectSampleRate(stream) {
+    const track = stream.getAudioTracks()[0];
+    const rate = track?.getSettings()?.sampleRate;
+    return typeof rate === "number" ? rate : null;
+}
+function describeErr(e) {
+    if (e instanceof Error)
+        return e.message;
+    return String(e);
+}
+
+	const api = {
+		ConvbasedClient,
+		TtsClient,
+		uploadAudio,
+		requestAudioUpload,
+		putToPresigned,
+		graphqlRequest,
+		applyOpusSdpOptions,
+		fetchRTCServers,
+		DEFAULT_STUN_SERVERS,
+		DEFAULT_SIGNALING_URL,
+		DEFAULT_GRAPHQL_URL,
+		RTCStatusCode,
+	};
+
+	// Expose as window.Convbased so consumers can do:
+	//   const client = new Convbased.ConvbasedClient({ apiKey });
+	if (typeof globalThis.Convbased === "undefined") {
+		globalThis.Convbased = api;
+	} else {
+		Object.assign(globalThis.Convbased, api);
+	}
+})(typeof globalThis !== "undefined" ? globalThis : window);