@olares/lares-core 0.15.17 → 0.15.19

package/voice/pcm-player.js

@@ -0,0 +1,51 @@
+import { PCM_PLAYER_WORKLET } from "./pcm-worklet.js";
+import { pcmSamples } from "./realtime-audio.js";
+
+export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () => {}, context: Context = globalThis.AudioContext || globalThis.webkitAudioContext } = {}) {
+  let context, node, resolve, reject, played = 0, generation = 0, pendingByte = null, failed = null, paused = false;
+  const stop = () => {
+    generation++; paused = false; node?.disconnect(); if (node) node.port.onmessage = null; node = null;
+    if (context && context.state !== "closed") void context.close().catch(() => {}); context = null; resolve?.(); resolve = reject = null; pendingByte = null;
+  };
+  return {
+    async start({ sampleRate, channels, encoding }) {
+      stop(); failed = null; played = 0;
+      if (!Context || channels !== 1 || encoding !== "pcm_s16le" || !Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) throw new Error("voice_audio_format");
+      const epoch = generation;
+      context = new Context(); const opened = context;
+      const url = URL.createObjectURL(new Blob([PCM_PLAYER_WORKLET], { type: "text/javascript" }));
+      try { await opened.audioWorklet.addModule(url); await opened.resume(); } finally { URL.revokeObjectURL(url); }
+      if (epoch !== generation) { await opened.close().catch(() => {}); throw new Error("voice_cancelled"); }
+      node = new AudioWorkletNode(opened, "lares-pcm-player", { processorOptions: { inputRate: sampleRate }, numberOfInputs: 0, numberOfOutputs: 1, outputChannelCount: [1] });
+      node.port.onmessage = ({ data }) => {
+        if (epoch !== generation) return;
+        if (data.type === "progress") { played = data.frames; onProgress(played); }
+        if (data.type === "started" || data.type === "underrun") onMetric({ stage: `playback_${data.type}` });
+        if (data.type === "done") { resolve?.(); resolve = reject = null; }
+        if (data.type === "error") { failed = new Error("voice_audio_backpressure"); reject?.(failed); }
+      };
+      node.connect(opened.destination);
+    },
+    write(bytes) {
+      if (!node) throw new Error("voice_cancelled");
+      let chunk = bytes;
+      if (pendingByte !== null) { chunk = new Uint8Array(bytes.length + 1); chunk[0] = pendingByte; chunk.set(bytes, 1); pendingByte = null; }
+      if (chunk.length % 2) { pendingByte = chunk[chunk.length - 1]; chunk = chunk.subarray(0, -1); }
+      if (!chunk.length) return;
+      const samples = pcmSamples(chunk);
+      node.port.postMessage({ type: "audio", samples }, [samples.buffer]);
+    },
+    finish() {
+      if (failed) return Promise.reject(failed);
+      if (!node) return Promise.resolve();
+      if (pendingByte !== null) return Promise.reject(new Error("voice_audio_format"));
+      return new Promise((done, fail) => { resolve = done; reject = fail; node.port.postMessage({ type: "finish" }); });
+    },
+    canPause: true,
+    pause() { paused = true; node?.port.postMessage({ type: "pause" }); },
+    resume() { paused = false; node?.port.postMessage({ type: "resume" }); },
+    get paused() { return paused; },
+    playedFrames: () => played,
+    stop,
+  };
+}

package/voice/pcm-worklet.js

