@datalayer/agent-runtimes 1.3.62 → 1.3.64

package/lib/voice/capture.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The microphone, for one press (VOICE.md VO-10, VO-62): opened by a
+ * gesture, shown while open, closed when the press ends or is cancelled.
+ * What it heard is kept in memory only, until it is transcribed.
+ *
+ * @module voice/capture
+ */
+/** The rate the speech models hear at. */
+export declare const HEARING_RATE = 16000;
+/** One opening of the microphone. */
+export interface Capture {
+    /** How loud it is now, between 0 and 1: what the level meter shows. */
+    level: () => number;
+    /** Close it and give what it heard, mono at 16 kHz. */
+    stop: () => Promise<Float32Array>;
+    /** Close it and forget what it heard. */
+    cancel: () => void;
+}
+/** The microphone could not be opened: said in a sentence, never a trace. */
+export declare class MicrophoneRefused extends Error {
+}
+/** The loudness of what an analyser holds now, between 0 and 1. */
+export declare function levelOf(analyser: AnalyserNode, buffer: Float32Array): number;
+/** Mono samples at one rate, brought to another. */
+export declare function resample(samples: Float32Array, from: number, to?: number): Float32Array;
+/**
+ * Open the microphone. The browser's echo cancellation is asked for, so
+ * the agent's own voice is not heard back (VO-13).
+ */
+export declare function openMicrophone(): Promise<Capture>;

package/lib/voice/capture.js

@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The microphone, for one press (VOICE.md VO-10, VO-62): opened by a
+ * gesture, shown while open, closed when the press ends or is cancelled.
+ * What it heard is kept in memory only, until it is transcribed.
+ *
+ * @module voice/capture
+ */
+/** The rate the speech models hear at. */
+export const HEARING_RATE = 16000;
+/** The microphone could not be opened: said in a sentence, never a trace. */
+export class MicrophoneRefused extends Error {
+}
+/** The loudness of what an analyser holds now, between 0 and 1. */
+export function levelOf(analyser, buffer) {
+    analyser.getFloatTimeDomainData(buffer);
+    let sum = 0;
+    for (let index = 0; index < buffer.length; index += 1) {
+        sum += buffer[index] * buffer[index];
+    }
+    // Speech sits around 0.05 to 0.2 RMS: brought to a scale the eye reads.
+    return Math.min(1, Math.sqrt(sum / buffer.length) * 5);
+}
+/** Mono samples at one rate, brought to another. */
+export function resample(samples, from, to = HEARING_RATE) {
+    if (from === to) {
+        return samples;
+    }
+    const length = Math.round((samples.length * to) / from);
+    const out = new Float32Array(length);
+    const step = from / to;
+    for (let index = 0; index < length; index += 1) {
+        const at = index * step;
+        const left = Math.floor(at);
+        const right = Math.min(left + 1, samples.length - 1);
+        out[index] = samples[left] + (samples[right] - samples[left]) * (at - left);
+    }
+    return out;
+}
+/**
+ * Open the microphone. The browser's echo cancellation is asked for, so
+ * the agent's own voice is not heard back (VO-13).
+ */
+export async function openMicrophone() {
+    if (!navigator.mediaDevices?.getUserMedia) {
+        throw new MicrophoneRefused('This browser gives no page a microphone.');
+    }
+    let stream;
+    try {
+        stream = await navigator.mediaDevices.getUserMedia({
+            audio: {
+                channelCount: 1,
+                echoCancellation: true,
+                noiseSuppression: true,
+                autoGainControl: true,
+            },
+        });
+    }
+    catch (error) {
+        const name = error?.name;
+        throw new MicrophoneRefused(name === 'NotAllowedError'
+            ? 'The microphone was not allowed: allow it for this page to talk, or type.'
+            : name === 'NotFoundError'
+                ? 'No microphone was found on this device.'
+                : 'The microphone could not be opened.');
+    }
+    const context = new AudioContext();
+    const source = context.createMediaStreamSource(stream);
+    const analyser = context.createAnalyser();
+    analyser.fftSize = 1024;
+    source.connect(analyser);
+    // The samples as they come, kept in memory until the press ends.
+    const recorder = context.createScriptProcessor(4096, 1, 1);
+    const chunks = [];
+    recorder.onaudioprocess = event => {
+        chunks.push(new Float32Array(event.inputBuffer.getChannelData(0)));
+    };
+    source.connect(recorder);
+    // A processor runs only when connected; a silent gain keeps it off the speakers.
+    const mute = context.createGain();
+    mute.gain.value = 0;
+    recorder.connect(mute);
+    mute.connect(context.destination);
+    const buffer = new Float32Array(analyser.fftSize);
+    const close = () => {
+        recorder.onaudioprocess = null;
+        stream.getTracks().forEach(track => track.stop());
+        void context.close();
+    };
+    return {
+        level: () => levelOf(analyser, buffer),
+        stop: async () => {
+            const rate = context.sampleRate;
+            close();
+            const length = chunks.reduce((total, chunk) => total + chunk.length, 0);
+            const joined = new Float32Array(length);
+            let at = 0;
+            for (const chunk of chunks) {
+                joined.set(chunk, at);
+                at += chunk.length;
+            }
+            chunks.length = 0;
+            return resample(joined, rate);
+        },
+        cancel: () => {
+            close();
+            chunks.length = 0;
+        },
+    };
+}

