@runtypelabs/persona 4.25.0 → 4.26.1

package/src/voice/read-aloud-controller.ts

@@ -18,37 +18,39 @@ export type ReadAloudListener = (
 ) => void;
 
 export class ReadAloudController {
-  private engine: SpeechEngine | null = null;
-  private activeId: string | null = null;
-  private state: ReadAloudState = "idle";
-  private listeners = new Set<ReadAloudListener>();
+  #engine: SpeechEngine | null = null;
+  #activeId: string | null = null;
+  #state: ReadAloudState = "idle";
+  #listeners = new Set<ReadAloudListener>();
   // Bumped on every play/stop so a late async engine creation or a stale
   // utterance callback from a superseded request can't mutate current state.
-  private generation = 0;
+  #generation = 0;
 
+  #resolveEngine: () => SpeechEngine | Promise<SpeechEngine> | null;
   constructor(
-    private resolveEngine: () => SpeechEngine | Promise<SpeechEngine> | null
-  ) {}
+    resolveEngine: () => SpeechEngine | Promise<SpeechEngine> | null
+  ) {
+    this.#resolveEngine = resolveEngine;}
 
   /** Whether the active engine supports pause/resume (vs. stop-only). */
   get supportsPause(): boolean {
-    return this.engine?.supportsPause ?? true;
+    return this.#engine?.supportsPause ?? true;
   }
 
   /** Playback state for a message id (`idle` unless it's the active message). */
   stateFor(id: string): ReadAloudState {
-    return this.activeId === id ? this.state : "idle";
+    return this.#activeId === id ? this.#state : "idle";
   }
 
   /** The message currently being read aloud, if any. */
   activeMessageId(): string | null {
-    return this.activeId;
+    return this.#activeId;
   }
 
   /** Subscribe to state changes. Returns an unsubscribe function. */
   onChange(listener: ReadAloudListener): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
   }
 
   /**
@@ -57,22 +59,22 @@ export class ReadAloudController {
    * start fresh when a different message is requested.
    */
   toggle(id: string, request: SpeechRequest): void {
-    if (this.activeId === id) {
-      if (this.state === "playing") {
-        if (this.engine?.supportsPause) {
-          this.engine.pause();
-          this.set(id, "paused");
+    if (this.#activeId === id) {
+      if (this.#state === "playing") {
+        if (this.#engine?.supportsPause) {
+          this.#engine.pause();
+          this.#set(id, "paused");
         } else {
           this.stop();
         }
         return;
       }
-      if (this.state === "paused") {
-        this.engine?.resume();
-        this.set(id, "playing");
+      if (this.#state === "paused") {
+        this.#engine?.resume();
+        this.#set(id, "playing");
         return;
       }
-      if (this.state === "loading") {
+      if (this.#state === "loading") {
         this.stop();
         return;
       }
@@ -82,55 +84,55 @@ export class ReadAloudController {
 
   /** Start (or restart) playback for a message, stopping any current playback. */
   async play(id: string, request: SpeechRequest): Promise<void> {
-    const generation = ++this.generation;
-    this.engine?.stop();
-    this.set(id, "loading");
+    const generation = ++this.#generation;
+    this.#engine?.stop();
+    this.#set(id, "loading");
 
     try {
-      if (!this.engine) {
-        const resolved = await this.resolveEngine();
-        if (generation !== this.generation) return; // superseded mid-resolve
+      if (!this.#engine) {
+        const resolved = await this.#resolveEngine();
+        if (generation !== this.#generation) return; // superseded mid-resolve
         if (!resolved) {
-          this.set(null, "idle");
+          this.#set(null, "idle");
           return;
         }
-        this.engine = resolved;
+        this.#engine = resolved;
       }
 
-      this.engine.speak(request, {
+      this.#engine.speak(request, {
         onStart: () => {
-          if (generation === this.generation) this.set(id, "playing");
+          if (generation === this.#generation) this.#set(id, "playing");
         },
         onEnd: () => {
-          if (generation === this.generation) this.set(null, "idle");
+          if (generation === this.#generation) this.#set(null, "idle");
         },
         onError: () => {
-          if (generation === this.generation) this.set(null, "idle");
+          if (generation === this.#generation) this.#set(null, "idle");
         },
       });
     } catch {
-      if (generation === this.generation) this.set(null, "idle");
+      if (generation === this.#generation) this.#set(null, "idle");
     }
   }
 
   /** Stop playback and return to idle. */
   stop(): void {
-    this.generation++;
-    this.engine?.stop();
-    this.set(null, "idle");
+    this.#generation++;
+    this.#engine?.stop();
+    this.#set(null, "idle");
   }
 
   /** Drop the controller and its engine (called on widget teardown). */
   destroy(): void {
     this.stop();
-    this.engine?.destroy?.();
-    this.engine = null;
-    this.listeners.clear();
+    this.#engine?.destroy?.();
+    this.#engine = null;
+    this.#listeners.clear();
   }
 
-  private set(id: string | null, state: ReadAloudState): void {
-    this.activeId = state === "idle" ? null : id;
-    this.state = state;
-    for (const listener of this.listeners) listener(this.activeId, this.state);
+  #set(id: string | null, state: ReadAloudState): void {
+    this.#activeId = state === "idle" ? null : id;
+    this.#state = state;
+    for (const listener of this.#listeners) listener(this.#activeId, this.#state);
   }
 }

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

@@ -85,42 +85,44 @@ export class RuntypeSpeechEngine implements SpeechEngine {
   // speechSynthesis.pause().
   readonly supportsPause = true;
 
-  private player: PcmStreamPlayer | null = null;
-  private playerPromise: Promise<PcmStreamPlayer> | null = null;
+  #player: PcmStreamPlayer | null = null;
+  #playerPromise: Promise<PcmStreamPlayer> | null = null;
   // Bumped on every speak()/stop() so a superseded request's async callbacks and
   // its in-flight stream read loop become no-ops.
-  private generation = 0;
+  #generation = 0;
 
-  constructor(private readonly opts: RuntypeSpeechEngineOptions) {}
+  readonly #opts: RuntypeSpeechEngineOptions;
+  constructor(opts: RuntypeSpeechEngineOptions) {
+    this.#opts = opts;}
 
   // Create one player lazily (a worklet engine's addModule is async), then reuse
   // it across speaks; flush() between replies clears the queue without tearing
   // down the AudioContext. Defaults to the in-bundle AudioPlaybackManager.
-  private ensurePlayer(): Promise<PcmStreamPlayer> {
-    return (this.playerPromise ??= Promise.resolve(
-      this.opts.createPlaybackEngine
-        ? this.opts.createPlaybackEngine()
+  #ensurePlayer(): Promise<PcmStreamPlayer> {
+    return (this.#playerPromise ??= Promise.resolve(
+      this.#opts.createPlaybackEngine
+        ? this.#opts.createPlaybackEngine()
         : new AudioPlaybackManager(24000, {
-            prebufferMs: this.opts.prebufferMs ?? 200,
+            prebufferMs: this.#opts.prebufferMs ?? 200,
           }),
-    ).then((player) => (this.player = player)));
+    ).then((player) => (this.#player = player)));
   }
 
   speak(request: SpeechRequest, callbacks: SpeechCallbacks): void {
-    const gen = ++this.generation;
+    const gen = ++this.#generation;
     // Run the async fetch/stream without making speak() itself async — the
     // widget surfaces the time until audio starts as the "loading" state.
-    void this.run(gen, request, callbacks);
+    void this.#run(gen, request, callbacks);
   }
 
-  private async run(
+  async #run(
     gen: number,
     request: SpeechRequest,
     callbacks: SpeechCallbacks,
   ): Promise<void> {
     try {
-      const player = await this.ensurePlayer();
-      if (gen !== this.generation) return; // superseded while the worklet booted
+      const player = await this.#ensurePlayer();
+      if (gen !== this.#generation) return; // superseded while the worklet booted
       player.flush(); // drop any prior playback (and its callbacks)
       player.resume(); // clear a prior pause so this reply isn't stuck suspended
 
@@ -130,14 +132,14 @@ export class RuntypeSpeechEngine implements SpeechEngine {
       // no onStarted and an immediate onFinished, so the UI skips straight back
       // to idle without a phantom "playing".
       player.onStarted(() => {
-        if (gen === this.generation) callbacks.onStart?.();
+        if (gen === this.#generation) callbacks.onStart?.();
       });
       player.onFinished(() => {
-        if (gen === this.generation) callbacks.onEnd?.();
+        if (gen === this.#generation) callbacks.onEnd?.();
       });
 
-      const url = `${normalizeHost(this.opts.host)}/v1/agents/${encodeURIComponent(
-        this.opts.agentId,
+      const url = `${normalizeHost(this.#opts.host)}/v1/agents/${encodeURIComponent(
+        this.#opts.agentId,
       )}/speak`;
       const res = await fetch(url, {
         method: "POST",
@@ -145,21 +147,21 @@ export class RuntypeSpeechEngine implements SpeechEngine {
           "Content-Type": "application/json",
           // Match Runtype's client-token auth convention. Never placed in the
           // URL/query string.
-          Authorization: `Bearer ${this.opts.clientToken}`,
+          Authorization: `Bearer ${this.#opts.clientToken}`,
         },
         body: JSON.stringify({
           text: request.text,
-          voice: request.voice ?? this.opts.voice,
+          voice: request.voice ?? this.#opts.voice,
           format: "pcm",
         }),
       });
-      if (gen !== this.generation) return; // superseded while awaiting headers
+      if (gen !== this.#generation) return; // superseded while awaiting headers
       if (!res.ok || !res.body) throw new Error(await describeError(res));
 
       const reader = res.body.getReader();
       for (;;) {
         const { done, value } = await reader.read();
-        if (gen !== this.generation) {
+        if (gen !== this.#generation) {
           // A newer speak()/stop() won — stop pulling and release the stream.
           await reader.cancel().catch(() => {});
           return;
@@ -170,31 +172,31 @@ export class RuntypeSpeechEngine implements SpeechEngine {
 
       player.markStreamEnd();
     } catch (err) {
-      if (gen !== this.generation) return; // error from a superseded request
+      if (gen !== this.#generation) return; // error from a superseded request
       const error = err instanceof Error ? err : new Error(String(err));
-      this.opts.onError?.(error); // surface the reason (log, telemetry, …)
+      this.#opts.onError?.(error); // surface the reason (log, telemetry, …)
       callbacks.onError?.(error); // and let the widget (or fallback) react
     }
   }
 
   pause(): void {
-    this.player?.pause();
+    this.#player?.pause();
   }
 
   resume(): void {
-    this.player?.resume();
+    this.#player?.resume();
   }
 
   stop(): void {
-    this.generation++; // invalidate any in-flight stream + pending onFinished
-    this.player?.flush();
+    this.#generation++; // invalidate any in-flight stream + pending onFinished
+    this.#player?.flush();
   }
 
   destroy(): void {
-    this.generation++;
-    void this.player?.destroy();
-    this.player = null;
-    this.playerPromise = null;
+    this.#generation++;
+    void this.#player?.destroy();
+    this.#player = null;
+    this.#playerPromise = null;
   }
 }