@@ -0,0 +1,71 @@
+/** Separate from the UI thread so rendering cannot interrupt PCM playback. */
+export const PCM_PLAYER_WORKLET = `
+class LaresPcmPlayer extends AudioWorkletProcessor {
+  constructor(options) {
+    super(); this.queue = []; this.offset = 0; this.frames = 0; this.reported = 0;
+    this.rate = options.processorOptions.inputRate; this.step = this.rate / sampleRate;
+    this.paused = false; this.queued = 0; this.finished = false; this.started = false; this.starved = false;
+    this.port.onmessage = ({ data }) => {
+      if (data.type === 'audio') {
+        if (this.queued + data.samples.length > this.rate * 4) { this.port.postMessage({ type: 'error' }); return; }
+        this.queue.push(data.samples); this.queued += data.samples.length;
+      } else if (data.type === 'finish') this.finished = true;
+      else if (data.type === 'pause') this.paused = true;
+      else if (data.type === 'resume') this.paused = false;
+    };
+  }
+  process(inputs, outputs) {
+    const out = outputs[0][0];
+    out.fill(0);
+    if (this.paused) return true;
+    for (let i = 0; i < out.length; i++) {
+      while (this.queue.length && this.offset >= this.queue[0].length) {
+        const head = this.queue.shift(); this.offset -= head.length; this.queued -= head.length;
+        this.frames += head.length;
+      }
+      const head = this.queue[0];
+      if (!head) {
+        if (this.finished) { this.port.postMessage({ type: 'progress', frames: this.frames }); this.port.postMessage({ type: 'done' }); return false; }
+        if (this.started && !this.starved) this.port.postMessage({ type: 'underrun' });
+        this.starved = true; continue;
+      }
+      const at = Math.floor(this.offset), fraction = this.offset - at;
+      // Interpolate across transport blocks; never clamp an unfinished block's edge.
+      let next = head[at + 1];
+      if (next === undefined) next = this.queue[1]?.[0];
+      if (fraction > 0 && next === undefined && !this.finished) {
+        if (this.started && !this.starved) this.port.postMessage({ type: 'underrun' });
+        this.starved = true; break;
+      }
+      if (!this.started) { this.started = true; this.port.postMessage({ type: 'started' }); }
+      this.starved = false;
+      out[i] = head[at] * (1 - fraction) + (next ?? head[at]) * fraction;
+      this.offset += this.step;
+    }
+    const played = this.frames + Math.min(this.queue[0]?.length || 0, Math.floor(this.offset));
+    if (played - this.reported >= this.rate * 0.05) { this.reported = played; this.port.postMessage({ type: 'progress', frames: played }); }
+    return true;
+  }
+}
+registerProcessor('lares-pcm-player', LaresPcmPlayer);
+`;
+
+export const PCM_CAPTURE_WORKLET = `
+class LaresPcmCapture extends AudioWorkletProcessor {
+  constructor() {
+    super(); this.pending = new Float32Array(1024); this.length = 0;
+    this.port.onmessage = ({ data }) => { if (data.type === 'flush') { this.flush(); this.port.postMessage({ type: 'flushed' }); } };
+  }
+  flush() {
+    if (!this.length) return;
+    const samples = this.pending.slice(0, this.length); this.length = 0;
+    this.port.postMessage({ type: 'samples', samples }, [samples.buffer]);
+  }
+  process(inputs) {
+    const input = inputs[0]?.[0];
+    if (input) for (const value of input) { this.pending[this.length++] = value; if (this.length === this.pending.length) this.flush(); }
+    return true;
+  }
+}
+registerProcessor('lares-pcm-capture', LaresPcmCapture);
+`;

package/voice/preferences.js

