@the-inclusionist/engine 10.0.0 → 11.0.0

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

@@ -22,6 +22,7 @@
 // the contract you think you have; the one that exists was three lines of the served file away.
 import { HEAVY_FILES, deliveryPath } from './heavy.js';
 import { commandsLanguageOf } from './heavy-catalogue.js';
+import { readModelVocabulary } from './vosk-vocabulary.js';
 /** The three files of the runtime. The model is chosen by language, below. */
 export const VOICE_RUNTIME_FILES = ['commands:runtime', 'commands:runtime:worker', 'commands:runtime:wasm'];
 /** The catalogue id of the model that hears THIS language, or `null` where the project has none. */
@@ -52,6 +53,48 @@ export function createBundleLoader(load) {
         return pending;
     };
 }
+/**
+ * ONE MODEL PER LANGUAGE, LOADED ONCE AND KEPT (ADR-0256): the 👄 and a choice by voice ask the same `load`, and a listener that
+ * stops no longer ends the model — the one handed out has a `terminate` that does nothing; the real one is ended when it is
+ * pushed out (more than `keep` languages, the oldest first) or by `closeAll()`, the root's end.
+ * 📏 Why: every start used to spawn a worker and unpack ~40 MiB of model, and every choice started two — the Dev's machine froze
+ * on 2026-09-27. A load that failed is forgotten, so a model that comes down later is found.
+ */
+export function keepVoskModels(load, keep = 2) {
+    /** Per language: the load as it came (whose model is the one to end) and the one handed out. */
+    const kept = new Map();
+    const end = (entry) => {
+        void entry.real.then((l) => { if (l.ok)
+            l.model.terminate?.(); }, () => { });
+    };
+    return {
+        load(d) {
+            const key = d.language.split('-')[0].toLowerCase();
+            const found = kept.get(key);
+            if (found) {
+                kept.delete(key);
+                kept.set(key, found);
+                return found.lent;
+            } // the most recent last
+            const real = load(d);
+            const lent = real.then((l) => (l.ok ? { ...l, model: { get KaldiRecognizer() { return l.model.KaldiRecognizer; }, terminate: () => { } } } : l));
+            const entry = { real, lent };
+            kept.set(key, entry);
+            const forget = () => { if (kept.get(key) === entry)
+                kept.delete(key); };
+            real.then((l) => { if (!l.ok)
+                forget(); }, forget);
+            while (kept.size > keep) {
+                const [oldest, q] = kept.entries().next().value;
+                kept.delete(oldest);
+                end(q);
+            }
+            return lent;
+        },
+        closeAll() { for (const entry of kept.values())
+            end(entry); kept.clear(); },
+    };
+}
 /**
  * Opens the recogniser for the child's language, or says what is missing.
  *
@@ -89,5 +132,20 @@ export async function loadVoskRuntime(d) {
         throw new Error(`vosk-runtime: the bundle asked for a file this delivery does not carry: ${logicalPath}`);
     };
     // 📌 `-1` is the bundle's «say nothing»: a recogniser that logs every frame fills a school machine's console with noise.
-    return { ok: true, model: await api.createModel(at(modelId), beside, -1) };
+    const model = await api.createModel(at(modelId), beside, -1);
+    const { fetch } = d;
+    if (!fetch)
+        return { ok: true, model };
+    // the SAME address the worker was given: the service worker answers both from the checked cache, and the words read are the
+    // words of the model that was loaded, never another language's
+    const vocabulary = async () => {
+        try {
+            const r = await fetch(at(modelId));
+            return r.ok && r.body ? await readModelVocabulary(r.body) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    return { ok: true, model, vocabulary };
 }

package/dist-pkg/platform/vosk-vocabulary.d.ts

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * The words the model in this `.tar.gz` knows — the output symbol table of its `Gr.fst` — or `null` when that cannot be read
+ * (no word graph, a header that is not OpenFst's, a stream that ends early). Stops reading the archive once the table is read.
+ */
+export declare function readModelVocabulary(archive: ReadableStream<BufferSource>): Promise<ReadonlySet<string> | null>;

package/dist-pkg/platform/vosk-vocabulary.js

