@the-inclusionist/engine 8.0.0 → 10.0.0

package/dist-pkg/core/screens.js

@@ -1,27 +1,22 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-// core/screens — a grade de telas do multiplayer, num só lugar.
+// core/screens — the multiplayer screen grid, in one place.
 //
-// O jogo divide a janela em uma tela por jogador (pilar: multiplayer em telas SEPARADAS, sem split-screen —
-// ADR-0010). Quantas colunas e quantas linhas isso dá era uma conta de uma linha copiada em CINCO lugares:
-// ui/layout.ts (escala inteira), render/crt.ts (só as linhas, para o passo do scanline), ui/hud.ts (posição
-// de cada `.player-screen`), e no game.js em configureRender() e fitsN().
+// The game splits the window into one screen per player (pillar: multiplayer on SEPARATE screens, no split-screen —
+// ADR-0010). How many columns and rows that gives was a one-line sum copied into several places (the layout's integer
+// scale, the CRT's scanline step, the HUD's `.player-screen` positions), and one copy DIVERGED: without the `n<=1`
+// guard, n=0 gives zero columns and every geometry becomes NaN. It survived because that case is unreachable today,
+// not because anyone checked it — which is why the sum lives here once.
 //
-// A quinta cópia estava DIVERGENTE: `cols = n<=2 ? n : 2`, sem a guarda de `n<=1`. Para n>=1 as duas contas
-// concordam, então a divergência nunca chegou a aparecer — com n=0 uma devolve 1 e a outra devolve 0, e
-// dividir por 0 colunas daria NaN em toda a geometria. Vale a pena guardar essa história: a cópia errada
-// sobreviveu justamente porque o caso onde ela erra é inalcançável hoje, e não porque alguém a conferiu.
-//
-// Módulo FOLHA de propósito: zero dependências, nem de estado. `n` é parâmetro, nunca `numPlayers` global —
-// é isso que deixa a conta testável e que permite o render, o layout e o HUD importarem daqui sem que um
-// passe a depender do outro.
+// A LEAF module on purpose: no dependencies, not even on state. `n` is a parameter, never a global `numPlayers` —
+// that is what makes the sum testable and lets render, layout and HUD import it without depending on each other.
 /**
- * A grade para `n` jogadores: 1 -> 1x1 · 2 -> 2x1 · 3 e 4 -> 2x2.
- * `n` menor que 1 devolve a grade de uma tela, e não zero colunas.
+ * The grid for `n` players: 1 -> 1x1 · 2 -> 2x1 · 3 and 4 -> 2x2.
+ * `n` below 1 gives the grid of one screen, not zero columns.
  */
 export function screenGrid(n) {
     return { cols: n <= 1 ? 1 : (n <= 2 ? n : 2), rows: n <= 2 ? 1 : 2 };
 }
