@runtypelabs/persona 3.34.1 → 3.36.0

package/src/voice/audio-playback-manager.test.ts

@@ -0,0 +1,159 @@
+// Tests for the AudioPlaybackManager PcmStreamPlayer surface: prebuffer gating,
+// onStarted-once, short/empty-reply finish, and pause/resume via AudioContext
+// suspension. Web Audio is faked — these assert scheduling decisions, not sound.
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { AudioPlaybackManager } from "./audio-playback-manager";
+
+class MockBufferSource {
+  buffer: { duration: number } | null = null;
+  onended: (() => void) | null = null;
+  startTime = -1;
+  connect() {}
+  disconnect() {}
+  start(t: number) {
+    this.startTime = t;
+  }
+  stop() {}
+}
+
+class MockAudioContext {
+  static instances: MockAudioContext[] = [];
+  state: "running" | "suspended" | "closed" = "running";
+  currentTime = 0;
+  destination = {};
+  sampleRate: number;
+  sources: MockBufferSource[] = [];
+  suspendCalls = 0;
+  resumeCalls = 0;
+
+  constructor(opts?: { sampleRate?: number }) {
+    this.sampleRate = opts?.sampleRate ?? 44100;
+    MockAudioContext.instances.push(this);
+  }
+  createBuffer(_channels: number, length: number, rate: number) {
+    const data = new Float32Array(length);
+    return { length, duration: length / rate, getChannelData: () => data };
+  }
+  createBufferSource() {
+    const s = new MockBufferSource();
+    this.sources.push(s);
+    return s as unknown as AudioBufferSourceNode;
+  }
+  async suspend() {
+    this.suspendCalls++;
+    this.state = "suspended";
+  }
+  async resume() {
+    this.resumeCalls++;
+    this.state = "running";
+  }
+  async close() {
+    this.state = "closed";
+  }
+}
+
+/** A PCM16 chunk of `n` samples (content is irrelevant — we assert scheduling). */
+const pcm = (n: number) => new Uint8Array(n * 2);
+
+describe("AudioPlaybackManager (PcmStreamPlayer surface)", () => {
+  beforeEach(() => {
+    MockAudioContext.instances = [];
+    (global as any).window = {
+      AudioContext: MockAudioContext,
+      webkitAudioContext: MockAudioContext,
+    };
+  });
+
+  afterEach(() => {
+    delete (global as any).window;
+  });
+
+  // waterline @ 24kHz / 200ms = round(24000 * 200 / 1000) = 4800 samples.
+  it("holds audio until the prebuffer waterline, then releases and fires onStarted once", () => {
+    const m = new AudioPlaybackManager(24000, { prebufferMs: 200 });
+    const started = vi.fn();
+    m.onStarted(started);
+
+    // Below the waterline: nothing is scheduled and no AudioContext is created.
+    m.enqueue(pcm(1000));
+    expect(MockAudioContext.instances).toHaveLength(0);
+    expect(started).not.toHaveBeenCalled();
+
+    // Crossing the waterline releases the whole held batch as scheduled sources.
+    m.enqueue(pcm(4000)); // 1000 + 4000 = 5000 >= 4800
+    const ctx = MockAudioContext.instances[0];
+    expect(ctx.sources).toHaveLength(2);
+    expect(started).toHaveBeenCalledTimes(1);
+
+    // Subsequent post-release chunks schedule directly and never re-fire onStarted.
+    m.enqueue(pcm(100));
+    expect(ctx.sources).toHaveLength(3);
+    expect(started).toHaveBeenCalledTimes(1);
+  });
+
+  it("plays a reply shorter than the prebuffer (markStreamEnd flushes the gate)", () => {
+    const m = new AudioPlaybackManager(24000, { prebufferMs: 200 });
+    const finished = vi.fn();
+    m.onFinished(finished);
+
+    m.enqueue(pcm(500)); // well below the 4800 waterline
+    expect(MockAudioContext.instances).toHaveLength(0);
+
+    m.markStreamEnd();
+    const ctx = MockAudioContext.instances[0];
+    expect(ctx.sources).toHaveLength(1); // released so it still plays
+    expect(finished).not.toHaveBeenCalled(); // not until the source ends
+
+    ctx.sources[0].onended?.();
+    expect(finished).toHaveBeenCalledTimes(1);
+  });
+
+  it("resolves an empty reply to finished without ever opening an AudioContext", () => {
+    const m = new AudioPlaybackManager(24000, { prebufferMs: 200 });
+    const finished = vi.fn();
+    m.onFinished(finished);
+
+    m.markStreamEnd(); // no audio ever enqueued
+    expect(finished).toHaveBeenCalledTimes(1);
+    expect(MockAudioContext.instances).toHaveLength(0);
+  });
+
+  it("pauses via AudioContext.suspend and does not auto-resume on further audio", () => {
+    const m = new AudioPlaybackManager(24000); // prebufferMs 0 → realtime, no gate
+    const started = vi.fn();
+    m.onStarted(started);
+
+    m.enqueue(pcm(100)); // schedules immediately
+    const ctx = MockAudioContext.instances[0];
+    expect(ctx.sources).toHaveLength(1);
+    expect(started).toHaveBeenCalledTimes(1);
+    expect(ctx.state).toBe("running");
+
+    m.pause();
+    expect(ctx.suspendCalls).toBe(1);
+    expect(ctx.state).toBe("suspended");
+
+    // More audio arriving while paused must NOT silently un-pause the context.
+    m.enqueue(pcm(100));
+    expect(ctx.state).toBe("suspended");
+
+    m.resume();
+    expect(ctx.resumeCalls).toBeGreaterThanOrEqual(1);
+    expect(ctx.state).toBe("running");
+  });
+
+  it("clears the started latch on flush so the next reply can fire onStarted again", () => {
+    const m = new AudioPlaybackManager(24000); // realtime: schedules on first chunk
+    const started = vi.fn();
+    m.onStarted(started);
+
+    m.enqueue(pcm(100));
+    expect(started).toHaveBeenCalledTimes(1);
+
+    m.flush();
+    const startedAgain = vi.fn();
+    m.onStarted(startedAgain);
+    m.enqueue(pcm(100));
+    expect(startedAgain).toHaveBeenCalledTimes(1);
+  });
+});

