@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/platform/kokoro-runtime.js

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/kokoro-runtime — THE ENGINE LOADS THE NEURAL VOICE ITSELF (ADR-0216 and its erratum; issue #200).
+//
+// The Dev, 2026-09-21: «a engine deve oferecer objetos de leitura e TTS. O jogo não deve precisar saber como isso funciona». So the
+// phonemizer and the ONNX runtime are no longer a game's dependency: they are catalogued heavy files (`voz:runtime:*`), the build
+// puts them in the delivery, and this loads them from `heavy/` on the page's own origin — the same path the vision runtime
+// already takes (ADR-0177, `platform/vision`).
+//
+// ⚠️ NOTHING HERE IS IMPORTED FROM npm, and that is the point: an `import 'espeak-ng'` would put the phonemizer in the bundle of
+// every game that merely links the engine, and would need a bundler to resolve it. `import(url)` of an address on our own origin
+// needs neither, and it happens only when a child picks a neural voice.
+//
+// · The wasm of espeak-ng is compiled ONCE and instantiated per sentence: its module runs one program and exits.
+// · onnxruntime's threads load their own glue and wasm; they are pointed at `heavy/` too, because a worker that goes looking for
+//   them on a CDN finds nothing in a school with no network, and the child hears silence (measured in the quiz demo, #181).
+import { createKokoroPort } from './kokoro-port.js';
+import { atDelivery, loadOnnxRuntime } from './onnx-runtime.js';
+// The addresses are the catalogue's, reached by id through `platform/onnx-runtime` — never written twice (ADR-0114, ADR-0177).
+const ESPEAK_GLUE = 'voz:runtime:fonemas';
+const ESPEAK_WASM = 'voz:runtime:fonemas:wasm';
+/**
+ * Builds the neural voice. Everything it needs is fetched from the delivery, so a device that never had a network day has it all
+ * or has none of it — and «none of it» is a refusal the caller reports, not a silence.
+ */
+export async function loadKokoroRuntime(d) {
+    const { compileWasm: compile, instantiateWasm: instantiate, fetch: get } = d;
+    const loadModule = d.importModule ?? ((url) => import(/* @vite-ignore */ url));
+    const espeakModule = await loadModule(atDelivery(ESPEAK_GLUE, d.base));
+    const factory = (typeof espeakModule === 'function' ? espeakModule : espeakModule.default);
+    if (typeof factory !== 'function')
+        throw new Error('Kokoro: espeak-ng did not load from the delivery (voz:runtime:fonemas)');
+    // by BYTES and not by stream: a server that sends the file without `application/wasm` must not break the voice
+    let compiled = null;
+    const espeak = (options) => {
+        compiled ??= get(atDelivery(ESPEAK_WASM, d.base)).then(async (r) => {
+            if (!r.ok)
+                throw new Error(`Kokoro: HTTP ${r.status} for espeak-ng's wasm — the delivery does not carry it`);
+            return compile(await r.arrayBuffer());
+        });
+        const module = compiled;
+        return factory({
+            ...options,
+            instantiateWasm: (imports, ready) => {
+                void module.then(async (m) => ready(await instantiate(m, imports), m));
+                return {};
+            },
+        });
+    };
+    // the runtime, and the rule about its threads, are `platform/onnx-runtime`'s — the reading loads the same one the same way
+    const ort = await loadOnnxRuntime({ base: d.base, importModule: loadModule });
+    return createKokoroPort({ espeak, ort, fetch: get, base: d.base });
+}

package/dist-pkg/platform/kokoro.d.ts

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { NeuralVoice } from './voice-plan.js';
+/** A Kokoro inference session on one device: token ids and a style row in, a 24 kHz waveform out. */
+export interface KokoroSession {
+    readonly synthesize: (ids: readonly number[], styleVector: Float32Array) => Promise<Float32Array>;
+}
+/**
+ * WHAT SPEAKING NEEDS OF KOKORO — `platform/kokoro-runtime` fills it from the delivery (ADR-0216 §1).
+ * `phonemize` is espeak-ng in the voice's language (`pt-br`, `es-419`, `en-us`, `en-gb`); `vocabulary` the model tokenizer's symbols;
+ * `voice` a voice's style table; `session` a session on WebGPU or WASM.
+ *
+ * 📌 IT LIVES IN THIS LEAF and not beside the speaking, so that the runtime that builds one can be reached from `platform/tts` by
+ * `import()` without the two naming each other — a cycle the direction gate (ADR-0173) refuses, and rightly: the loader must not
+ * have to load the speaker to be loaded by it.
+ */
+export interface KokoroModule {
+    readonly phonemize: (text: string, espeak: string) => Promise<string>;
+    readonly vocabulary: () => Promise<Readonly<{
+        [symbol: string]: number;
+    }>>;
+    readonly voice: (id: string) => Promise<Float32Array>;
+    readonly session: (device: 'webgpu' | 'wasm') => Promise<KokoroSession>;
+}
+/** How the neural voice arrives. Until ADR-0216 every game wrote one of these; now the engine has its own. */
+export type LoadKokoro = () => Promise<KokoroModule>;
+/** A Kokoro voice of the engine's three languages. `recommended` marks the two the Dev rated good (ADR-0198 §3). */
+export interface KokoroVoice extends NeuralVoice {
+    readonly engine: 'kokoro';
+    /** The espeak-ng voice that phonemizes this voice's text. */
+    readonly espeak: string;
+    readonly recommended: boolean;
+}
+/**
+ * Kokoro-82M v1.0's voices for Portuguese, Spanish and English, as the model repository lists them (read 2026-09-14). The model's
+ * first letter is the language — `p` Brazilian Portuguese, `e` Spanish, `a` American and `b` British English — and the second the
+ * voice's gender. The others (French, Hindi, Italian, Japanese, Chinese) are not the engine's languages.
+ */
+export declare const KOKORO_VOICES: readonly KokoroVoice[];
+export declare const KOKORO_MODEL_URL = "https://huggingface.co/onnx-community/Kokoro-82M-v1.0-ONNX/resolve/main/onnx/model.onnx";
+export declare const URL_DO_TOKENIZADOR_KOKORO = "https://huggingface.co/onnx-community/Kokoro-82M-v1.0-ONNX/resolve/main/tokenizer.json";
+export declare const kokoroVoiceUrl: (id: string) => string;
+/**
+ * Each voice file's SHA-256 and size, read from the repository's LFS metadata on 2026-09-14 (all 522 240 bytes); `pf_dora` also
+ * measured on the downloaded file. The model: 325 532 232 bytes, measured on the file. Checked before anything is kept (#168).
+ */
+export declare const KOKORO_VOICES_SHA256: Readonly<{
+    [id: string]: string;
+}>;
+export declare const KOKORO_VOICE_BYTES = 522240;
+export declare const KOKORO_MODEL_SHA256 = "8fbea51ea711f2af382e88c833d9e288c6dc82ce5e98421ea61c058ce21a34cb";
+export declare const KOKORO_MODEL_BYTES = 325532232;
+export declare const SHA256_DO_TOKENIZADOR_KOKORO = "77a02c8e164413299b4b4c403b14f8e0e1c1b727db4d46a09d6327b861060a34";
+export declare const BYTES_DO_TOKENIZADOR_KOKORO = 3497;
+/** The model's context: ids between the two pad tokens. A longer sentence is cut here (the caller splits text by sentence). */
+export declare const MAX_KOKORO_TOKENS = 510;
+/** A voice file is a table of style rows, one per token count, 256 numbers each. */
+export declare const STYLE_DIMENSION = 256;
+/** The token ids of a phoneme string: each symbol the vocabulary knows, in order, between two pad tokens (id 0). */
+export declare function tokenize(phonemes: string, symbolIds: Readonly<{
+    [symbol: string]: number;
+}>): number[];
+/** The style row a sentence of `tokens` ids (pads excluded) takes from a voice table. */
+export declare function sentenceStyle(styleTable: Float32Array, tokens: number): Float32Array;
+/**
+ * Is a synthesis speech? Measured on 2026-09-14: WebGPU on one AMD GPU gave a waveform whose samples ran to 2×10⁷ — noise a child
+ * would hear as a burst. A speech waveform stays within ±1 (a sample or two past it is clipping, not noise) and is not silent.
+ */
+export declare function eFala(waveform: ArrayLike<number>): boolean;
+/** A 16-bit mono PCM WAV of a waveform, clipped to ±1 — what the narration's media element plays. */
+export declare function wavDe(waveform: ArrayLike<number>, sampleRate?: number): ArrayBuffer;

package/dist-pkg/platform/kokoro.js

@@ -0,0 +1,133 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+const voiceEntry = (id, locale, espeak, isRecommended = false) => Object.freeze({ locale, engine: 'kokoro', voice: id, espeak, recommended: isRecommended });
+/**
+ * Kokoro-82M v1.0's voices for Portuguese, Spanish and English, as the model repository lists them (read 2026-09-14). The model's
+ * first letter is the language — `p` Brazilian Portuguese, `e` Spanish, `a` American and `b` British English — and the second the
+ * voice's gender. The others (French, Hindi, Italian, Japanese, Chinese) are not the engine's languages.
+ */
+export const KOKORO_VOICES = Object.freeze([
+    voiceEntry('pf_dora', 'pt-BR', 'pt-br'), voiceEntry('pm_alex', 'pt-BR', 'pt-br'), voiceEntry('pm_santa', 'pt-BR', 'pt-br'),
+    voiceEntry('ef_dora', 'es', 'es-419'), voiceEntry('em_alex', 'es', 'es-419'), voiceEntry('em_santa', 'es', 'es-419'),
+    voiceEntry('af_heart', 'en-US', 'en-us', true), voiceEntry('af_bella', 'en-US', 'en-us', true),
+    ...['af_alloy', 'af_aoede', 'af_jessica', 'af_kore', 'af_nicole', 'af_nova', 'af_river', 'af_sarah', 'af_sky',
+        'am_adam', 'am_echo', 'am_eric', 'am_fenrir', 'am_liam', 'am_michael', 'am_onyx', 'am_puck', 'am_santa'].map((id) => voiceEntry(id, 'en-US', 'en-us')),
+    ...['bf_alice', 'bf_emma', 'bf_isabella', 'bf_lily', 'bm_daniel', 'bm_fable', 'bm_george', 'bm_lewis'].map((id) => voiceEntry(id, 'en-GB', 'en-gb')),
+]);
+/**
+ * WHERE KOKORO COMES FROM, in one place (ADR-0114's rule for hosts): the model repository the catalogue fetches at build time; the
+ * delivery serves the same paths from its own origin (ADR-0177), and a game's port asks for them there.
+ */
+const KOKORO_REPOSITORY = 'https://huggingface.co/onnx-community/Kokoro-82M-v1.0-ONNX/resolve/main';
+export const KOKORO_MODEL_URL = `${KOKORO_REPOSITORY}/onnx/model.onnx`;
+export const URL_DO_TOKENIZADOR_KOKORO = `${KOKORO_REPOSITORY}/tokenizer.json`;
+export const kokoroVoiceUrl = (id) => `${KOKORO_REPOSITORY}/voices/${id}.bin`;
+/**
+ * Each voice file's SHA-256 and size, read from the repository's LFS metadata on 2026-09-14 (all 522 240 bytes); `pf_dora` also
+ * measured on the downloaded file. The model: 325 532 232 bytes, measured on the file. Checked before anything is kept (#168).
+ */
+export const KOKORO_VOICES_SHA256 = Object.freeze({
+    pf_dora: '3da7b5b2d91847ebf5646f57631af6ececae3c29a89cd300f06edf9aa6cfe9ee',
+    pm_alex: '0175c753f59c54e7fd5a995bedef0c5ff2fb67e0043dd3dcb2ae74ec2acbeb2a',
+    pm_santa: '8b012db3185778afe2e45a62cbad69db73021774fe68dda634bcc748a982eede',
+    ef_dora: 'f66ec66bd295acb18372e37008533a9a3228483ccd294e7538d5d9294ac9a532',
+    em_alex: '27809e9eafdcbcfff90a3016c697568676531de2a2c39cee29c96c7bd6b83e95',
+    em_santa: 'ad43b774e1ca24d05c6161297d8aeb770ac3d29bb95daf516727af5f7d543683',
+    af_heart: 'd583ccff3cdca2f7fae535cb998ac07e9fcb90f09737b9a41fa2734ec44a8f0b',
+    af_bella: 'f69d836209b78eb8c66e75e3cda491e26ea838a3674257e9d4e5703cbaf55c8b',
+    af_alloy: 'c4a6b876047fd7fb472edf4ebd63cfac7c3b958a7cae7c106e8f038ca6308c45',
+    af_aoede: '4a004c33430762e2461eedb2013fad808ef4ab3121f5300f554476caf58d8361',
+    af_jessica: 'a240a5e3c15b43563d6e923bdca8ef5613a23471d9b77653694012435df23bd8',
+    af_kore: '9be5221b6a941c04b561959b8ff0b06e809444dcc4ab7e75a7b23606f691819e',
+    af_nicole: 'cd2191ab31b914ed7b318416b0e4440fdf392ddad9106a060819aa600a64f59a',
+    af_nova: '18778272caa0d0eebaea251c35fd635f038434f9eee5e691d02a174bd328414f',
+    af_river: '00a2bcf82b1d86e8f19902ede58c65ccf6c0e43b44b7d74fad54e5d8933c9c30',
+    af_sarah: '4409fbc125afabacc615d94db5398d847006a737b0247d6892b7a9a0007a2f0a',
+    af_sky: '4435255c9744f3f31659e0d714ab7689bf65d9e77ec1cce060f083912614f0b9',
+    am_adam: '162b035ed91cfc48b6046982184c645f72edcdd1b82843347f605d7bf7b15716',
+    am_echo: '3968b92c3c4cd1c4416dbded36c13eaa388a90d5788d02a13e4d781f5f8cf3c3',
+    am_eric: 'e8b5be17edd1e3636901ce7598baafe2dc8dd8ff707a0c23bf9e461add7e2832',
+    am_fenrir: 'c27989f741f7ee34d273a39d8a595cc0837d35f5ced9a29b7cc162614616df43',
+    am_liam: '52403be32fd047c6a44517cb0bcd6b134f2a18baa73e70ef41651e0eab921ade',
+    am_michael: '1d1f21dd8da39c30705cd4c75d039d265e9bc4a2a93ed09bc9e1b1225eb95ba1',
+    am_onyx: 'da5d135b424164916d75a68ffb4c2abce3d7d5ccc82dd1ee6cf447ce286145e6',
+    am_puck: 'fcf73c989033e9233e0b98713eca600c8c74dcc1614b37009d5450ff4a2274a0',
+    am_santa: '61150cf726ab6c5ed7a99f90a304f91f5a72c00c592e89ec94e5df11c319227a',
+    bf_alice: '08afa6ba24da61ea5e8efa139e5aadc938d83f0a6da5a900adaf763ac1da5573',
+    bf_emma: '669fe0647f9dd04fcab92f1439a40eeb4c8b4ab1f82e4996fe3d918ce4a63b73',
+    bf_isabella: '3754352c4aaa46d17f27654ab7518d65b62ad6163a0f55a5f4330c2da2c4e94f',
+    bf_lily: '5e0ee32ebe64a467124976b14e69590746f1c4ce41a12b587a50c862edfea335',
+    bm_daniel: '6b3194bbceffb746733cbc22c8f593dd44e401a71d53895a2dca891bc595a1e8',
+    bm_fable: 'f889083196807b4adb15e9204252165f503b8d33d3982e681c52443c49d798f1',
+    bm_george: 'c4b235a4c1f2cd3b939fed08b899ce9385638b763f7b73a59616c4fc9bd6c9bc',
+    bm_lewis: 'b8f671cef828c30e66fdf0b0756a76bba58f6bb3398cbbf27058642acbcedb97',
+});
+export const KOKORO_VOICE_BYTES = 522_240;
+export const KOKORO_MODEL_SHA256 = '8fbea51ea711f2af382e88c833d9e288c6dc82ce5e98421ea61c058ce21a34cb';
+export const KOKORO_MODEL_BYTES = 325_532_232;
+export const SHA256_DO_TOKENIZADOR_KOKORO = '77a02c8e164413299b4b4c403b14f8e0e1c1b727db4d46a09d6327b861060a34';
+export const BYTES_DO_TOKENIZADOR_KOKORO = 3_497;
+/** The model's context: ids between the two pad tokens. A longer sentence is cut here (the caller splits text by sentence). */
+export const MAX_KOKORO_TOKENS = 510;
+/** A voice file is a table of style rows, one per token count, 256 numbers each. */
+export const STYLE_DIMENSION = 256;
+const KOKORO_SAMPLE_RATE = 24_000;
+/** The token ids of a phoneme string: each symbol the vocabulary knows, in order, between two pad tokens (id 0). */
+export function tokenize(phonemes, symbolIds) {
+    const ids = [];
+    for (const symbol of phonemes) {
+        const id = symbolIds[symbol];
+        if (id !== undefined)
+            ids.push(id);
+        if (ids.length === MAX_KOKORO_TOKENS)
+            break;
+    }
+    return [0, ...ids, 0];
+}
+/** The style row a sentence of `tokens` ids (pads excluded) takes from a voice table. */
+export function sentenceStyle(styleTable, tokens) {
+    const rowCount = Math.floor(styleTable.length / STYLE_DIMENSION);
+    const row = Math.max(0, Math.min(rowCount - 1, tokens));
+    return styleTable.slice(row * STYLE_DIMENSION, (row + 1) * STYLE_DIMENSION);
+}
+/**
+ * Is a synthesis speech? Measured on 2026-09-14: WebGPU on one AMD GPU gave a waveform whose samples ran to 2×10⁷ — noise a child
+ * would hear as a burst. A speech waveform stays within ±1 (a sample or two past it is clipping, not noise) and is not silent.
+ */
+export function eFala(waveform) {
+    if (waveform.length === 0)
+        return false;
+    let outside = 0, energy = 0;
+    for (let i = 0; i < waveform.length; i++) {
+        const s = waveform[i];
+        if (!Number.isFinite(s))
+            return false;
+        if (Math.abs(s) > 1.5)
+            outside++;
+        energy += s * s;
+    }
+    return outside === 0 && Math.sqrt(energy / waveform.length) > 1e-3;
+}
+/** A 16-bit mono PCM WAV of a waveform, clipped to ±1 — what the narration's media element plays. */
+export function wavDe(waveform, sampleRate = KOKORO_SAMPLE_RATE) {
+    const n = waveform.length;
+    const buf = new ArrayBuffer(44 + n * 2);
+    const v = new DataView(buf);
+    const text = (o, s) => { for (let i = 0; i < s.length; i++)
+        v.setUint8(o + i, s.charCodeAt(i)); };
+    text(0, 'RIFF');
+    v.setUint32(4, 36 + n * 2, true);
+    text(8, 'WAVE');
+    text(12, 'fmt ');
+    v.setUint32(16, 16, true);
+    v.setUint16(20, 1, true);
+    v.setUint16(22, 1, true);
+    v.setUint32(24, sampleRate, true);
+    v.setUint32(28, sampleRate * 2, true);
+    v.setUint16(32, 2, true);
+    v.setUint16(34, 16, true);
+    text(36, 'data');
+    v.setUint32(40, n * 2, true);
+    for (let i = 0; i < n; i++)
+        v.setInt16(44 + i * 2, Math.round(Math.max(-1, Math.min(1, waveform[i])) * 32767), true);
+    return buf;
+}

package/dist-pkg/platform/listener-scope.d.ts

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** A window that remembers what was hung on it, so it can be taken down. */
+export interface ListenerScope {
+    /** The window to hand around. Identical to the real one, except that its listeners are remembered. */
+    readonly win: Window;
+    /**
+     * Takes off every listener still installed through `win`. Idempotent: what was already removed by hand, or removed itself
+     * (`once: true`), is simply no longer there — removing a listener that is not installed is a no-op in the DOM.
+     */
+    releaseAll(): void;
+}
+export declare function createListenerScope(real: Window): ListenerScope;

package/dist-pkg/platform/listener-scope.js

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/listener-scope — A WINDOW THAT CAN BE LET GO.
+//
+// 🔴 WHY THIS EXISTS, AND IT IS A DEFECT THAT WAS MEASURED, NOT A TIDINESS. A root (`boot/create-game`) installs about thirty
+// listeners on the window — the scan interception, START, SELECT, `action4`, the resize, the language change, and the five that
+// `ui/menu-nav.attach()` puts there — AND THERE WAS NO WAY TO TAKE THEM OFF. `unmount()` is not that way and must not become it:
+// it releases the CURRENT CARTRIDGE (ADR-0142), and a root that went deaf on `unmount()` would come back from the next `mount()`
+// with no keyboard at all.
+//
+// 📏 What that cost, measured in the browser with the real engine: a root whose host element was removed from the document KEEPS
+// LISTENING, and every query it makes is document-wide (`getPauseMenu` is `doc.querySelector('#vp-pause-0')`,
+// `topVisibleOverlay` is `doc.querySelectorAll('#game-region .overlay')`) — so the dead root finds THE LIVE ROOT'S pause card and
+// navigates it too. One ArrowDown moved the cursor one item with one root, TWO with a second root, THREE with a third. Nobody
+// gets an error: the child presses down once and the cursor jumps two.
+//
+// ⚠️ AND `stopPropagation()` SAVES NOBODY HERE. Every one of these listeners sits on the SAME node in the SAME phase, and
+// stopping propagation does not stop the siblings on that node — only `stopImmediatePropagation()` would, and using it would mean
+// the first root to be built silences every other one, which is a worse rule than the bug.
+//
+// 🎯 THE SHAPE: one seam instead of a `detach()` in each of the seven modules that listen. The root wraps the window ONCE and
+// hands the WRAPPER down; every listener installed through it — by the root or by any module it builds — is remembered, and
+// `releaseAll()` takes all of them off at once. A module that learns to listen tomorrow is covered without being edited, which a
+// list of `detach()` calls could never promise: the one that is forgotten is the one that leaks.
+//
+// 📌 Everything else about the window is UNCHANGED. `getComputedStyle`, `requestAnimationFrame`, `matchMedia`, `innerWidth` and
+// the rest answer exactly as the real window does — this is a window with a memory, not a window with a smaller API.
+const captureOf = (o) => (typeof o === 'boolean' ? o : !!o?.capture);
+export function createListenerScope(real) {
+    const installed = [];
+    // A released scope is ended: a listener armed before the end and added after it (a timer) must not reach the window.
+    let released = false;
+    const listen = (type, listener, options) => {
+        if (released)
+            return;
+        real.addEventListener(type, listener, options);
+        installed.push({ type, listener, capture: captureOf(options), options });
+    };
+    const forget = (type, listener, options) => {
+        real.removeEventListener(type, listener, options);
+        const capture = captureOf(options);
+        const i = installed.findIndex((e) => e.type === type && e.listener === listener && e.capture === capture);
+        if (i >= 0)
+            installed.splice(i, 1);
+    };
+    /*
+     * ⚠️ WHAT LEAVES THIS TRAP IS ANSWERED BY THE REAL WINDOW, NEVER BY THE PROXY, and it is not style: `innerWidth`,
+     * `devicePixelRatio` and `location` are GETTERS on the window, and `getComputedStyle`, `requestAnimationFrame` and
+     * `matchMedia` are methods of it — run any of them with the proxy as `this` and the browser answers «Illegal invocation».
+     * So the receiver is left at its default (which IS the target) and every function leaves answered by the real window.
+     *
+     * 🔴 EVERY FUNCTION, WITH NO GUESS AT WHAT IT IS (`onTheWindow`): a call runs with the real window as `this`, and everything
+     * else — `new`, the `prototype`, a static like `SpeechRecognition.available` — reaches the function itself. The rule before
+     * guessed: a function with a `prototype` was a constructor and left unbound, the rest were `bind`-ed. The guess held for the
+     * browser's own functions and failed for an extension's: one that wraps `window.fetch` does it with a plain `function`, which
+     * HAS a `prototype`, so the engine's fetch left unbound and every heavy file failed with «Illegal invocation» inside the
+     * download's `catch`. 📏 Measured on 2026-09-27 in the Dev's Brave: no heavy file ever requested, an empty checked cache, and
+     * the 👄 and the 📷 unable to start; with a wrapped fetch in a clean profile, 0 requests against 66 without it. A `bind` could
+     * not be the answer either: it drops the `prototype` that `platform/speech-recognition` reads.
+     */
+    const answered = new WeakMap();
+    const onTheWindow = (fn) => {
+        // one wrapper per function, so the same property read twice is the same function; `new` builds with the function itself as
+        // the target — with the wrapper as `newTarget`, a constructor already bound (a host may lend one) built an object with none of
+        // its methods («observe is not a function», measured in `tests/no-need-to-hold.browser.test.js`)
+        if (!answered.has(fn))
+            answered.set(fn, new Proxy(fn, {
+                apply: (f, _this, args) => Reflect.apply(f, real, args),
+                construct: (f, args) => Reflect.construct(f, args),
+            }));
+        return answered.get(fn);
+    };
+    const win = new Proxy(real, {
+        get(target, prop) {
+            if (prop === 'addEventListener')
+                return listen;
+            if (prop === 'removeEventListener')
+                return forget;
+            const value = Reflect.get(target, prop);
+            return typeof value === 'function' ? onTheWindow(value) : value;
+        },
+    });
+    const releaseAll = () => {
+        released = true;
+        // Drained as it goes: a listener that took another off while being removed would otherwise make this skip one, and a scope
+        // released twice must not try to take the same listener off again.
+        for (const e of installed.splice(0))
+            real.removeEventListener(e.type, e.listener, e.options);
+    };
+    return { win, releaseAll };
+}

package/dist-pkg/platform/locale-host.d.ts

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** The three hooks `core/i18n`'s port takes. A host that has no page passes none, and the engine runs without one. */
+export interface LocaleHostHooks {
+    readonly applied: (locale: string, tag: string) => void;
+    readonly preferred: () => string | null;
+    readonly follow: (react: (locale: string) => void) => void;
+}
+/**
+ * What a browser can offer a translator: the page effects of a change, the language the person's browser is set to, and
+ * the page's signal that ANOTHER root changed the language (ADR-0232 D3: the language is the page's, and every root follows).
+ */
+export declare function localeHostHooks(doc: Document, win: Window, applyDom: (root: ParentNode) => void): LocaleHostHooks;
+/** Hangs a root's translator on the window for tests and the preview, which is what `core/i18n` used to do to itself. */
+export declare function exposeI18n(win: Window, i18n: unknown): void;

package/dist-pkg/platform/locale-host.js

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/locale-host — WHAT A PAGE DOES WHEN THE LANGUAGE CHANGES, and what language it would prefer (ADR-0221 step 7g).
+//
+// 🔴 WHY THIS MODULE EXISTS: `core/i18n` used to write `document.documentElement.lang`, dispatch `i18n:change` on `window`,
+// read `navigator.language` and hang itself on `window.__i18n` — four reaches into globals from `core`, which ADR-0173
+// defines as «what the engine IS, without a browser». The health ratchet measured them (step 7d) and the Dev chose to SPLIT
+// rather than to move the module (option B, 2026-09-22): the decisions — which languages exist, which one is kept, what a
+// key resolves to — stay in `core`, and the three things only a page can do live here.
+//
+// 📌 WHY NOT INJECT AND LEAVE IT AT THAT, which was the cheaper option C: the sentence «core is what the engine is, without a
+// browser» would have stayed a rule with an exception nobody reads. 📏 The cost measured before choosing was 8 sites; this
+// module is what those 8 became.
+//
+// ⚠️ It touches `document` and `window` ON PURPOSE and that is why it is `platform/`: this is the layer whose job is the
+// browser. What it must never do is decide anything about language — it receives the locale and the tag already chosen.
+/**
+ * What a browser can offer a translator: the page effects of a change, the language the person's browser is set to, and
+ * the page's signal that ANOTHER root changed the language (ADR-0232 D3: the language is the page's, and every root follows).
+ */
+export function localeHostHooks(doc, win, applyDom) {
+    return {
+        applied: (locale, tag) => {
+            // 📌 THE THREE EFFECTS IN THE ORDER THEY WERE WRITTEN IN `core/i18n`, and the order matters to a screen reader: the
+            // document's language is announced before the text it governs changes.
+            doc.documentElement.lang = tag;
+            applyDom(doc);
+            win.dispatchEvent(new CustomEvent('i18n:change', { detail: { locale } }));
+        },
+        // ⚠️ `navigator` through the window, not the global: a host that hands the engine another window — a second document, an
+        // iframe — means that window's language, and reading the global would silently answer for the wrong one.
+        preferred: () => win.navigator?.language ?? null,
+        // 📌 On the window the root was GIVEN — its listener scope, so a disposed root stops following (ADR-0220).
+        follow: (react) => {
+            win.addEventListener('i18n:change', (e) => {
+                const locale = e.detail?.locale;
+                if (typeof locale === 'string')
+                    react(locale);
+            });
+        },
+    };
+}
+/** Hangs a root's translator on the window for tests and the preview, which is what `core/i18n` used to do to itself. */
+export function exposeI18n(win, i18n) {
+    win.__i18n = i18n;
+}

package/dist-pkg/platform/microphone.d.ts

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** The part of the Web Audio API this uses — narrow on purpose, so a case can answer it without a browser. */
+export interface AudioNodeLike {
+    connect(to: unknown): void;
+    disconnect(): void;
+}
+export interface ProcessorNode extends AudioNodeLike {
+    onaudioprocess: ((e: {
+        inputBuffer: {
+            getChannelData(ch: number): Float32Array;
+        };
+    }) => void) | null;
+}
+export interface AudioContextLike {
+    readonly sampleRate: number;
+    readonly destination: unknown;
+    createMediaStreamSource(stream: unknown): AudioNodeLike;
+    createScriptProcessor(bufferSize: number, inputs: number, outputs: number): ProcessorNode;
+    close(): Promise<void> | void;
+}
+/** A stream, in the one thing that matters after the reading: letting go of it. */
+export interface StreamLike {
+    getTracks(): readonly {
+        stop(): void;
+    }[];
+}
+/** What the microphone uses of the browser, lent by the root from the host's window (ADR-0232 D4). All REQUIRED. */
+export interface MicrophoneDeps {
+    /** The host's `navigator.mediaDevices.getUserMedia`. `undefined` is a device with no microphone: REFUSED and said, not hidden. */
+    readonly getUserMedia: ((constraints: {
+        audio: boolean;
+    }) => Promise<StreamLike>) | undefined;
+    /** A new audio context at this rate, from the host's `AudioContext`. */
+    readonly createContext: (rate: number) => AudioContextLike;
+    /** The host's clock, `performance.now()`: what the silence and the ceiling are measured against. */
+    readonly now: () => number;
+}
+export interface RecordOptions {
+    /** How long a silence ends the reading. Default 1.5 s: shorter cuts a child who is thinking between words. */
+    readonly silenceMs?: number;
+    /** The ceiling, so a forgotten microphone does not listen for ever. Default 30 s, the window Whisper reads at once. */
+    readonly maxMs?: number;
+}
+export interface Microphone {
+    /** Listens, and answers with what was said, at 16 kHz mono. */
+    record(options?: RecordOptions): Promise<Float32Array>;
+    /** Gives the microphone back now; the recording in hand answers with what it has. */
+    stop(): void;
+}
+export declare const READING_RATE = 16000;
+export declare function createMicrophone(d: MicrophoneDeps): Microphone;

package/dist-pkg/platform/microphone.js

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/microphone — THE CHILD'S VOICE, AND NOTHING ELSE (ADR-0216 §2, ADR-0200 erratum; issues #185, #200).
+//
+// The reading model eats 16 kHz mono samples. This is where they come from, and it is the only place in the engine that opens a
+// microphone for reading: what it captures stays in this page, is handed to the model on this machine, and is dropped when the
+// reading ends (ADR-0200's erratum: on the device or not at all).
+//
+// · IT ENDS WHEN THE CHILD DOES. A reading closes after `silenceMs` of quiet FOLLOWING something that was said, or at the `maxMs`
+//   ceiling, whichever comes first. A child who stops mid-sentence is not an error: what was heard so far is the answer.
+// · «QUIET» IS MEASURED, NOT ASSUMED. The first moments are taken as the room she is in, and sound is what stands above it —
+//   a fixed threshold would end a whispering child's reading in a noisy classroom, and never end in a quiet one.
+// · ⚠️ IT USES `ScriptProcessorNode`, which is deprecated. The replacement, an AudioWorklet, needs its code fetched as a module,
+//   and the engine's CSP has no `blob:` in `script-src` since ADR-0214 — so the modern way would need a new file in every
+//   delivery and a decision about serving it. This one works everywhere the project targets today, and it is written here so the
+//   next person does not «fix» it without that decision.
+export const READING_RATE = 16_000;
+const SILENCE_MS = 1500;
+const MAX_MS = 30_000;
+const BUFFER = 4096;
+/** How much of the start is taken as «the room»: long enough to be a room, short enough not to swallow a first word. */
+const ROOM_MS = 300;
+/** How far above the room a sound must be to be a voice, and the floor under it for a digitally silent input. */
+const OVER_ROOM = 4;
+const QUIETEST = 0.005;
+const rms = (block) => {
+    let sum = 0;
+    for (const v of block)
+        sum += v * v;
+    return Math.sqrt(sum / (block.length || 1));
+};
+/** 16 kHz from whatever the device gave us. Linear, because what follows is a mel filterbank, not a listener. */
+function atReadingRate(samples, from) {
+    if (from === READING_RATE)
+        return samples;
+    const out = new Float32Array(Math.round((samples.length * READING_RATE) / from));
+    const step = from / READING_RATE;
+    for (let i = 0; i < out.length; i++) {
+        const at = i * step;
+        const left = Math.floor(at);
+        const right = Math.min(left + 1, samples.length - 1);
+        out[i] = samples[left] + (samples[right] - samples[left]) * (at - left);
+    }
+    return out;
+}
+export function createMicrophone(d) {
+    const { now } = d;
+    let askToStop = null;
+    return {
+        stop() { askToStop?.(); },
+        async record(options = {}) {
+            const { getUserMedia } = d;
+            if (!getUserMedia)
+                throw new Error('microphone: this device offers none, so a reading cannot be heard here');
+            const makeContext = d.createContext;
+            const silenceMs = options.silenceMs ?? SILENCE_MS;
+            const maxMs = options.maxMs ?? MAX_MS;
+            const stream = await getUserMedia({ audio: true });
+            const context = makeContext(READING_RATE);
+            const source = context.createMediaStreamSource(stream);
+            const processor = context.createScriptProcessor(BUFFER, 1, 1);
+            const blocks = [];
+            const startedAt = now();
+            let room = 0, roomBlocks = 0, spoke = false, lastSound = startedAt, done = false;
+            return await new Promise((resolve) => {
+                const finish = () => {
+                    if (done)
+                        return;
+                    done = true;
+                    askToStop = null;
+                    processor.onaudioprocess = null;
+                    processor.disconnect();
+                    source.disconnect();
+                    // ⚠️ THE LIGHT GOES OUT. A track left running keeps the microphone open and the browser saying so, which to a child
+                    // and to whoever is with her means the game is still listening.
+                    for (const track of stream.getTracks())
+                        track.stop();
+                    void context.close();
+                    let total = 0;
+                    for (const b of blocks)
+                        total += b.length;
+                    const whole = new Float32Array(total);
+                    let at = 0;
+                    for (const b of blocks) {
+                        whole.set(b, at);
+                        at += b.length;
+                    }
+                    resolve(atReadingRate(whole, context.sampleRate));
+                };
+                askToStop = finish;
+                processor.onaudioprocess = (e) => {
+                    if (done)
+                        return;
+                    const block = Float32Array.from(e.inputBuffer.getChannelData(0));
+                    blocks.push(block);
+                    const level = rms(block);
+                    const elapsed = now() - startedAt;
+                    if (elapsed < ROOM_MS) {
+                        room = (room * roomBlocks + level) / (roomBlocks + 1);
+                        roomBlocks++;
+                        return;
+                    }
+                    if (level > Math.max(room * OVER_ROOM, QUIETEST)) {
+                        spoke = true;
+                        lastSound = now();
+                    }
+                    else if (spoke && now() - lastSound >= silenceMs) {
+                        finish();
+                        return;
+                    }
+                    if (elapsed >= maxMs)
+                        finish();
+                };
+                source.connect(processor);
+                processor.connect(context.destination);
+            });
+        },
+    };
+}

package/dist-pkg/platform/onnx-runtime.d.ts

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+export interface OnnxTensor {
+    readonly data: unknown;
+    readonly dims?: readonly number[];
+}
+/** An open graph: the names it answers with, and one run. */
+export interface OnnxSession {
+    readonly inputNames?: readonly string[];
+    readonly outputNames: readonly string[];
+    run(inputs: {
+        readonly [name: string]: OnnxTensor;
+    }): Promise<{
+        readonly [name: string]: OnnxTensor;
+    }>;
+}
+/** The part of onnxruntime the engine uses — small on purpose: what is not named here cannot be depended on. */
+export interface OnnxRuntime {
+    readonly Tensor: new (type: 'int64' | 'float32' | 'bool', data: BigInt64Array | Float32Array | Uint8Array, shape: readonly number[]) => OnnxTensor;
+    readonly InferenceSession: {
+        create(model: Uint8Array, options: {
+            executionProviders: readonly string[];
+        }): Promise<OnnxSession>;
+    };
+}
+/** Where the delivery serves a catalogued file, from the page's own address. */
+export declare const atDelivery: (id: string, base: string) => string;
+export interface OnnxRuntimeDeps {
+    /** The page's address, which `heavy/` is resolved against. */
+    readonly base: string;
+    /** `import()`, injected so a case can hand in a module without a network or a wasm engine. */
+    readonly importModule?: (url: string) => Promise<unknown>;
+}
+/** The runtime, from the delivery, with its threads pointed at the delivery too. Refuses by NAME when it is not there. */
+export declare function loadOnnxRuntime(d: OnnxRuntimeDeps): Promise<OnnxRuntime>;