@@ -0,0 +1,178 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/vosk-vocabulary — THE WORDS A VOSK MODEL KNOWS, READ FROM ITS OWN ARCHIVE (ADR-0194 §4, ADR-0169).
+//
+// A menu item whose name has a word the model lacks cannot be said: Kaldi drops that word from the grammar and the item goes
+// mute. The recogniser cannot tell the page so, and this was MEASURED in the delivery's runtime (`vosk-browser-dynamic-
+// execution-0`), not assumed: the drop is a Kaldi warning («Ignoring word missing in vocabulary: 'acao'») written by the wasm to
+// the WORKER's console, never posted to the page, and the bundle's API has no call that lists the vocabulary. So the page reads
+// the list where the model keeps it — the output symbol table of its word graph `Gr.fst`, in the header, before any state — from
+// the same archive the worker opens, and stops reading as soon as the table ends.
+//
+// 📏 In `vosk-model-small-pt-0.3.tar.gz` (the delivery's archive, sorted by `scripts/models/repack-vosk-models.py`) `Gr.fst` is
+// the first entry and its table (99 105 words) ends 4 MB into the uncompressed tar; «configurações», «ação» and «estibordo» are
+// in it, «configuracoes», «acao» and «boreste» are not — the same answers the earlier lab and browser measurements gave. The es
+// and en archives were NOT on the machine that measured this; their `Gr.fst` should sit under `graph/`, after other entries,
+// which the walk below passes over.
+//
+// ⚠️ A model with no `Gr.fst` answers `null` («cannot know»), not an empty set: such a model has no runtime grammar at all, and
+// an empty set would report every word of every name as missing.
+/** The magic numbers of an OpenFst binary file and of a symbol table written inside one (`fst/fst.h`, `fst/symbol-table.h`). */
+const FST_MAGIC = 2125659606;
+const SYMBOL_TABLE_MAGIC = 2125658996;
+/** The header flags that say an input / output symbol table follows the header. */
+const HAS_INPUT_SYMBOLS = 1;
+const HAS_OUTPUT_SYMBOLS = 2;
+const TAR_BLOCK = 512;
+/** Guards against reading a corrupt length as a request for gigabytes. */
+const MAX_STRING = 1 << 16;
+const MAX_SYMBOLS = 5_000_000;
+const UTF8 = new TextDecoder('utf-8');
+const ASCII = new TextDecoder('latin1');
+/** The archive ended, or a length in it cannot be true: whatever was being read cannot be known. */
+class Unreadable extends Error {
+}
+/**
+ * A pull reader over a byte stream: takes exactly what it is asked for, across chunk boundaries, and THROWS `Unreadable` when the
+ * stream ends first — so a reader of a format states the format, and one `catch` answers every truncation.
+ */
+class Bytes {
+    chunks = [];
+    head = 0;
+    have = 0;
+    source;
+    constructor(source) { this.source = source; }
+    async fill(n) {
+        while (this.have < n) {
+            const { done, value } = await this.source.read();
+            if (done)
+                throw new Unreadable('the archive ended');
+            if (value.length) {
+                this.chunks.push(value);
+                this.have += value.length;
+            }
+        }
+    }
+    drop(k) {
+        this.head += k;
+        this.have -= k;
+        if (this.head === this.chunks[0].length) {
+            this.chunks.shift();
+            this.head = 0;
+        }
+    }
+    /** The next `n` bytes. */
+    async take(n) {
+        await this.fill(n);
+        const out = new Uint8Array(n);
+        for (let o = 0; o < n;) {
+            const k = Math.min(n - o, this.chunks[0].length - this.head);
+            out.set(this.chunks[0].subarray(this.head, this.head + k), o);
+            o += k;
+            this.drop(k);
+        }
+        return out;
+    }
+    /** Passes `n` bytes without keeping them. */
+    async skip(n) {
+        for (let left = n; left > 0;) {
+            await this.fill(1);
+            const k = Math.min(left, this.chunks[0].length - this.head);
+            left -= k;
+            this.drop(k);
+        }
+    }
+    async int32() { return new DataView((await this.take(4)).buffer).getInt32(0, true); }
+    async int64() { return Number(new DataView((await this.take(8)).buffer).getBigInt64(0, true)); }
+    /** An OpenFst string: a 32-bit length, then that many bytes of UTF-8. */
+    async text() { return UTF8.decode(await this.take(bounded(await this.int32(), MAX_STRING))); }
+}
+/** A length read from the archive, refused when it cannot be one. */
+function bounded(n, max) {
+    if (!Number.isFinite(n) || n < 0 || n > max)
+        throw new Unreadable(`a length of ${n}`);
+    return n;
+}
+/** A NUL-padded tar field as text. */
+const field = (block, from, length) => ASCII.decode(block.subarray(from, from + length)).replace(/\0.*$/s, '');
+/** The value of `path` in a pax extended header, if it sets one. */
+const paxPath = (data) => /(?:^|\n)\d+ path=([^\n]*)\n/.exec(UTF8.decode(data))?.[1] ?? null;
+/** The path a ustar header names: its prefix and its name. */
+const headerPath = (header) => {
+    const prefix = field(header, 345, 155);
+    return prefix ? `${prefix}/${field(header, 0, 100)}` : field(header, 0, 100);
+};
+const isWordGraph = (type, path) => (type === '0' || type === '\0') && /(?:^|\/)Gr\.fst$/.test(path);
+/**
+ * Walks the tar entries until one whose path ends in `/Gr.fst` and leaves the reader at its first byte. `false` when the archive
+ * ends without one. Pax (`x`) and GNU long-name (`L`) headers name the entry that follows them; a global pax header is skipped.
+ */
+async function toWordGraph(bytes) {
+    let named = null;
+    for (;;) {
+        const header = await bytes.take(TAR_BLOCK);
+        if (header.every((b) => b === 0))
+            return false;
+        const size = bounded(parseInt(field(header, 124, 12).trim() || '0', 8), Number.MAX_SAFE_INTEGER);
+        const padded = Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+        const type = String.fromCharCode(header[156]);
+        if (type === 'x' || type === 'L') {
+            const data = (await bytes.take(padded)).subarray(0, size);
+            named = type === 'x' ? paxPath(data) : field(data, 0, size);
+            continue;
+        }
+        if (isWordGraph(type, named ?? headerPath(header)))
+            return true;
+        named = null;
+        await bytes.skip(padded);
+    }
+}
+/** One symbol table, as `fst::SymbolTable::Write` lays it out: magic, name, available key, size, then (symbol, key) pairs. */
+async function symbolTable(bytes) {
+    if ((await bytes.int32()) !== SYMBOL_TABLE_MAGIC)
+        throw new Unreadable('not a symbol table');
+    await bytes.text();
+    await bytes.int64();
+    const size = bounded(await bytes.int64(), MAX_SYMBOLS);
+    const words = new Set();
+    for (let i = 0; i < size; i++) {
+        words.add(await bytes.text());
+        await bytes.int64();
+    }
+    return words;
+}
+/**
+ * The OpenFst header up to its flags — magic, fst type, arc type, version, flags, properties, start, states, arcs — and the flags,
+ * leaving the reader at the first symbol table.
+ */
+async function fstFlags(bytes) {
+    if ((await bytes.int32()) !== FST_MAGIC)
+        throw new Unreadable('not an OpenFst file');
+    await bytes.text();
+    await bytes.text();
+    await bytes.int32();
+    const flags = await bytes.int32();
+    await bytes.skip(4 * 8);
+    return flags;
+}
+/**
+ * The words the model in this `.tar.gz` knows — the output symbol table of its `Gr.fst` — or `null` when that cannot be read
+ * (no word graph, a header that is not OpenFst's, a stream that ends early). Stops reading the archive once the table is read.
+ */
+export async function readModelVocabulary(archive) {
+    const reader = archive.pipeThrough(new DecompressionStream('gzip')).getReader();
+    const bytes = new Bytes(reader);
+    try {
+        if (!(await toWordGraph(bytes)))
+            return null;
+        const flags = await fstFlags(bytes);
+        const input = flags & HAS_INPUT_SYMBOLS ? await symbolTable(bytes) : null;
+        // the words a grammar is matched against are the OUTPUT side; an acceptor written with one table has it on both
+        return flags & HAS_OUTPUT_SYMBOLS ? await symbolTable(bytes) : input;
+    }
+    catch {
+        return null; // truncated, not OpenFst, not gzip: each is one more «cannot know»
+    }
+    finally {
+        reader.cancel().catch(() => { });
+    }
+}