@@ -0,0 +1,89 @@
+import { DICTATION_INSTRUCTIONS, DICTATION_PRESETS } from "./dictation.js";
+import { validateVoiceShortcuts } from "./shortcuts.js";
+
+/** Editing drafts are independent of confirmed recording configuration. Writes merge at execution time. */
+export function createVoicePreferences({ load, save }) {
+  let state = { value: null, drafts: {}, pending: {}, errors: {}, loading: false, loadError: null };
+  let serial = Promise.resolve(), loading = null;
+  const listeners = new Set();
+  const emit = patch => { state = { ...state, ...patch }; for (const listener of listeners) listener(); };
+  const dirty = id => Boolean(state.drafts[id] && JSON.stringify(state.drafts[id]) !== JSON.stringify(state.value?.config.dictationProfiles[id]));
+  const write = (key, build, accept = () => {}) => {
+    if (state.pending[key]) return state.pending[key];
+    const run = serial.catch(() => {}).then(async () => {
+      try { const next = await save(build(state.value.config)); emit({ value: next }); accept(next.config); return next; }
+      catch (error) { emit({ errors: { ...state.errors, [key]: error.reason || error.code || error.message } }); throw error; }
+      finally { const pending = { ...state.pending }; delete pending[key]; emit({ pending }); }
+    });
+    serial = run; emit({ pending: { ...state.pending, [key]: run }, errors: { ...state.errors, [key]: null } });
+    return run;
+  };
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    dirty,
+    accept(value) { emit({ value }); },
+    dirtyIds: () => Object.keys(state.drafts).filter(dirty),
+    profile: id => state.drafts[id] || state.value?.config.dictationProfiles[id],
+    async load(force = false) {
+      if (loading) return loading;
+      emit({ loading: true, loadError: null });
+      loading = load({ force, diagnostics: false }).then(value => { emit({ value }); return value; }, error => { emit({ loadError: error.code || error.message }); throw error; }).finally(() => { loading = null; emit({ loading: false }); });
+      return loading;
+    },
+    patch: partial => write(Object.keys(partial)[0], () => partial),
+    edit(id, partial) { emit({ drafts: { ...state.drafts, [id]: { ...(state.drafts[id] || state.value.config.dictationProfiles[id]), ...partial } }, errors: { ...state.errors, [`profile:${id}`]: null } }); },
+    restore(id) { this.edit(id, { instructions: DICTATION_INSTRUCTIONS[id] }); },
+    discard(ids = this.dirtyIds()) { const drafts = { ...state.drafts }, errors = { ...state.errors }; for (const id of ids) { delete drafts[id]; delete errors[`profile:${id}`]; } emit({ drafts, errors }); },
+    saveProfile(id) {
+      const take = structuredClone(this.profile(id));
+      return write(`profile:${id}`, config => ({ dictationProfiles: { ...config.dictationProfiles, [id]: take } }), () => {
+        if (JSON.stringify(state.drafts[id]) === JSON.stringify(take)) this.discard([id]);
+      });
+    },
+    async saveDirty() { for (const id of this.dirtyIds()) await this.saveProfile(id); },
+    saveTtsVoice(model, voice) { return write("ttsVoiceByModel", config => ({ ttsVoiceByModel: { ...config.ttsVoiceByModel, [model]: voice } })); },
+    saveShortcut(id, key) { return write(`shortcut:${id}`, config => ({ dictationShortcuts: validateVoiceShortcuts({ ...config.dictationShortcuts, [id]: key }) })); },
+  };
+}
+
+/** Shared three-way unsaved-edit guard; platforms only render its question. */
+export function createPreferencesGuard(preferences) {
+  let state = { open: false, saving: false, selecting: false, error: false }, pending = null, selection = null;
+  const listeners = new Set();
+  const emit = patch => { state = { ...state, ...patch }; for (const listener of listeners) listener(); };
+  const finish = value => { pending?.resolve(value); pending = null; emit({ open: false, saving: false }); };
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    request() {
+      if (pending) return pending.promise;
+      if (!preferences.dirtyIds().length) return Promise.resolve(true);
+      let resolve; const promise = new Promise(done => { resolve = done; }); pending = { promise, resolve };
+      emit({ open: true, error: false }); return promise;
+    },
+    selectPreset(id) {
+      if (!DICTATION_PRESETS.includes(id)) return Promise.reject(new Error("voice_config_invalid"));
+      if (selection) return selection;
+      if (id === preferences.getSnapshot().value.config.dictationPreset) return Promise.resolve(true);
+      emit({ selecting: true });
+      selection = (async () => {
+        try {
+          if (!await this.request()) return false;
+          await preferences.patch({ dictationPreset: id });
+          return true;
+        } finally { selection = null; emit({ selecting: false }); }
+      })();
+      return selection;
+    },
+    async answer(action) {
+      if (state.saving) return;
+      if (action === "continue") { finish(false); return; }
+      if (action === "discard") { preferences.discard(); finish(true); return; }
+      if (action !== "save") return;
+      emit({ saving: true, error: false });
+      try { await preferences.saveDirty(); finish(true); } catch { emit({ saving: false, error: true }); }
+    },
+    dispose() { finish(false); listeners.clear(); },
+  };
+}

package/voice/presentation.js