-/** Dimensões em pixels de arte da grade de `n` telas (320x180 por tela — o pixel canônico do ADR-0010). */
+/** Size in art pixels of the grid of `n` screens (320x180 per screen — the canonical pixel of ADR-0010). */
 export function screenBaseSize(n) {
     const { cols, rows } = screenGrid(n);
     return { w: 320 * cols, h: 180 * rows };

package/dist-pkg/core/setting-defaults.d.ts

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { CameraControl } from './camera-cycle.js';
+/**
+ * The browser's media-query question, as the composition root passes it (`win.matchMedia`). Only `matches` is read.
+ * A test passes a double; nothing here reaches `window`.
+ */
+export type MediaQuery = (query: string) => {
+    readonly matches: boolean;
+};
+/**
+ * The REDUCED MOTION default is not a constant — it is what the operating system asks for, asked NOW and not at boot.
+ *
+ * It lives beside `DEFAULTS` because ADR-0029's rule is ONE source for what a default is, and a computed default is no less
+ * a default for not fitting a frozen object. Its readers are the help slides, the scene flags when nothing is stored, and the
+ * motion panel's mark and «restore defaults».
+ *
+ * Why the reset must read this and not `false`: on a machine whose owner asked for less motion, `false` would TURN THE
+ * ANIMATION BACK ON — the reset would do, by itself, exactly what WCAG 2.3.3 exists to prevent, on the screen of someone who
+ * already said they cannot take it.
+ *
+ * 📌 THE QUESTION ARRIVES AS A PARAMETER (ADR-0232): whoever calls passes `matchMedia`; the query itself stays here, once.
+ */
+export declare function defaultReducedMotion(matchMedia: MediaQuery): boolean;
+/**
+ * THE DEFAULTS, named. One value per line, each used in TWO places: the boot's read (when nothing is stored) and the
+ * "restore defaults" of the panel that holds it (ADR-0028).
+ *
+ * The alternative is writing each default twice — once in the stored read, once in the reset — and two copies nobody
+ * forces to agree diverge. Here the divergence would be worse than elsewhere: a reset that restores a value DIFFERENT
+ * from what the game uses when nothing was set leaves the child in a third state, neither theirs nor the factory's, that
+ * they have no name for when asking for help.
+ *
+ * `as const` + `Object.freeze` on purpose: a default someone can write at run time stops being a default.
+ */
+export declare const DEFAULTS: Readonly<{
+    readonly blindMode: false;
+    readonly caneBlockDiv: 1;
+    readonly captionsOn: true;
+    readonly menuIndexOn: true;
+    readonly wheelchair: false;
+    readonly oneButton: false;
+    readonly inputCooldown: 0;
+    readonly switchScan: false;
+    readonly voiceControl: false;
+    readonly gameSpeed: 1;
+    readonly captionPpm: 125;
+    readonly speechPpm: 254;
+    readonly noGripStrength: false;
+    readonly cameraControl: CameraControl;
+    readonly easy: false;
+    readonly toggleMove: false;
+    readonly toggleRun: false;
+    readonly cbSafe: false;
+    readonly ownerColors: true;
+    readonly lq: 0;
+    readonly hcOutlineFg: 1;
+    readonly hcOutlineBg: 1;
+    readonly letterCase: "upper";
+    readonly calmMode: 0;
+    readonly viz: "normal";
+}>;

package/dist-pkg/core/setting-defaults.js

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * The REDUCED MOTION default is not a constant — it is what the operating system asks for, asked NOW and not at boot.
+ *
+ * It lives beside `DEFAULTS` because ADR-0029's rule is ONE source for what a default is, and a computed default is no less
+ * a default for not fitting a frozen object. Its readers are the help slides, the scene flags when nothing is stored, and the
+ * motion panel's mark and «restore defaults».
+ *
+ * Why the reset must read this and not `false`: on a machine whose owner asked for less motion, `false` would TURN THE
+ * ANIMATION BACK ON — the reset would do, by itself, exactly what WCAG 2.3.3 exists to prevent, on the screen of someone who
+ * already said they cannot take it.
+ *
+ * 📌 THE QUESTION ARRIVES AS A PARAMETER (ADR-0232): whoever calls passes `matchMedia`; the query itself stays here, once.
+ */
+export function defaultReducedMotion(matchMedia) {
+    return matchMedia('(prefers-reduced-motion: reduce)').matches;
+}
+/**
+ * THE DEFAULTS, named. One value per line, each used in TWO places: the boot's read (when nothing is stored) and the
+ * "restore defaults" of the panel that holds it (ADR-0028).
+ *
+ * The alternative is writing each default twice — once in the stored read, once in the reset — and two copies nobody
+ * forces to agree diverge. Here the divergence would be worse than elsewhere: a reset that restores a value DIFFERENT
+ * from what the game uses when nothing was set leaves the child in a third state, neither theirs nor the factory's, that
+ * they have no name for when asking for help.
+ *
+ * `as const` + `Object.freeze` on purpose: a default someone can write at run time stops being a default.
+ */
+export const DEFAULTS = Object.freeze({
+    // hearing
+    blindMode: false,
+    caneBlockDiv: 1,
+    captionsOn: true,
+    menuIndexOn: true, // the index is born ON: whoever does not know it exists is whoever needs it most
+    // motor
+    wheelchair: false,
+    oneButton: false,
+    inputCooldown: 0,
+    switchScan: false,
+    voiceControl: false,
+    gameSpeed: 1,
+    captionPpm: 125,
+    speechPpm: 254, // the voice's normal speed, the minimum (ADR-0196)
+    noGripStrength: false,
+    cameraControl: 'off',
+    easy: false, // per player (Easy mode)
+    toggleMove: false, // per player (movement by toggling)
+    // The run-button toggle is born off at the FACTORY — and switches itself on with the on-screen pad, which is context,
+    // not choice. The difference matters to ADR-0029's mark, which marks the stored CHOICE and not the state.
+    toggleRun: false, // per player (run-button toggle)
+    // visual
+    cbSafe: false,
+    ownerColors: true,
+    lq: 0, // the L→Q contrast boost, off
+    hcOutlineFg: 1,
+    hcOutlineBg: 1,
+    // communication (the letter case today; the AAC panel of ADR-0028 widens this)
+    letterCase: 'upper',
+    // ⚠️ THE LAST TWO are here because they were missing and it had a cost (issue #61): ADR-0029's mark reads `DEFAULTS`
+    // and nothing else, so a value with no named default here is one the mark CANNOT mark.
+    //   · `calmMode` — the autism-support level (0 normal · 1 calm · 2 quiet).
+    //   · `viz` — the vision mode. `'normal'` is the mode that does nothing, now said instead of deduced from an empty
+    //     string that happened to match no mode.
+    calmMode: 0,
+    viz: 'normal',
+});

package/dist-pkg/core/speech-rate.d.ts

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * THE SPEECH RATE (ADR-0183 §1, ADR-0196; issue #179): the child's words per minute, 254 to 504 by 50 — «velocidade normal é a
+ * mínima» (the Dev): no voice is played slower than it speaks — mapped onto each engine by MEASURING
+ * the voice rather than assuming it — the record: «the mapping needs each voice's words per minute at rate 1, measured, not
+ * assumed.» Measured in the lab on 2026-09-14, a neural voice spoke 255 words per minute of speech; another voice or
+ * sentence differs, so every synthesised utterance is measured (its words over its speech time) and played at the ratio.
+ *
+ * Pure: no I/O, no audio — the engine hands in the samples it synthesised.
+ */
+export declare const SPEECH_RATES: readonly [254, 304, 354, 404, 454, 504];
+export type SpeechRate = (typeof SPEECH_RATES)[number];
+/** The playback-rate bounds: never under the voice's own speed (ADR-0196), and a measurement error never garbles it. */
+export declare const MIN_PLAYBACK_RATE = 1;
+export declare const MAX_PLAYBACK_RATE = 3;
+/** A stored or passed rate that is not a step — the old 150…500 by 35 among them — reads as the normal speed, the first step. */
+export declare function isSpeechRate(ppm: number): SpeechRate;
+/** The words a voice says: tokens holding a letter; a dash, a number or a sign alone is not counted. */
+export declare function spokenWords(text: string): number;
+/** Seconds from the first to the last sample above the silence threshold — the pauses inside stay, the silent ends go. */
+export declare function speechSeconds(samples: ArrayLike<number>, sampleRate: number, silenceThreshold?: number): number;
+/**
+ * The rate to play an utterance at, and the voice's words per minute measured on it (`null` when it was too short to measure).
+ * Too short, it takes the voice's running average; with none yet, it plays as synthesised.
+ */
+export declare function speechPlaybackRate(words: number, seconds: number, ppm: number, voiceAverage: number | null): {
+    readonly rate: number;
+    readonly voiceWpm: number | null;
+};

package/dist-pkg/core/speech-rate.js

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * THE SPEECH RATE (ADR-0183 §1, ADR-0196; issue #179): the child's words per minute, 254 to 504 by 50 — «velocidade normal é a
+ * mínima» (the Dev): no voice is played slower than it speaks — mapped onto each engine by MEASURING
+ * the voice rather than assuming it — the record: «the mapping needs each voice's words per minute at rate 1, measured, not
+ * assumed.» Measured in the lab on 2026-09-14, a neural voice spoke 255 words per minute of speech; another voice or
+ * sentence differs, so every synthesised utterance is measured (its words over its speech time) and played at the ratio.
+ *
+ * Pure: no I/O, no audio — the engine hands in the samples it synthesised.
+ */
+export const SPEECH_RATES = [254, 304, 354, 404, 454, 504];
+/** The playback-rate bounds: never under the voice's own speed (ADR-0196), and a measurement error never garbles it. */
+export const MIN_PLAYBACK_RATE = 1;
+export const MAX_PLAYBACK_RATE = 3;
+/** Below this an utterance is too short to measure («Voltar»): its silent ends and one stressed syllable dominate. */
+const WORDS_TO_MEASURE = 3;
+const SECONDS_TO_MEASURE = 0.8;
+/** A stored or passed rate that is not a step — the old 150…500 by 35 among them — reads as the normal speed, the first step. */
+export function isSpeechRate(ppm) {
+    return SPEECH_RATES.includes(ppm) ? ppm : SPEECH_RATES[0];
+}
+/** The words a voice says: tokens holding a letter; a dash, a number or a sign alone is not counted. */
+export function spokenWords(text) {
+    return text.split(/\s+/).filter((w) => /\p{L}/u.test(w)).length;
+}
+/** Seconds from the first to the last sample above the silence threshold — the pauses inside stay, the silent ends go. */
+export function speechSeconds(samples, sampleRate, silenceThreshold = 0.01) {
+    let a = 0, b = samples.length - 1;
+    while (a <= b && Math.abs(samples[a]) < silenceThreshold)
+        a++;
+    while (b >= a && Math.abs(samples[b]) < silenceThreshold)
+        b--;
+    return b >= a ? (b - a + 1) / sampleRate : 0;
+}
+/**
+ * The rate to play an utterance at, and the voice's words per minute measured on it (`null` when it was too short to measure).
+ * Too short, it takes the voice's running average; with none yet, it plays as synthesised.
+ */
+export function speechPlaybackRate(words, seconds, ppm, voiceAverage) {
+    const target = isSpeechRate(ppm);
+    const clampInside = (x) => Math.min(MAX_PLAYBACK_RATE, Math.max(MIN_PLAYBACK_RATE, +x.toFixed(6)));
+    if (words >= WORDS_TO_MEASURE && seconds >= SECONDS_TO_MEASURE) {
+        const measuredWpm = (words / seconds) * 60;
+        return { rate: clampInside(target / measuredWpm), voiceWpm: measuredWpm };
+    }
+    return { rate: voiceAverage ? clampInside(target / voiceAverage) : 1, voiceWpm: null };
+}

package/dist-pkg/core/state.d.ts

@@ -1,35 +1,40 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
+import { type CameraControl } from './camera-cycle.js';
+/** The port the settings are read and written through. `platform/storage` has this shape; a test passes a double. */
+export interface StatePort {
+    get(key: string, fallback: string | null): string | null;
+    set(key: string, value: string | number | boolean): unknown;
+    getBool(key: string, fallback?: boolean): boolean;
+    setBool(key: string, on: boolean): unknown;
+    getNum(key: string, fallback?: number): number;
+    readonly KEYS: {
+        readonly letterCase: string;
+        readonly captions: string;
+        readonly menuIndex: string;
+        readonly cbsafe: string;
+        readonly ownercolors: string;
+        readonly outfg: string;
+        readonly outbg: string;
+    };
+}
 /**
- * ========================= O BARRAMENTO, TIPADO (Fase C do plano) =========================
- *
- * Era `emit(evt: string, val: unknown)`. Duas coisas erradas numa assinatura só:
- *
- *   · O NOME ERA `string`. Um `emit('viz', …)` em vez de `'vizMode'` não é erro em lugar nenhum — é
- *     SILÊNCIO. O assinante certo nunca é chamado, nada fica vermelho, e a única pista é um painel que
- *     parou de se atualizar. Hoje são dezessete pontos de emissão e cada nome aparece UMA vez; a chance de
- *     digitar errado é exatamente a chance de escrever a próxima linha.
- *   · A CARGA ERA `unknown`. Quem assinasse tinha de converter, e a conversão é onde a mentira entra.
+ * ========================= THE BUS, TYPED =========================
  *
- * Agora `EventoDoJogo` é um mapa nome → carga, e `emit`/`on` são genéricos sobre ele. Nome inexistente não
- * compila; carga errada não compila.
+ * It was `emit(evt: string, val: unknown)`, two wrongs in one signature:
  *
- * ✅ ERRATA 2026-09-08: O BARRAMENTO TEM ASSINANTES EM PRODUÇÃO. O parágrafo abaixo dizia «ZERO `on()` em
- * produção (só o teste assina)», e isso deixou de ser verdade no dia em que a engine passou a montar a barra
- * de acessibilidade: o `ui/settings-audio` assina `modoCego` para o botão `#opt-modocego` não mentir o
- * estado, e o `boot/create-game` assina o mesmo evento para a barra montada não mentir o dela. Os dois
- * chegaram pela razão que o parágrafo previa — «painéis que se redesenham quando a criança muda um ajuste» —
- * e chegaram com o contrato já tipado, que era o ponto de ele nascer assim.
+ *   · THE NAME WAS A `string`. An `emit('viz', …)` instead of `'vizMode'` is an error nowhere — it is SILENCE. The right
+ *     subscriber is never called, nothing goes red, and the only clue is a panel that stopped updating.
+ *   · THE PAYLOAD WAS `unknown`. A subscriber had to cast, and the cast is where the lie gets in.
  *
- * ⚠️ POR QUE ISTO EXISTIU ANTES DE TER ASSINANTE. Hoje o barramento tem ZERO `on()` em produção (só o teste
- * assina). Um mecanismo sem uso normalmente é dívida — mas este precisa nascer tipado, não ser retipado
- * depois: o ADR-0031 já exige que painéis e atividades se redesenhem quando a criança muda idioma ou fonte,
- * e a casca do `demos` vai reagir a ajuste durante a partida. O primeiro assinante chega com o contrato
- * pronto, em vez de chegar e ser seguido por uma migração.
+ * Now `GameEvent` maps name → payload and `emit`/`on` are generic over it: an unknown name does not compile, a wrong
+ * payload does not compile. It was typed before it had subscribers on purpose — ADR-0031 already required panels to
+ * redraw when the child changes a setting, and the first subscribers (the bar and the audio panel, which must not lie
+ * about blind mode) arrived with the contract already typed instead of being followed by a migration.
  */
-export interface EventoDoJogo {
+export interface GameEvent {
     numPlayers: number;
     vizMode: string;
-    modoCego: boolean;
+    blindMode: boolean;
     letterCase: LetterCase;
     captionsOn: boolean;
     menuIndexOn: boolean;
@@ -40,108 +45,103 @@ export interface EventoDoJogo {
     caneBlockDiv: number;
     wheelchair: boolean;
     oneButton: boolean;
+    /** The wait after an accepted key, in milliseconds (ADR-0217); 0 is off, which is how it leaves the factory. */
+    inputCooldown: number;
+    /** Playing with ONE button: the machine offers each position and any press takes the one showing (ADR-0218). */
+    switchScan: boolean;
+    /** Playing by SPEAKING: the child says a word of the game and the position it names is pressed (ADR-0189, issue #184). */
+    voiceControl: boolean;
+    /** The game speed, a step of `core/game-speed` (ADR-0180): 1 is 100%. */
+    gameSpeed: number;
+    /** The child's caption reading rate, words a minute (ADR-0183 §4): 125, 145 or 175. */
+    captionPpm: number;
+    /** The child's speech rate, words a minute (ADR-0183 §1, ADR-0196): 254 to 504 by 50. */
+    speechPpm: number;
+    /** The «no strength to hold» empathy simulation (ADR-0181): a held game key reads as one tap. */
+    noGripStrength: boolean;
+    /** Playing through the webcam (ADR-0215): off, hands, face or eyes — one mode at a time, each with its lines. */
+    cameraControl: CameraControl;
 }
-type Ouvinte<K extends keyof EventoDoJogo> = (val: EventoDoJogo[K]) => void;
-/** Assina `evt`. Devolve a função que cancela — guardar o retorno é mais barato que lembrar do `off`. */
-export declare function on<K extends keyof EventoDoJogo>(evt: K, fn: Ouvinte<K>): () => void;
-export declare function off<K extends keyof EventoDoJogo>(evt: K, fn: Ouvinte<K>): void;
+type Listener<K extends keyof GameEvent> = (val: GameEvent[K]) => void;
 /**
- * Avisa os assinantes de `evt`. EXPORTADO desde 2026-08-25 (item 19) porque `game/state` emite pelos mesmos
- * canais: um segundo mapa de assinantes seria um segundo barramento, e quem assinasse `coins` no lugar errado
- * simplesmente não seria avisado — sem erro, sem teste vermelho.
- *
- * O `try` em volta de cada assinante NÃO é preguiça: um ouvinte que estoura não pode impedir os outros de
- * receber. Um painel quebrado derruba o painel; não derruba o jogo.
+ * A gate tile: a gate is a LIST of these, not one object with a position. A STRUCTURAL minimum — `core/` does not
+ * import a game's types, and a game's richer tile is assignable to this.
  */
-export declare function emit<K extends keyof EventoDoJogo>(evt: K, val: EventoDoJogo[K]): void;
-export declare let vizMode: string;
-export declare function initVizMode(mode: string): void;
-export declare function setVizModeValue(mode: string): void;
+export interface GateTile {
+    readonly tx: number;
+    readonly ty: number;
+}
 /**
- * OS PADRÕES, com nome. Um valor por linha, e cada um usado em DOIS lugares: a leitura do boot (quando não há
- * nada gravado) e o "restaurar padrões" do menu que o contém (ADR-0028).
- *
- * Existe porque a alternativa é escrever o mesmo padrão duas vezes — uma no `store.getBool(chave, X)` e outra
- * no reset — e este repositório já mostrou quatro vezes o que acontece com duas cópias que ninguém obriga a
- * concordar. Aqui a divergência seria pior que as anteriores: um reset que restaura um valor DIFERENTE do que
- * o jogo usa quando nunca foi configurado deixa a criança num terceiro estado, que não é nem o dela nem o de
- * fábrica, e que ela não tem como nomear para pedir ajuda.
- *
- * `as const` + `Object.freeze` de propósito: um padrão que alguém consiga escrever em tempo de execução deixa
- * de ser padrão.
+ * letterCase: letters show in UPPER CASE or in their natural case. A stored 'lower' reads as 'mixed': the Dev asked for two
+ * options, upper and lower case together or upper case only (see the store's `letterCase`).
  */
+export type LetterCase = 'mixed' | 'upper';
+/** Outline thickness: 0 none · 1 thin · 2 thick. Out of range saturates, it is not rejected. */
+export type OutlineLevel = 0 | 1 | 2;
 /**
- * O padrão do MOVIMENTO REDUZIDO não é uma constante — é o que o sistema operacional pede.
+ * A root's settings store: every read is a LIVE getter (it answers the value of now, not of when it was taken), every write
+ * a setter that does three things and only three — stores, persists, tells.
  *
- * Mora aqui, ao lado do DEFAULTS, porque a regra do ADR-0029 é que existe UMA fonte sobre o que é padrão, e
- * um padrão calculado não deixa de ser padrão por não caber num objeto congelado. Quem lê isto: a carga do
- * boot (main.js) e o "restaurar padrões" do menu de sensibilidade visual.
- *
- * Por que importa que o reset leia isto em vez de `false`: numa máquina cujo dono pediu menos movimento,
- * devolver `false` RELIGARIA a animação — o reset passaria a fazer, sozinho, exatamente o que a WCAG 2.3.3
- * existe para impedir, e faria isso na tela de quem já tinha dito que não aguenta.
- *
- * `matchMedia` é guardado: este módulo roda no projeto `node` dos testes, onde `window` não existe.
+ * ⚠️ DESTRUCTURING A READ FREEZES IT: `const { blindMode } = store` copies the value of that moment. Read `store.blindMode`.
+ * The setters and the bus hold no `this`, so they can be taken apart (`const { on, emit } = store`).
  */
-export declare function defaultReducedMotion(): boolean;
-export declare const DEFAULTS: Readonly<{
-    readonly modoCego: false;
-    readonly caneBlockDiv: 1;
-    readonly captionsOn: true;
-    readonly menuIndexOn: true;
-    readonly wheelchair: false;
-    readonly oneButton: false;
-    readonly easy: false;
-    readonly toggleMove: false;
-    readonly toggleRun: false;
-    readonly cbSafe: false;
-    readonly ownerColors: true;
-    readonly lq: 0;
-    readonly hcOutlineFg: 1;
-    readonly hcOutlineBg: 1;
-    readonly letterCase: "upper";
-    readonly calmMode: 0;
-    readonly viz: "normal";
-}>;
-export declare let modoCego: boolean;
-export declare function setModoCegoValue(on: boolean): void;
+export interface SettingsStore {
+    /** The active visual/colour mode (stored in incl_viz by its setter; `initVizMode` does not store). */
+    readonly vizMode: string;
+    readonly blindMode: boolean;
+    readonly letterCase: LetterCase;
+    readonly captionsOn: boolean;
+    readonly menuIndexOn: boolean;
+    readonly cbSafe: boolean;
+    readonly ownerColors: boolean;
+    readonly hcOutlineFg: OutlineLevel;
+    readonly hcOutlineBg: OutlineLevel;
+    readonly caneBlockDiv: number;
+    readonly wheelchair: boolean;
+    readonly oneButton: boolean;
+    readonly noGripStrength: boolean;
+    readonly inputCooldown: number;
+    readonly switchScan: boolean;
+    readonly voiceControl: boolean;
+    readonly cameraControl: CameraControl;
+    readonly gameSpeed: number;
+    readonly captionPpm: number;
+    readonly speechPpm: number;
+    /** Sets the visual mode WITHOUT storing it: a default taken from the media query must follow the OS at every boot. */
+    initVizMode(mode: string): void;
+    setVizModeValue(mode: string): void;
+    setBlindModeValue(on: boolean): void;
+    setLetterCaseValue(c: LetterCase): void;
+    setCaptionsOnValue(on: boolean): void;
+    setMenuIndexOnValue(on: boolean): void;
+    setCbSafeValue(on: boolean): void;
+    setOwnerColorsValue(on: boolean): void;
+    setOutlineFgValue(v: number): void;
+    setOutlineBgValue(v: number): void;
+    setCaneBlockDivValue(div: number): void;
+    setWheelchairValue(on: boolean): void;
+    setOneButtonValue(on: boolean): void;
+    setNoGripStrengthValue(on: boolean): void;
+    setInputCooldownValue(ms: number): void;
+    setSwitchScanValue(on: boolean): void;
+    setVoiceControlValue(on: boolean): void;
+    setCameraControlValue(v: CameraControl): void;
+    setGameSpeedValue(v: number): void;
+    setCaptionPpmValue(ppm: number): void;
+    setSpeechPpmValue(ppm: number): void;
+    /** Subscribes to `evt`. Returns the function that cancels — keeping the return is cheaper than remembering `off`. */
+    on<K extends keyof GameEvent>(evt: K, fn: Listener<K>): () => void;
+    off<K extends keyof GameEvent>(evt: K, fn: Listener<K>): void;
+    /**
+     * Tells the subscribers of `evt`. PUBLIC because a game emits on the same channels: a second map of subscribers would be a
+     * second bus, and whoever subscribed in the wrong one would simply never be told — no error, no red test.
+     */
+    emit<K extends keyof GameEvent>(evt: K, val: GameEvent[K]): void;
+}
 /**
- * Um tile do portão. O portão é uma LISTA deles, não um objeto com posição — escrevi `{x, y}` na primeira
- * versão e o navegador me desmentiu: `gate` é `[{tx:29,ty:36}, {tx:30,ty:36}, …]`.
- *
- * O `tsc` não podia pegar. Quem chama `setLevelExtras` é o `main.js`, que é JavaScript, então o tipo declarado
- * aqui não tinha do outro lado nada que o contradissesse. É um argumento concreto para o `createGame()` do
- * passo 4 nascer em TypeScript: enquanto o composition root for JS, todo contrato que só ele exercita é uma
- * afirmação sem verificador.
- *
- * Mínimo ESTRUTURAL, como o `PlayerQuiz`: o `MapGateTile` de verdade mora em `game/level-geometry` e é
- * atribuível a este. `core/` não importa de `game/`.
+ * Builds a settings store over `port`, READING THE CHILD'S STORED SETTINGS FIRST (ADR-0178): the composition root builds it
+ * before anything reads or writes a setting, so no write can put a default over what the child saved. The port is
+ * REQUIRED — an optional one falling back to a shared store would be the singleton again (ADR-0232, erratum D2b).
  */
-export interface GateTile {
-    readonly tx: number;
-    readonly ty: number;
-}
-export type LetterCase = 'mixed' | 'upper';
-export declare let letterCase: LetterCase;
-export declare function setLetterCaseValue(c: LetterCase): void;
-export declare let captionsOn: boolean;
-export declare function setCaptionsOnValue(on: boolean): void;
-export declare let menuIndexOn: boolean;
-export declare function setMenuIndexOnValue(on: boolean): void;
-export declare let cbSafe: boolean;
-export declare function setCbSafeValue(on: boolean): void;
-export declare let ownerColors: boolean;
-export declare function setOwnerColorsValue(on: boolean): void;
-/** Espessura de contorno: 0 nenhum · 1 fino · 2 grosso. Fora da faixa satura, não rejeita. */
-export type OutlineLevel = 0 | 1 | 2;
-export declare let hcOutlineFg: OutlineLevel;
-export declare function setOutlineFgValue(v: number): void;
-export declare let hcOutlineBg: OutlineLevel;
-export declare function setOutlineBgValue(v: number): void;
-export declare let caneBlockDiv: number;
-export declare function setCaneBlockDivValue(div: number): void;
-export declare let wheelchair: boolean;
-export declare function setWheelchairValue(on: boolean): void;
-export declare let oneButton: boolean;
-export declare function setOneButtonValue(on: boolean): void;
+export declare function createSettingsStore(port: StatePort): SettingsStore;
 export {};