package/dist-pkg/render/crt.d.ts

@@ -22,17 +22,19 @@ export interface CrtCtx {
      */
     numPlayers: () => number;
     /**
-     * Is ANY player in a visual accessibility mode? (anything other than `normal`.)
+     * Does the SCANLINE yield now? The ROOT answers, because the root is where the visual modes are known (ADR-0232): under
+     * every visual accessibility mode but a colour-vision one on its own (ADR-0241). A correction or a simulation of colour
+     * blindness changes hue; a stripe costs a low-vision child half the vertical resolution of a glyph (ADR-0047).
      *
-     * ADR-0020 decides that accessibility modes SUPPRESS the CRT and decorative effects — accessibility takes precedence
-     * over aesthetics. Without it, `crt-vig-1` survived in `hc-direto`, `fix-deuter`, `lv-blur` and `blind` with the
-     * vignette on: a vignette darkening the edges works against the mode that exists to RAISE contrast.
-     *
-     * `ANY` and not "player 1": the CRT is GLOBAL decoration, one for the whole screen. There is no darkening the edges of
-     * half a screen. If the decoration and any child's accessibility contradict each other, the decoration yields — which
-     * is literally what accessibility-over-aesthetics means.
+     * A question for the whole screen and not for "player 1": the CRT is GLOBAL decoration, and if it contradicts any
+     * child's accessibility, the decoration yields.
+     */
+    scanlineYields: () => boolean;
+    /**
+     * Does the VIGNETTE yield now? Under EVERY visual accessibility mode, the colour-vision ones included (ADR-0047,
+     * kept by ADR-0241): darkened edges work against a mode that exists to raise contrast, whatever it does to hue.
      */
-    a11yVisualOn: () => boolean;
+    vignetteYields: () => boolean;
     /** Where the CRT is read from at build and kept at every `apply()`. Required: a look read from nowhere resets each visit. */
     store: CrtStore;
 }