@@ -24,7 +24,19 @@ export function voiceInputPresentation(view, now = Date.now()) {
 export function voiceDictationPresentation(view, now = Date.now()) {
   const ui = voiceInputPresentation(view, now);
   const processingFailed = Boolean(view.raw && view.error && view.error !== "voice_draft_changed");
-  return { ...ui, exclusive: Boolean(view.visible && view.mode === "single"), waveform: ui.phase === "recording" && !ui.error, processingFailed, recoverable: Boolean(view.raw && ui.error) };
+  return { ...ui, exclusive: Boolean(view.visible && view.mode === "single"), waveform: ui.phase === "recording" && !ui.error, processingFailed, recoverable: Boolean(view.raw && (ui.error || view.stage === "processing")) };
+}
+
+export function voiceIndicatorPresentation(view, settingsError = null) {
+  const error = view.error || view.snapshot?.error || view.readAloudError || settingsError;
+  const continuous = view.mode === "continuous";
+  const active = view.visible && (view.snapshot?.connection === "open" || view.busy && !view.snapshot);
+  return {
+    visible: continuous ? Boolean(active || error) : Boolean(view.visible || settingsError),
+    orb: continuous && active && !error,
+    ticking: Boolean(view.visible && !continuous && view.startedAt && view.snapshot?.capture === "recording"),
+    error,
+  };
 }
 
 /** Discovery establishes capability; a transient connection error does not revoke it. */

package/voice/reply-stream.js

@@ -0,0 +1,99 @@
+import { VoiceError } from "../router/stt.js";
+import { reduceUtterance } from "./speech.js";
+import { createSpeechSegmenter } from "./script.js";
+
+const STATUS = { voice_reply_invalid: 400, voice_reply_forbidden: 403 };
+const fault = code => new VoiceError(code, STATUS[code] ?? 409, code);
+const identity = source => JSON.stringify([source.sessionId, source.turn, source.step]);
+
+/** Only trusted Agent events may authorize live text; client input supplies an address, never text. */
+export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segmenterFactory = () => createSpeechSegmenter({ now }) } = {}) {
+  const rows = new Map();
+  const notify = row => { row.version = (row.version || 0) + 1; for (const wake of row.listeners) wake(); };
+  const fail = (row, code) => { row.segmenter.reset(); row.ready = []; row.error = code; row.done = true; row.at = now(); notify(row); };
+  const advance = row => {
+    if (!row.claimed || row.error || !row.eligible && !row.done) return;
+    try { row.ready.push(...row.segmenter.update(row.utterance?.text || "", { done: row.done })); }
+    catch (error) { fail(row, error.message === "voice_reply_rewritten" ? error.message : "voice_reply_invalid"); }
+  };
+  return {
+    frame(sessionId, frame) {
+      if (frame.type === "start") {
+        const key = identity({ sessionId, turn: frame.turn, step: frame.step });
+        const previous = rows.get(key);
+        if (previous) fail(previous, "voice_reply_replaced");
+        for (const [id, row] of rows) {
+          if (!row.done && now() - row.at > 180000) fail(row, "voice_reply_timeout");
+          if (row.done && now() - row.at > 30000) rows.delete(id);
+        }
+        if (rows.size >= 128) return;
+        rows.set(key, { sessionId, turn: frame.turn, step: frame.step, attemptId: frame.attemptId,
+          segmenter: segmenterFactory(), ready: [], eligible: frame.speechEligible === true, utterance: null, next: 0, done: false, error: null, at: now(), listeners: new Set() });
+        return;
+      }
+      for (const row of rows.values()) {
+        if (row.sessionId !== sessionId || row.attemptId !== frame.attemptId || row.done) continue;
+        if (frame.type === "chunk") {
+          if (frame.index < row.next) return;
+          if (frame.index !== row.next++) { fail(row, "voice_reply_sequence"); return; }
+          row.utterance = reduceUtterance(row.utterance, { type: "assistant/chunk", data: { turn: row.turn, step: row.step, attemptId: row.attemptId, chunkIndex: frame.index, chunk: frame.chunk } });
+          if (row.utterance?.silent) fail(row, "voice_reply_untrusted");
+          else if ((row.utterance?.text.length || 0) > 8192) fail(row, "voice_text_limit");
+          if (!row.error) advance(row);
+          notify(row);
+        } else if (frame.type === "end" && !row.done) fail(row, "voice_reply_unsettled");
+      }
+    },
+    event(sessionId, event) {
+      for (const row of rows.values()) {
+        if (row.sessionId !== sessionId || row.done) continue;
+        if (event.type === "turn/end" && event.data?.turn === row.turn) { fail(row, "voice_reply_unsettled"); continue; }
+        if (event.type !== "assistant/message" || event.data?.turn !== row.turn || event.data?.step !== row.step) continue;
+        row.utterance = reduceUtterance(row.utterance, event);
+        if (row.utterance.text.length > 8192) { fail(row, "voice_text_limit"); continue; }
+        if (row.utterance.silent) fail(row, "voice_reply_untrusted");
+        else { row.done = true; row.at = now(); advance(row); notify(row); }
+      }
+    },
+    async bind(scope, source) {
+      if (!source || typeof source.sessionId !== "string" || source.sessionId.length > 256 || !Number.isSafeInteger(source.turn) || !Number.isSafeInteger(source.step)) throw fault("voice_reply_invalid");
+      if (owner && scope.owner !== owner()) throw fault("voice_reply_forbidden");
+      await inspect(source.sessionId);
+      const row = rows.get(identity(source));
+      if (!row || source.attemptId && source.attemptId !== row.attemptId) throw fault("voice_reply_unavailable");
+      if (row.claimed) throw fault("voice_output_owned");
+      row.claimed = true; advance(row);
+      return async function* segments(signal) {
+        let index = 0;
+        try {
+          while (!signal.aborted) {
+            if (row.error) throw fault(row.error);
+            const version = row.version;
+            row.ready.push(...row.segmenter.flush());
+            while (index < row.ready.length) {
+              if (signal.aborted || row.error) throw fault(row.error || "voice_cancelled");
+              yield { text: row.ready[index], index: index++, attemptId: row.attemptId };
+            }
+            if (row.done && version === row.version) return;
+            if (version !== row.version) continue;
+            await new Promise((resolve, reject) => {
+              const deadline = row.segmenter.deadline;
+              const wait = deadline === null ? 30000 : Math.max(0, Math.min(30000, deadline - now()));
+              const cleanup = () => { clearTimeout(timer); row.listeners.delete(wake); signal.removeEventListener("abort", wake); };
+              const wake = () => { cleanup(); resolve(); };
+              const timer = setTimeout(() => { cleanup(); deadline === null ? reject(fault("voice_reply_timeout")) : resolve(); }, wait);
+              row.listeners.add(wake); signal.addEventListener("abort", wake, { once: true });
+              if (signal.aborted) wake();
+            });
+          }
+          throw fault("voice_cancelled");
+        } finally {
+          if (!row.done) fail(row, "voice_cancelled");
+          row.segmenter.reset();
+        }
+      };
+    },
+    remove(sessionId) { for (const [key, row] of rows) if (row.sessionId === sessionId) { fail(row, "voice_session_closed"); rows.delete(key); } },
+    close() { for (const row of rows.values()) fail(row, "voice_session_closed"); rows.clear(); },
+  };
+}

