@pellux/goodvibes-tui 0.19.31 → 0.19.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.31",
+  "version": "0.19.33",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -91,7 +91,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "^0.25.6",
+    "@pellux/goodvibes-sdk": "0.25.8",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/audio/player.ts

@@ -0,0 +1,156 @@
+import { accessSync, constants } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { spawn } from 'node:child_process';
+import type { Writable } from 'node:stream';
+import type { VoiceAudioChunk } from '@pellux/goodvibes-sdk/platform/voice/index';
+
+export interface StreamingAudioPlayerCommand {
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly label: string;
+}
+
+export interface StreamingAudioPlayer {
+  readonly label: string;
+  readonly available: boolean;
+  play(chunks: AsyncIterable<VoiceAudioChunk>, options: StreamingAudioPlaybackOptions): Promise<void>;
+  stop(): void;
+}
+
+export interface StreamingAudioPlaybackOptions {
+  readonly format?: string;
+  readonly signal?: AbortSignal;
+}
+
+interface SpawnProcess {
+  readonly stdin: Writable;
+  once(event: 'close', listener: () => void): this;
+  kill(signal?: NodeJS.Signals | number): boolean;
+}
+type SpawnProcessFactory = (command: string, args: readonly string[]) => SpawnProcess;
+
+export interface LocalStreamingAudioPlayerOptions {
+  readonly env?: NodeJS.ProcessEnv;
+  readonly spawnProcess?: SpawnProcessFactory;
+}
+
+export class LocalStreamingAudioPlayer implements StreamingAudioPlayer {
+  readonly command: StreamingAudioPlayerCommand | null;
+  private activeProcess: SpawnProcess | null = null;
+  private readonly spawnProcess: SpawnProcessFactory;
+
+  constructor(options: LocalStreamingAudioPlayerOptions = {}) {
+    this.command = resolveStreamingAudioPlayerCommand(options.env ?? process.env);
+    this.spawnProcess = options.spawnProcess ?? defaultSpawnProcess;
+  }
+
+  get label(): string {
+    return this.command?.label ?? 'no streaming audio player found';
+  }
+
+  get available(): boolean {
+    return this.command !== null;
+  }
+
+  async play(chunks: AsyncIterable<VoiceAudioChunk>, options: StreamingAudioPlaybackOptions = {}): Promise<void> {
+    if (!this.command) {
+      throw new Error('No streaming audio player found. Install mpv or ffplay to use /tts live playback.');
+    }
+    if (options.signal?.aborted) return;
+
+    const proc = this.spawnProcess(this.command.command, buildPlayerArgs(this.command, options.format));
+    this.activeProcess = proc;
+    const abort = () => {
+      try { proc.stdin.destroy(); } catch { /* ignore */ }
+      try { proc.kill('SIGTERM'); } catch { /* ignore */ }
+    };
+    options.signal?.addEventListener('abort', abort, { once: true });
+
+    try {
+      for await (const chunk of chunks) {
+        if (options.signal?.aborted) break;
+        if (chunk.data.byteLength === 0) continue;
+        await writeStdin(proc, chunk.data);
+      }
+      proc.stdin.end();
+      await waitForExit(proc);
+    } finally {
+      options.signal?.removeEventListener('abort', abort);
+      if (this.activeProcess === proc) this.activeProcess = null;
+    }
+  }
+
+  stop(): void {
+    const proc = this.activeProcess;
+    this.activeProcess = null;
+    if (!proc) return;
+    try { proc.stdin.destroy(); } catch { /* ignore */ }
+    try { proc.kill('SIGTERM'); } catch { /* ignore */ }
+  }
+}
+
+export function resolveStreamingAudioPlayerCommand(env: NodeJS.ProcessEnv = process.env): StreamingAudioPlayerCommand | null {
+  const mpv = findExecutable('mpv', env);
+  if (mpv) {
+    return {
+      command: mpv,
+      args: ['--no-terminal', '--really-quiet', '--force-window=no', '--cache=no', '-'],
+      label: 'mpv',
+    };
+  }
+  const ffplay = findExecutable('ffplay', env);
+  if (ffplay) {
+    return {
+      command: ffplay,
+      args: ['-nodisp', '-autoexit', '-loglevel', 'error', '-i', 'pipe:0'],
+      label: 'ffplay',
+    };
+  }
+  return null;
+}
+
+function buildPlayerArgs(command: StreamingAudioPlayerCommand, format?: string): readonly string[] {
+  if (command.label !== 'ffplay' || !format) return command.args;
+  const normalized = format.trim().toLowerCase();
+  if (!normalized || normalized.includes('/')) return command.args;
+  return ['-nodisp', '-autoexit', '-loglevel', 'error', '-f', normalized, '-i', 'pipe:0'];
+}
+
+function findExecutable(name: string, env: NodeJS.ProcessEnv): string | null {
+  const pathValue = env.PATH ?? '';
+  const extensions = process.platform === 'win32'
+    ? ['', '.exe', '.cmd', '.bat']
+    : [''];
+  for (const dir of pathValue.split(delimiter)) {
+    if (!dir) continue;
+    for (const ext of extensions) {
+      const candidate = join(dir, `${name}${ext}`);
+      try {
+        accessSync(candidate, constants.X_OK);
+        return candidate;
+      } catch {
+        // Keep scanning PATH.
+      }
+    }
+  }
+  return null;
+}
+
+function defaultSpawnProcess(command: string, args: readonly string[]): SpawnProcess {
+  return spawn(command, [...args], { stdio: ['pipe', 'ignore', 'ignore'] });
+}
+
+function writeStdin(proc: SpawnProcess, data: Uint8Array): Promise<void> {
+  return new Promise((resolve, reject) => {
+    proc.stdin.write(Buffer.from(data), (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+
+function waitForExit(proc: SpawnProcess): Promise<void> {
+  return new Promise((resolve) => {
+    proc.once('close', () => resolve());
+  });
+}

package/src/audio/spoken-turn-controller.ts

@@ -0,0 +1,200 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config/schema';
+import type { TurnEvent } from '@pellux/goodvibes-sdk/platform/runtime/events/index';
+import type { VoiceService, VoiceSynthesisStreamResult } from '@pellux/goodvibes-sdk/platform/voice/index';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+import { TtsTextChunker } from './text-chunker.ts';
+import type { StreamingAudioPlayer } from './player.ts';
+
+export interface SpokenTurnControllerOptions {
+  readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly player: StreamingAudioPlayer;
+  readonly notify?: (message: string) => void;
+  readonly now?: () => number;
+  readonly setInterval?: typeof setInterval;
+  readonly clearInterval?: typeof clearInterval;
+}
+
+export class SpokenTurnController {
+  private pendingPrompt: string | null = null;
+  private activeTurnId: string | null = null;
+  private chunker: TtsTextChunker | null = null;
+  private chunkSequence = 0;
+  private playbackChain: Promise<void> = Promise.resolve();
+  private readonly abortControllers = new Set<AbortController>();
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private errorReportedForTurn = false;
+  private readonly voiceService: Pick<VoiceService, 'synthesizeStream'>;
+  private readonly configManager: Pick<ConfigManager, 'get'>;
+  private readonly player: StreamingAudioPlayer;
+  private readonly notify?: (message: string) => void;
+  private readonly now: () => number;
+  private readonly setIntervalImpl: typeof setInterval;
+  private readonly clearIntervalImpl: typeof clearInterval;
+
+  constructor(options: SpokenTurnControllerOptions) {
+    this.voiceService = options.voiceService;
+    this.configManager = options.configManager;
+    this.player = options.player;
+    this.notify = options.notify;
+    this.now = options.now ?? (() => Date.now());
+    this.setIntervalImpl = options.setInterval ?? setInterval;
+    this.clearIntervalImpl = options.clearInterval ?? clearInterval;
+  }
+
+  submitNextTurn(prompt: string): boolean {
+    const normalized = prompt.trim();
+    if (!normalized) return false;
+    this.stop();
+    if (!this.player.available) {
+      this.notify?.('[TTS] Text response will continue, but live audio is unavailable. Install mpv or ffplay.');
+      return false;
+    }
+    this.pendingPrompt = normalized;
+    return true;
+  }
+
+  stop(message?: string): void {
+    this.pendingPrompt = null;
+    this.activeTurnId = null;
+    this.chunker?.reset();
+    this.chunker = null;
+    this.stopTimer();
+    for (const controller of this.abortControllers) controller.abort();
+    this.abortControllers.clear();
+    this.player.stop();
+    this.playbackChain = Promise.resolve();
+    this.errorReportedForTurn = false;
+    if (message) this.notify?.(`[TTS] ${message}`);
+  }
+
+  handleTurnEvent(event: TurnEvent): void {
+    if (event.type === 'TURN_SUBMITTED') {
+      this.maybeStartTurn(event.turnId, event.prompt);
+      return;
+    }
+    if (!this.activeTurnId || event.turnId !== this.activeTurnId) return;
+
+    if (event.type === 'STREAM_DELTA') {
+      this.enqueueChunks(this.chunker?.push(event.content) ?? []);
+      return;
+    }
+    if (event.type === 'STREAM_END' || event.type === 'TURN_COMPLETED') {
+      this.finishTurn(event.turnId);
+      return;
+    }
+    if (event.type === 'TURN_CANCEL' || event.type === 'TURN_ERROR' || event.type === 'PREFLIGHT_FAIL') {
+      this.stop(event.type === 'TURN_CANCEL' ? 'Spoken output stopped.' : 'Spoken output stopped because the turn did not complete.');
+    }
+  }
+
+  private maybeStartTurn(turnId: string, prompt: string): void {
+    if (!this.pendingPrompt) return;
+    if (prompt.trim() !== this.pendingPrompt) return;
+    this.pendingPrompt = null;
+    this.activeTurnId = turnId;
+    this.chunkSequence = 0;
+    this.errorReportedForTurn = false;
+    this.chunker = new TtsTextChunker({ now: this.now });
+    this.playbackChain = Promise.resolve();
+    this.startTimer();
+    this.notify?.(`[TTS] Live playback queued through ${this.player.label}.`);
+  }
+
+  private finishTurn(turnId: string): void {
+    if (turnId !== this.activeTurnId) return;
+    this.enqueueChunks(this.chunker?.flushAll() ?? []);
+    this.stopTimer();
+    const chain = this.playbackChain;
+    chain.finally(() => {
+      if (this.activeTurnId !== turnId) return;
+      this.activeTurnId = null;
+      this.chunker = null;
+      this.abortControllers.clear();
+    }).catch(() => {
+      // Errors are already reported in the queued task.
+    });
+  }
+
+  private startTimer(): void {
+    this.stopTimer();
+    this.timer = this.setIntervalImpl(() => {
+      if (!this.activeTurnId || !this.chunker) return;
+      this.enqueueChunks(this.chunker.flushDue());
+    }, 250);
+  }
+
+  private stopTimer(): void {
+    if (!this.timer) return;
+    this.clearIntervalImpl(this.timer);
+    this.timer = null;
+  }
+
+  private enqueueChunks(chunks: readonly string[]): void {
+    for (const chunk of chunks) {
+      this.enqueueChunk(chunk);
+    }
+  }
+
+  private enqueueChunk(text: string): void {
+    const turnId = this.activeTurnId;
+    if (!turnId || !text.trim()) return;
+    const sequence = ++this.chunkSequence;
+    const abortController = new AbortController();
+    this.abortControllers.add(abortController);
+    const resultPromise = this.synthesize(text, turnId, sequence, abortController.signal)
+      .then((result) => ({ ok: true as const, result }))
+      .catch((error: unknown) => ({ ok: false as const, error }));
+
+    this.playbackChain = this.playbackChain.then(async () => {
+      if (abortController.signal.aborted) return;
+      const result = await resultPromise;
+      this.abortControllers.delete(abortController);
+      if (!result.ok) {
+        this.reportError(result.error);
+        return;
+      }
+      await this.player.play(result.result.chunks, {
+        format: String(result.result.format ?? 'mp3'),
+        signal: abortController.signal,
+      });
+    }).catch((error: unknown) => {
+      this.abortControllers.delete(abortController);
+      this.reportError(error);
+    });
+  }
+
+  private synthesize(text: string, turnId: string, sequence: number, signal: AbortSignal): Promise<VoiceSynthesisStreamResult> {
+    return this.voiceService.synthesizeStream(readOptionalConfigString(this.configManager, 'tts.provider'), {
+      text,
+      voiceId: readOptionalConfigString(this.configManager, 'tts.voice'),
+      format: 'mp3',
+      signal,
+      metadata: {
+        source: 'goodvibes-tui',
+        feature: 'live-tts',
+        turnId,
+        sequence,
+      },
+    });
+  }
+
+  private reportError(error: unknown): void {
+    if (this.errorReportedForTurn) return;
+    this.errorReportedForTurn = true;
+    this.activeTurnId = null;
+    this.chunker = null;
+    this.stopTimer();
+    for (const controller of this.abortControllers) controller.abort();
+    this.abortControllers.clear();
+    this.player.stop();
+    this.playbackChain = Promise.resolve();
+    this.notify?.(`[TTS] Live playback stopped: ${summarizeError(error)}`);
+  }
+}
+
+function readOptionalConfigString(configManager: Pick<ConfigManager, 'get'>, key: ConfigKey): string | undefined {
+  const value = String(configManager.get(key) ?? '').trim();
+  return value || undefined;
+}

package/src/audio/spoken-turn-model-routing.ts

@@ -0,0 +1,117 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { ModelDefinition, ProviderRegistry } from '@pellux/goodvibes-sdk/platform/providers/registry';
+import type { ContentPart } from '@pellux/goodvibes-sdk/platform/providers/interface';
+import type { Orchestrator, OrchestratorUserInputOptions } from '../core/orchestrator.ts';
+
+const SPOKEN_TURN_SOURCE = 'tts';
+
+type RunTurn = (
+  text: string,
+  content?: ContentPart[],
+  options?: OrchestratorUserInputOptions,
+) => Promise<void>;
+
+type PatchableOrchestrator = {
+  runTurn?: RunTurn;
+  setCoreServices: (services: { providerRegistry?: ProviderRegistry }) => void;
+};
+
+export interface SpokenTurnModelRoutingOptions {
+  readonly orchestrator: Orchestrator;
+  readonly providerRegistry: ProviderRegistry;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly notify?: (message: string) => void;
+}
+
+export function createSpokenTurnInputOptions(): OrchestratorUserInputOptions {
+  return {
+    origin: {
+      source: SPOKEN_TURN_SOURCE,
+      surface: 'tui',
+      metadata: { spokenOutput: true },
+    },
+  };
+}
+
+export function attachSpokenTurnModelRouting(options: SpokenTurnModelRoutingOptions): () => void {
+  const target = options.orchestrator as unknown as PatchableOrchestrator;
+  const originalRunTurn = target.runTurn?.bind(options.orchestrator);
+  if (!originalRunTurn) return () => {};
+
+  target.runTurn = async (text, content, inputOptions) => {
+    if (!isSpokenTurn(inputOptions)) {
+      await originalRunTurn(text, content, inputOptions);
+      return;
+    }
+
+    const override = resolveSpokenTurnModelOverride({
+      providerRegistry: options.providerRegistry,
+      configManager: options.configManager,
+      notify: options.notify,
+    });
+    if (!override) {
+      await originalRunTurn(text, content, inputOptions);
+      return;
+    }
+
+    const routedRegistry = createRoutedProviderRegistry(options.providerRegistry, override);
+    target.setCoreServices({ providerRegistry: routedRegistry });
+    try {
+      await originalRunTurn(text, content, inputOptions);
+    } finally {
+      target.setCoreServices({ providerRegistry: options.providerRegistry });
+    }
+  };
+
+  return () => {
+    target.runTurn = originalRunTurn;
+    target.setCoreServices({ providerRegistry: options.providerRegistry });
+  };
+}
+
+export function resolveSpokenTurnModelOverride(options: {
+  readonly providerRegistry: Pick<ProviderRegistry, 'listModels' | 'getCurrentModel'>;
+  readonly configManager: Pick<ConfigManager, 'get'>;
+  readonly notify?: (message: string) => void;
+}): ModelDefinition | null {
+  const modelRef = readConfigString(options.configManager, 'tts.llmModel');
+  if (!modelRef) return null;
+
+  const providerId = readConfigString(options.configManager, 'tts.llmProvider');
+  const current = options.providerRegistry.getCurrentModel();
+  const model = options.providerRegistry.listModels().find((candidate) => {
+    const refMatches = candidate.registryKey === modelRef || candidate.id === modelRef;
+    const providerMatches = !providerId || candidate.provider === providerId;
+    return refMatches && providerMatches;
+  });
+
+  if (!model) {
+    options.notify?.(`[TTS] Configured TTS LLM '${modelRef}' was not found; using current chat model.`);
+    return null;
+  }
+  if (model.selectable === false) {
+    options.notify?.(`[TTS] Configured TTS LLM '${modelRef}' is not selectable; using current chat model.`);
+    return null;
+  }
+  if ((model.registryKey ?? model.id) === (current.registryKey ?? current.id)) return null;
+  return model;
+}
+
+function isSpokenTurn(options: OrchestratorUserInputOptions | undefined): boolean {
+  return options?.origin?.source === SPOKEN_TURN_SOURCE
+    || options?.origin?.metadata?.['spokenOutput'] === true;
+}
+
+function createRoutedProviderRegistry(providerRegistry: ProviderRegistry, model: ModelDefinition): ProviderRegistry {
+  return new Proxy(providerRegistry, {
+    get(target, prop, receiver) {
+      if (prop === 'getCurrentModel') return () => model;
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+}
+
+function readConfigString(configManager: Pick<ConfigManager, 'get'>, key: 'tts.llmProvider' | 'tts.llmModel'): string {
+  return String(configManager.get(key) ?? '').trim();
+}

package/src/audio/spoken-turn-wiring.ts

@@ -0,0 +1,44 @@
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
+import type { UiRuntimeEvents } from '@pellux/goodvibes-sdk/platform/runtime/ui-events';
+import type { VoiceService } from '@pellux/goodvibes-sdk/platform/voice/index';
+import { LocalStreamingAudioPlayer } from './player.ts';
+import { SpokenTurnController } from './spoken-turn-controller.ts';
+
+export interface SpokenTurnRuntime {
+  readonly unsubs: readonly (() => void)[];
+  submitNextTurn(prompt: string): boolean;
+  stop(message?: string): void;
+}
+
+export interface WireSpokenTurnRuntimeOptions {
+  readonly voiceService: VoiceService;
+  readonly configManager: ConfigManager;
+  readonly events: UiRuntimeEvents;
+  readonly notify: (message: string) => void;
+}
+
+export function wireSpokenTurnRuntime(options: WireSpokenTurnRuntimeOptions): SpokenTurnRuntime {
+  const controller = new SpokenTurnController({
+    voiceService: options.voiceService,
+    configManager: options.configManager,
+    player: new LocalStreamingAudioPlayer(),
+    notify: options.notify,
+  });
+
+  const turns = options.events.turns;
+  const unsubs = [
+    turns.on('TURN_SUBMITTED', (event) => controller.handleTurnEvent(event)),
+    turns.on('PREFLIGHT_FAIL', (event) => controller.handleTurnEvent(event)),
+    turns.on('STREAM_DELTA', (event) => controller.handleTurnEvent(event)),
+    turns.on('STREAM_END', (event) => controller.handleTurnEvent(event)),
+    turns.on('TURN_COMPLETED', (event) => controller.handleTurnEvent(event)),
+    turns.on('TURN_ERROR', (event) => controller.handleTurnEvent(event)),
+    turns.on('TURN_CANCEL', (event) => controller.handleTurnEvent(event)),
+  ];
+
+  return {
+    unsubs,
+    submitNextTurn: (prompt) => controller.submitNextTurn(prompt),
+    stop: (message) => controller.stop(message),
+  };
+}

package/src/audio/text-chunker.ts

@@ -0,0 +1,110 @@
+export interface TtsTextChunkerOptions {
+  readonly minBoundaryChars?: number;
+  readonly maxChunkChars?: number;
+  readonly maxLatencyMs?: number;
+  readonly now?: () => number;
+}
+
+export class TtsTextChunker {
+  private buffer = '';
+  private firstBufferedAt: number | null = null;
+  private readonly minBoundaryChars: number;
+  private readonly maxChunkChars: number;
+  private readonly maxLatencyMs: number;
+  private readonly now: () => number;
+
+  constructor(options: TtsTextChunkerOptions = {}) {
+    this.minBoundaryChars = options.minBoundaryChars ?? 24;
+    this.maxChunkChars = options.maxChunkChars ?? 320;
+    this.maxLatencyMs = options.maxLatencyMs ?? 1_000;
+    this.now = options.now ?? (() => Date.now());
+  }
+
+  push(delta: string): string[] {
+    if (!delta) return [];
+    if (this.firstBufferedAt === null) this.firstBufferedAt = this.now();
+    this.buffer += delta;
+    return this.drainReady(false);
+  }
+
+  flushDue(): string[] {
+    if (!this.buffer.trim() || this.firstBufferedAt === null) return [];
+    if (this.now() - this.firstBufferedAt < this.maxLatencyMs) return [];
+    return this.drainReady(true);
+  }
+
+  flushAll(): string[] {
+    if (!this.buffer.trim()) {
+      this.buffer = '';
+      this.firstBufferedAt = null;
+      return [];
+    }
+    return [this.takeChunk(this.buffer.length)].filter(Boolean);
+  }
+
+  reset(): void {
+    this.buffer = '';
+    this.firstBufferedAt = null;
+  }
+
+  private drainReady(forceLatencyFlush: boolean): string[] {
+    const chunks: string[] = [];
+    while (this.buffer.trim()) {
+      const boundary = this.findBoundary(forceLatencyFlush);
+      if (boundary <= 0) break;
+      const chunk = this.takeChunk(boundary);
+      if (chunk) chunks.push(chunk);
+      forceLatencyFlush = false;
+    }
+    return chunks;
+  }
+
+  private findBoundary(forceLatencyFlush: boolean): number {
+    const latestSentence = this.findLatestSentenceBoundary();
+    if (latestSentence >= this.minBoundaryChars) return latestSentence;
+
+    if (this.buffer.length >= this.maxChunkChars) {
+      return this.findWordBoundaryBefore(this.maxChunkChars) || this.maxChunkChars;
+    }
+
+    if (forceLatencyFlush) {
+      return this.buffer.length;
+    }
+
+    return -1;
+  }
+
+  private findLatestSentenceBoundary(): number {
+    let best = -1;
+    for (let i = 0; i < this.buffer.length; i++) {
+      const char = this.buffer[i];
+      if (char !== '.' && char !== '!' && char !== '?' && char !== ';' && char !== ':' && char !== '\n') {
+        continue;
+      }
+      const next = this.buffer[i + 1];
+      if (i === this.buffer.length - 1 || next === undefined || /\s/.test(next)) {
+        best = i + 1;
+      }
+    }
+    return best;
+  }
+
+  private findWordBoundaryBefore(index: number): number {
+    const max = Math.min(index, this.buffer.length);
+    for (let i = max; i > 0; i--) {
+      if (/\s/.test(this.buffer[i - 1] ?? '')) return i;
+    }
+    return -1;
+  }
+
+  private takeChunk(end: number): string {
+    const raw = this.buffer.slice(0, end);
+    this.buffer = this.buffer.slice(end);
+    this.firstBufferedAt = this.buffer.trim() ? this.now() : null;
+    return normalizeSpeechText(raw);
+  }
+}
+
+export function normalizeSpeechText(text: string): string {
+  return text.replace(/\s+/g, ' ').trim();
+}