package/dist-pkg/render/crt.js

@@ -3,8 +3,8 @@
 // region). `createCrt` builds one per root (ADR-0232 D4, issue #207): its `cfg` is the config {scan,vig,round} (0=off,1,2;
 // scan/vig are on/off) read from the injected store at build, migrating the old boolean format. `scanVars` anchors the
 // scanline to REAL PIXELS (recomputed from the region's real height + dpr → 1 line per art pixel, regular spacing).
-// Everything it touches arrives by injection: the region, the window's pixel ratio, the player count, the accessibility
-// question and the store.
+// Everything it touches arrives by injection: the region, the window's pixel ratio, the player count, the two
+// accessibility answers (does the scanline yield? does the vignette?) and the store.
 import { screenGrid } from '../core/screens.js';
 import { KEYS } from '../platform/storage-keys.js';
 // scanlines ON by default (the Dev's decision). Migrates incl_crt (boolean) → incl_crt2 (levels 0..2).
@@ -70,21 +70,17 @@ export function createCrt(ctx) {
         if (!g)
             return;
         ['crt-scan-1', 'crt-vig-1', 'crt-round-0', 'crt-round-2'].forEach((c) => g.classList.remove(c));
-        // BOTH EFFECTS YIELD TO ACCESSIBILITY, WITH NO EXCEPTION (ADR-0020 + ADR-0047).
-        //
-        // A version with a per-effect escape switch existed, at the Dev's request. They removed it after SEEING the result
-        // on screen: «Ceder fez muito bem ao jogo nos modos de acessibilidade». It is noted because the switch's absence is a
-        // decision, not an oversight — and because pillar 2 is back to having no exception at all.
+        // EACH EFFECT YIELDS TO ITS OWN ANSWER (ADR-0047, ADR-0241): the vignette to every visual mode, the scanline to every
+        // one but a colour-vision mode on its own. There is no escape switch for the child, by the Dev's decision (ADR-0047).
         //
         // The stored value is NOT changed: the preference stays and counts again by itself on leaving the accessibility
         // mode. Suppressing is not turning off — it is the distinction that keeps the child from losing what they chose every
         // time they turn high contrast on.
-        const a11y = ctx.a11yVisualOn();
-        if (cfg.scan && !a11y) {
+        if (cfg.scan && !ctx.scanlineYields()) {
             g.classList.add('crt-scan-' + cfg.scan);
             scanVars();
         }
-        if (cfg.vig && !a11y)
+        if (cfg.vig && !ctx.vignetteYields())
             g.classList.add('crt-vig-' + cfg.vig);
         if (cfg.round !== 1)
             g.classList.add('crt-round-' + cfg.round); // 1 = the default look (8px), no class

package/dist-pkg/render/cvd-matrices.d.ts

@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 /** The six colour-blindness mode keys — the SAME keys as `VIZ_MODES` in render/viz-modes. */
 export type CvdKey = 'sim-protan' | 'sim-deuter' | 'sim-tritan' | 'fix-protan' | 'fix-deuter' | 'fix-tritan';
-/** Canonical order: the three simulations (what the person sees) before the three corrections (what helps them see). */
+/**
+ * Canonical order: the three simulations (what the person sees) before the three corrections (what helps them see).
+ * It is also THE list of colour-vision modes the rest of the engine asks about — `onlyColourVision` (render/viz-axes)
+ * reads it for the scanline that stays under them (ADR-0241).
+ */
 export declare const CVD_KEYS: readonly CvdKey[];
 /**
  * The matrices, 4×5 in row order. Row A = `0 0 0 1 0` in all of them: none of the six modes touches alpha.

package/dist-pkg/render/cvd-matrices.js

@@ -17,7 +17,11 @@
 // `feColorMatrix type="matrix"` and `PIXI.ColorMatrixFilter#matrix` — so the array serves both with no conversion.
 // Applied in sRGB on both paths (the web's standard approximation; see the research's decision 2). Primary source and
 // the value-by-value check: docs/research/RESEARCH-DALTONIZATION.md.
-/** Canonical order: the three simulations (what the person sees) before the three corrections (what helps them see). */
+/**
+ * Canonical order: the three simulations (what the person sees) before the three corrections (what helps them see).
+ * It is also THE list of colour-vision modes the rest of the engine asks about — `onlyColourVision` (render/viz-axes)
+ * reads it for the scanline that stays under them (ADR-0241).
+ */
 export const CVD_KEYS = ['sim-protan', 'sim-deuter', 'sim-tritan', 'fix-protan', 'fix-deuter', 'fix-tritan'];
 /**
  * The matrices, 4×5 in row order. Row A = `0 0 0 1 0` in all of them: none of the six modes touches alpha.

package/dist-pkg/render/high-contrast.d.ts

@@ -2,8 +2,7 @@
 import { type CanvasDoc } from './canvas.js';
 import { type HcRoleKey, type PaintableRole } from './hc-role-data.js';
 import type { Store } from '../platform/storage.js';
-export type { PaintableRole, HcRoleKey } from './hc-role-data.js';
-export { HC_ROLE_KEYS, HC_ROLE_DEF } from './hc-role-data.js';
+export { HC_ROLE_DEF } from './hc-role-data.js';
 /** A role palette: one RGB triple per role. */
 export type RolePalette = Record<HcRoleKey, [number, number, number]>;
 export interface DirectCfg {

package/dist-pkg/render/high-contrast.js

@@ -14,7 +14,11 @@ import { outlineCanvas } from './sprite-fx.js';
 import { TILE } from '../core/constants.js';
 import { HC_ROLE_DEF } from './hc-role-data.js';
 import { KEYS } from '../platform/storage-keys.js';
-export { HC_ROLE_KEYS, HC_ROLE_DEF } from './hc-role-data.js';
+/* ===================== role → colour (color-blocking) ===================== */
+// The roles and their default colours live in render/hc-role-data (a leaf, no dependencies), because the visual
+// accessibility panel needs the SAME list to offer a colour picker per role. `HC_ROLE_DEF` is re-exported here because the
+// engine imports it from here; the rest is read from the leaf (issue #204).
+export { HC_ROLE_DEF } from './hc-role-data.js';
 /** The defaults with the stored colours laid over them, each clamped to 0–255; a malformed entry keeps its default. */
 function storedPalette(store) {
     const palette = JSON.parse(JSON.stringify(HC_ROLE_DEF));

package/dist-pkg/render/viz-axes.d.ts

@@ -54,6 +54,15 @@ export declare function isSimulation(v: VisualState): boolean;
 export declare function isBlind(v: VisualState): boolean;
 /** Is it one of the five LOW-VISION simulations? They need the overlay as a texture, not only a filter. */
 export declare function isLowVision(v: VisualState): boolean;
+/**
+ * Is a COLOUR-VISION mode the only visual mode in this state — the 🚥 correction, or the simulation of the same colour
+ * blindness, with the theme at its default? The decorative scanline stays under these (ADR-0241): they change hue, not
+ * contrast or sharpness.
+ *
+ * 📌 The list is `CVD_KEYS`, where those six modes are defined with their matrices: a colour-vision mode added there
+ * counts here, with no second list of names to keep true.
+ */
+export declare function onlyColourVision(v: VisualState): boolean;
 /** Is the theme off its default? It replaces a `/^hc-direto/` test on the old string. */
 export declare function hasHighContrast(v: VisualState): boolean;
 /** The next THEME in the quick bar icon's cycle. It moves only on its own axis and does not touch the correction. */

package/dist-pkg/render/viz-axes.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-// render/viz-axes — THE TWO AXES, and the simulation that is NOT one of them (ADR-0076). Only dependency: the shapes,
-// from `core/visual-state`.
+// render/viz-axes — THE TWO AXES, and the simulation that is NOT one of them (ADR-0076). Dependencies: the shapes, from
+// `core/visual-state`, and the list of colour-vision modes, from the leaf `render/cvd-matrices` that defines them.
 //
 // ========================= THE DEFECT THIS FIXES =========================
 // With ONE radio and `p.viz` keeping ONE string, choosing `fix-deuter` turned 7:1 contrast off, and choosing a contrast
@@ -19,6 +19,7 @@
 // Over an already corrected screen, a simulation shows neither the disability nor the correction; over a high-contrast
 // theme, it shows what the theme does and not what deuteranopia does. A demonstration running over an adaptation is not
 // a weaker demonstration — **it teaches something false**.
+import { CVD_KEYS } from './cvd-matrices.js';
 export const DEFAULT_VISUAL = Object.freeze({ tema: 'padrao', correcao: 'tricro', simulacao: null });
 /**
  * Are both axes at their default?
@@ -91,6 +92,18 @@ export function isBlind(v) {
 export function isLowVision(v) {
     return v.simulacao !== null && v.simulacao.startsWith('lv-');
 }
+/**
+ * Is a COLOUR-VISION mode the only visual mode in this state — the 🚥 correction, or the simulation of the same colour
+ * blindness, with the theme at its default? The decorative scanline stays under these (ADR-0241): they change hue, not
+ * contrast or sharpness.
+ *
+ * 📌 The list is `CVD_KEYS`, where those six modes are defined with their matrices: a colour-vision mode added there
+ * counts here, with no second list of names to keep true.
+ */
+export function onlyColourVision(v) {
+    const key = filterKey(v);
+    return !hasHighContrast(v) && key !== null && CVD_KEYS.includes(key);
+}
 /** Is the theme off its default? It replaces a `/^hc-direto/` test on the old string. */
 export function hasHighContrast(v) {
     return v.tema !== 'padrao';

package/dist-pkg/ui/aac-sets.d.ts

@@ -1,40 +1,45 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import type { Translate } from '../core/i18n.js';
 export type AacTier = 
-/** CC BY-SA or ours: it may travel inside the game and works with no network at all. */
-'bundled'
-/** The licence allows use, not redistribution: the person downloads it, once, and it stays cached. */
- | 'fetched'
-/** Permission is missing. It appears in the menu and is not selectable. */
- | 'negotiating';
-export interface AacSet {
+/** A licence is RECORDED in `license`: the set may be chosen. */
+'licensed'
+/** No licence: the set appears in the menu, locked, with the reason. */
+ | 'unlicensed';
+interface AacSetBase {
     readonly key: string;
     readonly name: string;
-    readonly tier: AacTier;
-    /** The licence as it was VERIFIED, or null when there is none yet. Short text, to fit on screen. */
-    readonly license: string | null;
-    /** Does it work IN THIS build? The pictograms are files that have not arrived yet. */
-    readonly available: boolean;
     /** Pictograms only: one line about the origin, when it changes what the choice means. */
     readonly note?: string;
 }
+/**
+ * A pictogram set. The tier and the licence travel together BY TYPE: a licensed set names its licence (short text, to
+ * fit on screen), and an unlicensed one has none to name.
+ */
+export type AacSet = (AacSetBase & {
+    readonly tier: 'licensed';
+    readonly license: string;
+}) | (AacSetBase & {
+    readonly tier: 'unlicensed';
+    readonly license: null;
+});
 export declare const AAC_SETS: readonly AacSet[];
 export declare const AAC_BY_KEY: Readonly<Record<string, AacSet>>;
-/** Which SETS the child can choose today: none. The menu does not pretend otherwise — the pictograms are thousands
- *  of files that have not entered the repository, and four of the sets depend on negotiation. */
+/** Can the child choose this set? Only when it is licensed — the tier is the one fact the menu reads. */
+export declare function aacSelectable(s: AacSet): boolean;
+/** Which SETS the child can choose today: none, because no licence has been obtained (ADR-0233). */
 export declare function aacAvailable(): AacSet[];
 /**
- * Why this set is not available — an i18n key, never finished text.
- *
- * The two answers tell the reader different things, which is why there are two: "in preparation" means the licence
- * is settled and the work is OURS; "awaiting negotiation" means the permission belongs to SOMEONE ELSE and no effort
- * of ours brings it forward.
- *
- * And that is why the unavailable ones are shown instead of hidden: they are exactly the sets a Brazilian school is
- * most likely to already use in another product. The educator who looks for PCS and does not find it concludes the
- * game cannot do it — when the obstacle is a licence, not a capability. Hiding would answer the wrong question, and
- * answer it wrongly.
+ * Is the AAC menu's DOOR disabled? Yes while no set is licensed (ADR-0233 erratum): the menu exists for pictogram
+ * exercises and a pictogram keyboard, and with no set it has nothing to offer. The door then says only that the menu is
+ * disabled (`pause.motivo.caa`) — never the licence reason. Letter case does not wait for it: it lives in the quick bar's
+ * communication cycle (ADR-0151).
+ */
+export declare function aacMenuLocked(): boolean;
+/**
+ * Why this set cannot be chosen — an i18n key, never finished text. One answer, because there is one reason: no
+ * licence. A selectable set has nothing to explain.
  */
 export declare function aacReason(s: AacSet): string | null;
 /** A label ready for the menu row: the name + the reason, when there is one. */
 export declare function aacLabel(t: Translate, s: AacSet): string;
+export {};

package/dist-pkg/ui/aac-sets.js

@@ -3,44 +3,36 @@
 // off, with off meaning both cases), not two entries. A binary choice presented as two options makes the child compare
 // two rows to discover they are the same question; a switch asks once.
 //
-// What remains here is genuinely a LIST: the pictogram sets, of which one is chosen.
+// What remains here is genuinely a LIST: the pictogram sets, of which one is chosen. «PCS» is the Picture Communication
+// Symbols set (ADR-0233 reads the Dev's «PECS» as PCS: PECS is a teaching method, not a symbol set).
 export const AAC_SETS = [
-    // --- PICTOGRAMS that MAY travel with the game (CC BY-SA, verified by the Dev). ---
-    { key: 'mulberry', name: 'Mulberry Symbols', tier: 'bundled', license: 'CC BY-SA', available: false },
-    { key: 'blissymbolics', name: 'Blissymbolics', tier: 'bundled', license: 'CC BY-SA 4.0', available: false,
-        note: 'Escrita simbólica própria: os símbolos se combinam para formar sentidos novos.' },
-    { key: 'tawasol', name: 'Tawasol', tier: 'bundled', license: 'CC BY-SA 4.0', available: false,
-        note: 'Desenhado na e para a cultura árabe. Um pictograma não é neutro — a criança reconhece mais depressa os objetos, as roupas e os rostos do próprio mundo.' },
-    // --- PICTOGRAMS that must be DOWNLOADED. ---
-    { key: 'arasaac', name: 'ARASAAC', tier: 'fetched', license: 'baixado à parte', available: false },
-    // --- AWAITING NEGOTIATION. Visible on purpose: see `aacReason`. ---
-    { key: 'sclera', name: 'Sclera', tier: 'negotiating', license: null, available: false },
-    { key: 'pcs', name: 'PCS', tier: 'negotiating', license: null, available: false },
-    { key: 'symbolstix', name: 'SymbolStix', tier: 'negotiating', license: null, available: false },
-    { key: 'widgit', name: 'Widgit Symbols', tier: 'negotiating', license: null, available: false },
+    { key: 'arasaac', name: 'ARASAAC', tier: 'unlicensed', license: null },
+    { key: 'pcs', name: 'PCS', tier: 'unlicensed', license: null },
 ];
 export const AAC_BY_KEY = Object.fromEntries(AAC_SETS.map((s) => [s.key, s]));
-/** Which SETS the child can choose today: none. The menu does not pretend otherwise — the pictograms are thousands
- *  of files that have not entered the repository, and four of the sets depend on negotiation. */
+/** Can the child choose this set? Only when it is licensed — the tier is the one fact the menu reads. */
+export function aacSelectable(s) {
+    return s.tier === 'licensed';
+}
+/** Which SETS the child can choose today: none, because no licence has been obtained (ADR-0233). */
 export function aacAvailable() {
-    return AAC_SETS.filter((s) => s.available);
+    return AAC_SETS.filter(aacSelectable);
+}
+/**
+ * Is the AAC menu's DOOR disabled? Yes while no set is licensed (ADR-0233 erratum): the menu exists for pictogram
+ * exercises and a pictogram keyboard, and with no set it has nothing to offer. The door then says only that the menu is
+ * disabled (`pause.motivo.caa`) — never the licence reason. Letter case does not wait for it: it lives in the quick bar's
+ * communication cycle (ADR-0151).
+ */
+export function aacMenuLocked() {
+    return aacAvailable().length === 0;
 }
 /**
- * Why this set is not available — an i18n key, never finished text.
- *
- * The two answers tell the reader different things, which is why there are two: "in preparation" means the licence
- * is settled and the work is OURS; "awaiting negotiation" means the permission belongs to SOMEONE ELSE and no effort
- * of ours brings it forward.
- *
- * And that is why the unavailable ones are shown instead of hidden: they are exactly the sets a Brazilian school is
- * most likely to already use in another product. The educator who looks for PCS and does not find it concludes the
- * game cannot do it — when the obstacle is a licence, not a capability. Hiding would answer the wrong question, and
- * answer it wrongly.
+ * Why this set cannot be chosen — an i18n key, never finished text. One answer, because there is one reason: no
+ * licence. A selectable set has nothing to explain.
  */
 export function aacReason(s) {
-    if (s.available)
-        return null;
-    return s.tier === 'negotiating' ? 'aac.aguardandoNegociacao' : 'aac.emPreparo';
+    return aacSelectable(s) ? null : 'aac.noLicence';
 }
 /** A label ready for the menu row: the name + the reason, when there is one. */
 export function aacLabel(t, s) {

package/dist-pkg/ui/audio-choices.d.ts

@@ -9,8 +9,11 @@ export interface AudioCatState {
     on: boolean;
     vol: number;
 }
-/** The SOUND-NAVIGATION categories (cane/sonar/guard/guide) — their master volume is separate from the game's sound. */
-export declare const NAV_CATS: readonly ["sonar", "guard", "guide"];
+/**
+ * The SOUND-NAVIGATION categories — their master volume is separate from the game's sound. Only the sonar since `guard` and
+ * `guide` left (ADR-0258): the engine plays nothing in them since the guide moved to the platformer.
+ */
+export declare const NAV_CATS: readonly ["sonar"];
 /** The game's GENERAL categories (TTS lives in the Voice section, outside this list). */
 export declare const GEN_CATS: readonly ["music", "ambient", "interact", "earcons"];
 /** 0..1 -> 0..100 rounded (slider display value). */
@@ -36,14 +39,16 @@ export interface VoiceLike {
     lang: string;
 }
 /**
- * The system voices in the language asked for; with none of them, the whole list.
+ * The system voices in the language asked for, and ONLY those (ADR-0185): with none of them, none — the list then says there is
+ * no voice, and the speech rows lock.
  *
  * It was called `pickPtVoices` and filtered a hard-coded `/^pt/i`, so a game in English offered a child a list of PORTUGUESE
  * voices to read English text. The name told the truth about what it did and lied about what it should do.
  *
  * The comparison is by language PREFIX and not by the whole tag: a child playing in pt-BR should also be able to choose a
- * pt-PT voice if that is the only one installed, and a school's browser rarely has the exact variant. The fallback to the
- * whole list stays: an empty list would be worse than a list in the wrong language, which at least she can hear and reject.
+ * pt-PT voice if that is the only one installed, and a school's browser rarely has the exact variant. 🔴 There is no fallback
+ * to the whole list: a voice of another language reads the text with the wrong phonetics, and ADR-0243 §3 decided that a wrong
+ * voice is worse than none — silence is noticed, a wrong accent is learned.
  */
 export declare function pickVoicesFor<T extends VoiceLike>(voices: readonly T[], lang: string): readonly T[];
 /** "<name> (<lang>)" option label. */