package/lib/voice/consent.d.ts

@@ -0,0 +1,6 @@
+/** Whether the person said yes for this application. */
+export declare function consented(app: string): boolean;
+/** Remember the person's yes for this application. */
+export declare function consent(app: string): void;
+/** The sentence said before the first use: where the audio goes (VO-61). */
+export declare const CONSENT_SENTENCE = "What you say is transcribed on this device: the sound never leaves it, and is not kept. The words go in the message box, for you to send.";

package/lib/voice/consent.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The person's yes to the microphone, asked once per application before the
+ * browser's own prompt (VOICE.md VO-61), and remembered where the page keeps
+ * its preferences. A page without storage asks again next time.
+ *
+ * @module voice/consent
+ */
+const KEY = 'datalayer-voice-consent';
+/** Whether the person said yes for this application. */
+export function consented(app) {
+    try {
+        const kept = JSON.parse(window.localStorage.getItem(KEY) || '{}');
+        return kept?.[app] === true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Remember the person's yes for this application. */
+export function consent(app) {
+    try {
+        const kept = JSON.parse(window.localStorage.getItem(KEY) || '{}');
+        window.localStorage.setItem(KEY, JSON.stringify({ ...kept, [app]: true }));
+    }
+    catch {
+        // Without storage, the yes holds for the page.
+    }
+}
+/** The sentence said before the first use: where the audio goes (VO-61). */
+export const CONSENT_SENTENCE = 'What you say is transcribed on this device: the sound never leaves it, and is not kept. The words go in the message box, for you to send.';

package/lib/voice/hearing.d.ts

@@ -0,0 +1,37 @@
+import type { Transcript, VoiceEngines } from './types';
+/** How far the first use has come: bytes loaded of the bytes to load. */
+export type HearingProgress = (loaded: number, total: number) => void;
+/** A language no device model hears. */
+export declare class NotHeardHere extends Error {
+}
+/** Where onnxruntime-web's own files are served, beside the models. */
+export declare function runtimeFiles(modelsUrl: string, version: string): {
+    mjs: string;
+    wasm: string;
+};
+/** Joins the speech a VAD found, in order. */
+export declare function joinSegments(segments: Float32Array[]): Float32Array;
+/**
+ * The page's hearing: loaded once, on first use, from Datalayer's origin
+ * (`modelsUrl`), every file checked against its pin.
+ */
+export declare class DeviceHearing {
+    private readonly modelsUrl;
+    private readonly engines;
+    private recognizers;
+    private vad?;
+    constructor(modelsUrl: string, engines: VoiceEngines);
+    /** The model that hears a language here, or a refusal in a sentence. */
+    modelFor(language: string): import("..").SpeechModelSpec;
+    /** What the first use downloads for a language, in bytes. */
+    sizeFor(language: string): number;
+    /** Load what hears a language, saying how far it has come. */
+    ready(language: string, progress?: HearingProgress): Promise<void>;
+    private recognizer;
+    private activity;
+    /**
+     * What was said in a press, or `undefined` when nothing was: its speech
+     * found by the VAD, then transcribed in the language.
+     */
+    hear(audio: Float32Array, language: string): Promise<Transcript | undefined>;
+}

package/lib/voice/hearing.js

@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Hearing on the device (VOICE.md VO-10, VO-14, decision 3): what was said
+ * in one press, kept to its speech by Silero VAD and transcribed by the
+ * catalogue's model for the language — Moonshine for English, Whisper for
+ * French — in the page, with transformers.js. The audio never leaves the
+ * browser, and is forgotten once heard.
+ *
+ * @module voice/hearing
+ */
+import { SPEECH_MODEL_CATALOGUE, transcriberFor } from '../specs/voices';
+import { pinnedBytes, pinnedFetch, downloadSize } from './pinned';
+import { HEARING_RATE } from './capture';
+/** A language no device model hears. */
+export class NotHeardHere extends Error {
+}
+/** Where onnxruntime-web's own files are served, beside the models. */
+export function runtimeFiles(modelsUrl, version) {
+    const root = `${modelsUrl.replace(/\/+$/, '')}/onnxruntime-web/${version}/`;
+    return {
+        mjs: `${root}ort-wasm-simd-threaded.asyncify.mjs`,
+        wasm: `${root}ort-wasm-simd-threaded.asyncify.wasm`,
+    };
+}
+/** Joins the speech a VAD found, in order. */
+export function joinSegments(segments) {
+    const out = new Float32Array(segments.reduce((n, s) => n + s.length, 0));
+    let at = 0;
+    for (const segment of segments) {
+        out.set(segment, at);
+        at += segment.length;
+    }
+    return out;
+}
+/**
+ * The page's hearing: loaded once, on first use, from Datalayer's origin
+ * (`modelsUrl`), every file checked against its pin.
+ */
+export class DeviceHearing {
+    modelsUrl;
+    engines;
+    recognizers = new Map();
+    vad;
+    constructor(modelsUrl, engines) {
+        this.modelsUrl = modelsUrl;
+        this.engines = engines;
+    }
+    /** The model that hears a language here, or a refusal in a sentence. */
+    modelFor(language) {
+        const model = transcriberFor(language);
+        if (!model) {
+            throw new NotHeardHere(`Nothing in this browser hears ${language} yet: type, or choose English or French.`);
+        }
+        return model;
+    }
+    /** What the first use downloads for a language, in bytes. */
+    sizeFor(language) {
+        return (downloadSize(this.modelFor(language).id) + downloadSize('silero-vad'));
+    }
+    /** Load what hears a language, saying how far it has come. */
+    async ready(language, progress) {
+        await Promise.all([this.recognizer(language, progress), this.activity()]);
+    }
+    recognizer(language, progress) {
+        const model = this.modelFor(language);
+        let loading = this.recognizers.get(model.id);
+        if (!loading) {
+            loading = (async () => {
+                const transformers = await this.engines.transformers();
+                const { env } = transformers;
+                env.allowLocalModels = false;
+                env.allowRemoteModels = true;
+                env.remoteHost = `${this.modelsUrl.replace(/\/+$/, '')}/`;
+                env.remotePathTemplate = '{model}/';
+                env.useBrowserCache = true;
+                env.fetch = pinnedFetch(this.modelsUrl);
+                const wasm = env.backends.onnx.wasm;
+                const version = env.backends.onnx.versions?.web;
+                if (wasm && version) {
+                    wasm.wasmPaths = runtimeFiles(this.modelsUrl, version);
+                }
+                const total = downloadSize(model.id);
+                const loaded = new Map();
+                const recognizer = await transformers.pipeline('automatic-speech-recognition', model.id, {
+                    dtype: model.dtype,
+                    device: 'wasm',
+                    progress_callback: (info) => {
+                        if (info?.status === 'progress' &&
+                            typeof info.loaded === 'number') {
+                            loaded.set(String(info.file), info.loaded);
+                            progress?.(Array.from(loaded.values()).reduce((a, b) => a + b, 0), total);
+                        }
+                    },
+                });
+                progress?.(total, total);
+                return recognizer;
+            })();
+            loading.catch(() => this.recognizers.delete(model.id));
+            this.recognizers.set(model.id, loading);
+        }
+        return loading;
+    }
+    activity() {
+        if (!this.vad) {
+            const file = SPEECH_MODEL_CATALOGUE['silero-vad'].files[0].path;
+            const url = `${this.modelsUrl.replace(/\/+$/, '')}/silero-vad/${file}`;
+            this.vad = this.engines.vad().then(module => module.NonRealTimeVAD.new({
+                modelURL: url,
+                modelFetcher: path => pinnedBytes(this.modelsUrl, path),
+                ortConfig: ort => {
+                    const version = ort?.env?.versions?.web;
+                    if (ort?.env?.wasm && version) {
+                        ort.env.wasm.wasmPaths = runtimeFiles(this.modelsUrl, version);
+                    }
+                },
+                // A press is short: keep a word said alone.
+                minSpeechMs: 150,
+                preSpeechPadMs: 200,
+                redemptionMs: 600,
+            }));
+            this.vad.catch(() => {
+                this.vad = undefined;
+            });
+        }
+        return this.vad;
+    }
+    /**
+     * What was said in a press, or `undefined` when nothing was: its speech
+     * found by the VAD, then transcribed in the language.
+     */
+    async hear(audio, language) {
+        const started = performance.now();
+        const model = this.modelFor(language);
+        const [recognize, vad] = await Promise.all([
+            this.recognizer(language),
+            this.activity(),
+        ]);
+        const segments = [];
+        for await (const segment of vad.run(audio, HEARING_RATE)) {
+            segments.push(segment.audio);
+        }
+        const speech = joinSegments(segments);
+        if (speech.length < HEARING_RATE * 0.2) {
+            return undefined;
+        }
+        // Whisper is told the language; Moonshine hears English only.
+        const options = model.id.startsWith('whisper')
+            ? {
+                language: language.startsWith('fr') ? 'french' : 'english',
+                task: 'transcribe',
+            }
+            : {};
+        const heard = await recognize(speech, options);
+        const text = (Array.isArray(heard) ? heard.map(h => h.text).join(' ') : heard.text).trim();
+        if (!text) {
+            return undefined;
+        }
+        return {
+            text,
+            metadata: { input: 'voice', language, engine: model.id, where: 'device' },
+            seconds: speech.length / HEARING_RATE,
+            ms: Math.round(performance.now() - started),
+        };
+    }
+}

package/lib/voice/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Voice: agents that listen and speak (VOICE.md).
+ *
+ * Push-to-talk heard on the device (Moonshine, Whisper, Silero VAD, from
+ * Datalayer's origin and as pinned), answers spoken by Datalayer's speech
+ * service (Kokoro on ai-agents), the assistant's mouth moving with them.
+ *
+ * @module voice
+ */
+import type { VoiceEngines } from './types';
+export * from './types';
+export * from './sentences';
+export * from './pinned';
+export * from './capture';
+export * from './hearing';
+export * from './speaker';
+export * from './consent';
+export * from './useSpokenAnswers';
+export { VoiceInput } from './VoiceInput';
+export type { VoiceInputProps, ListeningState } from './VoiceInput';
+/**
+ * A chat's voice: what a host gives `ChatBase` and `ChatFloating` to let a
+ * person talk to the agent and hear it — the Appspec's `interface.voice`,
+ * with where the models and the speech service are.
+ */
+export interface ChatVoice {
+    /** The language listened to and spoken, BCP 47. */
+    language: string;
+    /** `push_to_talk`, or `off`. Hands-free is Phase V3. */
+    input: 'off' | 'push_to_talk';
+    /** When answers are heard: `always`, or `off`. */
+    output: 'off' | 'always';
+    /** The voice of the catalogue answers are spoken with. */
+    voice: string;
+    /** Datalayer's origin for the browser's models: the pinned store. */
+    modelsUrl: string;
+    /** The packages that hear, loaded when voice is first used. */
+    engines: VoiceEngines;
+    /** ai-agents, whose speech service says the answers. */
+    speechUrl?: string;
+    /** The token the speech service is asked with. */
+    token?: string;
+    /** Send what is said at once, rather than put it in the composer. */
+    sendWhatISay?: boolean;
+    /** Whose consent to the microphone is remembered: the application's id. */
+    consentKey?: string;
+}

package/lib/voice/index.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './types';
+export * from './sentences';
+export * from './pinned';
+export * from './capture';
+export * from './hearing';
+export * from './speaker';
+export * from './consent';
+export * from './useSpokenAnswers';
+export { VoiceInput } from './VoiceInput';

package/lib/voice/pinned.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The browser's models, from Datalayer's origin and as pinned (VOICE.md
+ * VO-49, VO-03): every file a model is made of is fetched from the models'
+ * origin, laid out as the pinned store is (`<model id>/<path>`), and its
+ * SHA-256 checked against the catalogue before anything reads it. A file
+ * that is not the one pinned is refused; nothing is asked of another origin.
+ *
+ * @module voice/pinned
+ */
+import { type PinnedFile } from '../specs/voices';
+/** A file of a model that is not the one the catalogue pins, or not reachable. */
+export declare class PinRefused extends Error {
+}
+/** The pinned file at a URL under the models' origin, if it is one. */
+export declare function pinOf(base: string, url: string): PinnedFile | undefined;
+/** The SHA-256 of some bytes, in hex. */
+export declare function sha256Hex(bytes: ArrayBuffer): Promise<string>;
+/**
+ * A `fetch` that reaches the models' origin only, and answers a model's
+ * file only once its hash is the one pinned. The runtime's own files
+ * (onnxruntime-web's WASM, under `onnxruntime-web/`) come from the same
+ * origin, at the version the page bundles.
+ */
+export declare function pinnedFetch(base: string, fetcher?: typeof fetch): (input: string | URL, init?: RequestInit) => Promise<Response>;
+/** A model's file as bytes, checked against its pin. */
+export declare function pinnedBytes(base: string, url: string, fetcher?: typeof fetch): Promise<ArrayBuffer>;
+/** What a first use downloads for a model, in bytes. */
+export declare function downloadSize(modelId: string): number;

package/lib/voice/pinned.js

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The browser's models, from Datalayer's origin and as pinned (VOICE.md
+ * VO-49, VO-03): every file a model is made of is fetched from the models'
+ * origin, laid out as the pinned store is (`<model id>/<path>`), and its
+ * SHA-256 checked against the catalogue before anything reads it. A file
+ * that is not the one pinned is refused; nothing is asked of another origin.
+ *
+ * @module voice/pinned
+ */
+import { SPEECH_MODEL_CATALOGUE } from '../specs/voices';
+/** A file of a model that is not the one the catalogue pins, or not reachable. */
+export class PinRefused extends Error {
+}
+/** The pinned file at a URL under the models' origin, if it is one. */
+export function pinOf(base, url) {
+    const root = base.replace(/\/+$/, '') + '/';
+    if (!url.startsWith(root)) {
+        return undefined;
+    }
+    const [model, ...rest] = url.slice(root.length).split('?')[0].split('/');
+    const path = rest.join('/');
+    return SPEECH_MODEL_CATALOGUE[model]?.files.find(file => file.path === path);
+}
+/** The SHA-256 of some bytes, in hex. */
+export async function sha256Hex(bytes) {
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(digest))
+        .map(byte => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * A `fetch` that reaches the models' origin only, and answers a model's
+ * file only once its hash is the one pinned. The runtime's own files
+ * (onnxruntime-web's WASM, under `onnxruntime-web/`) come from the same
+ * origin, at the version the page bundles.
+ */
+export function pinnedFetch(base, fetcher = (input, init) => fetch(input, init)) {
+    const root = base.replace(/\/+$/, '') + '/';
+    return async (input, init) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (!url.startsWith(root)) {
+            throw new PinRefused(`Voice reads its models from ${root} only, not ${url}.`);
+        }
+        const answered = await fetcher(url, init);
+        const pin = pinOf(base, url);
+        if (!pin || !answered.ok) {
+            return answered;
+        }
+        const bytes = await answered.arrayBuffer();
+        if (bytes.byteLength !== pin.size ||
+            (await sha256Hex(bytes)) !== pin.sha256) {
+            throw new PinRefused(`${url.slice(root.length)} is not the file the voice catalogue pins: refused.`);
+        }
+        return new Response(bytes, {
+            status: answered.status,
+            headers: answered.headers,
+        });
+    };
+}
+/** A model's file as bytes, checked against its pin. */
+export async function pinnedBytes(base, url, fetcher) {
+    const answered = await pinnedFetch(base, fetcher)(url);
+    if (!answered.ok) {
+        throw new PinRefused(`${url} could not be read (${answered.status}).`);
+    }
+    return answered.arrayBuffer();
+}
+/** What a first use downloads for a model, in bytes. */
+export function downloadSize(modelId) {
+    return (SPEECH_MODEL_CATALOGUE[modelId]?.files ?? []).reduce((total, file) => total + file.size, 0);
+}

package/lib/voice/sentences.d.ts

@@ -0,0 +1,26 @@
+/**
+ * An answer as it is heard (VOICE.md VO-20): read as plain words, the way
+ * the balloon reads it (T-23), and cut into sentences as it is written, so
+ * that the first one is said before the answer is finished.
+ *
+ * @module voice/sentences
+ */
+/**
+ * The words of an answer: no Markdown signs; a code block said as *a code
+ * block*, a table as *a table*, a link by its text, an image by its words.
+ */
+export declare function plainWords(markdown: string): string;
+/**
+ * Cuts an answer into the sentences to say, as it grows.
+ *
+ * `feed` takes the answer as written so far (its whole text, each time) and
+ * gives back the sentences now complete and not given before; `end` gives
+ * what is left once the answer is finished. A sentence is complete at its
+ * stop followed by a space — never at the very end of what has arrived,
+ * which may be cut in the middle of a number (`3.5`).
+ */
+export declare class SentenceCutter {
+    private said;
+    feed(written: string): string[];
+    end(written: string): string[];
+}

package/lib/voice/sentences.js

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * An answer as it is heard (VOICE.md VO-20): read as plain words, the way
+ * the balloon reads it (T-23), and cut into sentences as it is written, so
+ * that the first one is said before the answer is finished.
+ *
+ * @module voice/sentences
+ */
+/**
+ * The words of an answer: no Markdown signs; a code block said as *a code
+ * block*, a table as *a table*, a link by its text, an image by its words.
+ */
+export function plainWords(markdown) {
+    return (markdown
+        .replace(/```[\s\S]*?(```|$)/g, ' A code block. ')
+        // A table: its rows, said once as what they are.
+        .replace(/(^|\n)(\|[^\n]*\|[ \t]*(\n|$))+/g, '$1 A table. \n')
+        .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/`([^`]*)`/g, '$1')
+        .replace(/^\s{0,3}#{1,6}\s+(.*)$/gm, '$1.')
+        .replace(/^\s*(?:[-*+]|\d+[.)])\s+/gm, '')
+        .replace(/^\s*>\s?/gm, '')
+        .replace(/[*_~]+/g, '')
+        .replace(/\.\s*\./g, '.')
+        .replace(/\s+/g, ' ')
+        .trim());
+}
+/** Where a sentence ends: its stop, then a space or the end of what is written. */
+const END = /[.!?…:;](?=["'»)\]]*(\s|$))/g;
+/** Below this, a sentence waits for the next one to be said with it. */
+const SHORTEST = 12;
+/**
+ * Cuts an answer into the sentences to say, as it grows.
+ *
+ * `feed` takes the answer as written so far (its whole text, each time) and
+ * gives back the sentences now complete and not given before; `end` gives
+ * what is left once the answer is finished. A sentence is complete at its
+ * stop followed by a space — never at the very end of what has arrived,
+ * which may be cut in the middle of a number (`3.5`).
+ */
+export class SentenceCutter {
+    said = 0;
+    feed(written) {
+        const words = plainWords(written);
+        const out = [];
+        END.lastIndex = this.said;
+        let match;
+        while ((match = END.exec(words)) !== null) {
+            const stop = match.index + match[0].length;
+            // At the very end, more may still come: wait.
+            if (stop >= words.length) {
+                break;
+            }
+            const sentence = words.slice(this.said, stop).trim();
+            if (sentence.length >= SHORTEST) {
+                out.push(sentence);
+                this.said = stop;
+            }
+        }
+        return out;
+    }
+    end(written) {
+        const rest = plainWords(written).slice(this.said).trim();
+        this.said = plainWords(written).length;
+        return rest ? [rest] : [];
+    }
+}