@the-inclusionist/engine 10.0.0 → 11.0.0

package/dist-pkg/boot/create-game.js

@@ -22,11 +22,10 @@
 //
 // And one finding that only appeared when this function tried to boot against an injected document:
 //
-//  · FINDING 15 — `initI18n()` called `applyDom(document)`, the GLOBAL, underneath whoever called it. In a browser
-//    it makes no difference, which is how it survived; in a pure-logic test it is the difference between booting and
-//    not, and with two documents (an engine in an iframe, an editor beside the game) it would be the difference
-//    between translating the right document and the other one. Hence `initI18n(root)`, with the global as default,
-//    exactly as `applyDom` already did.
+//  · FINDING 15 — the language's boot called `applyDom(document)`, the GLOBAL, underneath whoever called it. In a
+//    browser it makes no difference, which is how it survived; in a pure-logic test it is the difference between booting
+//    and not, and with two documents (an engine in an iframe, an editor beside the game) it would be the difference
+//    between translating the right document and the other one. Hence `translator.init(root)`: the document comes in.
 //
 // ========================= DECLINING IS NOT LYING =========================
 // The quiz declined the sonar and the pad instead of inventing tiles and a fake collision box, and that distinction
@@ -44,7 +43,7 @@
 // game with a title screen. What it covers is what is the SAME in every game: language, screen reader, mixer, voice,
 // the dialog stack, the colour filters, the remappable keyboard, menu navigation, the pause card and the accessibility
 // bar, the settings panels, the navigation sonar, and every input transport.
-import i18nObject, { initI18n, loadLocale, createTranslator } from '../core/i18n.js';
+import { createTranslator, availableLocales } from '../core/i18n.js';
 import { localeHostHooks, exposeI18n } from '../platform/locale-host.js';
 import { createInputState } from '../input/state.js';
 import { initTouch, mountTouchControls, touchGaps } from '../input/touch.js';
@@ -58,20 +57,22 @@ import { accommodationAnswersProblems, subjectWord } from '../core/accommodation
 import { genreProblems, genreWarning } from '../core/genres.js';
 import { cartridgeProblems } from '../core/cartridge-problems.js';
 import { contractSubjects } from '../core/accommodation-subjects.js';
-import { presetActions, startClaimProblem, selectClaimProblem, labellerFrom, shortLabellerFrom, ACTIONS } from '../core/actions.js';
+import { presetActions, startClaimProblem, selectClaimProblem, labellerFrom, shortLabellerFrom, wordsOf, ACTIONS } from '../core/actions.js';
 import { createAnnouncer } from '../core/a11y-sr.js';
 import { createEyeControl, videoFeed } from '../ui/eye-control.js';
 import { createFaceControl } from '../ui/face-control.js';
 import { createHandControl } from '../ui/hand-control.js';
 import { checkedCacheHas, sha256With } from '../platform/heavy.js';
-import { createBundleLoader } from '../platform/vosk-runtime.js';
+import { createBundleLoader, keepVoskModels, loadVoskRuntime } from '../platform/vosk-runtime.js';
+import { createVoiceChooser, openWithCommandRecogniser } from '../platform/choose-by-voice.js';
 import { followCameraMode } from '../ui/camera-control.js';
 import { initPauseIcons, wireBarCaption, showPauseOptions } from '../ui/pause-icons.js';
 // 📌 The bar's markup is a pure string builder and lives with the rest of the pause markup (ADR-0221, issue #203); what this
 // root asks `ui/pause-icons` for is the WIRING — the icons this game can actually act on, and the reflection of their state.
 import { iconsMarkup } from '../ui/pause-markup.js';
 import { accessibleLabel } from '../core/accessible-label.js';
-import { helpRows, mountSlides, showSlide, animateFigure, howToPlayProblems } from '../ui/help-panel.js';
+import { helpRows, mountSlides, showSlide, animateFigure, howToPlayProblems, playSlidesOf } from '../ui/help-panel.js';
+import { missingDeclaredKeys } from '../ui/declared-words.js';
 import { initSettingsControls } from '../ui/settings-controls.js';
 import { keyName } from '../ui/control-choices.js';
 import { reserveTopBand } from '../ui/top-band.js';
@@ -79,7 +80,9 @@ import { reserveTopBand } from '../ui/top-band.js';
 import { createSettingsStore } from '../core/state.js';
 import { DEFAULTS, defaultReducedMotion } from '../core/setting-defaults.js';
 import { CAMERA_CONTROLS } from '../core/camera-cycle.js';
-import { createLibras } from '../ui/vlibras.js';
+import { createDeafMode } from '../ui/vlibras.js';
+import { createLibrasAvatarInterpreter } from '../ui/libras-avatar-player.js';
+import { screenText, unreadableWorldProblems, menuSonarPress } from '../ui/screen-text.js';
 import { conformanceProblems } from '../core/contract.js';
 import { createSceneStack } from '../core/scenes.js';
 import { createTts } from '../platform/tts.js';
@@ -88,11 +91,12 @@ import { createAudio } from '../platform/audio.js';
 import { createAudioSonar } from '../platform/audio-sonar.js';
 // The root is the layer that MAY know both axes: `render/` is below it, and it is the root's job to answer
 // `platform/audio-sonar`, which cannot import from here without inverting an edge (#104).
-import { isBlind, isLowVision, DEFAULT_VISUAL, filterKey, simulationUnavailable } from '../render/viz-axes.js';
+import { isBlind, isLowVision, hasHighContrast, onlyColourVision, DEFAULT_VISUAL, filterKey, simulationUnavailable } from '../render/viz-axes.js';
 // 📌 The mode → `url(#...)` table, which `render/cvd-matrices` installs and the `consumer-quiz` consumes.
 import { VIZ_FILTER } from '../render/viz-modes.js';
 import { createPadWizard, createPadMaps } from '../input/pad-wizard.js';
-import { typographyCycle, CYCLE_START, FONT_BY_KEY } from '../ui/fonts.js';
+import { typographyCycle, CYCLE_START, FONT_BY_KEY, ENGINE_FAMILIES } from '../ui/fonts.js';
+import { declaredFamilies, startLibraryFonts } from '../platform/font-library.js';
 // 📏 The drawing reporters (`barIntruders`, `belowFloor`, `minimumTarget` and their types) live in `ui/drawing-problems`
 // (ADR-0221, issue #203), and the root does not know them. An import that can be deleted is coupling that no longer
 // exists, and that is how this debt is paid: by subject.
@@ -105,18 +109,22 @@ import { LOGICAL_W } from '../core/constants.js';
 import { captionDuration, CAPTION_RATES } from '../core/caption-duration.js';
 import { initSettingsPanel } from '../ui/settings-panel.js';
 import { mountPanel } from '../ui/mount-panel.js';
-// 📌 No `latchRefusal` or `setMoveLatch` here: the sticky keys are written by the bar's ☝️, which already resolves both
-// the device's refusal and the two stored keys.
+// 📌 No `setMoveLatch` here: the sticky keys are written by the bar's ☝️, which already writes both stored keys. What the root
+// does is RESOLVE the latch when any transport presses (ADR-0109 rule 3, ADR-0249) — `createLatchedEdge`, below.
+import { createLatchedEdge } from '../input/latch-edge.js';
 import { stampSource, sourceOfEvent } from '../input/synthetic-source.js';
 import { createVirtualController } from '../input/virtual-controller.js';
-import { createSwitchScan, SWITCH_SCAN_DEFAULTS } from '../input/switch-scan.js';
+import { keyGoesToGame, keyPressesOwnControl, keyTypedIntoField } from '../input/key-default.js';
+import { createSwitchScan, playScanList, SWITCH_SCAN_DEFAULTS } from '../input/switch-scan.js';
+import { menuScanFor, menuStepKeys } from '../ui/menu-intent.js';
 import { mountScanOverlay, scanItemText } from '../ui/scan-overlay.js';
 import { createVoiceControl } from '../ui/voice-control.js';
-import { mountSteps, updateSteps, nextStep, controlRow, labelRow } from '../ui/panel-widgets.js';
+import { mountSteps, updateSteps, nextStep, controlRow, labelRow, mountChoice } from '../ui/panel-widgets.js';
 import { PERSONAS_DO_PAD, closestPersona } from '../input/touch.js';
 import { initSettingsTypo } from '../ui/settings-typo.js';
 import { initSettingsMotion } from '../ui/settings-motion.js';
-import { readStoredScene, storeScene } from '../ui/motion-scene.js';
+import { readStoredScene, storeScene, SCENE_KEYS } from '../ui/motion-scene.js';
+import { watchFooterScroll } from '../ui/footer-scroll-driver.js';
 import { initSettingsVisual } from '../ui/settings-visual.js';
 import { initSettingsEmpathy } from '../ui/settings-empathy.js';
 import { HC_ROLE_DEF } from '../render/hc-role-data.js';
@@ -129,6 +137,8 @@ import { createEmpathyFilter } from '../input/empathy-filter.js';
 import { createInputCooldown, COOLDOWN_MS } from '../input/input-cooldown.js';
 import { markChanged } from '../ui/changed-mark.js';
 import { mountHudBands, hudNumbersProblems } from '../ui/hud-bands.js';
+import { mountSessionClock } from '../ui/session-clock.js';
+import { mountHudRow, reserveBottomBand, followThePad } from '../ui/hud-row.js';
 import { gameOptionsProblems, drawGameOptions } from '../ui/game-options.js';
 import { createStorage, keysOutsideScopes } from '../platform/storage.js';
 import { KEYS } from '../platform/storage-keys.js';
@@ -142,7 +152,7 @@ import { showOnlyRowsThatApply } from '../ui/audio-rows-that-apply.js';
 import { initKeyboardRuntime } from '../input/keyboard-runtime.js';
 import { createKeyboardConfig } from '../input/keyboard.js';
 import { createPadTable } from '../input/pad-defaults.js';
-import { downloadHeavy, heavyAtBoot } from '../platform/heavy.js';
+import { downloadHeavy, heavyAtBoot, deliveryPath } from '../platform/heavy.js';
 import { installCvdFilters } from '../render/cvd-matrices.js';
 /**
  * The backend the host lent, else its window's `localStorage` — or `null` where the window has none or reading it throws
@@ -158,6 +168,13 @@ function hostStorage(host) {
         return null;
     }
 }
+/**
+ * The interpreter the host lent — it always wins — else the one the DELIVERY carries (`delivered`, built only when needed): the
+ * free Libras player where the delivery was built with `--libras`, which answers as `NO_INTERPRETER` where it was not.
+ */
+function hostInterpreter(host, delivered) {
+    return host.interpreter ?? delivered();
+}
 /*
  * ONE SENTENCE FOR BOTH REFUSALS.
  *
@@ -168,56 +185,39 @@ function hostStorage(host) {
 function refuseDeclaration(who, problemas) {
     throw new Error(`${who}: declaração malformada — ${problemas.join('; ')}`);
 }
-/*
- * «start» BELONGS TO THE PAUSE, AND A CARTRIDGE DOES NOT TAKE IT (ADR-0144 §4).
+/**
+ * EVERY LINE `createGame` AND `mount()` REFUSE A CARTRIDGE WITH — one list, read by the boot, by `mount()` and by the
+ * cartridge checker the engine ships (`inclusionist-check-cartridge`, ADR-0253). EMPTY means the cartridge holds.
  *
- * ⚠️ THE SENTENCE LIVES IN `core/actions`, not here, for two reasons that point the same way: that is where the
- * validity of an `ActionPreset` lives, and that is where the raw-prose ledger already answers for messages read by
- * whoever WRITES a preset. A new sentence in this module would raise its cap to pay for text that belongs to the input
- * vocabulary, not to the boot.
+ * 🎯 ONE LIST AND NOT A CHECKER'S COPY OF IT: a checker that re-listed these rules would drift from the boot the first time
+ * a rule was added here, and it would then accept a cartridge the platform refuses — the drift ADR-0253 exists to end.
  *
- * ⚠️ IT THROWS, by the rubric of the two refusals above: this is a PROGRAM defect — the game declared a word for a
- * position that is not its own — and not a gap of the host. `problems` is for what still lets the child play.
+ * ⚠️ EACH ROW THROWS AT BOOT, by the rubric of ADR-0169: every one is a PROGRAM defect, never a gap of the host, and
+ * `problems` is for what still lets the child play.
+ *   · the declaration's shape (`core/contract`, ADR-0030);
+ *   · «start» and «select» belong to the pause, and a cartridge does not take them (ADR-0144 §4, ADR-0155) — the sentences
+ *     live in `core/actions`, where the validity of a preset lives;
+ *   · the accommodations are ANSWERED, all of them (ADR-0153): the engine would not know which rows to mount;
+ *   · a genre outside the engine's list, or Casino game (ADR-0156 §2, §4); an absent genre is conformant;
+ *   · a malformed `hud`, game options or `howToPlay` (ADR-0169): the engine would not know what to place, draw or show.
  */
