assemblyai 4.33.3 → 4.34.4

package/dist/streaming.browser.mjs

@@ -1,3 +1,16 @@
+/**
+ * Thrown when `DualChannelCapture` is constructed in a non-browser environment
+ * (no `globalThis.AudioContext`). The helper is intentionally surfaced from the
+ * main entrypoint so the import path is uniform across runtimes; the runtime
+ * guard moves to construction time.
+ */
+class BrowserOnlyError extends Error {
+    constructor(message = "DualChannelCapture requires a browser environment (AudioContext is undefined).") {
+        super(message);
+        this.name = "BrowserOnlyError";
+    }
+}
+
 const { WritableStream } = typeof window !== "undefined"
     ? window
     : typeof global !== "undefined"
@@ -67,9 +80,58 @@ const RealtimeErrorMessages = {
 class RealtimeError extends Error {
 }
 
+const StreamingErrorType = {
+    BadSampleRate: 4000,
+    AuthFailed: 4001,
+    InsufficientFunds: 4002,
+    FreeTierUser: 4003,
+    NonexistentSessionId: 4004,
+    SessionExpired: 4008,
+    ClosedSession: 4010,
+    RateLimited: 4029,
+    UniqueSessionViolation: 4030,
+    SessionTimeout: 4031,
+    AudioTooShort: 4032,
+    AudioTooLong: 4033,
+    AudioTooSmallToTranscode: 4034,
+    BadSchema: 4101,
+    TooManyStreams: 4102,
+    Reconnected: 4103,
+    ServerError: 3005,
+    InputValidationError: 3006,
+    AudioChunkDurationViolation: 3007,
+    MaxSessionDurationExceeded: 3008,
+    ConcurrencyLimitExceeded: 3009,
+};
+const StreamingErrorMessages = {
+    [StreamingErrorType.ServerError]: "Server error",
+    [StreamingErrorType.InputValidationError]: "Input validation error",
+    [StreamingErrorType.AudioChunkDurationViolation]: "Audio chunk duration violation",
+    [StreamingErrorType.MaxSessionDurationExceeded]: "Session expired: maximum session duration exceeded",
+    [StreamingErrorType.ConcurrencyLimitExceeded]: "Too many concurrent sessions",
+    [StreamingErrorType.BadSampleRate]: "Sample rate must be a positive integer",
+    [StreamingErrorType.AuthFailed]: "Not Authorized",
+    [StreamingErrorType.InsufficientFunds]: "Insufficient funds",
+    [StreamingErrorType.FreeTierUser]: "This feature is paid-only and requires you to add a credit card. Please visit https://app.assemblyai.com/ to add a credit card to your account.",
+    [StreamingErrorType.NonexistentSessionId]: "Session ID does not exist",
+    [StreamingErrorType.SessionExpired]: "Session has expired",
+    [StreamingErrorType.ClosedSession]: "Session is closed",
+    [StreamingErrorType.RateLimited]: "Rate limited",
+    [StreamingErrorType.UniqueSessionViolation]: "Unique session violation",
+    [StreamingErrorType.SessionTimeout]: "Session Timeout",
+    [StreamingErrorType.AudioTooShort]: "Audio too short",
+    [StreamingErrorType.AudioTooLong]: "Audio too long",
+    [StreamingErrorType.AudioTooSmallToTranscode]: "Audio too small to transcode",
+    [StreamingErrorType.BadSchema]: "Bad schema",
+    [StreamingErrorType.TooManyStreams]: "Too many streams",
+    [StreamingErrorType.Reconnected]: "This session has been reconnected. This WebSocket is no longer valid.",
+};
+class StreamingError extends Error {
+}
+
 const defaultRealtimeUrl = "wss://api.assemblyai.com/v2/realtime/ws";
 const forceEndOfUtteranceMessage = `{"force_end_utterance":true}`;
-const terminateSessionMessage = `{"terminate_session":true}`;
+const terminateSessionMessage$1 = `{"terminate_session":true}`;
 /**
  * RealtimeTranscriber connects to the Streaming Speech-to-Text API and lets you transcribe audio in real-time.
  */
@@ -262,11 +324,11 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
                     const sessionTerminatedPromise = new Promise((resolve) => {
                         this.sessionTerminatedResolve = resolve;
                     });
-                    this.socket.send(terminateSessionMessage);
+                    this.socket.send(terminateSessionMessage$1);
                     await sessionTerminatedPromise;
                 }
                 else {
-                    this.socket.send(terminateSessionMessage);
+                    this.socket.send(terminateSessionMessage$1);
                 }
             }
             if (this.socket?.removeAllListeners)
@@ -283,4 +345,1185 @@ Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/c
 class RealtimeService extends RealtimeTranscriber {
 }
 
