assemblyai 4.33.3 → 4.34.4

package/dist/streaming.mjs

@@ -1,5 +1,18 @@
 import ws from 'ws';
 
+/**
+ * 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";
+    }
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -17,6 +30,18 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 function __awaiter(thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -95,9 +120,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.
  */
@@ -292,11 +366,11 @@ class RealtimeTranscriber {
                         const sessionTerminatedPromise = new Promise((resolve) => {
                             this.sessionTerminatedResolve = resolve;
                         });
-                        this.socket.send(terminateSessionMessage);
+                        this.socket.send(terminateSessionMessage$1);
                         yield sessionTerminatedPromise;
                     }
                     else {
-                        this.socket.send(terminateSessionMessage);
+                        this.socket.send(terminateSessionMessage$1);
                     }
                 }
                 if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.removeAllListeners)
@@ -314,4 +388,1202 @@ class RealtimeTranscriber {
 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 = {}) {
+        var _a, _b, _c, _d;
+        this.hangoverRemaining = 0;
+        this.thresholdRatio = (_a = params.thresholdRatio) !== null && _a !== void 0 ? _a : 3.0;
+        this.noiseFloorAlpha = (_b = params.noiseFloorAlpha) !== null && _b !== void 0 ? _b : 0.05;
+        this.hangoverFrames = (_c = params.hangoverFrames) !== null && _c !== void 0 ? _c : 10;
+        this.initialNoiseFloor = (_d = params.initialNoiseFloor) !== null && _d !== void 0 ? _d : 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) {
+    var _a;
+    const scores = new Map();
+    for (const f of frames) {
+        if (!f.active)
+            continue;
+        scores.set(f.channel, ((_a = scores.get(f.channel)) !== null && _a !== void 0 ? _a : 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) {
+    var _a;
+    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, ((_a = totals.get(w.channel)) !== null && _a !== void 0 ? _a : 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) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        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 = Object.assign(Object.assign({}, 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 = (_a = params.channelAttribution) !== null && _a !== void 0 ? _a : {};
+            this.attributionParams = {
+                dominanceRatio: (_b = att.dominanceRatio) !== null && _b !== void 0 ? _b : 4,
+                timelineWindowMs: (_c = att.timelineWindowMs) !== null && _c !== void 0 ? _c : 30000,
+                createVad: (_d = att.createVad) !== null && _d !== void 0 ? _d : (() => new EnergyVad()),
+                flushIntervalMs: (_e = att.flushIntervalMs) !== null && _e !== void 0 ? _e : 50,
+                resolveUnknownChannelsMethod: (_f = att.resolveUnknownChannelsMethod) !== null && _f !== void 0 ? _f : "window",
+                resolutionWindowWords: (_g = att.resolutionWindowWords) !== null && _g !== void 0 ? _g : 2,
+                speakerHistoryMinRmsEvidence: (_h = att.speakerHistoryMinRmsEvidence) !== null && _h !== void 0 ? _h : 0.5,
+                speakerHistoryDominanceRatio: (_j = att.speakerHistoryDominanceRatio) !== null && _j !== void 0 ? _j : 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() {
+        var _a, _b;
+        const url = new URL((_a = this.params.websocketBaseUrl) !== null && _a !== void 0 ? _a : "");
+        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 = (_b = this.params.minTurnSilence) !== null && _b !== void 0 ? _b : 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 {
+                this.socket = factory(url.toString(), {
+                    headers: { Authorization: this.apiKey },
+                });
+            }
+            this.socket.binaryType = "arraybuffer";
+            this.socket.onopen = () => { };
+            this.socket.onclose = ({ code, reason }) => {
+                var _a, _b;
+                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;
+                }
+                (_b = (_a = this.listeners).close) === null || _b === void 0 ? void 0 : _b.call(_a, code, reason);
+            };
+            this.socket.onerror = (event) => {
+                var _a, _b, _c, _d;
+                if (event.error)
+                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, event.error);
+                else
+                    (_d = (_c = this.listeners).error) === null || _d === void 0 ? void 0 : _d.call(_c, new Error(event.message));
+            };
+            this.socket.onmessage = ({ data }) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+                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;
+                    }
+                    (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+                    return;
+                }
+                switch (message.type) {
+                    case "Begin": {
+                        resolve(message);
+                        (_d = (_c = this.listeners).open) === null || _d === void 0 ? void 0 : _d.call(_c, 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;
+                            }
+                        }
+                        (_f = (_e = this.listeners).turn) === null || _f === void 0 ? void 0 : _f.call(_e, message);
+                        break;
+                    }
+                    case "SpeechStarted": {
+                        (_h = (_g = this.listeners).speechStarted) === null || _h === void 0 ? void 0 : _h.call(_g, message);
+                        break;
+                    }
+                    case "LLMGatewayResponse": {
+                        (_k = (_j = this.listeners).llmGatewayResponse) === null || _k === void 0 ? void 0 : _k.call(_j, message);
+                        break;
+                    }
+                    case "SpeakerRevision": {
+                        (_m = (_l = this.listeners).speakerRevision) === null || _m === void 0 ? void 0 : _m.call(_l, message);
+                        break;
+                    }
+                    case "Warning": {
+                        const warning = message;
+                        console.warn(`Streaming warning (code=${warning.warning_code}): ${warning.warning}`);
+                        (_p = (_o = this.listeners).warning) === null || _p === void 0 ? void 0 : _p.call(_o, warning);
+                        break;
+                    }
+                    case "Termination": {
+                        (_q = this.sessionTerminatedResolve) === null || _q === void 0 ? void 0 : _q.call(this);
+                        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 === null || options === void 0 ? void 0 : 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) {
+        var _a, _b;
+        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);
+                (_b = (_a = this.listeners).vad) === null || _b === void 0 ? void 0 : _b.call(_a, 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) {
+        var _a, _b;
+        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) {
+                (_b = (_a = this.listeners).error) === null || _b === void 0 ? void 0 : _b.call(_a, 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) {
+        var _a;
+        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, ((_a = tally.get(ch)) !== null && _a !== void 0 ? _a : 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) {
+        var _a;
+        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, ((_a = entry.get(f.channel)) !== null && _a !== void 0 ? _a : 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 } = config, rest = __rest(config, ["min_end_of_turn_silence_when_confident", "min_turn_silence"]);
+        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 !== null && min_turn_silence !== void 0 ? min_turn_silence : min_end_of_turn_silence_when_confident;
+        const message = Object.assign(Object.assign({ 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);
+    }
+    close() {
+        return __awaiter(this, arguments, void 0, function* (waitForSessionTermination = true) {
+            var _a;
+            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);
+                        yield sessionTerminatedPromise;
+                    }
+                    else {
+                        this.socket.send(terminateSessionMessage);
+                    }
+                }
+                if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.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(Object.assign(Object.assign({}, 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: "__SDK_VERSION__" },
+};
+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 || {});
+        }
+    }
+    fetch(input, init) {
+        return __awaiter(this, void 0, void 0, function* () {
+            init = Object.assign(Object.assign({}, DEFAULT_FETCH_INIT), init);
+            let headers = {
+                Authorization: this.params.apiKey,
+                "Content-Type": "application/json",
+            };
+            if (DEFAULT_FETCH_INIT === null || DEFAULT_FETCH_INIT === void 0 ? void 0 : DEFAULT_FETCH_INIT.headers)
+                headers = Object.assign(Object.assign({}, headers), DEFAULT_FETCH_INIT.headers);
+            if (init === null || init === void 0 ? void 0 : init.headers)
+                headers = Object.assign(Object.assign({}, 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 = yield fetch(input, init);
+            if (response.status >= 400) {
+                let json;
+                const text = yield response.text();
+                if (text) {
+                    try {
+                        json = JSON.parse(text);
+                    }
+                    catch (_a) {
+                        /* empty */
+                    }
+                    if (json === null || json === void 0 ? void 0 : json.error)
+                        throw new Error(json.error);
+                    throw new Error(text);
+                }
+                throw new Error(`HTTP Error: ${response.status} ${response.statusText}`);
+            }
+            return response;
+        });
+    }
+    fetchJson(input, init) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.fetch(input, init);
+            return response.json();
+        });
+    }
+}
+
+class StreamingTranscriberFactory extends BaseService {
+    constructor(params) {
+        super(params);
+        this.baseServiceParams = params;
+    }
+    transcriber(params) {
+        const serviceParams = Object.assign({}, params);
+        if (!serviceParams.token && !serviceParams.apiKey) {
+            serviceParams.apiKey = this.baseServiceParams.apiKey;
+        }
+        return new StreamingTranscriber(serviceParams);
+    }
+    createTemporaryToken(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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 = 16000;
+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) {
+        var _a;
+        this.running = false;
+        if (typeof globalThis.AudioContext === "undefined") {
+            throw new BrowserOnlyError();
+        }
+        this.params = {
+            micStream: params.micStream,
+            systemStream: params.systemStream,
+            transcriber: params.transcriber,
+            targetSampleRate: (_a = params.targetSampleRate) !== null && _a !== void 0 ? _a : 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.
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 {
+                yield 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) => {
+            var _a;
+            try {
+                this.params.transcriber.sendAudio(e.data.pcm, { channel });
+            }
+            catch (err) {
+                (_a = this.errorListener) === null || _a === void 0 ? void 0 : _a.call(this, 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.
+     */
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f;
+            if (!this.running)
+                return;
+            this.running = false;
+            try {
+                (_a = this.micEncoder) === null || _a === void 0 ? void 0 : _a.port.close();
+                (_b = this.sysEncoder) === null || _b === void 0 ? void 0 : _b.port.close();
+                (_c = this.micEncoder) === null || _c === void 0 ? void 0 : _c.disconnect();
+                (_d = this.sysEncoder) === null || _d === void 0 ? void 0 : _d.disconnect();
+                (_e = this.micSource) === null || _e === void 0 ? void 0 : _e.disconnect();
+                (_f = this.sysSource) === null || _f === void 0 ? void 0 : _f.disconnect();
+            }
+            catch (_g) {
+                // Disconnecting already-disconnected nodes throws in some browsers; ignore.
+            }
+            if (this.context && this.context.state !== "closed") {
+                yield 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) {
+        var _a;
+        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 = (_a = input[input.length - 1]) !== null && _a !== void 0 ? _a : 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 };