@pipecat-ai/moq-transport 0.1.0

package/dist/index.js

@@ -0,0 +1,574 @@
+var $9t2yL$moqjson = require("@moq/json");
+var $9t2yL$moqnet = require("@moq/net");
+var $9t2yL$moqpublish = require("@moq/publish");
+var $9t2yL$moqsignals = require("@moq/signals");
+var $9t2yL$moqwatch = require("@moq/watch");
+var $9t2yL$pipecataiclientjs = require("@pipecat-ai/client-js");
+
+
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
+      return;
+    }
+
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
+
+  return dest;
+}
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+var $c3a8005c91f7c1e1$exports = {};
+
+$parcel$export($c3a8005c91f7c1e1$exports, "MoqTransport", () => $c3a8005c91f7c1e1$export$739cde4b077543d1);
+/*
+ * Copyright (c) 2024-2026, Daily
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */ 
+
+
+
+
+
+const $c3a8005c91f7c1e1$var$DEFAULT_NAMESPACE = "pipecat";
+const $c3a8005c91f7c1e1$var$DEFAULT_CLIENT_ID = "client0";
+const $c3a8005c91f7c1e1$var$DEFAULT_BOT_ID = "bot0";
+const $c3a8005c91f7c1e1$var$DEFAULT_TRANSCRIPT_TRACK = "transcript.json.z";
+// Bounded jitter buffer on the audio decoder. Lower = more interactive
+// but more drops on bad networks. Matches the bot's audio_in_max_latency_ms
+// in spirit (each side enforces its own deadline).
+const $c3a8005c91f7c1e1$var$DEFAULT_AUDIO_LATENCY_MS = 80;
+// Latency ceiling for buffered TTS playback (ms). A finite cap (vs
+// uncapped) because the player's group/jitter buffer needs a concrete
+// maximum span to retain before dropping. The bot paces its writes a
+// little under this (~25s, see the Python transport's
+// `audio_out_max_buffer_ms`) so the producer self-limits below this drop
+// ceiling and the player never actually has to drop.
+const $c3a8005c91f7c1e1$var$DEFAULT_AUDIO_BUFFER_MAX_MS = 30000;
+// Sample rate we pin on the publish-side Opus encoder. Opus only supports
+// {8, 12, 16, 24, 48} kHz; 48 kHz is the upstream default and what most
+// browsers report as the mic's native rate. The bot reads this from our
+// catalog and resamples to its `audio_in_sample_rate` after decode, so we
+// don't need to match it exactly — but pinning it keeps the catalog
+// unambiguous.
+const $c3a8005c91f7c1e1$var$DEFAULT_AUDIO_SAMPLE_RATE = 48000;
+function $c3a8005c91f7c1e1$var$applyDefaults(opts) {
+    return {
+        relayUrl: opts.relayUrl,
+        serverCertificateHashes: opts.serverCertificateHashes,
+        clientId: opts.clientId ?? $c3a8005c91f7c1e1$var$DEFAULT_CLIENT_ID,
+        botId: opts.botId ?? $c3a8005c91f7c1e1$var$DEFAULT_BOT_ID,
+        namespace: opts.namespace ?? $c3a8005c91f7c1e1$var$DEFAULT_NAMESPACE,
+        transcriptTrack: opts.transcriptTrack ?? $c3a8005c91f7c1e1$var$DEFAULT_TRANSCRIPT_TRACK,
+        audioLatencyMs: opts.audioLatencyMs ?? $c3a8005c91f7c1e1$var$DEFAULT_AUDIO_LATENCY_MS,
+        audioBufferMaxMs: opts.audioBufferMaxMs ?? $c3a8005c91f7c1e1$var$DEFAULT_AUDIO_BUFFER_MAX_MS,
+        audioSampleRate: opts.audioSampleRate ?? $c3a8005c91f7c1e1$var$DEFAULT_AUDIO_SAMPLE_RATE
+    };
+}
+function $c3a8005c91f7c1e1$var$isMoqStartResponse(value) {
+    return "moq" in value;
+}
+/** Decode the bot's base64 SHA-256 cert hash into the ArrayBuffer shape
+ *  ``WebTransport.serverCertificateHashes`` expects. */ function $c3a8005c91f7c1e1$var$decodeCertHash(b64) {
+    const bin = atob(b64);
+    const bytes = new Uint8Array(bin.length);
+    for(let i = 0; i < bin.length; i++)bytes[i] = bin.charCodeAt(i);
+    return bytes.buffer;
+}
+class $c3a8005c91f7c1e1$export$739cde4b077543d1 extends (0, $9t2yL$pipecataiclientjs.Transport) {
+    constructor(options){
+        super();
+        // Connection + reactive root.
+        this._reload = null;
+        this._signals = null;
+        // Publish side (mic → bot).
+        this._publishBroadcast = null;
+        this._microphone = null;
+        // RTVI JSON side-channel from client → bot, symmetric with the bot's
+        // outbound `transcript` track. Published as a lossless `@moq/json`
+        // append-stream (compression on); `sendMessage` appends each RTVI
+        // message and the bot's `_forward_peer_transcript` on the Python side
+        // drains it. The stream Producer binds to a single track with no
+        // built-in fan-out, and `publishTrack` serves each subscriber its own
+        // track, so we hold one Producer per subscription (`_transcriptOut`)
+        // and replay the message log (`_transcriptLog`) into each — so a bot
+        // that subscribes late still gets every message, in order.
+        this._transcriptOut = null;
+        this._transcriptLog = null;
+        this._micEnabled = new (0, $9t2yL$moqsignals.Signal)(true);
+        this._micConstraints = new (0, $9t2yL$moqsignals.Signal)(undefined);
+        this._preferredMicId = new (0, $9t2yL$moqsignals.Signal)(undefined);
+        // Encoder sample rate is wired into the catalog the bot reads. We
+        // expose this as a Signal so `_connect` can update it from the resolved
+        // options at connect time.
+        this._audioSampleRate = new (0, $9t2yL$moqsignals.Signal)(undefined);
+        // Watch side (bot → playback). Buffered playback via @moq/watch:
+        // Broadcast -> Audio.Source -> Decoder -> Emitter, with `Sync.latencyMax`
+        // letting faster-than-real-time TTS build up instead of the player
+        // skipping ahead, and `reset()` flushing the buffer on interruption.
+        this._watchBroadcast = null;
+        this._sync = null;
+        this._audioSource = null;
+        this._audioDecoder = null;
+        this._audioEmitter = null;
+        this._moqOptions = $c3a8005c91f7c1e1$var$applyDefaults(options);
+        this._state = "disconnected";
+    }
+    // --------------------------------------------------------------------
+    // Lifecycle
+    // --------------------------------------------------------------------
+    initialize(options, messageHandler) {
+        this._options = options;
+        this._callbacks = options.callbacks ?? {};
+        this._onMessage = messageHandler;
+        this.state = "initialized";
+    }
+    async initDevices() {
+        // Spin up the Microphone with permission requested so labels are
+        // available for the picker before the user clicks Connect. Real
+        // capture constraints (incl. sample rate) get applied in `_connect`
+        // once we have the resolved options.
+        if (!this._microphone) this._microphone = new $9t2yL$moqpublish.Source.Microphone({
+            enabled: this._micEnabled,
+            constraints: this._micConstraints,
+            device: {
+                preferred: this._preferredMicId
+            }
+        });
+        this._microphone.device.requestPermission();
+    }
+    _validateConnectionParams(connectParams) {
+        if (connectParams === undefined || connectParams === null) return this._optionsAsInput();
+        if (typeof connectParams !== "object") throw new (0, $9t2yL$pipecataiclientjs.RTVIError)("MoqTransport connect params must be an object");
+        // The bot's `/start` response is `{ moq: {...} }`, not already-shaped
+        // `MoqTransportOptions` — unwrap and decode it here so apps can pass
+        // the raw response straight through with no transport-specific glue.
+        if ($c3a8005c91f7c1e1$var$isMoqStartResponse(connectParams)) {
+            const { moq: moq } = connectParams;
+            if (!moq) throw new (0, $9t2yL$pipecataiclientjs.RTVIError)("MoqTransport connect params did not include `moq` config (server may not be running with `-t moq`)");
+            return {
+                ...this._optionsAsInput(),
+                relayUrl: moq.relayUrl,
+                clientId: moq.clientId,
+                botId: moq.botId,
+                namespace: moq.namespace,
+                transcriptTrack: moq.transcriptTrack,
+                serverCertificateHashes: moq.certHash ? [
+                    {
+                        algorithm: "sha-256",
+                        value: $c3a8005c91f7c1e1$var$decodeCertHash(moq.certHash)
+                    }
+                ] : undefined
+            };
+        }
+        return {
+            ...this._optionsAsInput(),
+            ...connectParams
+        };
+    }
+    /** Return the resolved options re-shaped to the public input type
+     *  (used when merging with connect-time params). */ _optionsAsInput() {
+        return {
+            ...this._moqOptions
+        };
+    }
+    async _connect(connectParams) {
+        const merged = connectParams ? {
+            ...this._moqOptions,
+            ...$c3a8005c91f7c1e1$var$applyDefaults({
+                ...this._moqOptions,
+                ...connectParams
+            })
+        } : this._moqOptions;
+        if (!merged.relayUrl) throw new (0, $9t2yL$pipecataiclientjs.RTVIError)("MoqTransport requires `relayUrl`");
+        this._moqOptions = merged;
+        this.state = "connecting";
+        let url;
+        try {
+            url = new URL(merged.relayUrl);
+        } catch (err) {
+            this.state = "error";
+            throw new (0, $9t2yL$pipecataiclientjs.RTVIError)(`MoqTransport invalid relayUrl ${JSON.stringify(merged.relayUrl)}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // @moq/net narrows `algorithm` to the literal `"sha-256"`, while
+        // the browser's `WebTransportHash` types it as `string`. Cast at
+        // the boundary; SHA-256 is the only algorithm WebTransport accepts.
+        const webtransport = merged.serverCertificateHashes ? {
+            serverCertificateHashes: merged.serverCertificateHashes.flatMap((h)=>h.value ? [
+                    {
+                        algorithm: "sha-256",
+                        value: h.value
+                    }
+                ] : [])
+        } : undefined;
+        // Reload auto-reconnects on disconnect; Publish.Broadcast and
+        // Watch.Broadcast both react to its `established` signal.
+        this._reload = new $9t2yL$moqnet.Connection.Reload({
+            enabled: new (0, $9t2yL$moqsignals.Signal)(true),
+            url: new (0, $9t2yL$moqsignals.Signal)(url),
+            webtransport: webtransport
+        });
+        // One reactive root for status mirroring. Connect/Watch are
+        // self-driving via their own internal effects.
+        this._signals = new (0, $9t2yL$moqsignals.Effect)();
+        this._signals.run((eff)=>{
+            const status = eff.get(this._reload.status);
+            if (status === "connected") {
+                if (this._state === "connecting") this.state = "connected";
+            } else if (status === "connecting") this.state = "connecting";
+            else if (status === "disconnected") {
+                if (this._state !== "disconnecting" && this._state !== "disconnected") this.state = "disconnected";
+            }
+        });
+        const ourPath = $9t2yL$moqnet.Path.from(merged.namespace, merged.clientId);
+        const botPath = $9t2yL$moqnet.Path.from(merged.namespace, merged.botId);
+        // ----------------------------------------------------------------
+        // Publish — Microphone owns getUserMedia, device selection, and
+        // produces a reactive `source` signal that Publish.Broadcast
+        // consumes. Constraints (channelCount:1, sampleRate) and preferred
+        // deviceId flow through the signals we hold a reference to, so
+        // updateMic() re-routes audio without re-creating the broadcast.
+        // The encoder's sampleRate Signal pins what the catalog advertises.
+        // ----------------------------------------------------------------
+        this._micConstraints.set({
+            channelCount: {
+                exact: 1
+            },
+            sampleRate: {
+                ideal: merged.audioSampleRate
+            },
+            echoCancellation: true,
+            noiseSuppression: true
+        });
+        this._audioSampleRate.set(merged.audioSampleRate);
+        if (!this._microphone) this._microphone = new $9t2yL$moqpublish.Source.Microphone({
+            enabled: this._micEnabled,
+            constraints: this._micConstraints,
+            device: {
+                preferred: this._preferredMicId
+            }
+        });
+        this._publishBroadcast = new $9t2yL$moqpublish.Broadcast({
+            connection: this._reload.established,
+            enabled: new (0, $9t2yL$moqsignals.Signal)(true),
+            name: new (0, $9t2yL$moqsignals.Signal)(ourPath),
+            audio: {
+                source: this._microphone.source,
+                enabled: this._micEnabled,
+                sampleRate: this._audioSampleRate
+            }
+        });
+        // Client-side transcript: `sendMessage` appends each RTVI message to
+        // a lossless JSON append-stream. `publishTrack` hands us a fresh track
+        // per subscription (only one, in the normal single-bot flow), so we
+        // spin up a `Json.Stream.Producer` per subscriber and replay the
+        // message log into it — a bot that subscribes after we've already sent
+        // messages still gets the full log, in order. The bot subscribes to
+        // this track by its name — same convention as the bot's own transcript
+        // track — so no catalog entry is needed.
+        this._transcriptLog = [];
+        this._transcriptOut = new Set();
+        this._publishBroadcast.publishTrack(merged.transcriptTrack, (track, effect)=>{
+            const producer = new $9t2yL$moqjson.Stream.Producer(track, {
+                compression: true
+            });
+            for (const msg of this._transcriptLog ?? [])producer.append(msg);
+            this._transcriptOut?.add(producer);
+            effect.cleanup(()=>{
+                this._transcriptOut?.delete(producer);
+                producer.finish();
+            });
+        });
+        // Log the mic settings the browser actually granted, so we can see
+        // when a UA ignores the constraint (e.g. macOS often pins 48k
+        // regardless of `sampleRate.ideal`).
+        this._signals.run((eff)=>{
+            const src = eff.get(this._microphone.source);
+            if (!src) return;
+            const track = "track" in src ? src.track : src;
+            const s = track.getSettings();
+            console.log(`[MoqTransport] publish: requested=${merged.audioSampleRate}Hz, ` + `mic granted=${s.sampleRate}Hz, channels=${s.channelCount}, ` + `deviceId=${s.deviceId}`);
+        });
+        // ----------------------------------------------------------------
+        // Watch — Broadcast handles catalog discovery and rendition
+        // tracking; Audio.Source picks the active audio rendition;
+        // Audio.Decoder runs the WebCodecs decode loop and feeds an
+        // AudioWorklet ring buffer; Audio.Emitter routes that to the
+        // speakers. `Sync.latencyMax` lets faster-than-real-time TTS build
+        // up a buffer instead of the player skipping ahead; `reset()`
+        // (invoked on `user-started-speaking`) flushes it on interruption.
+        // We also tap Decoder.root → MediaStreamAudioDestinationNode so
+        // tracks().bot.audio returns a MediaStreamTrack.
+        //
+        // `catalogFormat: "hang"` is pinned because the pipecat bot publishes
+        // a hang-format catalog (camelCase `sampleRate`). The auto-detector
+        // would also land on "hang" here (no suffix on the broadcast name,
+        // and hang is the DEFAULT_FORMAT) but pinning removes ambiguity if
+        // a future publisher adds a suffix or a different default ships.
+        // ----------------------------------------------------------------
+        this._watchBroadcast = new $9t2yL$moqwatch.Broadcast({
+            connection: this._reload.established,
+            enabled: new (0, $9t2yL$moqsignals.Signal)(true),
+            name: new (0, $9t2yL$moqsignals.Signal)(botPath),
+            catalogFormat: new (0, $9t2yL$moqsignals.Signal)("hang")
+        });
+        // Latency range: floor = interactive jitter buffer (audioLatencyMs),
+        // ceiling = how much faster-than-real-time TTS the player will hold
+        // before dropping (audioBufferMaxMs). A number-typed max opens the
+        // buffer; "real-time" collapses to the floor (skip-ahead behavior).
+        const sync = new $9t2yL$moqwatch.Sync({
+            connection: this._reload.established,
+            latency: new (0, $9t2yL$moqsignals.Signal)({
+                min: merged.audioLatencyMs,
+                max: merged.audioBufferMaxMs === "real-time" ? "real-time" : merged.audioBufferMaxMs
+            })
+        });
+        this._sync = sync;
+        this._audioSource = new $9t2yL$moqwatch.Audio.Source(sync, {
+            broadcast: this._watchBroadcast
+        });
+        this._audioDecoder = new $9t2yL$moqwatch.Audio.Decoder(this._audioSource, {
+            enabled: new (0, $9t2yL$moqsignals.Signal)(true)
+        });
+        this._audioEmitter = new $9t2yL$moqwatch.Audio.Emitter(this._audioDecoder);
+        // Bridge Decoder.root (AudioNode) → MediaStreamTrack for tracks().bot.audio.
+        this._signals.run((eff)=>{
+            const ctx = eff.get(this._audioDecoder.context);
+            const root = eff.get(this._audioDecoder.root);
+            if (!ctx || !root) return;
+            const dest = ctx.createMediaStreamDestination();
+            root.connect(dest);
+            this._botAudioTrack = dest.stream.getAudioTracks()[0];
+            eff.cleanup(()=>{
+                try {
+                    root.disconnect(dest);
+                } catch  {
+                // best-effort.
+                }
+                this._botAudioTrack?.stop();
+                this._botAudioTrack = undefined;
+            });
+        });
+        // Log the bot's announced audio config + the AudioContext rate we
+        // ended up at. If these disagree the voice will play at the wrong
+        // pitch — the catalog drives the AudioContext, so a mismatch means
+        // either a parser bug or the bot is advertising a rate that doesn't
+        // match its actual Opus stream.
+        this._signals.run((eff)=>{
+            const config = eff.get(this._audioSource.config);
+            const ctx = eff.get(this._audioDecoder.context);
+            if (!config && !ctx) return;
+            console.log(`[MoqTransport] consume: catalog codec=${config?.codec}, ` + `catalog sampleRate=${config?.sampleRate}Hz, ` + `catalog channels=${config?.numberOfChannels}, ` + `AudioContext rate=${ctx?.sampleRate}Hz`);
+        });
+        // Transcript — a lossless JSON append-stream over a single track. We
+        // re-subscribe on each (re)connect; @moq/json's stream Consumer yields
+        // every appended record in order, losslessly.
+        this._signals.run((eff)=>{
+            const conn = eff.get(this._reload.established);
+            if (!conn) return;
+            const botBroadcast = conn.consume(botPath);
+            const track = botBroadcast.subscribe(merged.transcriptTrack, 0);
+            const consumer = new $9t2yL$moqjson.Stream.Consumer(track, {
+                compression: true
+            });
+            const ac = new AbortController();
+            this._drainTranscript(consumer, ac.signal).catch((e)=>{
+                if (!ac.signal.aborted) console.warn("MoqTransport bot-transcript loop:", e);
+            });
+            eff.cleanup(()=>{
+                ac.abort();
+                try {
+                    track.close();
+                } catch  {
+                // best-effort.
+                }
+            });
+        });
+    }
+    async _disconnect() {
+        if (this._state === "disconnected") return;
+        this.state = "disconnecting";
+        try {
+            this._audioEmitter?.close();
+            this._audioDecoder?.close();
+            this._audioSource?.close();
+            this._sync?.close();
+            this._watchBroadcast?.close();
+            // Each producer's own effect.cleanup (registered in the `publishTrack`
+            // callback above) already calls producer.finish() when this cascades
+            // through the broadcast's internal effect scope — no need to also
+            // finish them explicitly here.
+            this._publishBroadcast?.close();
+            this._microphone?.close();
+            this._signals?.close();
+            this._reload?.close();
+        } finally{
+            this._audioEmitter = null;
+            this._audioDecoder = null;
+            this._audioSource = null;
+            this._sync = null;
+            this._watchBroadcast = null;
+            this._transcriptOut = null;
+            this._transcriptLog = null;
+            this._publishBroadcast = null;
+            this._microphone = null;
+            this._signals = null;
+            this._reload = null;
+            this.state = "disconnected";
+            // Fire the SDK's disconnected callback. `state = "disconnected"`
+            // above already triggers `onTransportStateChanged`, but the SDK
+            // wires UI teardown (voice-ui-kit's connection-state hook, the
+            // `Disconnected` event, message-dispatcher cleanup) through
+            // `onDisconnected` — without this call the transport goes idle
+            // but the UI stays stuck in "connected" and never restores its
+            // "Connect" button. Matches the pattern used by
+            // small-webrtc-transport, openai-realtime-webrtc-transport, and
+            // gemini-live-websocket-transport.
+            this._callbacks?.onDisconnected?.();
+        }
+    }
+    sendReadyMessage() {
+        // Flip transport state to `ready` and dispatch the RTVI `client-ready`
+        // message on the client→bot transcript track so the bot's RTVIProcessor
+        // can negotiate protocol version. Mirrors the pattern used by
+        // small-webrtc-transport and daily-transport.
+        this.state = "ready";
+        this.sendMessage((0, $9t2yL$pipecataiclientjs.RTVIMessage).clientReady());
+    }
+    // --------------------------------------------------------------------
+    // State
+    // --------------------------------------------------------------------
+    get state() {
+        return this._state;
+    }
+    set state(next) {
+        if (this._state === next) return;
+        this._state = next;
+        this._callbacks?.onTransportStateChanged?.(next);
+    }
+    // --------------------------------------------------------------------
+    // Devices
+    // --------------------------------------------------------------------
+    async getAllMics() {
+        return this._microphone?.device.available.peek() ?? [];
+    }
+    async getAllCams() {
+        return [];
+    }
+    async getAllSpeakers() {
+        return [];
+    }
+    updateMic(micId) {
+        this._preferredMicId.set(micId);
+    }
+    updateCam(_camId) {}
+    updateSpeaker(_speakerId) {}
+    get selectedMic() {
+        const id = this._microphone?.device.active.peek();
+        if (!id) return {};
+        return this._microphone?.device.available.peek()?.find((d)=>d.deviceId === id) ?? {};
+    }
+    get selectedCam() {
+        return {};
+    }
+    get selectedSpeaker() {
+        return {};
+    }
+    enableMic(enable) {
+        this._micEnabled.set(enable);
+    }
+    enableCam(_enable) {}
+    enableScreenShare(_enable) {}
+    get isCamEnabled() {
+        return false;
+    }
+    get isMicEnabled() {
+        return this._micEnabled.get();
+    }
+    get isSharingScreen() {
+        return false;
+    }
+    // --------------------------------------------------------------------
+    // Messaging + tracks
+    // --------------------------------------------------------------------
+    sendMessage(message) {
+        if (!this._transcriptOut || !this._transcriptLog) {
+            console.warn("[MoqTransport] sendMessage called before connect; dropping", message);
+            return;
+        }
+        // Append to the lossless stream. Keep a log too, so a bot that
+        // subscribes after this point is replayed every message in order
+        // (see the `publishTrack` serve callback above).
+        this._transcriptLog.push(message);
+        for (const producer of this._transcriptOut)producer.append(message);
+    }
+    tracks() {
+        const localSource = this._microphone?.source.peek();
+        const localAudio = localSource && "track" in localSource ? localSource.track : localSource;
+        return {
+            local: localAudio ? {
+                audio: localAudio
+            } : {},
+            bot: this._botAudioTrack ? {
+                audio: this._botAudioTrack
+            } : {}
+        };
+    }
+    // --------------------------------------------------------------------
+    // Internals — transcript
+    // --------------------------------------------------------------------
+    /** Pull RTVI messages off the @moq/json stream consumer and hand each
+     *  one to `PipecatClient` via `_onMessage`. The handler resolves the
+     *  SDK's connect promise when bot-ready arrives. */ async _drainTranscript(consumer, signal) {
+        for(;;){
+            const message = await consumer.next();
+            if (!message || signal.aborted) break;
+            if (typeof message !== "object") continue;
+            // Intra-transport shutdown signal from the bot: bot is about to
+            // close its MoQ session. Disable auto-reconnect, tear down the
+            // audio decoder + subscribers on our side while WebTransport is
+            // still healthy — without this the connection just vanishes
+            // underneath Chrome's WebCodecs decoder and can crash the
+            // renderer. Not an RTVI event; don't forward it to `_onMessage`.
+            const label = message.label;
+            const type = message.type;
+            if (label === "moq-transport" && type === "session-ending") {
+                console.log("[MoqTransport] bot signaled session-ending \u2014 closing cleanly");
+                // Fire-and-forget; we're returning from the drain loop right
+                // after, and _disconnect() aborts the consumer that owns us.
+                this._disconnect();
+                return;
+            }
+            // Interruption: the user started talking, so flush the
+            // already-buffered TTS for the bot's previous utterance instead
+            // of letting it drain. With the bot writing faster than
+            // real-time, that buffer can be seconds long.
+            if (type === "user-started-speaking") this._resetBotAudio();
+            this._onMessage?.(message);
+        }
+    }
+    /** Flush buffered bot audio and re-anchor playback at an utterance
+     *  boundary. Called on interruption (`user-started-speaking`) so the
+     *  already-buffered TTS for the previous utterance stops immediately
+     *  instead of draining: re-anchor the sync reference and flush the
+     *  decoder's ring buffer. */ _resetBotAudio() {
+        this._sync?.reset();
+        this._audioDecoder?.reset();
+    }
+}
+$c3a8005c91f7c1e1$export$739cde4b077543d1.SERVICE_NAME = "moq-transport";
+
+
+$parcel$exportWildcard(module.exports, $c3a8005c91f7c1e1$exports);
+
+
+//# sourceMappingURL=index.js.map