-export { RealtimeService, RealtimeTranscriber };
+/**
+ * Energy-based VAD with adaptive noise-floor tracking and hangover. Pure JS,
+ * no dependencies. Suitable for the "which physical channel is speaking" task
+ * because the channels are already physically separated at capture — the harder
+ * problem (speech vs. non-speech in the wild) is one a customer can swap in a
+ * DNN VAD for via the `createVad` parameter.
+ *
+ * Tuning notes:
+ * - thresholdRatio below 2 will treat anything above noise as speech (too sensitive).
+ * - thresholdRatio above 6 will miss quiet utterance onsets/offsets.
+ * - noiseFloorAlpha above 0.1 makes the floor track quickly (good for non-stationary
+ *   background) but risks slowly adapting *up* to a sustained low voice.
+ */
+class EnergyVad {
+    constructor(params = {}) {
+        this.hangoverRemaining = 0;
+        this.thresholdRatio = params.thresholdRatio ?? 3.0;
+        this.noiseFloorAlpha = params.noiseFloorAlpha ?? 0.05;
+        this.hangoverFrames = params.hangoverFrames ?? 10;
+        this.initialNoiseFloor = params.initialNoiseFloor ?? 1e-4;
+        this.noiseFloor = this.initialNoiseFloor;
+    }
+    process(frame) {
+        let sumSq = 0;
+        for (let i = 0; i < frame.length; i++) {
+            sumSq += frame[i] * frame[i];
+        }
+        const rms = frame.length > 0 ? Math.sqrt(sumSq / frame.length) : 0;
+        const threshold = this.noiseFloor * this.thresholdRatio;
+        let active = rms > threshold;
+        if (active) {
+            this.hangoverRemaining = this.hangoverFrames;
+        }
+        else if (this.hangoverRemaining > 0) {
+            this.hangoverRemaining--;
+            active = true;
+            // While in hangover, do not update noise floor — RMS may still reflect tail energy.
+        }
+        else {
+            this.noiseFloor =
+                this.noiseFloor * (1 - this.noiseFloorAlpha) +
+                    rms * this.noiseFloorAlpha;
+        }
+        return { active, energy: rms };
+    }
+    reset() {
+        this.noiseFloor = this.initialNoiseFloor;
+        this.hangoverRemaining = 0;
+    }
+}
+
+/**
+ * Append-only ring buffer of VAD frames in stream-relative ms order.
+ * `pushFrame` is O(1) amortized; `framesInWindow` is O(n) over kept frames,
+ * which is fine for the per-word lookups we do (a 30 s window at 50 frames/s
+ * per channel × 2 channels = 3000 entries, scanned once per word).
+ *
+ * Runtime-agnostic — no DOM or Web Audio dependencies.
+ */
+class VadTimeline {
+    constructor(windowMs) {
+        this.windowMs = windowMs;
+        this.frames = [];
+        this.head = 0;
+    }
+    pushFrame(frame) {
+        this.frames.push(frame);
+        const cutoff = frame.ts - this.windowMs;
+        while (this.head < this.frames.length &&
+            this.frames[this.head].ts < cutoff) {
+            this.head++;
+        }
+        if (this.head > 1024 && this.head * 2 > this.frames.length) {
+            this.frames = this.frames.slice(this.head);
+            this.head = 0;
+        }
+    }
+    framesInWindow(startMs, endMs) {
+        const out = [];
+        for (let i = this.head; i < this.frames.length; i++) {
+            const f = this.frames[i];
+            if (f.ts < startMs)
+                continue;
+            if (f.ts > endMs)
+                break;
+            out.push(f);
+        }
+        return out;
+    }
+    clear() {
+        this.frames = [];
+        this.head = 0;
+    }
+}
+/**
+ * Sum per-channel active RMS over a window. Returns a Map from channel name
+ * to total score. Channels with zero score are omitted.
+ */
+function scoreChannels(frames) {
+    const scores = new Map();
+    for (const f of frames) {
+        if (!f.active)
+            continue;
+        scores.set(f.channel, (scores.get(f.channel) ?? 0) + f.rms);
+    }
+    return scores;
+}
+/**
+ * Decide which channel was dominant during a word's `[start, end]` window.
+ *
+ * - If no channel has any active VAD energy → `"unknown"`.
+ * - If the top channel beats the runner-up by at least `dominanceRatio` → top channel.
+ * - Else: top channel wins on absolute score; exact ties → `"unknown"`.
+ */
+function attributeWord(word, timeline, params) {
+    const scores = scoreChannels(timeline.framesInWindow(word.start, word.end));
+    if (scores.size === 0)
+        return "unknown";
+    const sorted = [...scores.entries()].sort((a, b) => b[1] - a[1]);
+    if (sorted.length === 1)
+        return sorted[0][0];
+    const [topName, topScore] = sorted[0];
+    const [runnerName, runnerScore] = sorted[1];
+    if (topScore >= params.dominanceRatio * runnerScore)
+        return topName;
+    if (topScore > runnerScore)
+        return topName;
+    if (runnerScore > topScore)
+        return runnerName;
+    return "unknown";
+}
+/**
+ * Duration-weighted majority of word channels. `"unknown"` if there are no
+ * words, every word resolved to `"unknown"`, or two channels tie exactly.
+ */
+function rollUpTurnChannel(words) {
+    const totals = new Map();
+    for (const w of words) {
+        if (!w.channel || w.channel === "unknown")
+            continue;
+        const dur = Math.max(0, w.end - w.start);
+        totals.set(w.channel, (totals.get(w.channel) ?? 0) + dur);
+    }
+    if (totals.size === 0)
+        return "unknown";
+    const sorted = [...totals.entries()].sort((a, b) => b[1] - a[1]);
+    if (sorted.length === 1)
+        return sorted[0][0];
+    const [topName, topMs] = sorted[0];
+    const [, runnerMs] = sorted[1];
+    if (topMs === runnerMs)
+        return "unknown";
+    return topName;
+}
+/**
+ * Mutate `turn` in place: write `turn.words[i].channel` for every word and set
+ * `turn.channel` to the duration-weighted rollup.
+ *
+ * Returns `void` because the transcriber owns the `TurnEvent` ref and forwards
+ * the same object to the customer listener — no need to allocate a copy.
+ */
+function attributeTurn(turn, timeline, params) {
+    for (const w of turn.words) {
+        w.channel = attributeWord(w, timeline, params);
+    }
+    turn.channel = rollUpTurnChannel(turn.words);
+}
+
+/**
+ * View any `AudioData` (ArrayBuffer / ArrayBufferView / typed array) as a
+ * little-endian Int16 sample sequence without copying. Callers must guarantee
+ * the underlying byte length is even.
+ */
+function toInt16View(audio) {
+    // AudioData is ArrayBufferLike per the public type, but in practice callers
+    // pass ArrayBuffer or a typed-array view. Handle both without copying.
+    if (audio instanceof Int16Array)
+        return audio;
+    if (ArrayBuffer.isView(audio)) {
+        const view = audio;
+        return new Int16Array(view.buffer, view.byteOffset, Math.floor(view.byteLength / 2));
+    }
+    return new Int16Array(audio);
+}
+const defaultStreamingUrl = "wss://streaming.assemblyai.com/v3/ws";
+const terminateSessionMessage = `{"type":"Terminate"}`;
+/**
+ * Per-send chunk cap in milliseconds for the dual-channel mixer. The streaming
+ * server rejects audio messages longer than 1000 ms (`Input Duration Error`).
+ * If a backlog accumulates (e.g. when a browser tab is backgrounded and
+ * `setInterval` is throttled to ~1 Hz), `flushMix` loops and emits multiple
+ * sends each ≤ this cap until the buffers drain.
+ */
+const MAX_CHUNK_MS = 200;
+/**
+ * Per-send minimum chunk size in milliseconds. The streaming server also
+ * rejects audio messages shorter than 50 ms with the same
+ * `Input Duration Error`, so the mixer waits until both per-channel buffers
+ * have at least this much accumulated before emitting. Final-flush (close
+ * path) bypasses this floor so the trailing partial buffer still gets sent.
+ */
+const MIN_CHUNK_MS = 50;
+class StreamingTranscriber {
+    constructor(params) {
+        this.listeners = {};
+        // Dual-channel mode state (allocated only when params.channels is set).
+        this.isDualChannel = false;
+        this.vadFrameSamples = 0;
+        this.minChunkSamples = 0;
+        this.maxChunkSamples = 0;
+        this.params = {
+            ...params,
+            websocketBaseUrl: params.websocketBaseUrl || defaultStreamingUrl,
+        };
+        if ("token" in params && params.token)
+            this.token = params.token;
+        if ("apiKey" in params && params.apiKey)
+            this.apiKey = params.apiKey;
+        if (!(this.token || this.apiKey)) {
+            throw new Error("API key or temporary token is required.");
+        }
+        if (params.channels) {
+            if (params.channels.length !== 2) {
+                throw new Error("StreamingTranscriber.channels must have exactly 2 entries.");
+            }
+            const names = params.channels.map((c) => c.name);
+            if (new Set(names).size !== names.length) {
+                throw new Error("StreamingTranscriber.channels names must be unique.");
+            }
+            this.isDualChannel = true;
+            this.channelNames = names;
+            const att = params.channelAttribution ?? {};
+            this.attributionParams = {
+                dominanceRatio: att.dominanceRatio ?? 4,
+                timelineWindowMs: att.timelineWindowMs ?? 30_000,
+                createVad: att.createVad ?? (() => new EnergyVad()),
+                flushIntervalMs: att.flushIntervalMs ?? 50,
+                resolveUnknownChannelsMethod: att.resolveUnknownChannelsMethod ?? "window",
+                resolutionWindowWords: att.resolutionWindowWords ?? 2,
+                speakerHistoryMinRmsEvidence: att.speakerHistoryMinRmsEvidence ?? 0.5,
+                speakerHistoryDominanceRatio: att.speakerHistoryDominanceRatio ?? 3,
+            };
+            if (this.attributionParams.resolveUnknownChannelsMethod ===
+                "speaker-history") {
+                this.speakerHistory = new Map();
+            }
+            // 20 ms VAD frames at the transcriber's target sample rate.
+            this.vadFrameSamples = Math.max(1, Math.round(params.sampleRate * 0.02));
+            this.minChunkSamples = Math.max(1, Math.round(params.sampleRate * (MIN_CHUNK_MS / 1000)));
+            this.maxChunkSamples = Math.max(this.minChunkSamples, Math.round(params.sampleRate * (MAX_CHUNK_MS / 1000)));
+            this.channelBuffers = new Map(names.map((n) => [n, []]));
+            this.channelSamplesReceived = new Map(names.map((n) => [n, 0]));
+            this.channelVadFloatBuffers = new Map(names.map((n) => [n, new Float32Array(this.vadFrameSamples)]));
+            this.channelVadBufferIdx = new Map(names.map((n) => [n, 0]));
+            this.channelVads = new Map(names.map((n) => [n, this.attributionParams.createVad(n)]));
+            this.timeline = new VadTimeline(this.attributionParams.timelineWindowMs);
+        }
+    }
+    connectionUrl() {
+        const url = new URL(this.params.websocketBaseUrl ?? "");
+        if (url.protocol !== "wss:") {
+            throw new Error("Invalid protocol, must be wss");
+        }
+        const searchParams = new URLSearchParams();
+        if (this.token) {
+            searchParams.set("token", this.token);
+        }
+        searchParams.set("sample_rate", this.params.sampleRate.toString());
+        if (this.params.endOfTurnConfidenceThreshold) {
+            searchParams.set("end_of_turn_confidence_threshold", this.params.endOfTurnConfidenceThreshold.toString());
+        }
+        if (this.params.minEndOfTurnSilenceWhenConfident !== undefined) {
+            if (this.params.minTurnSilence !== undefined) {
+                console.warn("[Deprecation Warning] Both `minEndOfTurnSilenceWhenConfident` and `minTurnSilence` are set. Using `minTurnSilence`; `minEndOfTurnSilenceWhenConfident` is deprecated.");
+            }
+            else {
+                console.warn("[Deprecation Warning] `minEndOfTurnSilenceWhenConfident` is deprecated and will be removed in a future release. Please use `minTurnSilence` instead.");
+            }
+        }
+        const effectiveMinTurnSilence = this.params.minTurnSilence ??
+            this.params.minEndOfTurnSilenceWhenConfident;
+        if (effectiveMinTurnSilence !== undefined) {
+            searchParams.set("min_turn_silence", effectiveMinTurnSilence.toString());
+        }
+        if (this.params.maxTurnSilence) {
+            searchParams.set("max_turn_silence", this.params.maxTurnSilence.toString());
+        }
+        if (this.params.vadThreshold !== undefined) {
+            searchParams.set("vad_threshold", this.params.vadThreshold.toString());
+        }
+        if (this.params.formatTurns) {
+            searchParams.set("format_turns", this.params.formatTurns.toString());
+        }
+        if (this.params.encoding) {
+            searchParams.set("encoding", this.params.encoding.toString());
+        }
+        if (this.params.keytermsPrompt) {
+            searchParams.set("keyterms_prompt", JSON.stringify(this.params.keytermsPrompt));
+        }
+        else if (this.params.keyterms) {
+            console.warn("[Deprecation Warning] `keyterms` is deprecated and will be removed in a future release. Please use `keytermsPrompt` instead.");
+            searchParams.set("keyterms_prompt", JSON.stringify(this.params.keyterms));
+        }
+        if (this.params.prompt) {
+            searchParams.set("prompt", this.params.prompt);
+        }
+        if (this.params.agentContext) {
+            searchParams.set("agent_context", this.params.agentContext);
+        }
+        if (this.params.filterProfanity) {
+            searchParams.set("filter_profanity", this.params.filterProfanity.toString());
+        }
+        if (this.params.speechModel === "u3-pro") {
+            console.warn("[Deprecation Warning] The speech model `u3-pro` is deprecated and will be removed in a future release. Please use `u3-rt-pro` instead.");
+        }
+        if (this.params.speechModel !== undefined) {
+            searchParams.set("speech_model", this.params.speechModel.toString());
+        }
+        if (this.params.languageDetection !== undefined) {
+            searchParams.set("language_detection", this.params.languageDetection.toString());
+        }
+        if (this.params.domain) {
+            searchParams.set("domain", this.params.domain);
+        }
+        if (this.params.inactivityTimeout !== undefined) {
+            searchParams.set("inactivity_timeout", this.params.inactivityTimeout.toString());
+        }
+        if (this.params.speakerLabels !== undefined) {
+            searchParams.set("speaker_labels", this.params.speakerLabels.toString());
+        }
+        if (this.params.maxSpeakers !== undefined) {
+            searchParams.set("max_speakers", this.params.maxSpeakers.toString());
+        }
+        if (this.params.voiceFocus) {
+            searchParams.set("voice_focus", this.params.voiceFocus);
+        }
+        if (this.params.voiceFocusThreshold !== undefined) {
+            searchParams.set("voice_focus_threshold", this.params.voiceFocusThreshold.toString());
+        }
+        if (this.params.continuousPartials !== undefined) {
+            searchParams.set("continuous_partials", this.params.continuousPartials.toString());
+        }
+        if (this.params.interruptionDelay !== undefined) {
+            searchParams.set("interruption_delay", this.params.interruptionDelay.toString());
+        }
+        if (this.params.turnLeftPadMs !== undefined) {
+            searchParams.set("turn_left_pad_ms", this.params.turnLeftPadMs.toString());
+        }
+        if (this.params.customerSupportAudioCapture) {
+            console.warn("`customerSupportAudioCapture=true` will record session audio. Only enable this when explicitly coordinating with AssemblyAI support.");
+            // The server's canonical wire name is `_customer_support_audio_capture`
+            // (leading underscore = "not officially supported / unstable"). The
+            // server also accepts `customer_support_audio_capture` via
+            // `populate_by_name=True`, but we send the underscore form to honor
+            // the server's stability marker.
+            searchParams.set("_customer_support_audio_capture", this.params.customerSupportAudioCapture.toString());
+        }
+        if (this.params.webhookUrl) {
+            searchParams.set("webhook_url", this.params.webhookUrl);
+        }
+        if (this.params.webhookAuthHeaderName) {
+            searchParams.set("webhook_auth_header_name", this.params.webhookAuthHeaderName);
+        }
+        if (this.params.webhookAuthHeaderValue) {
+            searchParams.set("webhook_auth_header_value", this.params.webhookAuthHeaderValue);
+        }
+        if (this.params.includePartialTurns !== undefined) {
+            searchParams.set("include_partial_turns", this.params.includePartialTurns.toString());
+        }
+        if (this.params.redactPii !== undefined) {
+            searchParams.set("redact_pii", this.params.redactPii.toString());
+        }
+        if (this.params.redactPiiPolicies !== undefined) {
+            searchParams.set("redact_pii_policies", JSON.stringify(this.params.redactPiiPolicies));
+        }
+        if (this.params.redactPiiSub !== undefined) {
+            searchParams.set("redact_pii_sub", this.params.redactPiiSub);
+        }
+        if (this.params.mode !== undefined) {
+            searchParams.set("mode", this.params.mode);
+        }
+        if (this.params.llmGateway !== undefined) {
+            searchParams.set("llm_gateway", JSON.stringify(this.params.llmGateway));
+        }
+        url.search = searchParams.toString();
+        return url;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    on(event, listener) {
+        this.listeners[event] = listener;
+    }
+    connect() {
+        return new Promise((resolve) => {
+            if (this.socket) {
+                throw new Error("Already connected");
+            }
+            const url = this.connectionUrl();
+            if (this.token) {
+                this.socket = factory(url.toString());
+            }
+            else {
+                {
+                    console.warn(`API key authentication is not supported for the StreamingTranscriber in browser environment. Use temporary token authentication instead.
+Learn more at https://github.com/AssemblyAI/assemblyai-node-sdk/blob/main/docs/compat.md#browser-compatibility.`);
+                }
+                this.socket = factory(url.toString(), {
+                    headers: { Authorization: this.apiKey },
+                });
+            }
+            this.socket.binaryType = "arraybuffer";
+            this.socket.onopen = () => { };
+            this.socket.onclose = ({ code, reason }) => {
+                if (!reason) {
+                    if (code in StreamingErrorMessages) {
+                        reason = StreamingErrorMessages[code];
+                    }
+                }
+                // Stop the flush timer when the socket is gone (server-initiated close,
+                // network drop, etc.) — otherwise subsequent ticks call send() on a
+                // closed socket and spam the error listener.
+                if (this.flushTimer) {
+                    clearInterval(this.flushTimer);
+                    this.flushTimer = undefined;
+                }
+                this.listeners.close?.(code, reason);
+            };
+            this.socket.onerror = (event) => {
+                if (event.error)
+                    this.listeners.error?.(event.error);
+                else
+                    this.listeners.error?.(new Error(event.message));
+            };
+            this.socket.onmessage = ({ data }) => {
+                const message = JSON.parse(data.toString());
+                if ("error" in message) {
+                    const err = new StreamingError(message.error);
+                    if ("error_code" in message) {
+                        err.code =
+                            message.error_code;
+                    }
+                    this.listeners.error?.(err);
+                    return;
+                }
+                switch (message.type) {
+                    case "Begin": {
+                        resolve(message);
+                        this.listeners.open?.(message);
+                        break;
+                    }
+                    case "Turn": {
+                        if (this.isDualChannel && this.timeline && this.attributionParams) {
+                            attributeTurn(message, this.timeline, {
+                                dominanceRatio: this.attributionParams.dominanceRatio,
+                            });
+                            switch (this.attributionParams.resolveUnknownChannelsMethod) {
+                                case "window":
+                                    this.resolveUnknownChannelsByWindow(message);
+                                    break;
+                                case "speaker-history":
+                                    this.resolveUnknownChannelsBySpeakerHistory(message);
+                                    break;
+                            }
+                        }
+                        this.listeners.turn?.(message);
+                        break;
+                    }
+                    case "SpeechStarted": {
+                        this.listeners.speechStarted?.(message);
+                        break;
+                    }
+                    case "LLMGatewayResponse": {
+                        this.listeners.llmGatewayResponse?.(message);
+                        break;
+                    }
+                    case "SpeakerRevision": {
+                        this.listeners.speakerRevision?.(message);
+                        break;
+                    }
+                    case "Warning": {
+                        const warning = message;
+                        console.warn(`Streaming warning (code=${warning.warning_code}): ${warning.warning}`);
+                        this.listeners.warning?.(warning);
+                        break;
+                    }
+                    case "Termination": {
+                        this.sessionTerminatedResolve?.();
+                        break;
+                    }
+                }
+            };
+        });
+    }
+    /**
+     * Returns a WritableStream that pumps PCM chunks into `sendAudio`. Single-channel
+     * only — in dual-channel mode use `sendAudio(pcm, { channel })` directly, since
+     * `WritableStream` has no place to carry a channel tag.
+     */
+    stream() {
+        return new WritableStream({
+            write: (chunk) => {
+                this.sendAudio(chunk);
+            },
+        });
+    }
+    /**
+     * Send PCM audio.
+     *
+     * In single-channel mode, `audio` is forwarded directly to the WebSocket and
+     * `options` is ignored.
+     *
+     * In dual-channel mode (when `channels` is configured), `options.channel` is
+     * REQUIRED and must match one of the declared channel names. Per-channel PCM is
+     * fed into that channel's VAD, accumulated into a per-channel ring buffer, and
+     * a scheduled flush (`channelAttribution.flushIntervalMs`, default 50ms) mixes
+     * the buffers into mono before sending to the WebSocket.
+     */
+    sendAudio(audio, options) {
+        if (!this.isDualChannel) {
+            this.send(audio);
+            return;
+        }
+        if (!options?.channel) {
+            throw new Error("StreamingTranscriber is in dual-channel mode; sendAudio requires { channel }.");
+        }
+        if (!this.channelNames.includes(options.channel)) {
+            throw new Error(`Unknown channel "${options.channel}"; declared channels: ${this.channelNames.join(", ")}.`);
+        }
+        this.ingestChannelAudio(options.channel, audio);
+    }
+    ingestChannelAudio(name, audio) {
+        const samples = toInt16View(audio);
+        const buf = this.channelBuffers.get(name);
+        const vadBuf = this.channelVadFloatBuffers.get(name);
+        let vadIdx = this.channelVadBufferIdx.get(name);
+        let received = this.channelSamplesReceived.get(name);
+        const vad = this.channelVads.get(name);
+        const sampleRate = this.params.sampleRate;
+        const frameSize = this.vadFrameSamples;
+        for (let i = 0; i < samples.length; i++) {
+            const s = samples[i];
+            buf.push(s);
+            vadBuf[vadIdx++] = s / 0x8000;
+            received++;
+            if (vadIdx === frameSize) {
+                const result = vad.process(vadBuf);
+                const frame = {
+                    ts: (received / sampleRate) * 1000,
+                    channel: name,
+                    active: result.active,
+                    rms: result.energy,
+                };
+                this.timeline.pushFrame(frame);
+                this.listeners.vad?.(frame);
+                vadIdx = 0;
+            }
+        }
+        this.channelVadBufferIdx.set(name, vadIdx);
+        this.channelSamplesReceived.set(name, received);
+        if (!this.flushTimer)
+            this.startFlushTimer();
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => this.flushMix(), this.attributionParams.flushIntervalMs);
+    }
+    flushMix(force = false) {
+        if (!this.channelNames || !this.channelBuffers)
+            return;
+        const bufs = this.channelNames.map((n) => this.channelBuffers.get(n));
+        const divisor = bufs.length;
+        // Loop so a backlog (e.g. accumulated while a browser tab was throttled in
+        // the background) drains as multiple sends, each capped at MAX_CHUNK_MS.
+        // Without the cap a single message could exceed the server's 1000 ms input
+        // duration limit and be rejected with code 3007.
+        for (;;) {
+            let mixLen = Infinity;
+            for (const b of bufs)
+                if (b.length < mixLen)
+                    mixLen = b.length;
+            if (!Number.isFinite(mixLen) || mixLen === 0)
+                return;
+            // The streaming server rejects audio messages shorter than 50 ms with
+            // `Input Duration Error`. Wait until both per-channel buffers have at
+            // least minChunkSamples worth queued before emitting. The `force` path
+            // (final flush on close) bypasses this so the trailing partial buffer
+            // still gets through.
+            if (!force && mixLen < this.minChunkSamples)
+                return;
+            if (mixLen > this.maxChunkSamples)
+                mixLen = this.maxChunkSamples;
+            const out = new Int16Array(mixLen);
+            for (let i = 0; i < mixLen; i++) {
+                let sum = 0;
+                for (let c = 0; c < divisor; c++)
+                    sum += bufs[c][i];
+                const avg = Math.round(sum / divisor);
+                out[i] = avg < -32768 ? -32768 : avg > 32767 ? 32767 : avg;
+            }
+            for (const b of bufs)
+                b.splice(0, mixLen);
+            try {
+                this.send(out.buffer);
+            }
+            catch (err) {
+                this.listeners.error?.(err);
+                return;
+            }
+        }
+    }
+    /**
+     * Fill in words whose per-word VAD attribution was `"unknown"` by looking
+     * at the dominant non-`"unknown"` channel among ±N neighbors in the same
+     * turn. Words with no non-`"unknown"` neighbors stay `"unknown"`. Confident
+     * per-word VAD decisions are never modified.
+     *
+     * Local temporal heuristic — ignores `speaker_label`, so it works even when
+     * AAI's diarization re-uses the same label for two physically distinct
+     * voices. Each resolved word gets `channelResolved: true` so downstream
+     * renderers can distinguish inferred channels from directly-measured ones.
+     */
+    resolveUnknownChannelsByWindow(turn) {
+        if (!this.attributionParams)
+            return;
+        const window = this.attributionParams.resolutionWindowWords;
+        const words = turn.words;
+        let mutated = false;
+        for (let i = 0; i < words.length; i++) {
+            if (words[i].channel !== "unknown")
+                continue;
+            const tally = new Map();
+            const lo = Math.max(0, i - window);
+            const hi = Math.min(words.length - 1, i + window);
+            for (let j = lo; j <= hi; j++) {
+                if (j === i)
+                    continue;
+                const ch = words[j].channel;
+                if (!ch || ch === "unknown")
+                    continue;
+                tally.set(ch, (tally.get(ch) ?? 0) + 1);
+            }
+            if (tally.size === 0)
+                continue;
+            // Pick the dominant neighbor channel. Ties → leave `"unknown"` (rare;
+            // would require an equal count of mic and system neighbors).
+            let top;
+            let topCount = 0;
+            let tied = false;
+            for (const [name, count] of tally) {
+                if (count > topCount) {
+                    top = name;
+                    topCount = count;
+                    tied = false;
+                }
+                else if (count === topCount) {
+                    tied = true;
+                }
+            }
+            if (top && !tied) {
+                words[i].channel = top;
+                words[i].channelResolved = true;
+                mutated = true;
+            }
+        }
+        // Recompute the rollup only if any per-word channel changed.
+        if (mutated)
+            turn.channel = rollUpTurnChannel(words);
+    }
+    /**
+     * Fill `"unknown"` words by looking up the speaker's session-wide channel
+     * evidence. For each `speaker_label`, sums active VAD frame RMS per channel
+     * across every word the speaker has uttered to date. A speaker is
+     * "resolvable" if their total evidence clears
+     * `speakerHistoryMinRmsEvidence` and their top channel exceeds the
+     * runner-up by `speakerHistoryDominanceRatio`.
+     *
+     * Only touches `"unknown"` words. Confident per-word VAD decisions are
+     * never modified. `speaker_label` is never modified.
+     */
+    resolveUnknownChannelsBySpeakerHistory(turn) {
+        if (!this.timeline || !this.attributionParams || !this.speakerHistory)
+            return;
+        const minEvidence = this.attributionParams.speakerHistoryMinRmsEvidence;
+        const dominanceRatio = this.attributionParams.speakerHistoryDominanceRatio;
+        // 1. Accumulate evidence from this turn's words.
+        for (const w of turn.words) {
+            if (!w.speaker)
+                continue;
+            const frames = this.timeline.framesInWindow(w.start, w.end);
+            let entry = this.speakerHistory.get(w.speaker);
+            if (!entry) {
+                entry = new Map();
+                this.speakerHistory.set(w.speaker, entry);
+            }
+            for (const f of frames) {
+                if (!f.active)
+                    continue;
+                entry.set(f.channel, (entry.get(f.channel) ?? 0) + f.rms);
+            }
+        }
+        // 2. Fill unknown words whose speakers have dominant evidence.
+        let mutated = false;
+        for (const w of turn.words) {
+            if (w.channel !== "unknown" || !w.speaker)
+                continue;
+            const entry = this.speakerHistory.get(w.speaker);
+            if (!entry || entry.size === 0)
+                continue;
+            let total = 0;
+            let topName;
+            let topScore = 0;
+            let runnerScore = 0;
+            for (const [name, score] of entry) {
+                total += score;
+                if (score > topScore) {
+                    runnerScore = topScore;
+                    topScore = score;
+                    topName = name;
+                }
+                else if (score > runnerScore) {
+                    runnerScore = score;
+                }
+            }
+            if (total < minEvidence)
+                continue;
+            if (runnerScore > 0 && topScore < dominanceRatio * runnerScore)
+                continue;
+            if (topName) {
+                w.channel = topName;
+                w.channelResolved = true;
+                mutated = true;
+            }
+        }
+        if (mutated)
+            turn.channel = rollUpTurnChannel(turn.words);
+    }
+    /**
+     * Update the streaming configuration mid-stream.
+     * @param config - The configuration parameters to update
+     */
+    updateConfiguration(config) {
+        const { min_end_of_turn_silence_when_confident, min_turn_silence, ...rest } = config;
+        if (min_end_of_turn_silence_when_confident !== undefined) {
+            if (min_turn_silence !== undefined) {
+                console.warn("[Deprecation Warning] Both `min_end_of_turn_silence_when_confident` and `min_turn_silence` are set. Using `min_turn_silence`; `min_end_of_turn_silence_when_confident` is deprecated.");
+            }
+            else {
+                console.warn("[Deprecation Warning] `min_end_of_turn_silence_when_confident` is deprecated and will be removed in a future release. Please use `min_turn_silence` instead.");
+            }
+        }
+        const effective = min_turn_silence ?? min_end_of_turn_silence_when_confident;
+        const message = {
+            type: "UpdateConfiguration",
+            ...rest,
+            ...(effective !== undefined ? { min_turn_silence: effective } : {}),
+        };
+        this.send(JSON.stringify(message));
+    }
+    /**
+     * Force the current turn to end immediately.
+     */
+    forceEndpoint() {
+        const message = {
+            type: "ForceEndpoint",
+        };
+        this.send(JSON.stringify(message));
+    }
+    send(data) {
+        if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
+            throw new Error("Socket is not open for communication");
+        }
+        this.socket.send(data);
+    }
+    async close(waitForSessionTermination = true) {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+            // Best-effort: drain any final partial mix so the server gets the tail.
+            // Bypass the 50ms floor here since this is the last flush; if the tail
+            // is <50ms the server will reject that single message, but we'd lose
+            // the audio either way.
+            this.flushMix(true);
+        }
+        if (this.socket) {
+            if (this.socket.readyState === this.socket.OPEN) {
+                if (waitForSessionTermination) {
+                    const sessionTerminatedPromise = new Promise((resolve) => {
+                        this.sessionTerminatedResolve = resolve;
+                    });
+                    this.socket.send(terminateSessionMessage);
+                    await sessionTerminatedPromise;
+                }
+                else {
+                    this.socket.send(terminateSessionMessage);
+                }
+            }
+            if (this.socket?.removeAllListeners)
+                this.socket.removeAllListeners();
+            this.socket.close();
+        }
+        this.listeners = {};
+        this.socket = undefined;
+    }
+}
+
+const DEFAULT_FETCH_INIT = {
+    cache: "no-store",
+};
+
+const buildUserAgent = (userAgent) => defaultUserAgentString +
+    (userAgent === false
+        ? ""
+        : " AssemblyAI/1.0 (" +
+            Object.entries({ ...defaultUserAgent, ...userAgent })
+                .map(([key, item]) => item ? `${key}=${item.name}/${item.version}` : "")
+                .join(" ") +
+            ")");
+let defaultUserAgentString = "";
+if (typeof navigator !== "undefined" && navigator.userAgent) {
+    defaultUserAgentString += navigator.userAgent;
+}
+const defaultUserAgent = {
+    sdk: { name: "JavaScript", version: "4.34.4" },
+};
+if (typeof process !== "undefined") {
+    if (process.versions.node && defaultUserAgentString.indexOf("Node") === -1) {
+        defaultUserAgent.runtime_env = {
+            name: "Node",
+            version: process.versions.node,
+        };
+    }
+    if (process.versions.bun && defaultUserAgentString.indexOf("Bun") === -1) {
+        defaultUserAgent.runtime_env = {
+            name: "Bun",
+            version: process.versions.bun,
+        };
+    }
+}
+if (typeof Deno !== "undefined") {
+    if (process.versions.bun && defaultUserAgentString.indexOf("Deno") === -1) {
+        defaultUserAgent.runtime_env = { name: "Deno", version: Deno.version.deno };
+    }
+}
+
+/**
+ * Base class for services that communicate with the API.
+ */
+class BaseService {
+    /**
+     * Create a new service.
+     * @param params - The parameters to use for the service.
+     */
+    constructor(params) {
+        this.params = params;
+        if (params.userAgent === false) {
+            this.userAgent = undefined;
+        }
+        else {
+            this.userAgent = buildUserAgent(params.userAgent || {});
+        }
+    }
+    async fetch(input, init) {
+        init = { ...DEFAULT_FETCH_INIT, ...init };
+        let headers = {
+            Authorization: this.params.apiKey,
+            "Content-Type": "application/json",
+        };
+        if (DEFAULT_FETCH_INIT?.headers)
+            headers = { ...headers, ...DEFAULT_FETCH_INIT.headers };
+        if (init?.headers)
+            headers = { ...headers, ...init.headers };
+        if (this.userAgent) {
+            headers["User-Agent"] = this.userAgent;
+            {
+                // chromium browsers have a bug where the user agent can't be modified
+                if (typeof window !== "undefined" && "chrome" in window) {
+                    headers["AssemblyAI-Agent"] =
+                        this.userAgent;
+                }
+            }
+        }
+        init.headers = headers;
+        if (!input.startsWith("http"))
+            input = this.params.baseUrl + input;
+        const response = await fetch(input, init);
+        if (response.status >= 400) {
+            let json;
+            const text = await response.text();
+            if (text) {
+                try {
+                    json = JSON.parse(text);
+                }
+                catch {
+                    /* empty */
+                }
+                if (json?.error)
+                    throw new Error(json.error);
+                throw new Error(text);
+            }
+            throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+        }
+        return response;
+    }
+    async fetchJson(input, init) {
+        const response = await this.fetch(input, init);
+        return response.json();
+    }
+}
+
+class StreamingTranscriberFactory extends BaseService {
+    constructor(params) {
+        super(params);
+        this.baseServiceParams = params;
+    }
+    transcriber(params) {
+        const serviceParams = { ...params };
+        if (!serviceParams.token && !serviceParams.apiKey) {
+            serviceParams.apiKey = this.baseServiceParams.apiKey;
+        }
+        return new StreamingTranscriber(serviceParams);
+    }
+    async createTemporaryToken(params) {
+        const searchParams = new URLSearchParams();
+        // Add each param to the search params
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                searchParams.append(key, String(value));
+            }
+        });
+        const queryString = searchParams.toString();
+        const url = queryString ? `/v3/token?${queryString}` : "/v3/token";
+        const data = await this.fetchJson(url, {
+            method: "GET",
+        });
+        return data.token;
+    }
+}
+class StreamingServiceFactory extends StreamingTranscriberFactory {
+}
+
+/**
+ * AudioWorklet processor that ingests mono Float32 audio at the AudioContext's
+ * native sample rate, resamples to `targetRate` (linear interpolation, stateful
+ * across `process()` calls), packs to little-endian Int16 PCM, and posts
+ * fixed-size chunks via `port.postMessage` with a running `samplesSent` counter.
+ *
+ * `samplesSent` is in **target-rate samples**, so the main thread can derive a
+ * stream-relative timestamp = `samplesSent / targetRate * 1000` (ms) — the same
+ * frame AAI uses for `StreamingWord.start` / `.end`.
+ *
+ * Defined as a string so it can be registered via a Blob URL — the SDK ships as
+ * a single ESM file, so a separate `.js` worklet asset isn't viable.
+ */
+const pcm16EncoderWorkletSource = `
+class Pcm16EncoderProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const opts = (options && options.processorOptions) || {};
+    this.targetRate = opts.targetRate || 16000;
+    this.chunkMs = opts.chunkMs || 50;
+    this.ratio = sampleRate / this.targetRate;
+    this.chunkSize = Math.round(this.targetRate * this.chunkMs / 1000);
+    this.buffer = new Int16Array(this.chunkSize);
+    this.bufferIdx = 0;
+    this.samplesSent = 0;
+    this.lastSample = 0;
+    this.fractional = 0;
+  }
+
+  process(inputs) {
+    const input = inputs[0];
+    if (!input || input.length === 0 || !input[0] || input[0].length === 0) {
+      return true;
+    }
+    const mono = input[0];
+    let pos = this.fractional;
+    while (pos < mono.length) {
+      const i = Math.floor(pos);
+      const frac = pos - i;
+      const a = i === 0 ? this.lastSample : mono[i - 1];
+      const b = mono[i];
+      const sample = a + (b - a) * frac;
+      const clamped = sample < -1 ? -1 : sample > 1 ? 1 : sample;
+      this.buffer[this.bufferIdx++] = clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff;
+      if (this.bufferIdx === this.chunkSize) {
+        const out = new Int16Array(this.chunkSize);
+        out.set(this.buffer);
+        this.samplesSent += this.chunkSize;
+        this.port.postMessage(
+          { pcm: out.buffer, samplesSent: this.samplesSent },
+          [out.buffer],
+        );
+        this.bufferIdx = 0;
+      }
+      pos += this.ratio;
+    }
+    this.lastSample = mono[mono.length - 1];
+    this.fractional = pos - mono.length;
+    return true;
+  }
+}
+registerProcessor("aai-pcm16-encoder", Pcm16EncoderProcessor);
+`;
+const PCM16_ENCODER_PROCESSOR_NAME = "aai-pcm16-encoder";
+
+const DEFAULT_TARGET_RATE = 16_000;
+const DEFAULT_CHUNK_MS = 50;
+const MIC_CHANNEL = "mic";
+const SYSTEM_CHANNEL = "system";
+/**
+ * Browser-only adapter that pumps two `MediaStream`s into a `StreamingTranscriber`
+ * configured for dual-channel mode. Each `MediaStream` runs through its own
+ * `pcm16-encoder` AudioWorklet (resample to `targetSampleRate`, encode to Int16
+ * PCM); each PCM chunk is forwarded via `transcriber.sendAudio(pcm, { channel })`.
+ *
+ * All dual-channel orchestration (mixing, VAD, per-word attribution) lives inside
+ * `StreamingTranscriber` — this class is a pure I/O adapter. Non-browser runtimes
+ * can replicate its job by pushing tagged PCM into `transcriber.sendAudio` directly.
+ *
+ * Caller responsibilities:
+ * - **Echo cancellation** is set at `getUserMedia` time (`audio: { echoCancellation: true }`).
+ * - **System-audio capture** is platform-dependent. Chrome's `getDisplayMedia({ audio: true })`
+ *   captures tab audio (and on Windows, full system audio when sharing the whole screen).
+ *   macOS requires a virtual loopback driver (e.g. BlackHole) to expose system audio at all.
+ * - **Token auth.** Construct the transcriber with `token` — API-key auth is unsupported in browsers.
+ * - **Stream ownership.** `stop()` tears down the AudioContext but does NOT stop the
+ *   `MediaStreamTrack`s passed in — callers own those.
+ */
+class DualChannelCapture {
+    constructor(params) {
+        this.running = false;
+        if (typeof globalThis.AudioContext === "undefined") {
+            throw new BrowserOnlyError();
+        }
+        this.params = {
+            micStream: params.micStream,
+            systemStream: params.systemStream,
+            transcriber: params.transcriber,
+            targetSampleRate: params.targetSampleRate ?? DEFAULT_TARGET_RATE,
+        };
+    }
+    on(event, listener) {
+        if (event === "error")
+            this.errorListener = listener;
+    }
+    /**
+     * Wire the capture pipeline and start pumping tagged PCM into the transcriber.
+     * The transcriber must already be connected. Returns once the worklet is
+     * registered and the audio graph is live.
+     */
+    async start() {
+        if (this.running) {
+            throw new Error("DualChannelCapture already started");
+        }
+        this.context = new AudioContext();
+        const blob = new Blob([pcm16EncoderWorkletSource], {
+            type: "application/javascript",
+        });
+        const url = URL.createObjectURL(blob);
+        try {
+            await this.context.audioWorklet.addModule(url);
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+        this.micSource = this.context.createMediaStreamSource(this.params.micStream);
+        this.sysSource = this.context.createMediaStreamSource(this.params.systemStream);
+        this.micEncoder = this.makeEncoder(MIC_CHANNEL);
+        this.sysEncoder = this.makeEncoder(SYSTEM_CHANNEL);
+        this.micSource.connect(this.micEncoder);
+        this.sysSource.connect(this.sysEncoder);
+        this.running = true;
+    }
+    makeEncoder(channel) {
+        const node = new AudioWorkletNode(this.context, PCM16_ENCODER_PROCESSOR_NAME, {
+            numberOfInputs: 1,
+            numberOfOutputs: 0,
+            channelCount: 1,
+            channelCountMode: "explicit",
+            channelInterpretation: "speakers",
+            processorOptions: {
+                targetRate: this.params.targetSampleRate,
+                chunkMs: DEFAULT_CHUNK_MS,
+            },
+        });
+        node.port.onmessage = (e) => {
+            try {
+                this.params.transcriber.sendAudio(e.data.pcm, { channel });
+            }
+            catch (err) {
+                this.errorListener?.(err);
+            }
+        };
+        return node;
+    }
+    /**
+     * Tear down internal nodes and close the AudioContext. Does NOT stop the
+     * caller-provided MediaStream tracks — they remain available for preview UI,
+     * recording, etc. Idempotent.
+     */
+    async stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        try {
+            this.micEncoder?.port.close();
+            this.sysEncoder?.port.close();
+            this.micEncoder?.disconnect();
+            this.sysEncoder?.disconnect();
+            this.micSource?.disconnect();
+            this.sysSource?.disconnect();
+        }
+        catch {
+            // Disconnecting already-disconnected nodes throws in some browsers; ignore.
+        }
+        if (this.context && this.context.state !== "closed") {
+            await this.context.close();
+        }
+        this.context = undefined;
+        this.micSource = undefined;
+        this.sysSource = undefined;
+        this.micEncoder = undefined;
+        this.sysEncoder = undefined;
+    }
+}
+
+/**
+ * Linear-interpolation resampler for streaming Float32 audio. Stateful across
+ * `process()` calls so chunk boundaries don't introduce phase discontinuities:
+ * the last input sample and a fractional read position are carried over.
+ *
+ * Linear interpolation is good enough for ASR ingest — the downstream
+ * StreamingTranscriber band-limits at the target rate anyway, and a polyphase
+ * filter would be overkill in the AudioWorklet hot path. If a customer needs
+ * higher quality they can supply their own VadDetector + bypass the encoder.
+ */
+class LinearResampler {
+    constructor(sourceRate, targetRate) {
+        this.sourceRate = sourceRate;
+        this.targetRate = targetRate;
+        this.lastSample = 0;
+        this.fractional = 0;
+        if (sourceRate <= 0 || targetRate <= 0) {
+            throw new Error("sourceRate and targetRate must be positive");
+        }
+        this.ratio = sourceRate / targetRate;
+    }
+    process(input) {
+        if (this.sourceRate === this.targetRate) {
+            return input;
+        }
+        // Worst-case output length; we'll slice to actual.
+        const out = new Float32Array(Math.ceil(input.length / this.ratio) + 1);
+        let outIdx = 0;
+        let pos = this.fractional;
+        while (pos < input.length) {
+            const i = Math.floor(pos);
+            const frac = pos - i;
+            const a = i === 0 ? this.lastSample : input[i - 1];
+            const b = input[i];
+            out[outIdx++] = a + (b - a) * frac;
+            pos += this.ratio;
+        }
+        this.lastSample = input[input.length - 1] ?? this.lastSample;
+        this.fractional = pos - input.length;
+        return out.subarray(0, outIdx);
+    }
+    reset() {
+        this.lastSample = 0;
+        this.fractional = 0;
+    }
+}
+/** Convert Float32 PCM (-1..1) to little-endian Int16 PCM. */
+function float32ToPcm16(input) {
+    const out = new ArrayBuffer(input.length * 2);
+    const view = new DataView(out);
+    for (let i = 0; i < input.length; i++) {
+        const clamped = Math.max(-1, Math.min(1, input[i]));
+        view.setInt16(i * 2, clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff, true);
+    }
+    return out;
+}
+
+export { BrowserOnlyError, DualChannelCapture, EnergyVad, LinearResampler, RealtimeService, RealtimeTranscriber, StreamingServiceFactory, StreamingTranscriber, StreamingTranscriberFactory, VadTimeline, attributeTurn, attributeWord, float32ToPcm16, rollUpTurnChannel };