package/src/voice/audio-playback-manager.ts

@@ -1,3 +1,5 @@
+import type { PcmStreamPlayer } from "../types";
+
 /**
  * AudioPlaybackManager
  *
@@ -7,26 +9,60 @@
  * playback using AudioBufferSourceNode.
  *
  * Works on all browsers including iOS Safari (no MediaSource dependency).
+ *
+ * This is the default {@link PcmStreamPlayer} for both the realtime voice
+ * provider and the `provider: 'runtype'` "Read aloud" path. It runs entirely on
+ * the main thread, so it stays in the main bundle (no AudioWorklet module). The
+ * jitter-buffered AudioWorklet player (`createPcmStreamPlayer` from
+ * `@runtypelabs/persona/voice-worklet-player`) is the higher-quality, opt-in
+ * alternative — inject it via `voiceRecognition.provider.runtype.createPlaybackEngine`
+ * or `textToSpeech.createPlaybackEngine` and it lands in the consumer's bundle.
+ *
+ * With the default `prebufferMs: 0` this behaves exactly like a bare scheduler
+ * (the realtime path), so that path is unchanged. A non-zero `prebufferMs`
+ * (the read-aloud path passes ~200) holds incoming audio until a waterline of
+ * samples is buffered before starting, and re-enters buffering on underrun —
+ * softening the schedule-clock snap that a hand-scheduled BufferSource otherwise
+ * turns into a click on bursty HTTP-streamed audio. This is a pragmatic
+ * approximation of the worklet's audio-thread silence, not parity.
  */