-function refuseIfItClaimsStart(who, preset) {
-    // 📌 AND SELECT TOO, since ADR-0155: the two system positions are the two doors of the pause.
-    const problemas = [startClaimProblem(preset), selectClaimProblem(preset)].filter((x) => x !== null);
-    if (problemas.length)
-        refuseDeclaration(who, problemas);
-}
-/**
- * Did the cartridge ANSWER its accommodations? (ADR-0153.) Same rubric as the contract: a missing or incomplete answer is
- * a precondition, not a gap — `problems` is for what still lets the child play, and here the engine would not know which
- * rows to mount.
- */
-function refuseIfNoAnswer(who, answers) {
-    const problemas = accommodationAnswersProblems(answers);
-    if (problemas.length)
-        refuseDeclaration(who, problemas);
-}
-/** A genre outside the engine's list, or Casino game, refuses the boot (ADR-0156 §2, §4); an absent genre is conformant. */
-function refuseIfGenreRefused(who, genre) {
-    const problemas = genreProblems(genre);
-    if (problemas.length)
-        refuseDeclaration(who, problemas);
-}
-/** A malformed `hud` is a program defect, refused like the declaration (ADR-0169): the engine would not know what to place. */
-function refuseIfHudMalformed(who, hud) {
-    const problemas = hudNumbersProblems(hud);
-    if (problemas.length)
-        refuseDeclaration(who, problemas);
+export function cartridgeRefusals(declaration, hooks) {
+    const h = hooks ?? {};
+    return [
+        ...conformanceProblems(declaration),
+        ...[startClaimProblem(h.preset), selectClaimProblem(h.preset)].filter((x) => x !== null),
+        ...accommodationAnswersProblems(h.accommodations),
+        ...genreProblems(h.genre),
+        ...hudNumbersProblems(h.hud),
+        ...gameOptionsProblems(h.gameOptions),
+        ...howToPlayProblems(h.howToPlay),
+    ];
 }
-/** Malformed game options are a program defect, refused like the declaration (ADR-0169): the engine would not know what to draw. */
-function refuseIfOptionsMalformed(who, options) {
-    const problemas = gameOptionsProblems(options);
-    if (problemas.length)
-        refuseDeclaration(who, problemas);
-}
-/** A malformed `howToPlay` is a program defect, refused like the declaration (ADR-0169): the help would not know what to show. */
-function refuseIfHowToPlayMalformed(who, slides) {
-    const problemas = howToPlayProblems(slides);
-    if (problemas.length)
-        refuseDeclaration(who, problemas);
+/** Throws with every refusal at once: an author fixes the whole list in one pass instead of meeting it line by line. */
+function refuseCartridge(who, declaration, hooks) {
+    const problems = cartridgeRefusals(declaration, hooks);
+    if (problems.length)
+        refuseDeclaration(who, problems);
 }
 /** The ids the engine announces and draws into. Without them a child who listens hears nothing (finding 6). */
 const REQUIRED_MARKUP = ['#game-region', '#sr-status', '#sr-alert'];
@@ -229,6 +229,12 @@ const REQUIRED_MARKUP = ['#game-region', '#sr-status', '#sr-alert'];
  * bar, and its own sentence can say WHAT is lost, which is what makes it useful to whoever reads it first.
  */
 const A11Y_BAR_SELECTOR = '#title-icons';
+/**
+ * The engine's own controls that stay pressable by key IN PLAY: the accessibility bar's icons, in `#title-icons` and in the
+ * HUD. A key that activates one of them is that control's, and play does not hear it (`input/key-default`, ADR-0111 errata of
+ * 2026-09-26).
+ */
+const ENGINE_CONTROLS_IN_PLAY = '.pi-btn';
 /**
  * Switches the engine on for a declared game.
  *
@@ -245,16 +251,7 @@ export function createGame(o) {
      * tied to the argument would leave a root serving several cartridges with the first of them forever.
      */
     let cartridge = o;
-    const contractProblems = conformanceProblems(cartridge.declaration);
-    if (contractProblems.length) {
-        refuseDeclaration('createGame', contractProblems);
-    }
-    refuseIfItClaimsStart('createGame', cartridge.preset);
-    refuseIfNoAnswer('createGame', cartridge.accommodations);
-    refuseIfGenreRefused('createGame', cartridge.genre);
-    refuseIfHudMalformed('createGame', cartridge.hud);
-    refuseIfOptionsMalformed('createGame', cartridge.gameOptions);
-    refuseIfHowToPlayMalformed('createGame', cartridge.howToPlay);
+    refuseCartridge('createGame', cartridge.declaration, cartridge);
     const { doc } = o.host;
     /*
      * 🔴 THE WINDOW THIS ROOT LISTENS ON IS A SCOPED ONE, and it is not plumbing: a root installs about thirty listeners on the
@@ -275,21 +272,32 @@ export function createGame(o) {
     const whenDisposed = (release) => { endOfLife.push(release); };
     const stateOn = (evt, fn) => { const off = state.on(evt, fn); whenDisposed(off); return off; };
     /*
-     * THE ROOT'S TRANSLATOR (ADR-0232 D3): the page's language, and this root's `t`, markup pass and door to a language change.
-     * `localeOn` is that door — like `stateOn`, whatever subscribes through it is released by `dispose()` (ADR-0220).
+     * 🔴 THE PAGE'S ONE STORE IS BUILT HERE, from what the HOST lends (ADR-0232 point 2, issue #207): the backend the host
+     * passed, or its window's `localStorage`. Every module below that persists receives THIS store; none reaches the global.
+     * Reading `win.localStorage` can itself THROW (file://, some private modes), which is a host with no storage: `null`.
+     */
+    const store = createStorage(hostStorage(o.host));
+    /*
+     * THE ROOT'S TRANSLATOR (ADR-0232 D3): the page's language as this root speaks it, the game's dictionary, and this root's
+     * `t`, markup pass and door to a language change. `core/i18n` holds none of it (erratum of 2026-09-25).
+     * 🔴 ITS PORT IS THE STORED LANGUAGE **AND** THE BROWSER'S (ADR-0221 step 7g): the page effects — writing `<html lang>`,
+     * dispatching on the window, reading `navigator.language`, hearing another root switch — come in through `localeHostHooks`,
+     * which is THIS root's host speaking: the document and the scoped window it received, never the globals.
+     * `localeOn` is its door — like `stateOn`, whatever subscribes through it is released by `dispose()` (ADR-0220).
      */
-    const translator = createTranslator();
+    const translator = createTranslator({
+        ...store, KEYS, ...localeHostHooks(doc, win, (root) => { translator.applyDom(root); }),
+    });
     for (const [code, entries] of Object.entries(o.dictionaries ?? {}))
         translator.registerDict(code, entries);
     // 📌 The root's own words go through ITS translator, which reads this game's dictionary (ADR-0232 D3).
-    const { t, bcp47 } = translator;
+    const { t, bcp47, word } = translator;
     const localeOn = (react) => { const off = translator.onChange(react); whenDisposed(off); return off; };
-    /*
-     * 🔴 THE PAGE'S ONE STORE IS BUILT HERE, from what the HOST lends (ADR-0232 point 2, issue #207): the backend the host
-     * passed, or its window's `localStorage`. Every module below that persists receives THIS store; none reaches the global.
-     * Reading `win.localStorage` can itself THROW (file://, some private modes), which is a host with no storage: `null`.
+    /**
+     * THE GAME'S POSITIONS IN WORDS, resolved NOW from its keys (ADR-0232 D3, erratum of 2026-09-25). A function and never a
+     * value: every surface that shows a position asks at its drawing, so a language change reaches all of them at once.
      */
-    const store = createStorage(hostStorage(o.host));
+    const actionWords = () => (cartridge.preset ? wordsOf(cartridge.preset, word) : {});
     // THE CHILD'S STORED SETTINGS, FIRST (ADR-0178): nothing below reads or writes one before this.
     // ⚠️ The port of ADR-0178 carries the key names beside the store, so `core` names no storage place itself.
     const state = createSettingsStore({ ...store, KEYS });
@@ -297,15 +305,8 @@ export function createGame(o) {
     // Destructured so the call sites below read as they did; a game reads the same object as `Engine.input`.
     const input = createInputState();
     const { inputOf, keys, markKeyFrom, releaseKey, playerEdge, letGoOfTheKeyboard } = input;
-    /*
-     * 🔴 THE STORED LANGUAGE **AND** THE BROWSER'S (ADR-0221 step 7g). `core/i18n` keeps the decisions; the page effects —
-     * writing `<html lang>`, dispatching on the window, reading `navigator.language` — come in through these two functions,
-     * which are THIS root's host speaking: the document and window it received, never the globals. `core` is what the
-     * engine IS without a browser.
-     */
-    loadLocale({ ...store, KEYS, ...localeHostHooks(doc, win, translator.applyDom) });
-    // 📌 And the debugging exposure: whoever HAS a window is this root.
-    exposeI18n(win, i18nObject);
+    // 📌 And the debugging exposure: whoever HAS a window is this root, and what it exposes is its translator.
+    exposeI18n(win, translator);
     /*
      * ⚠️ A READER AND NOT A SNAPSHOT. `declines` belongs to the GAME's half (ADR-0139: the cartridge declares what it does
      * NOT have), so a `const` taken at boot would return, after a `mount()`, the previous cartridge's declines — and a
@@ -319,17 +320,34 @@ export function createGame(o) {
     const $ = (sel) => doc.querySelector(sel);
     const $$ = (sel) => [...doc.querySelectorAll(sel)];
     /*
-     * THIS ROOT'S ANNOUNCER AND DEAF MODE (ADR-0232 D4): the screen reader's two regions written in the HOST's document on the
-     * host's frames, and the Libras interpreter over its store. A window with no frames (a test double) is the announcer's to answer.
-     * 📌 DD1: the root does NOT mirror its announcements into Libras — a game connects that sink (`Engine.mirrorAnnouncements`),
-     * as before; mirroring everything would be `announcer.mirrorTo(libras.say)` here.
+     * THIS ROOT'S ANNOUNCER AND DEAF MODE (ADR-0232 D4, ADR-0234): the screen reader's two regions written in the HOST's
+     * document on the host's frames, and deaf mode over its store. A window with no frames (a test double) is the announcer's to answer.
+     * 📌 Deaf mode hands the interpreter what the SONAR reads — the text on screen (`ui/screen-text`) — never the announcements,
+     * and that text is spoken with the mode off. The interpreter is the host's; else the free Libras player the DELIVERY shipped
+     * (`ui/libras-avatar-player`, ADR-0234 route B), opened from the page's own origin at the first request — three.js arrives
+     * with it, never before; and where the delivery shipped none, that player answers as `NO_INTERPRETER` does — the sonar's text
+     * is captioned, and «signing unavailable» goes to `problems` and to the child. The ports it calls later (`tts`, the caption,
+     * `measuredProblems`) are read when it calls.
      */
     const announcer = createAnnouncer({
         doc,
         raf: win.requestAnimationFrame, // as the host has it: the announcer answers a window with none (bound by the listener scope)
     });
     const { say: srSay, alert: srAlert } = announcer;
-    const libras = createLibras({ doc, win, store, now: () => Date.now() });
+    const deafMode = createDeafMode({
+        store,
+        captionsSetting: () => state.captionsOn,
+        t: translator.t,
+        interpreter: hostInterpreter(o.host, () => createLibrasAvatarInterpreter({
+            doc, win, fetch: win.fetch, base: doc.baseURI, title: () => t('sr.deaf.interpreter'),
+        })),
+        // a player's sonar waits for another player's reading and cuts its own (ADR-0234, errata 2026-09-26)
+        speak: (text, seat) => { tts.narrate(text, { seat }); },
+        caption: (text) => { writeSoundCaption(text); },
+        tell: srSay,
+        report: (line) => { measuredProblems.push(line); },
+    });
+    whenDisposed(deafMode.dispose);
     for (const sel of REQUIRED_MARKUP) {
         if (!$(sel))
             hostProblems.push(`the page lacks ${sel}: the engine announces and draws into it, and without it a child who listens hears nothing — add it to the page`);
@@ -380,8 +398,7 @@ export function createGame(o) {
     }
     // 1. LANGUAGE BEFORE EVERYTHING. The interface cannot be built before the language is known. The document goes in:
     //    see finding 15.
-    initI18n(doc);
-    translator.applyDom(doc); // the host's markup, with THIS game's dictionary too — the module's pass reads only the page's
+    translator.init(doc); // the host's markup, with THIS game's dictionary too, and the stored or preferred language asked for
     // 2. MIXER BEFORE VOICE. Finding 3 turned into sequence: `createAudio` loads the mixer, and the voice reads it.
     //    🔴 THE BROWSER'S SOUND AND SPEECH ARE LENT HERE, from the host's window (ADR-0232 D4): the audio context — made at the
     //    first sound, never at boot, so it is born inside the child's gesture and the browser lets it run — and the speech
@@ -396,6 +413,31 @@ export function createGame(o) {
         synth: () => speechHost.speechSynthesis ?? null,
         utterance: (text) => new speechHost.SpeechSynthesisUtterance(text),
     };
+    /*
+     * THE DEVICE'S VOICES ARRIVE LATE, AND TWO THINGS FOLLOW THEM (ADR-0185 §4, erratum 2026-09-26): the hearing panel's speech rows
+     * and the 🗣 of the bars. The page has ONE `onvoiceschanged` slot, so this root takes it once and hands each change to every
+     * listener. The last root takes the slot, and an ended root empties it only if it is still its own (ADR-0220).
+     */
+    const voicesListeners = [];
+    const voicesChanged = () => { for (const again of voicesListeners)
+        again(); };
+    const whenVoicesChange = (again) => {
+        voicesListeners.push(again);
+        if (voicesListeners.length > 1)
+            return;
+        try {
+            if (speechHost.speechSynthesis)
+                speechHost.speechSynthesis.onvoiceschanged = voicesChanged;
+        }
+        catch (e) { /* noop */ }
+        whenDisposed(() => {
+            try {
+                if (speechHost.speechSynthesis?.onvoiceschanged === voicesChanged)
+                    speechHost.speechSynthesis.onvoiceschanged = null;
+            }
+            catch (e) { /* noop */ }
+        });
+    };
     /*
      * THE ENGINE'S OWN KOKORO LOADER (ADR-0216 §1 and §5) — the Dev, 2026-09-21: «O jogo não deve precisar saber como isso funciona».
      * ⚠️ IMPORTED AT THE FIRST NEURAL UTTERANCE AND NOT BEFORE: `kokoro-runtime` is what names espeak-ng and the ONNX runtime, so a
@@ -420,6 +462,9 @@ export function createGame(o) {
         createAudio: () => doc.createElement('audio'),
         speech,
         now: () => win.performance.now(),
+        // a part in a language the device has no voice for (ADR-0243 §3); `measuredProblems` is declared below and read when it calls
+        report: (line) => { if (!measuredProblems.includes(line))
+            measuredProblems.push(line); },
     });
     // 📌 The neural-voice line lives in `measureCartridgeProblems()`: the decline that silences it is the game's.
     /**
@@ -488,19 +533,27 @@ export function createGame(o) {
         const simulation = simulationSuspended() ? null : worldState.simulacao;
         simulationOverWorld.onlyInPlay(simulation ? (VIZ_FILTER[simulation] ?? '') : '', enhancement);
         simulationOverWorld.drawLayer(simulation);
-        applyCrt(); // the decorative CRT yields to every visual mode, and comes back when none is on (ADR-0047)
+        applyCrt(); // the decorative CRT yields to the visual modes, and comes back when none is on (ADR-0047, ADR-0241)
     }
+    /*
+     * WHICH VISUAL MODES ARE ON — decided here, once: a colour correction or a simulation (the world filter), the game's
+     * high-contrast theme, the contrast enhancement. A colour-vision mode ON ITS OWN only changes hue (ADR-0241).
+     */
+    const visualModeOn = () => filterKey(worldState) !== null || hasHighContrast(worldState) || lq.t() > 0;
+    const onlyHueChanges = () => lq.t() === 0 && onlyColourVision(worldState);
     /*
      * THE CRT, applied by the engine (study items A5, B1). 📏 Measured: the panel said «Scanlines: on» and the region had no
-     * CRT class until a toggle was pressed — `render/crt` was never started under `createGame`. It yields to a colour
-     * correction, a simulation and the contrast enhancement; its scanlines are re-anchored to real pixels at every scale.
+     * CRT class until a toggle was pressed — `render/crt` was never started under `createGame`. The vignette yields to every
+     * visual mode; the scanline to every one but a colour-vision mode on its own (ADR-0241). Its scanlines are re-anchored
+     * to real pixels at every scale.
      */
     const crt = createCrt({
         region: () => $('#game-region'),
         win,
         // `cartucho` and not `players()`: this runs at boot, above the `players` declaration (temporal dead zone)
         numPlayers: () => Math.max(1, (cartridge.players ?? []).length),
-        a11yVisualOn: () => filterKey(worldState) !== null || lq.t() > 0,
+        scanlineYields: () => visualModeOn() && !onlyHueChanges(),
+        vignetteYields: visualModeOn,
         store,
     });
     const { apply: applyCrt, scanVars: crtScanVars } = crt;
@@ -585,6 +638,12 @@ export function createGame(o) {
     // The screen footer (see `screenFooter`): declared HERE, before the first `changePhase`, which already clears it.
     let footer = null;
     let barExplanation = null;
+    /*
+     * WHO HOLDS THE EXPLANATION BAND (ADR-0244): the GAME's text is the band's resting text (`Engine.explain`); an engine item —
+     * a quick-bar icon, a pause-card item, a locked item's reason — takes the band while it is pointed and gives it back.
+     */
+    let gameExplanation = null;
+    let itemExplanation = null;
     // The quick-pause state and the button legend, declared before the first `changePhase` too: its `pauseControls.hide`
     // refreshes the legend (ADR-0164 rule 3), and reading them earlier would be a temporal-dead-zone error at boot.
     const inQuickPause = new Set();
@@ -618,6 +677,8 @@ export function createGame(o) {
      * protect what does not exist.
      */
     engineActions.quit = () => changePhase('title');
+    /** Print mode is armed: the next key is its way out, and not play's (read by the keyboard conductor). */
+    let printArmed = false;
     /*
      * PRINT — «ver a tela sem menus», and any button comes back.
      *
@@ -632,6 +693,11 @@ export function createGame(o) {
      * neither to the game nor to the pause, it is the way out. 🎯 And it does not collide with the `start` hook (ADR-0144),
      * which bubbles: `goBack` reveals the card in the capture, and when the bubbling one arrives the card-already-open
      * guard sends it away.
+     *
+     * 🔴 AND THE KEY THAT ENDS IT IS NOT PLAYED (ADR-0111 erratum of 2026-09-26, one key one action). `goBack` is added after
+     * the keyboard conductor, on the same node and phase, so the conductor runs first and saw no menu: 📏 on the served quiz
+     * the arrow that ended print mode also moved the quiz's cursor. The conductor reads `printArmed` instead. Not
+     * `stopImmediatePropagation`: the cool-down, the motor filter and the pad's hiding listen after, and must still see the key.
      */
     engineActions.print = () => {
         const findPauseCard = () => $('#vp-pause-0');
@@ -640,6 +706,7 @@ export function createGame(o) {
             return;
         eventTarget.hidden = true;
         const goBack = (e) => {
+            printArmed = false;
             if (e && typeof e.preventDefault === 'function') {
                 try {
                     e.preventDefault();
@@ -653,23 +720,15 @@ export function createGame(o) {
                 c.hidden = false;
         };
         win.setTimeout(() => {
+            printArmed = true;
             win.addEventListener('keydown', goBack, true);
             win.addEventListener('pointerdown', goBack, true);
         }, 80);
         srSay(t('sr.print.on'));
     };
     /**
-     * THE HEARING PANEL, resolved late and read early — the same laziness as `engineActions` above, for the same reason:
-     * `initPauseIcons` runs here and the panels mount further below.
-     *
-     * 🔴 IT IS A `let` BECAUSE OF A DEFECT KEPT VERBATIM. `ui/pause-icons` documents it: in the monolith the call that
-     * refreshed the narration row sat behind `typeof reflectTTS === 'function'`, a symbol that no longer existed, «so it
-     * never fires». The guard was ported as `reflectTtsPanelEnabled`, defaulting to `false`, so as not to fix it
-     * silently — and with a field to switch it back on.
-     *
-     * 🎯 THE ENGINE CAN: it mounts the panel, so it has the `reflectTts` to hand over. Without it, the child turns
-     * narration on with the bar's 🗣 icon and the panel goes on saying it is off — the family of defect where a control
-     * lies about its state.
+     * THE HEARING PANEL, resolved late and read early — the same laziness as `engineActions` above, for the same reason: the
+     * mixer's listener (`onCatChange`, below) is subscribed before the panels mount further below, and reads this when told.
      */
     let audio = null;
     /*
@@ -750,6 +809,7 @@ export function createGame(o) {
      */
     const sceneMotion = readStoredScene(store, defaultReducedMotion(win.matchMedia));
     const saveSceneMotion = () => { storeScene(store, sceneMotion); };
+    const setGameTheme = cartridge.setPlayerTheme;
     const pauseIcons = initPauseIcons({
         translator, store,
         settings: state, // the page's settings store itself: its live bindings are the reads the bar asks for (ADR-0232)
@@ -814,11 +874,13 @@ export function createGame(o) {
          * edge between layers to save one argument. Composition is this file's job.
          */
         transportInUse: (i) => inputOf(i).inUse,
-        // ✅ The monolith's dead guard works again — see the note on `audio`, above.
-        reflectTtsPanel: () => { audio?.reflectTts(); },
-        reflectTtsPanelEnabled: true,
-        isLibrasOn: libras.isOpen,
-        toggleLibras: () => libras.toggle(translator.t),
+        // ⚠️ OFF, and not the monolith's dead guard come back: the 🗣's write is told by the mixer, and the root's one listener to
+        // it (`onCatChange`, below) repaints the panel — a second path here would be two answers to «who reflects narration»
+        // (ADR-0247).
+        reflectTtsPanel: () => { },
+        reflectTtsPanelEnabled: false,
+        isLibrasOn: deafMode.isOn,
+        toggleLibras: deafMode.toggle,
         /*
          * ⚠️ WHAT THE GAME HANDS OVER: the three fields are optional on both sides. Absent, the pause card holds only what the
          * engine acts on, and the two visual icons follow their own rules. See the notes in `CreateGameOptions`.
@@ -865,7 +927,16 @@ export function createGame(o) {
             reserveBarBand(); // the name line under the bar grows with the text (issue #160)
             return FONT_BY_KEY[position.font]?.fam ?? null;
         } : undefined,
-        ...(cartridge.setPlayerTheme ? { setPlayerTheme: cartridge.setPlayerTheme } : {}),
+        /*
+         * 🌗 THE THEME IS THE GAME'S TO DRAW (ADR-0148 erratum) AND THE ROOT'S TO KNOW: the decorative CRT yields to high
+         * contrast (ADR-0047), and a writer handed straight through left the root blind to it — the scanlines and the vignette
+         * stayed over a high-contrast screen.
+         */
+        ...(setGameTheme ? { setPlayerTheme: (i, theme) => {
+                setGameTheme(i, theme);
+                worldState = { ...worldState, tema: theme };
+                applyCrt();
+            } } : {}),
         /*
          * 🚥 COLOUR-VISION CORRECTION HAS AN ENGINE DEFAULT (ADR-0148 §1), so the icon is never missing for want of a writer.
          *
@@ -948,7 +1019,7 @@ export function createGame(o) {
         /*
          * ⚠️ AND AGAIN WHEN THE BOOT LANGUAGE ARRIVES — without it the bar stays in the FALLBACK language.
          *
-         * `initI18n` applies pt synchronously (so the page is never blank) and, if the preferred language is another, ASKS
+         * `translator.init` applies pt synchronously (so the page is never blank) and, if the preferred language is another, ASKS
          * for the switch — which is asynchronous, because en/es are on-demand chunks. This markup is born in that interval.
          *
          * 📌 IT IS THE `i18n:change` LISTENER near the pad that repaints it (study item C6, ADR-0031): the boot's preferred
@@ -961,7 +1032,8 @@ export function createGame(o) {
          * `aria-pressed=false` after the child had turned it on — the control lying about its state.
          *
          * 📌 ONLY THE STATES WITH AN EVENT that can change elsewhere: blind mode, the camera control and the voice control
-         * (`GameEvent`). The other icons reflect themselves on the click, which is the path by which they change.
+         * (`GameEvent`), and NARRATION, which is the mixer's category and is told by the mixer (`onCatChange`, below). The other
+         * icons reflect themselves on the click, which is the path by which they change.
          */
         stateOn('blindMode', () => { pauseIcons.reflectIconsIn(a11yBar, 0); });
         // the 👀 changes elsewhere too: the eye control puts it back to off when the camera or the files are missing (ADR-0213)
@@ -971,6 +1043,26 @@ export function createGame(o) {
         // is worse than a missing one (ADR-0106 §5), and the click path does not cover it, because this change comes from elsewhere.
         stateOn('voiceControl', () => { pauseIcons.reflectIconsIn(a11yBar, 0); });
     }
+    // 🔴 AND THE 🗣 WHEN THE DEVICE'S VOICES CHANGE (ADR-0185 erratum 2026-09-26): they can arrive after load, or leave, and the
+    // icon's greyed-out look is the lock the child sees. Silent: the press says why on its own, and nothing else changed.
+    whenVoicesChange(() => {
+        if (a11yBar && barUsable)
+            pauseIcons.reflectIconsIn(a11yBar, 0);
+        pauseIcons.reflectPauseIcons();
+    });
+    /*
+     * 🔴 THE MIXER TELLS EVERY CHANGE, AND THIS IS THE ONE LISTENER (ADR-0247). The engine hands the mixer itself to the game
+     * (`Engine.audio`), so a category — narration above all — is written by the bar's 🗣, by the panels, and by a game's own mute
+     * button or cut-scene; without this, the bar and the panel said the state the child had left while the voice spoke or fell
+     * silent (ADR-0159 rule 10: the state is said in words, and a stale word is a lie). Every writer is heard here and every
+     * surface is drawn from here: the bar's icons for narration, the only category the bar shows, and the panels for any.
+     * It is the ROOT's, so it ends with `dispose()`; `unmount()` keeps it, as the root and its surfaces live on (ADR-0142).
+     */
+    whenDisposed(mixer.onCatChange((k) => {
+        if (k === 'tts' && a11yBar && barUsable)
+            pauseIcons.reflectIconsIn(a11yBar, 0);
+        audio?.reflectCategory(k);
+    }));
     // 4d. WHO OPENED THE PAUSE, when there is more than one seat — finding 3 of the `game-soccer` audit.
     //
     // ⚠️ THE KEYBOARD PANEL IS PARAMETERISED BY THE SEAT: `render(selPlayer)` draws the positions of THAT scheme, and the
@@ -998,6 +1090,11 @@ export function createGame(o) {
         findPauseCard.id = 'vp-pause-0';
         pauseMountPoint.appendChild(findPauseCard);
     }
+    // THE LIBRARY FAMILIES THIS GAME DECLARED (`uses.fonts`, ADR-0255), the engine's own left out; a declaration that is not a list
+    // of names is said in `problems`. Their faces are written and kept at the end of the boot, with the heavy files.
+    const libraryFonts = declaredFamilies(o.uses?.fonts, ENGINE_FAMILIES);
+    if (libraryFonts.problem)
+        hostProblems.push(libraryFonts.problem);
     /*
      * 4f. THE SETTINGS PANELS (ADR-0106 §1).
      *
@@ -1038,12 +1135,10 @@ export function createGame(o) {
             t: translator.t, $, srSay, store, root: doc.documentElement,
             // The rows' prose goes to the footer at EVERY render, or it appears twice on the first click.
             fillExplain: overlays.fillExplain,
-            // ⚠️ `doc.fonts` IS A BROWSER GLOBAL — FINDING 15 of this file. Here it comes from the host's `doc` and is still
-            // asked whether it exists: a fake document has no `fonts`, and the absence has a declared answer (the row is
-            // disabled WITH the message that tells the adult which fonts solve it).
-            ...(typeof doc.fonts?.check === 'function'
-                ? { fontInstalled: (family) => doc.fonts.check(`16px "${family}"`) }
-                : {}),
+            // 🔴 A LIBRARY FACE IS THERE WHEN THIS GAME DECLARED ITS FAMILY (ADR-0255), and that is the whole detector: the engine
+            // writes the family's `@font-face` for exactly those. `document.fonts.check` is not asked, because it answers `true` for a
+            // family NO rule declares (nothing to load) — it would offer every library row on every page.
+            fontInstalled: (family) => libraryFonts.asked.includes(family),
         });
         /*
          * AAC — COMMUNICATION: THE PANEL IS NOT MOUNTED (ADR-0151).
@@ -1087,7 +1182,11 @@ export function createGame(o) {
                         return;
                     while (list.firstChild)
                         list.removeChild(list.firstChild);
-                    const slideContents = [...(cartridge.howToPlay ?? []), ...helpRows(cartridge.preset, (a) => keyboard.kbFor(0)[a], (code) => keyName(t, code))];
+                    // the game's words resolved NOW, in the page's language (ADR-0232 D3): a language change re-renders an open panel
+                    const slideContents = [
+                        ...playSlidesOf(cartridge.howToPlay ?? [], word),
+                        ...helpRows(actionWords(), (a) => keyboard.kbFor(0)[a], (code) => keyName(t, code)),
+                    ];
                     const ctxDoSlide = { create: (tag) => doc.createElement(tag), t, title: t('menu.help') };
                     const slides = mountSlides(ctxDoSlide);
                     list.appendChild(slides);
@@ -1143,7 +1242,7 @@ export function createGame(o) {
         });
         gamePanel.shell.reset.hidden = true;
         redrawGameOptions = () => {
-            drawGameOptions({ ...panelCtx, say: srSay, t: translator.t }, gamePanel.shell.list, cartridge.gameOptions ?? []);
+            drawGameOptions({ ...panelCtx, say: srSay, t: translator.t, word }, gamePanel.shell.list, cartridge.gameOptions ?? []);
             if (!gamePanel.shell.overlay.hidden)
                 overlays.fillExplain(gamePanel.shell.card);
         };
@@ -1197,9 +1296,9 @@ export function createGame(o) {
             fillExplain: overlays.fillExplain,
             toggleBtn,
             // The «Personagem» section exists only if the GAME said it has one (ADR-0153). Read at every render: it changes on `mount()`.
-            hasCharacter: () => subjectWord(cartridge.accommodations, 'reducedCharacterMotion') !== null,
-            // and its title is the game's word for it (ADR-0153 confirmation)
-            characterLabel: () => subjectWord(cartridge.accommodations, 'reducedCharacterMotion')?.label ?? null,
+            hasCharacter: () => subjectWord(cartridge.accommodations, 'reducedCharacterMotion', word) !== null,
+            // and its title is the game's word for it (ADR-0153 confirmation), resolved at every render (ADR-0232 D3)
+            characterLabel: () => subjectWord(cartridge.accommodations, 'reducedCharacterMotion', word)?.label ?? null,
         });
         engineActions.anim = animPanel.open;
         /*
@@ -1292,8 +1391,8 @@ export function createGame(o) {
          * Owner colours carries the game's word; the outlines are two positions of one subject, named by the engine.
          */
         const ownerSpec = () => {
-            const word = subjectWord(cartridge.accommodations, 'ownerColors');
-            return { id: 'opt-dono', label: word?.label ?? '', hint: word?.hint };
+            const owner = subjectWord(cartridge.accommodations, 'ownerColors', word);
+            return { id: 'opt-dono', label: owner?.label ?? '', hint: owner?.hint };
         };
         const { row: ownerRow, control: ownerButton } = controlRow(panelCtx, ownerSpec());
         const reflectOwner = () => {
@@ -1331,7 +1430,7 @@ export function createGame(o) {
             });
             // the hint is written BEFORE the panel's render, which runs `fillExplain`: written after, it stays inside the row
             const writeHint = () => {
-                explanation.textContent = subjectWord(cartridge.accommodations, 'contrastOutlines')?.hint ?? t(`visual.contorno.${plane}.dica`);
+                explanation.textContent = subjectWord(cartridge.accommodations, 'contrastOutlines', word)?.hint ?? t(`visual.contorno.${plane}.dica`);
             };
             writeHint();
             const reflect = () => { updateSteps(stepper, spec()); };
@@ -1340,12 +1439,12 @@ export function createGame(o) {
         const fgOutline = outline('fg');
         const bgOutline = outline('bg');
         const offerOwnerAndOutlines = () => {
-            ownerRow.hidden = subjectWord(cartridge.accommodations, 'ownerColors') === null;
+            ownerRow.hidden = subjectWord(cartridge.accommodations, 'ownerColors', word) === null;
             if (!ownerRow.hidden) {
                 labelRow(ownerRow, ownerSpec());
                 reflectOwner();
             }
-            const withoutOutlines = subjectWord(cartridge.accommodations, 'contrastOutlines') === null;
+            const withoutOutlines = subjectWord(cartridge.accommodations, 'contrastOutlines', word) === null;
             for (const c of [fgOutline, bgOutline]) {
                 c.row.hidden = withoutOutlines;
                 if (!withoutOutlines)
@@ -1513,7 +1612,7 @@ export function createGame(o) {
         const audioPanel = mountPanel(panelCtx, {
             id: 'audio',
             // 📌 THE SHELL'S LIST IS NAVIGATION SOUND since ADR-0151: the taste categories went to «Áudio». The id
-            // `navsound-list` is the one `initSettingsAudio` fills with sonar, cane and guide.
+            // `navsound-list` is the one `initSettingsAudio` fills with the sonar and the cane (`guard`/`guide` left, ADR-0258).
             listId: 'navsound-list',
             labels: () => ({
                 title: t('menu.audio'),
@@ -1560,7 +1659,7 @@ export function createGame(o) {
         // is not wiring. ⚠️ Read at every opening: the topology is a function, and a game changes its demands between phases (ADR-0084).
         const hideRowsWithoutSubject = () => showOnlyRowsThatApply({
             find: $,
-            caneWord: () => subjectWord(cartridge.accommodations, 'caneSpacing'),
+            caneWord: () => subjectWord(cartridge.accommodations, 'caneSpacing', word),
             hasNavigationSound: () => contractSubjects({
                 declaration: cartridge.declaration,
                 actions: cartridge.preset ? presetActions(cartridge.preset) : [],
@@ -1586,6 +1685,12 @@ export function createGame(o) {
                 catch (e) {
                     return [];
                 } },
+                /*
+                 * 🔴 THE SAMPLE SPEAKS THE PAGE'S LANGUAGE, read at every press: its text comes from the page's dictionary, so a fixed tag
+                 * asked the browser for a Portuguese voice to read English words. And a chosen voice of ANOTHER language is not handed
+                 * over (ADR-0185): the page's system-voice list offers every voice when none matches, and the one picked before a
+                 * language switch outlives it. So the voice goes only if the engine's own list for the language (`tts.voices()`) has it.
+                 */
                 speakSample: (sample, chosen) => {
                     try {
                         const ss = win.speechSynthesis;
@@ -1593,8 +1698,8 @@ export function createGame(o) {
                             return;
                         ss.cancel();
                         const u = speech.utterance(sample);
-                        u.lang = 'pt-BR';
-                        if (chosen)
+                        u.lang = bcp47();
+                        if (chosen && tts.voices().some((v) => v.voice === 'webspeech:' + chosen.name))
                             u.voice = chosen;
                         u.rate = 1;
                         u.volume = 1;
@@ -1602,21 +1707,7 @@ export function createGame(o) {
                     }
                     catch (e) { /* the device refused to speak; the panel already says what it can do */ }
                 },
-                whenVoicesChange: (again) => {
-                    try {
-                        if (win.speechSynthesis)
-                            win.speechSynthesis.onvoiceschanged = again;
-                    }
-                    catch (e) { /* noop */ }
-                    // one slot per page and the last root takes it: an ended root empties it only if it is still its own (ADR-0220)
-                    whenDisposed(() => {
-                        try {
-                            if (win.speechSynthesis?.onvoiceschanged === again)
-                                win.speechSynthesis.onvoiceschanged = null;
-                        }
-                        catch (e) { /* noop */ }
-                    });
-                },
+                whenVoicesChange,
             },
             audioOutputs: {
                 canList: () => !!(win.navigator?.mediaDevices && win.navigator.mediaDevices.enumerateDevices),
@@ -1649,6 +1740,7 @@ export function createGame(o) {
             getVolume: () => mixer.volume,
             setVolume,
             getAudioCat: () => mixer.audioCat,
+            // the bar follows what the panel writes through the mixer's own event, `onCatChange` above (ADR-0247)
             setCatGain,
             tts,
             getBlindMode: readBlindMode,
@@ -1662,18 +1754,17 @@ export function createGame(o) {
         engineActions.audio = audioPanel.open;
         engineActions.som = soundPanel.open;
     }
-    // 4b. NAVIGATION SOUND. Only the contract goes in: no tile, collision box or coin array.
+    // 4b. THE SONAR. Only the contract goes in: no tile, collision box or coin array. Its WORDS are the text on screen at the
+    //     press, read from the page by `ui/screen-text` (ADR-0234: «sonar do que está na tela»); its tone points at the target.
+    const screen = { doc, world: () => cartridge.declaration.world() };
     const sonar = createAudioSonar({
+        screenText: () => screenText(screen),
         t: translator.t,
         topology: () => cartridge.declaration.topology(),
         targetsOf: (i) => cartridge.declaration.targetsOf(i),
         nameAt: (at) => cartridge.declaration.nameAt(at),
-        // Field 2 + the mixer bus: what the CONTINUOUS GUIDE needs and the beep did not (#84 item 2). `roleAt` is what lets
-        // the route go round a wall; `catNode`/`audioOut`/`getVolume` put a PERMANENT graph on the same volume slider as
-        // all the rest of the audio.
-        roleAt: (at) => cartridge.declaration.roleAt(at),
-        tonePan, srSay, narrate: (text) => tts.narrate(text),
-        catNode, audioOut, getVolume: () => mixer.volume,
+        // what the sonar reads is spoken — or, in deaf mode, captioned and signed by the interpreter (ADR-0234)
+        tonePan, srSay, narrate: deafMode.sonar,
         // ⚠️ THE ANSWER, NOT THE TABLE (#104): `platform/audio-sonar` does not know what a visual mode is, so it is answered
         // here — the root is the only layer that knows both axes AND may import from `render/`.
         visionImpaired: (pl) => {
@@ -1681,14 +1772,7 @@ export function createGame(o) {
             return !!v && (isBlind(v) || isLowVision(v));
         },
         getBlindMode: readBlindMode, LOGICAL_W,
-        // The player DERIVED from the focus: field 4 answering where the child is. A game that supplies no list still has
-        // the sonar, and that is what makes the accessibility stack not an accessory.
-        getPlayers: cartridge.sonarPlayers ?? (() => {
-            const f = cartridge.declaration.focusOf(0);
-            return f ? [{ i: 0, x: f.at.x, y: f.at.y, visual: DEFAULT_VISUAL }] : [];
-        }),
         getNumPlayers: () => (cartridge.players ?? [null]).length,
-        getAudioCtx: () => mixer.audioCtx, getSoundOn: () => mixer.soundOn, getAudioCat: () => mixer.audioCat,
         newContext: newAudioContext,
     });
     // 5. Remappable keyboard — the best cut of the base (finding 11): a key scheme, no world.
@@ -1768,6 +1852,8 @@ export function createGame(o) {
         // registered with the overlays, which cancels a running wizard without storing its map.
         closePadWiz: () => { overlays.closeById('padwiz'); },
         whichPlayer: (code) => keyboard.whichPlayer(code),
+        // this root's one screen: another seat's keys steer none of its menus (below, at the rule)
+        leadsTheScreen,
         actionOf: (code, i) => keyboard.actionOf(code, i),
         // Finding 12, SOLVED IN THE ENGINE: the port is generic over `WindowEventMap` (see `EventTargetLike` in
         // input/touch-bindings), so the real `window` goes straight in, with no adapter per consumer.
@@ -1794,6 +1880,7 @@ export function createGame(o) {
      * first is not what can be built first.
      */
     const blockKey = (e) => { e.preventDefault(); e.stopImmediatePropagation(); };
+    /** Takes the item the scan shows, for a press from `source`; answers whether one-button scanning took it (ADR-0218 §4). */
     let scanPress = null;
     win.addEventListener('keydown', (e) => {
         if (!state.switchScan || !scanPress || keyboard.whichPlayer(e.code) < 0)
@@ -1807,6 +1894,36 @@ export function createGame(o) {
         if (state.switchScan && scanPress && keyboard.whichPlayer(e.code) >= 0)
             blockKey(e);
     }, true);
+    /*
+     * 🔴 AND EVERY TOUCH ON THE GAME REGION (ADR-0218 §4) — and on the on-screen pad, wherever the host put it. Registered here
+     * for the key's reason: above the menus' own pointer listeners (a hold places the cursor, ADR-0159), the pad's and the game's,
+     * so one touch is one take and nothing else. The click the browser fires after it is swallowed too; a click the ENGINE sends
+     * — a menu's «confirm» pressing its item — is not, which is why `scanPress` clears the mark before every take.
+     * 📌 THE QUICK BAR STAYS ITSELF: ☝️ on it is the way OUT of one-button mode, and 📷 and 👄 turn the camera and voice transports
+     * on and off — the child's own switches, which a scan must not swallow (ADR-0218 erratum of 2026-09-26).
+     */
+    let swallowClick = false;
+    const scanTakesTouch = (target) => {
+        const el = target;
+        if (!state.switchScan || !scanPress || !el || typeof el.closest !== 'function')
+            return false;
+        const onTheBar = !!el.closest(`${ENGINE_CONTROLS_IN_PLAY}, .pause-icons`) || !!a11yBar?.contains(el);
+        return !onTheBar && !!el.closest('#game-region, #touch-controls');
+    };
+    win.addEventListener('pointerdown', (e) => {
+        swallowClick = false;
+        if (!scanTakesTouch(e.target))
+            return;
+        blockKey(e);
+        scanPress?.('toque');
+        swallowClick = true;
+    }, true);
+    win.addEventListener('pointerup', (e) => { if (scanTakesTouch(e.target))
+        blockKey(e); }, true);
+    win.addEventListener('click', (e) => { if (swallowClick) {
+        swallowClick = false;
+        blockKey(e);
+    } }, true);
     // ⚠️ AND NOW THE MENU NAVIGATION SWITCHES ON — after the block above, and the ORDER IS THE BEHAVIOUR: listeners on one
     // node run in registration order, so the scan sees the key first and can stop it. The other way round, one press would
     // move the menu AND take an item (ADR-0218). 🔴 No type sees a lost call: browser cases hold that the menus answer the
@@ -1963,8 +2080,8 @@ export function createGame(o) {
      * 📌 The name line is counted whether or not a name is showing — reserving only while pointing would move the game
      * under the child's finger. Measured again at every scale and every typography step: both change the text's size.
      * ⚠️ Zero without a bar: nothing to reserve.
-     * 📌 With a HUD (ADR-0175) the room also holds the two top columns — points and mission on the left, power on the right —
-     * when either reaches lower than the bar's room; each is narrowed so it never reaches the bar.
+     * 📌 With a HUD the room also holds the mission, centred just under the bar (ADR-0239 erratum), when it reaches lower than
+     * the bar's room. The rest of the HUD is the row at the bottom, measured with it.
      */
     function reserveBarBand() {
         reserveTopBand({
@@ -1973,6 +2090,18 @@ export function createGame(o) {
             hud: hudMounted,
             ...(typeof win.getComputedStyle === 'function' ? { computedStyle: (el) => win.getComputedStyle(el) } : {}),
         });
+        reserveRowBand();
+    }
+    /*
+     * THE HUD ROW AT THE BOTTOM (ADR-0239; issue #94): learning bars · the session clock · the power over the score · the game's
+     * map, left to right. The ROOT's, for its whole life — the clock lives in it and the session is the root's — and the bands
+     * of each cartridge go into its cells. Measured (`--hud-row-h`, `--hud-row-bottom`) at every measure of the top and at every
+     * tick of the clock: the on-screen pad shows and hides with the child's hands, and the row must stand above it.
+     */
+    const hudRow = mountHudRow(doc, $('#game-region'));
+    whenDisposed(() => { hudRow?.row.parentNode?.removeChild(hudRow.row); });
+    function reserveRowBand() {
+        reserveBottomBand({ region: $('#game-region'), row: hudRow?.row ?? null, pad: $('#touch-controls') });
     }
     /*
      * THE HUD the engine mounts from the cartridge's `hud` (ADR-0168; issue #162). Read on every animation frame while mounted —
@@ -1981,13 +2110,27 @@ export function createGame(o) {
      */
     let hudMounted = null;
     let hudFrame = false;
+    /*
+     * THE SESSION CLOCK (ADR-0236, ADR-0239, ADR-0050 §3; issue #94): a label over the time left in digits and a Time Timer pie,
+     * in the centre of the HUD row, for every cartridge — it measures the SESSION, which is this root's life, so a `mount()` does
+     * not restart it and only `dispose()` takes it away. It always shows, measures one hour and turns red at the end: nothing on
+     * the child's side sets it, and nothing about it is stored (ADR-0240).
+     */
+    const sessionClock = mountSessionClock({
+        doc, slot: hudRow?.clock ?? null, t: translator.t,
+        // as the host has them: a host with no clock mounts none, answered in the module (ADR-0232)
+        performance: win.performance, setInterval: win.setInterval, clearInterval: win.clearInterval,
+        announce: srSay, drawn: reserveRowBand,
+    });
+    whenDisposed(() => { sessionClock?.remove(); });
+    localeOn(() => { sessionClock?.refresh(); });
     function mountHud() {
         hudMounted?.remove();
         hudMounted = null;
         const regionEl = $('#game-region');
         const numbers = cartridge.hud ?? [];
         if (numbers.length && regionEl && typeof regionEl.appendChild === 'function')
-            hudMounted = mountHudBands(translator.t, doc, regionEl, numbers);
+            hudMounted = mountHudBands(translator, doc, regionEl, numbers, 0, hudRow ?? undefined);
         reserveBarBand();
         if (hudMounted && !hudFrame && typeof win.requestAnimationFrame === 'function') {
             hudFrame = true;
@@ -2215,8 +2358,15 @@ export function createGame(o) {
                 const classes = records.map((r) => r.target.classList);
                 if (classes.some((c) => c?.contains('screen-pause')))
                     updateCaption();
-                if (classes.some((c) => c?.contains('screen-pause') || c?.contains('overlay') || c?.contains('pause-menu')))
+                // the modal boundary follows the front card by ANY door, including a close that returns no focus (ADR-0130 rule 1)
+                if (classes.some((c) => c?.contains('screen-pause') || c?.contains('overlay')))
+                    overlays.syncLayers?.();
+                if (classes.some((c) => c?.contains('screen-pause') || c?.contains('overlay') || c?.contains('pause-menu'))) {
                     announceContext();
+                    // 🔴 THE NAMES A CHILD CAN SAY CHANGED (ADR-0194 §1): this is the one signal that a card, one of its lists or a panel
+                    // showed or hid — without it no menu's names reach the recogniser, and no name can be said.
+                    voiceControl?.refreshGrammar();
+                }
                 // ADR-0166: the pad leaves when the card or a panel opens, and comes back when the last of them closes
                 if (classes.some((c) => c?.contains('screen-pause') || c?.contains('overlay')))
                     reflectPadInMenus();
@@ -2225,6 +2375,16 @@ export function createGame(o) {
                     recomposeWorldFilter();
             }).observe(regionEl, { attributes: true, attributeFilter: ['hidden'], subtree: true });
         }
+        // ADR-0245: a footer explanation longer than its lines scrolls inside them, at the child's caption rate; reduced motion is the
+        // system's or the child's (any scene switch reduced: pages carry the same words, so a false «reduced» costs nothing)
+        if (regionEl && Observer && typeof win.getComputedStyle === 'function' && typeof doc.createRange === 'function') {
+            watchFooterScroll(regionEl, {
+                doc, getComputedStyle: (el) => win.getComputedStyle(el), MutationObserver: Observer,
+                setTimeout: (fn, ms) => win.setTimeout(fn, ms), clearTimeout: (id) => win.clearTimeout(id),
+                ppm: () => state.captionPpm,
+                reduced: () => defaultReducedMotion(win.matchMedia) || SCENE_KEYS.some((k) => sceneMotion[k]),
+            });
+        }
     }
     /*
      * THE SCREEN FOOTER: one column, at the bottom of the region, with the EXPLANATION of the pointed icon above the quick
@@ -2265,11 +2425,12 @@ export function createGame(o) {
      * «the sound caption above, the explanation below it»); `aria-hidden`, because whoever listens heard the sound itself.
      * 📌 Its time on screen is a child's reading time for its words, never under the 2600 ms the games had measured in play
      * (`core/caption-duration`, plan phase 5c); a new caption restarts it.
+     * 📌 Written while captions are on OR deaf mode is: in deaf mode every sound gets its caption (ADR-0234).
      */
     let soundCaption = null;
     let clearSoundCaption = null;
     function writeSoundCaption(text) {
-        if (!state.captionsOn || !text)
+        if (!deafMode.captionsOn() || !text)
             return;
         if (!soundCaption) {
             const home = screenFooter($('#game-region'));
@@ -2287,8 +2448,21 @@ export function createGame(o) {
             clearTimeout(clearSoundCaption);
         clearSoundCaption = setTimeout(() => { captionHome.hidden = true; captionHome.textContent = ''; }, captionDuration(text, state.captionPpm));
     }
-    /** The footer says ONE explanation at a time: the pointed icon's, or the reason a locked item is locked (ADR-0161). */
+    /**
+     * The footer says ONE explanation at a time: the pointed icon's, or the reason a locked item is locked (ADR-0161). `null` is
+     * the item leaving — and the band goes back to the game's text, not to empty (ADR-0244 §2).
+     */
     function writeInFooter(text) {
+        itemExplanation = text || null;
+        showExplanation();
+    }
+    /** The game's own explanation, its resting text (ADR-0244 §1); `null` clears it. Under a pointed engine item until it leaves. */
+    function explainForGame(text) {
+        gameExplanation = text || null;
+        showExplanation();
+    }
+    function showExplanation() {
+        const text = itemExplanation ?? gameExplanation;
         if (!barExplanation && text) {
             const home = screenFooter($('#game-region'));
             if (home) {
@@ -2330,30 +2504,61 @@ export function createGame(o) {
         if (!toOtherScreen)
             changePhase('playing');
     }
-    function toggleQuickPauseByStart(e) {
-        const seat = seatOfPosition(e.code, 'start');
-        if (seat === null)
-            return;
+    /**
+     * THE PAUSE IS PER SCREEN, AND A SHARED SCREEN'S IS ITS FIRST PLAYER'S (ADR-0144, erratum of 2026-09-26). This root draws ONE
+     * screen — one region, one pause card (`#vp-pause-0`), one quick bar (`getA11yBars`) — and every seat it seats plays on it, so
+     * its pause and its menus answer seat 0: START and SELECT from any other seat, by any transport, do nothing. A player with a
+     * screen of her own has a root of her own, and its pause. START asks this below and the pad's START on an open menu asks it
+     * too (`resume`); SELECT needs no question, because `openSeatMenus` opens the seat's own card and this root mounts seat 0's only.
+     * And INSIDE an open menu the same: `ui/menu-nav` and `input/gamepad` ask it before handing a seat the dialog on top or the
+     * card, so another seat's direction, confirm and back — by its keys, its pad, or a transport pressing the controller, whose
+     * press becomes that seat's key — move, press and close nothing, and reach no game under the menu either.
+     */
+    function leadsTheScreen(seat) {
+        return seat === 0;
+    }
+    /**
+     * START for a seat, by whatever door: the key below, or a transport pressing the virtual controller in play (`systemPress`,
+     * ADR-0144 §1 «from any transport»). Answers whether it acted — the key is consumed only then.
+     */
+    function startForSeat(seat) {
+        if (!leadsTheScreen(seat))
+            return false; // another seat of this screen: its START does nothing (ADR-0144 erratum)
         // GUARD 1 — A PANEL IS OPEN. With an overlay visible, `menuNavKey` receives the key, finds no intent in it and leaves
         // without consuming it. Without this guard the quick pause would open UNDER the panel the child is in. Escape closes
         // a panel, not START.
         if (overlays.topVisibleOverlay())
-            return;
+            return false;
         // START AGAIN LEAVES — the second way out of the mode that ADR-0044 item 7 already gave START.
         if (inQuickPause.has(seat)) {
             leaveQuickPause(seat, 'jogo');
-            e.preventDefault();
-            return;
+            return true;
         }
         // GUARD 2 — THE CARD IS OPEN. With it open and a «start» key other than `Enter`, `menuNavKey` finds no intent and
         // lets it through. Closing the card belongs to «Voltar ao jogo» and to Escape.
         const findPauseCard = $(`#vp-pause-${seat}`);
         if (findPauseCard && findPauseCard.hidden === false)
-            return;
+            return false;
         enterQuickPause(seat);
-        // 📌 AND ONLY HERE, once the key was in fact OURS. `Enter` is «start» by default (`input/default-bindings`), and
-        // without this the same press would pause AND activate whatever had focus.
-        e.preventDefault();
+        return true;
+    }
+    function toggleQuickPauseByStart(e) {
+        const seat = seatOfPosition(e.code, 'start');
+        if (seat === null)
+            return;
+        // GUARD 0 — THE KEY WAS TYPED INTO A FIELD. A text field owns Enter and every character, so `Enter` or `H` typed there is
+        // the field's and not START, on the way in and out alike (ADR-0111 erratum of 2026-09-26). Left undecided, so it types.
+        if (keyTypedIntoField(e.target))
+            return;
+        // GUARD 3 — THE KEY PRESSES THE ENGINE'S FOCUSED CONTROL. `Enter` is «start», and a focused button is activated by Enter as
+        // well as Space: on ☰ it is ☰'s press, not the pause (ADR-0111 erratum of 2026-09-26, one key one action). Left undecided
+        // here, so the browser clicks it. Only on the way IN: on the quick pause's own bar the leave keeps its meaning.
+        if (!inQuickPause.has(seat) && keyPressesOwnControl(e.code, e.target, ENGINE_CONTROLS_IN_PLAY))
+            return;
+        // 📌 CONSUMED ONLY when it was in fact OURS. `Enter` is «start» by default (`input/default-bindings`), and without this
+        // the same press would pause AND activate whatever had focus.
+        if (startForSeat(seat))
+            e.preventDefault();
     }
     win.addEventListener('keydown', toggleQuickPauseByStart);
     /*
@@ -2384,7 +2589,8 @@ export function createGame(o) {
     }
     function openMenusBySelect(e) {
         const seat = seatOfPosition(e.code, 'select');
-        if (seat === null)
+        // `F` typed into a field is a letter, not SELECT (ADR-0111 erratum of 2026-09-26): the field owns every character.
+        if (seat === null || keyTypedIntoField(e.target))
             return;
         if (openSeatMenus(seat))
             e.preventDefault();
@@ -2399,8 +2605,8 @@ export function createGame(o) {
         const seat = seatOfPosition(e.code, 'action4');
         if (seat === null || !inQuickPause.has(seat))
             return;
-        if (overlays.topVisibleOverlay())
-            return;
+        if (overlays.topVisibleOverlay() || keyTypedIntoField(e.target))
+            return; // a letter typed into a field
         leaveQuickPause(seat, 'cartao');
         pauseControls.show(seat);
         e.preventDefault();
@@ -2418,6 +2624,8 @@ export function createGame(o) {
      */
     const touchHostEl = o.host.touchHost ?? $('#game-region');
     const touchUsable = !!touchHostEl && typeof touchHostEl.appendChild === 'function';
+    // the HUD row and the footer stand above the pad from the frame it shows in, and come down in the frame it leaves (ADR-0239 §6)
+    whenDisposed(followThePad(touchHostEl, win.MutationObserver, reserveRowBand));
     const seat0CardOpen = () => {
         const c = $('#vp-pause-0');
         return !!c && c.hidden === false;
@@ -2437,9 +2645,7 @@ export function createGame(o) {
         eventTarget.dispatchEvent(stampSource(new KeyboardEvent('keydown', { code, key: code, bubbles: true, cancelable: true }), origin));
     };
     const labelledActions = () => {
-        const preset = cartridge.preset;
-        if (!preset)
-            return [];
+        const preset = actionWords();
         const labelOf = labellerFrom(preset);
         return presetActions(preset).flatMap((a) => {
             const label = labelOf(a);
@@ -2457,6 +2663,8 @@ export function createGame(o) {
         // buttons DIRECTLY (ADR-0166, which undid ADR-0157's «the pad stays over the menus»). The only two callers that show
         // the pad — the touch listener below and `reflectPadInMenus` — already ask `isMenuOpen()` first.
         padAllowed: () => players().length <= 1,
+        // each slot drawn by its size, five named positions or fewer a cycle row (ADR-0130 rule 3)
+        drawChoice: (spec, pick) => mountChoice({ find: (sel) => $(sel), create: (tag) => doc.createElement(tag) }, spec, pick),
     });
     /** A menu the child touches directly is open: the pause card or a settings panel (ADR-0166 rule 2). */
     function isMenuOpen() {
@@ -2490,7 +2698,7 @@ export function createGame(o) {
             return;
         }
         const padMap = touchPad.getTouchMap();
-        const short = cartridge.preset ? shortLabellerFrom(cartridge.preset) : () => null;
+        const short = shortLabellerFrom(actionWords());
         const pad = mountTouchControls({ find: (sel) => $(sel), create: (tag) => doc.createElement(tag), t: translator.t }, {
             map: padMap,
             gameActions: cartridgeActions(),
@@ -2539,6 +2747,8 @@ export function createGame(o) {
          */
         press: (action, source) => virtualController.press(action, source),
         release: (action, source) => virtualController.release(action, source),
+        // the RAW edge: the press above already recorded it and resolved touch's latch at the controller's `pressedBy`, so this only
+        // repeats an edge the automaton holds (ADR-0109 rule 3)
         playerEdge,
         heldKeys: keys,
         attractOnInput: () => false,
@@ -2628,6 +2838,8 @@ export function createGame(o) {
      * ⚠️ IT EXISTS ONLY WHERE THERE IS A TOUCH HOST: without one there is no pad size to choose, and the submenu's door
      * falls away by itself (`engineActions.motora` is not defined).
      */
+    /** The motor panel's mapping wizard, once mounted: declared out here because the pad's poll below stands aside while it maps. */
+    let padWizard = null;
     if (pauseMountPoint && pauseUsable && touchUsable) {
         const mobilityCtx = {
             find: (sel) => $(sel),
@@ -2701,11 +2913,10 @@ export function createGame(o) {
         const modeLabel = (m) => t(m === 1 ? 'motora.teclado.1' : m === 2 ? 'motora.teclado.2' : 'motora.teclado.34');
         const SIDES = ['leftShoulder', 'leftTrigger', 'rightShoulder', 'rightTrigger'];
         const actionsToMap = () => {
-            if (!cartridge.preset)
-                return [];
-            const word = labellerFrom(cartridge.preset);
-            return presetActions(cartridge.preset).flatMap((presetAction) => {
-                const actionWord = word(presetAction);
+            const words = actionWords();
+            const nameOf = labellerFrom(words);
+            return presetActions(words).flatMap((presetAction) => {
+                const actionWord = nameOf(presetAction);
                 return actionWord ? [{ action: presetAction, label: actionWord }] : [];
             });
         };
@@ -2831,18 +3042,30 @@ export function createGame(o) {
         };
         reflectKeyboardRows();
         /*
-         * MAPEAR CONTROLE (ADR-0151 §2; issue #182): the engine's own wizard (`input/pad-wizard`), asking only the positions this
-         * game names, in its words, and storing the map `initGamepad` reads — one cache for the page. It reads the pads only
-         * while it is open. «Voltar» cancels; the last named position saves and closes. The shell's «restore» is hidden: a pad's
-         * map is replaced by mapping again.
+         * MAPEAR CONTROLE (ADR-0151 §2; issue #182): the engine's own wizard (`input/pad-wizard`), asking the positions this
+         * game names, in its words, then START and SELECT in the engine's (ADR-0144 erratum of 2026-09-26 — this labeller is the
+         * preset's, which may not name them), and storing the map `initGamepad` reads — one cache for the page. It reads the pads
+         * only while it is open. «Voltar» cancels; SELECT, the last step, saves and closes. The shell's «restore» is hidden: a
+         * pad's map is replaced by mapping again.
+         * 🔴 ONE WIZARD OWNS THE PAD: the gamepad transport builds its own wizard too (the one that opens by itself on a DirectInput
+         * pad with no map), and each asks only about itself. So the root, which holds both, keeps them apart: while this one maps,
+         * the pad's poll does not run (below), and while that one maps, this row does not open a second.
+         */
+        /**
+         * One closer for «Voltar» and Escape: a running wizard is cancelled (and its close hides the panel); an idle one just hides.
+         * 🔴 WHICHEVER WIZARD IS MAPPING: the transport's own shows in this same overlay, and hiding it alone left that wizard
+         * mapping unseen — the game paused, the pad answering questions nobody showed, and its map stored at the end.
          */
-        let padWizard = null;
-        /** One closer for «Voltar» and Escape: a running wizard is cancelled (and its close hides the panel); an idle one just hides. */
         const closeControl = () => {
             if (padWizard?.state()) {
                 padWizard.close(false);
                 return;
             }
+            // its close hides the overlay, resumes the game it paused, and gives the focus back through `wizardClosed` (ADR-0248)
+            if (gamepad.getPadWiz()) {
+                gamepad.closePadWiz(false);
+                return;
+            }
             controlPanel.shell.overlay.hidden = true;
             overlays.restoreFocus?.('padwiz');
         };
@@ -2893,6 +3116,8 @@ export function createGame(o) {
         controlButton.setAttribute('type', 'button');
         controlButton.id = 'opt-controle';
         controlButton.addEventListener('click', () => {
+            if (gamepad.getPadWiz())
+                return; // the transport's own wizard is mapping a pad: it keeps it
             controlPanel.open();
             padWizard?.open();
         });
@@ -2902,7 +3127,8 @@ export function createGame(o) {
             controlStrong.textContent = t('motora.controle');
             controlButton.textContent = t('motora.abrir');
             controlButton.setAttribute('aria-label', t('motora.controle'));
-            controlMappingRow.hidden = actionsToMap().length === 0; // nothing named, nothing to map
+            // ⚠️ SHOWN FOR EVERY GAME: one that names no position gets the wizard's fourteen default positions (ADR-0144, erratum of
+            // 2026-09-26), so there is always something to map.
         };
         reflectControlRow();
         /*
@@ -2926,7 +3152,7 @@ export function createGame(o) {
         const hideSlotsWithoutAction = () => {
             const named = cartridgeActions();
             const padMap = touchPad.getTouchMap();
-            for (const sel of Array.from(touchPanel.shell.list.querySelectorAll('select[data-slot]'))) {
+            for (const sel of Array.from(touchPanel.shell.list.querySelectorAll('[data-slot]'))) {
                 const rowNode = sel.closest('.ctrl-row');
                 if (rowNode)
                     rowNode.hidden = !named.has(padMap[sel.dataset.slot ?? ''] ?? '');
@@ -2958,10 +3184,8 @@ export function createGame(o) {
          * 🔴 NO STICKY-KEYS ROW IN THIS PANEL (the Dev: «Tire a linha de acessibilidade motora»): the bar's ☝️ is the one
          * surface for that cycle (ADR-0218), and two surfaces of one setting was what the row had become.
          *
-         * ⚠️ The row was also the only place that said WHY the latch is locked on a device that sends one command at a time
-         * (ADR-0113 clause 3). It stays honest because the cycle does not OFFER what is locked: where the latch is required,
-         * «padrão» does not appear, and there is nothing to explain. The «Esperar entre toques» row (ADR-0217) stays: it is
-         * another setting.
+         * 📌 No device locks it any more (ADR-0249): on eyes, face, gestures and speech the latch starts as the game's `holdsKeys()`
+         * and the ☝️ offers all three positions there too. The «Esperar entre toques» row (ADR-0217) stays: it is another setting.
          */
         /*
          * «ESPERAR ENTRE TOQUES» (ADR-0217; GAG Advanced/Motor, issue #182). The row beside the sticky keys, and the other half of
@@ -3031,7 +3255,10 @@ export function createGame(o) {
                 return; // at the end of the line nothing moved, and nothing is announced
             state.setCameraControlValue(mode);
             reflectCamera();
-            srSay(`${t('motora.camera')}: ${t(CAMERA_MODE_WORD[mode])}`);
+            // 🔴 A MODE THAT STARTS IS ANNOUNCED BY ITS CONTROL, which answers once it has really started or says why it could not —
+            // the rule and its reason are at the 📷 in `ui/pause-icons`. Off is true at once, and is said here.
+            if (mode === 'off')
+                srSay(`${t('motora.camera')}: ${t('state.off')}`);
         });
         // the 📷 and this row are one setting: whoever changes it, both show it
         stateOn('cameraControl', () => { reflectCamera(); });
@@ -3058,10 +3285,12 @@ export function createGame(o) {
         };
         voiceButton.addEventListener('click', () => {
             state.setVoiceControlValue(!state.voiceControl);
-            // ⚠️ THE ANNOUNCEMENT READS THE STATE AFTER THE WRITE, and not the value it meant to write: what cannot start puts the
-            // answer back to off inside the same click, and announcing the intention would tell the child the opposite of what is true.
             reflectVoice();
-            srSay(`${t('motora.voz')}: ${t(state.voiceControl ? 'state.on' : 'state.off')}`);
+            // 🔴 ON IS ANNOUNCED BY `ui/voice-control`, which starts AFTER this click, asynchronously, and answers either way: ready,
+            // or the reason it could not start. Reading the state here still read «on», because the failure had not happened yet —
+            // the rule and its reason are at the 👄 in `ui/pause-icons`. Off is true at once, and is said here.
+            if (!state.voiceControl)
+                srSay(`${t('motora.voz')}: ${t('state.off')}`);
         });
         stateOn('voiceControl', () => { reflectVoice(); });
         reflectVoice();
@@ -3162,17 +3391,38 @@ export function createGame(o) {
      * 📌 The right channel is the one the function already has: `onHeavyProgress`, handed to whoever calls. A consumer who
      * wants to show «N MB left» or «the voice did not come down» has a way; the engine invents no surface.
      */
+    /*
+     * THE LIBRARY FONTS THIS GAME DECLARED (ADR-0255): their `@font-face` rules go into the document as soon as the catalogue
+     * loads, pointing at the delivery's `heavy/`, and their files are kept FIRST in the checked cache — a family the library does
+     * not hold, or the delivery did not carry, becomes a line of `problems`. No catalogue is loaded for a game that declared none.
+     */
+    const fontsStarted = libraryFonts.asked.length ? startLibraryFonts({
+        asked: libraryFonts.asked,
+        declare: (css) => { const sheet = doc.createElement('style'); sheet.id = 'incl-library-fonts'; sheet.textContent = css; (doc.head ?? doc.documentElement).appendChild(sheet); },
+        href: (url) => new URL(deliveryPath(url), doc.baseURI).href,
+        report: (line) => { if (!measuredProblems.includes(line))
+            measuredProblems.push(line); },
+    }) : null;
     if (o.downloadHeavy !== false) {
-        // ⚠️ THE READING MODEL IS ASKED FOR BY LANGUAGE and not by a yes: the three together are 850 MiB, and the child is reading in
-        // one of them. `bcp47()` is already the language the interface booted in (ADR-0031), so nothing new has to be decided here.
-        void downloadHeavy({
-            // 📌 AND THE COMMAND MODEL IS ASKED FOR WITHOUT ASKING THE GAME (issue #184): a child who says «menu» instead of pressing
-            // it is reaching the controller, and no cartridge declares — or denies — a way in (ADR-0111). A delivery built without
-            // `--commands` simply has none, this background fetch fails quietly, and the transport says so when she turns it on.
-            only: heavyAtBoot({ kokoro: !!o.uses?.neuralVoice, reading: o.uses?.reading ? bcp47() : null, commands: bcp47() }),
-            onProgress: o.onHeavyProgress,
+        // ⚠️ THE READING MODELS OF EVERY LANGUAGE THE PAGE CAN SWITCH TO, when the game listens (ADR-0225 erratum, the Dev:
+        // «Negativo, baixar os três. Toda criança vai experimentar as três línguas imediatamente.»). `bcp47()` is the language the
+        // interface booted in (ADR-0031), named first so everything of hers comes down before the 850 MiB of the three does.
+        const keepHeavy = (fonts) => downloadHeavy({
+            also: fonts?.files ?? [],
+            // 📌 AND THE COMMAND MODELS ARE ASKED FOR WITHOUT ASKING THE GAME (issue #184): a child who says «menu» instead of pressing
+            // it is reaching the controller, and no cartridge declares — or denies — a way in (ADR-0111). ONE PER LANGUAGE THE PAGE
+            // CAN SWITCH TO, the child's first (ADR-0225 erratum): a language changed mid-game, offline the next day, must find its
+            // model kept. A language the delivery's `--commands` left out fails quietly here, and the transport says so when she speaks.
+            // 📌 The Libras player only while deaf mode is on (ADR-0234): the delivery's list of its avatar, clips, glosses and three.js,
+            // which a child who never asks for signing does not pay — and which keep it signing on the days without a network.
+            only: heavyAtBoot({
+                kokoro: !!o.uses?.neuralVoice, reading: o.uses?.reading ? [bcp47(), ...availableLocales()] : null,
+                commands: [bcp47(), ...availableLocales()], libras: deafMode.isOn(),
+            }),
+            onProgress: (r) => { fonts?.onReport(r); o.onHeavyProgress?.(r); },
             cacheStorage: heavyCaches, fetch: win.fetch, digest: sha256With(win.crypto?.subtle), base: doc.baseURI,
-        })
+        });
+        void (fontsStarted ? fontsStarted.then(keepHeavy) : keepHeavy(null))
             .catch(() => { });
     }
     /*
@@ -3192,22 +3442,16 @@ export function createGame(o) {
     // absent value becomes `{}` — the cartridge that did not answer — and is refused below with ADR-0153's sentence, never
     // with a TypeError on `hooks.preset`.
     function mountAll(declaration, hooks = {}) {
-        // ⚠️ IT THROWS, IT DOES NOT DIAGNOSE — the boot's rule, and so the boot's sentence. A malformed declaration is a
-        // precondition: `problems` is for gaps one can still play with, and this is not one.
-        const malformed = conformanceProblems(declaration);
-        if (malformed.length) {
-            refuseDeclaration('mount', malformed);
-        }
-        // ⚠️ AND `mount()` REFUSES BY THE SAME RULES, before writing to `cartridge`. `CartridgeHooks` is
-        // `Omit<GameHalf, 'declaration'>`, so it carries `preset` — a second cartridge could take the «start» the first one
-        // respected, and the root would be left with the pause unreachable mid-session.
-        refuseIfItClaimsStart('mount', hooks.preset);
-        refuseIfNoAnswer('mount', hooks.accommodations);
-        refuseIfGenreRefused('mount', hooks.genre);
-        refuseIfHudMalformed('mount', hooks.hud);
-        refuseIfOptionsMalformed('mount', hooks.gameOptions);
-        refuseIfHowToPlayMalformed('mount', hooks.howToPlay);
+        // ⚠️ IT THROWS, IT DOES NOT DIAGNOSE — the boot's rule, and so the boot's list and sentence (`cartridgeRefusals`). A
+        // malformed cartridge is a precondition: `problems` is for gaps one can still play with, and this is not one. And it
+        // refuses BEFORE writing to `cartridge`: `CartridgeHooks` carries `preset`, so a second cartridge could take the
+        // «start» the first one respected, and the root would be left with the pause unreachable mid-session.
+        refuseCartridge('mount', declaration, hooks);
         cartridge = { ...hooks, declaration };
+        explainForGame(null); // the explanation was the replaced cartridge's (ADR-0244)
+        // its words, before anything draws them: ADDED to the root's dictionary, so the keys a shell registered at boot stay
+        for (const [code, entries] of Object.entries(hooks.dictionaries ?? {}))
+            translator.registerDict(code, entries);
         mountHud(); // the numbers are the cartridge's: the new one's replace the old one's, and the room is measured again
         followCartridgeMappings(declaration);
         redrawGameOptions(); // the rows are the new cartridge's, drawn or cleared before its door is weighed
@@ -3286,11 +3530,42 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
      * vocabulary (ADR-0216): a method only this file calls has no business in a contract seven repositories read.
      */
     let closeReadingThread = () => { };
+    // the command recogniser's bundle, put in the page once and shared by the 👄 and a choice by voice
+    const voskBundle = createBundleLoader((url) => import(/* @vite-ignore */ url));
+    // one command model per language, loaded once for the 👄 and a choice alike, ended with the root (ADR-0220, ADR-0256)
+    const voskModels = keepVoskModels(loadVoskRuntime);
+    whenDisposed(() => { voskModels.closeAll(); });
+    /*
+     * A CHOICE AMONG THE OPTIONS THE GAME SHOWS (ADR-0256): heard by the command recogniser with a grammar of exactly those options,
+     * and the 👄 paused meanwhile — one ear per word. Not tied to `uses.reading`: the command models are asked of every delivery. A
+     * device with no microphone or no model is told by the chooser itself, in `problems` and to the game.
+     */
+    const chooser = createVoiceChooser({
+        language: () => bcp47(),
+        open: openWithCommandRecogniser({
+            base: doc.baseURI, hasFile: hasHeavyFile, loadBundle: voskBundle, fetch: (url) => win.fetch(url),
+            getUserMedia, createContext: () => new HostAudioContext(), load: voskModels.load,
+        }),
+        // the 👄 already listening in the options' language lends its ear: no second model, no second microphone
+        borrow: (language, grammar, onHeard) => voiceControl?.borrow(language, grammar, onHeard) ?? null,
+        after: (fn, ms) => win.setTimeout(fn, ms),
+        cancel: (h) => win.clearTimeout(h),
+        report: (line) => { if (!measuredProblems.includes(line))
+            measuredProblems.push(line); },
+        // `apply(false)` stops without writing the child's stored answer (ADR-0220), so resuming is applying that answer again
+        pause: () => { void voiceControl?.apply(false); },
+        resume: () => { void voiceControl?.apply(state.voiceControl); },
+    });
     const reading = (() => {
         const browserApis = win;
         let microphone = null;
-        /** The reading thread, kept between readings (opening it compiles the model again) and let go with the game. */
-        let readingThread = null;
+        /**
+         * The reading thread, ONE PER LANGUAGE and kept between readings — opening it compiles the model again, up to 378 MiB — and let
+         * go with the game (`platform/reading-in-worker.keepOneThreadPerLanguage`, built at the first reading with the module).
+         */
+        let readingThreads = null;
+        let readingRuntimes = null;
+        closeReadingThread = () => { readingThreads?.close(); readingRuntimes?.close(); };
         const listener = createReading({
             language: () => bcp47(),
             api: (browserApis.SpeechRecognition ?? browserApis.webkitSpeechRecognition ?? null),
@@ -3299,6 +3574,7 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
             stopEvery: (h) => win.clearInterval(h),
             report: (rowNode) => { if (!measuredProblems.includes(rowNode))
                 measuredProblems.push(rowNode); },
+            chooser,
             /**
              * THE ENGINE'S OWN RECOGNISER, and it arrives late on purpose (ADR-0216 §5): `platform/reading-runtime` is what names the
              * model files, so a game that never listens — and a child of a game that does, until the first `listen()` — loads none of
@@ -3322,31 +3598,45 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
                      */
                     const Worker = browserApis.Worker;
                     if (typeof Worker === 'function') {
-                        const { createReadingInWorker } = await import('../platform/reading-in-worker.js');
-                        readingThread?.close();
-                        readingThread = createReadingInWorker({
+                        const { createReadingInWorker, keepOneThreadPerLanguage } = await import('../platform/reading-in-worker.js');
+                        // 🔴 THE SAME LANGUAGE REUSES ITS THREAD: this port is asked at EVERY `listen()`, and it used to close and reopen the
+                        // thread each time — recompiling up to 378 MiB per reading. Another language closes the old one and opens hers.
+                        readingThreads ??= keepOneThreadPerLanguage();
+                        return readingThreads.forLanguage(language, (failed) => createReadingInWorker({
                             base: doc.baseURI,
                             language,
                             spawn: () => new Worker(new URL('../platform/reading-worker.js', import.meta.url), { type: 'module' }),
                             // 📌 THE SENTENCE IS WRITTEN HERE and the module hands over only the REASON: a thread that fails to open when
                             // nobody is waiting for the answer had nowhere to be said (ADR-0169), and whoever knows what the child loses
-                            // is the diagnostic channel, not a thread's protocol.
+                            // is the diagnostic channel, not a thread's protocol. It names BOTH fixes, since `--reading <language>` alone
+                            // would now narrow the delivery (ADR-0225 erratum) — and the child is told too, not only the adult.
                             report: (reason) => {
-                                const line = `reading: the transcription thread could not open — ${reason}; a child who reads aloud `
-                                    + 'gets no answer, and nothing else in the page will say so — check that the reading model for this '
-                                    + 'language reached `heavy/` (npx inclusionist-heavy --reading <language>)';
+                                failed(); // forgotten: the next reading opens it again, the model may have come down since
+                                const line = `reading: the transcription thread could not open for ${language} — ${reason}; a child who reads `
+                                    + 'aloud in this language gets no answer — build the delivery with `npx inclusionist-heavy --reading` alone (it '
+                                    + `carries every language) or with \`--reading ${language.split('-')[0].toLowerCase()}\` in its list, and open `
+                                    + 'the game once online so the install fetches it';
                                 if (!measuredProblems.includes(line))
                                     measuredProblems.push(line);
+                                srAlert(t('sr.reading.failed'));
                             },
-                        });
-                        closeReadingThread = () => { readingThread?.close(); readingThread = null; };
-                        return readingThread;
+                        }));
                     }
-                    measuredProblems.push('reading: this browser has no `Worker`, so the transcription runs on the same thread that '
+                    const sameThreadLine = 'reading: this browser has no `Worker`, so the transcription runs on the same thread that '
                         + 'draws the game and feeds the microphone — measured, that cuts the recording in gaps of seconds and the child '
-                        + 'loses the words she said meanwhile; serve the game where workers are available');
-                    const { loadReadingRuntime } = await import('../platform/reading-runtime.js');
-                    return loadReadingRuntime({ base: doc.baseURI, language, fetch: (url) => win.fetch(url) });
+                        + 'loses the words she said meanwhile; serve the game where workers are available';
+                    if (!measuredProblems.includes(sameThreadLine))
+                        measuredProblems.push(sameThreadLine);
+                    // 🔴 ONE RUNTIME PER LANGUAGE HERE TOO (issue #185): loading it at every `listen()` fetched and compiled up to 378 MiB per
+                    // reading, on the very thread that draws the game. A switch loads hers; a load that failed is forgotten and tried again.
+                    const { keepOneThreadPerLanguage } = await import('../platform/reading-in-worker.js');
+                    readingRuntimes ??= keepOneThreadPerLanguage();
+                    return readingRuntimes.forLanguage(language, (failed) => {
+                        const runtime = import('../platform/reading-runtime.js')
+                            .then(({ loadReadingRuntime }) => loadReadingRuntime({ base: doc.baseURI, language, fetch: (url) => win.fetch(url) }));
+                        runtime.catch(() => failed()); // the reading that asked still hears the reason: it awaits this same promise
+                        return { runtime, close: () => { } };
+                    }).runtime;
                 }
                 : undefined,
             /**
@@ -3368,6 +3658,7 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         return {
             ready: () => (o.uses?.reading ? listener.ready() : Promise.resolve({ can: false, why: 'no-model' })),
             stop: () => listener.stop(),
+            choose: (options, settings) => listener.choose(options, settings),
             listen: (options) => {
                 if (!o.uses?.reading) {
                     if (!measuredProblems.includes(notDeclared))
@@ -3392,52 +3683,90 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
     /*
      * THE SCAN ITSELF (ADR-0218): the list is the positions this cartridge declared AND NAMED, because the chip says the game's
      * own words and a position nobody named would cost the child a pass of silence (ADR-0074). It is rebuilt every time the scan
-     * starts, so a `mount()` of another cartridge scans ITS positions and not the ones that booted first (ADR-0142).
+     * starts, so a `mount()` of another cartridge scans ITS positions and not the ones that booted first (ADR-0142). After them come
+     * the engine's own doors, «menu» (SELECT) and «pausar» (START), each only where it has something behind it (ADR-0218 §3).
+     *
+     * 🔴 AND INSIDE A MENU THE LIST IS THAT MENU'S STEPS (ADR-0218 erratum of 2026-09-26). The switch's key is stopped before any
+     * listener, so no menu ever saw it: 📏 a child who opened the quick pause by scanning was left in it, every press doing nothing.
+     * With the quick bar, the card or a panel in front, the scan offers «cancel · next · confirm · back · previous» and a press
+     * moves the menu through `ui/menu-nav`, the path the keys and the pad take. On a panel's control with a value — a slider, a
+     * list, a ⯇ ⯈ row — the pass also offers «increase» and «decrease», the right and left keys' step (`menuScanFor`).
      */
     const gameRegion = $('#game-region');
     const scanChip = gameRegion ? mountScanOverlay(doc, gameRegion) : null;
-    let scanner = null;
+    let scanning = null;
     let scanFrame = 0;
-    const scanWord = (item) => scanItemText(item, (a) => (cartridge.preset ? labellerFrom(cartridge.preset)(a) : null), t('scan.nothing'));
+    // «Is a menu in front?» is the question the virtual controller asks (`menuWithDpad`): the quick pause, the card or a panel.
+    const freshScan = () => {
+        if (menuWithDpad()) {
+            const cursor = nav.underCursor(0);
+            return { inMenu: true, cursor, pass: createSwitchScan(menuScanFor(cursor)) };
+        }
+        const words = actionWords();
+        const names = labellerFrom(words);
+        // the ENGINE'S DOORS after the game's words (ADR-0218 §3): the card where it is mounted, the quick pause where it has its bar
+        const doors = { menus: pauseUsable, quickPause: barUsable };
+        return { inMenu: false, pass: createSwitchScan(playScanList(presetActions(words).filter((a) => !!names(a)), doors)) };
+    };
+    const scanWord = (item) => scanItemText(item, labellerFrom(actionWords()), t);
     // A word of a different length is a different amount of room to keep free, so the band is measured again — and only then.
     const scanShow = (item) => { if (scanChip?.showing(scanWord(item)))
         reserveBarBand(); };
     const scanTick = () => {
-        if (!scanner)
+        if (!scanning)
             return;
-        scanShow(scanner(win.performance.now()).showing.item);
+        // 📌 A MENU OPENED OR CLOSED, OR ITS CURSOR REACHED A CONTROL OF ANOTHER KIND: the pass becomes the other list, from
+        // «cancel», which is also what a press does — so the first thing offered in a menu just opened is the item that takes nothing.
+        if (scanning.inMenu !== menuWithDpad() || (scanning.inMenu && scanning.cursor !== nav.underCursor(0)))
+            scanning = freshScan();
+        scanShow(scanning.pass(win.performance.now()).showing.item);
         scanFrame = win.requestAnimationFrame(scanTick);
     };
     const stopScan = () => {
         if (scanFrame)
             win.cancelAnimationFrame(scanFrame);
         scanFrame = 0;
-        scanner = null;
+        scanning = null;
         scanChip?.hide();
         reserveBarBand(); // the room the chip was keeping goes back to the game
     };
     const startScan = () => {
-        if (scanner)
+        if (scanning)
             return;
-        const names = cartridge.preset ? labellerFrom(cartridge.preset) : null;
-        const offered = (cartridge.preset ? presetActions(cartridge.preset) : []).filter((a) => !!names?.(a));
-        scanner = createSwitchScan(offered);
+        scanning = freshScan();
         scanTick();
     };
+    /** The scan is pressing the controller itself: that press is the position it took, and must not be taken again. */
+    let scanIsPressing = false;
     scanPress = (source) => {
-        if (!scanner)
-            return;
+        if (!scanning || scanIsPressing)
+            return false;
+        swallowClick = false; // a click this take sends — a menu's «confirm» — is the take's, not a touch's (see the pointer above)
         // 📌 THE CHIP IS NOT REDRAWN HERE, and a surviving mutation is why: the frame loop above draws every frame, so a second
         // drawing path only saved the sixteen milliseconds until the next one — a line that could disagree with the loop and could
         // never be seen doing it.
-        const out = scanner(win.performance.now(), { press: true });
-        const action = out.commanded;
+        const now = win.performance.now();
+        if (scanning.inMenu) {
+            // THE MENU MOVES BY ITS OWN PATH: the step is the intent a key with that meaning carries, handed to `ui/menu-nav` as seat 0.
+            const step = scanning.pass(now, { press: true }).commanded;
+            if (step)
+                nav.navIntent(0, menuStepKeys(step));
+            return true;
+        }
+        const action = scanning.pass(now, { press: true }).commanded;
         if (!action)
-            return;
-        // 📌 THROUGH THE VIRTUAL CONTROLLER, like every other transport (ADR-0111): in a menu it becomes that menu's key, in play it
-        // holds the child's key and reaches the cartridge. The scan decides WHICH position; it does not decide what a position does.
-        virtualController.press(action, source, 0);
+            return true; // «cancel»: the press was taken, and means nothing
+        // 📌 THROUGH THE VIRTUAL CONTROLLER, like every other transport (ADR-0111): in play it holds the child's key and reaches the
+        // cartridge. The scan decides WHICH position; it does not decide what a position does.
+        scanIsPressing = true;
+        try {
+            virtualController.press(action, source, 0);
+        }
+        finally {
+            scanIsPressing = false;
+        }
         win.setTimeout(() => virtualController.release(action, source, 0), SWITCH_SCAN_DEFAULTS.pulseMs);
+        return true;
     };
     stateOn('switchScan', (on) => { if (on)
         startScan();
@@ -3446,13 +3775,43 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
     whenDisposed(stopScan); // the scan's frames are this root's, and an ended root keeps none running (ADR-0220)
     if (state.switchScan)
         startScan();
+    /*
+     * 🔴 THE DEVICE IN USE AND ITS LATCH, AT ONE DOOR (ADR-0109 rule 3, ADR-0113, ADR-0249). Every transport that plays presses
+     * this controller — the keyboard conductor below (`teclado`), the on-screen pad (`toque`), the gamepad, the eyes, the face,
+     * the hands, the voice — so its `pressedBy` is where the root hears «the child is using this device now». Each press is that
+     * device's edge: the seat's transport automaton moves to it, and the seat's latch is resolved again for it — the child's
+     * stored choice for that transport, else its default: the MOUNTED game's `holdsKeys()` read now on the four one-command
+     * transports (a platform game keeps walking on «direita», a quiz's «abaixo» presses once), the factory's on the keyboard, the
+     * pad and touch. So a key after a spoken word brings back the keyboard's latch, and the ☝️ writes under the keyboard.
+     * ⚠️ EVERY TRANSPORT, not one hook per transport: a transport this door did not hear would leave the automaton on the device
+     * the child put down, and play would go on under that device's latch — in silence. The seats are the ones the bar's ☝️
+     * writes (`PausePlayer`, the same cast).
+     */
+    const transportEdge = createLatchedEdge(() => players(), {
+        input, store, holdsKeys: () => cartridge.declaration.holdsKeys(),
+    });
     const virtualController = createVirtualController({
+        // told first, for every press that names its transport: the edge and the latch of the device that pressed
+        pressedBy: (source, seat) => { transportEdge(seat, source); },
         scheme: (i) => keyboard.kbFor(i), menuOpen: menuWithDpad,
-        // ⚠️ `markKeyFrom` AND NOT RAW `markKey`: a key that arrives WITHOUT a source — which is every real keyboard event —
-        // must ERASE whoever held it last instead of inheriting them (ADR-0109). The choice between the two doors lives in
-        // `input/state`.
+        // ⚠️ `markKeyFrom` AND NOT RAW `markKey`: a key that arrives WITHOUT a source — a synthetic key nobody stamped — must ERASE
+        // whoever held it last instead of inheriting them (ADR-0109). The choice between the two doors lives in `input/state`.
         holdKey: markKeyFrom,
         releaseKey: releaseKey, menuKey: keyToMenu, deliver: deliverCommand,
+        // With a menu open the game hears no press, so the engine answers the sonar there: R1 reads the menu in front, spoken or,
+        // in deaf mode, captioned and signed — the same two doors the play sonar's words take (ADR-0234). Any seat's R1 reads it,
+        // though only the first steers the menu (ADR-0144), and a reading takes turns with the other seats' (ADR-0234 errata).
+        menuAnswers: (action, seat) => menuSonarPress(action, screen, (text) => { srSay(text); deafMode.sonar(text, seat); }),
+        // START and SELECT from a transport with no key in the world — the eyes, the face, the hands, the voice, the scan — do what
+        // the keys do, for the seat that pressed (ADR-0144 §1, ADR-0155): in play and in the quick pause alike, so START there
+        // always LEAVES, whatever key the child bound first to `start` (ADR-0144 erratum of 2026-09-26).
+        systemPress: (action, seat) => { if (action === 'start')
+            startForSeat(seat);
+        else
+            openSeatMenus(seat); },
+        // 🔴 WITH ONE BUTTON ONLY ON, EVERY PRESS HERE IS THE SWITCH (ADR-0218 §4): the eyes, the face, the hands, the voice, the
+        // on-screen pad and the gamepad press this controller, so asking here is asking once for all of them.
+        takeShown: (source) => !!scanPress?.(source),
     });
     /*
      * 🔴 THE KEYBOARD CONDUCTOR, AND ONLY THAT (ADR-0223). It resolves the action and PRESSES the virtual controller, like the
@@ -3466,6 +3825,11 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
      *
      * 📌 And it does not ask whether a menu is open. That question has ONE answer, the controller's; what makes it true
      * for the keyboard is `keyToMenu` above, which does not redispatch a key that is already in the world.
+     *
+     * 🔴 ONE KEY PRESS IS ONE ACTION (ADR-0111 errata of 2026-09-26), from both sides. A key the game HEARD is spent: its browser
+     * default is cancelled, or Space on a focused button was the game's `action2` AND the button's click. A key that went to
+     * something else — a field being typed into, the engine's own control it activates — is not also played: `input/key-default`
+     * says which, and the controller holds it back from play (with a menu open it is the menu's either way).
      */
     for (const kind of ['keydown', 'keyup']) {
         win.addEventListener(kind, (e) => {
@@ -3480,12 +3844,23 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
             if (seat < 0)
                 return;
             const action = keyboard.actionOf(e.code, seat);
-            if (!action)
+            // ⚠️ START AND SELECT ARE NOT PRESSED HERE: their key is answered by the engine's own listeners above, which run for a
+            // cartridge with no `onCommand` too — pressed here as well, the controller would open the pause a second time (ADR-0144).
+            if (!action || action === 'start' || action === 'select')
                 return;
-            if (kind === 'keydown')
-                virtualController.press(action, source, seat);
-            else
+            if (kind === 'keyup') {
                 virtualController.release(action, source, seat);
+                return;
+            }
+            // 🔴 A KEY THE MENUS CONSUMED IS NOT ALSO PLAYED (ADR-0111 erratum of 2026-09-26). `nav.attach()` put `menuNavKey` on this
+            // window's capture first, so it has already decided — and a key that CLOSED the last menu (resume, «no» at the card's
+            // root, a panel's «Voltar») leaves the controller no menu to see: 📏 Space on resume resumed AND answered the quiz.
+            // 📌 And the key that ends print mode is print's: its listener runs after this one, so it is asked by its state (see there).
+            if (nav.consumed(e) || printArmed)
+                return;
+            const toPlay = keyGoesToGame(e.code, e.target, ENGINE_CONTROLS_IN_PLAY);
+            if (virtualController.press(action, source, seat, toPlay))
+                e.preventDefault();
         }, true);
     }
     /*
@@ -3521,17 +3896,20 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         getGamepads: () => win.navigator?.getGamepads?.() ?? [],
         // THE GAME'S WORD for a position: the engine knows the position exists, only the cartridge knows what it is called —
         // and it already declared that in the `preset` to exist.
-        actionLabel: (action) => (cartridge.preset ? labellerFrom(cartridge.preset)(action) : null),
+        actionLabel: (action) => labellerFrom(actionWords())(action),
         srSay, srAlert,
         frontOverlay: overlays.frontOverlay,
         // ⚠️ «PAUSE MENU» HERE IS EVERY MENU WITH A DIRECTIONAL, not only the card: the transport's `steerPause` already
         // handles the shared dialog before the card, which is the panel open on top. The same question the controller asks.
         pauseMenu: menuWithDpad,
         worldRunning: gameHooks.worldRunning,
-        // The gamepad's START is the QUICK PAUSE (ADR-0155), like the screen's; and the way out reuses the decision already
-        // written for the finger, which knows leaving the quick pause from closing the card.
+        // The pad's START in play is PRESSED for its seat and answered by `systemPress` (ADR-0144 §1); this `pause` is the mapping
+        // wizard's, which stops the game while a pad is mapped. The way out on the card and on seat 0's quick pause reuses the
+        // decision already written for the finger, which knows leaving the quick pause from closing the card — for the screen's
+        // first seat only: another seat's START there does nothing (ADR-0144, erratum of 2026-09-26).
         pause: () => { enterQuickPause(0); },
-        resume: togglePauseByTouch,
+        resume: (seat) => { if (leadsTheScreen(seat))
+            togglePauseByTouch(); },
         isAttractActive: gameHooks.attractActive,
         stopAttract: gameHooks.stopAttract,
         // A PHYSICAL button makes the on-screen pad vanish — the same per-modality switch as the keyboard.
@@ -3548,12 +3926,16 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         navBar,
         sharedDialogOpen: nav.sharedDialogOpen,
         navDialog: nav.navDialog,
+        leadsTheScreen, // another seat's pad steers none of this screen's menus, as its keys do not
         getPauseMenu: (i) => $(`#vp-pause-${i}`),
         navPause: nav.navPause,
         setPauseActor,
+        // the RAW edge: every pad press already reached the controller's `pressedBy`, which recorded it and resolved the pad's latch
         playerEdge,
         press: (action, source, player) => virtualController.press(action, source, player),
         release: (action, source, player) => virtualController.release(action, source, player),
+        // the pad also steers menus and the pause without pressing a position, so it asks the scan's question itself (ADR-0218 §4)
+        takeShown: () => !!scanPress?.('gamepad'),
         modalInput: gameHooks.modalInput,
         hasModal: gameHooks.hasModal,
         joinPlayer: gameHooks.joinPlayer,
@@ -3561,6 +3943,9 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         clearWaitingBadge: gameHooks.clearWaitingBadge,
         wizardStep: gameHooks.wizardStep,
         wizardTick: gameHooks.wizardTick,
+        // the root's answer, not a game's: its own wizard closed however it ended, and the focus goes back to whoever held it
+        // when that wizard opened — the same return the panel's wizard makes (ADR-0248)
+        wizardClosed: () => { overlays.restoreFocus?.('padwiz'); },
     });
     /*
      * AND THE ENGINE POLLS, because whoever mounts polls. ⚠️ The game loop is the CARTRIDGE's (`core/loop.startLoop` is
@@ -3569,7 +3954,10 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
      */
     let padFrameHandle = 0;
     const anyPadConnected = () => (win.navigator?.getGamepads?.() ?? []).some(Boolean);
-    const pollPad = () => { gamepad.pollPads(); padFrameHandle = win.requestAnimationFrame(pollPad); };
+    // 📌 While the motor panel's wizard maps, the pads talk only to it (the transport asks only about its own wizard): read
+    // under it, an unmapped DirectInput pad opened a second wizard on the same pad, and a standard pad steered the menus.
+    const pollPad = () => { if (!padWizard?.state())
+        gamepad.pollPads(); padFrameHandle = win.requestAnimationFrame(pollPad); };
     const stopPollingPad = () => { if (padFrameHandle)
         win.cancelAnimationFrame(padFrameHandle); padFrameHandle = 0; };
     /*
@@ -3616,37 +4004,37 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
      * PLAYING BY SPEAKING (ADR-0189, ADR-0193, ADR-0194; issue #184): the stored 👄 drives `ui/voice-control` — the recogniser
      * from the delivery, the microphone that stays open, and presses stamped `fala` on the virtual controller.
      *
-     * 📌 THE GRAMMAR FOLLOWS THE OPEN MENU: the names the child can see are the names she can say. They are read from the overlay
-     * on top, which is the same one the focus trap and the menu navigation already treat as «the menu that is open».
+     * 📌 THE GRAMMAR FOLLOWS THE OPEN MENU: the names the child can see are the names she can say, and a name heard activates
+     * its item (ADR-0194 §2). Both are asked of the MENU NAVIGATION for seat 0 — the seat the voice presses — so the names are
+     * those of the menu a confirm would reach (the panel on top, else the pause card), and saying one puts that navigation's
+     * cursor on it before the voice confirms through the virtual controller. The grammar is re-read when a card, a list of it or
+     * a panel shows or hides — the region's observer above.
      */
     if (canCaptureMedia) {
-        const menuWords = () => {
-            const card = overlays.topVisibleOverlay();
-            if (!card)
-                return [];
-            return [...card.querySelectorAll('button, [data-passos]')]
-                .filter((el) => !el.hidden && el.getAttribute('aria-disabled') !== 'true')
-                .map((el) => accessibleLabel(el))
-                .filter((s) => s.length > 1);
-        };
         voiceControl = createVoiceControl({
-            t: translator.t, base: doc.baseURI, language: () => bcp47(), controller: virtualController, menuWords,
+            t: translator.t, base: doc.baseURI, language: () => bcp47(), controller: virtualController,
+            menuWords: () => nav.itemNames(0), pointAt: (name) => nav.pointAt(name, 0),
+            // with one button only on, a word heard is the switch and nothing else: a name is not pointed at (ADR-0218 §4)
+            oneButtonOnly: () => state.switchScan,
             say: srSay, alert: srAlert,
             report: (line) => { if (!measuredProblems.includes(line))
                 measuredProblems.push(line); },
             turnOff: () => { state.setVoiceControlValue(false); },
             after: (fn, ms) => { win.setTimeout(fn, ms); },
             // ⚠️ THE ADDRESS IS ABSOLUTE AND THE BUNDLER MUST NOT FOLLOW IT: the recogniser arrives with the delivery at runtime.
-            hasFile: hasHeavyFile, loadBundle: createBundleLoader((url) => import(/* @vite-ignore */ url)),
+            hasFile: hasHeavyFile, loadBundle: voskBundle, loadRuntime: voskModels.load,
+            // the model's vocabulary is read from its archive, so a menu name the model cannot hear is a line of `problems` (ADR-0194 §4)
+            fetch: (url) => win.fetch(url),
             getUserMedia, createContext: () => new HostAudioContext(),
         });
         stateOn('voiceControl', (on) => { void voiceControl?.apply(on); });
-        // the words change with the menu that is open, and a menu opens on a key or a touch — so they are re-read on every draw of
-        // the bar, which is what already happens whenever a card or a panel appears (ADR-0106 §5)
-        stateOn('menuIndexOn', () => { voiceControl?.refreshGrammar(); });
-        void voiceControl.apply(state.voiceControl);
-        // and so does the microphone; pply(false) stops without writing the stored answer, which belongs to the child (ADR-0220)
-        whenDisposed(() => { void voiceControl?.apply(false); });
+        // 📌 A STORED 👄 STARTS ONCE THE STORED LANGUAGE HAS APPLIED: started before, it opened the boot language's model and then the
+        // child's — two workers and ~40 MiB unpacked for nothing on every English or Spanish boot (measured on 2026-09-27)
+        let voiceEnded = false;
+        void translator.ready().then(() => { if (!voiceEnded)
+            void voiceControl?.apply(state.voiceControl); }, () => { });
+        // and so does the microphone; `apply(false)` stops without writing the stored answer, which belongs to the child (ADR-0220)
+        whenDisposed(() => { voiceEnded = true; void voiceControl?.apply(false); });
     }
     /*
     /*
@@ -3667,8 +4055,13 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         closeReadingThread();
         followCartridgeMappings(null);
         removeReachNotice();
+        // the released cartridge's explanation goes with it: the next one has not explained anything yet (ADR-0244)
+        explainForGame(null);
         hudMounted?.remove();
         hudMounted = null;
+        // the map was the released cartridge's; the next one mounts its own (ADR-0239)
+        while (hudRow?.map.firstChild)
+            hudRow.map.removeChild(hudRow.map.firstChild);
         reserveBarBand();
         // ⚠️ `pop()` AND NOT A `clear()`: each `exit()` is that scene's DOM cleanup, and skipping it would leave on the page
         // what the previous cartridge drew. The loop ends because `pop()` returns `null` on an empty stack.
@@ -3693,15 +4086,19 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         tts,
         reading,
         captionSound: writeSoundCaption,
+        explain: explainForGame,
         gameSpeed: () => state.gameSpeed,
         menuIndexOn: () => state.menuIndexOn,
         t: translator.t,
         localeReady: translator.ready,
+        locale: translator.locale,
+        setLocale: translator.setLocale,
         say: srSay,
         alert: srAlert,
         mirrorAnnouncements: announcer.mirrorTo,
-        libras: { isOpen: libras.isOpen, say: libras.say, tick: libras.tick, toggle: () => { libras.toggle(translator.t); } },
+        deafMode: { isOn: deafMode.isOn, toggle: deafMode.toggle, captionsOn: deafMode.captionsOn },
         settings: state,
+        mapSlot: hudRow?.map ?? null,
         input,
         keyboardConfig,
         audio: mixer,
@@ -3717,7 +4114,11 @@ unstyled, so a child who plays by keyboard cannot see where focus is — link th
         scenes: rootScenes,
         onLocaleChange: (fn) => { localeListeners.push(fn); },
         cvdFilters,
-        get problems() { return [...hostProblems, ...stylesheetMissing(), ...measureCartridgeProblems(), ...translator.dictionaryGaps(), ...measuredProblems, ...storageOutsideScope()]; },
+        get problems() {
+            return [...hostProblems, ...stylesheetMissing(), ...measureCartridgeProblems(), ...translator.dictionaryGaps(),
+                ...missingDeclaredKeys(cartridge, translator.declares), ...measuredProblems, ...storageOutsideScope(),
+                ...unreadableWorldProblems(screen)];
+        },
         onFailure: announceFailure,
         get reach() { return currentReach; },
     };