package/voice/router-audio.js

@@ -1,5 +1,6 @@
+import { ttsVoiceForModel } from "./tts-voice.js";
 import { transcribe } from "../router/stt.js";
-import { pcmToWav, synthesize } from "../router/tts.js";
+import { pcmToWav, synthesizeStream } from "../router/tts.js";
 import { normalizeSttPcm } from "./pcm.js";
 import { createPcmResampler, pcmSamples } from "./realtime-audio.js";
 
@@ -16,11 +17,27 @@ export function wavData(wav) {
 export function createRouterAudio(config) {
   return {
     transcribe: (pcm, scope) => transcribe({ bytes: pcmToWav(pcm, 24000), filename: "voice.wav", contentType: "audio/wav", model: config().model || "default-stt", language: config().language || undefined, signal: scope.voiceAbort?.signal, once: true }),
-    async synthesize(text, scope) {
-      const settings = config();
-      const wav = await synthesize({ text, model: settings.ttsModel || "default-tts", voice: settings.voice || undefined, signal: scope.outputAbort?.signal });
-      const normalized = await normalizeSttPcm(wav, "audio/wav");
-      return Buffer.from(createPcmResampler(16000)(pcmSamples(wavData(normalized))));
+    async synthesize(text, scope, onChunk) {
+      const settings = structuredClone(config());
+      const model = settings.ttsModel || "default-tts";
+      const chunks = [];
+      let convert = null;
+      const write = async (pcm) => { if (onChunk) await onChunk(pcm); else chunks.push(pcm); };
+      let pending = Buffer.alloc(0);
+      const result = await synthesizeStream({ text, model, voice: settings.voice || ttsVoiceForModel(settings, model), signal: scope.outputAbort?.signal,
+        onFormat: (format) => { convert = createPcmResampler(format.sampleRate, 24000); },
+      }, async (chunk) => {
+        const joined = Buffer.concat([pending, chunk]);
+        const end = joined.length - joined.length % 2;
+        pending = joined.subarray(end);
+        if (end) await write(Buffer.from(convert(pcmSamples(joined.subarray(0, end)))));
+      });
+      if (pending.length) throw new Error("voice_audio_format");
+      if (!result.streamed) {
+        const normalized = await normalizeSttPcm(result.audio, "audio/wav");
+        await write(Buffer.from(createPcmResampler(16000, 24000)(pcmSamples(wavData(normalized)))));
+      }
+      return onChunk ? null : Buffer.concat(chunks);
     },
   };
 }

package/voice/script.js

@@ -1,4 +1,9 @@
 import { segment } from "sentencex";
+import { createNaturalSegmenter } from "./speech-segmenter.js";
+
+// Same-voice listening accepted natural segmentation; legacy remains a diagnostic baseline.
+export const SPEECH_SEGMENTATION_POLICY = "natural";
+import { spokenLines } from "./spoken-text.js";
 
 /**
  * Kokoro's pipeline splits on newlines and stitches the audio with no gap, and
@@ -8,40 +13,6 @@ import { segment } from "sentencex";
  */
 export const SENTENCE_GAP_MS = 300;
 
-/** Text still streaming may hold a code fence that has not closed yet. */
-function closedPart(text) {
-  const fences = text.match(/```/g)?.length ?? 0;
-  return fences % 2 === 0 ? text : text.slice(0, text.lastIndexOf("```"));
-}
-
-/** Table rules and horizontal rules carry nothing to read. */
-const RULE_LINE = /^\s*(?:\|?\s*:?-{3,}:?\s*)+\|?\s*$|^\s*([-*_])(?:\s*\1){2,}\s*$/;
-const BLOCK_MARK = /^\s*(?:>\s*)*(?:#{1,6}\s+|[-*+]\s+(?:\[[ xX]]\s+)?|\d+[.)]\s+)?/;
-
-function plainLine(line) {
-  if (RULE_LINE.test(line)) return "";
-  return line
-    .replace(BLOCK_MARK, "")
-    .replace(/`([^`]+)`/g, "$1")
-    .replace(/!\[[^\]]*]\([^)]*\)/g, " ")
-    .replace(/\[([^\]]+)]\([^)]*\)/g, "$1")
-    .replace(/[|#>*_]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}
-
-/**
- * Model answers are Markdown, and a heading, list item or table row often ends
- * without punctuation, so every line is a sentence boundary of its own.
- */
-function plainLines(text) {
-  return String(text ?? "")
-    .replace(/```[\s\S]*?```/g, " ")
-    .slice(0, 2000)
-    .split("\n")
-    .map(plainLine);
-}
-
 function sentencesOf(line) {
   return line ? segment("en", line).map((part) => part.trim()).filter(Boolean) : [];
 }
@@ -92,8 +63,9 @@ export function gapAfter(segment) {
  * mid-word, so only the sentences before its last one count.
  * @returns {string[]}
  */
-export function speechSegments(text, { done = true } = {}) {
-  const lines = plainLines(done ? text : closedPart(String(text ?? "")));
+export function speechSegments(text, { done = true, policy = SPEECH_SEGMENTATION_POLICY } = {}) {
+  if (policy === "natural") return createNaturalSegmenter().update(text, { done });
+  const lines = spokenLines(text, { done });
   const open = done ? "" : lines.pop();
   const sentences = lines.flatMap(sentencesOf);
   sentences.push(...sentencesOf(open).slice(0, -1));
@@ -103,3 +75,22 @@ export function speechSegments(text, { done = true } = {}) {
 export function speechScript(text) {
   return speechSegments(text).join("\n");
 }
+
+
+export function createSpeechSegmenter({ policy = SPEECH_SEGMENTATION_POLICY, now = Date.now } = {}) {
+  if (policy === "natural") return createNaturalSegmenter({ now });
+  let source = "", emitted = [];
+  return {
+    update(text, options) {
+      source = text;
+      const ready = speechSegments(text, { ...options, policy: "legacy" });
+      if (emitted.some((part, index) => part !== ready[index])) throw new Error("voice_reply_rewritten");
+      const result = ready.slice(emitted.length); emitted = ready; return result;
+    },
+    push(chunk, options = { done: false }) { return this.update(source + chunk, options); },
+    finish() { return this.update(source, { done: true }); },
+    flush() { return []; },
+    get deadline() { return null; },
+    reset() { source = ""; emitted = []; },
+  };
+}

package/voice/service.js

@@ -1,3 +1,4 @@
+import { ttsVoiceForModel } from "./tts-voice.js";
 import { writeReport } from "../log/report.js";
 import { createPcmResampler, pcmSamples } from "./realtime-audio.js";
 import { realtimeModelIds, validatedRealtimeModels } from "./realtime.js";
@@ -23,11 +24,10 @@ import { createCaptureSession } from "./capture.js";
 import { createDuplexCoordinator } from "./duplex.js";
 import { createDeviceLease } from "./lease.js";
 import { normalizeSttPcm } from "./pcm.js";
-import { gapAfter, speechSegments } from "./script.js";
+import { gapAfter, createSpeechSegmenter } from "./script.js";
 import {
   listTtsVoices,
   pcmToWav,
-  pickTtsVoice,
   silencePcm,
   synthesize,
   synthesizeStream,
@@ -118,18 +118,12 @@ export async function voiceStatusPayload(options) {
   };
 }
 
-export async function voiceModelsPayload(options) {
+export async function voiceCapabilitiesPayload(options) {
   const models = await listModels(options);
   const config = readConfig();
   const ids = models.map((model) => model.id);
   const stt = sttModelIds(models);
   const tts = ttsModelIds(models);
-  let charts = null;
-  try {
-    charts = await voiceChartsStatus();
-  } catch {
-    charts = null;
-  }
   return {
     models: ids,
     stt,
@@ -139,10 +133,17 @@ export async function voiceModelsPayload(options) {
     realtimeReady: validatedRealtimeModels(models),
     selected: pickSttModelId(models, config.model),
     ttsSelected: pickTtsModelId(models, config.ttsModel),
-    charts,
+    ttsDefault: pickTtsModelId(models, ""),
   };
 }
 
+export async function voiceModelsPayload(options) {
+  const capabilities = await voiceCapabilitiesPayload(options);
+  let charts = null;
+  try { charts = await voiceChartsStatus(); } catch { /* Diagnostics do not revoke capabilities. */ }
+  return { ...capabilities, charts };
+}
+
 export async function saveVoiceConfig(body) {
   const patch = validateConfigPatch(body);
   if (patch.model || patch.ttsModel || patch.realtimeModel || patch.backend === "realtime") {
@@ -156,6 +157,17 @@ export async function saveVoiceConfig(body) {
       throw new VoiceError("voice_model_unavailable", 400, "selected speech model is not available");
     }
   }
+  if (patch.ttsVoiceByModel) {
+    const current = readConfig().ttsVoiceByModel;
+    const changed = Object.entries(patch.ttsVoiceByModel).filter(([model, voice]) => voice && current[model] !== voice);
+    if (changed.length) {
+      const models = ttsModelIds(await listModels());
+      for (const [model, voice] of changed) {
+        if (!models.includes(model)) throw new VoiceError("voice_model_unavailable", 400, "selected speech model is not available");
+        if (!(await listTtsVoices(model)).includes(voice)) throw new VoiceError("voice_config_invalid", 400, "selected voice is not available");
+      }
+    }
+  }
   return writeConfig(patch);
 }
 
@@ -222,21 +234,6 @@ function cancelledSpeech() {
 
 const readouts = new WeakMap();
 
-/** model id → pinned voice. A failed lookup is not cached, so the next readout asks again. */
-const pinnedVoices = new Map();
-
-async function pinnedVoice(model, listVoices = listTtsVoices) {
-  if (pinnedVoices.has(model)) return pinnedVoices.get(model);
-  let voice = null;
-  try {
-    voice = pickTtsVoice(await listVoices(model));
-  } catch {
-    return null;
-  }
-  if (voice) pinnedVoices.set(model, voice);
-  return voice;
-}
-
 function deferred() {
   let resolve;
   let reject;
@@ -286,21 +283,36 @@ export async function speakFromConfig(text, options = {}) {
   if (!config.speak) throw new VoiceError("voice_speak_disabled", 409, "speech playback is off");
   const key = typeof options.key === "string" && options.key ? options.key : null;
   const done = key ? options.done === true : true;
-  const segments = speechSegments(text, { done });
   const part = partIndex(options.part);
   const coordinator = options.coordinator ?? options.scope?.duplex ?? duplex;
   const id = key ?? text;
   let readout = joinable(readouts.get(coordinator), id, key, part);
+  const segmenter = readout?.segmenter ?? (options.segmenterFactory?.() ?? createSpeechSegmenter());
+  let segments = segmenter.update(text, { done });
   if (!readout) {
-    if (!segments.length) {
-      if (key && part === null) return { sentences: 0 };
+    if (!segments.length && segmenter.deadline === null) {
+      if (part === null) return { sentences: 0 };
       throw new VoiceError("voice_config_invalid", 400, "nothing to speak");
     }
-    const model = options.model ?? await pickTtsModelId(await listModels(), config.ttsModel);
+    const catalog = options.model == null ? await listModels() : null;
+    if (catalog && config.ttsModel && !ttsModelIds(catalog).includes(config.ttsModel)) throw new VoiceError("voice_tts_unavailable", 503, "selected speech model is not available");
+    const model = options.model ?? pickTtsModelId(catalog, config.ttsModel);
     if (!model) throw new VoiceError("voice_tts_unavailable", 503, "no speech model available");
-    readout = joinable(readouts.get(coordinator), id, key, part) ?? startReadout(coordinator, id, model, options);
+    readout = joinable(readouts.get(coordinator), id, key, part) ?? startReadout(coordinator, id, model, { ...options, segmenter, config: structuredClone(config) });
+  }
+  if (readout.segmenter !== segmenter) segments = readout.segmenter.update(text, { done });
+  readout.extend([...readout.segments, ...segments], done);
+  const deadline = readout.segmenter.deadline;
+  if (deadline !== null) {
+    await new Promise((resolve, reject) => {
+      const cleanup = () => { clearTimeout(timer); readout.signal.removeEventListener("abort", cancel); };
+      const cancel = () => { cleanup(); reject(cancelledSpeech()); };
+      const timer = setTimeout(() => { cleanup(); resolve(); }, Math.max(0, deadline - Date.now()));
+      readout.signal.addEventListener("abort", cancel, { once: true });
+      if (readout.signal.aborted) cancel();
+    });
+    readout.extend([...readout.segments, ...readout.segmenter.flush()], done);
   }
-  readout.extend(segments, done);
   if (part === null) return key ? { sentences: readout.segments.length } : readout.result;
   if (part >= readout.segments.length) {
     throw new VoiceError("voice_config_invalid", 400, `answer has ${readout.segments.length} sentence(s)`);
@@ -319,6 +331,7 @@ function startReadout(coordinator, id, model, options) {
     firstAudio: false,
     active: lease.active,
     signal: lease.signal,
+    segmenter: options.segmenter,
     segments: [],
     parts: [],
     final: false,
@@ -348,9 +361,9 @@ function startReadout(coordinator, id, model, options) {
       });
     },
   };
-  readout.result = Promise.resolve(options.config?.voice || pinnedVoice(model, options.listVoices))
+  readout.result = Promise.resolve(options.voice ?? ttsVoiceForModel(options.config, model))
     .then((voice) => readAloud(readout, model, voice, lease, options));
-  readout.result.catch(() => {});
+  readout.result.finally(() => readout.segmenter.reset()).catch(() => {});
   readouts.set(coordinator, readout);
   return readout;
 }