@crestapps/ai-chat-ui 2.0.0-preview.154 → 2.0.0-preview.162

package/dist/realtime-audio.js

@@ -0,0 +1,2236 @@
+/*
+** NOTE: This file is generated by Gulp and should not be edited directly!
+** Any changes made directly to this file will be overwritten next time its asset group is processed by Gulp.
+*/
+
+/*
+ * Shared realtime (speech-to-speech) audio controller for interaction-style chat surfaces.
+ *
+ * Encapsulates the browser side of a realtime voice conversation: PCM16 mic capture and streaming,
+ * PCM playback with volume, the half-duplex echo guard, push-to-talk, the per-device audio settings
+ * popover, and switching the input between text and audio-only when a realtime deployment is selected.
+ *
+ * It is host-agnostic: the host (an MVC inline script or the Blazor chat-interaction Vue app) supplies the
+ * SignalR connection, a sendStart callback (so each surface can address its own hub method/identifier),
+ * element selectors, and a few display hooks. Reused so realtime lives in one place, not one copy per host.
+ *
+ * Usage:
+ *   var controller = window.CoreAIRealtime.attach({
+ *       connection: conn,
+ *       ensureConnected: function () { return startPromise; },     // () => Promise<any>
+ *       sendStart: function (subject, voice, language, silenceMs, vadThreshold) { ... },
+ *       voiceName: 'alloy',
+ *       capableDeployments: ['gpt-realtime'],
+ *       realtimeEnabled: true,
+ *       selectors: { realtimeButton, input, sendButton, micButton, conversationButton, deploymentSelect },
+ *       onActivate: function () { ... },        // realtime session started (host: show transcripts)
+ *       onDeactivate: function () { ... },       // realtime session stopped
+ *       onEnterRealtimeMode: function () { ... } // switched to audio-only (host: stop any STT recording)
+ *   });
+ *   // then route audio to it: controller.receivePcm(bytes)   // from ReceiveAudioChunk 'audio/pcm'
+ */
+(function (window, document) {
+  'use strict';
+
+  var REALTIME_SAMPLE_RATE = 24000;
+
+  // --- Microphone gate --------------------------------------------------------------------------------------
+  //
+  // The outbound mic is silenced unless the user is genuinely speaking, so the model never receives silence,
+  // room noise, or the assistant's echo — which is what stopped it answering itself and stopped the input
+  // transcriber hallucinating phantom "Thank you" turns.
+  //
+  //  - push-to-talk: open only while the key is held;
+  //  - barge-in on: open whenever the user speaks — even over the assistant (interrupts);
+  //  - barge-in off: open only when the user speaks and the assistant is silent (wait your turn).
+  //
+  // There are no user-facing modes or thresholds: everything the gate needs it measures for itself. It tracks
+  // the room's noise floor, and — the part that makes open speakers work — it learns how loud the assistant's
+  // own voice comes back into the microphone after echo cancellation (the echo return level). While the
+  // assistant is audible, only a voice clearly louder than that expected echo counts as the user interrupting;
+  // with a headset the expected echo is the room floor and interruptions are cheap, with loud speakers next to
+  // the microphone it is high and the gate simply waits its turn. Echo cancellation is still the first line of
+  // defence; this is what keeps the model from hearing itself when cancellation is not enough.
+  //
+  // It runs in an AudioWorklet rather than on a requestAnimationFrame loop. rAF is paused for hidden documents,
+  // so the old gate froze in whatever state it held the moment the user switched tabs: stuck closed meant they
+  // were never heard again. The audio thread keeps running regardless of visibility, sees every sample instead
+  // of a 10 ms window sampled 60 times a second, and can hold a look-ahead delay so the gate is already open
+  // when the first consonant arrives.
+  //
+  // Exported as window.CoreAIRealtime.createMicGate so both chat clients share one implementation.
+  var REALTIME_GATE_LOOKAHEAD_MS = 80;
+
+  /*
+   * The gate's decision, as a pure function of the current state and one block of measurements.
+   *
+   * It lives on its own for two reasons. It has to run inside an AudioWorklet, which cannot close over module
+   * scope — so it is stringified into the worklet below rather than duplicated there. And it is the part worth
+   * testing exhaustively: every one of this gate's historical failures (a quiet microphone never opening it, a
+   * loud room's echo opening it, one sentence chopped into several turns) is a rule in here, and each is far
+   * easier to pin down with numbers than with audio.
+   *
+   * `state` is mutated and returned. Callers create it with createGateState().
+   *
+   *   input: { micDb, assistantDb, nowMs, mode }
+   *   mode:  { pushToTalk, pttActive, bargeIn, speechHangoverMs }
+   */
+  function coreAiGateDecide(state, input) {
+    var micDb = input.micDb;
+    var assistantDb = typeof input.assistantDb === 'number' ? input.assistantDb : -100;
+    var nowMs = input.nowMs;
+    var mode = input.mode || {};
+
+    // Elapsed time since the previous decision, so the time constants below mean the same thing whether the
+    // gate runs per 128-sample block on the audio thread or on a 20 ms timer.
+    var dtMs = state.lastMs === null ? 0 : Math.max(0, Math.min(50, nowMs - state.lastMs));
+    state.lastMs = nowMs;
+
+    // "The assistant is speaking" must survive the gaps between its words. Without this hangover the
+    // half-duplex gate re-opened in every inter-word pause and fed the echo tail straight back to the model.
+    if (assistantDb > -50) {
+      state.assistantUntil = nowMs + 400;
+    }
+    var assistantSpeaking = nowMs < state.assistantUntil;
+
+    // Peak-held assistant level. The echo of a word reaches the microphone 50-200 ms after the word was played,
+    // so the expected echo has to be judged against what the assistant was doing a moment ago, not against the
+    // instantaneous level (which is silent between its words). Decays at 20 dB/s.
+    if (assistantDb > state.assistantPeakDb) {
+      state.assistantPeakDb = assistantDb;
+    } else {
+      state.assistantPeakDb = Math.max(-100, state.assistantPeakDb - 0.02 * dtMs);
+    }
+
+    // Adaptive noise floor. It falls to a quieter room quickly, and rises only while the gate is shut and the
+    // assistant is silent — that is, only from audio we have judged is neither speech nor echo.
+    //
+    // Letting it rise during speech makes the gate close on the talker: the estimate climbs towards their own
+    // voice, the level stops clearing floor + margin, and the sentence is cut part-way through.
+    //
+    // Cold start. Digital silence is not a measurement: a capture pipeline delivers a few empty blocks before
+    // the microphone is live (and noise suppression emits exact zeros in a quiet headset), and seeding on
+    // those anchored the floor at the clamp and made the room itself look like speech. The first real block
+    // is not trustworthy either — it may well be the user already talking, and a floor seeded at their own
+    // level meant the gate never opened for them at all. So the seed is the first real block capped at a
+    // typical quiet-room level; the fast downward adaptation below then finds the real floor within a few
+    // hundred milliseconds. (Seeding from the quietest block instead was tried and rejected: block-to-block
+    // level varies by several dB even on steady room noise, so a floor set at the minimum let ordinary noise
+    // peaks open the gate.)
+    if (micDb <= -95) {
+      if (state.floorDb === null) {
+        state.open = false;
+        return state;
+      }
+    } else if (state.floorDb === null) {
+      state.floorDb = Math.min(micDb, -50);
+    }
+    if (micDb < state.floorDb) {
+      state.floorDb += (micDb - state.floorDb) * Math.min(1, 0.0075 * dtMs);
+    } else if (!assistantSpeaking) {
+      // Rising. While the gate is shut this is responsive (~2 s). While it is open the audio is presumed to
+      // be speech and the floor moves slowly (~10 s), because learning from the talker's own voice is what
+      // closed the gate part-way through their sentence — but not so slowly that a steady sound could hold
+      // the gate open indefinitely. Past 10 s the assumption is abandoned altogether: nobody speaks
+      // continuously for that long, so it is ambient noise and the floor tracks it normally.
+      var sustained = state.openSince !== null && nowMs - state.openSince > 10000;
+      var risingPerMs = state.open && !sustained ? 0.0001 : 0.00056;
+      state.floorDb += (micDb - state.floorDb) * Math.min(1, risingPerMs * dtMs);
+    }
+    if (state.floorDb < -75) {
+      state.floorDb = -75;
+    }
+
+    // Echo return level: how loud the assistant comes back into the microphone, relative to its own level,
+    // after echo cancellation has done what it can. Learned only while the assistant is audible and the gate
+    // is shut, i.e. from audio we have judged is not the user. It warms up fast for the first second so the
+    // very first reply is protected, then follows slowly so a user interrupting cannot be mistaken for echo
+    // in the time it takes to confirm them (below). It falls slowly too, so turning the volume down is
+    // noticed within a couple of seconds.
+    if (assistantSpeaking && !state.open && assistantDb > -50 && !mode.pushToTalk) {
+      var erl = micDb - state.assistantPeakDb;
+      if (state.echoReturnDb === null) {
+        state.echoReturnDb = erl;
+      } else {
+        var warm = state.echoLearnedMs < 1000;
+        var ratePerMs = erl > state.echoReturnDb ? warm ? 0.02 : 0.0012 : 0.0006;
+        state.echoReturnDb += (erl - state.echoReturnDb) * Math.min(1, ratePerMs * dtMs);
+      }
+      state.echoLearnedMs += dtMs;
+    }
+
+    // Where the assistant's echo is expected to sit right now, or far below anything if it has never been
+    // heard (a headset).
+    var expectedEchoDb = state.echoReturnDb === null ? -100 : state.assistantPeakDb + state.echoReturnDb;
+    var openThreshold, holdThreshold;
+    if (assistantSpeaking) {
+      // Interrupting: the voice must clearly beat both the room and the expected echo, and be real speech
+      // in absolute terms — echo residual can sit well above a very quiet room's floor without being
+      // anywhere near a voice.
+      openThreshold = Math.max(state.floorDb + 12, expectedEchoDb + 8, -45);
+      holdThreshold = Math.max(state.floorDb + 3, expectedEchoDb + 3);
+    } else {
+      openThreshold = state.floorDb + 9;
+      holdThreshold = state.floorDb + 3;
+    }
+    var hangoverMs = mode.speechHangoverMs || 2000;
+    if (micDb > openThreshold) {
+      if (assistantSpeaking && !state.open) {
+        // An interruption has to be sustained for a moment before it counts. A single loud block over the
+        // assistant is far more often a click, a cough or an echo peak than the user; the look-ahead delay
+        // keeps the opening of a genuine interruption from being lost while we wait.
+        if (state.aboveSince === null) {
+          state.aboveSince = nowMs;
+        }
+        if (nowMs - state.aboveSince >= 250) {
+          state.speakUntil = nowMs + hangoverMs;
+        }
+      } else {
+        // The hangover must outlast the provider's end-of-turn detection. The gate emits digital silence
+        // when it closes, so whichever of the two expires first is what actually ends the user's turn —
+        // and a gate that closes first cuts people off mid-sentence and answers half a question.
+        state.speakUntil = nowMs + hangoverMs;
+      }
+    } else {
+      state.aboveSince = null;
+      if (state.open && micDb > holdThreshold) {
+        // Hysteresis: once open, stay open until the level really settles back towards the floor, so one
+        // sentence is not chopped into several provider turns.
+        state.speakUntil = Math.max(state.speakUntil, nowMs + 250);
+      }
+    }
+    var userActive = nowMs < state.speakUntil;
+    if (!assistantSpeaking && state.wasAssistantSpeaking) {
+      state.listenGraceUntil = nowMs + 1500;
+    }
+    state.wasAssistantSpeaking = assistantSpeaking;
+    state.assistantSpeaking = assistantSpeaking;
+    if (mode.pushToTalk) {
+      state.open = !!mode.pttActive;
+    } else if (mode.bargeIn) {
+      state.open = userActive;
+    } else {
+      state.open = !assistantSpeaking && (userActive || nowMs < state.listenGraceUntil);
+    }
+    if (state.open && state.openSince === null) {
+      state.openSince = nowMs;
+    } else if (!state.open) {
+      state.openSince = null;
+    }
+    return state;
+  }
+  function createGateState() {
+    return {
+      // Null until the first measurement, so the floor starts from the room rather than from a guess.
+      floorDb: null,
+      lastMs: null,
+      speakUntil: 0,
+      assistantUntil: 0,
+      assistantPeakDb: -100,
+      // Null until the assistant has been heard while the gate was shut (never, with a headset).
+      echoReturnDb: null,
+      echoLearnedMs: 0,
+      aboveSince: null,
+      listenGraceUntil: 0,
+      wasAssistantSpeaking: false,
+      assistantSpeaking: false,
+      open: false,
+      openSince: null
+    };
+  }
+
+  // Root-mean-square of a block, in dBFS. RMS (not peak) tracks perceived loudness, and dB is the only scale on
+  // which a fixed "N above the noise floor" rule behaves the same in a quiet room and a loud one.
+  function coreAiRmsDb(block) {
+    if (!block || !block.length) {
+      return -100;
+    }
+    var sum = 0;
+    for (var i = 0; i < block.length; i++) {
+      sum += block[i] * block[i];
+    }
+    var rms = Math.sqrt(sum / block.length);
+    return rms > 1e-7 ? 20 * Math.log10(rms) : -100;
+  }
+
+  // The gate decision itself, as an AudioWorkletProcessor. Registered from a Blob URL so it needs no separate
+  // asset file (and no host-specific path configuration). The decision and level functions are stringified in
+  // rather than rewritten, so the worklet and the fallback below can never disagree.
+  var REALTIME_GATE_WORKLET_SOURCE = ['var decide = ' + coreAiGateDecide.toString() + ';', 'var newState = ' + createGateState.toString() + ';', 'var rmsDb = ' + coreAiRmsDb.toString() + ';', 'class CoreAiMicGateProcessor extends AudioWorkletProcessor {', '  constructor(options) {', '    super();', '    var o = (options && options.processorOptions) || {};',
+  // The gate reads the live signal but emits it delayed, so by the time a word's first sample leaves here
+  // the gate has already seen it and opened. Without this the initial consonant of every utterance was
+  // clipped, which is exactly what degrades transcription and the model's understanding.
+  '    this.delay = new Float32Array(Math.max(1, Math.round(sampleRate * (o.lookaheadMs || 80) / 1000)));', '    this.delayPos = 0;', '    this.gain = 0;', '    this.mode = o.mode || {};', '    this.state = newState();', '    this.lastPost = 0;', '    this.port.onmessage = function (e) { this.mode = e.data || {}; }.bind(this);', '  }', '  process(inputs, outputs) {', '    var mic = (inputs[0] && inputs[0][0]) || null;', '    var assistant = (inputs[1] && inputs[1][0]) || null;', '    var out = (outputs[0] && outputs[0][0]) || null;', '    if (!out) { return true; }', '    var micDb = rmsDb(mic);', '    decide(this.state, { micDb: micDb, assistantDb: rmsDb(assistant), nowMs: currentTime * 1000, mode: this.mode });', '    var target = this.state.open ? 1 : 0;',
+  // Ramp over ~10 ms rather than switching instantly, so opening and closing never clicks.
+  '    var step = 1 / (sampleRate * 0.01);', '    var delay = this.delay;', '    var pos = this.delayPos;', '    var len = delay.length;', '    for (var i = 0; i < out.length; i++) {', '      var delayed = delay[pos];', '      delay[pos] = mic ? mic[i] : 0;', '      pos = (pos + 1) % len;', '      if (this.gain < target) { this.gain = Math.min(target, this.gain + step); }', '      else if (this.gain > target) { this.gain = Math.max(target, this.gain - step); }', '      out[i] = delayed * this.gain;', '    }', '    this.delayPos = pos;', '    if (currentTime * 1000 - this.lastPost > 100) {', '      this.lastPost = currentTime * 1000;', '      this.port.postMessage({ micDb: micDb, floorDb: this.state.floorDb, echoReturnDb: this.state.echoReturnDb, open: this.state.open, assistantSpeaking: this.state.assistantSpeaking });', '    }', '    return true;', '  }', '}', 'registerProcessor("coreai-mic-gate", CoreAiMicGateProcessor);'].join('\n');
+
+  /*
+   * Builds a microphone gate for a captured stream.
+   *
+   *   createMicGate(stream, mode) => Promise<{
+   *       track,                        // the gated track to send (or the raw mic when Web Audio is missing)
+   *       setMode(mode),                // { pushToTalk, pttActive, bargeIn, speechHangoverMs }
+   *       attachAssistantStream(stream),// so the gate knows when the assistant is audible
+   *       getLevel(),                   // last measurement, for a mic meter
+   *       stop()
+   *   }>
+   */
+  function createMicGate(rawStream, mode) {
+    var rawTrack = rawStream && rawStream.getAudioTracks && rawStream.getAudioTracks()[0] || null;
+    var state = {
+      ctx: null,
+      node: null,
+      micSource: null,
+      remoteSource: null,
+      dest: null,
+      timer: 0,
+      level: null,
+      fallback: null,
+      track: rawTrack,
+      stopped: false
+    };
+    var gate = {
+      track: rawTrack,
+      // True when the gate is running on the audio thread. The fallback still gates, but on a timer that a
+      // hidden tab throttles, so hosts and tests can tell the two apart.
+      usingWorklet: false,
+      getLevel: function getLevel() {
+        return state.level;
+      },
+      setMode: function setMode(next) {
+        mode = next || mode;
+        if (state.node && state.node.port) {
+          try {
+            state.node.port.postMessage(mode);
+          } catch (e) {}
+        }
+        if (state.fallback) {
+          state.fallback.mode = mode;
+        }
+      },
+      attachAssistantStream: function attachAssistantStream(remoteStream) {
+        attachAssistant(state, remoteStream);
+      },
+      stop: function stop() {
+        state.stopped = true;
+        if (state.timer) {
+          try {
+            window.clearInterval(state.timer);
+          } catch (e) {}
+          state.timer = 0;
+        }
+        if (state.node) {
+          try {
+            state.node.port.onmessage = null;
+            state.node.disconnect();
+          } catch (e) {}
+          state.node = null;
+        }
+        if (state.micSource) {
+          try {
+            state.micSource.disconnect();
+          } catch (e) {}
+          state.micSource = null;
+        }
+        if (state.remoteSource) {
+          try {
+            state.remoteSource.disconnect();
+          } catch (e) {}
+          state.remoteSource = null;
+        }
+        if (state.dest) {
+          try {
+            state.dest.disconnect();
+          } catch (e) {}
+          state.dest = null;
+        }
+        if (state.ctx) {
+          try {
+            state.ctx.close();
+          } catch (e) {}
+          state.ctx = null;
+        }
+        state.fallback = null;
+      }
+    };
+    var AudioCtor = window.AudioContext || window.webkitAudioContext;
+    if (!AudioCtor || !rawTrack) {
+      return Promise.resolve(gate);
+    }
+    try {
+      state.ctx = new AudioCtor();
+      // A context created under a strict autoplay policy starts suspended, and a suspended gate emits
+      // nothing at all — the model would simply never hear the user.
+      if (state.ctx.state === 'suspended' && typeof state.ctx.resume === 'function') {
+        state.ctx.resume()["catch"](function () {});
+      }
+    } catch (err) {
+      state.ctx = null;
+      return Promise.resolve(gate);
+    }
+    var blobUrl = null;
+    if (state.ctx.audioWorklet && typeof state.ctx.audioWorklet.addModule === 'function') {
+      try {
+        blobUrl = URL.createObjectURL(new Blob([REALTIME_GATE_WORKLET_SOURCE], {
+          type: 'application/javascript'
+        }));
+      } catch (err) {
+        blobUrl = null;
+      }
+    }
+    if (!blobUrl) {
+      gate.track = buildFallbackGate(state, rawStream, rawTrack, mode);
+      return Promise.resolve(gate);
+    }
+    return state.ctx.audioWorklet.addModule(blobUrl).then(function () {
+      try {
+        URL.revokeObjectURL(blobUrl);
+      } catch (e) {}
+      if (state.stopped) {
+        return gate;
+      }
+      var node = new AudioWorkletNode(state.ctx, 'coreai-mic-gate', {
+        numberOfInputs: 2,
+        numberOfOutputs: 1,
+        outputChannelCount: [1],
+        processorOptions: {
+          lookaheadMs: REALTIME_GATE_LOOKAHEAD_MS,
+          mode: mode
+        }
+      });
+      state.node = node;
+      node.port.onmessage = function (e) {
+        state.level = e.data || null;
+        // Also published on the module for support diagnostics (a host can read it from the console
+        // without holding a reference to the gate).
+        window.CoreAIRealtime.lastGateLevel = state.level;
+      };
+      state.micSource = state.ctx.createMediaStreamSource(rawStream);
+      state.micSource.connect(node, 0, 0);
+      state.dest = state.ctx.createMediaStreamDestination();
+      node.connect(state.dest);
+      if (state.pendingRemoteStream) {
+        attachAssistant(state, state.pendingRemoteStream);
+      }
+      gate.track = state.dest.stream.getAudioTracks()[0] || rawTrack;
+      gate.usingWorklet = true;
+      return gate;
+    })["catch"](function (err) {
+      try {
+        URL.revokeObjectURL(blobUrl);
+      } catch (e) {}
+      if (window.console && console.warn) {
+        console.warn('The realtime microphone gate worklet could not be loaded; using the simpler gate.', err);
+      }
+      gate.track = buildFallbackGate(state, rawStream, rawTrack, mode);
+      return gate;
+    });
+  }
+  function attachAssistant(state, remoteStream) {
+    state.pendingRemoteStream = remoteStream || null;
+    if (!state.ctx || !remoteStream || state.stopped) {
+      return;
+    }
+    try {
+      if (state.remoteSource) {
+        try {
+          state.remoteSource.disconnect();
+        } catch (e) {}
+      }
+      var src = state.ctx.createMediaStreamSource(remoteStream);
+      state.remoteSource = src;
+      if (state.node) {
+        src.connect(state.node, 0, 1);
+        return;
+      }
+      if (state.fallback) {
+        var analyser = state.ctx.createAnalyser();
+        analyser.fftSize = 2048;
+        src.connect(analyser);
+        state.fallback.remoteAnalyser = analyser;
+        state.fallback.remoteData = new Float32Array(analyser.fftSize);
+      }
+    } catch (e) {
+      // Assistant-level detection unavailable; the gate still opens on user speech.
+    }
+  }
+
+  // Fallback for browsers without AudioWorklet: the same decision on a timer instead of the audio thread. A
+  // timer is throttled in background tabs — worse than the worklet, better than nothing — and there is no
+  // look-ahead here, so utterance onsets are still clipped.
+  function buildFallbackGate(state, rawStream, rawTrack, mode) {
+    try {
+      var ctx = state.ctx;
+      var source = ctx.createMediaStreamSource(rawStream);
+      state.micSource = source;
+      var analyser = ctx.createAnalyser();
+      analyser.fftSize = 2048;
+      source.connect(analyser);
+      var gain = ctx.createGain();
+      gain.gain.value = 0;
+      source.connect(gain);
+      var dest = ctx.createMediaStreamDestination();
+      state.dest = dest;
+      gain.connect(dest);
+      var f = {
+        mode: mode,
+        remoteAnalyser: null,
+        remoteData: null
+      };
+      state.fallback = f;
+      if (state.pendingRemoteStream) {
+        attachAssistant(state, state.pendingRemoteStream);
+      }
+      var data = new Float32Array(analyser.fftSize);
+
+      // The same decision the worklet runs, on a timer instead of the audio thread. The floor adapts faster
+      // here only because this loop runs ~50x/s rather than ~375x/s; everything else is shared.
+      var gateState = createGateState();
+      state.timer = window.setInterval(function () {
+        analyser.getFloatTimeDomainData(data);
+        var micDb = coreAiRmsDb(data);
+        var assistantDb = -100;
+        if (f.remoteAnalyser && f.remoteData) {
+          f.remoteAnalyser.getFloatTimeDomainData(f.remoteData);
+          assistantDb = coreAiRmsDb(f.remoteData);
+        }
+        var nowMs = window.performance && performance.now ? performance.now() : Date.now();
+        coreAiGateDecide(gateState, {
+          micDb: micDb,
+          assistantDb: assistantDb,
+          nowMs: nowMs,
+          mode: f.mode || {}
+        });
+        state.level = {
+          micDb: micDb,
+          floorDb: gateState.floorDb,
+          open: gateState.open,
+          assistantSpeaking: gateState.assistantSpeaking
+        };
+        var target = gateState.open ? 1 : 0;
+        try {
+          gain.gain.setTargetAtTime(target, ctx.currentTime, 0.015);
+        } catch (e) {
+          gain.gain.value = target;
+        }
+      }, 20);
+      return dest.stream.getAudioTracks()[0] || rawTrack;
+    } catch (err) {
+      // Web Audio unavailable; send the raw mic (ungated).
+      return rawTrack;
+    }
+  }
+
+  /*
+   * Routes an audio element to the device the browser's echo canceller couples to, or to an explicitly chosen
+   * one. Preference order:
+   *   1. The caller's chosen device, when they picked one.
+   *   2. The "communications" sink (Chromium). Rendering here doesn't just pick a device — it puts the browser's
+   *      audio pipeline in communications mode, which is what actually couples playback with the microphone's
+   *      echo canceller, and what keeps full duplex stable across turns.
+   *   3. The concrete device the "default" alias points at, matched by groupId.
+   * If neither alias exists — Firefox lists only concrete outputs — nothing is set and the browser's own default
+   * stands. Guessing there routed the assistant to whatever was enumerated first (often an HDMI monitor), so it
+   * appeared silent.
+   */
+  function routeOutputToPreferredDevice(el, chosenDeviceId) {
+    if (!el || typeof el.setSinkId !== 'function') {
+      return;
+    }
+    if (chosenDeviceId) {
+      try {
+        el.setSinkId(chosenDeviceId)["catch"](function () {});
+      } catch (e) {}
+      return;
+    }
+    if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
+      return;
+    }
+    navigator.mediaDevices.enumerateDevices().then(function (devices) {
+      var outputs = devices.filter(function (d) {
+        return d.kind === 'audiooutput';
+      });
+      if (!outputs.length) {
+        return;
+      }
+      var target = '';
+      for (var i = 0; i < outputs.length; i++) {
+        if (outputs[i].deviceId === 'communications') {
+          target = 'communications';
+          break;
+        }
+      }
+      if (!target) {
+        var defaultEntry = null;
+        for (var d = 0; d < outputs.length; d++) {
+          if (outputs[d].deviceId === 'default') {
+            defaultEntry = outputs[d];
+            break;
+          }
+        }
+        if (defaultEntry && defaultEntry.groupId) {
+          for (var j = 0; j < outputs.length; j++) {
+            if (outputs[j].deviceId !== 'default' && outputs[j].deviceId !== 'communications' && outputs[j].groupId === defaultEntry.groupId) {
+              target = outputs[j].deviceId;
+              break;
+            }
+          }
+        }
+      }
+      if (target) {
+        try {
+          el.setSinkId(target)["catch"](function () {});
+        } catch (e) {}
+      }
+    })["catch"](function () {});
+  }
+
+  // Autoplay policies (Firefox's "Block audio and video", locked-down profiles) can reject playback even after a
+  // click, and a rejected play() is silent — the assistant simply never becomes audible. Ask explicitly and
+  // report the failure instead of leaving the user with a mute conversation.
+  function ensurePlayback(el, onBlocked) {
+    if (!el || typeof el.play !== 'function') {
+      return;
+    }
+    var played = el.play();
+    if (played && typeof played["catch"] === 'function') {
+      played["catch"](function (err) {
+        if (typeof onBlocked === 'function') {
+          onBlocked(err);
+        }
+        if (window.console && console.warn) {
+          console.warn('The browser blocked realtime audio playback. Interact with the page to enable audio.', err);
+        }
+      });
+    }
+  }
+  function attach(opts) {
+    opts = opts || {};
+    var connection = opts.connection;
+    var sel = opts.selectors || {};
+    var realtimeVoiceName = opts.voiceName || '';
+    var realtimeCapableDeployments = (opts.capableDeployments || []).map(function (n) {
+      return (n || '').toLowerCase();
+    });
+    var isRealtimeMode = !!opts.realtimeEnabled;
+    var noop = function noop() {};
+    var onActivate = opts.onActivate || noop;
+    var onDeactivate = opts.onDeactivate || noop;
+    var onEnterRealtimeMode = opts.onEnterRealtimeMode || noop;
+    // The server tells us a user utterance was captured before it has been transcribed, so the host can show a
+    // placeholder in the right position; onUserTurnDropped removes it when the utterance produced nothing.
+    var onUserTurnPending = opts.onUserTurnPending || noop;
+    var onUserTurnDropped = opts.onUserTurnDropped || noop;
+    // Hosts are localizable elsewhere, so let them override the handful of strings this module renders.
+    // Anything not supplied falls back to the English default.
+    var strings = opts.strings || {};
+    function localize(key, fallback) {
+      return typeof strings[key] === 'string' ? strings[key] : fallback;
+    }
+    var ensureConnected = opts.ensureConnected || function () {
+      return Promise.resolve(true);
+    };
+    var sendStart = opts.sendStart || noop;
+    // Optional: resolve the assistant voice live at session start (e.g. from a settings picker) so it
+    // reflects the current selection rather than the value captured when the controller was attached.
+    var getVoiceName = opts.getVoiceName || null;
+    // Optional server-relay WebRTC transport: when the server advertises it and the callback is supplied, the
+    // controller uses WebRTC (real acoustic echo cancellation) instead of the PCM-over-SignalR path.
+    var sendStartWebRtc = opts.sendStartWebRtc || null;
+    var webRtcEnabled = opts.webRtcEnabled === true && typeof window.RTCPeerConnection === 'function' && !!sendStartWebRtc;
+    // A host-supplied override; normally the servers are fetched from the hub right before the peer is created
+    // (see resolveIceServers) so configured TURN relays — and their short-lived credentials — are actually used.
+    var webRtcIceServers = Array.isArray(opts.webRtcIceServers) && opts.webRtcIceServers.length ? opts.webRtcIceServers : null;
+    var DEFAULT_ICE_SERVERS = [{
+      urls: 'stun:stun.l.google.com:19302'
+    }];
+    // Optional: notified on every state transition so the host can render "Connecting…", "Listening", etc.
+    var onStateChange = opts.onStateChange || noop;
+    var realtimeState = 'idle';
+    function q(name) {
+      var s = sel[name];
+      return s ? document.querySelector(s) : null;
+    }
+    var isRealtimeActive = false;
+    // Server-driven session lifecycle (see bindRealtimeLifecycleHandlers): the server tells us when the
+    // provider session is live, when the user interrupted, and when the session ended for any reason.
+    var realtimeLifecycleBound = false,
+      realtimeSessionReady = false,
+      realtimeEndedNotice = null,
+      realtimeCompatibilityNoticeEl = null,
+      realtimeStatusEl = null;
+    var realtimeStream = null,
+      realtimeAudioCtx = null,
+      realtimeSubject = null,
+      realtimeProcessor = null,
+      realtimeMicSource = null,
+      realtimeZeroGain = null,
+      realtimeGain = null,
+      realtimePlayHead = 0,
+      realtimeSources = [];
+    // WebRTC transport state.
+    var realtimeIsWebRtc = false,
+      realtimePc = null,
+      realtimeRemoteAudioEl = null,
+      realtimeWebRtcHandlersBound = false,
+      realtimeRemoteDescriptionSet = false,
+      realtimePendingIce = [];
+    // WebRTC connect-time fallback state: we decide WebRTC-vs-WebSocket only at connect time (never mid-session).
+    var realtimeWebRtcConnected = false,
+      realtimeWebRtcConnectTimer = null,
+      realtimeFellBack = false;
+    // How long to wait for the WebRTC peer to connect before dropping to the WebSocket transport. Once ICE
+    // gathering has finished without producing a relay candidate there is nothing left to wait for on a
+    // network that blocks UDP, so the wait is cut short rather than run to the full timeout.
+    var REALTIME_WEBRTC_CONNECT_TIMEOUT_MS = 8000;
+    var REALTIME_WEBRTC_NO_RELAY_TIMEOUT_MS = 5000;
+    // Fixed receive-side cushion for assistant audio (see pc.ontrack). The server paces the stream on a
+    // 20 ms clock, so this only has to cover network jitter, not provider burstiness.
+    var REALTIME_WEBRTC_JITTER_BUFFER_TARGET_MS = 150;
+    // Remembering a failed attempt for the rest of the browser session matters: without it, a user on a
+    // network where WebRTC cannot work pays the full connection timeout — and a second microphone prompt —
+    // at the start of every single conversation.
+    var REALTIME_WEBRTC_BLOCKED_KEY = 'coreai.realtime.webrtcBlocked';
+    var realtimeSawRelayCandidate = false;
+    // WebRTC half-duplex echo guard: the shared microphone gate (see createMicGate) watches both the mic and
+    // the assistant's remote audio and silences the outbound track unless the user is genuinely speaking, so
+    // the model cannot hear itself even when AEC underperforms against loud open-room speakers. It also
+    // enforces push-to-talk on the WebRTC mic track.
+    var realtimeWebRtcMicTrack = null,
+      realtimeGate = null,
+      realtimeGatePendingRemoteStream = null;
+
+    // Per-device audio preferences (interruptions, push-to-talk, volume, devices, language). They live in
+    // localStorage because they depend on the listener's hardware, not on the interaction.
+    var realtimeBargeIn = true,
+      realtimePushToTalk = false,
+      realtimePttActive = false,
+      realtimePttBound = false,
+      realtimePttKeyDown = null,
+      realtimePttKeyUp = null,
+      realtimePttButton = null,
+      realtimePttUiEl = null,
+      realtimeVolume = 1,
+      realtimeMicDeviceId = '',
+      realtimeOutputDeviceId = '',
+      realtimeLanguage = '',
+      realtimeAudioSettingsBuilt = false;
+
+    // The half-duplex echo tail on the WebSocket transport: how long the microphone stays muted after the
+    // scheduled end of the assistant's playback, covering the room's reverberation.
+    var REALTIME_WS_ECHO_HANGOVER_SEC = 0.5;
+
+    // Version 3 dropped the audio-setup presets, the voice-gate modes and the turn-detection sliders — all of
+    // that is measured or decided automatically now — and, the part that matters to anyone who used version 2,
+    // restores interruptions. The removed device-label guess had switched them off for every microphone whose
+    // name merely looked like a room microphone, and the earlier repair deliberately left that alone, so users
+    // found interruptions "off by default" with no idea why.
+    var REALTIME_PREFS_VERSION = 3;
+    function loadRealtimeAudioPrefs() {
+      var prefs = {
+        bargeIn: true,
+        pushToTalk: false,
+        volume: 1,
+        micDeviceId: '',
+        outputDeviceId: '',
+        language: '',
+        version: 0
+      };
+      try {
+        var raw = window.localStorage.getItem('coreai.realtime.audioPrefs');
+        if (raw) {
+          var parsed = JSON.parse(raw);
+          if (typeof parsed.bargeIn === 'boolean') {
+            prefs.bargeIn = parsed.bargeIn;
+          }
+          if (typeof parsed.pushToTalk === 'boolean') {
+            prefs.pushToTalk = parsed.pushToTalk;
+          }
+          if (typeof parsed.volume === 'number' && isFinite(parsed.volume)) {
+            prefs.volume = Math.min(1, Math.max(0, parsed.volume));
+          }
+          if (typeof parsed.micDeviceId === 'string') {
+            prefs.micDeviceId = parsed.micDeviceId;
+          }
+          if (typeof parsed.outputDeviceId === 'string') {
+            prefs.outputDeviceId = parsed.outputDeviceId;
+          }
+          if (typeof parsed.language === 'string') {
+            prefs.language = parsed.language;
+          }
+          if (typeof parsed.version === 'number') {
+            prefs.version = parsed.version;
+          }
+        }
+      } catch (err) {/* storage unavailable or blocked */}
+      return repairRealtimeAudioPrefs(prefs);
+    }
+    function repairRealtimeAudioPrefs(prefs) {
+      if (prefs.version === REALTIME_PREFS_VERSION) {
+        return prefs;
+      }
+      prefs.version = REALTIME_PREFS_VERSION;
+      prefs.bargeIn = true;
+      prefs.pushToTalk = false;
+      saveRealtimeAudioPrefs(prefs);
+      return prefs;
+    }
+    function saveRealtimeAudioPrefs(prefs) {
+      try {
+        window.localStorage.setItem('coreai.realtime.audioPrefs', JSON.stringify(prefs));
+      } catch (err) {}
+    }
+    function applyRealtimeAudioPrefs(prefs) {
+      realtimeBargeIn = prefs.bargeIn !== false;
+      realtimePushToTalk = !!prefs.pushToTalk;
+      realtimeVolume = typeof prefs.volume === 'number' ? prefs.volume : 1;
+      realtimeMicDeviceId = prefs.micDeviceId || '';
+      realtimeOutputDeviceId = prefs.outputDeviceId || '';
+      realtimeLanguage = prefs.language || '';
+      // The gate runs on the audio thread and cannot see these variables; push the change to it.
+      syncRealtimeGateMode();
+      if (realtimeGain) {
+        realtimeGain.gain.value = realtimeVolume;
+      }
+      // On WebRTC the assistant plays through the hidden <audio> element, so the volume slider must drive its
+      // volume directly. Lowering it also cuts the acoustic echo into the mic, which helps AEC with barge-in on.
+      if (realtimeRemoteAudioEl) {
+        realtimeRemoteAudioEl.volume = Math.max(0, Math.min(1, realtimeVolume));
+      }
+    }
+
+    // The push-to-talk handlers below run in the capture phase and swallow Space, which would otherwise eat
+    // every space character the user types elsewhere on the page while a voice session is active.
+    function isEditableTarget(target) {
+      if (!target || !target.tagName) {
+        return false;
+      }
+      var tag = target.tagName.toLowerCase();
+      return tag === 'input' || tag === 'textarea' || tag === 'select' || target.isContentEditable === true;
+    }
+
+    // Push-to-talk: hold Space to open the mic. Bound only while a realtime session is active so it never
+    // interferes with normal typing. Capture phase + preventDefault so Space never scrolls the page or
+    // activates a focused button (Space-up on a focused button fires a click that would toggle the session).
+    function attachRealtimePushToTalk() {
+      if (realtimePttBound) {
+        return;
+      }
+      realtimePttBound = true;
+      realtimePttActive = false;
+      realtimePttKeyDown = function realtimePttKeyDown(e) {
+        if (realtimePushToTalk && !isEditableTarget(e.target) && (e.code === 'Space' || e.key === ' ')) {
+          e.preventDefault();
+          if (!e.repeat) {
+            setRealtimePttActive(true);
+          }
+        }
+      };
+      realtimePttKeyUp = function realtimePttKeyUp(e) {
+        if (realtimePushToTalk && !isEditableTarget(e.target) && (e.code === 'Space' || e.key === ' ')) {
+          e.preventDefault();
+          setRealtimePttActive(false);
+        }
+      };
+      document.addEventListener('keydown', realtimePttKeyDown, true);
+      document.addEventListener('keyup', realtimePttKeyUp, true);
+    }
+    function detachRealtimePushToTalk() {
+      if (!realtimePttBound) {
+        return;
+      }
+      realtimePttBound = false;
+      realtimePttActive = false;
+      try {
+        document.removeEventListener('keydown', realtimePttKeyDown, true);
+      } catch (err) {}
+      try {
+        document.removeEventListener('keyup', realtimePttKeyUp, true);
+      } catch (err) {}
+    }
+    function setRealtimePttActive(active) {
+      realtimePttActive = active;
+      // The gate lives on the audio thread and cannot read this variable.
+      syncRealtimeGateMode();
+      if (realtimePttButton) {
+        realtimePttButton.classList.toggle('btn-danger', active);
+        realtimePttButton.classList.toggle('btn-outline-primary', !active);
+        realtimePttButton.innerHTML = active ? '<i class="bi bi-mic-fill me-1"></i> Listening…' : '<i class="bi bi-mic me-1"></i> Hold to talk';
+      }
+    }
+
+    // Shows a "hold to talk" control + hint while a push-to-talk realtime session is active.
+    function buildRealtimePttUi() {
+      var realtimeBtn = q('realtimeButton');
+      if (!realtimeBtn || realtimePttUiEl) {
+        return;
+      }
+      var coarse = window.matchMedia && window.matchMedia('(pointer: coarse)').matches;
+      var bar = document.createElement('div');
+      bar.className = 'text-center mt-2';
+      var btn = document.createElement('button');
+      btn.type = 'button';
+      btn.className = 'btn btn-outline-primary btn-sm';
+      btn.innerHTML = '<i class="bi bi-mic me-1"></i> Hold to talk';
+      var hint = document.createElement('div');
+      hint.className = 'form-text mt-1 mb-0';
+      hint.innerHTML = coarse ? 'Push-to-talk is on — press and hold the button to speak.' : 'Push-to-talk is on — hold <kbd>Space</kbd> or this button to speak.';
+      bar.appendChild(btn);
+      bar.appendChild(hint);
+      var row = realtimeBtn.parentElement;
+      if (row && row.parentElement) {
+        row.parentElement.appendChild(bar);
+      } else {
+        realtimeBtn.insertAdjacentElement('afterend', bar);
+      }
+      realtimePttButton = btn;
+      realtimePttUiEl = bar;
+      btn.addEventListener('pointerdown', function (e) {
+        e.preventDefault();
+        setRealtimePttActive(true);
+      });
+      btn.addEventListener('pointerup', function () {
+        setRealtimePttActive(false);
+      });
+      btn.addEventListener('pointerleave', function () {
+        setRealtimePttActive(false);
+      });
+      btn.addEventListener('pointercancel', function () {
+        setRealtimePttActive(false);
+      });
+      setRealtimePttActive(false);
+    }
+    function removeRealtimePttUi() {
+      realtimePttButton = null;
+      if (realtimePttUiEl) {
+        try {
+          realtimePttUiEl.remove();
+        } catch (err) {}
+        realtimePttUiEl = null;
+      }
+    }
+
+    // Builds a gear-triggered popover next to the realtime button with the per-device audio settings.
+    //
+    // It is deliberately short: a microphone, a speaker, the volume, the language, and two switches. Everything
+    // that used to be a knob here — echo margins, gate modes, turn-detection timing, audio-setup presets, an
+    // echo self-test — is measured or decided automatically now. A user should be able to press "Start
+    // speaking" and talk, in any room, without first understanding acoustics.
+    function setupRealtimeAudioSettings() {
+      var realtimeBtn = q('realtimeButton');
+      if (!realtimeBtn || realtimeAudioSettingsBuilt) {
+        return;
+      }
+      realtimeAudioSettingsBuilt = true;
+      var prefs = loadRealtimeAudioPrefs();
+      applyRealtimeAudioPrefs(prefs);
+      var wrap = document.createElement('span');
+      wrap.id = 'realtime-audio-settings';
+      wrap.style.position = 'relative';
+      wrap.style.display = 'inline-flex';
+      var gear = document.createElement('button');
+      gear.type = 'button';
+      gear.className = 'btn btn-outline-secondary';
+      gear.title = localize('settingsTitle', 'Voice settings');
+      gear.setAttribute('aria-label', localize('settingsTitle', 'Voice settings'));
+      gear.innerHTML = '<i class="bi bi-gear"></i>';
+      var langs = [['en', 'English'], ['es', 'Spanish'], ['fr', 'French'], ['de', 'German'], ['it', 'Italian'], ['pt', 'Portuguese'], ['nl', 'Dutch'], ['zh', 'Chinese'], ['ja', 'Japanese'], ['ko', 'Korean'], ['ar', 'Arabic'], ['hi', 'Hindi'], ['ru', 'Russian']];
+      var langOptions = '<option value=""' + (prefs.language === '' ? ' selected' : '') + '>' + localize('languageAuto', 'Automatic') + '</option>' + langs.map(function (l) {
+        return '<option value="' + l[0] + '"' + (prefs.language === l[0] ? ' selected' : '') + '>' + l[1] + '</option>';
+      }).join('');
+      var panel = document.createElement('div');
+      panel.className = 'card shadow-sm';
+      panel.style.cssText = 'position:absolute;bottom:calc(100% + 6px);right:0;z-index:1080;width:290px;max-height:70vh;overflow:auto;display:none;';
+      panel.innerHTML = '<div class="card-body p-3">' + '<div class="fw-semibold mb-2" style="font-size:0.85rem;">' + localize('settingsTitle', 'Voice settings') + '</div>' + '<label class="form-label mb-1 d-block" style="font-size:0.8rem;">' + localize('microphone', 'Microphone') + '</label>' + '<select class="form-select form-select-sm js-mic mb-2"><option value="">' + localize('defaultMicrophone', 'Default microphone') + '</option></select>' + '<label class="form-label mb-1 d-block" style="font-size:0.8rem;">' + localize('speaker', 'Speaker') + '</label>' + '<select class="form-select form-select-sm js-out mb-1"><option value="">' + localize('automatic', 'Automatic') + '</option></select>' + '<button type="button" class="btn btn-outline-secondary btn-sm mb-2 js-pick-out" style="display:none;">' + localize('chooseSpeaker', 'Choose speaker…') + '</button>' + '<div class="form-text mb-2 js-out-help">' + localize('speakerHelp', 'Automatic uses the device your system uses for calls. If you cannot hear the assistant, pick the speakers you are actually listening to.') + '</div>' + '<label class="form-label mb-1 d-block" style="font-size:0.8rem;">' + localize('assistantVolume', 'Assistant volume') + ': <strong class="js-vol-val">' + Math.round(prefs.volume * 100) + '</strong>%</label>' + '<input type="range" class="form-range js-vol mb-2" min="0" max="100" step="5" value="' + Math.round(prefs.volume * 100) + '">' + '<label class="form-label mb-1 d-block" style="font-size:0.8rem;">' + localize('language', 'Language') + '</label>' + '<select class="form-select form-select-sm js-lang mb-2">' + langOptions + '</select>' + '<div class="form-check form-switch mb-1">' + '<input class="form-check-input js-barge" type="checkbox" id="realtime-setting-barge"' + (prefs.bargeIn ? ' checked' : '') + '>' + '<label class="form-check-label" for="realtime-setting-barge">' + localize('allowInterruptions', 'Allow interruptions') + '</label>' + '</div>' + '<div class="form-text mb-2">' + localize('allowInterruptionsHelp', 'Talk over the assistant to interrupt it. Turn this off if the assistant keeps hearing itself through your speakers.') + '</div>' + '<div class="form-check form-switch mb-1">' + '<input class="form-check-input js-ptt" type="checkbox" id="realtime-setting-ptt"' + (prefs.pushToTalk ? ' checked' : '') + '>' + '<label class="form-check-label" for="realtime-setting-ptt">' + localize('pushToTalk', 'Push-to-talk') + '</label>' + '</div>' + '<div class="form-text">' + localize('pushToTalkHelp', 'Hold <kbd>Space</kbd> (or the button) to talk. For very noisy places.') + '</div>' + '</div>';
+      wrap.appendChild(gear);
+      wrap.appendChild(panel);
+      realtimeBtn.insertAdjacentElement('afterend', wrap);
+      var bargeInput = panel.querySelector('.js-barge');
+      var pttInput = panel.querySelector('.js-ptt');
+      var volInput = panel.querySelector('.js-vol');
+      var volVal = panel.querySelector('.js-vol-val');
+      var micSelect = panel.querySelector('.js-mic');
+      var outSelect = panel.querySelector('.js-out');
+      var outPickButton = panel.querySelector('.js-pick-out');
+      var langSelect = panel.querySelector('.js-lang');
+      function persist() {
+        var next = {
+          bargeIn: bargeInput.checked,
+          pushToTalk: pttInput.checked,
+          volume: (parseInt(volInput.value, 10) || 0) / 100,
+          micDeviceId: micSelect.value || '',
+          outputDeviceId: outSelect.value || '',
+          language: langSelect.value || '',
+          version: REALTIME_PREFS_VERSION
+        };
+        applyRealtimeAudioPrefs(next);
+        saveRealtimeAudioPrefs(next);
+        pushRealtimeSettingsToServer();
+      }
+      function populateDevices() {
+        if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
+          return;
+        }
+        navigator.mediaDevices.enumerateDevices().then(function (devices) {
+          var options = ['<option value="">' + localize('defaultMicrophone', 'Default microphone') + '</option>'];
+          devices.filter(function (d) {
+            return d.kind === 'audioinput';
+          }).forEach(function (d, i) {
+            var label = d.label || localize('microphone', 'Microphone') + ' ' + (i + 1);
+            options.push('<option value="' + d.deviceId + '"' + (d.deviceId === realtimeMicDeviceId ? ' selected' : '') + '>' + label.replace(/</g, '') + '</option>');
+          });
+          micSelect.innerHTML = options.join('');
+
+          // Output devices are only enumerable on browsers that expose them (Chromium); elsewhere the
+          // list stays on "Automatic" and the picker button below is the way in.
+          var outs = devices.filter(function (d) {
+            return d.kind === 'audiooutput' && d.deviceId && d.deviceId !== 'communications' && d.deviceId !== 'default';
+          });
+          if (outs.length) {
+            var outOptions = ['<option value="">' + localize('automatic', 'Automatic') + '</option>'];
+            outs.forEach(function (d, i) {
+              var label = d.label || localize('speaker', 'Speaker') + ' ' + (i + 1);
+              outOptions.push('<option value="' + d.deviceId + '"' + (d.deviceId === realtimeOutputDeviceId ? ' selected' : '') + '>' + label.replace(/</g, '') + '</option>');
+            });
+            outSelect.innerHTML = outOptions.join('');
+          }
+        })["catch"](function () {});
+      }
+      populateDevices();
+
+      // Unplugging the headset mid-conversation silently changes which devices exist. Refresh the lists, and
+      // end the session if the microphone it was actually using has gone — continuing on a different device
+      // without saying so is worse than stopping and letting the user restart.
+      if (navigator.mediaDevices && typeof navigator.mediaDevices.addEventListener === 'function') {
+        navigator.mediaDevices.addEventListener('devicechange', function () {
+          populateDevices();
+          if (!isRealtimeActive || !realtimeMicDeviceId) {
+            return;
+          }
+          navigator.mediaDevices.enumerateDevices().then(function (devices) {
+            var stillThere = devices.some(function (d) {
+              return d.kind === 'audioinput' && d.deviceId === realtimeMicDeviceId;
+            });
+            if (!stillThere) {
+              endRealtimeSessionFromServer('device_lost');
+            }
+          })["catch"](function () {});
+        });
+      }
+      function constrainPanel() {
+        // Keep the popover on screen horizontally. It is anchored to the button's right edge, which is
+        // correct where the button sits on the right of a wide row — but in a narrow layout, or with the
+        // button near the left edge, a 290px panel would otherwise hang off the side of the window.
+        panel.style.right = '0px';
+        panel.style.left = 'auto';
+        var panelRect = panel.getBoundingClientRect();
+        if (panelRect.left < 8) {
+          panel.style.right = panelRect.left - 8 + 'px';
+        }
+
+        // Cap its height to the space above the button up to the nearest scroll/fixed ancestor, so it
+        // scrolls instead of spilling out the top.
+        var rect = gear.getBoundingClientRect();
+        var boundaryTop = 8;
+        var node = panel.parentElement ? panel.parentElement.parentElement : null;
+        while (node && node !== document.body && node !== document.documentElement) {
+          var s = window.getComputedStyle(node);
+          if (s.overflowY === 'auto' || s.overflowY === 'scroll' || s.overflowY === 'hidden' || s.position === 'fixed') {
+            boundaryTop = Math.max(boundaryTop, node.getBoundingClientRect().top);
+            break;
+          }
+          node = node.parentElement;
+        }
+        panel.style.maxHeight = Math.max(160, rect.top - boundaryTop - 10) + 'px';
+      }
+      gear.addEventListener('click', function (e) {
+        e.stopPropagation();
+        var showing = panel.style.display === 'none';
+        if (showing) {
+          panel.style.display = 'block';
+          constrainPanel();
+          populateDevices();
+        }
+        panel.style.display = showing ? 'block' : 'none';
+      });
+      panel.addEventListener('click', function (e) {
+        e.stopPropagation();
+      });
+      document.addEventListener('click', function () {
+        panel.style.display = 'none';
+      });
+      bargeInput.addEventListener('change', persist);
+      pttInput.addEventListener('change', persist);
+      volInput.addEventListener('input', function () {
+        volVal.textContent = volInput.value;
+        persist();
+      });
+      micSelect.addEventListener('change', persist);
+      langSelect.addEventListener('change', persist);
+      outSelect.addEventListener('change', function () {
+        persist();
+        // Apply live: the whole point of the picker is that a user who cannot hear the assistant can fix
+        // it without ending the conversation.
+        applyRealtimeOutputDevice();
+      });
+
+      // Firefox exposes no output device list until the user picks one through this prompt.
+      if (navigator.mediaDevices && typeof navigator.mediaDevices.selectAudioOutput === 'function') {
+        outPickButton.style.display = '';
+        outPickButton.addEventListener('click', function () {
+          navigator.mediaDevices.selectAudioOutput().then(function (device) {
+            if (!device || !device.deviceId) {
+              return;
+            }
+            var option = document.createElement('option');
+            option.value = device.deviceId;
+            option.textContent = device.label || localize('selectedSpeaker', 'Selected speaker');
+            outSelect.appendChild(option);
+            outSelect.value = device.deviceId;
+            persist();
+            applyRealtimeOutputDevice();
+          })["catch"](function () {});
+        });
+      }
+    }
+
+    // The host supplies the button's markup as a data attribute. It is sanitized when DOMPurify is present;
+    // when it is not, the label falls back to text rather than injecting unsanitized markup — the module is
+    // shared, and not every host that loads it also loads DOMPurify.
+    function setRealtimeButtonHtml(button, html) {
+      if (!html) {
+        return;
+      }
+      if (window.DOMPurify && typeof window.DOMPurify.sanitize === 'function') {
+        button.replaceChildren(window.DOMPurify.sanitize(html, {
+          RETURN_DOM_FRAGMENT: true
+        }));
+        return;
+      }
+
+      // No DOMPurify: never parse the untrusted markup as HTML. Strip any tags with a plain-string pass and
+      // collapse whitespace, then render the remaining label as text only.
+      var text = html.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+      button.replaceChildren(document.createTextNode(text));
+    }
+    function updateRealtimeButton() {
+      var realtimeBtn = q('realtimeButton');
+      if (!realtimeBtn) {
+        return;
+      }
+      if (isRealtimeActive) {
+        realtimeBtn.classList.add('active', 'btn-primary');
+        realtimeBtn.classList.remove('btn-dark', 'btn-outline-dark', 'btn-outline-secondary');
+        realtimeBtn.title = realtimeBtn.getAttribute('data-end-title') || 'End Conversation';
+        setRealtimeButtonHtml(realtimeBtn, realtimeBtn.getAttribute('data-end-html'));
+      } else {
+        realtimeBtn.classList.remove('active', 'btn-primary', 'btn-dark', 'btn-outline-secondary');
+        realtimeBtn.classList.add('btn-outline-dark');
+        realtimeBtn.blur();
+        realtimeBtn.title = realtimeBtn.getAttribute('data-start-title') || 'Start speaking';
+        setRealtimeButtonHtml(realtimeBtn, realtimeBtn.getAttribute('data-start-html'));
+      }
+    }
+
+    // Switches the input between text and audio-only (realtime). Called at load and whenever the selected
+    // deployment changes to/from a realtime model.
+    function applyRealtimeMode(enable) {
+      isRealtimeMode = enable;
+      var realtimeBtn = q('realtimeButton');
+      var micBtn = q('micButton');
+      var conversationBtn = q('conversationButton');
+      var inputEl = q('input');
+      var sendBtn = q('sendButton');
+      var audioSettings = document.getElementById('realtime-audio-settings');
+      if (enable) {
+        onEnterRealtimeMode();
+        if (inputEl) {
+          inputEl.hidden = true;
+        }
+        if (sendBtn) {
+          sendBtn.hidden = true;
+        }
+        if (micBtn) {
+          micBtn.hidden = true;
+        }
+        if (conversationBtn) {
+          conversationBtn.hidden = true;
+        }
+        if (realtimeBtn) {
+          realtimeBtn.hidden = false;
+        }
+        if (audioSettings) {
+          audioSettings.hidden = false;
+        }
+      } else {
+        if (isRealtimeActive) {
+          stopRealtimeConversation();
+        }
+        if (realtimeBtn) {
+          realtimeBtn.hidden = true;
+        }
+        if (audioSettings) {
+          audioSettings.hidden = true;
+        }
+        removeCompatibilityModeNotice();
+        clearRealtimeStatus();
+        if (inputEl) {
+          inputEl.hidden = false;
+        }
+        if (sendBtn) {
+          sendBtn.hidden = false;
+        }
+        if (micBtn) {
+          micBtn.hidden = false;
+        }
+        if (conversationBtn) {
+          conversationBtn.hidden = false;
+        }
+      }
+      updateRealtimeButton();
+    }
+
+    // Barge-in and the voice-activity knobs are enforced by three layers at once: this client's microphone
+    // gate, the server's input pump, and the provider's own turn detection. Changing only this one leaves the
+    // three disagreeing — the classic symptom being barge-in switched off mid-conversation while the assistant
+    // still interrupts itself — so a change during a live session is sent on to the other two.
+    function pushRealtimeSettingsToServer() {
+      if (!isRealtimeActive || !connection || typeof connection.send !== 'function') {
+        return;
+      }
+      try {
+        connection.send('UpdateRealtimeSettings', realtimeBargeIn, null, null);
+      } catch (err) {}
+    }
+
+    // Reports the session's state to the host so it can show something more honest than a button that flips to
+    // "End Conversation" before anything has connected.
+    // What each state says to the user. Only the states worth narrating appear here; the rest clear the line.
+    var REALTIME_STATE_TEXT = {
+      'requesting-mic': localize('requestingMic', 'Waiting for microphone access…'),
+      'connecting': localize('connecting', 'Connecting…'),
+      'listening': localize('listening', 'Listening'),
+      'playback-blocked': localize('playbackBlocked', 'Audio is blocked by the browser — click the page to enable it.')
+    };
+    function setRealtimeState(state, detail) {
+      if (realtimeState === state) {
+        return;
+      }
+      realtimeState = state;
+      var text = REALTIME_STATE_TEXT[state];
+      if (text) {
+        showRealtimeStatus(text, false);
+      } else if (state === 'idle') {
+        clearRealtimeStatus();
+      }
+      try {
+        onStateChange({
+          state: state,
+          transport: realtimeIsWebRtc ? 'webrtc' : 'websocket',
+          detail: detail || null
+        });
+      } catch (err) {}
+    }
+
+    // The server owns the session's lifecycle; the browser cannot infer it from the audio it happens to
+    // receive. Without these handlers a session that ended server-side (provider socket closed, session cap,
+    // error, authorization failure) leaves the mic open and the button stuck on "End Conversation" while audio
+    // is streamed into nothing.
+    function bindRealtimeLifecycleHandlers() {
+      if (realtimeLifecycleBound || !connection) {
+        return;
+      }
+      realtimeLifecycleBound = true;
+      connection.on('ReceiveRealtimeEvent', function (identifier, type, payload) {
+        if (!isRealtimeActive) {
+          return;
+        }
+        if (type === 'session_ready') {
+          realtimeSessionReady = true;
+          setRealtimeState('listening');
+        } else if (type === 'session_ended') {
+          endRealtimeSessionFromServer(payload || 'completed');
+        } else if (type === 'speech_started') {
+          // Barge-in: stop the reply that is already scheduled for playback. On WebRTC the server flushes
+          // the peer itself, so this only matters for the WebSocket transport — but calling it there too
+          // is harmless and keeps the two transports behaving the same.
+          if (realtimeBargeIn) {
+            flushRealtimePlayback();
+          }
+        } else if (type === 'playback_flush') {
+          flushRealtimePlayback();
+        } else if (type === 'user_turn_pending') {
+          onUserTurnPending(payload);
+        } else if (type === 'user_turn_dropped') {
+          onUserTurnDropped(payload);
+        }
+      });
+
+      // An error while a voice session is running is terminal for that session: the server has already
+      // stopped, so keep the mic open no longer.
+      connection.on('ReceiveError', function () {
+        if (!isRealtimeActive) {
+          return;
+        }
+
+        // An error while the WebRTC peer is still being set up is a reason to try the other transport, not
+        // to give up: the WebSocket path may well work. Treating every error as terminal is what turned a
+        // recoverable server-side handshake failure into a session that silently did nothing at all.
+        if (realtimeIsWebRtc && !realtimeWebRtcConnected && !realtimeFellBack) {
+          fallbackToWebSocket('server reported an error before the peer connected');
+          return;
+        }
+
+        // Once the session is live, an error is terminal — the server has already stopped.
+        endRealtimeSessionFromServer('error');
+      });
+      if (typeof connection.onclose === 'function') {
+        connection.onclose(function () {
+          if (isRealtimeActive) {
+            endRealtimeSessionFromServer('disconnected');
+          }
+        });
+      }
+      if (typeof connection.onreconnecting === 'function') {
+        connection.onreconnecting(function () {
+          if (isRealtimeActive) {
+            endRealtimeSessionFromServer('disconnected');
+          }
+        });
+      }
+    }
+    function endRealtimeSessionFromServer(reason) {
+      realtimeEndedNotice = reason;
+      stopRealtimeConversation();
+      setRealtimeState('ended', reason);
+      if (window.console && console.info) {
+        console.info('The realtime voice session ended (' + reason + ').');
+      }
+
+      // An idle close is deliberate and recoverable, so say so and offer to pick the conversation back up
+      // rather than leaving the user staring at a button that silently stopped working.
+      if (reason === 'idle') {
+        showRealtimeStatus(localize('endedIdle', 'Voice paused after a period of silence.'), true);
+      } else if (reason === 'disconnected') {
+        showRealtimeStatus(localize('endedDisconnected', 'Voice session ended — the connection dropped.'), true);
+      } else if (reason === 'error') {
+        showRealtimeStatus(localize('endedError', 'Voice session ended unexpectedly.'), true);
+      } else if (reason === 'device_lost') {
+        showRealtimeStatus(localize('endedDeviceLost', 'Voice session ended — the microphone was disconnected.'), true);
+      }
+    }
+
+    // A single status line under the realtime button, optionally with a Resume button.
+    function showRealtimeStatus(text, offerResume) {
+      var realtimeBtn = q('realtimeButton');
+      if (!realtimeBtn) {
+        return;
+      }
+      if (!realtimeStatusEl) {
+        realtimeStatusEl = document.createElement('div');
+        realtimeStatusEl.className = 'form-text mt-2 mb-0 text-center';
+        realtimeStatusEl.setAttribute('role', 'status');
+        realtimeStatusEl.setAttribute('aria-live', 'polite');
+        var row = realtimeBtn.parentElement;
+        if (row && row.parentElement) {
+          row.parentElement.appendChild(realtimeStatusEl);
+        } else {
+          realtimeBtn.insertAdjacentElement('afterend', realtimeStatusEl);
+        }
+      }
+      realtimeStatusEl.replaceChildren();
+      realtimeStatusEl.appendChild(document.createTextNode(text));
+      if (offerResume) {
+        var resume = document.createElement('button');
+        resume.type = 'button';
+        resume.className = 'btn btn-link btn-sm p-0 ms-2 align-baseline';
+        resume.textContent = localize('resume', 'Resume');
+        resume.addEventListener('click', function () {
+          clearRealtimeStatus();
+          startRealtimeConversation();
+        });
+        realtimeStatusEl.appendChild(resume);
+      }
+    }
+    function clearRealtimeStatus() {
+      if (!realtimeStatusEl) {
+        return;
+      }
+      try {
+        realtimeStatusEl.remove();
+      } catch (err) {}
+      realtimeStatusEl = null;
+    }
+
+    // Resolves the ICE servers from the server immediately before creating the peer. Fetching them per session
+    // (rather than embedding them at page render time) is what makes ephemeral TURN credentials usable: they
+    // expire, and a page open for an hour would otherwise hand the browser a dead credential. Falls back to a
+    // public STUN server so a failed call degrades to today's behavior rather than breaking the session.
+    function resolveIceServers() {
+      if (webRtcIceServers) {
+        return Promise.resolve(webRtcIceServers);
+      }
+      if (!connection || typeof connection.invoke !== 'function') {
+        return Promise.resolve(DEFAULT_ICE_SERVERS);
+      }
+      return connection.invoke('GetRealtimeIceServers').then(function (servers) {
+        return Array.isArray(servers) && servers.length ? servers : DEFAULT_ICE_SERVERS;
+      })["catch"](function (err) {
+        if (window.console && console.warn) {
+          console.warn('Could not resolve the realtime ICE servers; using the default STUN server.', err);
+        }
+        return DEFAULT_ICE_SERVERS;
+      });
+    }
+    function isWebRtcKnownBlocked() {
+      try {
+        return window.sessionStorage.getItem(REALTIME_WEBRTC_BLOCKED_KEY) === '1';
+      } catch (err) {
+        return false;
+      }
+    }
+    function rememberWebRtcBlocked() {
+      try {
+        window.sessionStorage.setItem(REALTIME_WEBRTC_BLOCKED_KEY, '1');
+      } catch (err) {}
+    }
+
+    // A one-line, dismissible note under the realtime button. Shown once per browser session when voice falls
+    // back to the WebSocket transport, because the difference is audible (weaker echo handling in an open
+    // room) and users otherwise have no way to know why.
+    function showCompatibilityModeNotice() {
+      if (realtimeCompatibilityNoticeEl) {
+        return;
+      }
+      var realtimeBtn = q('realtimeButton');
+      if (!realtimeBtn) {
+        return;
+      }
+      var note = document.createElement('div');
+      note.className = 'form-text mt-2 mb-0 text-center';
+      note.setAttribute('role', 'status');
+      note.textContent = localize('compatibilityMode', 'Using compatibility audio mode. Echo cancellation may be weaker — headphones are recommended.');
+      var row = realtimeBtn.parentElement;
+      if (row && row.parentElement) {
+        row.parentElement.appendChild(note);
+      } else {
+        realtimeBtn.insertAdjacentElement('afterend', note);
+      }
+      realtimeCompatibilityNoticeEl = note;
+    }
+    function removeCompatibilityModeNotice() {
+      if (!realtimeCompatibilityNoticeEl) {
+        return;
+      }
+      try {
+        realtimeCompatibilityNoticeEl.remove();
+      } catch (err) {}
+      realtimeCompatibilityNoticeEl = null;
+    }
+    function startRealtimeConversation() {
+      if (!isRealtimeMode || isRealtimeActive || !connection) {
+        return;
+      }
+      applyRealtimeAudioPrefs(loadRealtimeAudioPrefs());
+      realtimeFellBack = false;
+      realtimeSessionReady = false;
+      realtimeEndedNotice = null;
+      clearRealtimeStatus();
+      bindRealtimeLifecycleHandlers();
+      setRealtimeState('requesting-mic');
+
+      // Prefer the WebRTC transport when the server advertises it: the browser's echo canceller references
+      // the assistant's media track, so the model can ignore its own voice with the mic open (open rooms).
+      // If the peer cannot connect (blocked UDP, no TURN, unsupported), we fall back to WebSocket at connect
+      // time — see fallbackToWebSocket. The decision is made once, before the session starts.
+      if (webRtcEnabled && !isWebRtcKnownBlocked()) {
+        startRealtimeWebRtcConversation();
+        return;
+      }
+      startRealtimeWebSocketConversation();
+    }
+    function startRealtimeWebSocketConversation() {
+      if (webRtcEnabled) {
+        showCompatibilityModeNotice();
+      }
+      attachRealtimePushToTalk();
+      // Drop focus from the just-clicked button so Space acts as push-to-talk, not a re-click.
+      var focusedBtn = q('realtimeButton');
+      if (focusedBtn) {
+        try {
+          focusedBtn.blur();
+        } catch (err) {}
+      }
+      var audioConstraints = {
+        channelCount: 1,
+        echoCancellation: {
+          ideal: true
+        },
+        noiseSuppression: true,
+        autoGainControl: true,
+        // Ask for the strongest available acoustic echo cancellation so the model can ignore its own
+        // voice in an open room (loud speakers + open mic). These are Chromium hints requested as
+        // "ideal", so any browser that doesn't support them simply ignores them — never a hard failure.
+        // echoCancellationType 'system' prefers the OS/hardware AEC over the browser's software AEC.
+        echoCancellationType: {
+          ideal: 'system'
+        },
+        voiceIsolation: {
+          ideal: true
+        }
+      };
+      if (realtimeMicDeviceId) {
+        audioConstraints.deviceId = {
+          exact: realtimeMicDeviceId
+        };
+      }
+      navigator.mediaDevices.getUserMedia({
+        audio: audioConstraints
+      }).then(function (stream) {
+        ensureConnected().then(function () {
+          realtimeStream = stream;
+          isRealtimeActive = true;
+          onActivate();
+          updateRealtimeButton();
+          setRealtimeState('connecting');
+          var AudioContextCtor = window.AudioContext || window.webkitAudioContext;
+          realtimeAudioCtx = new AudioContextCtor({
+            sampleRate: REALTIME_SAMPLE_RATE
+          });
+          // A context created under a strict autoplay policy starts suspended, and a suspended
+          // context plays nothing at all — silently. Ask for it explicitly.
+          if (realtimeAudioCtx.state === 'suspended' && typeof realtimeAudioCtx.resume === 'function') {
+            realtimeAudioCtx.resume()["catch"](function (err) {
+              setRealtimeState('playback-blocked');
+              if (window.console && console.warn) {
+                console.warn('The browser blocked realtime audio playback. Interact with the page to enable audio.', err);
+              }
+            });
+          }
+          realtimePlayHead = 0;
+          realtimeSources = [];
+          realtimeGain = realtimeAudioCtx.createGain();
+          realtimeGain.gain.value = realtimeVolume != null ? realtimeVolume : 1;
+          realtimeGain.connect(realtimeAudioCtx.destination);
+          realtimeSubject = new window.signalR.Subject();
+          var ctxAtStart = realtimeAudioCtx;
+          var processor = realtimeAudioCtx.createScriptProcessor(4096, 1, 1);
+          realtimeProcessor = processor;
+
+          // The gate watches the assistant's playback to know when it is audible; on this
+          // transport the assistant is a Web Audio graph, so tap the output gain into a stream.
+          var monitorDest = realtimeAudioCtx.createMediaStreamDestination();
+          realtimeGain.connect(monitorDest);
+
+          // Send the gated microphone rather than the raw one, exactly as the WebRTC transport
+          // does, so this fallback is not the one transport where the model hears its own echo.
+          // Until the gate's worklet is ready the processor has no input and streams silence.
+          setupMicGate(stream).then(function (micTrack) {
+            if (!isRealtimeActive || realtimeAudioCtx !== ctxAtStart || !micTrack) {
+              return;
+            }
+            var gatedStream = new MediaStream([micTrack]);
+            var source = realtimeAudioCtx.createMediaStreamSource(gatedStream);
+            realtimeMicSource = source;
+            source.connect(processor);
+            if (realtimeGate) {
+              realtimeGate.attachAssistantStream(monitorDest.stream);
+            }
+          });
+          processor.onaudioprocess = function (event) {
+            var input = event.inputBuffer.getChannelData(0);
+            // Always send a frame (silence when muted) so the server keeps a continuous audio
+            // stream and its voice-activity detector promptly notices the pause and responds.
+            // Muted cases: push-to-talk not held, or the echo guard while the assistant plays back.
+            var muted;
+            if (realtimePushToTalk) {
+              muted = !realtimePttActive;
+            } else {
+              muted = !realtimeBargeIn && realtimeAudioCtx && realtimeAudioCtx.currentTime < realtimePlayHead + REALTIME_WS_ECHO_HANGOVER_SEC;
+            }
+            var pcm = new Int16Array(input.length);
+            if (!muted) {
+              for (var i = 0; i < input.length; i++) {
+                var s = Math.max(-1, Math.min(1, input[i]));
+                pcm[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+              }
+            }
+            var bytes = new Uint8Array(pcm.buffer);
+            var binary = '';
+            for (var b = 0; b < bytes.length; b++) {
+              binary += String.fromCharCode(bytes[b]);
+            }
+            try {
+              realtimeSubject.next(btoa(binary));
+            } catch (err) {/* completed */}
+          };
+
+          // A zero-gain node keeps the processor alive without echoing the mic to the speakers.
+          var zeroGain = realtimeAudioCtx.createGain();
+          zeroGain.gain.value = 0;
+          realtimeZeroGain = zeroGain;
+          processor.connect(zeroGain);
+          zeroGain.connect(realtimeAudioCtx.destination);
+
+          // "Auto" means auto-detect: send nothing. Sending the browser's locale instead pinned transcription
+          // and the reply language to it, so a bilingual user with an English browser speaking Spanish
+          // got English-forced (garbage) transcripts and an English-locked assistant.
+          var language = realtimeLanguage || null;
+          var voice = getVoiceName && getVoiceName() || realtimeVoiceName || '';
+          sendStart(realtimeSubject, voice, language, null, null, realtimeBargeIn);
+          if (realtimePushToTalk) {
+            buildRealtimePttUi();
+          }
+        })["catch"](function (err) {
+          stream.getTracks().forEach(function (track) {
+            track.stop();
+          });
+          isRealtimeActive = false;
+          onDeactivate();
+          updateRealtimeButton();
+          console.error('The realtime conversation could not start because the chat connection is not available.', err);
+        });
+      })["catch"](function (err) {
+        console.error('Microphone access denied:', err);
+        isRealtimeActive = false;
+        onDeactivate();
+        updateRealtimeButton();
+      });
+    }
+
+    // --- WebRTC (server-relay) transport ---
+
+    function startRealtimeWebRtcConversation() {
+      // Keep the WebRTC capture constraints minimal. WebRTC's own echo canceller (AEC3) already references
+      // the remote assistant track we render into the hidden <audio> element, which is the entire reason we
+      // use WebRTC for open-room audio. The stronger hints we request on the WebSocket path
+      // (echoCancellationType:'system' + voiceIsolation) are counterproductive here: layered on top of the
+      // peer-connection AEC loop they gate the mic down to near-silence (~1-3% of full scale), so the model
+      // never detects speech. Ask only for standard echo cancellation and let AEC3 do its job.
+      var micConstraints = {
+        // Match what ChatGPT's voice mode requests: a plain echoCancellation:true and nothing else exotic.
+        // The browser still applies its default noise suppression and auto gain; we only pass those through
+        // so the user's toggles can turn them off.
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true
+      };
+      if (realtimeMicDeviceId) {
+        micConstraints.deviceId = {
+          exact: realtimeMicDeviceId
+        };
+      }
+      navigator.mediaDevices.getUserMedia({
+        audio: micConstraints
+      }).then(function (stream) {
+        ensureConnected().then(function () {
+          return resolveIceServers();
+        }).then(function (iceServers) {
+          realtimeStream = stream;
+          isRealtimeActive = true;
+          realtimeIsWebRtc = true;
+          onActivate();
+          updateRealtimeButton();
+          setRealtimeState('connecting');
+          realtimeRemoteDescriptionSet = false;
+          realtimePendingIce = [];
+          realtimeWebRtcConnected = false;
+          var pc = new RTCPeerConnection({
+            iceServers: iceServers
+          });
+          realtimePc = pc;
+
+          // Push-to-talk and the barge-in/echo guard both gate the outbound mic track. Wire the
+          // same push-to-talk controls the WebSocket path uses so they work on WebRTC too.
+          // Device labels only become readable after permission is granted, so this is the first
+          // chance to notice a headset (safe for full duplex) or a standalone mic in front of
+          // speakers (not). Only ever a suggestion: an explicit choice is never overridden.
+
+          attachRealtimePushToTalk();
+          var focusedBtn = q('realtimeButton');
+          if (focusedBtn) {
+            try {
+              focusedBtn.blur();
+            } catch (err) {}
+          }
+          if (realtimePushToTalk) {
+            buildRealtimePttUi();
+          }
+
+          // Play the assistant's remote track through a hidden <audio> element. This gives the
+          // browser's echo canceller a reference to remove the assistant's voice from the mic, and
+          // is what the echo-guard monitor listens to for half-duplex mic muting.
+          var audioEl = document.createElement('audio');
+          audioEl.autoplay = true;
+          audioEl.style.display = 'none';
+          audioEl.volume = Math.max(0, Math.min(1, realtimeVolume != null ? realtimeVolume : 1));
+          document.body.appendChild(audioEl);
+          realtimeRemoteAudioEl = audioEl;
+          // Route playback so the browser couples it with the mic's echo canceller as a proper
+          // AEC reference (see routeRealtimeOutputToDefaultDevice for the preference order).
+          routeRealtimeOutputToDefaultDevice(audioEl);
+          pc.ontrack = function (e) {
+            // Ask the browser to hold a fixed cushion of received audio before playing it,
+            // rather than the adaptive minimum it would otherwise pick. Network jitter then
+            // lands inside the cushion instead of making the jitter buffer stretch or speed
+            // speech up to re-adapt; the audio itself is played as received. Ignored by
+            // browsers without the property.
+            try {
+              if (e.receiver && 'jitterBufferTarget' in e.receiver) {
+                e.receiver.jitterBufferTarget = REALTIME_WEBRTC_JITTER_BUFFER_TARGET_MS;
+              }
+            } catch (err) {}
+            if (e.streams && e.streams[0]) {
+              audioEl.srcObject = e.streams[0];
+              ensureRealtimePlayback(audioEl);
+              // Let the gate watch the assistant's level so it can raise the speech threshold
+              // while the assistant talks (barge-in on) and stay closed until it finishes
+              // (barge-in off).
+              attachWebRtcAssistantAnalyser(e.streams[0]);
+            }
+          };
+          realtimeSawRelayCandidate = false;
+          pc.onicecandidate = function (e) {
+            if (e.candidate) {
+              if (e.candidate.candidate && e.candidate.candidate.indexOf(' relay ') !== -1) {
+                realtimeSawRelayCandidate = true;
+              }
+              try {
+                connection.send('AddRealtimeIceCandidate', e.candidate.candidate, e.candidate.sdpMid || '', e.candidate.sdpMLineIndex || 0);
+              } catch (err) {}
+              return;
+            }
+
+            // Gathering finished. With no relay candidate there is no path left for a network
+            // that blocks UDP, so stop waiting the full timeout for something that cannot come.
+            if (!realtimeSawRelayCandidate && !realtimeWebRtcConnected && realtimeWebRtcConnectTimer) {
+              clearTimeout(realtimeWebRtcConnectTimer);
+              realtimeWebRtcConnectTimer = setTimeout(function () {
+                if (!realtimeWebRtcConnected && isRealtimeActive) {
+                  fallbackToWebSocket('no relay candidate and no direct connection');
+                }
+              }, REALTIME_WEBRTC_NO_RELAY_TIMEOUT_MS);
+            }
+          };
+          pc.onconnectionstatechange = function () {
+            if (pc.connectionState === 'connected') {
+              markWebRtcConnected();
+            } else if (pc.connectionState === 'failed') {
+              // Before the peer connects, a failure means WebRTC is unusable here — fall back.
+              // After it connects, a drop ends the session (we never migrate mid-session).
+              if (!realtimeWebRtcConnected) {
+                fallbackToWebSocket('connection failed');
+              } else if (isRealtimeActive) {
+                stopRealtimeConversation();
+              }
+            } else if (pc.connectionState === 'closed' && isRealtimeActive && realtimeWebRtcConnected) {
+              stopRealtimeConversation();
+            }
+          };
+          pc.oniceconnectionstatechange = function () {
+            var s = pc.iceConnectionState;
+            if (s === 'connected' || s === 'completed') {
+              markWebRtcConnected();
+            } else if (s === 'failed' && !realtimeWebRtcConnected) {
+              fallbackToWebSocket('ICE failed');
+            }
+          };
+          bindWebRtcSignalingHandlers();
+
+          // Fall back to WebSocket if the peer does not connect within the timeout (blocked UDP,
+          // missing TURN, etc.). Cleared as soon as the peer connects (markWebRtcConnected).
+          realtimeWebRtcConnectTimer = setTimeout(function () {
+            if (!realtimeWebRtcConnected && isRealtimeActive) {
+              fallbackToWebSocket('connection timed out');
+            }
+          }, REALTIME_WEBRTC_CONNECT_TIMEOUT_MS);
+
+          // Send a gated version of the mic: silent unless the user is actually speaking. The gate
+          // loads an AudioWorklet, so the track is only available once that resolves — hence the
+          // offer is created here rather than synchronously above.
+          setupMicGate(stream).then(function (micTrackToSend) {
+            if (realtimePc !== pc) {
+              return null;
+            }
+            if (micTrackToSend) {
+              pc.addTrack(micTrackToSend, stream);
+            }
+            return pc.createOffer();
+          }).then(function (offer) {
+            if (!offer || realtimePc !== pc) {
+              return null;
+            }
+            return pc.setLocalDescription(offer).then(function () {
+              return offer;
+            });
+          }).then(function (offer) {
+            if (!offer) {
+              return;
+            }
+            // "Auto" means auto-detect: send nothing (see the WebSocket path above).
+            var language = realtimeLanguage || null;
+            var voice = getVoiceName && getVoiceName() || realtimeVoiceName || '';
+            sendStartWebRtc(offer.sdp, voice, language, null, null, realtimeBargeIn);
+          })["catch"](function (err) {
+            console.error('Failed to create the WebRTC offer; falling back to WebSocket.', err);
+            fallbackToWebSocket('offer failed');
+          });
+        })["catch"](function (err) {
+          stream.getTracks().forEach(function (t) {
+            t.stop();
+          });
+          isRealtimeActive = false;
+          realtimeIsWebRtc = false;
+          onDeactivate();
+          updateRealtimeButton();
+          console.error('The realtime WebRTC conversation could not start because the chat connection is not available.', err);
+        });
+      })["catch"](function (err) {
+        console.error('Microphone access denied:', err);
+        isRealtimeActive = false;
+        realtimeIsWebRtc = false;
+        onDeactivate();
+        updateRealtimeButton();
+      });
+    }
+    function bindWebRtcSignalingHandlers() {
+      if (realtimeWebRtcHandlersBound) {
+        return;
+      }
+      realtimeWebRtcHandlersBound = true;
+      connection.on('ReceiveRealtimeAnswer', function (sdp) {
+        if (!realtimePc) {
+          return;
+        }
+        realtimePc.setRemoteDescription({
+          type: 'answer',
+          sdp: sdp
+        }).then(function () {
+          realtimeRemoteDescriptionSet = true;
+          // Flush any ICE candidates that arrived before the answer was applied.
+          var pending = realtimePendingIce;
+          realtimePendingIce = [];
+          pending.forEach(function (init) {
+            try {
+              realtimePc.addIceCandidate(init)["catch"](function () {});
+            } catch (err) {}
+          });
+        })["catch"](function (err) {
+          console.error('Failed to apply the WebRTC answer.', err);
+        });
+      });
+      connection.on('ReceiveRealtimeIceCandidate', function (candidate, sdpMid, sdpMLineIndex) {
+        if (!realtimePc || !candidate) {
+          return;
+        }
+        var init = {
+          candidate: candidate,
+          sdpMid: sdpMid,
+          sdpMLineIndex: sdpMLineIndex
+        };
+        // A candidate can only be added after the remote description (answer) is set; buffer until then.
+        if (realtimeRemoteDescriptionSet) {
+          try {
+            realtimePc.addIceCandidate(init)["catch"](function () {});
+          } catch (err) {}
+        } else {
+          realtimePendingIce.push(init);
+        }
+      });
+    }
+    function stopRealtimeWebRtc() {
+      stopWebRtcEchoGuard();
+      realtimeWebRtcMicTrack = null;
+      if (realtimePc) {
+        try {
+          realtimePc.close();
+        } catch (err) {}
+        realtimePc = null;
+      }
+      if (realtimeRemoteAudioEl) {
+        try {
+          realtimeRemoteAudioEl.srcObject = null;
+          realtimeRemoteAudioEl.remove();
+        } catch (err) {}
+        realtimeRemoteAudioEl = null;
+      }
+      realtimeIsWebRtc = false;
+    }
+    function markWebRtcConnected() {
+      if (realtimeWebRtcConnected) {
+        return;
+      }
+      realtimeWebRtcConnected = true;
+      if (realtimeWebRtcConnectTimer) {
+        clearTimeout(realtimeWebRtcConnectTimer);
+        realtimeWebRtcConnectTimer = null;
+      }
+    }
+
+    // --- Microphone gate (thin wrapper over the shared factory) ----------------------------------------
+
+    // How long the gate stays open after the user's level drops. The gate is a safety net around echo, not a
+    // turn detector: the provider's turn detection sees the real speech and should be the one deciding a
+    // turn is over, so this must comfortably outlast the pause it is willing to wait through. The gate emits
+    // digital silence when it closes, and whichever of the two expires first is what actually ends the turn.
+    var REALTIME_GATE_HANGOVER_MS = 2000;
+    function realtimeGateModeMessage() {
+      return {
+        pushToTalk: !!realtimePushToTalk,
+        pttActive: !!realtimePttActive,
+        bargeIn: !!realtimeBargeIn,
+        speechHangoverMs: REALTIME_GATE_HANGOVER_MS
+      };
+    }
+
+    // The gate runs on the audio thread and cannot read this closure's variables, so every settings or
+    // push-to-talk change has to be pushed to it explicitly.
+    function syncRealtimeGateMode() {
+      if (realtimeGate) {
+        realtimeGate.setMode(realtimeGateModeMessage());
+      }
+    }
+
+    // Builds the gate and resolves with the track to send (over the peer, or into the WebSocket capture graph).
+    function setupMicGate(rawStream) {
+      stopWebRtcEchoGuard();
+      var rawTrack = rawStream && rawStream.getAudioTracks()[0] || null;
+      realtimeWebRtcMicTrack = rawTrack;
+      return createMicGate(rawStream, realtimeGateModeMessage()).then(function (gate) {
+        realtimeGate = gate;
+        if (realtimeGatePendingRemoteStream) {
+          gate.attachAssistantStream(realtimeGatePendingRemoteStream);
+        }
+        return gate.track || rawTrack;
+      });
+    }
+
+    // Feeds the assistant's remote stream into the gate so it knows when the assistant is audible — for the
+    // raised threshold with barge-in on, and for half-duplex with barge-in off. The track can arrive before
+    // the gate's worklet has finished loading, so remember it either way.
+    function attachWebRtcAssistantAnalyser(remoteStream) {
+      realtimeGatePendingRemoteStream = remoteStream || null;
+      if (realtimeGate && remoteStream) {
+        realtimeGate.attachAssistantStream(remoteStream);
+      }
+    }
+    function stopWebRtcEchoGuard() {
+      if (realtimeGate) {
+        try {
+          realtimeGate.stop();
+        } catch (e) {}
+        realtimeGate = null;
+      }
+      realtimeGatePendingRemoteStream = null;
+    }
+
+    // Route the assistant playback element so the browser's echo canceller couples to it as an AEC reference,
+    // the way ChatGPT's voice mode does. Preference order:
+    //   1. The "communications" sink (Chrome/Edge). Rendering here doesn't just pick a device — it puts the
+    //      browser's audio pipeline in COMMUNICATIONS mode, which is what actually couples playback with the
+    //      mic's echo canceller. This is what ChatGPT uses and what keeps full-duplex stable across turns.
+    //   2. The concrete device the "default" alias points at, matched by groupId.
+    // If neither alias exists — Firefox exposes only concrete outputs — we deliberately do nothing and let the
+    // browser use its own default. Picking "the first concrete output" there routed the assistant to whatever
+    // device happened to be enumerated first (often an HDMI monitor), so the assistant appeared silent.
+    // Applies the user's chosen speaker to the playing element, live.
+    function applyRealtimeOutputDevice() {
+      routeOutputToPreferredDevice(realtimeRemoteAudioEl, realtimeOutputDeviceId);
+    }
+    function routeRealtimeOutputToDefaultDevice(el) {
+      routeOutputToPreferredDevice(el, realtimeOutputDeviceId);
+    }
+    function ensureRealtimePlayback(el) {
+      ensurePlayback(el, function () {
+        setRealtimeState('playback-blocked');
+      });
+    }
+
+    // Connect-time only: tear down the failed WebRTC attempt and restart on the known-good WebSocket path.
+    // Never called once a session is established (see the connection-state handlers), so we never migrate audio
+    // mid-conversation — we only choose the transport before the model starts responding.
+    function fallbackToWebSocket(reason) {
+      if (realtimeFellBack) {
+        return;
+      }
+      realtimeFellBack = true;
+      if (realtimeWebRtcConnectTimer) {
+        clearTimeout(realtimeWebRtcConnectTimer);
+        realtimeWebRtcConnectTimer = null;
+      }
+      if (window.console && console.warn) {
+        console.warn('Realtime WebRTC transport unavailable (' + reason + '); falling back to the WebSocket transport.');
+      }
+      rememberWebRtcBlocked();
+      showCompatibilityModeNotice();
+      try {
+        if (realtimeStream) {
+          realtimeStream.getTracks().forEach(function (t) {
+            t.stop();
+          });
+        }
+      } catch (err) {}
+      realtimeStream = null;
+      stopRealtimeWebRtc();
+      realtimeIsWebRtc = false;
+      // Reset the active flag so the WebSocket start proceeds cleanly; it re-activates immediately.
+      isRealtimeActive = false;
+      startRealtimeWebSocketConversation();
+    }
+    function stopRealtimeConversation() {
+      if (!isRealtimeActive) {
+        return;
+      }
+      if (realtimeWebRtcConnectTimer) {
+        clearTimeout(realtimeWebRtcConnectTimer);
+        realtimeWebRtcConnectTimer = null;
+      }
+      isRealtimeActive = false;
+      realtimeSessionReady = false;
+      onDeactivate();
+      updateRealtimeButton();
+      detachRealtimePushToTalk();
+      removeRealtimePttUi();
+      if (!realtimeEndedNotice) {
+        setRealtimeState('idle');
+      }
+      if (realtimeIsWebRtc) {
+        stopRealtimeWebRtc();
+        try {
+          if (realtimeStream) {
+            realtimeStream.getTracks().forEach(function (t) {
+              t.stop();
+            });
+          }
+        } catch (err) {}
+        realtimeStream = null;
+        return;
+      }
+      try {
+        if (realtimeSubject) {
+          realtimeSubject.complete();
+        }
+      } catch (err) {/* already completed */}
+      realtimeSubject = null;
+      stopWebRtcEchoGuard();
+      try {
+        if (realtimeProcessor) {
+          realtimeProcessor.disconnect();
+          realtimeProcessor.onaudioprocess = null;
+        }
+      } catch (err) {}
+      try {
+        if (realtimeMicSource) {
+          realtimeMicSource.disconnect();
+        }
+      } catch (err) {}
+      try {
+        if (realtimeZeroGain) {
+          realtimeZeroGain.disconnect();
+        }
+      } catch (err) {}
+      try {
+        if (realtimeGain) {
+          realtimeGain.disconnect();
+        }
+      } catch (err) {}
+      try {
+        if (realtimeStream) {
+          realtimeStream.getTracks().forEach(function (t) {
+            t.stop();
+          });
+        }
+      } catch (err) {}
+      realtimeProcessor = null;
+      realtimeMicSource = null;
+      realtimeZeroGain = null;
+      realtimeGain = null;
+      realtimeStream = null;
+      flushRealtimePlayback();
+      try {
+        if (realtimeAudioCtx) {
+          realtimeAudioCtx.close();
+        }
+      } catch (err) {}
+      realtimeAudioCtx = null;
+    }
+    function toggleRealtime() {
+      if (isRealtimeActive) {
+        stopRealtimeConversation();
+        return;
+      }
+      startRealtimeConversation();
+    }
+
+    // Resolves with the receive-side statistics of the assistant's audio track (WebRTC transport only), in
+    // the browser's own words: packets lost, jitter, how much the jitter buffer is holding, and how often it
+    // had to conceal or time-stretch audio. Null on the WebSocket transport.
+    function getTransportStats() {
+      if (!realtimePc || typeof realtimePc.getStats !== 'function') {
+        return Promise.resolve(null);
+      }
+      return realtimePc.getStats().then(function (report) {
+        // Where playback actually goes (the "communications" sink puts Chrome's pipeline in communications
+        // mode; empty means the browser default) and the receiver's requested cushion, so a report of
+        // "sounds different in this browser" can be tied to the output path.
+        var result = {
+          transport: 'webrtc',
+          inbound: null,
+          codec: null,
+          sinkId: realtimeRemoteAudioEl && typeof realtimeRemoteAudioEl.sinkId === 'string' ? realtimeRemoteAudioEl.sinkId : null,
+          jitterBufferTargetMs: function () {
+            try {
+              var r = realtimePc.getReceivers().filter(function (x) {
+                return x.track && x.track.kind === 'audio';
+              })[0];
+              return r && 'jitterBufferTarget' in r ? r.jitterBufferTarget : null;
+            } catch (e) {
+              return null;
+            }
+          }()
+        };
+        report.forEach(function (stat) {
+          if (stat.type === 'inbound-rtp' && stat.kind === 'audio') {
+            result.inbound = {
+              packetsReceived: stat.packetsReceived,
+              packetsLost: stat.packetsLost,
+              packetsDiscarded: stat.packetsDiscarded,
+              jitterMs: typeof stat.jitter === 'number' ? Math.round(stat.jitter * 1000) : null,
+              jitterBufferDelayMs: typeof stat.jitterBufferDelay === 'number' && stat.jitterBufferEmittedCount ? Math.round(stat.jitterBufferDelay / stat.jitterBufferEmittedCount * 1000) : null,
+              totalSamplesReceived: stat.totalSamplesReceived,
+              concealedSamples: stat.concealedSamples,
+              concealmentEvents: stat.concealmentEvents,
+              silentConcealedSamples: stat.silentConcealedSamples,
+              insertedSamplesForDeceleration: stat.insertedSamplesForDeceleration,
+              removedSamplesForAcceleration: stat.removedSamplesForAcceleration,
+              audioLevel: stat.audioLevel
+            };
+            if (stat.codecId) {
+              var codec = report.get(stat.codecId);
+              if (codec) {
+                result.codec = {
+                  mimeType: codec.mimeType,
+                  clockRate: codec.clockRate,
+                  channels: codec.channels,
+                  sdpFmtpLine: codec.sdpFmtpLine
+                };
+              }
+            }
+          }
+        });
+        return result;
+      })["catch"](function () {
+        return null;
+      });
+    }
+    function playRealtimePcm(bytes) {
+      if (!realtimeAudioCtx || !bytes || bytes.length < 2) {
+        return;
+      }
+      var ctx = realtimeAudioCtx;
+      var sampleCount = Math.floor(bytes.length / 2);
+      var pcm = new Int16Array(bytes.buffer, bytes.byteOffset, sampleCount);
+      var f32 = new Float32Array(sampleCount);
+      for (var i = 0; i < sampleCount; i++) {
+        f32[i] = pcm[i] / 0x8000;
+      }
+      var buffer = ctx.createBuffer(1, sampleCount, ctx.sampleRate);
+      buffer.copyToChannel(f32, 0);
+      var src = ctx.createBufferSource();
+      src.buffer = buffer;
+      src.connect(realtimeGain || ctx.destination);
+      var now = ctx.currentTime;
+      if (realtimePlayHead < now) {
+        realtimePlayHead = now;
+      }
+      src.start(realtimePlayHead);
+      realtimePlayHead += buffer.duration;
+      realtimeSources.push(src);
+      src.onended = function () {
+        realtimeSources = realtimeSources.filter(function (s) {
+          return s !== src;
+        });
+      };
+    }
+    function flushRealtimePlayback() {
+      realtimeSources.forEach(function (s) {
+        try {
+          s.stop();
+        } catch (err) {}
+      });
+      realtimeSources = [];
+      if (realtimeAudioCtx) {
+        realtimePlayHead = realtimeAudioCtx.currentTime;
+      }
+    }
+    function isRealtimeDeployment(deploymentName) {
+      if (!deploymentName) {
+        return false;
+      }
+      return realtimeCapableDeployments.indexOf(deploymentName.toLowerCase()) !== -1;
+    }
+
+    // --- Wire up ---
+    var realtimeBtn = q('realtimeButton');
+    if (realtimeBtn) {
+      realtimeBtn.addEventListener('click', function (e) {
+        // Ignore keyboard-synthesized clicks (Space/Enter) during an active realtime session, so a
+        // push-to-talk Space press can never toggle the session off.
+        if (e && e.detail === 0 && isRealtimeActive) {
+          return;
+        }
+        toggleRealtime();
+      });
+      setupRealtimeAudioSettings();
+    }
+    var deploymentSelect = q('deploymentSelect');
+    if (deploymentSelect) {
+      deploymentSelect.addEventListener('change', function () {
+        applyRealtimeMode(isRealtimeDeployment(deploymentSelect.value));
+      });
+    }
+
+    // Apply the initial input mode: audio-only when the interaction already uses a realtime deployment.
+    applyRealtimeMode(isRealtimeMode || deploymentSelect && isRealtimeDeployment(deploymentSelect.value));
+    var controller = {
+      toggle: toggleRealtime,
+      start: startRealtimeConversation,
+      stop: stopRealtimeConversation,
+      applyMode: applyRealtimeMode,
+      isRealtimeDeployment: isRealtimeDeployment,
+      receivePcm: playRealtimePcm,
+      isActive: function isActive() {
+        return isRealtimeActive;
+      },
+      getState: function getState() {
+        return realtimeState;
+      },
+      // The gate's most recent measurement (level, tracked noise floor, open/closed, assistant audible), for
+      // hosts that want to render a microphone meter or explain why the mic is muted.
+      getGateLevel: function getGateLevel() {
+        return realtimeGate ? realtimeGate.getLevel() : null;
+      },
+      // The browser's own receive-side statistics for the assistant's audio on the WebRTC transport
+      // (packets lost, jitter, jitter-buffer delay, concealment), for diagnosing choppy playback.
+      getTransportStats: getTransportStats
+    };
+
+    // The most recently attached controller, for diagnostics from the console or a test.
+    window.CoreAIRealtime.activeController = controller;
+    return controller;
+  }
+  window.CoreAIRealtime = {
+    attach: attach,
+    createMicGate: createMicGate,
+    // Exposed for tests: the gate's rules are where every one of its historical failures lived, and they are
+    // far easier to pin down with numbers than with audio.
+    decideGate: coreAiGateDecide,
+    createGateState: createGateState,
+    rmsDb: coreAiRmsDb,
+    // Host-agnostic playback helpers, so a host that drives realtime itself still shares one implementation
+    // of these rather than growing its own.
+    routeOutputToPreferredDevice: routeOutputToPreferredDevice,
+    ensurePlayback: ensurePlayback
+  };
+})(window, document);
+//# sourceMappingURL=realtime-audio.js.map