-export class AudioPlaybackManager {
+export class AudioPlaybackManager implements PcmStreamPlayer {
   private ctx: AudioContext | null = null;
   private nextStartTime = 0;
   private activeSources: AudioBufferSourceNode[] = [];
   private finishedCallbacks: (() => void)[] = [];
+  private startedCallbacks: (() => void)[] = [];
   private playing = false;
   private streamEnded = false;
   private pendingCount = 0;
+  // Fires once per playback session when the first sample is actually scheduled
+  // (loading→playing). Cleared by flush(); a mid-reply underrun does not re-fire.
+  private started = false;
+  // Explicit user pause via pause(); kept separate from the AudioContext's
+  // autoplay-policy suspension so ensureContext() doesn't auto-resume over it.
+  private userPaused = false;
+
+  // Prebuffer gate: while `buffering`, incoming samples accumulate in
+  // `pendingBuffers` until they reach `waterlineSamples`, then release into the
+  // scheduler. With `waterlineSamples === 0` the gate is off (realtime default).
+  private buffering: boolean;
+  private pendingBuffers: Float32Array[] = [];
+  private pendingSamples = 0;
 
   // PCM format constants
   private readonly sampleRate: number;
+  private readonly waterlineSamples: number;
 
   // Remainder byte from a previous chunk when the chunk had an odd byte count.
   // Network chunks don't respect 2-byte sample boundaries, so we carry over
   // the orphaned byte and prepend it to the next chunk.
   private remainder: Uint8Array | null = null;
 
-  constructor(sampleRate = 24000) {
+  constructor(sampleRate = 24000, options: { prebufferMs?: number } = {}) {
     this.sampleRate = sampleRate;
+    const prebufferMs = Math.max(0, options.prebufferMs ?? 0);
+    this.waterlineSamples = Math.round((sampleRate * prebufferMs) / 1000);
+    this.buffering = this.waterlineSamples > 0;
   }
 
   /**
@@ -41,8 +77,9 @@ export class AudioPlaybackManager {
       this.ctx = new AudioCtx({ sampleRate: this.sampleRate }) as AudioContext;
     }
     const ctx = this.ctx!;
-    // Resume if suspended (autoplay policy)
-    if (ctx.state === "suspended") {
+    // Resume if suspended (autoplay policy) — but never override an explicit
+    // user pause(): more audio may still stream in while paused.
+    if (ctx.state === "suspended" && !this.userPaused) {
       ctx.resume();
     }
     return ctx;
@@ -73,34 +110,17 @@ export class AudioPlaybackManager {
 
     if (data.length === 0) return;
 
-    const ctx = this.ensureContext();
     const float32 = this.pcmToFloat32(data);
+    if (float32.length === 0) return;
 
-    const buffer = ctx.createBuffer(1, float32.length, this.sampleRate);
-    buffer.getChannelData(0).set(float32);
-
-    const source = ctx.createBufferSource();
-    source.buffer = buffer;
-    source.connect(ctx.destination);
-
-    // Schedule gap-free playback
-    const now = ctx.currentTime;
-    if (this.nextStartTime < now) {
-      this.nextStartTime = now;
+    if (this.buffering) {
+      // Hold until the prebuffer waterline fills, then release as a batch.
+      this.pendingBuffers.push(float32);
+      this.pendingSamples += float32.length;
+      if (this.pendingSamples >= this.waterlineSamples) this.releaseBuffer();
+    } else {
+      this.scheduleSamples(float32);
     }
-    source.start(this.nextStartTime);
-    this.nextStartTime += buffer.duration;
-
-    this.activeSources.push(source);
-    this.pendingCount++;
-    this.playing = true;
-
-    source.onended = () => {
-      const idx = this.activeSources.indexOf(source);
-      if (idx !== -1) this.activeSources.splice(idx, 1);
-      this.pendingCount--;
-      this.checkFinished();
-    };
   }
 
   /**
@@ -108,6 +128,9 @@ export class AudioPlaybackManager {
    * The onFinished callback fires after all queued audio has played.
    */
   markStreamEnd(): void {
+    // A reply shorter than the prebuffer never reaches the waterline; release
+    // whatever we held so it still plays.
+    if (this.pendingBuffers.length > 0) this.releaseBuffer();
     this.streamEnded = true;
     this.checkFinished();
   }
@@ -130,7 +153,13 @@ export class AudioPlaybackManager {
     this.playing = false;
     this.streamEnded = false;
     this.finishedCallbacks = [];
+    this.startedCallbacks = [];
     this.remainder = null;
+    // Reset the prebuffer gate and the started latch for the next reply.
+    this.pendingBuffers = [];
+    this.pendingSamples = 0;
+    this.buffering = this.waterlineSamples > 0;
+    this.started = false;
   }
 
   /**
@@ -147,6 +176,30 @@ export class AudioPlaybackManager {
     this.finishedCallbacks.push(callback);
   }
 
+  /**
+   * Register a callback fired once when audible playback first begins (the first
+   * sample is scheduled, after any prebuffer). Cleared by {@link flush}; a
+   * mid-reply underrun re-buffer does not re-fire it.
+   */
+  onStarted(callback: () => void): void {
+    this.startedCallbacks.push(callback);
+  }
+
+  /**
+   * Pause playback. Suspends the AudioContext clock; queued/scheduled audio
+   * freezes in place and {@link resume} continues exactly where it left off.
+   */
+  pause(): void {
+    this.userPaused = true;
+    if (this.ctx && this.ctx.state === "running") void this.ctx.suspend();
+  }
+
+  /** Resume playback after {@link pause}. */
+  resume(): void {
+    this.userPaused = false;
+    if (this.ctx && this.ctx.state === "suspended") void this.ctx.resume();
+  }
+
   /**
    * Clean up AudioContext resources.
    */
@@ -158,8 +211,70 @@ export class AudioPlaybackManager {
     }
   }
 
+  /** Release held prebuffer samples into the scheduler in arrival order. */
+  private releaseBuffer(): void {
+    this.buffering = false;
+    const held = this.pendingBuffers;
+    this.pendingBuffers = [];
+    this.pendingSamples = 0;
+    for (const samples of held) this.scheduleSamples(samples);
+  }
+
+  /** Schedule one Float32 sample block for gap-free playback. */
+  private scheduleSamples(float32: Float32Array): void {
+    if (float32.length === 0) return;
+    const ctx = this.ensureContext();
+
+    const buffer = ctx.createBuffer(1, float32.length, this.sampleRate);
+    buffer.getChannelData(0).set(float32);
+
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.connect(ctx.destination);
+
+    const now = ctx.currentTime;
+    if (this.nextStartTime === 0) {
+      // Fresh start (first audio of this session, or after flush).
+      this.nextStartTime = now;
+    } else if (this.nextStartTime < now) {
+      // Underrun: the playhead caught up to the queue. Snap to now (a small,
+      // unavoidable gap) and, when a prebuffer is configured, re-enter buffering
+      // so subsequent chunks re-accumulate before scheduling — collapsing a
+      // train of clicks into a single rebuffer.
+      this.nextStartTime = now;
+      if (this.waterlineSamples > 0) this.buffering = true;
+    }
+    source.start(this.nextStartTime);
+    this.nextStartTime += buffer.duration;
+
+    this.activeSources.push(source);
+    this.pendingCount++;
+    this.playing = true;
+
+    if (!this.started) {
+      this.started = true;
+      const cbs = this.startedCallbacks.slice();
+      this.startedCallbacks = [];
+      for (const cb of cbs) cb();
+    }
+
+    source.onended = () => {
+      const idx = this.activeSources.indexOf(source);
+      if (idx !== -1) this.activeSources.splice(idx, 1);
+      this.pendingCount--;
+      this.checkFinished();
+    };
+  }
+
   private checkFinished(): void {
-    if (this.streamEnded && this.pendingCount <= 0 && this.playing) {
+    // Fire once the stream has ended and nothing is scheduled or held. No
+    // `playing` precondition: an empty reply (markStreamEnd with no audio) must
+    // still resolve to idle, matching the worklet's immediate 'drained'.
+    if (
+      this.streamEnded &&
+      this.pendingCount <= 0 &&
+      this.pendingBuffers.length === 0
+    ) {
       this.playing = false;
       this.streamEnded = false;
       const cbs = this.finishedCallbacks.slice();

package/src/voice/browser-speech-engine.ts

@@ -0,0 +1,130 @@
+// Browser Speech Engine
+//
+// Default `SpeechEngine` for the per-message "Read aloud" action and the
+// auto-speak path, backed by the browser Web Speech API
+// (`window.speechSynthesis`). Zero-backend and offline-capable, but limited to
+// the OS/browser voice set.
+//
+// A hosted engine (Runtype TTS, ElevenLabs, a server proxy, …) implements the
+// same `SpeechEngine` interface and is supplied via
+// `textToSpeech.createEngine`; such an engine can stream PCM into the realtime
+// voice `VoicePlaybackEngine` (see `audio-playback-manager.ts`). Nothing in the
+// `ReadAloudController` is browser-specific — only this file is.
+
+import type { SpeechCallbacks, SpeechEngine, SpeechRequest } from "../types";
+
+/**
+ * Pick the best available English voice from the browser's voice list.
+ * Prefers high-quality remote/natural voices, then enhanced local voices,
+ * then standard local voices, then any English voice, then the first voice.
+ */
+export function pickBestVoice(voices: SpeechSynthesisVoice[]): SpeechSynthesisVoice {
+  // Priority list: high-quality voices across browsers/platforms.
+  const preferred = [
+    // Edge Online Natural (highest quality)
+    "Microsoft Jenny Online (Natural) - English (United States)",
+    "Microsoft Aria Online (Natural) - English (United States)",
+    "Microsoft Guy Online (Natural) - English (United States)",
+    // Google remote (good quality, cross-platform in Chrome)
+    "Google US English",
+    "Google UK English Female",
+    // Apple premium/enhanced (macOS)
+    "Ava (Premium)",
+    "Evan (Enhanced)",
+    "Samantha (Enhanced)",
+    // Apple standard (macOS/iOS)
+    "Samantha",
+    "Daniel",
+    "Karen",
+    // Windows SAPI
+    "Microsoft David Desktop - English (United States)",
+    "Microsoft Zira Desktop - English (United States)",
+  ];
+
+  for (const name of preferred) {
+    const match = voices.find((v) => v.name === name);
+    if (match) return match;
+  }
+
+  // Fallback: any English voice, then first available.
+  return voices.find((v) => v.lang.startsWith("en")) ?? voices[0];
+}
+
+export interface BrowserSpeechEngineOptions {
+  /** Custom voice picker, used when no exact `voice` name is requested. */
+  pickVoice?: (voices: SpeechSynthesisVoice[]) => SpeechSynthesisVoice;
+}
+
+/** Default `SpeechEngine` backed by the browser Web Speech API. */
+export class BrowserSpeechEngine implements SpeechEngine {
+  readonly id = "browser";
+  // speechSynthesis exposes pause()/resume(); reliable for start/stop and
+  // serviceable for pause on most engines (Chrome has known quirks on resume).
+  readonly supportsPause = true;
+
+  constructor(private options: BrowserSpeechEngineOptions = {}) {}
+
+  /** Whether the Web Speech API is available in this environment. */
+  static isSupported(): boolean {
+    return typeof window !== "undefined" && "speechSynthesis" in window;
+  }
+
+  speak(request: SpeechRequest, callbacks: SpeechCallbacks): void {
+    if (!BrowserSpeechEngine.isSupported()) {
+      callbacks.onError?.(new Error("Web Speech API is unavailable"));
+      return;
+    }
+
+    const synth = window.speechSynthesis;
+    synth.cancel();
+
+    const utterance = new SpeechSynthesisUtterance(request.text);
+    const voices = synth.getVoices();
+    if (request.voice) {
+      const match = voices.find((v) => v.name === request.voice);
+      if (match) utterance.voice = match;
+    } else if (voices.length > 0) {
+      utterance.voice = this.options.pickVoice
+        ? this.options.pickVoice(voices)
+        : pickBestVoice(voices);
+    }
+    if (request.rate !== undefined) utterance.rate = request.rate;
+    if (request.pitch !== undefined) utterance.pitch = request.pitch;
+
+    utterance.onend = () => callbacks.onEnd?.();
+    utterance.onerror = (event) => {
+      // A stop()/superseding utterance fires "canceled"/"interrupted" — that's
+      // a normal end of playback, not an error worth surfacing. `event` is a
+      // SpeechSynthesisErrorEvent, so `.error` is the failure reason.
+      const reason = event.error;
+      if (reason === "canceled" || reason === "interrupted") {
+        callbacks.onEnd?.();
+      } else {
+        callbacks.onError?.(new Error(reason || "Speech synthesis failed"));
+      }
+    };
+
+    // Chrome bug: cancel() immediately followed by speak() can drop rate/pitch.
+    // A short delay lets the engine reset before the new utterance starts.
+    setTimeout(() => {
+      synth.speak(utterance);
+      // `utterance.onstart` is unreliable across browsers — Chrome can leave it
+      // unfired even while actively speaking, which would strand the UI in the
+      // "loading" state. Browser TTS has no real async prepare phase, so treat
+      // scheduling as the start; onend/onerror still drive the return to idle.
+      callbacks.onStart?.();
+    }, 50);
+  }
+
+  pause(): void {
+    if (BrowserSpeechEngine.isSupported()) window.speechSynthesis.pause();
+  }
+
+  resume(): void {
+    if (BrowserSpeechEngine.isSupported()) window.speechSynthesis.resume();
+  }
+
+  stop(): void {
+    if (BrowserSpeechEngine.isSupported()) window.speechSynthesis.cancel();
+  }
+}

package/src/voice/fallback-speech-engine.ts

@@ -0,0 +1,89 @@
+// Fallback Speech Engine
+//
+// Composes a primary `SpeechEngine` with a fallback one (typically a hosted
+// engine + the browser Web Speech API). If the primary fails *before* any audio
+// is audible — a missing/404 endpoint, a network error, an auth failure — the
+// fallback transparently takes over for that utterance, so the "Read aloud"
+// button is never left broken. A failure that happens *after* playback has
+// started (a mid-stream drop) is surfaced as a real error instead of restarting
+// from the top.
+//
+// This is what makes `textToSpeech: { provider: 'runtype' }` safe to ship before
+// (or independently of) the Runtype TTS endpoint: it speaks with the browser
+// voice today and auto-upgrades to Runtype voices the moment the endpoint
+// answers. Set `browserFallback: false` to opt out and surface Runtype errors.
+
+import type { SpeechCallbacks, SpeechEngine, SpeechRequest } from "../types";
+
+export interface FallbackSpeechEngineOptions {
+  /**
+   * Called once when the primary engine fails before audio starts and the
+   * fallback takes over — so a silent downgrade is still observable in dev/
+   * telemetry even though the user keeps hearing speech.
+   */
+  onFallback?: (error: Error) => void;
+}
+
+/** A `SpeechEngine` that falls back from `primary` to `fallback` per utterance. */
+export class FallbackSpeechEngine implements SpeechEngine {
+  readonly id = "fallback";
+
+  // Whichever engine is currently driving playback, so pause/resume/stop route
+  // to the right one after a fallback has (or hasn't) kicked in.
+  private active: SpeechEngine;
+
+  constructor(
+    private readonly primary: SpeechEngine,
+    private readonly fallback: SpeechEngine,
+    private readonly options: FallbackSpeechEngineOptions = {},
+  ) {
+    this.active = primary;
+  }
+
+  // Pause/resume only matters once something is playing, and both built-in
+  // engines support it; report the active engine's capability.
+  get supportsPause(): boolean {
+    return this.active.supportsPause;
+  }
+
+  speak(request: SpeechRequest, callbacks: SpeechCallbacks): void {
+    this.active = this.primary;
+    let started = false;
+
+    this.primary.speak(request, {
+      onStart: () => {
+        started = true;
+        callbacks.onStart?.();
+      },
+      onEnd: () => callbacks.onEnd?.(),
+      onError: (error) => {
+        // A failure once audio is playing is a genuine error — don't restart.
+        if (started) {
+          callbacks.onError?.(error);
+          return;
+        }
+        // Pre-start failure: silently hand the utterance to the fallback.
+        this.options.onFallback?.(error);
+        this.active = this.fallback;
+        this.fallback.speak(request, callbacks);
+      },
+    });
+  }
+
+  pause(): void {
+    this.active.pause();
+  }
+
+  resume(): void {
+    this.active.resume();
+  }
+
+  stop(): void {
+    this.active.stop();
+  }
+
+  destroy(): void {
+    this.primary.destroy?.();
+    this.fallback.destroy?.();
+  }
+}

package/src/voice/index.ts

@@ -14,3 +14,24 @@ export {
   createBestAvailableVoiceProvider,
   isVoiceSupported
 } from './voice-factory';
+
+export {
+  BrowserSpeechEngine,
+  pickBestVoice,
+  type BrowserSpeechEngineOptions
+} from './browser-speech-engine';
+
+// NOTE: RuntypeSpeechEngine is intentionally NOT re-exported here. It pairs with
+// the AudioWorklet player (`worklet-playback-engine`) and ships from the
+// `@runtypelabs/persona/voice-worklet-player` subpath; `session.ts` lazy-imports
+// it so its module only evaluates when `provider: 'runtype'` actually plays audio.
+// FallbackSpeechEngine's value export lives on the
+// `@runtypelabs/persona/voice-worklet-player` subpath so the hosted read-aloud
+// path can be deferred to the `runtype-tts.js` chunk; only the (erased) type is
+// re-exported here for `session.ts`.
+export type { FallbackSpeechEngineOptions } from './fallback-speech-engine';
+
+export {
+  ReadAloudController,
+  type ReadAloudListener
+} from './read-aloud-controller';