@the-inclusionist/engine 9.0.0 → 10.0.0

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

@@ -1,743 +1,3724 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-// boot/create-game — O TESTE DE FRONTEIRA DO ADR-0027 (passo 4), escrito em vez de discutido.
+// boot/create-game — THE BOUNDARY TEST OF ADR-0027 (step 4), written instead of argued.
 //
-// ========================= A PERGUNTA QUE ESTE ARQUIVO EXISTE PARA RESPONDER =========================
-// O ADR-0027 pôs um veredito e não o deixou vago:
+// ========================= THE QUESTION THIS FILE EXISTS TO ANSWER =========================
+// ADR-0027 set a verdict and did not leave it vague: if `createGame()` could not be written without a parameter
+// called `coinTarget`, the boundary that record proposed was wrong, and its steps 5 to 7 could not begin.
 //
-//     "se `createGame()` não puder ser escrito sem um parâmetro chamado `coinTarget`, a fronteira que este
-//      registro propõe está errada e os passos 5 a 7 NÃO PODEM COMEÇAR."
+// It can. There is no `coinTarget` here, and not out of discipline: ADR-0030 settled where the target comes from —
+// field 5 of the contract (`objectiveOf`). The HUD that asked for a coin count asks the game how many of how many, and
+// the coin stops being an engine word. `tests/boot-create-game.node.test.js` holds this.
 //
-// Pode. Não há `coinTarget` aqui, e não é por disciplina — é porque o ADR-0030 resolveu de onde o alvo vem:
-// campo 5 do contrato (`objectiveOf`). O HUD que pedia um número de moedas passa a perguntar ao jogo quantas
-// de quantas, e "moeda" deixa de ser palavra da engine. `tests/boot-create-game.node.test.js` prende isso.
+// ========================= WHAT THIS IS: THE ORDER =========================
+// Not a framework. It is the sequence that switches the engine on, which every consumer would otherwise rewrite by
+// hand — and the second consumer measured the price of rewriting it (`consumer-quiz`, findings 3, 6 and 12):
 //
-// ========================= O QUE ISTO É: A ORDEM, E O QUE FALTA =========================
-// Não é um framework. É a sequência de ligar a engine, que hoje cada consumidor reescreve à mão — e o segundo
-// consumidor mediu o preço de reescrevê-la (`consumer-quiz`, achados 3, 6 e 12):
+//  · FINDING 3 — the mixer MUST be loaded before `createTts`, or `audioCat` is null and `narrate` gives up
+//    SILENTLY. An order dependency no type declared, found by the silence. Here it cannot be got wrong: `createAudio`
+//    loads the mixer as it is built, and the voice is built after it.
+//  · FINDING 6 — the panels need fixed ids in the document and, when they are missing, OPEN EMPTY, with no error.
+//    Here the engine builds its panels, and what the page lacks becomes `problems`, a list the consumer can read.
+//  · FINDING 12 — every consumer wrote the same one-line adapter for `window`. Written once.
 //
-//  · ACHADO 3 — `initAudioMixer()` TEM de rodar antes de `createTts`, senão `audioCat` é null e o `narrate`
-//    desiste CALADO. Uma dependência de ordem que nenhum tipo declara e que se descobre pelo silêncio. Aqui
-//    ela é impossível de errar: quem chama não escolhe a ordem.
-//  · ACHADO 6 — os painéis exigem ids fixos no documento (`#typo`, `#typo-list`…) e, quando faltam, ABREM
-//    VAZIOS. Sem erro. Aqui a falta vira `problems`, que é uma lista que o consumidor pode ler e mostrar.
-//  · ACHADO 12 — todo consumidor escreve o mesmo adaptador de uma linha para o `window`. Escrito uma vez.
+// And one finding that only appeared when this function tried to boot against an injected document:
 //
-// E um achado NOVO, que só apareceu quando esta função tentou bootar contra um documento injetado:
+//  · 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.
 //
-//  · ACHADO 15 — `initI18n()` chamava `applyDom(document)`, o GLOBAL, por baixo de quem a chamasse. Num
-//    navegador dá no mesmo e por isso sobreviveu; num teste de lógica pura é a diferença entre bootar e não
-//    bootar, e num futuro com dois documentos (uma engine em iframe, um editor ao lado do jogo) seria a
-//    diferença entre traduzir o documento certo e o outro. Consertado no mesmo passo: `initI18n(root)`, com
-//    o global como padrão, exatamente como `applyDom` já fazia.
+// ========================= DECLINING IS NOT LYING =========================
+// The quiz declined the sonar and the pad instead of inventing tiles and a fake collision box, and that distinction
+// separates a finding from a false green. Here it becomes a TYPE: a game without a piece says so in a field instead
+// of returning `null` from a getter and hoping. What is declined is kept in the returned object, so a consumer can be
+// audited by what it refused.
+// ⚠️ THIS PARAGRAPH NAMES NONE OF THE FIELDS, which looks odd and is deliberate: `tests/no-decline-is-dead` counts
+// MENTIONS, comments included, on purpose — erring towards «alive» is the right direction for that error, because a
+// false accusation switches a gate off. So using a decline as an EXAMPLE in prose makes it look read, and a field
+// that is genuinely dead stops being accused.
 //
-// ========================= DECLINAR NÃO É MENTIR =========================
-// O quiz recusou o sonar e o pad em vez de inventar tiles e uma caixa de colisão falsos, e essa distinção é o
-// que separa um achado de um verde falso. Aqui ela vira TIPO: um jogo que não tem uma peça declara-o num
-// campo em vez de devolver `null` de um getter e torcer. O que se declina fica registrado no objeto devolvido,
-// e um consumidor pode ser auditado pelo que recusou.
-// ⚠️ E ESTE PARÁGRAFO NÃO NOMEIA NENHUM DOS CAMPOS, o que parece esquisito e é medido: o
-// `tests/declinio-morto` conta MENÇÕES, incluindo as de comentário, e fá-lo de propósito — «falhar para o lado
-// de vivo é a direcção certa deste erro», porque uma acusação falsa desliga um gate. A consequência é que usar
-// um declínio como EXEMPLO em prosa o faz parecer lido, e um campo genuinamente morto deixa de ser acusado.
-// 📌 O primeiro rascunho desta nota fez exactamente isso, e o crivo apanhou-o no mesmo minuto.
-//
-// ========================= O QUE ISTO AINDA NÃO FAZ, DITO AQUI E NÃO ESCONDIDO =========================
-// Não liga render, física, tiles nem o sonar — nada disso é de todo jogo, e o achado 9 mostra que o sonar hoje
-// exige seis coisas de plataforma. Não substitui o boot do `main.js`, que tem catorze anos de ordem própria.
-// O que ele cobre é o que o quiz provou ser IDÊNTICO em qualquer jogo: idioma, leitor de tela, mixer, voz,
-// pilha de diálogos, filtros de daltonismo, teclado remapeável e navegação de menu.
-import { initI18n, idiomaPronto } from '../core/i18n.js';
-import { entradaDe } from '../input/state.js';
-import { criarAvisoDeQueda } from '../ui/loop-crash.js';
-import { initFocusTrap, focaveisNoDom } from '../ui/focus-trap.js';
-import { mostrarAvisoDeAlcance, REACH_NOTICE_ID } from '../ui/reach-notice.js';
-import { alcance, transportesPadrao } from '../input/transports.js';
-import { presetActions, ACTIONS } from '../core/actions.js';
-import { t } from '../core/i18n.js';
-import { srSay, srAlert } from '../core/a11y-sr.js';
-import { initPauseIcons, iconsMarkup } from '../ui/pause-icons.js';
-// O módulo INTEIRO: o on do barramento de eventos, para a barra montada continuar a dizer a verdade.
-import * as state from '../core/state.js';
-import { vlibrasOpen, toggleLibras } from '../ui/vlibras.js';
+// ========================= WHAT THIS DOES NOT DO =========================
+// It does not start a renderer, physics or tiles, nor the game loop: none of that belongs to every game, and the loop
+// is the cartridge's (`core/loop.startLoop`, called by the game). It does not mount `ui/shell`, the phase machine of a
+// 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 { localeHostHooks, exposeI18n } from '../platform/locale-host.js';
+import { createInputState } from '../input/state.js';
+import { initTouch, mountTouchControls, touchGaps } from '../input/touch.js';
+import { initTouchBindings } from '../input/touch-bindings.js';
+import { createCrashNotice } from '../ui/loop-crash.js';
+import { sampleFlashes } from '../platform/flash-sampler.js';
+import { initFocusTrap, focusablesInDom } from '../ui/focus-trap.js';
+import { showReachNotice, REACH_NOTICE_ID } from '../ui/reach-notice.js';
+import { reach, defaultTransports } from '../input/transports.js';
+import { accommodationAnswersProblems, subjectWord } from '../core/accommodations.js';
+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 { 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 { 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 { initSettingsControls } from '../ui/settings-controls.js';
+import { keyName } from '../ui/control-choices.js';
+import { reserveTopBand } from '../ui/top-band.js';
+// The settings store's FACTORY: this root builds the one store it, its modules and its game read (ADR-0232 D4).
+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 { conformanceProblems } from '../core/contract.js';
-import { criarPilha } from '../core/scenes.js';
+import { createSceneStack } from '../core/scenes.js';
 import { createTts } from '../platform/tts.js';
-import { ensureAC, catNode, audioOut, soundOn, volume, audioCat, initAudioMixer, tonePan, audioCtx, setCatGain } from '../platform/audio.js';
+import { createReading } from '../platform/reading.js';
+import { createAudio } from '../platform/audio.js';
 import { createAudioSonar } from '../platform/audio-sonar.js';
-// A raiz é a camada que PODE conhecer os dois eixos: `render/` está abaixo dela, e é dela a tarefa de
-// responder ao `platform/audio-sonar`, que não pode importar daqui sem inverter uma aresta (#104).
-import { ehCego, ehBaixaVisao, PADRAO } from '../render/viz-axes.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';
+// 📌 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';
+// 📏 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.
+import { stageScale, applyScale } from '../ui/layout.js';
+import { screenBaseSize } from '../core/screens.js';
 import { OVERLAY_SCOPE_SELECTOR } from '../ui/settings-panel.js';
+import { drawnBelowTheFloor, barIntruderProblems } from '../ui/drawing-problems.js';
+import { createListenerScope } from '../platform/listener-scope.js';
 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.
+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 { 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 { 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 { initSettingsVisual } from '../ui/settings-visual.js';
+import { initSettingsEmpathy } from '../ui/settings-empathy.js';
+import { HC_ROLE_DEF } from '../render/hc-role-data.js';
+import { createLqFilter } from '../render/lq-filter.js';
+import { createCrt } from '../render/crt.js';
+import { initSettingsAudio, mountAudioInside, mountSoundInside } from '../ui/settings-audio.js';
+import { AUDIO_CATS } from '../platform/audio-mixer.js';
+import { toggleBtn, toggleLabel } from '../ui/dom.js';
+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 { gameOptionsProblems, drawGameOptions } from '../ui/game-options.js';
+import { createStorage, keysOutsideScopes } from '../platform/storage.js';
+import { KEYS } from '../platform/storage-keys.js';
 import { initMenuNav } from '../ui/menu-nav.js';
+// 🔴 THE GAMEPAD IS MOUNTED HERE (ADR-0224), like every other transport — no longer by the cartridge.
+import { initGamepad, padGameAnswers, seatEveryPlayer } from '../input/gamepad.js';
+import { whereTheChildIs } from '../ui/where-the-child-is.js';
+import { createSimulationOverTheWorld } from '../ui/simulation-over-the-world.js';
+import { createSimulationList } from '../ui/simulation-list.js';
+import { showOnlyRowsThatApply } from '../ui/audio-rows-that-apply.js';
 import { initKeyboardRuntime } from '../input/keyboard-runtime.js';
-import { kb, initKB, registrarMapeamentoDoTeclado } from '../input/keyboard.js';
-import { registrarMapeamentoDoPad } from '../input/pad-defaults.js';
-import { baixarPesados } from '../platform/pesados.js';
+import { createKeyboardConfig } from '../input/keyboard.js';
+import { createPadTable } from '../input/pad-defaults.js';
+import { downloadHeavy, heavyAtBoot } 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
+ * (file://, private modes): a host with no storage, whose reads give their fallbacks.
+ */
+function hostStorage(host) {
+    if (host.storage)
+        return host.storage;
+    try {
+        return host.win.localStorage ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/*
+ * ONE SENTENCE FOR BOTH REFUSALS.
+ *
+ * ⚠️ The boot and `mount()` refuse a malformed declaration for the SAME reason, so with the same sentence: two copies
+ * of a sentence are two places for it to drift, and a second translation to do when pillar 3 reaches it (the i18n
+ * gate caps this module's raw text).
+ */
+function refuseDeclaration(who, problemas) {
+    throw new Error(`${who}: declaração malformada — ${problemas.join('; ')}`);
+}
 /*
- * UMA FRASE SÓ PARA AS DUAS RECUSAS, e o gate do pilar 3 é que a pediu.
+ * «start» BELONGS TO THE PAUSE, AND A CARTRIDGE DOES NOT TAKE IT (ADR-0144 §4).
  *
- * ⚠️ O arranque e o `mount()` recusam uma declaração malformada pela MESMA razão e com a mesma frase, e
- * escrevê-la duas vezes fez o teto de texto cru deste módulo subir de 15 para 16 — o crivo de i18n reprovou,
- * e reprovou com razão. Duas cópias de uma frase são dois sítios para ela divergir, e é também a segunda
- * tradução a fazer quando o pilar 3 chegar aqui.
+ * ⚠️ 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.
+ *
+ * ⚠️ 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.
  */
-function recusarDeclaracao(quem, problemas) {
-    throw new Error(`${quem}: declaração malformada — ${problemas.join('; ')}`);
+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);
 }
-/** Os ids que os painéis emprestados exigem do documento. Achado 6: sem eles o painel abre VAZIO, sem erro. */
-const MARCACAO_EXIGIDA = ['#game-region', '#sr-status', '#sr-alert'];
 /**
- * Onde a engine procura a barra de acessibilidade quando o jogo não declara `host.a11yBarHost`.
+ * 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);
+}
+/** 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);
+}
+/** 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'];
+/**
+ * Where the engine looks for the accessibility bar when the game does not declare `host.a11yBarHost`.
+ *
+ * ⚠️ NOT IN `REQUIRED_MARKUP` on purpose, and the difference is one of message, not of rigour. That list produces «the
+ * page lacks #x», which is what one says of an id the game forgot. What is missing here is not an id — it is the whole
+ * 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';
+/**
+ * Switches the engine on for a declared game.
  *
- * ⚠️ NÃO ENTROU NA `MARCACAO_EXIGIDA` de propósito, e a diferença é de mensagem e não de rigor. Aquela lista
- * produz «marcação ausente: #x», que é o que se diz de um id que o jogo esqueceu. Aqui o que falta não é um
- * id — é a barra inteira, e cinco jogos do catálogo não a têm porque ninguém lhes disse que a deviam ter. A
- * frase própria pode explicar O QUE se perde, e é isso que a torna útil a quem a lê pela primeira vez.
+ * ⚠️ THROWS if the declaration is malformed, and does NOT throw if markup is missing. The difference is not taste: a
+ * wrong declaration is a PROGRAM defect, and a game that runs half-declared is worse than one that does not open; a
+ * missing id is a gap of the HOST, and the quiz proved that switching on only the part that serves is legitimate —
+ * that is how it declined the pad and the sonar without lying. So one becomes an exception and the other `problems`.
  */
-const SELETOR_BARRA_A11Y = '#title-icons';
 export function createGame(o) {
     /*
-     * O CARTUCHO CORRENTE, e por enquanto ele É as opções que chegaram.
+     * THE CURRENT CARTRIDGE, which starts as the options that arrived.
      *
-     * ⚠️ Este passo não muda comportamento nenhum: `cartucho` começa como o próprio `o`, então toda leitura
-     * abaixo devolve exatamente o que devolvia. O que ele compra é o LUGAR onde `mount()` vai escrever
-     * (ADR-0142) — sem ele, as trinta e seis leituras da metade do jogo estão presas ao argumento, e uma raiz
-     * de composição a servir vários cartuchos ficaria com o primeiro deles para sempre.
+     * 📌 Every read of the game's half goes through `cartridge`, which is the PLACE `mount()` writes (ADR-0142): a read
+     * tied to the argument would leave a root serving several cartridges with the first of them forever.
      */
-    let cartucho = o;
-    const problemasDoContrato = conformanceProblems(cartucho.declaration);
-    if (problemasDoContrato.length) {
-        recusarDeclaracao('createGame', problemasDoContrato);
+    let cartridge = o;
+    const contractProblems = conformanceProblems(cartridge.declaration);
+    if (contractProblems.length) {
+        refuseDeclaration('createGame', contractProblems);
     }
-    const { doc, win } = o.host;
+    refuseIfItClaimsStart('createGame', cartridge.preset);
+    refuseIfNoAnswer('createGame', cartridge.accommodations);
+    refuseIfGenreRefused('createGame', cartridge.genre);
+    refuseIfHudMalformed('createGame', cartridge.hud);
+    refuseIfOptionsMalformed('createGame', cartridge.gameOptions);
+    refuseIfHowToPlayMalformed('createGame', cartridge.howToPlay);
+    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
+     * window and, until this line existed, NOTHING COULD TAKE THEM OFF. A root whose host was removed from the document kept
+     * listening, and because every query it makes is document-wide (`getPauseMenu` below is `doc.querySelector('#vp-pause-0')`) it
+     * drove the NEXT root's pause card: measured in the browser, one ArrowDown moved the cursor one item with one root, two with a
+     * second, three with a third. `dispose()` is the end of life this had never had. See `platform/listener-scope`.
+     */
+    const listeners = createListenerScope(o.host.win);
+    const win = listeners.win;
+    /*
+     * 🔴 AND THE REST OF WHAT THIS ROOT HOLDS ENDS WITH IT (ADR-0220): the window's scope never saw the STATE BUS, which keeps
+     * its subscribers for the whole page. So every `state.on` of this root goes through `stateOn`, and whatever a subscription
+     * started (the scan's frames, the recogniser, the camera) hands its stop to `whenDisposed`. `dispose()` runs them all;
+     * `unmount()` runs none, because it releases the cartridge and the root goes on hearing (ADR-0142).
+     */
+    const endOfLife = [];
+    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).
+     */
+    const translator = createTranslator();
+    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 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`.
+     */
+    const store = createStorage(hostStorage(o.host));
+    // 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 });
+    // THIS ROOT'S INPUT STATE (ADR-0232 D4): held keys and their sources, the transport in use per player, the pads' frames.
+    // 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);
     /*
-     * ⚠️ LEITOR E NÃO INSTANTÂNEO — terceira vez que este ficheiro comete e conserta o mesmo padrão, depois do
-     * `seguraTeclas` e do `players`. `declines` é da metade do JOGO (ADR-0139, errata de 2026-09-11: é o
-     * cartucho que declara o que NÃO tem), então um `const` tirado no arranque devolve, depois de um `mount()`,
-     * os declínios do cartucho anterior — e um declínio lido errado esconde uma linha de `problems` ou
-     * inventa outra.
+     * ⚠️ 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
+     * decline read wrong hides a line of `problems` or invents one.
      *
-     * 📌 O vazio é uma constante e não um literal por chamada: `declines()` é lido em sítios que comparam.
+     * 📌 The empty value is a constant and not a literal per call: `declines()` is read in places that compare.
      */
-    const SEM_DECLINIOS = {};
-    const declines = () => cartucho.declines ?? SEM_DECLINIOS;
-    const problemasDoHospedeiro = [];
+    const NO_DECLINES = {};
+    const declines = () => cartridge.declines ?? NO_DECLINES;
+    const hostProblems = [];
     const $ = (sel) => doc.querySelector(sel);
     const $$ = (sel) => [...doc.querySelectorAll(sel)];
-    for (const sel of MARCACAO_EXIGIDA) {
+    /*
+     * 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.
+     */
+    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() });
+    for (const sel of REQUIRED_MARKUP) {
         if (!$(sel))
-            problemasDoHospedeiro.push(`marcação ausente: ${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`);
     }
-    // ⚠️ O MUNDO DECLARADO TEM DE EXISTIR NO DOCUMENTO, e esta é a falha que o ADR-0087 deixaria aberta se
-    // parasse na conformidade. `conformanceProblems` confere a FORMA — que há um seletor e que ele não está
-    // vazio — e não tem como conferir se ele CASA alguma coisa, porque `core/contract` é puro e não vê DOM.
+    // ⚠️ THE DECLARED WORLD MUST EXIST IN THE DOCUMENT, the gap ADR-0087 would leave open if it stopped at conformance.
+    // `conformanceProblems` checks the SHAPE — that there is a selector and it is not empty — and cannot check whether it
+    // MATCHES anything, because `core/contract` is pure and sees no DOM.
     //
-    // Um seletor com erro de digitação (`#gaem-region`) passa na conformidade e produz exatamente o defeito
-    // que o registro existe para eliminar: a simulação de empatia aplicada a NADA, e um adulto informado de
-    // que sentiu algo que não sentiu. É um problema do HOSPEDEIRO e não do programa, então entra em
-    // `problems` como as marcações — o jogo abre, e quem o integrou lê que o mundo dele não está lá.
-    /*
-     * AS TRÊS LINHAS DE `problems` QUE DEPENDEM DO CARTUCHO, juntas e recalculáveis.
-     *
-     * 📏 Medido: das oito que esta raiz produz, CINCO são sobre a PÁGINA — marcação ausente, sem host de
-     * filtros, sem barra de acessibilidade, uma barra que não aceita conteúdo, sem sítio para a pausa — e
-     * essas não mexem quando se troca de jogo, porque não é o jogo que as causa. Só estas três mexem.
-     *
-     * ⚠️ E é por isso que `problems` não podia continuar a ser UM array construído no arranque: metade dele
-     * descreve o hospedeiro e vale para sempre, a outra metade descreve um cartucho e caduca no `mount()`.
-     * Recalcular tudo apagaria diagnósticos do hospedeiro que ninguém consertou; não recalcular nada deixaria
-     * o diagnóstico a falar do jogo errado.
-     */
-    function problemasDoCartucho() {
-        const p = [];
-        // O mundo declarado tem de existir na página — e quem o declara é o jogo, não o hospedeiro.
-        const mundo = cartucho.declaration.world();
-        if (mundo.kind === 'element' && !$(mundo.selector)) {
-            p.push(`mundo declarado não encontrado: ${mundo.selector}`);
-        }
-        // ⚠️ MISTA, e fica deste lado por causa da segunda metade: a porta é do hospedeiro
-        // (`carregarVozNeural`), mas o declínio é do CARTUCHO — logo a linha pode aparecer ou calar-se ao
-        // trocar de jogo, com o mesmo hospedeiro.
-        if (!o.carregarVozNeural && !declines().semVozNeural) {
-            p.push('sem voz neural: declare `carregarVozNeural` (uma linha — ver ADR-0094) ou `declines.semVozNeural`. '
-                + 'Sem ela a criança que não lê fica com a voz do sistema, que em Chromebook de escola pode não existir '
-                + 'em português');
-        }
-        const assentos = (cartucho.players ?? []).length;
-        if (assentos > 1 && !declines().semAtorDePausa && !cartucho.setPauseActor) {
-            p.push(`declarou ${assentos} jogadores e não registra o ator da pausa: o painel de controle edita sempre o `
-                + 'assento 0, então ninguém além do primeiro consegue remapear. Declare `declines.semAtorDePausa` se '
-                + 'for de propósito');
-        }
-        return p;
+    // A selector with a typo (`#gaem-region`) passes conformance and produces exactly the defect that record exists to
+    // remove: the empathy simulation applied to NOTHING, and an adult told they felt something they did not. It is a
+    // HOST problem and not a program one, so it goes into `problems` like the markup — the game opens, and whoever
+    // integrated it reads that their world is not there.
+    /*
+     * `problems` HAS TWO HALVES. The HOST's lines (`hostProblems`) are measured once at boot and hold for as long as the
+     * page does: they are about the page, not the game, and do not change when a cartridge is swapped. The CARTRIDGE's
+     * lines are measured again at every read, so they follow `mount()`. Recomputing everything would drop host
+     * diagnoses nobody fixed; recomputing nothing would leave the diagnosis talking about the wrong game.
+     */
+    /**
+     * The VIRTUAL CONTROLLER's gaps for this cartridge. Starts empty and is replaced once the pad is mounted, below:
+     * `measureCartridgeProblems` runs only when `problems` is read, after boot, but reading the pad from here before it
+     * exists would fall into the temporal dead zone.
+     */
+    let padGapProblems = () => [];
+    /*
+     * 🔴 THE RULES LIVE IN `core/cartridge-problems` (ADR-0221 step 7c). What stays here is MEASURING the page and answering
+     * that module; what is a decision — the rules, the order of the lines, when to keep quiet — lives where a sentence can
+     * be read whole. A composition root is big on purpose and carries WIRING; branches are logic, and ADR-0221's erratum
+     * measures a root's debt in branches.
+     */
+    function measureCartridgeProblems() {
+        const declaredWorld = cartridge.declaration.world();
+        const worldCssSelector = declaredWorld.kind === 'element' ? declaredWorld.selector : null;
+        return cartridgeProblems({
+            padGaps: padGapProblems(),
+            resizedRegion: regionResizedByCartridge(),
+            drawnBelowFloor: drawnBelowTheFloor(drawingContext),
+            genreWarning: genreWarning(cartridge.genre),
+        }, {
+            worldSelector: worldCssSelector,
+            worldIsInPage: !!worldCssSelector && !!$(worldCssSelector),
+            wantsNeuralVoice: !!o.uses?.neuralVoice,
+            declinesNeuralVoice: !!declines().noNeuralVoice,
+            seats: (cartridge.players ?? []).length,
+            setsPauseActor: !!cartridge.setPauseActor,
+            declinesPauseActor: !!declines().noPauseActor,
+        });
     }
-    // 1. IDIOMA ANTES DE TUDO. A interface não pode ser construída antes de a língua ser conhecida — foi o que
-    //    o item 14 consertou movendo `initI18n()` para o topo do boot. O documento entra: ver o achado 15.
+    // 1. LANGUAGE BEFORE EVERYTHING. The interface cannot be built before the language is known. The document goes in:
+    //    see finding 15.
     initI18n(doc);
-    // 2. MIXER ANTES DA VOZ. O achado 3, virado sequência: quem chama não tem como inverter estas duas linhas.
-    initAudioMixer();
+    translator.applyDom(doc); // the host's markup, with THIS game's dictionary too — the module's pass reads only the page's
+    // 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
+    //    synthesis the voice speaks through. The sonar's per-player contexts come from the same maker.
+    const audioHost = win;
+    const newAudioContext = () => {
+        const AC = audioHost.AudioContext ?? audioHost.webkitAudioContext;
+        return AC ? new AC() : null;
+    };
+    const speechHost = win;
+    const speech = {
+        synth: () => speechHost.speechSynthesis ?? null,
+        utterance: (text) => new speechHost.SpeechSynthesisUtterance(text),
+    };
+    /*
+     * 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
+     * game that never speaks neurally never loads a byte of them — which is the whole reason this is an `import()` and not an
+     * import. The page's address, `fetch` and WebAssembly are the host's.
+     */
+    const wasmHost = win.WebAssembly;
+    const loadKokoro = () => import('../platform/kokoro-runtime.js').then((m) => m.loadKokoroRuntime({
+        base: doc.baseURI,
+        fetch: (url) => win.fetch(url),
+        compileWasm: (bytes) => wasmHost.compile(bytes),
+        instantiateWasm: (module, imports) => wasmHost.instantiate(module, imports),
+    }));
+    const mixer = createAudio({ newContext: newAudioContext, store });
+    const { ensureAC, catNode, audioOut, setSoundOn, setVolume, tonePan, setCatGain, setHearingLossGraph } = mixer;
     const tts = createTts({
-        srSay, srAlert, ensureAC, catNode, audioOut,
-        getSoundOn: () => soundOn, getVolume: () => volume, getAudioCat: () => audioCat,
-        carregarVozNeural: o.carregarVozNeural,
+        store, translator, srSay, srAlert, ensureAC, catNode, audioOut,
+        getSoundOn: () => mixer.soundOn, getVolume: () => mixer.volume, getAudioCat: () => mixer.audioCat,
+        neuralVoice: !!o.uses?.neuralVoice, // ADR-0216 §3: the game says it wants one; the engine loads it
+        loadKokoro,
+        getSpeechPpm: () => state.speechPpm, // ADR-0183 §1: the child's speech rate
+        createAudio: () => doc.createElement('audio'),
+        speech,
+        now: () => win.performance.now(),
     });
-    // 📌 A linha da voz neural mudou-se para `problemasDoCartucho()`: o declínio que a cala é do jogo.
+    // 📌 The neural-voice line lives in `measureCartridgeProblems()`: the decline that silences it is the game's.
     /**
-     * O FILTRO DE VISÃO, aplicado ao MUNDO QUE O JOGO DECLAROU (ADR-0087).
+     * THE VISION FILTER, applied to THE WORLD THE GAME DECLARED (ADR-0087).
      *
-     * ⚠️ E A REGRA DOS MENUS É UMA GENERALIZAÇÃO, não uma segunda regra. O jogo próprio da engine limpava o
-     * filtro em `#dom-layer` porque ele está DENTRO de `#game-region` e um filtro CSS herda — sem isso, uma
-     * simulação de cegueira apagaria o menu de pausa e trancaria a criança dentro dela (#82). O 15-puzzle não
-     * tem nada dentro, e a mesma linha não faz nada. Um só código serve às duas formas porque ele pergunta ao
-     * DOM em vez de assumir a forma: limpa o filtro nos overlays que ESTEJAM dentro do mundo.
+     * ⚠️ THE RULE OF MENUS IS A GENERALISATION, not a second rule. A CSS filter is inherited, so a menu inside the world
+     * would be filtered with it — a blindness simulation would black out the pause menu and lock the child inside it
+     * (#82). A world with nothing inside it (the 15-puzzle) is untouched by the same line. One code serves both shapes
+     * because it asks the DOM instead of assuming the shape: it clears the filter on the overlays that ARE inside the
+     * world.
      *
-     * ⚠️ `{kind:'none'}` NÃO APLICA NADA. Uma atividade sem espaço não tem mundo para simular, e pintar um
-     * filtro sobre ela seria a mentira que o ADR-0087 existe para impedir, só que ao contrário.
+     * ⚠️ `{kind:'none'}` APPLIES NOTHING. An activity with no space has no world to simulate, and painting a filter over
+     * it would be the lie ADR-0087 exists to prevent, only backwards.
      */
-    function aplicarFiltroDeVisao(css, alcance) {
-        const mundo = cartucho.declaration.world();
-        if (mundo.kind !== 'element')
+    function setVisionFilter(css, reach) {
+        const declaredWorld = cartridge.declaration.world();
+        if (declaredWorld.kind !== 'element')
             return;
-        const el = $(mundo.selector);
+        const el = $(declaredWorld.selector);
         if (!el)
-            return; // já reportado em `problems`; não se inventa superfície
+            return; // already reported in `problems`; no surface is invented
         el.style.filter = css;
-        if (alcance === 'mundo') {
-            // Os menus vivem POR CIMA da simulação e são o instrumento de sair dela: se herdaram o filtro por
-            // estarem dentro do mundo, desfaz-se neles.
+        if (reach === 'mundo') {
+            // Menus live ABOVE the simulation and are the way out of it: if they inherited the filter by being inside the
+            // world, it is undone on them.
             for (const ov of $$(OVERLAY_SCOPE_SELECTOR)) {
                 if (el.contains(ov))
                     ov.style.filter = '';
             }
         }
     }
-    // 3. A pilha de diálogos. O ctx é o mesmo em qualquer jogo — é boilerplate, e boilerplate repetido é onde
-    //    consumidores divergem sem querer.
+    /*
+     * THE WORLD'S FILTER IS A COMPOSITION: the 🚥's colour correction and the L→Q contrast enhancement (ADR-0151). Written
+     * apart, the second writer erased the first — turning the enhancement on turned off the correction a colour-blind
+     * child had set. Each writer keeps its part and asks for the composition.
+     */
+    // The visual state the WORLD shows: the correction (🚥) and the simulation (empathy mode) are two fields of it, and
+    // `filterKey` already knows the simulation runs only with the correction at its default (ADR-0076).
+    let worldState = DEFAULT_VISUAL;
+    /*
+     * A DISABILITY SIMULATION RUNS IN THE GAME, NEVER IN A MENU (issue #182). The Dev: «Simulação de deficiência não pode
+     * funcionar no menu! Só no jogo! Senão fica impossível desabilitar em certos casos.» Two rules make it so:
+     *   · SUSPENDED while a menu is open — the pause card, a panel, the quick pause — and back when the child returns to play;
+     *   · NEVER ON AN ANCESTOR OF A MENU: a CSS filter reaches every descendant, and clearing it on the child does not undo it.
+     *     📏 In the quiz the world is the whole region, menus inside it: a simulated blindness blacked out the empathy panel
+     *     where it is turned off. So the filter goes on the world's parts that hold no menu, down to the world itself when
+     *     it holds none (a canvas world).
+     */
+    /** Assigned once the menus exist (below): until then no menu can be open. */
+    let simulationSuspended = () => false;
+    /*
+     * 🔴 WHERE THE SIMULATION LANDS lives in `ui/simulation-over-the-world` (ADR-0221 step 7c). Going down into a box that
+     * holds a door, sending the layer to a canvas's parent because a canvas has no children, keeping what HELPS under what
+     * SIMULATES: those are rules with reasons, not wiring.
+     */
+    const simulationOverWorld = createSimulationOverTheWorld({
+        world: () => cartridge.declaration.world(),
+        find: (sel) => $(sel),
+        createCanvas: () => doc.createElement('canvas'),
+    });
+    function recomposeWorldFilter() {
+        // what HELPS (the colour correction, the contrast enhancement) stays on the world as before; the SIMULATION is laid apart
+        const enhancementKey = filterKey({ ...worldState, simulacao: null });
+        const enhancement = [enhancementKey ? (VIZ_FILTER[enhancementKey] ?? '') : '', lq.filter()].filter(Boolean).join(' ');
+        setVisionFilter(enhancement, 'mundo');
+        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)
+    }
+    /*
+     * 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.
+     */
+    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,
+        store,
+    });
+    const { apply: applyCrt, scanVars: crtScanVars } = crt;
+    const lq = createLqFilter({ doc, onChange: recomposeWorldFilter, store });
+    if (lq.t() > 0)
+        recomposeWorldFilter(); // the stored enhancement holds from boot
+    else
+        applyCrt(); // and the stored CRT too (the recompose above applies it when it runs)
+    // 3. The dialog stack. The ctx is the same in every game — it is boilerplate, and repeated boilerplate is where
+    //    consumers diverge without meaning to.
     const overlays = initSettingsPanel({
-        $, $$, doc,
+        t: translator.t, $, $$, doc,
         computedZ: (el) => +win.getComputedStyle(el).zIndex || 0,
     });
-    // 4. Daltonismo: a engine ENTREGA o markup em vez de exigir que o consumidor o adivinhe (achado 7).
+    // 4. Colour vision: the engine HANDS OVER the markup instead of making the consumer guess it (finding 7).
     const cvdFilters = installCvdFilters(o.host.cvdHost ?? null);
     if (!cvdFilters)
-        problemasDoHospedeiro.push('sem host de filtros (<svg>): a correção de daltonismo não foi montada');
-    // 4c. A BARRA DE ACESSIBILIDADE DA PRIMEIRA TELA. Ver a nota em `EngineHost.a11yBarHost`: cinco dos seis
-    //     jogos do catálogo não têm nenhuma, e nada o dizia. Isto não a monta — diz que ela falta, que é o
-    //     passo que tira o silêncio. A frase nomeia a saída, como as outras deste bloco fazem.
-    const a11yBar = o.host.a11yBarHost ?? $(SELETOR_BARRA_A11Y);
+        hostProblems.push('there is no filter host (<svg>): colour-vision correction was not mounted, so a colour-blind child cannot turn it on — set `host.cvdHost`');
+    // 4c. THE FIRST SCREEN'S ACCESSIBILITY BAR. See the note on `EngineHost.a11yBarHost`. This block only reports that it
+    //     is missing, with a sentence that names the way out; the bar is mounted further below, once the icons exist.
+    const a11yBar = o.host.a11yBarHost ?? $(A11Y_BAR_SELECTOR);
     if (!a11yBar) {
-        problemasDoHospedeiro.push(`sem barra de acessibilidade na primeira tela: declare \`host.a11yBarHost\` ou ponha um ${SELETOR_BARRA_A11Y} no documento. Sem ela a criança não alcança modo cego, TTS, alto contraste nem Libras antes de começar`);
+        hostProblems.push(`there is no accessibility bar on the first screen: a child cannot reach blind mode, narration or Libras before starting — set \`host.a11yBarHost\` or put a ${A11Y_BAR_SELECTOR} in the page`);
+    }
+    /*
+     * ⚠️ THE ENGINE MOUNTS IT (ADR-0106 §4, step 2): step 1 took from the game the duty of answering the seven incidental
+     * fields, and step 3 gave the menu a default list, so `PauseIconsCtx` demands nothing this root cannot answer.
+     *
+     * ⚠️ IT IS NOT `buildQuickBar`, and the difference has a reason: that one sets `tabIndex = -1` on the buttons because
+     * during play ten tab stops separate the child from the game (ADR-0044 item 7). On the first screen nobody is playing,
+     * and taking the icons out of the tab order there would hide them from whoever navigates by keyboard — exactly the
+     * person they exist for.
+     */
+    /**
+     * THE BLIND-MODE READER — and it must read WHERE THE DEFAULT WRITER WRITES.
+     *
+     * 🔴 The writer's default is the engine's (`ui/pause-icons`: `ctx.setBlindMode ?? setBlindModeValue`), which stores
+     * in `core/state`. A reader that answered a CONSTANT `false` made blind mode impossible to turn off in a game that does
+     * not inject `isBlindMode`: the first press turned it on; the reflection read `false` and the icon said off; the
+     * second press wrote `true` AGAIN, `core/state`'s equality guard returned early, and nothing happened. A game that
+     * starts describing everything aloud and never stops, with no error anywhere.
+     *
+     * 📌 ONE CONSTANT AND NOT THE EXPRESSION REPEATED IN TWO PLACES, because repetition IS the defect: two answers to the
+     * same question drift. The store's `blindMode` is a LIVE getter, so this reads the value of now and not of boot.
+     */
+    const readBlindMode = cartridge.isBlindMode ?? (() => state.blindMode);
+    /**
+     * WHAT THE ENGINE CAN ACT ON BY ITSELF IN THE PAUSE MENU — filled below, read when the pause opens.
+     *
+     * 🔴 Without it, a game that calls only `createGame` got a pause card of one item: with an empty table
+     * `itemsThatAct` keeps only the `ENGINE_ITEMS`, and `rootThatActs` also drops `options` — «uma porta para uma sala
+     * vazia». A pause menu with one item is not a pause menu.
+     *
+     * ⚠️ MUTABLE AND READ LATE, on purpose, which is what the field's laziness is for: `initPauseIcons` runs here and the
+     * panels mount further below. `refreshPauseItems` evaluates it when the pause OPENS, not at mounting; reading the
+     * table now would freeze an empty object.
+     *
+     * 📌 AND THE CARTRIDGE OVERRIDES, not the other way round: a game that brings its own entry wins over the engine's.
+     * What ADR-0122 makes non-declinable is that the pause EXISTS, not that the engine owns every item in it.
+     */
+    const engineActions = {};
+    /** Opens the game options panel, once mounted (ADR-0182). Offered as the door's action only while the cartridge declares rows. */
+    let openGameOptions = null;
+    let redrawGameOptions = () => { };
+    /*
+     * ===================== THE WAY OUT, BORN WITH THE WAY IN (ADR-0144, erratum) =====================
+     *
+     * 🔴 `resume` is not in `ENGINE_ITEMS`, so without this entry `itemsThatAct` cut «continuar» from the card of EVERY game
+     * that calls only `createGame`; and Escape at the card's root calls `setPhase('playing')` (`ui/menu-nav`), which with
+     * no hook was a no-op. Both go through `changePhase` now.
+     *
+     * ⚠️ OPENING A DOOR WITH NO WAY OUT IS WORSE THAN NOT OPENING IT. It is ADR-0106 §5 in so many words, and the child
+     * stuck on the card would be precisely the one who navigates without seeing, who has no mouse to fall back on.
+     *
+     * 📌 It also unlocks a third thing: `enterBarMode` in `ui/pause-icons` calls `resume` before handing the directional
+     * to the bar, so ADR-0044's item 7 is reachable from any game.
+     *
+     * 📌 THE CARTRIDGE STILL OVERRIDES (the order of the spread in `getPauseActs` does not change): a game with its own
+     * «continuar» — because resuming there means unfreezing physics, resuming audio and more — wins over this one. What the
+     * engine guarantees is that there is ALWAYS one.
+     */
+    // The screen footer (see `screenFooter`): declared HERE, before the first `changePhase`, which already clears it.
+    let footer = null;
+    let barExplanation = 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();
+    // the menus and the quick pause exist from here on: a simulation is suspended while one is open (issue #182)
+    simulationSuspended = () => isMenuOpen() || inQuickPause.size > 0;
+    let pauseCaption = null;
+    function changePhase(p) {
+        // ⚠️ THE ENGINE CLOSES ITS CARD; THE GAME STILL DECIDES THE WORLD. It is the exact symmetry of ADR-0144 §2 from the
+        // other side: there the engine reveals and ASKS for the pause, here it hides and ASKS for the resume.
+        if (p !== 'paused') {
+            pauseControls.hide(0);
+            writeInFooter(null);
+        } // an item's reason does not stay over the game
+        cartridge.setPhase?.(p);
     }
+    engineActions.resume = () => changePhase('playing');
     /*
-     * ⚠️ E AGORA A ENGINE MONTA-A (ADR-0106 §4, etapa 2). Até 2026-09-08 esta raiz só REPORTAVA a ausência, e o
-     * registo dizia porquê: «reportar não é oferecer — cinco jogos continuam sem barra até alguém agir na
-     * linha». A etapa 1 tirou dos sete campos acidentais a obrigação de virem do jogo, e a 3 deu lista padrão
-     * ao menu; com isso o `PauseIconsCtx` deixou de exigir seja o que for que esta raiz não saiba responder.
+     * QUIT — «voltar à tela de press start» (the Dev's decision, 2026-09-12; erratum of ADR-0144 §5).
+     *
+     * 🔴 ADR-0144 §5 had left this OPEN on purpose, because the wrong answer loses a child's game: reload? `history.back()`?
+     * an activities menu that may not exist? The answer is none of the three — it is a PHASE the project already has a
+     * name and a contract for.
+     *
+     * ⚠️ AND THE EDGE IS STATED: `ui/shell`, which draws that screen, is deliberately not mounted by this root. The engine
+     * hides its card and ASKS for the phase; a game without the hook stays where it is. It is the same asymmetry as
+     * `setPhase('paused')` in ADR-0144 §2, and that is why the gate asserts the CALL.
      *
-     * ⚠️ NÃO É `buildQuickBar`, e a diferença tem dono: aquele põe `tabIndex = -1` nos botões porque durante a
-     * partida dez paradas de tabulação separam a criança do jogo (ADR-0044 item 7). Na primeira tela não se
-     * está a jogar, e tirar os ícones da ordem de tabulação ali seria escondê-los de quem navega por teclado —
-     * exactamente a pessoa para quem eles existem.
+     * 📌 NO CONFIRMATION, and that is a choice, not an omission. The ring puts `quit` one step from `resume` (ADR-0044
+     * item 1), which makes it easy to reach by mistake — but ADR-0037 decides: this project saves nothing, so what is lost
+     * is the current round and not progress. A confirmation dialog would cost one more stop in the scan of EVERY exit to
+     * protect what does not exist.
      */
+    engineActions.quit = () => changePhase('title');
+    /*
+     * PRINT — «ver a tela sem menus», and any button comes back.
+     *
+     * 📌 `ui/shell.printMode` does this, and `ui/shell` is not mounted by this root. But it needs no phase machine: it needs
+     * the cards, the window and the announcement — three things the engine has. Rewritten here with the SAME behaviour,
+     * including the delay.
+     *
+     * ⚠️ THE 80 ms ARE NOT SUPERSTITION: without them, the very event that TRIGGERED print is what undoes it — the child
+     * presses once and sees the clean screen blink.
+     *
+     * 📌 IN CAPTURE, not bubbling, because the point is to intercept BEFORE anyone else: in print mode the key belongs
+     * 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.
+     */
+    engineActions.print = () => {
+        const findPauseCard = () => $('#vp-pause-0');
+        const eventTarget = findPauseCard();
+        if (!eventTarget)
+            return;
+        eventTarget.hidden = true;
+        const goBack = (e) => {
+            if (e && typeof e.preventDefault === 'function') {
+                try {
+                    e.preventDefault();
+                }
+                catch { /* noop */ }
+            }
+            win.removeEventListener('keydown', goBack, true);
+            win.removeEventListener('pointerdown', goBack, true);
+            const c = findPauseCard();
+            if (c)
+                c.hidden = false;
+        };
+        win.setTimeout(() => {
+            win.addEventListener('keydown', goBack, true);
+            win.addEventListener('pointerdown', goBack, true);
+        }, 80);
+        srSay(t('sr.print.on'));
+    };
     /**
-     * O LEITOR DO MODO CEGO — e ele tem de ler ONDE O ESCRITOR PADRÃO ESCREVE.
+     * 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.
      *
-     * 🔴 ESTAS DUAS METADES GANHARAM PADRÃO EM DIAS DIFERENTES E NÃO SE FALAVAM, o que produziu um defeito que
-     * nenhum teste podia ver. O escritor recebeu o padrão da engine na etapa 1b do ADR-0106
-     * (`ui/pause-icons` → `ctx.setModoCego ?? setModoCegoValue`), que grava no `core/state`. O leitor ficou com
-     * o `() => false` que já cá estava — uma CONSTANTE. Num jogo que não injecta `isBlindMode`:
+     * 🔴 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.
+     */
+    let audio = null;
+    /*
+     * ⚠️ HOISTED ABOVE `initPauseIcons`, and the reason is ORDER, not tidiness: the bar decides WHICH ICONS it mounts at
+     * boot (`iconsThatAct`, resolved once), and the 11th — the typography cycle — exists only if the typography writer
+     * exists. That writer is born inside `if (pauseMountPoint && pauseUsable)`, further below; read there, the bar would
+     * already have decided.
      *
-     *   1. a criança carrega no ícone → `setModoCego(!false)` → o modo LIGA de verdade;
-     *   2. o reflexo lê `false` → o ícone diz «desligado» e o anúncio diz o mesmo;
-     *   3. ela carrega outra vez → `setModoCegoValue(!false)` = `true` OUTRA VEZ → a guarda de igualdade do
-     *      `core/state` devolve cedo → nada acontece.
+     * 📌 Hoisting instead of repeating the question: `o.host.pauseHost ?? $('#game-region')` written in two places would be
+     * the same answer with two sources.
+     */
+    const pauseMountPoint = o.host.pauseHost ?? $('#game-region');
+    const pauseUsable = !!pauseMountPoint && typeof pauseMountPoint.appendChild === 'function';
+    /*
+     * ⚠️ `typo` IS HOISTED TOO, for the same reason: the bar's typography cycle, decided earlier, must reach it. It is still
+     * assigned below; what changed is the SCOPE, not the moment.
+     */
+    let typo = null;
+    /** The typography cycle's current position. See the note on `cycleTypography`, below. */
+    let typographyStep = CYCLE_START;
+    /*
+     * 🔴 THE PLAYERS ARE HOISTED HERE (issue #147), for an order-of-boot reason: `initPauseIcons` consumes `getPlayers()`
+     * EAGERLY (when building the audio sub-ctx), so a `players` declared lower down fell into the temporal dead zone and
+     * brought the boot down. And with the bar reading `cartridge.players ?? []` instead, a game that declares no players
+     * had ZERO seats for the bar and ONE for the keyboard, and the bar's cycles (🚥 correction, ☝️, ASD) stuck on the
+     * first position: the state had nowhere to be kept and each press re-read the default.
+     */
+    // ⚠️ THE BOOT SCHEME REACHES NOTHING, and says so with `null` instead of with an empty object (issue #118). It lives an
+    // instant — `assignControls()` just below replaces it with the real scheme — but while it lives it is a `KeyScheme` like
+    // any other, and the only honest form of a scheme that reaches nothing is fourteen declared absences. A `{}` made the
+    // type lie about being complete.
+    const withoutReach = Object.fromEntries(ACTIONS.map((a) => [a, null]));
+    // ⚠️ THE FALLBACK IS A CONSTANT and not a new literal per call: `getPlayers` is read by the keyboard runtime at every
+    // control read, and returning a new array each time would make any identity comparison lie — a defect that shows
+    // only in whoever compares, and late.
+    const withoutPlayers = [{ ctrl: withoutReach }];
+    // ⚠️ IT READS `cartridge.players`, NOT A SNAPSHOT: with several cartridges on one composition root (ADR-0142), a `const`
+    // taken at boot would leave the keyboard with the players of the cartridge that booted first.
+    const players = () => cartridge.players ?? withoutPlayers;
+    /*
+     * THE COLOUR-BLIND-SAFE PALETTE IN THE MENUS AND THE HUD (ADR-0151) — Okabe-Ito, through `:root[data-paleta]`.
      *
-     * ⚠️ O modo cego ligava uma vez e NÃO HAVIA COMO DESLIGAR — um jogo que começa a descrever tudo em voz alta
-     * e não se cala, sem erro em lado nenhum. Para quem não depende dele, é o jogo a ficar inutilizável.
+     * 📌 `core/state.cbSafe` stores, persists and notifies; this is its writer on the page. The colours, and the measure
+     * that chose them, are in the stylesheet (`style.css`, beside `data-cursiva`).
      *
-     * 📌 UMA CONSTANTE E NÃO A EXPRESSÃO REPETIDA NOS DOIS SÍTIOS, porque a repetição É o defeito: duas
-     * respostas à mesma pergunta divergem, e foi assim que esta divergiu. `import * as state` dá ligação VIVA,
-     * então isto lê o valor de agora e não o do arranque.
+     * 🎯 THE RULE IS THE DEV'S, in their words: «ativada automaticamente quando se liga correção para protano,
+     * deutero e tritanopia e desativada automaticamente quando muda para visão padrão (tricromática). Aqui se
+     * permite ativá-la sem usar o filtro.» So the state is ONE (`cbSafe`), and the correction only pushes it.
+     */
+    const applySafePalette = (on) => {
+        if (on)
+            doc.documentElement.dataset.paleta = 'okabe-ito';
+        else
+            delete doc.documentElement.dataset.paleta;
+    };
+    applySafePalette(state.cbSafe);
+    stateOn('cbSafe', (v) => applySafePalette(Boolean(v)));
+    /**
+     * Wraps ANY correction writer — the cartridge's or the engine's: the palette follows the correction whoever applies it.
+     * ⚠️ Wrapping only the engine's would leave a game that corrects in its own render (`game-pinball`) without the palette
+     * the child asked for by pressing the same icon.
+     */
+    function withSafePalette(write) {
+        return (i, correction) => {
+            write(i, correction);
+            state.setCbSafeValue(correction !== 'tricro');
+        };
+    }
+    // 📌 ONE DOOR FOR BOTH, and the name says so since 2026-09-21: getUserMedia is what a page has to ask the camera AND the
+    // microphone for. It used to be called «temCamera» and the 👄 read it anyway — a name that describes half of what it answers is
+    // how a device with a headset and no webcam would have lost the voice for a reason nobody could see in the code.
+    const canCaptureMedia = typeof win.navigator?.mediaDevices?.getUserMedia === 'function';
+    /*
+     * ONE SET OF SCENE REDUCED-MOTION FLAGS, built here and handed to BOTH writers — the quick bar's calm icon and the motion
+     * panel (ADR-0232: state is built by the root). Left to themselves each read its own copy from storage, so the panel
+     * showed the scene animated after the calm mode reduced it, and its next switch stored that stale copy over the calm mode.
+     * The object is mutated in place; its identity is what the two share.
      */
-    const lerModoCego = cartucho.isBlindMode ?? (() => state.modoCego);
+    const sceneMotion = readStoredScene(store, defaultReducedMotion(win.matchMedia));
+    const saveSceneMotion = () => { storeScene(store, sceneMotion); };
     const pauseIcons = initPauseIcons({
-        doc,
+        translator, store,
+        settings: state, // the page's settings store itself: its live bindings are the reads the bar asks for (ADR-0232)
+        doc, matchMedia: win.matchMedia, // the reduced-motion default when nothing is stored (ADR-0232)
+        rm: sceneMotion, saveRM: saveSceneMotion,
         /*
-         * A RESPOSTA DO JOGO, lida da declaração (ADR-0115). Sem ela o ícone `altmove` não é montado.
-         *
-         * ⚠️ LIDA UMA VEZ, NO ARRANQUE, e a razão não é economia — é a criança. O campo é uma FUNÇÃO porque o
-         * ADR-0084 diz que um jogo muda de exigência entre fases, mas a COMPOSIÇÃO DA BARRA não pode mudar
-         * debaixo da mão de quem está a usá-la: um ícone que aparece e some entre fases é pior do que um que
-         * nunca esteve lá, e para quem navega por teclado desloca a ordem de tabulação a meio.
-         * 📌 Logo a leitura correcta do contrato é «este jogo segura teclas em ALGUMA fase» — um jogo que segura
-         * a pé e nada dentro de um veículo declara `true`, e o registo não disse isto porque a pergunta só
-         * aparece quando se monta a barra.
+         * THE GAME'S ANSWER, read from the declaration (ADR-0115). Without it the `altmove` icon is not mounted.
+         *
+         * ⚠️ WHICH ICONS THE BAR HAS IS DECIDED ONCE, AT BOOT, and the reason is not economy — it is the child. The field is
+         * a FUNCTION because ADR-0084 says a game changes its demands between phases, but the bar's COMPOSITION must not
+         * change under the hand of whoever is using it: an icon that comes and goes between phases is worse than one that
+         * was never there, and for someone navigating by keyboard it shifts the tab order midway.
+         * 📌 So the right reading of the contract is: this game holds keys in SOME phase — a game that holds keys on foot
+         * and nothing inside a vehicle declares `true`.
          */
-        // ⚠️ A REFERÊNCIA, e não o resultado. Chamar aqui congelava a resposta no arranque, e o
-        // `reflectPauseIcons` — que existe porque a tabela de acções muda (ADR-0106 §5) — refrescava a partir
-        // dela. Com vários cartuchos numa raiz de composição (ADR-0142) o ícone descrevia o primeiro deles.
-        seguraTeclas: () => cartucho.declaration.seguraTeclas(),
-        getPlayers: () => cartucho.players ?? [],
-        getNumPlayers: () => (cartucho.players ?? [null]).length,
+        // ⚠️ THE REFERENCE, not the result: the ☝️'s cycle reads it again at each press, and with several cartridges on one
+        // composition root (ADR-0142) it must describe the mounted one.
+        holdsKeys: () => cartridge.declaration.holdsKeys(),
+        // how many positions this cartridge declared — what «one button only» would have to offer (ADR-0218, issue #201)
+        declaredPositions: () => (cartridge.preset ? presetActions(cartridge.preset).length : 0),
+        // the hourglass is offered where time runs by itself (ADR-0180), read per cartridge
+        clock: () => cartridge.declaration.tick === 'clock',
+        // the 📷 is offered where there is a camera to ask for (ADR-0215); the three camera controls below follow its position
+        camera: canCaptureMedia,
+        // and the 👄 where there is a MICROPHONE (issue #184) — the same door as the camera's, so the same answer
+        microphone: canCaptureMedia,
+        // the ☰, the bar's first icon (interface log 2026-09-16): the SELECT door, where there is a card to open. Hoisted, read at the press.
+        ...(pauseUsable ? { openMenus: (i) => { openSeatMenus(i); } } : {}),
+        // no voice speaks the current language: the narration icon locks like the panel's rows (ADR-0185)
+        noVoice: () => tts.voices().length === 0,
+        /*
+         * ✅ THE SAME LIST AS THE KEYBOARD (issue #147).
+         *
+         * 📏 With an empty list, `iconAct('cvd', i)` re-read `(P()[i] || {}).visual` as `undefined` at every press: the cycle
+         * STUCK on the first position while the icon announced different corrections — and the same for the ☝️ and ASD.
+         * Since ADR-0151 the correction also switches the safe palette, which is PERSISTED, so it stuck for good.
+         *
+         * ⚠️ `initPauseIcons` consumes this EAGERLY, which is why `players` is hoisted above this call. A game that declares
+         * no players has ONE child playing, not none.
+         */
+        getPlayers: () => players(),
+        getNumPlayers: () => players().length,
         srSay, srAlert,
-        // ⚠️ NÃO `instanceof HTMLElement`: esse é um GLOBAL DO NAVEGADOR, e lê-lo onde ele não existe LANÇA —
-        // não devolve falso. Escrito assim na etapa 2, fazia o `reflectPauseIcons` rebentar em qualquer ambiente
-        // sem DOM. É o mesmo erro de forma do ACHADO 15 no cabeçalho deste ficheiro: alcançar o global por baixo
-        // de quem injectou o documento. A pergunta certa é a mesma que o `barraUsavel` faz — sabe ser uma barra?
-        getA11yBars: () => (barraUsavel && a11yBar ? [a11yBar] : []),
-        getModoCego: lerModoCego,
-        getAudioCat: () => audioCat,
+        // Leaving the bar is leaving the quick pause, by any door (ADR-0155). Hoisted function, read when called.
+        onLeaveBar: (i, silent) => endQuickPause(i, silent),
+        // What the pointed icon DOES goes to the footer (hoisted function, read when called).
+        explainIcon: (_i, k) => explainIconInFooter(k),
+        explainItem: (text) => writeInFooter(text),
+        // ⚠️ NOT `instanceof HTMLElement`: that is a BROWSER GLOBAL, and reading it where it does not exist THROWS — it does
+        // not return false. It is the same shape of error as FINDING 15 in this file's header: reaching the global underneath
+        // whoever injected the document. The right question is the one `barUsable` asks — can it be a bar?
+        getA11yBars: () => (barUsable && a11yBar ? [a11yBar] : []),
+        getBlindMode: readBlindMode,
+        getAudioCat: () => mixer.audioCat,
         setCatGain,
         /*
-         * ⚠️ QUEM RESPONDE PELO APARELHO EM USO É A RAIZ, e é aqui que o autómato do ADR-0109 ganha o primeiro
-         * leitor. `input/state.entradaDe(i)` devolve `PADRAO` para quem nunca produziu uma aresta, logo isto
-         * nunca é `undefined` e o ícone nunca escreve numa chave torta.
+         * ⚠️ THE ROOT ANSWERS FOR THE DEVICE IN USE, and here ADR-0109's automaton gets its reader. `input/state.inputOf(i)`
+         * returns `DEFAULT_INPUT_STATE` for whoever never produced an edge, so this is never `undefined` and the icon never
+         * writes to a crooked key.
          *
-         * 📌 E é a RAIZ que o passa, não o ícone que o importa: `ui/` a ler estado de módulo de `input/` seria
-         * uma aresta nova entre camadas para poupar um argumento. A composição é o trabalho deste ficheiro.
+         * 📌 And the ROOT passes it rather than the icon importing it: `ui/` reading module state from `input/` would be a new
+         * edge between layers to save one argument. Composition is this file's job.
          */
-        transporteEmUso: (i) => entradaDe(i).emUso,
-        reflectTtsPanel: () => { },
-        reflectTtsPanelEnabled: false,
-        isLibrasOn: vlibrasOpen,
-        toggleLibras,
+        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),
         /*
-         * ⚠️ O QUE O JOGO ENTREGA, E QUE ATÉ HOJE NÃO TINHA POR ONDE. Os três campos são opcionais dos dois
-         * lados: ausentes, tudo se comporta como antes — tabela de acções vazia e os dois ícones visuais
-         * não montados. Ver as notas em `CreateGameOptions` para o que a ausência custava.
+         * ⚠️ 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`.
          */
-        ...(cartucho.getPauseActs ? { getPauseActs: cartucho.getPauseActs } : {}),
-        ...(cartucho.setTemaDoJogador ? { setTemaDoJogador: cartucho.setTemaDoJogador } : {}),
-        ...(cartucho.setCorrecaoDoJogador ? { setCorrecaoDoJogador: cartucho.setCorrecaoDoJogador } : {}),
+        // ⚠️ ALWAYS PASSED: a cartridge's absence means only what the engine acts on, which is what ADR-0106 §1 asks for.
+        getPauseActs: () => ({
+            ...engineActions,
+            ...(openGameOptions && cartridge.gameOptions?.length ? { opcoesdojogo: openGameOptions } : {}),
+            ...(cartridge.getPauseActs ? cartridge.getPauseActs() : {}),
+        }),
+        /*
+         * THE TYPOGRAPHY CYCLE OF THE 11th ICON (ADR-0149 §1, ADR-0150 §2).
+         *
+         * 🎯 ONE PRESS CHANGES THE CASE **AND** THE FACE, and that is the decision: `letterCase` (ADR-0028) and the face are
+         * two settings, and Andika in capitals is ONE pedagogical choice of whoever teaches reading. A child should not
+         * have to know the model to make it.
+         *
+         * 📌 THE POSITION LIVES HERE, in a `let` of the root, and not in `core/state`: it is derived — the case and the face
+         * are each persisted on their own —, and storing an index beside what it derives from is a third place for the
+         * three to drift. On reopening, the cycle restarts at the default position with the face that was left.
+         *
+         * ⚠️ THE COUNTRY'S HAND COMES FROM THE BCP-47 TAG of the current language, and the fallback is the COLONISER's
+         * (ADR-0150): Spanish → Spain, Portuguese → Portugal, English → England. A language outside the repertoire returns an
+         * empty list and the cycle has four positions — better one fewer than the hand of a country that is not that child's.
+         */
+        cycleTypography: pauseUsable ? () => {
+            // ⚠️ `typo` is read HERE and not in the condition: it is born further below, and the condition runs now. Whether
+            // the icon exists is decided by `pauseUsable`, the SAME question that decides whether the writer is born.
+            if (!typo)
+                return null;
+            const cycle = typographyCycle(bcp47());
+            typographyStep = (typographyStep + 1) % cycle.length;
+            const position = cycle[typographyStep];
+            state.setLetterCaseValue(position.letterCase);
+            typo.setFont(position.font, false);
+            /*
+             * ⚠️ THE SCALE IS ALWAYS WRITTEN, not only when it is above 1. Writing only on the way up would leave the country's
+             * hand in force after the child went back to Atkinson — the whole text 25% larger with nothing explaining it, and
+             * her pressing the button again to try to undo it.
+             * 📌 On the document root and not on `#game-region`: the base `font-size` belongs to `html,body`, and that is what
+             * this ratio multiplies.
+             */
+            doc.documentElement.style.setProperty('--fonte-escala', String(position.scale));
+            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 } : {}),
+        /*
+         * 🚥 COLOUR-VISION CORRECTION HAS AN ENGINE DEFAULT (ADR-0148 §1), so the icon is never missing for want of a writer.
+         *
+         * 🎯 A FILTER NEEDS NOT KNOW THE GAME — the argument that makes this legitimate. It goes over whatever the game drew,
+         * the same way the `consumer-quiz` does by hand. What the engine CANNOT do is repaint textures, which is why the 🌗
+         * stays the game's (see the ADR-0148 erratum).
+         *
+         * ⚠️ AND ONLY IF THE FILTERS EXIST. Without `host.cvdHost`, `installCvdFilters` returns zero, `url(#cvd-fix-protan)`
+         * points at nothing and the icon would announce a correction that does not happen — a control that lies about its
+         * state, worse than one icon fewer (ADR-0106 §5). The `problems` line for that gap already exists.
+         *
+         * 📌 THE CARTRIDGE STILL WINS: a game that corrects colour in its own render (`game-pinball`, in a framebuffer) hands in
+         * its own and the engine steps aside.
+         */
+        ...(cartridge.setPlayerCorrection
+            ? { setPlayerCorrection: withSafePalette(cartridge.setPlayerCorrection) }
+            : cvdFilters
+                /*
+                 * ⚠️ `filterKey` AND NOT `VIZ_FILTER[correction]`: the two vocabularies are DIFFERENT. The axis says `protan`;
+                 * `VIZ_FILTER` knows `fix-protan`. Translated by hand, the lookup gave `undefined`, the filter came out empty and
+                 * the icon ANNOUNCED a correction that did not happen — exactly the control lying about its state.
+                 * 📌 And `filterKey` does more than glue a prefix: it puts the SIMULATION ahead of the correction when there is
+                 * one, a rule this module should not reinvent.
+                 */
+                ? { setPlayerCorrection: withSafePalette((i, correction) => {
+                        /*
+                         * 🔴 STORE BEFORE APPLYING: applying alone left the cycle STUCK on the first position. The next step is computed
+                         * by `nextCorrection(p.visual)` in `ui/pause-icons`; without writing it back, every press re-read the default and
+                         * returned `protan`.
+                         * ⚠️ No error at all: the icon announced the right correction, the filter changed the first time, and the child
+                         * pressed twice more to see the same screen. Caught by a surviving MUTATION — always apply, never clear — that stayed
+                         * green because the case pressed only once.
+                         */
+                        // ⚠️ `players()`, the SAME list `ui/pause-icons` reads (`getPlayers`, above) to compute the next step: written
+                        // anywhere else, the state would land where nobody reads it again.
+                        const player = players()[i];
+                        // A correction switched ON stops the demonstration (ADR-0076): a simulation over an adaptation teaches something false.
+                        const before = player?.visual ?? worldState;
+                        const nextVisual = { ...before, correcao: correction, simulacao: correction === 'tricro' ? before.simulacao : null };
+                        if (player)
+                            player.visual = nextVisual;
+                        worldState = nextVisual;
+                        recomposeWorldFilter();
+                    }) }
+                : {}),
     });
     /*
-     * ⚠️ O HOSPEDEIRO TEM DE SABER SER UMA BARRA, e perguntar isso não é zelo: `a11yBarHost` é `Element` no
-     * tipo, e um consumidor pode passar um duplo, um nó de outro documento, ou um elemento de um `<svg>`. Sem
-     * esta guarda, um objecto sem `addEventListener` derruba o BOOT INTEIRO — e derrubá-lo por causa da barra
-     * de acessibilidade seria tirar o jogo a toda a gente para não o dar a ninguém.
+     * ⚠️ THE HOST MUST BE ABLE TO BE A BAR, and asking is not fussiness: `a11yBarHost` is `Element` in the type, and a
+     * consumer may pass a double, a node from another document, or an element of an `<svg>`. Without this guard, an object
+     * without `addEventListener` brings the WHOLE BOOT down — and bringing it down for the accessibility bar would take
+     * the game from everyone so as to give it to no one.
      *
-     * Não sabendo, é `problems` como qualquer outra lacuna do hospedeiro: o consumidor lê e conserta.
+     * If it cannot, it is `problems` like any other gap of the host: the consumer reads and fixes.
      */
-    const barraUsavel = !!a11yBar
+    const barUsable = !!a11yBar
         && typeof a11yBar.addEventListener === 'function'
         && 'innerHTML' in a11yBar;
-    if (a11yBar && !barraUsavel) {
-        problemasDoHospedeiro.push('o elemento da barra de acessibilidade não aceita conteúdo nem clique: os ícones não foram montados');
+    if (a11yBar && !barUsable) {
+        hostProblems.push('the accessibility bar element takes neither content nor clicks: its icons were not mounted, so a child cannot reach them — give `host.a11yBarHost` a real element');
     }
-    if (a11yBar && barraUsavel) {
-        a11yBar.innerHTML = iconsMarkup(pauseIcons.iconesMontados);
+    if (a11yBar && barUsable) {
+        // 🔴 WITH THE NAME CAPTION under the row: the bar the engine mounted had none, and the Dev saw it mute when navigating
+        // and hovering. `aria-hidden` because the name is already SPOKEN (`srSay` on the cursor, the `aria-label` on focus).
+        a11yBar.innerHTML = iconsMarkup(translator, pauseIcons.mountedIcons) + '<p class="pause-icons-cap" aria-hidden="true"></p>';
+        wireBarCaption(a11yBar, explainIconInFooter);
         a11yBar.addEventListener('click', (e) => {
-            const botao = e.target?.closest('.pi-btn');
-            if (!botao)
+            const rowButton = e.target?.closest('.pi-btn');
+            if (!rowButton)
                 return;
-            pauseIcons.iconAct(botao.dataset.pi ?? '', 0);
+            pauseIcons.iconAct(rowButton.dataset.pi ?? '', 0);
             pauseIcons.reflectIconsIn(a11yBar, 0);
-            // O anúncio lê o `aria-label` DEPOIS do reflexo, porque é ele que carrega o estado NOVO — anunciar
-            // antes diria o estado que a criança acabou de deixar.
-            srSay(botao.getAttribute('aria-label') ?? '');
+            const caption = a11yBar.querySelector('.pause-icons-cap');
+            if (caption)
+                caption.textContent = accessibleLabel(rowButton); // the NEW state, after the reflection; «N de M» is spoken, never written (ADR-0167)
+            // The announcement reads the `aria-label` AFTER the reflection, because that carries the NEW state — announcing
+            // before would say the state the child just left.
+            srSay(rowButton.getAttribute('aria-label') ?? '');
         });
         pauseIcons.reflectIconsIn(a11yBar, 0);
         /*
-         * ⚠️ E OUTRA VEZ QUANDO O IDIOMA DO ARRANQUE CHEGAR — sem isto a barra fica no idioma de RECUO.
-         *
-         * O `initI18n` aplica pt de forma síncrona (para a página nunca ficar em branco) e, se o idioma
-         * preferido for outro, PEDE a troca — que é assíncrona, porque en/es são chunks sob demanda. Esta
-         * marcação nasce nesse intervalo. 📏 Medido num navegador em 2026-09-08, com `lang="en"`: a barra
-         * servia cinco rótulos em inglês e três ainda em português, na mesma linha de ícones.
-         *
-         * 📌 O `idiomaPronto()` existe exactamente para isto, e o cabeçalho dele já descreve o defeito noutro
-         * lugar: «o `applyDom` conserta o markup ESTÁTICO, mas o que o JavaScript monta tinha capturado o
-         * texto de pt e ninguém reconstruía». A barra é a instância nova, criada quando a ENGINE passou a
-         * montá-la (ADR-0106 etapa 2).
-         *
-         * ⚠️ É O `idiomaPronto()` E NÃO O EVENTO `i18n:change`, de propósito: o evento é a troca de idioma EM
-         * EXECUÇÃO, e o próprio `core/i18n` declara essa pergunta como sendo do Dev («QUANDO a interface se
-         * reconstrói ao trocar de idioma em execução»). Isto responde só a pergunta do ARRANQUE, que aquele
-         * mesmo comentário diz não ter duas respostas.
+         * ⚠️ 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
+         * 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
+         * language arrives through `setLocale`, which dispatches that same event, so one path serves the boot and a change
+         * made mid-game.
          */
-        void idiomaPronto().then(() => { pauseIcons.reflectIconsIn(a11yBar, 0); });
         /*
-         * ⚠️ E ELA TEM DE CONTINUAR A DIZER A VERDADE quando o estado muda NOUTRO SÍTIO. O modo cego liga-se
-         * também pelo painel de áudio e pela simulação de empatia; sem esta assinatura, o ícone da barra ficaria
-         * a dizer «desligado» com `aria-pressed=false` depois de a criança o ter ligado — o controlo a mentir o
-         * estado, que é a família de defeito que o `reflectTTS` e o `#opt-modocego` já custaram a este projeto.
-         *
-         * 📌 SÓ O MODO CEGO, e a limitação é medida e não preguiça: dos ícones que esta raiz monta, ele é o ÚNICO
-         * cujo estado tem evento (`EventoDoJogo` tem `modoCego`; TTS, Libras, TEA e alternância não emitem nada).
-         * Os outros continuam a refletir-se ao clique, que é o caminho por onde hoje eles mudam.
+         * ⚠️ AND IT MUST GO ON TELLING THE TRUTH when a state changes ELSEWHERE. Blind mode is also switched by the hearing
+         * panel and by the empathy simulation; without this subscription, the bar's icon would go on saying off with
+         * `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.
          */
-        state.on('modoCego', () => { pauseIcons.reflectIconsIn(a11yBar, 0); });
+        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)
+        stateOn('cameraControl', () => { pauseIcons.reflectIconsIn(a11yBar, 0); }); // a mode that cannot start puts the 📷 back to off
+        // 🔴 AND THE 👄 FOR THE SAME REASON, measured in a browser on 2026-09-21: with the microphone refused, the child heard «it did
+        // not open», the stored answer went back to off — and the button went on saying «ligado». A control that lies about its state
+        // 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); });
     }
-    // 4d. QUEM ABRIU A PAUSA, quando há mais de um assento — o achado 3 da auditoria do `game-soccer`.
+    // 4d. WHO OPENED THE PAUSE, when there is more than one seat — finding 3 of the `game-soccer` audit.
     //
-    // ⚠️ O PAINEL DE CONTROLE É PARAMETRIZADO PELO ASSENTO: `render(selPlayer)` desenha as posições DAQUELE
-    // esquema, e não há selector de assento — o `#ctrl-players` é uma FRASE, não abas. Quem decide o assento é
-    // o consumidor, passando o ator da pausa: «edita o controle de quem abriu o menu».
+    // ⚠️ THE KEYBOARD PANEL IS PARAMETERISED BY THE SEAT: `render(selPlayer)` draws the positions of THAT scheme, and the
+    // consumer decides the seat by passing the pause actor: the panel edits the controls of whoever opened the menu.
     //
-    // ✅ E ISTO DEIXOU DE SER MUDO. O `setPauseActor` desta raiz era `() => {}` LITERAL, sem campo por onde um
-    // jogo o entregar: a linha abaixo dizia «conserte» sem haver por onde, e a única saída era declarar
-    // `semAtorDePausa`, que é aceitar a perda em vez de a corrigir. Agora ela só acusa quem NÃO respondeu —
-    // que é o que uma linha de `problems` deve fazer, pelo §2 do ADR-0106.
-    // 📌 A linha do ator da pausa mudou-se para `problemasDoCartucho()`: quem declara assentos é o jogo.
-    /*
-     * 4e. O CARTÃO DE PAUSA DA PRIMEIRA TELA — e isto fecha um LAÇO QUE ESTAVA ABERTO.
-     *
-     * 📏 MEDIDO EM 2026-09-08, nos seis jogos do catálogo local: `#vp-pause-0` é procurado por esta raiz (o
-     * `getPauseMenu` do `initMenuNav`, mais abaixo) e **NENHUM jogo o cria**. `git grep vp-pause` devolve zero
-     * em `game-platformer`, `game-soccer`, `pixi-15-puzzle`, `2048`, `whackwhack` e `game-chess`. Ou seja: a
-     * engine inventou uma convenção, procurou-a, não a achou, e concluiu em silêncio que nenhum jogo tem menu
-     * de pausa — que é a MESMA forma de defeito do ADR-0106 §2, desta vez cometida pela engine contra si mesma.
-     *
-     * Agora ela cria o que procura — e para TODO jogo, desde o ADR-0120 e outra vez desde o ADR-0122: o
-     * declínio saiu, porque a razão de ele existir foi construída fora por este mesmo ADR-0106, e porque a
-     * regra é do Dev — a pausa e os ícones de acessibilidade estão em todo jogo, logo são da engine.
-     */
-    const hospedeiroDaPausa = o.host.pauseHost ?? $('#game-region');
-    const pausaUsavel = !!hospedeiroDaPausa && typeof hospedeiroDaPausa.appendChild === 'function';
-    if (!pausaUsavel) {
-        problemasDoHospedeiro.push('sem sítio para o menu de pausa: declare `host.pauseHost` ou tenha um #game-region que aceite filhos. '
-            + 'Sem ele a criança não alcança os ajustes durante a partida — e NÃO há como declinar: desde o '
-            + 'ADR-0122 a pausa é da engine em todo jogo, e o que este jogo declara é só ONDE ela cabe');
-    }
-    if (hospedeiroDaPausa && pausaUsavel) {
-        const cartao = pauseIcons.buildScreenPause(0);
-        // ⚠️ O ID É O QUE A PRÓPRIA ENGINE PROCURA, logo abaixo, no `getPauseMenu`. Montar sem o pôr deixaria o
-        // laço tão aberto como estava — o cartão existiria e a navegação de menu continuaria a não o achar.
-        cartao.id = 'vp-pause-0';
-        hospedeiroDaPausa.appendChild(cartao);
-    }
-    // 4b. NAVEGAÇÃO SONORA. Só o contrato entra: nada de tile, caixa de colisão ou array de moedas.
+    // 📌 The pause-actor line of `problems` lives in `measureCartridgeProblems()`: whoever declares seats is the game, and
+    // the line accuses only a game that did not answer (ADR-0106 §2).
+    /*
+     * 4e. THE FIRST SCREEN'S PAUSE CARD. `#vp-pause-0` is what this root looks for (`getPauseMenu` of `initMenuNav`, below),
+     * and games did not create it: the engine had invented a convention, looked for it, not found it, and concluded in
+     * silence that no game had a pause menu — the same shape of defect as ADR-0106 §2, committed by the engine against
+     * itself. So the engine creates what it looks for, for EVERY game (ADR-0120, ADR-0122): the pause and the
+     * accessibility icons are in every game, so they are the engine's.
+     */
+    // (`pauseMountPoint` and `pauseUsable` are hoisted above `initPauseIcons` — see the note there. They depend only on
+    //  `o.host` and `$`, and the bar needs the answer BEFORE deciding which icons it mounts.)
+    if (!pauseUsable) {
+        hostProblems.push('the pause menu has nowhere to mount: a child cannot reach the settings during play — set `host.pauseHost` or give '
+            + '#game-region room for children (the pause is the engine\'s in every game, ADR-0122; the game only says where it fits)');
+    }
+    if (pauseMountPoint && pauseUsable) {
+        const findPauseCard = pauseIcons.buildScreenPause(0);
+        // ⚠️ THE ID IS WHAT THE ENGINE ITSELF LOOKS FOR, just below, in `getPauseMenu`. Mounting without it would leave the
+        // loop as open as it was — the card would exist and menu navigation would still not find it.
+        findPauseCard.id = 'vp-pause-0';
+        pauseMountPoint.appendChild(findPauseCard);
+    }
+    /*
+     * 4f. THE SETTINGS PANELS (ADR-0106 §1).
+     *
+     * 🔴 `ui/panel-shell.mountShell` BUILDS a panel's shell, and each `ui/settings-*` fills the INSIDE of ids somebody
+     * must create. Left to the page, the failure took the worst form available — the quiz recorded it as finding 6: the
+     * panel opens EMPTY, with no error. So the engine mounts each shell (`ui/mount-panel`) and then its writer.
+     *
+     * ⚠️ AND THE PANELS LIVE WHERE THE CARD LIVES, which is not tidiness: `ui/settings-panel.topVisibleOverlay` scans
+     * `'#game-region .overlay'` (`OVERLAY_SCOPE_SELECTOR`), and that is how `ui/menu-nav` reaches the top dialog to move
+     * with the arrows. A panel hung outside that scope OPENS, closes with Escape — and **the arrows do not move inside
+     * it**, with no error at all. Hence the `problems` line below instead of silence.
+     */
+    if (pauseMountPoint && pauseUsable) {
+        const regionEl = $('#game-region');
+        const insideScope = !!regionEl && typeof regionEl.contains === 'function'
+            && regionEl.contains(pauseMountPoint);
+        if (!insideScope) {
+            hostProblems.push('the pause host is outside #game-region: settings panels open, but arrows do not move inside them, so a child '
+                + 'who plays by keyboard cannot reach the settings — put `host.pauseHost` inside #game-region');
+        }
+        const panelCtx = {
+            find: (sel) => $(sel),
+            create: (tag) => doc.createElement(tag),
+            host: pauseMountPoint,
+            overlays,
+            localeOn, // a language change redraws an open panel, and `dispose()` releases it (ADR-0232 D4)
+        };
+        /*
+         * TYPOGRAPHY — NO PANEL since ADR-0151: «quem escolhe a tipografia é o jogo, o jogador escolhe suas fontes via o
+         * menu de acessibilidade rápida». Its door left the inclusion settings and its shell is not mounted — a dialog in the
+         * document that nobody reaches is the defect ADR-0144 measured.
+         *
+         * 📌 BUT THE WRITER STAYS, which is why the `init` is still here: the 11th button's cycle writes the face through this
+         * API (`typo.setFont`), and the `init` applies at boot the font the child left stored. `initSettingsTypo` guards each
+         * access to the document, so it runs without the shell.
+         */
+        typo = initSettingsTypo({
+            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}"`) }
+                : {}),
+        });
+        /*
+         * AAC — COMMUNICATION: THE PANEL IS NOT MOUNTED (ADR-0151).
+         *
+         * 🔴 The «Comunicação» door left the inclusion settings: the letter case moves with the bar's 11th button, which is the
+         * COMMUNICATION cycle (with ARASAAC and PCS disabled). Mounting a panel with no door would leave in the document a
+         * dialog nobody reaches — the defect ADR-0144 measured. The `ui/settings-aac` module stays in the engine for whoever
+         * wants to mount it.
+         */
+        /*
+         * HELP — which button does what, IN THIS game, on THIS child's keyboard (ADR-0147 §4).
+         *
+         * 🔴 The `ajuda` item has been on the pause list since ADR-0044 and the engine could not act on it, so `itemsThatAct`
+         * hid it in every game. The engine draws it now, so no game has to write its own.
+         *
+         * ⚠️ IT IS NOT MOUNTED WITHOUT `howToPlay` OR `preset`, and the absence is the right answer: without the game's words,
+         * the table could only show `action2` — an identifier in front of a child, the defect ADR-0074 forbids in so many
+         * words. Better no help than one that cannot be read.
+         *
+         * 📌 THE KEY COMES FROM `kbFor(0)`, not the factory map: whoever remapped sees HER key. It is the same reason ADR-0144
+         * listens to the action and not the key.
+         */
+        // The cartridge's «how to play» slides come first (ADR-0195; issue #188); the help stands with them, with the buttons, or both.
+        if (cartridge.preset || cartridge.howToPlay?.length) {
+            let stopFigure = () => { };
+            const helpPanel = mountPanel(panelCtx, {
+                id: 'help',
+                labels: () => ({
+                    title: t('menu.help'),
+                    listLabel: t('help.grupo.rotulo'),
+                    resetLabel: t('menu.restoreDefaults'),
+                    closeLabel: t('pause.pmback'),
+                }),
+                // ⚠️ `render` AND NOT A ONE-OFF MOUNTING: the preset may change with another cartridge's `mount()` (ADR-0142) and
+                // the child may have remapped between two openings. A table built at boot would show yesterday's key — the exact
+                // shape of the control lying about its state.
+                // The slide show opens on its first slide (interface log, 2026-09-13; `ui/help-panel`).
+                render: () => {
+                    const list = $('#help-list');
+                    if (!list)
+                        return;
+                    while (list.firstChild)
+                        list.removeChild(list.firstChild);
+                    const slideContents = [...(cartridge.howToPlay ?? []), ...helpRows(cartridge.preset, (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);
+                    const slideTimer = {
+                        requestFrame: (cb) => win.requestAnimationFrame(cb),
+                        cancelFrame: (id) => win.cancelAnimationFrame(id),
+                        reduced: defaultReducedMotion(win.matchMedia),
+                    };
+                    const showSlideAt = (i) => {
+                        stopFigure();
+                        const shown = showSlide(slides, slideContents, i, ctxDoSlide);
+                        const slide = slideContents[shown.index];
+                        if (slide && 'text' in slide)
+                            stopFigure = animateFigure(slides, slide, slideTimer);
+                        return shown;
+                    };
+                    let currentSlide = showSlideAt(0).index;
+                    slides.addEventListener('passo', (ev) => {
+                        const fresh = nextStep(currentSlide, slideContents.length, ev.detail);
+                        if (fresh === currentSlide)
+                            return;
+                        const shown = showSlideAt(fresh);
+                        currentSlide = shown.index;
+                        srSay(shown.spoken);
+                    });
+                },
+            });
+            // A slide show restores nothing: the reset row the panel shell builds does not show here.
+            const helpActions = helpPanel.shell.reset.parentElement;
+            if (helpActions)
+                helpActions.hidden = true;
+            engineActions.ajuda = helpPanel.open;
+        }
+        else {
+            hostProblems.push('the help screen was not mounted: it shows how to play and each position, its key and the game\'s word, and without '
+                + '`howToPlay` or `preset` it could only show a child `action2` — declare `howToPlay` (ADR-0195) or `preset` (ADR-0085)');
+        }
+        /*
+         * OPÇÕES DO JOGO — the cartridge's rows, drawn by the engine (ADR-0182; issue #178).
+         * 📌 Drawn at every opening and at every `mount()`: the rows are the CURRENT cartridge's, and each value is read from it.
+         * The shell's «restore defaults» is hidden: a cartridge declares no defaults, and a button that does nothing is the
+         * dead control ADR-0106 §5 forbids.
+         */
+        const gamePanel = mountPanel(panelCtx, {
+            id: 'game-options',
+            labels: () => ({
+                title: t('pause.opcoesdojogo'),
+                listLabel: t('pause.opcoesdojogo'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => redrawGameOptions(),
+        });
+        gamePanel.shell.reset.hidden = true;
+        redrawGameOptions = () => {
+            drawGameOptions({ ...panelCtx, say: srSay, t: translator.t }, gamePanel.shell.list, cartridge.gameOptions ?? []);
+            if (!gamePanel.shell.overlay.hidden)
+                overlays.fillExplain(gamePanel.shell.card);
+        };
+        openGameOptions = gamePanel.open;
+        /*
+         * ANIMATION — motion sensitivity.
+         *
+         * 📌 `rm`, `saveRM`, `rmKeys` and `rmChar` are OPTIONAL (ADR-0106 step 1), and the absence is the news: none of them
+         * held a choice of the game — `rmKeys` was the `MotionSceneKey` union written by hand and `rm`/`saveRM` read an engine
+         * storage key with an engine default. `ui/motion-scene` answers for the four, so this panel needs nothing only the
+         * cartridge knows. The root still passes `rm`/`saveRM`: not the game's, but the ONE object the quick bar also writes.
+         *
+         * ⚠️ AND ITS LIST IS `#motion-list`, NOT `#animation-list` — inherited from the monolith, where the panel was called
+         * «motion» and the overlay «animation». See `PanelShellSpec.listId`: renaming would touch the contract with markup of
+         * consumers this repository cannot measure.
+         */
+        let motion = null;
+        const animPanel = mountPanel(panelCtx, {
+            id: 'animation',
+            listId: 'motion-list',
+            labels: () => ({
+                title: t('menu.animation'),
+                listLabel: t('animation.grupo.rotulo'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => motion?.render(),
+        });
+        /*
+         * THE MASTER BUTTON — stop all animations at once.
+         *
+         * ⚠️ CREATED HERE AND BEFORE THE `init`: `initSettingsMotion` wires its click ONCE, at boot. And it is not
+         * decoration — it is the way out for someone who felt sick with the screen moving and needs to stop EVERYTHING in one
+         * gesture, instead of going through seven rows one by one.
+         * 📌 The label comes from the panel itself (`motionMasterLabel`), which swaps it by state; setting it here would give
+         * two hands writing the same text, and the one left behind would lie about the state.
+         */
+        const animMaster = doc.createElement('button');
+        animMaster.id = 'motion-master';
+        animMaster.className = 'mode-btn switch';
+        animMaster.setAttribute('type', 'button');
+        animPanel.shell.card.insertBefore(animMaster, animPanel.shell.list);
+        motion = initSettingsMotion({
+            t: translator.t, $, srSay, store, matchMedia: win.matchMedia, crt,
+            // the SAME flags the quick bar's calm icon writes (see `sceneMotion`, above)
+            rm: sceneMotion, saveRM: saveSceneMotion,
+            getNumPlayers: () => (cartridge.players ?? [null]).length,
+            getPlayers: () => cartridge.players ?? [],
+            frontOverlay: overlays.frontOverlay,
+            restoreFocus: overlays.restoreFocus,
+            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,
+        });
+        engineActions.anim = animPanel.open;
+        /*
+         * VISUAL ACCESSIBILITY (ADR-0151) — and the item is no longer locked (ADR-0161).
+         *
+         * 📌 THE MODULE IS `ui/settings-visual`, with the two rows the engine CAN act on: the contrast enhancement (the L→Q
+         * filter, composed on the world with the colour correction) and the safe palette (`core/state.cbSafe`, which paints
+         * menus and HUD). ⚠️ Role colours («lava, escada, água, portão») stay OUT: they belong to a game with those roles, and
+         * the engine does not describe a game it does not know. Owner colours and outlines are offered below, where the game
+         * answers them (ADR-0188). High contrast and colour correction left this panel for the quick bar (ADR-0151).
+         * ⚠️ The writers of the rows not offered are inert ON PURPOSE: `reset` calls them only when the value read differs
+         * from the default, and the value returned here IS the default.
+         */
+        const visualPanel = mountPanel(panelCtx, {
+            id: 'visual',
+            labels: () => ({
+                title: t('menu.visual'),
+                listLabel: t('visual.grupo.rotulo'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => {
+                rateHint.textContent = t('visual.legenda.ritmo.dica'); // before `visual.render()` runs `fillExplain`
+                fgOutline.escreverDica();
+                bgOutline.escreverDica();
+                visual.render();
+                offerOwnerAndOutlines();
+                labelRow(captionsRow, captionsSpec()); // in the language of the opening
+                reflectCaptions();
+                reflectCaptionRate();
+            },
+        });
+        /*
+         * CAPTIONS (ADR-0151 §2; issue #182): the Dev listed them in the visual panel. `state.captionsOn` was stored and read by
+         * the sound captions (`captionSound`) with no row to change it. Placed after the panel's list, which `visual.render()`
+         * rewrites by markup; built once, so its listener is not lost.
+         */
+        const captionsSpec = () => ({ id: 'opt-captions', label: t('visual.captions'), hint: t('visual.captions.dica') });
+        const { row: captionsRow, control: captionsButton } = controlRow(panelCtx, captionsSpec());
+        visualPanel.shell.card.insertBefore(captionsRow, visualPanel.shell.list.nextSibling);
+        const reflectCaptions = () => {
+            toggleBtn(captionsButton, state.captionsOn);
+            captionsButton.textContent = toggleLabel(t, state.captionsOn);
+            markChanged(t, captionsRow, state.captionsOn !== DEFAULTS.captionsOn);
+        };
+        /* THE CAPTION RATE (ADR-0183 §4; issue #179): 125, 145 or 175 words a minute, by steps, right after the captions switch. */
+        const rateSpec = () => ({
+            label: t('visual.legenda.ritmo'),
+            values: CAPTION_RATES.map((n) => t('visual.legenda.ppm', { n })),
+            current: Math.max(0, CAPTION_RATES.indexOf(state.captionPpm)),
+        });
+        const speechRateRow = doc.createElement('div');
+        speechRateRow.className = 'ctrl-row ctrl-row--passos';
+        const rateEnvelope = doc.createElement('span');
+        const rateHint = doc.createElement('span');
+        rateHint.className = 'opt-hint';
+        // ⚠️ WRITTEN NOW, and again before the panel's render: `visual.render()` runs `fillExplain` on the whole card, and a row it
+        // meets with an empty hint is marked done and keeps its hint INSIDE — the Dev saw the explanation in the row.
+        rateHint.textContent = t('visual.legenda.ritmo.dica');
+        rateEnvelope.appendChild(rateHint);
+        speechRateRow.appendChild(rateEnvelope);
+        const rateSteps = mountSteps(panelCtx, rateSpec());
+        rateSteps.id = 'opt-legenda-ppm';
+        speechRateRow.appendChild(rateSteps);
+        visualPanel.shell.card.insertBefore(speechRateRow, captionsRow.nextSibling);
+        rateSteps.addEventListener('passo', (ev) => {
+            const currentSlide = rateSpec().current;
+            const fresh = nextStep(currentSlide, CAPTION_RATES.length, ev.detail);
+            if (fresh === currentSlide)
+                return;
+            state.setCaptionPpmValue(CAPTION_RATES[fresh]);
+            updateSteps(rateSteps, rateSpec());
+            markChanged(t, speechRateRow, state.captionPpm !== DEFAULTS.captionPpm);
+            srSay(`${t('visual.legenda.ritmo')}: ${t('visual.legenda.ppm', { n: state.captionPpm })}`);
+        });
+        const reflectCaptionRate = () => {
+            updateSteps(rateSteps, rateSpec());
+            rateHint.textContent = t('visual.legenda.ritmo.dica');
+            markChanged(t, speechRateRow, state.captionPpm !== DEFAULTS.captionPpm);
+        };
+        captionsButton.addEventListener('click', () => {
+            state.setCaptionsOnValue(!state.captionsOn);
+            reflectCaptions();
+            srSay(t(state.captionsOn ? 'sr.visual.captionsOn' : 'sr.visual.captionsOff'));
+        });
+        /*
+         * OWNER COLOURS AND CONTRAST OUTLINES (ADR-0188; issue #183): rows only where the cartridge answers the subject. Built once
+         * beside the panel's list (`visual.render()` rewrites that by markup), with their own ids — `ui/settings-visual` wires
+         * `#opt-ownercolors` at every render — and shown or hidden at each opening: `mount()` may have swapped the answer.
+         * 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 { row: ownerRow, control: ownerButton } = controlRow(panelCtx, ownerSpec());
+        const reflectOwner = () => {
+            toggleBtn(ownerButton, state.ownerColors);
+            ownerButton.textContent = toggleLabel(t, state.ownerColors);
+            markChanged(t, ownerRow, state.ownerColors !== DEFAULTS.ownerColors);
+        };
+        ownerButton.addEventListener('click', () => {
+            state.setOwnerColorsValue(!state.ownerColors);
+            reflectOwner();
+            srSay(`${ownerSpec().label}: ${toggleLabel(t, state.ownerColors)}`);
+        });
+        const OUTLINE_LEVELS = ['visual.contorno.0', 'visual.contorno.1', 'visual.contorno.2'];
+        const outline = (plane) => {
+            const readOutline = () => (plane === 'fg' ? state.hcOutlineFg : state.hcOutlineBg);
+            const write = plane === 'fg' ? state.setOutlineFgValue : state.setOutlineBgValue;
+            const spec = () => ({ label: t(`visual.contorno.${plane}`), values: OUTLINE_LEVELS.map((k) => t(k)), current: readOutline() });
+            const rowC = doc.createElement('div');
+            rowC.className = 'ctrl-row ctrl-row--passos';
+            const envelope = doc.createElement('span');
+            const explanation = doc.createElement('span');
+            explanation.className = 'opt-hint';
+            envelope.appendChild(explanation);
+            rowC.appendChild(envelope);
+            const stepper = mountSteps(panelCtx, spec());
+            stepper.id = `opt-contorno-${plane}`;
+            rowC.appendChild(stepper);
+            stepper.addEventListener('passo', (ev) => {
+                const fresh = nextStep(readOutline(), OUTLINE_LEVELS.length, ev.detail);
+                if (fresh === readOutline())
+                    return;
+                write(fresh);
+                updateSteps(stepper, spec());
+                srSay(`${t(`visual.contorno.${plane}`)}: ${t(OUTLINE_LEVELS[fresh])}`);
+            });
+            // 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`);
+            };
+            writeHint();
+            const reflect = () => { updateSteps(stepper, spec()); };
+            return { row: rowC, refletir: reflect, escreverDica: writeHint };
+        };
+        const fgOutline = outline('fg');
+        const bgOutline = outline('bg');
+        const offerOwnerAndOutlines = () => {
+            ownerRow.hidden = subjectWord(cartridge.accommodations, 'ownerColors') === null;
+            if (!ownerRow.hidden) {
+                labelRow(ownerRow, ownerSpec());
+                reflectOwner();
+            }
+            const withoutOutlines = subjectWord(cartridge.accommodations, 'contrastOutlines') === null;
+            for (const c of [fgOutline, bgOutline]) {
+                c.row.hidden = withoutOutlines;
+                if (!withoutOutlines)
+                    c.refletir();
+            }
+        };
+        // after the list, owner colours first, then the two outlines (the captions row, built above, follows them)
+        for (const l of [bgOutline.row, fgOutline.row, ownerRow])
+            visualPanel.shell.card.insertBefore(l, visualPanel.shell.list.nextSibling);
+        offerOwnerAndOutlines();
+        const noEffect = () => { };
+        const visual = initSettingsVisual({
+            t: translator.t, $, srSay,
+            getNumPlayers: () => players().length,
+            getPlayers: () => cartridge.players ?? [],
+            getVisualSettings: () => ({
+                lq: lq.t(), cbSafe: state.cbSafe,
+                ownerColors: state.ownerColors, outlineFg: state.hcOutlineFg, outlineBg: state.hcOutlineBg,
+                roleColors: { ...HC_ROLE_DEF },
+            }),
+            getSelectedPlayer: () => 0,
+            setSelectedPlayer: noEffect,
+            setPlayerViz: noEffect,
+            renderVisualAxes: noEffect,
+            setLq: lq.set,
+            setCbSafe: state.setCbSafeValue,
+            // the panel's «restore» puts these back too (ADR-0188): their rows now exist where the game answered them
+            setOwnerColors: state.setOwnerColorsValue, setOutlineFg: state.setOutlineFgValue, setOutlineBg: state.setOutlineBgValue,
+            setRoleColor: noEffect, resetRoleColors: noEffect,
+            fillExplain: overlays.fillExplain,
+            offer: { owner: false, roles: false },
+        });
+        engineActions.visual = visualPanel.open;
+        /*
+         * EMPATHY MODE (ADR-0151) — and the last locked item of the submenu unlocks (ADR-0161).
+         *
+         * 📌 THE MODULE IS `ui/settings-empathy`, with what the engine CAN do:
+         *   · the SIMULATIONS that are a filter on the world — the three colour-blindness ones (the matrices of
+         *     `installCvdFilters`), blur, haze and blindness; and the three DRAWN ones — tunnel vision, a central scotoma,
+         *     scattered scotomas — whose filter is only a blur: `ui/simulation-over-the-world` lays their drawing over the
+         *     world (issue #182);
+         *   · HEARING LOSS (`platform/audio.setHearingLossGraph`, already the engine's);
+         *   · the two MOTOR simulations (ADR-0181): «um botão por vez» and «sem força para segurar», applied to game keys by
+         *     the filter at the end of the boot, before any cartridge hears them.
+         * ⚠️ No wheelchair (cut by ADR-0151).
+         * ⚠️ And the simulation respects ADR-0076: with a colour correction on it does not run, and SAYS why.
+         */
+        const WORLD_SIMULATIONS = ['normal', 'sim-protan', 'sim-deuter', 'sim-tritan', 'lv-blur', 'lv-haze', 'lv-tunnel', 'lv-macular', 'lv-diabetic', 'blind'];
+        const empathyPanel = mountPanel(panelCtx, {
+            id: 'empathy',
+            labels: () => ({
+                title: t('menu.empathy'),
+                listLabel: t('empathy.grupo.rotulo'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            // the hearing-loss row was born in the fallback language: relabelled at every opening, like the hearing panel's inside
+            render: () => {
+                labelRow(hearingRow, hearingSpec());
+                labelRow(oneAtOnceRow, oneAtOnceSpec());
+                labelRow(noStrengthRow, noStrengthSpec());
+                empathy.render();
+            },
+        });
+        // The hearing-loss row is born BEFORE the `init`, which wires its click once (the same order rule as the motion master).
+        const hearingSpec = () => ({ id: 'opt-hearing', label: t('empathy.hearing'), hint: t('empathy.hearing.dica') });
+        const hearingRow = controlRow(panelCtx, hearingSpec()).row;
+        empathyPanel.shell.card.insertBefore(hearingRow, empathyPanel.shell.list);
+        // THE TWO MOTOR SIMULATIONS (ADR-0181), before the `init`, which wires `#opt-onebtn` once (the same order rule).
+        const oneAtOnceSpec = () => ({ id: 'opt-onebtn', label: t('empathy.onebtn'), hint: t('empathy.onebtn.dica') });
+        const noStrengthSpec = () => ({ id: 'opt-semforca', label: t('empathy.semforca'), hint: t('empathy.semforca.dica') });
+        const oneAtOnceRow = controlRow(panelCtx, oneAtOnceSpec()).row;
+        const noStrengthRow = controlRow(panelCtx, noStrengthSpec()).row;
+        empathyPanel.shell.card.insertBefore(oneAtOnceRow, empathyPanel.shell.list);
+        empathyPanel.shell.card.insertBefore(noStrengthRow, empathyPanel.shell.list);
+        const reflectMobilitySimulations = () => {
+            for (const [id, on] of [['#opt-onebtn', state.oneButton], ['#opt-semforca', state.noGripStrength]]) {
+                const b = $(id);
+                if (!b)
+                    continue;
+                toggleBtn(b, on);
+                b.textContent = toggleLabel(t, on);
+            }
+            markChanged(t, noStrengthRow, state.noGripStrength !== DEFAULTS.noGripStrength);
+        };
+        const simulate = (i, key) => {
+            const simulation = (key === 'normal' ? null : key);
+            const player = players()[i];
+            const base = player?.visual ?? worldState;
+            const reason = simulation ? simulationUnavailable(base) : null;
+            if (reason) {
+                srSay(t(`sim.indisponivel.${reason}`));
+                return false;
+            } // a VISIBLE, explained refusal (ADR-0076)
+            const nextVisual = { ...base, simulacao: simulation };
+            if (player) {
+                player.visual = nextVisual;
+                player.viz = key;
+            }
+            worldState = nextVisual;
+            recomposeWorldFilter();
+            return true;
+        };
+        // ONE LIST, NOT SEVEN BUTTONS (ADR-0159 rule 7) — `ui/simulation-list` says why, and it is not wiring.
+        const simulationPicker = createSimulationList({
+            t: translator.t,
+            find: $,
+            make: (tag) => doc.createElement(tag),
+            keys: WORLD_SIMULATIONS,
+            running: () => worldState.simulacao ?? null,
+            // a refused simulation (ADR-0076) is announced by `simular` and the re-render puts the list back on what runs
+            picked: (key) => { simulate(0, key); empathy.render(); },
+        });
+        const empathy = initSettingsEmpathy({
+            t: translator.t, $, srSay, store,
+            hearing: mixer,
+            renderVizGroup: (listSelector) => { simulationPicker.render(listSelector); },
+            reflectMobilityEmpathy: reflectMobilitySimulations,
+            reflectVizButtons: noEffect,
+            frontOverlay: overlays.frontOverlay,
+            fillExplain: overlays.fillExplain,
+            restoreFocus: overlays.restoreFocus,
+            setHearingLoss: (on) => {
+                setHearingLossGraph(on);
+                store.set(KEYS.hearingloss, on);
+                srSay(t(on ? 'sr.empathy.hearingOn' : 'sr.empathy.hearingOff'));
+            },
+            setOneButton: (on) => {
+                state.setOneButtonValue(on);
+                srSay(t(on ? 'sr.empathy.onebtnOn' : 'sr.empathy.onebtnOff'));
+                reflectMobilitySimulations();
+            },
+            setWheelchair: noEffect,
+            getOneButton: () => state.oneButton,
+            getWheelchair: () => DEFAULTS.wheelchair,
+            getPlayers: () => [{ viz: worldState.simulacao ?? 'normal' }],
+            setPlayerViz: (i, rowMode) => { simulate(i, rowMode); },
+        });
+        // «sem força para segurar» is wired here: the empathy module predates it. Refused over toggle keys (ADR-0076): a latch
+        // would hold what the simulation lets go, and the demonstration would show the accommodation instead of the difficulty.
+        $('#opt-semforca')?.addEventListener('click', () => {
+            const wire = !state.noGripStrength;
+            if (wire && players().some((p) => p.toggleMove)) {
+                srAlert(t('sim.indisponivel.alternancia'));
+                return;
+            }
+            state.setNoGripStrengthValue(wire);
+            srSay(t(wire ? 'sr.empathy.semforcaOn' : 'sr.empathy.semforcaOff'));
+            empathy.render();
+        });
+        // and the panel's «restore defaults» turns it off too, after the module's own reset
+        $('#empathy-reset')?.addEventListener('click', () => { state.setNoGripStrengthValue(false); empathy.render(); });
+        engineActions.empatia = empathyPanel.open;
+        /*
+         * HEARING ACCESSIBILITY — the biggest of the panels, and the one with the most to lose by not existing.
+         *
+         * 📏 The panel reached nodes it never created; `mountAudioInside`, beside it, builds them. ⚠️ And the inside goes in
+         * BEFORE the `init`, by the order rule the panels above already paid for: `initSettingsAudio` wires its clicks once,
+         * at boot.
+         *
+         * 📌 None of the `ctx` fields is the game's: the mixer, the volume, blind mode, the cane and the voice are all the
+         * engine's, and the cartridge's players serve as they are. It was the most expensive panel to mount and the least
+         * dependent on who mounts it.
+         */
+        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.
+            listId: 'navsound-list',
+            labels: () => ({
+                title: t('menu.audio'),
+                listLabel: t('audio.navsound.grupo'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            /*
+             * ⚠️ THE INSIDE GOES IN AT RENDER, not only at mounting. The frame is retranslated (`MountPanelSpec.labels`); the
+             * inside, run once, would keep the text of the boot interval, where the language is still the fallback — the
+             * title in English and the rows in Portuguese on the same screen, as measured in a real browser with `lang="en"`.
+             *
+             * 📌 `mountAudioInside` RELABELS what exists instead of rebuilding it — rebuilding would leave controls in the
+             * document with no listener. And no unit test catches this: they all run in one language.
+             */
+            render: () => {
+                mountAudioInside(translator.t, panelCtx, audioPanel.shell.card, audioPanel.shell.list);
+                hideRowsWithoutSubject();
+                audio?.renderAudio();
+            },
+        });
+        mountAudioInside(translator.t, panelCtx, audioPanel.shell.card, audioPanel.shell.list);
+        /*
+         * AUDIO — general sound and the four taste categories (ADR-0151 §2 item 4), apart from hearing accessibility.
+         * ⚠️ MOUNTED BEFORE `initSettingsAudio`, by the siblings' order rule: this panel's master switch, volume and «restore»
+         * are wired ONCE, at boot.
+         */
+        const soundPanel = mountPanel(panelCtx, {
+            id: 'som',
+            listId: 'audio-list',
+            labels: () => ({
+                title: t('menu.som'),
+                listLabel: t('audio.grupo.rotulo'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => {
+                mountSoundInside(translator.t, panelCtx, soundPanel.shell.card, soundPanel.shell.list);
+                audio?.renderAudio();
+            },
+        });
+        mountSoundInside(translator.t, panelCtx, soundPanel.shell.card, soundPanel.shell.list);
+        // The two hearing-panel rows that exist only where there is a subject — `ui/audio-rows-that-apply` says why, and it
+        // 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'),
+            hasNavigationSound: () => contractSubjects({
+                declaration: cartridge.declaration,
+                actions: cartridge.preset ? presetActions(cartridge.preset) : [],
+                players: players().length,
+            }).has('navigationSound'),
+        });
+        hideRowsWithoutSubject();
+        audio = initSettingsAudio({
+            translator, $, srSay, store,
+            // the page's settings store, and the ROOT'S door to its bus: the panel's subscription ends with `dispose()` (ADR-0220)
+            settings: state, on: stateOn,
+            /*
+             * 🔴 THE AUDIO PANEL'S BROWSER COMES FROM HERE (ADR-0227). What ADR-0221 step 7d asks is not that nobody touches the
+             * browser — it is that whoever touches it is whoever RECEIVED it. This root receives `doc` and `win` from the host
+             * (`EngineHost`), so the reach moves place and not owner: out of a panel that does not know which page it is in,
+             * into the only module of the tree that legitimately knows.
+             */
+            newElement: (tag) => doc.createElement(tag),
+            speech: {
+                voices: () => { try {
+                    return win.speechSynthesis?.getVoices() ?? [];
+                }
+                catch (e) {
+                    return [];
+                } },
+                speakSample: (sample, chosen) => {
+                    try {
+                        const ss = win.speechSynthesis;
+                        if (!ss)
+                            return;
+                        ss.cancel();
+                        const u = speech.utterance(sample);
+                        u.lang = 'pt-BR';
+                        if (chosen)
+                            u.voice = chosen;
+                        u.rate = 1;
+                        u.volume = 1;
+                        ss.speak(u);
+                    }
+                    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 */ }
+                    });
+                },
+            },
+            audioOutputs: {
+                canList: () => !!(win.navigator?.mediaDevices && win.navigator.mediaDevices.enumerateDevices),
+                canRoute: () => {
+                    const w = win;
+                    return typeof (w.AudioContext ?? w.webkitAudioContext) !== 'undefined';
+                },
+                list: async () => {
+                    const md = win.navigator?.mediaDevices;
+                    if (!md?.enumerateDevices)
+                        return [];
+                    return (await md.enumerateDevices()).filter((d) => d.kind === 'audiooutput');
+                },
+                detect: async () => {
+                    const md = win.navigator?.mediaDevices;
+                    if (!md?.enumerateDevices)
+                        return [];
+                    // 📌 The permission is what gives the outputs NAMES: without it the browser lists anonymous devices, and a choice
+                    // between «Saída 1» and «Saída 2» is not a choice. The track is let go at once.
+                    await md.getUserMedia?.({ audio: true }).then((s) => s.getTracks().forEach((t) => t.stop())).catch(() => { });
+                    return (await md.enumerateDevices()).filter((d) => d.kind === 'audiooutput');
+                },
+            },
+            audioCats: AUDIO_CATS,
+            toggleBtn,
+            getNumPlayers: () => players().length,
+            getPlayers: () => cartridge.players ?? [],
+            getSoundOn: () => mixer.soundOn,
+            setSoundOn,
+            getVolume: () => mixer.volume,
+            setVolume,
+            getAudioCat: () => mixer.audioCat,
+            setCatGain,
+            tts,
+            getBlindMode: readBlindMode,
+            // 📌 The `core/state` pattern: store, persist, notify. The game effects are a REACTION, and whoever reacts
+            // subscribes to `on('blindMode', …)` — the same decision `ui/pause-icons` took for the icon.
+            setBlindMode: state.setBlindModeValue,
+            getCaneBlockDiv: () => state.caneBlockDiv,
+            setCaneBlockDiv: state.setCaneBlockDivValue,
+            fillExplain: overlays.fillExplain,
+        });
+        engineActions.audio = audioPanel.open;
+        engineActions.som = soundPanel.open;
+    }
+    // 4b. NAVIGATION SOUND. Only the contract goes in: no tile, collision box or coin array.
     const sonar = createAudioSonar({
-        topology: () => cartucho.declaration.topology(),
-        targetsOf: (i) => cartucho.declaration.targetsOf(i),
-        nameAt: (at) => cartucho.declaration.nameAt(at),
-        // Campo 2 + o barramento do mixer: o que o GUIA CONTÍNUO precisa e o bipe não precisava (#84 item 2). O
-        // `roleAt` é o que deixa a rota contornar parede; o `catNode`/`audioOut`/`getVolume` são o que põem um
-        // grafo PERMANENTE no mesmo cursor de volume que todo o resto do áudio usa.
-        roleAt: (at) => cartucho.declaration.roleAt(at),
-        tonePan, srSay, narrate: (texto) => tts.narrate(texto),
-        catNode, audioOut, getVolume: () => volume,
-        // ⚠️ A RESPOSTA, E NÃO A TABELA (#104). O `platform/audio-sonar` recebia o `VIZ_BY_KEY` e atravessava-o
-        // com `pl.viz`; ele deixou de saber o que é um modo visual, e quem responde é aqui — a raiz é a única
-        // camada que conhece os dois eixos E pode importar de `render/`.
-        visaoComprometida: (pl) => {
+        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,
+        // ⚠️ 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) => {
             const v = pl.visual;
-            return !!v && (ehCego(v) || ehBaixaVisao(v));
+            return !!v && (isBlind(v) || isLowVision(v));
         },
-        getModoCego: lerModoCego, LOGICAL_W,
-        // O jogador DERIVADO do foco: campo 4 respondendo "onde a criança está". Um jogo que não fornece lista
-        // ainda tem sonar, e é isso que faz a pilha de acessibilidade não ser acessório.
-        getPlayers: cartucho.sonarPlayers ?? (() => {
-            const f = cartucho.declaration.focusOf(0);
-            return f ? [{ i: 0, x: f.at.x, y: f.at.y, visual: PADRAO }] : [];
+        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: () => (cartucho.players ?? [null]).length,
-        getAudioCtx: () => audioCtx, getSoundOn: () => soundOn, getAudioCat: () => audioCat,
+        getNumPlayers: () => (cartridge.players ?? [null]).length,
+        getAudioCtx: () => mixer.audioCtx, getSoundOn: () => mixer.soundOn, getAudioCat: () => mixer.audioCat,
+        newContext: newAudioContext,
     });
-    // 5. Teclado remapeável — o melhor recorte da base (achado 11): esquema de teclas, sem mundo.
+    // 5. Remappable keyboard — the best cut of the base (finding 11): a key scheme, no world.
     //
-    // ⚠️ O PADRÃO DO JOGO REGISTA-SE ANTES DO `initKB()`, e a ordem é a regra: quem lê o disco já tem de saber
-    // qual é a fábrica sobre a qual o dado da criança se sobrepõe (ADR-0115). Registar depois deixaria o
-    // primeiro arranque com a fábrica da ENGINE e o segundo com a do jogo — a pior espécie de defeito, porque
-    // desaparece quando alguém vai ver.
-    // 📌 E o registo aceita `null`, que é o que um jogo sem opinião produz: fica a fábrica da engine.
-    /*
-     * OS DOIS REGISTOS NUMA FUNÇÃO, porque são EFEITO GLOBAL e não valor: quem os chama por último ganha.
-     *
-     * ⚠️ É o que os torna diferentes de tudo o mais nesta raiz. Repontar uma leitura para o `cartucho` chega
-     * para os campos que são lidos quando alguém pergunta; estes dois já foram escritos noutro sítio no
-     * momento do arranque, então trocar de cartucho sem os reescrever deixa o mapa do anterior a valer —
-     * calado, e exactamente no lugar onde uma criança que remapeou teclas iria notar primeiro.
-     *
-     * 📌 `null` é o valor honesto de «este jogo não tem opinião», e é também o que o `desmontar()` escreve.
-     */
-    function registrarMapeamentosDoCartucho() {
-        registrarMapeamentoDoTeclado(cartucho.declaration.mapeamentoDoTeclado
-            ? (jogadores, assento) => cartucho.declaration.mapeamentoDoTeclado(jogadores, assento)
-            : null);
-        // ⚠️ E O DO CONTROLE REGISTA-SE AQUI AINDA QUE ESTA RAIZ NÃO MONTE GAMEPAD NENHUM. Não é descuido: quem
-        // chama `initGamepad` é o cartucho, e é exactamente por isso que o registo não pode viver lá — seria mais
-        // um campo que um jogo pode esquecer, e esquecê-lo devolve o mapa da ENGINE a quem declarou outro, calado.
-        registrarMapeamentoDoPad(cartucho.declaration.mapeamentoDoPad
-            ? (jogadores, assento) => cartucho.declaration.mapeamentoDoPad(jogadores, assento)
-            : null);
-    }
-    registrarMapeamentosDoCartucho();
-    initKB();
-    // ⚠️ O ESQUEMA DE ARRANQUE ALCANÇA NADA, e diz isso com `null` em vez de com um objeto vazio (issue #118).
-    // Ele vive um instante — `assignControls()` logo abaixo substitui-o pelo esquema real —, mas enquanto vive
-    // é um `KeyScheme` como qualquer outro, e a única forma honesta de um esquema que não alcança nada é
-    // catorze ausências declaradas. Um `{}` fazia o tipo mentir sobre estar completo.
-    const semAlcance = Object.fromEntries(ACTIONS.map((a) => [a, null]));
-    // ⚠️ O FALLBACK É UMA CONSTANTE e não um literal novo a cada chamada: `getPlayers` é lido pelo runtime de
-    // teclado a cada leitura de controlo, e devolver um array novo de cada vez faria qualquer comparação de
-    // identidade mentir — um defeito que só aparece em quem compara, e tarde.
-    const semJogadores = [{ ctrl: semAlcance }];
-    // ⚠️ LÊ `cartucho.players`, E NÃO UM INSTANTÂNEO. Os getters já existiam; o que eles fechavam é que era um `const`
-    // tirado no arranque. As linhas de `initPauseIcons` e do sonar, neste mesmo ficheiro, já liam a fonte viva —
-    // esta era a que faltava. Com vários cartuchos numa raiz de composição (ADR-0142), o teclado ficava com os
-    // jogadores do cartucho que arrancou primeiro.
-    const players = () => cartucho.players ?? semJogadores;
+    /*
+     * THE MOUNTED CARTRIDGE'S TWO DEFAULT MAPPINGS (ADR-0115), held by THIS root (ADR-0232 D4): they were module registrations,
+     * and a second root overwrote the first root's. `null` is the honest value of «this game has no opinion», and it is also
+     * what `unmount()` sets. The keyboard config reads the mapping through a closure, so a `mount()` answers with the new
+     * cartridge's; the pad table is REBUILT, because its memo belongs to one mapping — a kept memo would serve the previous
+     * game's table.
+     */
+    let keyboardMappingNow = null;
+    let padTableNow = createPadTable(null);
+    function followCartridgeMappings(declaration) {
+        const keyboardMapping = declaration?.keyboardMapping;
+        keyboardMappingNow = keyboardMapping ? (players, seat) => keyboardMapping(players, seat) : null;
+        const padMapping = declaration?.padMapping;
+        padTableNow = createPadTable(padMapping ? (players, seat) => padMapping(players, seat) : null);
+    }
+    followCartridgeMappings(cartridge.declaration);
+    // ⚠️ THE GAME'S DEFAULT IS KNOWN BEFORE `load()`, and the order is the rule: whoever reads the disk must already know which
+    // factory the child's data overlays (ADR-0115).
+    const keyboardConfig = createKeyboardConfig({
+        store, mapping: (players, seat) => keyboardMappingNow?.(players, seat) ?? null,
+    });
+    keyboardConfig.load();
+    // THE CHILD'S PAD MAPS, one cache for this root, handed to BOTH readers: the motor panel's wizard and the gamepad.
+    const padMaps = createPadMaps(store);
+    // (`withoutReach`, `withoutPlayers` and `players` are hoisted above `initPauseIcons` — issue #147.)
     const keyboard = initKeyboardRuntime({
-        getKB: () => kb, getNumPlayers: () => players().length, getPlayers: () => players(),
+        getKB: keyboardConfig.kb, getNumPlayers: () => players().length, getPlayers: () => players(),
     });
+    /** The «Mapear teclado» panel, once mounted. Declared here because the menu navigation, just below, asks it whether it
+     *  is capturing a key — and it is born only with the motor panel, further on. */
+    let keyboardControls = null;
     keyboard.assignControls();
-    // 6. Navegação de menu. Os três declínios entram como AUSÊNCIA DECLARADA, não como getter que devolve null.
+    /*
+     * THE THREE ANSWERS THE CARTRIDGE MAY REPLACE, resolved ONCE. They feed the menu navigation and, since ADR-0224, the
+     * gamepad too — and writing the same `??` in two places is writing the same decision twice.
+     */
+    const isOnBar = cartridge.onBar ?? ((i) => pauseIcons.onBar(i));
+    const navBar = cartridge.navBar ?? ((i, k, withStart) => pauseIcons.navBar(i, k, withStart));
+    const setPauseActor = cartridge.setPauseActor ?? (() => { });
+    // 6. Menu navigation.
     const nav = initMenuNav({
-        $, getActiveElement: () => doc.activeElement,
+        $, t: translator.t, getActiveElement: () => doc.activeElement,
         topVisibleOverlay: overlays.topVisibleOverlay, closeById: overlays.closeById,
         getPauseMenu: (i) => $(`#vp-pause-${i}`),
-        setPhase: cartucho.setPhase ?? (() => { }),
-        setPauseActor: cartucho.setPauseActor ?? (() => { }),
+        // ⚠️ NOT `cartridge.setPhase ?? (() => {})`: «no» at the card's root calls `setPhase('playing')` (`ui/menu-nav`) and
+        // nothing more — it hides nothing —, so in a game without the hook Escape did not close the pause ADR-0144 opens. It
+        // goes through the same `changePhase` as the «continuar» item: one way out, whatever door the child leaves by.
+        setPhase: changePhase,
+        setPauseActor,
         srSay,
-        // Sem opinião declarada, o índice fica LIGADO: quem precisa dele para se orientar não tem como saber
-        // que ele existe se vier desligado (a mesma razão de o modo cego nascer com TTS e sonar).
-        comIndice: cartucho.comIndice ?? (() => true),
-        isNavigable: cartucho.isNavigable ?? (() => true),
+        // With no declared opinion, the index is ON: whoever needs it to find their way cannot know it exists if it comes
+        // switched off (the same reason blind mode is born with narration and sonar).
+        withIndex: cartridge.withIndex ?? (() => true),
+        explainItem: (text) => writeInFooter(text),
+        isNavigable: cartridge.isNavigable ?? (() => true),
         /*
-         * ⚠️ ESTE PADRÃO ERA `() => false` / `() => {}`, E DESDE HOJE ISSO SERIA UM BURACO QUE EU ABRI. O
-         * comentário que estava aqui dizia «um hospedeiro que não tenha barra de acessibilidade responde nunca e
-         * nunca chama nada» — verdade até a etapa 2 do ADR-0106, quando esta raiz passou a MONTAR a barra.
+         * ⚠️ THE DEFAULT IS THE ENGINE'S BAR, and not `() => false` / `() => {}`: this root MOUNTS the bar (ADR-0106 step 2).
+         * With these two as no-ops the bar would exist and **could not be navigated by keyboard or gamepad** — reachable only
+         * by pointer. For a blind child, who navigates by keyboard, a bar she cannot reach is the same as no bar — exactly
+         * the offer-the-path-then-refuse-it that ADR-0106 §5 forbids.
          *
-         * Com a barra montada e estes dois em no-op, ela existiria e **não se conseguiria navegar por teclado nem
-         * por controle**: alcançável só por ponteiro. Para uma criança cega, que navega por teclado, uma barra
-         * que ela não alcança é o mesmo que barra nenhuma — e é exactamente o «oferece o caminho e depois
-         * recusa-o» que o §5 do ADR-0106 proíbe.
+         * The engine answers with ITS instance, the same one that mounted the bar. Whoever injects still rules.
          *
-         * A engine responde com a SUA instância, que é a mesma que montou a barra. Quem injecta continua a mandar.
-         *
-         * ⚠️ E FICA UMA METADE POR LIGAR, dita aqui em vez de descoberta: o `navBar` do `ui/menu-nav` recebe
-         * `(i, k)` e não o terceiro argumento `temStart`, que é a borda do botão de pausa — a SEGUNDA saída do
-         * modo (ADR-0044 item 7). No cartucho ela chega por outra rota (o encaminhador do gamepad, `main.ts:1470`)
-         * que esta raiz ainda não monta. Logo: o direcional navega a barra; sair por START, por enquanto, não.
+         * 📌 `ui/menu-nav` calls `navBar` with `(i, k)` and never the third argument, the START edge — the SECOND way out of
+         * the mode (ADR-0044 item 7). That one arrives through the gamepad transport, which this root mounts below.
          */
-        naBarraDe: cartucho.naBarraDe ?? ((i) => pauseIcons.naBarraDe(i)),
-        navBar: cartucho.navBar ?? ((i, k) => pauseIcons.navBar(i, k)),
-        isCapturing: () => false,
-        closePadWiz: () => { },
+        onBar: isOnBar,
+        navBar,
+        // ⚠️ NOT `() => false`: the remapping panel captures a key (ADR-0151), and without this the arrow the child wants to
+        // record would move the menu instead of landing on the key.
+        isCapturing: () => keyboardControls?.isCapturing() ?? false,
+        // Escape on the controller-mapping panel (`#padwiz`) closes it the way «Voltar» does: through the panel's own closer,
+        // registered with the overlays, which cancels a running wizard without storing its map.
+        closePadWiz: () => { overlays.closeById('padwiz'); },
         whichPlayer: (code) => keyboard.whichPlayer(code),
         actionOf: (code, i) => keyboard.actionOf(code, i),
-        // Achado 12, RESOLVIDO NA ENGINE: o ctx tipava `win` com `fn: (e: never) => void`, o `window` real não
-        // casava, e cada consumidor escrevia o mesmo adaptador de uma linha. A porta agora é genérica sobre
-        // `WindowEventMap` (ver `EventTargetLike` em input/touch-bindings), então o `window` entra direto.
+        // 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.
         win,
     });
-    // ⚠️ E AGORA LIGA. A `nav` era montada aqui e ficava desligada — `MenuNavApi.attach()` existia, `menu-nav.ts`
-    // descrevia-a como estando ali "para o game.js instalar exatamente como antes", e `createGame` nunca a
-    // chamava. O efeito num jogo que arranque pela engine: os diálogos de acessibilidade e o menu de pausa
-    // respondem só ao RATO, o que é o pilar 2 a falhar por inteiro — e o `consumer-quiz` teve de a chamar à mão
-    // depois do `createGame`, que é o sintoma da fronteira estar no lugar errado.
-    //
-    // Um fio que a engine MONTA e não liga é pior do que um que ela não monta: a ausência seria visível — o
-    // objeto tem uma `nav`, e ela parece pronta.
+    // ⚠️ AND IT IS SWITCHED ON. A wire the engine MOUNTS and does not switch on is worse than one it does not mount: the
+    // absence would be visible — the object has a `nav`, and it looks ready — while the accessibility dialogs and the pause
+    // menu answered only to the MOUSE, pillar 2 failing whole.
     //
-    // Instalar aqui é seguro antes de o jogo acabar de arrancar: sem diálogo aberto e sem menu de pausa,
-    // `menuNavKey` não consome tecla nenhuma e a deixa seguir para quem for o dono.
+    // Attaching here is safe before the game finishes booting: with no dialog open and no pause menu, `menuNavKey`
+    // consumes no key and lets it go on to its owner.
+    /*
+     * 🔴 ONE BUTTON ONLY TAKES THE KEY BEFORE EVERYONE ELSE (ADR-0218, issue #201), and that is why this listener is registered
+     * HERE, above `nav.attach()`, instead of beside the cool-down and the simulations further down.
+     *
+     * With the scan on, the child has ONE input in the world, and every press of it means the same thing: take what is showing.
+     * It must not also move a menu, reach the game or feed the motor filters — so the press is stopped dead (`barrar`) and the
+     * scan decides what happens. Listeners on one node run in the order they were registered, and `stopImmediatePropagation`
+     * only reaches the ones after it: registered below the menu navigation, this would have let the menu move AND the scan take,
+     * which is one press doing two things.
+     *
+     * ⚠️ `scanPress` is filled in much later, where the virtual controller exists. Until then, and whenever the scan is off,
+     * this listener answers nothing — the same hoisting the pause card's host uses, and for the same reason: what has to run
+     * first is not what can be built first.
+     */
+    const blockKey = (e) => { e.preventDefault(); e.stopImmediatePropagation(); };
+    let scanPress = null;
+    win.addEventListener('keydown', (e) => {
+        if (!state.switchScan || !scanPress || keyboard.whichPlayer(e.code) < 0)
+            return;
+        // A HELD KEY IS ONE PRESS, not one a frame: a child who cannot let go would otherwise take an item every repeat.
+        if (!e.repeat)
+            scanPress(sourceOfEvent(e) ?? 'teclado');
+        blockKey(e);
+    }, true);
+    win.addEventListener('keyup', (e) => {
+        if (state.switchScan && scanPress && keyboard.whichPlayer(e.code) >= 0)
+            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
+    // keyboard.
     nav.attach();
-    // ⚠️ E A ARMADILHA DE FOCO, que não existia em lado nenhum — os outros dois fios eram montados e deixados
-    // desligados; este nunca tinha sido escrito. Com um overlay aberto, o Tab entrava no tabuleiro por baixo,
-    // enquanto todo `.overlay__card` do documento diz `aria-modal="true"`. Uma promessa que o teclado desmente
-    // é pior do que promessa nenhuma: quem usa leitor de tela sai para um jogo cujo estado não percebe.
+    // ⚠️ AND THE FOCUS TRAP. With an overlay open, Tab went into the board underneath, while every `.overlay__card` in the
+    // document says `aria-modal="true"`. A promise the keyboard contradicts is worse than no promise: a screen-reader user
+    // steps out into a game whose state they do not understand.
     initFocusTrap({
-        overlayDeCima: overlays.topVisibleOverlay,
-        focoAtual: () => doc.activeElement,
-        focaveisDe: focaveisNoDom,
+        topOverlay: overlays.topVisibleOverlay,
+        currentFocus: () => doc.activeElement,
+        focusablesIn: focusablesInDom,
         win,
     }).attach();
     /**
-     * O ALCANCE: entre os transportes DISPONÍVEIS a esta criança, algum carrega as ações deste jogo?
+     * THE REACH: among the transports AVAILABLE to this child, does any carry this game's actions?
      *
-     * ⚠️ A detecção segue o que o projeto JÁ usa para a mesma pergunta (`isCoarsePointer` em `game/session`):
-     * `pointer:coarse && hover:none` é toque, e o contrário é teclado. Ela erra num tablet COM teclado — e o
-     * erro só é tolerável porque a tela INFORMA em vez de recusar. Ver o cabeçalho de `ui/reach-notice`.
+     * ⚠️ The detection: `pointer:coarse && hover:none` is touch, and the opposite is keyboard. It is wrong on a tablet WITH
+     * a keyboard — and the error is tolerable only because the screen INFORMS instead of refusing. See the header of
+     * `ui/reach-notice`.
      */
-    const disponibilidade = o.disponibilidade ?? {
+    const deviceAvailability = o.availability ?? {
         gamepad: () => { try {
             return [...(win.navigator?.getGamepads?.() ?? [])].some(Boolean);
         }
         catch {
             return false;
         } },
-        toque: () => { try {
+        touch: () => { try {
             return win.matchMedia('(pointer:coarse)').matches && win.matchMedia('(hover:none)').matches;
         }
         catch {
             return false;
         } },
-        teclado: () => { try {
+        keyboard: () => { try {
             return !(win.matchMedia('(pointer:coarse)').matches && win.matchMedia('(hover:none)').matches);
         }
         catch {
             return true;
         } },
         /**
-         * O RATO (ADR-0112) — e a sonda é `any-pointer` de propósito, não `pointer`.
+         * THE MOUSE (ADR-0112) — and the probe is `any-pointer` on purpose, not `pointer`.
          *
-         * ⚠️ `(pointer:fine)` descreve o ponteiro PRIMÁRIO, então um tablet com rato ligado responde «coarse» e
-         * o rato desaparecia — exactamente o aparelho que esta pergunta existe para achar. `any-pointer:fine` diz
-         * «ALGUM dos dispositivos apontadores é fino», que é a pergunta certa: para desenhar basta um.
+         * ⚠️ `(pointer:fine)` describes the PRIMARY pointer, so a tablet with a mouse plugged in answers coarse and the mouse
+         * disappeared — exactly the device this question exists to find. `any-pointer:fine` says ANY of the pointing devices
+         * is fine, which is the right question: to draw, one is enough.
          *
-         * ⚠️ ELA ERRA, e a direcção do erro é a que se aceita: um stylus também responde `fine`, e é um ponteiro
-         * a sério — logo isso não é erro. O que pode faltar é um rato ligado depois do arranque, e por isso a
-         * sonda é uma FUNÇÃO, avaliada a cada pergunta, como as três acima.
+         * ⚠️ A stylus also answers `fine`, and it is a real pointer — so that is not an error. What can be missing is a mouse
+         * plugged in after boot, which is why the probe is a FUNCTION, evaluated at every question, like the three above.
          */
-        rato: () => { try {
+        mouse: () => { try {
             return win.matchMedia('(any-pointer:fine)').matches;
         }
         catch {
             return false;
         } },
     };
-    // O segundo eixo entra aqui, e vem do jogo (ADR-0104 §A): quantas posições ele segura ao mesmo tempo.
-    // ⚠️ O TERCEIRO EIXO ENTRA AQUI (ADR-0112), e vem do jogo tal como os outros dois. `?? false` e não um
-    // padrão inventado: o campo é opcional de propósito — ver a nota nele —, e a ausência significa «este jogo
-    // não desenha», que é a resposta certa para a esmagadora maioria dos trezentos.
-    /*
-     * O ALCANCE E O SEU AVISO, numa função, porque os dois dependem do cartucho e o segundo CRIA DOM.
-     *
-     * ⚠️ O aviso é o único sítio desta raiz que escreve um elemento a partir de uma resposta do jogo, e por
-     * isso é o único que precisa de ser RETIRADO antes de ser reescrito: `mostrarAvisoDeAlcance` cria um `div`
-     * com `id` fixo, então chamá-lo duas vezes deixaria dois — e o segundo cartucho ficaria com o aviso do
-     * primeiro por baixo do seu.
-     *
-     * 📌 `retirarAvisoDeAlcance()` corre SEMPRE antes, e não só quando há o que mostrar: um cartucho que não
-     * tem nada a avisar tem de apagar o aviso do anterior, e é esse o caso que se esquece.
-     */
-    function retirarAvisoDeAlcance() {
-        const aviso = $(`#${REACH_NOTICE_ID}`);
-        if (!aviso)
-            return;
-        // ⚠️ CAPACIDADE E NÃO TIPO, pela mesma razão que este ficheiro já escreve mais acima sobre o
-        // `instanceof HTMLElement`: o hospedeiro pode ser um documento falso, e os que estes testes usam têm
-        // `parentNode` mas não `remove`. Perguntar pelo método é o que funciona nos dois.
-        if (typeof aviso.remove === 'function')
-            aviso.remove();
+    // The second axis (ADR-0104 §A) and the third (ADR-0112) come from the game, like the first: how many positions it
+    // holds at once, and whether it needs a pointer. `?? false` and not an invented default: the field is optional on
+    // purpose — see its note —, and its absence means the game does not draw.
+    /*
+     * THE REACH AND ITS NOTICE, in one function, because both depend on the cartridge and the second CREATES DOM.
+     *
+     * ⚠️ The notice is the only place in this root that writes an element from a game's answer, and so the only one that
+     * must be REMOVED before being rewritten: `showReachNotice` creates a `div` with a fixed `id`, so calling it twice
+     * would leave two — and the second cartridge would have the first one's notice under its own.
+     *
+     * 📌 `removeReachNotice()` ALWAYS runs first, not only when there is something to show: a cartridge with nothing to
+     * warn about must erase the previous one's notice, and that is the case that gets forgotten.
+     */
+    function removeReachNotice() {
+        const notice = $(`#${REACH_NOTICE_ID}`);
+        if (!notice)
+            return;
+        // ⚠️ CAPABILITY AND NOT TYPE, for the reason this file gives about `instanceof HTMLElement`: the host may be a fake
+        // document, and the ones these tests use have `parentNode` but no `remove`. Asking for the method works in both.
+        if (typeof notice.remove === 'function')
+            notice.remove();
         else
-            aviso.parentNode?.removeChild(aviso);
-    }
-    function derivarAlcance() {
-        const acoes = cartucho.preset ? presetActions(cartucho.preset) : [];
-        const a = alcance(transportesPadrao(disponibilidade), acoes, cartucho.declaration.holdsAtOnce(), cartucho.declaration.needsPointer?.() ?? false);
-        retirarAvisoDeAlcance();
-        // ⚠️ SÓ APARECE QUANDO HÁ O QUE DIZER. Um aviso que aparece sempre deixa de ser lido, e um jogo cujas
-        // ações cabem no toque não tem nada a avisar — que é o caso comum e tem de continuar silencioso.
-        if (acoes.length) {
-            mostrarAvisoDeAlcance({
-                procurar: (sel) => $(sel),
-                criar: (tag) => doc.createElement(tag),
+            notice.parentNode?.removeChild(notice);
+    }
+    function deriveReach() {
+        const declaredActions = cartridge.preset ? presetActions(cartridge.preset) : [];
+        const a = reach(defaultTransports(deviceAvailability), declaredActions, cartridge.declaration.holdsAtOnce(), cartridge.declaration.needsPointer?.() ?? false);
+        removeReachNotice();
+        // ⚠️ IT APPEARS ONLY WHEN THERE IS SOMETHING TO SAY. A notice that always appears stops being read, and a game whose
+        // actions fit the touch screen has nothing to warn about — the common case, which must stay silent.
+        if (declaredActions.length) {
+            showReachNotice({
+                find: (sel) => $(sel),
+                create: (tag) => doc.createElement(tag),
                 t,
                 srAlert,
             }, a);
         }
         return a;
     }
-    let alcanceAtual = derivarAlcance();
-    // O ANÚNCIO DE QUE O LAÇO PAROU (ADR-0054). Entregue e não instalado: quem chama `startLoop` é o JOGO, que
-    // é o dono do ticker. Um jogo que monte o laço sem passar isto continua a PARAR — parar não é opcional; o
-    // que ele perde é dizer que parou.
-    const aoFalhar = criarAvisoDeQueda({
-        procurar: (sel) => $(sel),
-        criar: (tag) => doc.createElement(tag),
-        narrar: (texto) => tts.narrate(texto),
+    let currentReach = deriveReach();
+    /*
+     * THE RESOLUTION IS THE ENGINE'S (ADR-0163), and the cartridge has no other. The Dev: «A Engine deve forçar isso e
+     * guiar esta construção, de modo que o cartucho não tenha alternativa». The region gets the largest integer multiple
+     * of 320×180 in REAL pixels that fits the stage, never less than 640×360, with the tolerance of ≤5 logical px cut
+     * per side — and again at every window resize (ADR-0001).
+     * ⚠️ The STAGE is the `#stage-wrap`/`.stage-wrap` shell when it exists; without it, the region's parent — the room it has.
+     * ⚠️ BY CAPABILITY, like the rest: a double without `style.setProperty` is not resized, and the boot does not fall for it.
+     */
+    let appliedScale = null;
+    /**
+     * What departs is SAID (ADR-0163 rule 4): the region's measured size against the one the engine gave it, read when
+     * `problems` is read — a cartridge that resizes the region after boot is seen then, and the line goes when it stops.
+     */
+    function regionResizedByCartridge() {
+        const regionEl = $('#game-region');
+        if (!appliedScale || !regionEl || typeof regionEl.getBoundingClientRect !== 'function')
+            return null;
+        const r = regionEl.getBoundingClientRect();
+        if (!r.width || !r.height)
+            return null; // not laid out: nothing measured, nothing to accuse
+        const { width: scaledWidth, height: scaledHeight } = appliedScale;
+        if (Math.abs(r.width - scaledWidth) < 1 && Math.abs(r.height - scaledHeight) < 1)
+            return null;
+        return `the cartridge sized #game-region to ${Math.round(r.width)}×${Math.round(r.height)} over the engine's `
+            + `${Math.round(scaledWidth)}×${Math.round(scaledHeight)}: text and targets stop following the screen, so a child with low vision `
+            + 'gets them small — the resolution is the engine\'s (ADR-0163): lay the game out inside the region and read `--ui-fs` and `--alvo-min`';
+    }
+    /*
+     * THE CONTEXT OF THE TWO DRAWING REPORTERS (`ui/drawing-problems`), and the three readers are FUNCTIONS on purpose: the
+     * region, the bar and the scale are things this root SWAPS — a `mount()` swaps the cartridge, the bar is born after the
+     * root, and the scale changes at every `resize`. Passing them by value would freeze the first answer, and an element
+     * out of the page still answers `getBoundingClientRect()` without complaint.
+     */
+    const drawingContext = {
+        region: () => $('#game-region'),
+        bar: () => a11yBar,
+        scale: () => appliedScale,
+        computedStyle: typeof win.getComputedStyle === 'function' ? (el) => win.getComputedStyle(el) : undefined,
+    };
+    function applyResolution() {
+        const regionEl = $('#game-region');
+        const stage = $('#stage-wrap') ?? $('.stage-wrap') ?? (regionEl?.parentElement ?? null);
+        if (!regionEl || !stage || typeof regionEl.style?.setProperty !== 'function')
+            return;
+        const { w, h } = screenBaseSize(Math.max(1, players().length));
+        appliedScale = stageScale(stage.clientWidth || w, stage.clientHeight || h, win.devicePixelRatio || 1, w, h);
+        applyScale(regionEl, appliedScale);
+        crtScanVars(); // the scanline period is one art pixel in REAL pixels, so it follows the scale (study item A5)
+        reserveBarBand();
+    }
+    /**
+     * THE ROOM THE GAME LEAVES FREE UNDER THE TOP EDGE (ADR-0148 §3, erratum of 2026-09-13; issue #160), written as
+     * `--barra-a11y-h` on the region: the bar's own offset, the bar, the line of the pointed icon's NAME under it, and a
+     * light gap of a quarter of that line's font (4 px at 640×360). 📏 Measured at 640×360: the variable said 44 px (the bar alone) and the name, at
+     * 57–87 px, covered the quiz statement. The Dev: «é necessário que exista um leve espaçamento abaixo da barra».
+     * 📌 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.
+     */
+    function reserveBarBand() {
+        reserveTopBand({
+            region: $('#game-region'),
+            bar: a11yBar,
+            hud: hudMounted,
+            ...(typeof win.getComputedStyle === 'function' ? { computedStyle: (el) => win.getComputedStyle(el) } : {}),
+        });
+    }
+    /*
+     * THE HUD the engine mounts from the cartridge's `hud` (ADR-0168; issue #162). Read on every animation frame while mounted —
+     * the numbers are functions, so a game never has to say «refresh»; only a changed text is written, and a changed text
+     * measures the room again, because a longer number can wrap.
+     */
+    let hudMounted = null;
+    let hudFrame = false;
+    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);
+        reserveBarBand();
+        if (hudMounted && !hudFrame && typeof win.requestAnimationFrame === 'function') {
+            hudFrame = true;
+            const position = () => {
+                if (!hudMounted) {
+                    hudFrame = false;
+                    return;
+                }
+                if (hudMounted.refresh())
+                    reserveBarBand();
+                win.requestAnimationFrame(position);
+            };
+            win.requestAnimationFrame(position);
+        }
+    }
+    mountHud();
+    applyResolution();
+    if (typeof win.addEventListener === 'function')
+        win.addEventListener('resize', applyResolution);
+    /*
+     * THE SKIP LINK, when the page has none (study item C5; WCAG 2.4.1). The stylesheet rule, the dictionary sentence and its
+     * layer (ADR-0102) already existed, and the element depended on each page remembering it: the quiz writes its own, and a
+     * cartridge page that did not copy it left a keyboard no way over what precedes the game. First in the body, so it is the
+     * first thing a keyboard reaches; a page's own link is kept. By capability: a host double without a body mounts nothing.
+     */
+    if (doc.body && typeof doc.body.insertBefore === 'function' && !$('.skip-link')) {
+        const skipLink = doc.createElement('a');
+        skipLink.className = 'skip-link';
+        skipLink.setAttribute('href', '#game-region');
+        skipLink.setAttribute('data-i18n', 'skip.toGame');
+        skipLink.textContent = t('skip.toGame');
+        doc.body.insertBefore(skipLink, doc.body.firstChild); // `data-i18n`: every `setLocale` rewrites it, the boot's included
+    }
+    /*
+     * THE LETTER CASE REACHES THE PAGE (ADR-0028; ADR-0149 §1). The stylesheet capitalises under `:root[data-letras="upper"]`,
+     * and nothing wrote that attribute: the communication button's first position kept «capitals» in the state and showed
+     * natural case (reported by the Dev). Written at every change, and at boot only when the child CHOSE a case — the state's
+     * default is `upper` (ADR-0028) while the cycle's default is position (c), natural case (ADR-0149), and writing the default
+     * would put every new child's game in capitals.
+     */
+    const writeBox = (c) => {
+        if (doc.documentElement?.dataset)
+            doc.documentElement.dataset.letras = c;
+    };
+    if (store.get(KEYS.letterCase, null) !== null)
+        writeBox(state.letterCase);
+    stateOn('letterCase', writeBox);
+    {
+        /*
+         * THE BAR IS HUD, AND THE GAME DOES NOT WRITE OVER IT (ADR-0148 §3). `#title-icons` is `position:absolute` INSIDE
+         * `#game-region`, and a game's heading can take the same pixels: the child looking for blind mode finds the question's
+         * title over the buttons, with no error, no type, no console — and whoever depends on the row most is whoever cannot
+         * see it is covered.
+         *
+         * 📌 THE ENGINE SAYS, and does not fix — because it cannot. Pushing the game's content would mean changing the width
+         * and height `ui/layout` locks to an integer multiple of real pixels, which is ADR-0001's scale. The engine has the
+         * rectangle; the game draws, and now knows where not to draw. The reserved room itself (`--barra-a11y-h`, next to
+         * `--tap` and `--alvo-min`) is written by `reserveBarBand`, inside `applyResolution`.
+         *
+         * ⚠️ BY CAPABILITY AND NOT BY TYPE: a fake document has no `getBoundingClientRect`, and reading it blindly would bring
+         * the boot down where there is no DOM. Without the measure, nobody is accused: silence beats an invented accusation.
+         */
+        const intruders = barIntruderProblems(drawingContext);
+        if (intruders.length) {
+            hostProblems.push(`the game draws over the accessibility bar (${intruders.slice(0, 4).join(', ')}): a child who needs its buttons `
+                + 'to start cannot reach them — read `--barra-a11y-h` on #game-region and leave that room free (ADR-0148)');
+        }
+    }
+    const announceFailure = createCrashNotice({
+        t: translator.t,
+        find: (sel) => $(sel),
+        create: (tag) => doc.createElement(tag),
+        narrate: (text) => tts.narrate(text),
     });
     /*
-     * ⚠️ MOSTRAR REFAZ OS ITENS ANTES DE REVELAR, e a ordem é a regra: o §5 do ADR-0106 diz que a criança nunca
-     * vê um item que não acciona, e a tabela de acções deste jogo pode ter mudado desde a montagem. Revelar
-     * primeiro e refazer depois deixaria um piscar em que ela vê o que não pode usar.
+     * ⚠️ SHOWING REBUILDS THE ITEMS BEFORE REVEALING, and the order is the rule: ADR-0106 §5 says the child never sees an
+     * item that does not act, and this game's action table may have changed since mounting. Revealing first and
+     * rebuilding after would leave a blink in which she sees what she cannot use.
      */
-    const pausa = {
-        mostrar: (i) => {
+    const pauseControls = {
+        show: (i) => {
             pauseIcons.reflectPauseIcons();
-            const cartao = $(`#vp-pause-${i}`);
-            if (cartao)
-                cartao.hidden = false;
+            const findPauseCard = $(`#vp-pause-${i}`);
+            if (!findPauseCard)
+                return;
+            findPauseCard.hidden = false;
+            updateCaption();
+            // 🔴 THE CURSOR LANDS ON ITEM 1, at the root (ADR-0158: «a saída é onde o cursor cai ao abrir»). Without it, opened
+            // by SELECT no item was marked, and the first arrow jumped to item 2.
+            showPauseOptions(findPauseCard, 'raiz');
         },
-        esconder: (i) => {
-            const cartao = $(`#vp-pause-${i}`);
-            if (cartao)
-                cartao.hidden = true;
+        hide: (i) => {
+            const findPauseCard = $(`#vp-pause-${i}`);
+            if (findPauseCard)
+                findPauseCard.hidden = true;
+            updateCaption();
         },
     };
     /*
-     * AS COISAS PESADAS COMEÇAM A DESCER AQUI, e a linha é deliberadamente a ÚLTIMA coisa do arranque.
+     * ===================== THE KEYS THAT OPEN THE PAUSE (ADR-0144, ADR-0155) =====================
+     *
+     * ⚠️ BUBBLING, NOT CAPTURE. `menuNavKey` runs in CAPTURE with `stopPropagation()`, and the header of `ui/menu-nav` keeps
+     * TWO preserved defects about it — today's correct behaviour depends on that `stopPropagation()` and not on the
+     * registered chain. Putting a second meaning in the same phase would lean on that accidental safety net. In bubbling,
+     * `menuNavKey` always has the first refusal, and the game's OWN listener — which lives in `#game-region`, under the
+     * window — runs before these. Whoever owns the key stays its owner.
      *
-     * ⚠️ SEM `await`. O arranque não espera por 241 MB — se esperasse, a primeira tela de uma escola com 3G
-     * ficaria em branco durante minutos e a criança concluiria que o jogo não abre. O `catch` vazio é a mesma
-     * regra escrita duas vezes: uma falha de rede aqui não pode derrubar um jogo que hoje nem usa a voz.
+     * 📏 AND `menuNavKey` DOES NOT EAT these keys: `menuKeyIntent` (`ui/menu-intent`) has no branch for `start`, `select`
+     * or `action4` (only `action2`, `action3` and the four directions), so it finds no intent and lets them go. That is
+     * why the guards below exist — in real situations the key arrives here and is not ours.
+     *
+     * ⚠️ THE ENGINE OPENS THE CARD; THE GAME STOPS THE WORLD (ADR-0144 §2). Freezing physics and silencing the ambience are
+     * the game's, so the second half is a request, `setPhase('paused')`, and not an order.
+     */
+    /** The seat that owns a key, if it is ITS `presetAction` position; otherwise `null`. */
+    function seatOfPosition(code, presetAction) {
+        // ⚠️ THE KEY'S OWNER DECIDES THE SEAT, as in `menuNavKey`: whoever pressed opens THEIR pause. A key that is nobody's
+        // (`-1`) cannot be any seat's «start» — asking seat 0 about it would hand Player 1's pause to whoever pressed a loose
+        // key.
+        const keyOwner = keyboard.whichPlayer(code);
+        if (keyOwner < 0)
+            return null;
+        return keyboard.actionOf(code, keyOwner) === presetAction ? keyOwner : null;
+    }
+    /*
+     * ===================== THE QUICK PAUSE — START (ADR-0155) =====================
      *
-     * 🔴 E O RELATÓRIO NÃO VAI PARA `problems`, embora a primeira versão o fizesse. Duas razões medidas, e a
-     * primeira é a que importa:
+     * The game FREEZES (`setPhase('paused')` is asked, as ADR-0144 §2 asked for the card), the directional goes to the BAR,
+     * and the word PAUSED appears in the centre. No card is drawn: it is the print view.
      *
-     *  1. **CHEGA DEPOIS DE O LEITOR SE IR EMBORA.** `problems` é devolvido na linha abaixo, sincronamente; a
-     *     descarga é de fundo, logo TODA linha dela entraria num vector que o consumidor já leu. Quem faz
-     *     `if (motor.problems.length) …` não veria nada, e quem o lesse mais tarde veria uma lista que cresceu
-     *     depois do arranque. Um relatório que chega depois do leitor não é um relatório — é a forma exacta do
-     *     `srSay` a escrever onde não havia `#sr-status`.
-     *  2. **AFOGAVA O QUE SE PODE RESOLVER.** Sem rede — uma escola sem rede, que é o alvo e não a excepção —
-     *     são OITO falhas a empurrar para uma lista que o ADR-0106 §2 construiu para dizer o que FALTA NO
-     *     HOSPEDEIRO. A criança perde a barra de acessibilidade e a linha que o diz fica em nono lugar.
+     * 📌 ONE WAY OUT, by any door. «Voltar» on the bar, START again and SELECT all end in `pauseIcons.leaveBar`, and the
+     * `onLeaveBar` hook is what unfreezes. Two ways out written apart would be two chances for one of them to leave the
+     * world stopped with the child back on the character.
      *
-     * 📌 O canal certo é o que a própria função já tem: `aoProgredir`, entregue a quem chama. Um consumidor que
-     * queira mostrar «faltam 241 MB» ou «a voz não desceu» tem por onde; a engine não inventa uma superfície.
+     * ⚠️ AND THE STATE IS IN-QUICK-PAUSE, not on-the-bar: a host without `#title-icons` has no bar to enter, and the quick
+     * pause still freezes and says PAUSED — with START leaving it. Asking the bar would trap that child in a stopped game.
      */
-    if (o.baixarPesados !== false) {
-        void baixarPesados({ aoProgredir: o.aoProgredirPesados })
-            .catch(() => { });
+    let pausedWord = null;
+    /*
+     * THE FOOTER LEGEND of the frozen screen (ADR-0155 erratum): «Ação 2: confirmar · Ação 3: voltar · Ação 4: menu ·
+     * START: voltar ao jogo». It is the menus' second door — `action4` — and it also tells the child SELECT is not the
+     * only one: the stopped screen teaches how to leave it and where to.
+     * (`pauseCaption` is declared before `changePhase`; see there.)
+     */
+    function showPaused() {
+        const regionEl = $('#game-region');
+        if (!pausedWord && regionEl && typeof regionEl.appendChild === 'function') {
+            pausedWord = doc.createElement('div');
+            pausedWord.className = 'pausa-rapida';
+            // The screen reader already hears the entry into the bar, which says the game stopped and how to go back; the word
+            // is for the eyes, and said twice it trampled the announcement that teaches the way out.
+            pausedWord.setAttribute('aria-hidden', 'true');
+            regionEl.appendChild(pausedWord);
+        }
+        if (!pausedWord)
+            return;
+        // resolved WHEN SHOWN: the language may have changed since boot
+        pausedWord.textContent = t('pause.quick');
+        pausedWord.hidden = false;
+        updateCaption();
+    }
+    /**
+     * THE BUTTON LEGEND FOLLOWS THE SCREEN (ADR-0164 rule 3): on the quick pause it says the quick pause's buttons, on the
+     * pause card (SELECT) the menu's — «2: confirmar · 3: voltar» —, and nothing in play. Asked again whenever one of them
+     * opens or closes; a card hidden by a path that calls nothing here (the print mode) is seen by the observer below.
+     */
+    function updateCaption() {
+        const cardOpen = !!$('.screen-pause:not([hidden])');
+        const text = inQuickPause.size ? t('pause.quick.legenda') : cardOpen ? t('pause.card.legenda') : null;
+        if (!text) {
+            if (pauseCaption)
+                pauseCaption.hidden = true;
+            return;
+        }
+        if (!pauseCaption) {
+            const home = screenFooter($('#game-region'));
+            if (!home)
+                return;
+            pauseCaption = doc.createElement('div');
+            pauseCaption.className = 'pausa-legenda';
+            pauseCaption.setAttribute('aria-hidden', 'true');
+            home.appendChild(pauseCaption);
+        }
+        writeCaption(pauseCaption, text); // resolved when shown: the language may have changed since boot
+        pauseCaption.hidden = false;
+    }
+    /*
+     * EVERY CHANGE OF CONTEXT IS ANNOUNCED (ADR-0159 rule 3): «Opening a menu or panel speaks its title; closing it speaks
+     * where the child is back to; entering play is announced.» 📏 Measured in the dist: SELECT opened the card in silence,
+     * and a panel opened, closed and went back to the root without a word.
+     * 📌 ONE PLACE, by comparison: the observer below asks where the child is now — a panel, a list of the card, or the
+     * game — and speaks only when that changed. An arrow changes no `hidden`, so it still says only the item.
+     */
+    let screenAnnounced = 'jogo';
+    const rootWithIndex = () => (cartridge.withIndex ?? (() => true))();
+    /*
+     * 🔴 THE QUESTION LIVES IN `ui/where-the-child-is` (ADR-0221 step 7c); what stays here is answering where it reads the
+     * document from. Whether this is a panel, a list of the card or the game, and what it is called, is a rule with a
+     * reason — not wiring — and ADR-0221's erratum measures a root's debt in branches.
+     */
+    const whereIsTheChild = () => whereTheChildIs({
+        t: translator.t,
+        topVisibleOverlay: overlays.topVisibleOverlay,
+        pauseCard: () => $('.screen-pause:not([hidden])'),
+        focused: () => doc.activeElement,
+        withIndex: rootWithIndex,
+    });
+    function announceContext() {
+        const nowMs = whereIsTheChild();
+        if (nowMs.key === screenAnnounced)
+            return;
+        const cameFromMenu = screenAnnounced !== 'jogo';
+        screenAnnounced = nowMs.key;
+        if (nowMs.sentence)
+            srSay(nowMs.sentence);
+        // back in play from a menu — the quick pause says its own exit
+        else if (cameFromMenu && !inQuickPause.size)
+            srSay(t('sr.a11y.barExit'));
+    }
+    {
+        const regionEl = $('#game-region');
+        const Observer = win.MutationObserver;
+        if (regionEl && Observer && typeof regionEl.appendChild === 'function') {
+            new Observer((records) => {
+                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')))
+                    announceContext();
+                // 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();
+                // a simulation stops while a menu is open and comes back with the game (issue #182)
+                if (classes.some((c) => c?.contains('screen-pause') || c?.contains('overlay')))
+                    recomposeWorldFilter();
+            }).observe(regionEl, { attributes: true, attributeFilter: ['hidden'], subtree: true });
+        }
+    }
+    /*
+     * THE SCREEN FOOTER: one column, at the bottom of the region, with the EXPLANATION of the pointed icon above the quick
+     * pause's LEGEND. The Dev's request — the name under the row, what it does in the footer (`CLAUDE.md` §4, the three
+     * zones).
+     * ⚠️ ONE COLUMN and not two bands positioned apart: the quick pause lands the cursor on the first icon on entering, so
+     * both appear together from the first instant, and two absolute boxes covered each other when one wrapped.
+     */
+    function screenFooter(regionEl) {
+        if (footer || !regionEl || typeof regionEl.appendChild !== 'function')
+            return footer;
+        footer = doc.createElement('div');
+        footer.className = 'rodape-da-tela';
+        regionEl.appendChild(footer);
+        return footer;
+    }
+    /**
+     * The button legend as one dark chip per «name: function» (ADR-0164 rule 3) — the dictionary writes the items joined
+     * by « · », and each becomes its own element so the background sits behind the words and not across the screen.
+     */
+    function writeCaption(home, text) {
+        home.textContent = '';
+        text.split('·').map((s) => s.trim()).filter(Boolean).forEach((item, i) => {
+            // a space between chips, by capability: a host document without createTextNode still gets the chips
+            if (i > 0 && typeof doc.createTextNode === 'function')
+                home.appendChild(doc.createTextNode(' '));
+            const name = doc.createElement('span');
+            name.className = 'lg-nome';
+            name.textContent = item;
+            home.appendChild(name);
+        });
+    }
+    function explainIconInFooter(k) {
+        writeInFooter(k ? t(`icon.${k}.dica`) : null);
+    }
+    /*
+     * THE SOUND CAPTION (study item D3). In the footer column, above the button legend and the explanation (ADR-0164 rule 4:
+     * «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.
+     */
+    let soundCaption = null;
+    let clearSoundCaption = null;
+    function writeSoundCaption(text) {
+        if (!state.captionsOn || !text)
+            return;
+        if (!soundCaption) {
+            const home = screenFooter($('#game-region'));
+            if (!home)
+                return;
+            soundCaption = doc.createElement('div');
+            soundCaption.className = 'legenda-de-som';
+            soundCaption.setAttribute('aria-hidden', 'true');
+            home.appendChild(soundCaption);
+        }
+        const captionHome = soundCaption;
+        captionHome.textContent = text;
+        captionHome.hidden = false;
+        if (clearSoundCaption !== null)
+            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). */
+    function writeInFooter(text) {
+        if (!barExplanation && text) {
+            const home = screenFooter($('#game-region'));
+            if (home) {
+                barExplanation = doc.createElement('div');
+                barExplanation.className = 'barra-explicacao';
+                barExplanation.setAttribute('aria-live', 'polite');
+                home.insertBefore(barExplanation, home.firstChild);
+            }
+        }
+        if (!barExplanation)
+            return;
+        barExplanation.textContent = text ?? '';
+        barExplanation.hidden = !text;
+    }
+    function enterQuickPause(seat) {
+        inQuickPause.add(seat);
+        recomposeWorldFilter(); // the quick pause is a menu: the simulation stops (issue #182)
+        pauseIcons.enterBar(seat);
+        if (!pauseIcons.onBar(seat))
+            srSay(t('sr.a11y.quickPause'));
+        showPaused();
+        changePhase('paused');
+    }
+    /** Leaves by any door. `to` says where: the game (unfreezes) or the card (stays stopped). */
+    function leaveQuickPause(seat, to) {
+        if (pauseIcons.onBar(seat)) {
+            pauseIcons.leaveBar(seat, to === 'cartao');
+            return;
+        } // the hook finishes the job
+        if (to === 'jogo')
+            srSay(t('sr.a11y.barExit'));
+        endQuickPause(seat, to === 'cartao');
+    }
+    function endQuickPause(seat, toOtherScreen) {
+        if (!inQuickPause.delete(seat))
+            return; // the simulation returns through the observer: leaving writes the card's `hidden`
+        if (pausedWord && inQuickPause.size === 0)
+            pausedWord.hidden = true;
+        if (!toOtherScreen)
+            changePhase('playing');
+    }
+    function toggleQuickPauseByStart(e) {
+        const seat = seatOfPosition(e.code, 'start');
+        if (seat === null)
+            return;
+        // 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;
+        // 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;
+        }
+        // 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;
+        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();
+    }
+    win.addEventListener('keydown', toggleQuickPauseByStart);
+    /*
+     * ===================== SELECT OPENS THE MENUS (ADR-0155) =====================
+     *
+     * The card of ADR-0151. `select` is mapped (`KeyF`, `input/default-bindings`), and ADR-0086 kept it for «what belongs
+     * to the session» — the pause menus are that.
+     *
+     * ⚠️ FROM THE QUICK PAUSE TO THE CARD the game does NOT unfreeze: the bar is left in silence (saying «back to the game»
+     * with the card opening would be a lie) and the phase is already `paused` — asking for it again would be a second
+     * `paused` in a stopped game.
+     */
+    /** Opens the seat's card, whichever door it comes from — the SELECT key, the ☰ or the touch pill. Returns whether it opened. */
+    function openSeatMenus(seat) {
+        if (overlays.topVisibleOverlay())
+            return false;
+        const findPauseCard = $(`#vp-pause-${seat}`);
+        if (!findPauseCard || findPauseCard.hidden === false)
+            return false;
+        const alreadyStopped = inQuickPause.has(seat);
+        if (alreadyStopped)
+            leaveQuickPause(seat, 'cartao');
+        // ⚠️ SHOWING COMES FIRST, and the order is the defence: a game without `setPhase` must get the card all the same.
+        pauseControls.show(seat);
+        if (!alreadyStopped)
+            changePhase('paused');
+        return true;
+    }
+    function openMenusBySelect(e) {
+        const seat = seatOfPosition(e.code, 'select');
+        if (seat === null)
+            return;
+        if (openSeatMenus(seat))
+            e.preventDefault();
+    }
+    win.addEventListener('keydown', openMenusBySelect);
+    /*
+     * THE MENUS' SECOND DOOR: `action4`, only INSIDE the quick pause (ADR-0155 erratum). Outside it `action4` is the game's,
+     * and the engine does not touch it — that is the pair that keeps the door from stealing a verb mid-match.
+     * 📏 `menuNavKey` has no intent for `action4` and, on the bar, lets it rise without consuming it: it arrives here.
+     */
+    function openMenusByAction4(e) {
+        const seat = seatOfPosition(e.code, 'action4');
+        if (seat === null || !inQuickPause.has(seat))
+            return;
+        if (overlays.topVisibleOverlay())
+            return;
+        leaveQuickPause(seat, 'cartao');
+        pauseControls.show(seat);
+        e.preventDefault();
+    }
+    win.addEventListener('keydown', openMenusByAction4);
+    /*
+     * ===================== THE VIRTUAL CONTROLLER (ADR-0143, plan phase 4) =====================
+     *
+     * 🔴 `mountTouchControls`, `initTouch` and `initTouchBindings` are wired HERE: in a school where the device is a tablet
+     * with no keyboard, a game booted by this root has to be playable, and nothing else would call them.
+     *
+     * 📌 THE PAD IS DRAWN ONLY WHEN THE CARTRIDGE ASKS FOR IT (`onScreenPad`, ADR-0166): a game played by touching its own
+     * elements needs none. What it lacks is said in `problems` (`touchGaps`); with no `preset` it carries only START and
+     * SELECT, the doors to the pause, which is not declinable (ADR-0122).
+     */
+    const touchHostEl = o.host.touchHost ?? $('#game-region');
+    const touchUsable = !!touchHostEl && typeof touchHostEl.appendChild === 'function';
+    const seat0CardOpen = () => {
+        const c = $('#vp-pause-0');
+        return !!c && c.hidden === false;
+    };
+    /** A menu the directional moves is open: an overlay, the seat-0 card, or the quick pause (ADR-0157). */
+    const menuWithDpad = () => !!overlays.topVisibleOverlay() || seat0CardOpen() || inQuickPause.has(0);
+    /** A position's key handed to the menus, which read keys — stamped with who produced it (ADR-0109). */
+    const keyToMenu = (code, origin) => {
+        // 🔴 THE KEYBOARD'S KEY IS ALREADY IN THE WORLD (ADR-0223). This function translates POSITION → key, and it exists for
+        // the transports that produce no keys: the finger, the eyes, the face, the hands, the voice, the scan. The keyboard
+        // does — the event that got here IS the key — so dispatching it again would move the menu TWICE.
+        // 📌 Because this is written here, the keyboard conductor need not ask whether a menu is open: that question has ONE
+        // answer, the controller's, and this line is what makes it true for the keyboard too.
+        if (!origin || origin === 'teclado')
+            return;
+        const eventTarget = $('#game-region') ?? doc.body;
+        eventTarget.dispatchEvent(stampSource(new KeyboardEvent('keydown', { code, key: code, bubbles: true, cancelable: true }), origin));
+    };
+    const labelledActions = () => {
+        const preset = cartridge.preset;
+        if (!preset)
+            return [];
+        const labelOf = labellerFrom(preset);
+        return presetActions(preset).flatMap((a) => {
+            const label = labelOf(a);
+            return label ? [{ action: a, label }] : [];
+        });
+    };
+    const touchPad = initTouch({
+        $, srSay, store, win, t: translator.t,
+        gameActions: labelledActions,
+        root: doc.documentElement,
+        isMobile: deviceAvailability.touch,
+        viewport: () => ({ w: win.innerWidth, h: win.innerHeight }),
+        frontOverlay: overlays.frontOverlay,
+        // Touch always belongs to Player 1 (`touch-bindings`), and with the card or a panel open the child touches the menu's
+        // 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,
+    });
+    /** A menu the child touches directly is open: the pause card or a settings panel (ADR-0166 rule 2). */
+    function isMenuOpen() {
+        return !!overlays.topVisibleOverlay() || !!$('.screen-pause:not([hidden])');
+    }
+    /** The pad was in view (or asked for by a touch) when a menu took the screen — it comes back when the menu goes. */
+    let padBeforeMenu = false;
+    function reflectPadInMenus() {
+        const pad = $('#touch-controls');
+        if (!pad)
+            return;
+        if (isMenuOpen()) {
+            if (!pad.hidden) {
+                padBeforeMenu = true;
+                touchPad.hideTouchControls('menu');
+            }
+        }
+        else if (padBeforeMenu) {
+            padBeforeMenu = false;
+            touchPad.showTouchControls();
+        }
+    }
+    const cartridgeActions = () => new Set(cartridge.preset ? presetActions(cartridge.preset) : []);
+    function drawPad() {
+        if (!touchUsable || !touchHostEl)
+            return;
+        // ADR-0166: a cartridge that does not ask for the pad gets none — and one swapped in by `mount()` takes the last one away
+        if (!cartridge.onScreenPad) {
+            const old = $('#touch-controls');
+            old?.parentNode?.removeChild(old);
+            return;
+        }
+        const padMap = touchPad.getTouchMap();
+        const short = cartridge.preset ? shortLabellerFrom(cartridge.preset) : () => null;
+        const pad = mountTouchControls({ find: (sel) => $(sel), create: (tag) => doc.createElement(tag), t: translator.t }, {
+            map: padMap,
+            gameActions: cartridgeActions(),
+            // The FUNCTION of each slot (ADR-0165): the game's SHORT word, said after the button's name in its accessible
+            // name; the face shows the name. `start`/`select` are system positions the engine names itself.
+            slotLabel: (slot) => (slot === 'start' ? t('touch.start') : slot === 'select' ? t('touch.select')
+                // only what the game names is drawn (ADR-0162), so its word always exists
+                : (short(padMap[slot]) ?? '')),
+            dpad: store.get(KEYS.padDir, 'stick') === 'cross' ? 'cruz' : 'analogico',
+        });
+        if (!pad.parentNode)
+            touchHostEl.appendChild(pad);
+    }
+    padGapProblems = () => (!cartridge.onScreenPad ? [] : touchUsable
+        ? touchGaps({ map: touchPad.getTouchMap(), gameActions: cartridgeActions() })
+        : ['the virtual pad has nowhere to mount: set `host.touchHost`, or give #game-region room for children. '
+                + 'Without it, a child on a keyboardless tablet cannot play, nor reach the pause']);
+    /**
+     * The screen's START: seat 0's QUICK PAUSE, like the key (ADR-0155) — and a second touch leaves it.
+     *
+     * ⚠️ THE PAD STAYS IN VIEW on the quick pause: the START pill IS the way out for someone who has only a finger, and
+     * hiding it would leave the child in a stopped game with no door. With the card open, START closes it.
+     */
+    function togglePauseByTouch() {
+        if (overlays.topVisibleOverlay())
+            return;
+        if (inQuickPause.has(0)) {
+            leaveQuickPause(0, 'jogo');
+            return;
+        }
+        if (seat0CardOpen()) {
+            changePhase('playing');
+            return;
+        }
+        enterQuickPause(0);
+    }
+    const touchBindings = initTouchBindings({
+        $, win,
+        getSearch: () => win.location?.search ?? '',
+        getControls: () => keyboard.controlsState().controls,
+        getPlayers: () => players(),
+        /*
+         * 🔴 TOUCH PRESSES THE VIRTUAL CONTROLLER (ADR-0223), like every other transport: one decision, not a second copy of
+         * it inside the pad — a copy that, when it existed, left a cartridge listening to `onCommand` deaf to the finger.
+         * 📌 Arrows and not direct references: `virtualController` is born further below (the temporal dead zone).
+         */
+        press: (action, source) => virtualController.press(action, source),
+        release: (action, source) => virtualController.release(action, source),
+        playerEdge,
+        heldKeys: keys,
+        attractOnInput: () => false,
+        // a touch inside a menu does not bring the pad over it; it only remembers that the child is on touch (ADR-0166)
+        showTouchControls: () => { if (isMenuOpen()) {
+            padBeforeMenu = true;
+            return;
+        } touchPad.showTouchControls(); },
+        hideTips: () => { },
+        togglePause: togglePauseByTouch,
+        /*
+         * THE SELECT PILL (ADR-0155): the menus by touch. Without it, someone with only a finger could not reach «Sair», the
+         * number of players or the settings — SELECT was a key. ⚠️ THE PAD LEAVES when the card opens (ADR-0166,
+         * `reflectPadInMenus`): over the card it would cover the buttons that are now her way out («Voltar ao jogo»).
+         */
+        openMenus: () => { openSeatMenus(0); },
+        getTouchMap: () => touchPad.getTouchMap(),
+        // ✅ This root HAS the map, so the screen's START reads the action it carries.
+        getStartAction: () => touchPad.getTouchMap().start,
+        getStickTravelPx: () => touchPad.getStickTravelPx(),
+        getStickDeadPx: () => touchPad.getStickDeadPx(),
+    });
+    drawPad();
+    touchBindings.attach();
+    /*
+     * A LANGUAGE CHANGED MID-GAME REACHES WHAT THE ENGINE DREW (study item C6; ADR-0031). 📏 Measured in the quiz: after
+     * `setLocale('en')` the icon bar's names, the card's name, the button legend and the PAUSED word stayed in the old
+     * language — `applyDom` reaches only `[data-i18n]`, and these are written by code. An open panel redraws itself
+     * (`ui/mount-panel`), keeping focus where it was; nothing here moves focus.
+     * 🔴 THE BOOT IS THE SAME EVENT: the pad and the bar are drawn in the fallback language, and the preferred one arrives
+     * through `setLocale` (measured in the `dist`: «Cima/Baixo» on an English page). This listener replaced the
+     * `localeReady()` repaints that did it for the boot alone.
+     */
+    /**
+     * The 👄, when it exists. Declared HERE because the language change — just below — must reach it, and it is born further
+     * down: the temporal dead zone again.
+     */
+    let voiceControl = null;
+    /*
+     * 🔴 AND THE CARTRIDGE NEEDS TO KNOW TOO (ADR-0225): changing the flag took `<html lang>`, the footer, the bar and the
+     * panels to the new language and left the ACTIVITY — the quiz's statement — in the old one. The frame followed; the
+     * activity did not.
+     *
+     * 📌 The door is the engine's and not the event's, by the rule the Dev wrote for reading and speech (ADR-0216): «o jogo
+     * não deve precisar saber como isso funciona». A cartridge that had to subscribe to `i18n:change` on the WINDOW would
+     * have to know the event's name, the object it is dispatched on and the order in which the engine handles it — and
+     * would reach a global to do it, which ADR-0221 step 7d refuses to a new module.
+     */
+    const localeListeners = [];
+    {
+        // through the root's door, released by `dispose()`; the window's `i18n:change` stays the host's page-level signal
+        localeOn(() => {
+            pauseIcons.reflectPauseIcons();
+            updateCaption();
+            if (pausedWord && !pausedWord.hidden)
+                pausedWord.textContent = t('pause.quick');
+            drawPad();
+            touchBindings.rewire();
+            /*
+             * 🔴 AND WHAT THE ENGINE HEARS CHANGES TOO (ADR-0225). What it DRAWS follows since study item C6; what it SAYS follows
+             * by itself (`tts` reads `bcp47()` at every utterance) and what it READS too (at every `listen()`). Command
+             * recognition chose its language ONCE — and listening in the old language is worse than stopping, because the
+             * grammar follows the menu and the new words would feed the old model.
+             */
+            void voiceControl?.languageChanged();
+            // ⚠️ THE CARTRIDGE LAST, on purpose: when it redraws, the bar, the caption and the pad are already in the new language,
+            // so it never measures a half-translated screen. And a cartridge that throws does not take the engine's frame with it.
+            for (const listener of localeListeners) {
+                try {
+                    listener();
+                }
+                catch (e) { /* the cartridge failed; the engine goes on */ }
+            }
+        });
+    }
+    /*
+     * ===================== MOTOR ACCESSIBILITY — the engine's panel (ADR-0151 §2 item 5) =====================
+     *
+     * 🔴 THE OLD PANEL DOES NOT SERVE, and not by taste: `ui/settings-mobility` mounts Easy Mode and the two toggles, and
+     * ADR-0151 took the three out of this panel («dificuldade é opção do jogo»; the toggles live on the ☝️). So this is a
+     * NEW panel (`#motora`), and the old one still serves whoever mounts it with their own markup.
+     *
+     * 📌 ITS ROWS are the Dev's list: the CONTROLLER SIZE in four steps, one per persona; mapping the keyboard (for 1, 2 and
+     * 3–4 players), the gamepad and the touch pad; waiting between presses; the camera; the microphone. Each is offered
+     * only where it has a subject.
+     *
+     * ⚠️ 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).
+     */
+    if (pauseMountPoint && pauseUsable && touchUsable) {
+        const mobilityCtx = {
+            find: (sel) => $(sel),
+            create: (tag) => doc.createElement(tag),
+            host: pauseMountPoint,
+            overlays,
+            localeOn, // a language change redraws an open panel, and `dispose()` releases it (ADR-0232 D4)
+        };
+        let padSteps = null;
+        let padHint = null;
+        let padSizeRow = null;
+        /** Reflects the keyboard-mapping rows (defined further below, with the `#ctrl` panel). */
+        let reflectKeyboard = () => { };
+        let currentPersona = closestPersona(store.getNum(KEYS.padBtnMm, 12.5));
+        const specDoPad = () => ({
+            label: t('motora.pad'),
+            values: PERSONAS_DO_PAD.map((p) => t(p.label)),
+            current: currentPersona,
+        });
+        const mobilityPanel = mountPanel(mobilityCtx, {
+            id: 'motora',
+            labels: () => ({
+                title: t('menu.motora'),
+                listLabel: t('menu.motora'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            // Read again at every opening: the size may have changed elsewhere, and the labels follow the language of now.
+            render: () => {
+                currentPersona = closestPersona(store.getNum(KEYS.padBtnMm, 12.5));
+                // ADR-0166 + ADR-0106 §5: the pad's size is offered only to a cartridge that has a pad — hidden, not locked, because
+                // there is nothing to unlock. Read at each opening: `mount()` may have swapped the cartridge.
+                if (padSizeRow)
+                    padSizeRow.hidden = !cartridge.onScreenPad;
+                if (padSteps)
+                    updateSteps(padSteps, specDoPad());
+                // ⚠️ THE HINT IN THE LANGUAGE OF NOW, before the footer collects it: written at boot, it came out in the fallback
+                // language.
+                if (padHint)
+                    padHint.textContent = t('motora.pad.dica');
+                reflectKeyboard();
+            },
+        });
+        const rowNode = doc.createElement('div');
+        rowNode.className = 'ctrl-row ctrl-row--passos';
+        padSizeRow = rowNode; // offered or not is decided at each opening (`render` above)
+        const explanation = doc.createElement('span');
+        explanation.className = 'opt-hint';
+        padHint = explanation;
+        const envelope = doc.createElement('span');
+        envelope.appendChild(explanation);
+        rowNode.appendChild(envelope);
+        padSteps = mountSteps(mobilityCtx, specDoPad());
+        padSteps.id = 'opt-pad-persona';
+        rowNode.appendChild(padSteps);
+        mobilityPanel.shell.list.appendChild(rowNode);
+        padSteps.addEventListener('passo', (ev) => {
+            const fresh = nextStep(currentPersona, PERSONAS_DO_PAD.length, ev.detail);
+            if (fresh === currentPersona)
+                return; // at the end, a step that did not happen is not announced
+            currentPersona = fresh;
+            touchPad.setPadMm(PERSONAS_DO_PAD[fresh].mm);
+            updateSteps(padSteps, specDoPad());
+            srSay(`${t('motora.pad')}: ${t(PERSONAS_DO_PAD[fresh].label)}`);
+        });
+        engineActions.motora = mobilityPanel.open;
+        let keyboardMode = 1;
+        let seatInMap = 0;
+        const modeScheme = (conf, i) => (keyboardMode === 1 ? conf.solo
+            : keyboardMode === 2 ? (conf.p2[i] ?? conf.p2[0]) : (conf.p4[i] ?? conf.p4[0]));
+        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);
+                return actionWord ? [{ action: presetAction, label: actionWord }] : [];
+            });
+        };
+        let seatSteps = null;
+        const seatSpec = () => ({
+            label: t('ctrl.assento'),
+            values: Array.from({ length: keyboardMode }, (_, i) => t('ctrl.jogador', { n: i + 1 })),
+            current: seatInMap,
+        });
+        const keyboardPanel = mountPanel(mobilityCtx, {
+            id: 'ctrl',
+            labels: () => ({
+                title: modeLabel(keyboardMode),
+                listLabel: modeLabel(keyboardMode),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => {
+                if (seatSteps) {
+                    seatInMap = Math.min(seatInMap, keyboardMode - 1);
+                    updateSteps(seatSteps, seatSpec());
+                    seatSteps.closest('.ctrl-row').hidden = keyboardMode === 1;
+                }
+                keyboardControls?.render(seatInMap);
+            },
+        });
+        {
+            // THE SEAT, by steps — only in the modes of more than one: «◀ Teclado de: Jogador 2 ▶».
+            const seatRow = doc.createElement('div');
+            seatRow.className = 'ctrl-row ctrl-row--passos';
+            seatSteps = mountSteps(mobilityCtx, seatSpec());
+            seatSteps.id = 'ctrl-assento';
+            seatRow.appendChild(seatSteps);
+            keyboardPanel.shell.card.insertBefore(seatRow, keyboardPanel.shell.list);
+            seatSteps.addEventListener('passo', (ev) => {
+                const nextValue = nextStep(seatInMap, keyboardMode, ev.detail);
+                if (nextValue === seatInMap)
+                    return;
+                seatInMap = nextValue;
+                updateSteps(seatSteps, seatSpec());
+                keyboardControls?.render(seatInMap);
+                srSay(`${t('ctrl.assento')}: ${t('ctrl.jogador', { n: nextValue + 1 })}`);
+            });
+        }
+        /** The four-player mode carries the first three seats of the three-player mode — see the header above. */
+        const syncThree = (conf) => {
+            conf.p3.forEach((left, i) => {
+                const de = conf.p4[i];
+                if (de)
+                    for (const a of ACTIONS)
+                        left[a] = de[a] ? [...de[a]] : de[a];
+            });
+        };
+        keyboardControls = initSettingsControls({
+            t: translator.t, $, srSay, srAlert,
+            gameActions: actionsToMap,
+            store: {
+                saveKB: (conf) => { if (keyboardMode === 4)
+                    syncThree(conf); keyboardConfig.save(conf); },
+                // ⚠️ «RESTORE» FOR THIS MODE, not for the whole keyboard: whoever resets the two-player keyboard does not erase the one-player one.
+                resetKB: () => {
+                    const factory = keyboardConfig.factoryWithGame();
+                    const kb = keyboardConfig.kb();
+                    if (keyboardMode === 1)
+                        kb.solo = factory.solo;
+                    else if (keyboardMode === 2)
+                        kb.p2 = factory.p2;
+                    else {
+                        kb.p4 = factory.p4;
+                        kb.p3 = factory.p3;
+                    }
+                    keyboardConfig.save(kb);
+                    return kb;
+                },
+            },
+            kb: keyboardConfig.kb(),
+            setKB: keyboardConfig.set,
+            kbFor: (i) => modeScheme(keyboardConfig.kb(), i),
+            defaultSchemeFor: (i) => modeScheme(keyboardConfig.factoryWithGame(), i),
+            getNumPlayers: () => keyboardMode,
+            applyControls: () => { keyboard.refreshControls(); },
+            assignControls: () => { keyboard.assignControls(); },
+            fillExplain: overlays.fillExplain,
+        });
+        // THE CAPTURE GETS THE KEY BEFORE EVERYTHING ELSE: while capturing, the menu navigation already steps aside, and this
+        // keeps the recorded key from rising on to START, SELECT or the game.
+        win.addEventListener('keydown', (e) => {
+            if (keyboardControls?.isCapturing() && keyboardControls.handleCaptureKeydown(e))
+                e.stopPropagation();
+        }, true);
+        // THE THREE ROWS in the motor panel, each a DOOR to `#ctrl` in its mode.
+        const keyboardRows = [];
+        for (const rowMode of [1, 2, 4]) {
+            const rowT = doc.createElement('div');
+            rowT.className = 'ctrl-row';
+            const envelope = doc.createElement('span');
+            const strongLabel = doc.createElement('strong');
+            envelope.appendChild(strongLabel);
+            rowT.appendChild(envelope);
+            const rowButton = doc.createElement('button');
+            rowButton.className = 'mode-btn';
+            rowButton.setAttribute('type', 'button');
+            rowButton.id = `opt-teclado-${rowMode}`;
+            rowButton.addEventListener('click', () => {
+                keyboardMode = rowMode;
+                seatInMap = 0;
+                keyboardPanel.open();
+            });
+            rowT.appendChild(rowButton);
+            mobilityPanel.shell.list.appendChild(rowT);
+            keyboardRows.push({ mode: rowMode, row: rowT, strong: strongLabel, button: rowButton });
+        }
+        /** Labels in the language of now, and who appears: with no named positions there is nothing to map; «3–4» without sides. */
+        const reflectKeyboardRows = () => {
+            const declaredActions = cartridge.preset ? presetActions(cartridge.preset) : [];
+            const hasSides = declaredActions.some((a) => SIDES.includes(a));
+            for (const { mode: rowMode, row: l, strong: strongLabel, button: rowButton } of keyboardRows) {
+                strongLabel.textContent = modeLabel(rowMode);
+                rowButton.textContent = t('motora.abrir');
+                rowButton.setAttribute('aria-label', modeLabel(rowMode));
+                l.hidden = actionsToMap().length === 0 || (rowMode === 4 && hasSides);
+            }
+        };
+        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.
+         */
+        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;
+            }
+            controlPanel.shell.overlay.hidden = true;
+            overlays.restoreFocus?.('padwiz');
+        };
+        const controlPanel = mountPanel(mobilityCtx, {
+            id: 'padwiz',
+            labels: () => ({
+                title: t('motora.controle'),
+                listLabel: t('motora.controle'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => { },
+            closeOwn: () => closeControl(),
+        });
+        controlPanel.shell.reset.hidden = true;
+        controlPanel.shell.close.addEventListener('click', closeControl); // `closeOwn` means this panel wires its own button
+        const controlSentence = doc.createElement('p');
+        controlSentence.id = 'padwiz-prompt';
+        controlSentence.setAttribute('aria-live', 'assertive');
+        const controlProgress = doc.createElement('p');
+        controlProgress.id = 'padwiz-progress';
+        controlProgress.className = 'opt-hint';
+        controlPanel.shell.card.insertBefore(controlSentence, controlPanel.shell.list);
+        controlPanel.shell.card.insertBefore(controlProgress, controlPanel.shell.list);
+        padWizard = createPadWizard({
+            maps: padMaps, t: translator.t,
+            getGamepads: () => {
+                const nav = win.navigator;
+                return typeof nav?.getGamepads === 'function' ? nav.getGamepads() : null;
+            },
+            actionLabel: (presetAction) => actionsToMap().find((x) => x.action === presetAction)?.label ?? null,
+            say: (phrase) => { controlSentence.textContent = phrase; srSay(phrase); },
+            progress: (text) => { controlProgress.textContent = text; },
+            srAlert,
+            onClose: () => {
+                controlPanel.shell.overlay.hidden = true;
+                overlays.restoreFocus?.('padwiz');
+            },
+        });
+        const controlMappingRow = doc.createElement('div');
+        controlMappingRow.className = 'ctrl-row';
+        const controlMappingLabel = doc.createElement('span');
+        const controlStrong = doc.createElement('strong');
+        controlMappingLabel.appendChild(controlStrong);
+        controlMappingRow.appendChild(controlMappingLabel);
+        const controlButton = doc.createElement('button');
+        controlButton.className = 'mode-btn';
+        controlButton.setAttribute('type', 'button');
+        controlButton.id = 'opt-controle';
+        controlButton.addEventListener('click', () => {
+            controlPanel.open();
+            padWizard?.open();
+        });
+        controlMappingRow.appendChild(controlButton);
+        mobilityPanel.shell.list.appendChild(controlMappingRow);
+        const reflectControlRow = () => {
+            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
+        };
+        reflectControlRow();
+        /*
+         * MAPEAR TOQUE (ADR-0151 §2; issue #182): which function each on-screen pad button carries, with `input/touch`'s own
+         * editor (`renderTouchMap`, slot → one of the functions the game names). Offered only to a cartridge with a pad (ADR-0166),
+         * and only for the buttons the pad DRAWS — a slot whose function the game does not name is not drawn (ADR-0162), so its
+         * row would change nothing on screen. The pad is redrawn with every choice.
+         */
+        const touchPanel = mountPanel(mobilityCtx, {
+            id: 'touchcfg',
+            listId: 'touchmap-list',
+            labels: () => ({
+                title: t('motora.toque'),
+                listLabel: t('motora.toque'),
+                resetLabel: t('menu.restoreDefaults'),
+                closeLabel: t('pause.pmback'),
+            }),
+            render: () => { touchPad.renderTouchMap(); hideSlotsWithoutAction(); },
+        });
+        touchPanel.shell.reset.hidden = true;
+        const hideSlotsWithoutAction = () => {
+            const named = cartridgeActions();
+            const padMap = touchPad.getTouchMap();
+            for (const sel of Array.from(touchPanel.shell.list.querySelectorAll('select[data-slot]'))) {
+                const rowNode = sel.closest('.ctrl-row');
+                if (rowNode)
+                    rowNode.hidden = !named.has(padMap[sel.dataset.slot ?? ''] ?? '');
+            }
+        };
+        // after the select's own listener (it writes the map), the pad is drawn again with the new function
+        touchPanel.shell.list.addEventListener('change', () => { drawPad(); hideSlotsWithoutAction(); });
+        const touchMappingRow = doc.createElement('div');
+        touchMappingRow.className = 'ctrl-row';
+        const touchEnvelope = doc.createElement('span');
+        const touchStrong = doc.createElement('strong');
+        touchEnvelope.appendChild(touchStrong);
+        touchMappingRow.appendChild(touchEnvelope);
+        const touchButton = doc.createElement('button');
+        touchButton.className = 'mode-btn';
+        touchButton.setAttribute('type', 'button');
+        touchButton.id = 'opt-toque';
+        touchButton.addEventListener('click', () => touchPanel.open());
+        touchMappingRow.appendChild(touchButton);
+        mobilityPanel.shell.list.appendChild(touchMappingRow);
+        const reflectTouchRow = () => {
+            touchStrong.textContent = t('motora.toque');
+            touchButton.textContent = t('motora.abrir');
+            touchButton.setAttribute('aria-label', t('motora.toque'));
+            touchMappingRow.hidden = !cartridge.onScreenPad || actionsToMap().length === 0; // no pad, or nothing named
+        };
+        reflectTouchRow();
+        /*
+         * 🔴 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.
+         */
+        /*
+         * «ESPERAR ENTRE TOQUES» (ADR-0217; GAG Advanced/Motor, issue #182). The row beside the sticky keys, and the other half of
+         * the same problem: that one is for a hand that cannot HOLD, this one for a hand that cannot press ONCE.
+         *
+         * ⚠️ OFF BY DEFAULT and offered as a choice, because for a child with no tremor it is half a second lost between every two
+         * presses — in a game of reaction, the game. Hidden where the game holds no key, like its neighbour: what it refuses is a
+         * second press, and a game nobody presses twice has none to refuse.
+         */
+        const cooldownRowSpec = () => ({ id: 'opt-cooldown', label: t('motor.espera'), hint: t('motor.espera.dica') });
+        const { row: cooldownRow, control: cooldownButton } = controlRow(mobilityCtx, cooldownRowSpec());
+        mobilityPanel.shell.list.appendChild(cooldownRow);
+        const reflectCooldown = () => {
+            labelRow(cooldownRow, cooldownRowSpec());
+            const on = state.inputCooldown > 0;
+            toggleBtn(cooldownButton, on);
+            cooldownButton.textContent = toggleLabel(t, on);
+            markChanged(t, cooldownRow, on !== (DEFAULTS.inputCooldown > 0));
+            cooldownRow.hidden = !cartridge.declaration.holdsKeys();
+        };
+        cooldownButton.addEventListener('click', () => {
+            state.setInputCooldownValue(state.inputCooldown > 0 ? 0 : COOLDOWN_MS);
+            reflectCooldown();
+            srSay(`${t('motor.espera')}: ${t(state.inputCooldown > 0 ? 'state.on' : 'state.off')}`);
+        });
+        reflectCooldown();
+        /*
+         * PLAYING WITH THE CAMERA, IN THE PANEL (issue #182; ADR-0215): «webcam (gestos/rosto/olhos)» was one of the motor rows the
+         * Dev listed as missing, and until the 📷 existed there was nothing to put in it. Now there is, and this row is the same
+         * setting the bar's 📷 cycles — one stored value (`incl_camera_control`), two surfaces, the panel's being the one that says
+         * what each position does.
+         *
+         * ⚠️ HIDDEN WHERE THERE IS NO CAMERA TO ASK FOR, the same rule the icon uses: a row that offers a device the browser does
+         * not have is the dead button of ADR-0106 §5, and a child who picks it waits for a permission dialog that never comes.
+         *
+         * 📌 AND THE MICROPHONE ROW IS RIGHT BELOW, since 2026-09-21: it used to be missing on purpose, because with no voice-command
+         * transport a «microfone» row would switch nothing. The transport landed (issue #184), so the row has a subject.
+         */
+        const CAMERA_MODE_WORD = {
+            off: 'state.off', hands: 'camera.hands', face: 'camera.face', eyes: 'camera.eyes',
+        };
+        const cameraRowSpec = () => ({
+            label: t('motora.camera'),
+            values: CAMERA_CONTROLS.map((m) => t(CAMERA_MODE_WORD[m])),
+            current: Math.max(0, CAMERA_CONTROLS.indexOf(state.cameraControl)),
+        });
+        const cameraRow = doc.createElement('div');
+        cameraRow.className = 'ctrl-row ctrl-row--passos';
+        const cameraHint = doc.createElement('span');
+        cameraHint.className = 'opt-hint';
+        const cameraWrap = doc.createElement('span');
+        cameraWrap.appendChild(cameraHint);
+        cameraRow.appendChild(cameraWrap);
+        const cameraSteps = mountSteps(mobilityCtx, cameraRowSpec());
+        cameraSteps.id = 'opt-camera';
+        cameraRow.appendChild(cameraSteps);
+        mobilityPanel.shell.list.appendChild(cameraRow);
+        const reflectCamera = () => {
+            updateSteps(cameraSteps, cameraRowSpec());
+            cameraHint.textContent = t('motora.camera.dica');
+            cameraRow.hidden = !canCaptureMedia;
+        };
+        cameraSteps.addEventListener('passo', (ev) => {
+            const next = nextStep(Math.max(0, CAMERA_CONTROLS.indexOf(state.cameraControl)), CAMERA_CONTROLS.length, ev.detail);
+            const mode = CAMERA_CONTROLS[next];
+            if (mode === state.cameraControl)
+                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])}`);
+        });
+        // the 📷 and this row are one setting: whoever changes it, both show it
+        stateOn('cameraControl', () => { reflectCamera(); });
+        reflectCamera();
+        /*
+         * PLAYING BY SPEAKING, IN THE PANEL (issue #182's «microfone» row; ADR-0189): the same stored answer the bar's 👄 writes
+         * (`incl_voice_control`), on the surface that has room to say what it does. Two surfaces of one setting, and neither may
+         * name it differently — which is the correction ADR-0218 had just made to the ☝️.
+         *
+         * ⚠️ HIDDEN WHERE THERE IS NO MICROPHONE TO ASK FOR, the rule the 📷 above follows and the one ADR-0106 §5 states: a row
+         * that offers a device this browser cannot even ask for is a dead control, and a child who picks it waits for a permission
+         * dialog that never comes. What happens when the microphone EXISTS and is refused is another matter and is already
+         * answered: `ui/voice-control` says why and puts the answer back to off, and this row follows it like the icon does.
+         */
+        const voiceRowSpec = () => ({ id: 'opt-voice', label: t('motora.voz'), hint: t('motora.voz.dica') });
+        const { row: voiceRow, control: voiceButton } = controlRow(mobilityCtx, voiceRowSpec());
+        mobilityPanel.shell.list.appendChild(voiceRow);
+        const reflectVoice = () => {
+            labelRow(voiceRow, voiceRowSpec());
+            toggleBtn(voiceButton, state.voiceControl);
+            voiceButton.textContent = toggleLabel(t, state.voiceControl);
+            markChanged(t, voiceRow, state.voiceControl !== DEFAULTS.voiceControl);
+            voiceRow.hidden = !canCaptureMedia;
+        };
+        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')}`);
+        });
+        stateOn('voiceControl', () => { reflectVoice(); });
+        reflectVoice();
+        reflectKeyboard = () => {
+            reflectKeyboardRows();
+            reflectControlRow();
+            reflectTouchRow();
+            reflectCooldown();
+            reflectCamera();
+            reflectVoice();
+        };
     }
     /*
-     * ⚠️ `declaration` E `declines` SÃO GETTERS; o resto não é, e a assimetria é a decisão.
+     * THE MOTOR EMPATHY SIMULATIONS REACH THE GAME HERE (ADR-0181): in the window's capture, after the menu navigation registered
+     * its own, and before any cartridge hears a game key. A refused key and its release stop here; a tapped key passes and is
+     * released at once by a synthetic keyup, which this filter lets through.
+     */
+    const empathyFilter = createEmpathyFilter();
+    /*
+     * AND THE COOL-DOWN, WHICH IS THE OPPOSITE OF THEM (ADR-0217): the simulations above make play harder so an adult can feel
+     * what a motor disability costs; this refuses the SECOND press of a hand that shakes, which is a child losing a turn she did
+     * not play. It sits in the same pass because the question is the same one — does this key reach the game — and it comes
+     * FIRST: a press the cool-down refuses never happened, so it must not teach the simulations that a key is held.
+     */
+    const cooldown = createInputCooldown();
+    stateOn('inputCooldown', () => { cooldown.reset(); }); // turning it off must not leave a press refused by an old wait
+    const releasedByFilter = new WeakSet();
+    const block = (e) => { e.preventDefault(); e.stopImmediatePropagation(); };
+    win.addEventListener('keydown', (e) => {
+        if (keyboard.whichPlayer(e.code) < 0)
+            return;
+        if (cooldown.keydown(e.code, win.performance.now(), state.inputCooldown, e.repeat || keys.has(e.code)) === 'refuse') {
+            block(e);
+            return;
+        }
+        const decision = empathyFilter.keydown(e.code, e.repeat, { noChords: state.oneButton, noGripStrength: state.noGripStrength });
+        if (decision === 'barrar') {
+            block(e);
+            return;
+        }
+        if (decision === 'tocar') {
+            const eventTarget = e.target ?? win;
+            setTimeout(() => {
+                // a release the keyboard's own press produced
+                const released = stampSource(new KeyboardEvent('keyup', { code: e.code, key: e.key, bubbles: true, cancelable: true }), 'teclado');
+                releasedByFilter.add(released);
+                eventTarget.dispatchEvent(released);
+            }, 0);
+        }
+    }, true);
+    win.addEventListener('keyup', (e) => {
+        if (releasedByFilter.has(e) || keyboard.whichPlayer(e.code) < 0)
+            return;
+        if (empathyFilter.keyup(e.code) === 'barrar')
+            block(e);
+    }, true);
+    // Playing on the keyboard HIDES the pad — the same per-modality switch `input/keydown` makes. Only some player's keys:
+    // a browser shortcut is not the child changing device.
+    // 🔴 IN CAPTURE (`true`): `ui/menu-nav` consumes a menu's key in the window's capture with `stopPropagation()`, and a
+    // bubbling listener never heard it — in a menu, the child moved to the keyboard and the pad stayed over the card (seen
+    // by the Dev). `stopPropagation` does not silence another listener on the SAME node, so registration order does not matter.
+    win.addEventListener('keydown', (e) => {
+        if (sourceOfEvent(e) === 'toque')
+            return; // the key the pad itself handed to a menu
+        if (keyboard.whichPlayer(e.code) >= 0) {
+            touchPad.hideTouchControls();
+            padBeforeMenu = false;
+        } // on the keyboard now
+    }, true);
+    /*
+     * 🔴 THE BROWSER THE HEAVY FILES AND THE RECOGNISERS USE IS LENT HERE, ONCE (ADR-0232 D4, issue #207): the checked cache, the
+     * hash and `fetch` are read from the HOST's window, and the modules below receive them instead of reaching the globals.
+     * 📌 `caches` and `crypto.subtle` are ABSENT outside a secure context, and absent is an answer each module already gives: the
+     * download reports every file, a loader names the files it cannot find, and nothing is kept unverified.
+     */
+    const heavyCaches = win.caches;
+    const hasHeavyFile = checkedCacheHas(heavyCaches);
+    // 📌 The microphone and the audio context the recognisers open, from the same window: `undefined` is a device without one.
+    const mediaDevices = win.navigator?.mediaDevices;
+    const getUserMedia = mediaDevices?.getUserMedia?.bind(mediaDevices);
+    const HostAudioContext = win.AudioContext;
+    /*
+     * THE HEAVY FILES START COMING DOWN HERE, and the line is deliberately the LAST thing of the boot.
      *
-     * Os dois pertencem à metade do JOGO (ADR-0139 §1), logo têm de seguir o cartucho que estiver montado —
-     * um campo fixo aqui devolveria, depois de um `mount()`, a declaração do cartucho que arrancou primeiro.
-     * `pausa`, `tts`, `overlays`, `nav`, `keyboard` e o sonar são da PÁGINA e existem uma vez só, que é a
-     * decisão inteira do ADR-0117 §2 — e é por isso que eles ficam como estão.
+     * ⚠️ NO `await`. The start does not wait for the heavy files — if it did, a 3G school's first screen would stay blank for minutes
+     * and the child would conclude the game does not open. The empty `catch` is the same rule written twice: a network failure here
+     * cannot bring down a game that may not even use the voice.
      *
-     * 📌 `problems` e `alcance` ainda são fixos, e ainda descrevem o arranque. É a dívida que o ADR-0142
-     * nomeia e que o `mount()` fecha.
+     * 🔴 AND THE REPORT DOES NOT GO TO `problems`, for two reasons, and the first is the one that matters:
+     *
+     *  1. **IT ARRIVES AFTER THE READER HAS GONE.** `problems` is returned synchronously; the download runs in the background,
+     *     so EVERY line of it would land in an array the consumer has already read. Whoever does `if (motor.problems.length) …`
+     *     would see nothing, and whoever read it later would see a list that grew after boot.
+     *  2. **IT WOULD DROWN WHAT CAN BE FIXED.** Without a network — a school without one is the target, not the exception —
+     *     every file is a failure pushed into a list ADR-0106 §2 built to say what the HOST LACKS. The child loses the
+     *     accessibility bar and the line that says so sits under all of them.
+     *
+     * 📌 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.
      */
+    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,
+            cacheStorage: heavyCaches, fetch: win.fetch, digest: sha256With(win.crypto?.subtle), base: doc.baseURI,
+        })
+            .catch(() => { });
+    }
     /*
-     * A PILHA DE CENAS É DA RAIZ, e não do retorno, porque o `desmontar()` tem de a alcançar. Nasce uma vez
-     * (ADR-0117 §2: a página tem uma) e é esvaziada entre cartuchos, nunca substituída.
+     * ⚠️ `declaration`, `declines`, `problems` AND `reach` ARE GETTERS; the rest are not, and the asymmetry is the decision.
+     *
+     * The first two belong to the GAME's half (ADR-0139 §1), and the last two are derived from it, so all four must follow
+     * the mounted cartridge — a plain field here would return, after a `mount()`, what the cartridge that booted first had.
+     * `pause`, `tts`, `overlays`, `nav`, `keyboard` and the sonar belong to the PAGE and exist once, which is the whole
+     * decision of ADR-0117 §2.
+     */
+    /*
+     * THE SCENE STACK BELONGS TO THE ROOT, and not to the return value, because `unmount()` must reach it. Born once
+     * (ADR-0117 §2: the page has one) and emptied between cartridges, never replaced.
      */
-    const cenasDaRaiz = criarPilha();
-    function montar(declaration, ganchos = {}) {
-        // ⚠️ LANÇA, NÃO DIAGNOSTICA — a mesma regra do arranque, e por isso a mesma frase. Uma declaração
-        // malformada é pré-condição: `problems` é para lacunas com que se consegue jogar, e isto não é uma.
-        const malformada = conformanceProblems(declaration);
-        if (malformada.length) {
-            recusarDeclaracao('mount', malformada);
+    const rootScenes = createSceneStack();
+    // The hooks carry the REQUIRED answer to the accommodations (ADR-0153). The public type lets them be omitted, so an
+    // 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);
         }
-        cartucho = { ...ganchos, declaration };
-        registrarMapeamentosDoCartucho();
-        alcanceAtual = derivarAlcance();
-    }
-    function desmontar() {
-        registrarMapeamentoDoTeclado(null);
-        registrarMapeamentoDoPad(null);
-        retirarAvisoDeAlcance();
-        // ⚠️ `pop()` E NÃO UM `clear()`: cada `exit()` é a limpeza de DOM daquela cena, e saltá-la deixaria na
-        // página o que o cartucho anterior desenhou. O laço tem fim porque `pop()` devolve `null` na pilha vazia.
-        while (cenasDaRaiz.pop()) { /* o `exit()` de cada cena É o teardown dela */ }
+        // ⚠️ 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);
+        cartridge = { ...hooks, declaration };
+        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
+        pauseIcons.reflectPauseIcons(); // the bar follows the new cartridge: the hourglass exists only where time runs by itself
+        currentReach = deriveReach();
+        // The pad has the SHAPE of the preset, so it changes with the cartridge; the window listeners stay (`rewire`, not `attach`).
+        drawPad();
+        touchBindings.rewire();
+    }
+    /**
+     * THE PAGE LINKS THE ENGINE STYLESHEET, or it is told (study item B4). `createGame` injects no CSS; without
+     * `style.css` the panels, the footer band, the target floor and the focus rings are all missing, and nothing said so.
+     * Read when `problems` is read, by the sentinel only that stylesheet declares — a stylesheet loading late is not
+     * accused; a host without `getComputedStyle` measures nothing and accuses nothing.
+     */
+    function stylesheetMissing() {
+        if (typeof win.getComputedStyle !== 'function' || !doc.documentElement)
+            return [];
+        const rootStyles = win.getComputedStyle(doc.documentElement);
+        if (!rootStyles || typeof rootStyles.getPropertyValue !== 'function')
+            return [];
+        return rootStyles.getPropertyValue('--incl-engine-stylesheet').trim() ? [] : [`the page does not link the engine stylesheet \
+(package export \`the-inclusionist-engine/style.css\`): panels, the footer band, the target floor and the focus rings are \
+unstyled, so a child who plays by keyboard cannot see where focus is — link that stylesheet`];
+    }
+    /*
+     * THE FLASH SAMPLER (study item B2, cut 2). Each animation frame the world's canvas is drawn into 160×120, the relative
+     * luminance is computed per pixel (WCAG's sRGB formula) and averaged into the 16×12 grid of `core/flash-threshold` — per
+     * pixel and then averaged, so a small bright area weighs by its area; a direct 16×12 downscale samples a few pixels and a
+     * flash between them goes unseen. Registered from the frame after the call, gone when the time is up.
+     */
+    /*
+     * STORAGE OUTSIDE THE ENGINE'S SCOPES (study item E2). The keys of both storages are photographed at boot; `problems`
+     * names the ones that appeared since and sit outside every scope. Only what appeared: on a shared origin (localhost)
+     * the keys already there are other pages'. By capability: a host without storage, or one that throws, measures nothing.
+     */
+    function storageKeys() {
+        const keysFound = new Set();
+        for (const name of ['localStorage', 'sessionStorage']) {
+            try {
+                const area = win[name];
+                if (!area || typeof area.key !== 'function')
+                    continue;
+                for (let i = 0; i < area.length; i++) {
+                    const k = area.key(i);
+                    if (k !== null)
+                        keysFound.add(k);
+                }
+            }
+            catch { /* private mode or a host double: nothing to read */ }
+        }
+        return keysFound;
+    }
+    const keysAtBoot = storageKeys();
+    function storageOutsideScope() {
+        const keysSinceBoot = [...storageKeys()].filter((k) => !keysAtBoot.has(k));
+        const outsideScopes = keysOutsideScopes(keysSinceBoot);
+        if (!outsideScopes.length)
+            return [];
+        return [`the cartridge stored keys outside the engine's scopes (${outsideScopes.slice(0, 5).join(', ')}): a child's settings `
+                + 'kept there do not follow them to the next game, and a game\'s own collide with other games\' — what belongs to '
+                + 'the child goes under incl_* through the engine\'s settings, what belongs to the game under incl.<game>.* (storage-keys.gameKey)'];
+    }
+    const measuredProblems = [];
+    /*
+     * THE CHILD READS ALOUD, AND THE GAME RECEIVES TEXT (ADR-0216, issue #200). The engine owns the microphone, the route and
+     * the promise of privacy; the cartridge calls `listen()`. ⚠️ Recognition on the device or nothing: `platform/reading` only
+     * uses the browser's recogniser where it says it recognises locally, and refuses otherwise instead of quietly sending a
+     * child's voice to a server.
+     */
+    /*
+     * 📌 THE READING THREAD GOES WITH THE CARTRIDGE (issue #185), and the closer lives OUT HERE rather than on the `Reading`
+     * object: a root that mounts another game keeps the same reading object, and a worker holding a compiled model of up to
+     * 378 MiB for a cartridge that never listens is a school machine's memory spent on nothing. It is opened again at the next
+     * `listen()`, which is also the moment the child is willing to wait. ⚠️ Out here because `Reading` is the CARTRIDGE's
+     * vocabulary (ADR-0216): a method only this file calls has no business in a contract seven repositories read.
+     */
+    let closeReadingThread = () => { };
+    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;
+        const listener = createReading({
+            language: () => bcp47(),
+            api: (browserApis.SpeechRecognition ?? browserApis.webkitSpeechRecognition ?? null),
+            now: () => win.performance.now(),
+            every: (fn, ms) => win.setInterval(fn, ms),
+            stopEvery: (h) => win.clearInterval(h),
+            report: (rowNode) => { if (!measuredProblems.includes(rowNode))
+                measuredProblems.push(rowNode); },
+            /**
+             * 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
+             * it. Only reached where the device's own recogniser cannot serve the language (ADR-0200 erratum).
+             */
+            /*
+             * 🔴 AND IT RUNS IN A THREAD OF ITS OWN (issue #185). 📏 Measured in the lab: transcribing on the main thread cut the
+             * recording in gaps of 4 s — the child goes on reading and the words she says while the page is busy are not in the
+             * sound at all. In a worker the biggest gap was 264 ms.
+             * ⚠️ WHERE THERE IS NO `Worker` the reading still works, on this thread, and the LINE SAYS SO: an engine that quietly
+             * fell back would put the defect back exactly where nobody looks for it.
+             */
+            model: o.uses?.reading
+                ? async (language) => {
+                    /*
+                     * ⚠️ A LOCAL NAMED `Worker`, HOLDING THE HOST'S, AND THE LITERAL BELOW IN EXACTLY THIS FORM (ADR-0232 D4). A bundler
+                     * emits the worker's file and rewrites its address only for `new Worker(new URL('…', import.meta.url), { … })`
+                     * written out — which is what makes the thread travel with whoever installs the package; a plain string would
+                     * resolve against the PAGE and 404 in every game whose folders differ. The bundler reads the NAME; the VALUE is the
+                     * window this root was lent, so the thread is opened by the host and no global is reached.
+                     */
+                    const Worker = browserApis.Worker;
+                    if (typeof Worker === 'function') {
+                        const { createReadingInWorker } = await import('../platform/reading-in-worker.js');
+                        readingThread?.close();
+                        readingThread = 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.
+                            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>)';
+                                if (!measuredProblems.includes(line))
+                                    measuredProblems.push(line);
+                            },
+                        });
+                        closeReadingThread = () => { readingThread?.close(); readingThread = null; };
+                        return readingThread;
+                    }
+                    measuredProblems.push('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) });
+                }
+                : undefined,
+            /**
+             * AND THE MICROPHONE, for the model route only: the browser's own recogniser opens one itself. It is built at the first
+             * reading and let go at the end of each — a track left running is a browser still saying «this page is listening».
+             */
+            record: o.uses?.reading
+                ? async (options) => {
+                    const { createMicrophone } = await import('../platform/microphone.js');
+                    microphone ??= createMicrophone({
+                        getUserMedia, createContext: (rate) => new HostAudioContext({ sampleRate: rate }), now: () => win.performance.now(),
+                    });
+                    return microphone.record(options);
+                }
+                : undefined,
+        });
+        const notDeclared = 'reading: this game called `reading.listen()` without declaring `uses: { reading: true }` — the child '
+            + 'speaks and nothing answers, because a delivery built from this declaration carries no reading model; declare it';
+        return {
+            ready: () => (o.uses?.reading ? listener.ready() : Promise.resolve({ can: false, why: 'no-model' })),
+            stop: () => listener.stop(),
+            listen: (options) => {
+                if (!o.uses?.reading) {
+                    if (!measuredProblems.includes(notDeclared))
+                        measuredProblems.push(notDeclared);
+                    return Promise.reject(new Error('reading was not declared by this game: `uses: { reading: true }`'));
+                }
+                return listener.listen(options);
+            },
+        };
+    })();
+    /*
+     * PLAYING WITH THE EYES (ADR-0213; issues #194, #196): the stored 👀 position drives `ui/eye-control` — the camera, the reading, the
+     * keys stamped `olhos` on `#game-region` for seat 0, and the regions drawn over the game. What cannot start is said, lands here in
+     * `problems`, and puts the 👀 back to off. A stored position opens the camera at start, which asks the child's permission.
+     */
+    /*
+     * THE VIRTUAL CONTROLLER CARRIES COMMANDS TO THE GAME (ADR-0111 erratum; issue #197). The keyboard reaches it by the child's scheme,
+     * in the window's capture after the menu navigation and the motor simulations (a key they refused stopped there); a transport that
+     * reads positions presses the controller directly.
+     */
+    const deliverCommand = (cmd) => { cartridge.onCommand?.(cmd); };
+    /*
+     * 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).
+     */
+    const gameRegion = $('#game-region');
+    const scanChip = gameRegion ? mountScanOverlay(doc, gameRegion) : null;
+    let scanner = null;
+    let scanFrame = 0;
+    const scanWord = (item) => scanItemText(item, (a) => (cartridge.preset ? labellerFrom(cartridge.preset)(a) : null), t('scan.nothing'));
+    // 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)
+            return;
+        scanShow(scanner(win.performance.now()).showing.item);
+        scanFrame = win.requestAnimationFrame(scanTick);
+    };
+    const stopScan = () => {
+        if (scanFrame)
+            win.cancelAnimationFrame(scanFrame);
+        scanFrame = 0;
+        scanner = null;
+        scanChip?.hide();
+        reserveBarBand(); // the room the chip was keeping goes back to the game
+    };
+    const startScan = () => {
+        if (scanner)
+            return;
+        const names = cartridge.preset ? labellerFrom(cartridge.preset) : null;
+        const offered = (cartridge.preset ? presetActions(cartridge.preset) : []).filter((a) => !!names?.(a));
+        scanner = createSwitchScan(offered);
+        scanTick();
+    };
+    scanPress = (source) => {
+        if (!scanner)
+            return;
+        // 📌 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;
+        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);
+        win.setTimeout(() => virtualController.release(action, source, 0), SWITCH_SCAN_DEFAULTS.pulseMs);
+    };
+    stateOn('switchScan', (on) => { if (on)
+        startScan();
+    else
+        stopScan(); });
+    whenDisposed(stopScan); // the scan's frames are this root's, and an ended root keeps none running (ADR-0220)
+    if (state.switchScan)
+        startScan();
+    const virtualController = createVirtualController({
+        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`.
+        holdKey: markKeyFrom,
+        releaseKey: releaseKey, menuKey: keyToMenu, deliver: deliverCommand,
+    });
+    /*
+     * 🔴 THE KEYBOARD CONDUCTOR, AND ONLY THAT (ADR-0223). It resolves the action and PRESSES the virtual controller, like the
+     * other transports — so there is ONE `deliver`, called from one place.
+     *
+     * 📏 What that guarantees:
+     *   · with a menu open, a release is delivered only for a press the game HEARD — the controller's `held` memory;
+     *   · a press swallowed by a menu followed by a release does not deliver a release without a press;
+     *   · the question is asked the INVERSE way and does not age: what is not the keyboard is not this conductor's. A
+     *     list of transports to exclude would age with the list, as it did when voice and scan arrived.
+     *
+     * 📌 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.
+     */
+    for (const kind of ['keydown', 'keyup']) {
+        win.addEventListener(kind, (e) => {
+            if (e.repeat || !cartridge.onCommand)
+                return;
+            const source = sourceOfEvent(e);
+            // ⚠️ NO STAMP IS THE REAL KEYBOARD: an event the child produced carries no expando. The only stamp that belongs to
+            // this conductor is `teclado`, and it exists for the release the motor filter synthesises.
+            if (source && source !== 'teclado')
+                return;
+            const seat = keyboard.whichPlayer(e.code);
+            if (seat < 0)
+                return;
+            const action = keyboard.actionOf(e.code, seat);
+            if (!action)
+                return;
+            if (kind === 'keydown')
+                virtualController.press(action, source, seat);
+            else
+                virtualController.release(action, source, seat);
+        }, true);
+    }
+    /*
+     * 🔴 LOSING FOCUS IS THE KEYUP THAT NEVER ARRIVES. With a key down, a click on the browser's own bar, an on-screen
+     * keyboard or a switch-access program taking focus, or a tab change leaves the page without its keyup: the key stays
+     * held, the character keeps walking, and the cartridge believes the button is still down. The window's `blur` is the
+     * only signal left, so it dispatches the keyup each held key is owed — through every listener a real one would reach
+     * (the simulations, the cool-down, this conductor), which is what keeps them all agreeing that the key is up.
+     *
+     * Which keys those are is `input/state`'s answer (`letGoOfTheKeyboard`); stamped `teclado` because this engine never
+     * dispatches an unsigned synthetic key (ADR-0109), and the keyboard's own stamp is what the motor filter's release uses.
+     */
+    win.addEventListener('blur', () => letGoOfTheKeyboard((code) => {
+        win.dispatchEvent(stampSource(new KeyboardEvent('keyup', { code, bubbles: true, cancelable: true }), 'teclado'));
+    }));
+    /*
+     * 🔴 THE GAMEPAD, MOUNTED BY THE ENGINE (ADR-0224), like every other transport: the virtual controller is a local of
+     * this function, and the one door (ADR-0223) has to reach it. A physical gamepad works because the child plugged one
+     * in, not because a game remembered to ask.
+     *
+     * 📌 Almost every port of `GamepadCtx` is answered here with what this root already has. The rest are the cartridge's
+     * world and arrive in one field (`GamepadGameHooks`), with **each absence having a written meaning** — never guessed.
+     * A cartridge that declares nothing has a working gamepad.
+     */
+    // 📌 The absences are resolved in `input/gamepad`, in a table: what an absence MEANS is a decision, and a composition
+    // root carries wiring (ADR-0221, erratum). Only `worldRunning`'s is from here, because only whoever mounts knows which
+    // menus it has open.
+    const gameHooks = padGameAnswers(cartridge.gamepad, () => !menuWithDpad());
+    const gamepad = initGamepad({
+        $, padMaps, input, t: translator.t,
+        padTable: (players, seat) => padTableNow(players, seat), // the MOUNTED cartridge's table, rebuilt by `mount()`
+        oneButton: () => state.oneButton, // the motor empathy, read each frame from the settings store (ADR-0232)
+        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),
+        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.
+        pause: () => { enterQuickPause(0); },
+        resume: togglePauseByTouch,
+        isAttractActive: gameHooks.attractActive,
+        stopAttract: gameHooks.stopAttract,
+        // A PHYSICAL button makes the on-screen pad vanish — the same per-modality switch as the keyboard.
+        isTouchMode: () => { const p = $('#touch-controls'); return !!p && !p.hidden; },
+        hideTouchControls: () => { touchPad.hideTouchControls(); padBeforeMenu = false; },
+        // ⚠️ SEEDED AT EVERY READ and not once: the cartridge repopulates the list at every restart, and a seat seeded only at
+        // boot would leave the new players without a `pad` — invisible to the transport, with no error anywhere.
+        getPlayers: () => seatEveryPlayer(players()),
+        getNumPlayers: () => players().length,
+        navTitle: gameHooks.navTitle,
+        onBar: isOnBar,
+        // ✅ THE BAR'S SECOND WAY OUT: `ui/menu-nav` calls `navBar` with `(i, k)` and never the third argument, the START edge —
+        // the SECOND way out of the mode (ADR-0044 item 7). With the gamepad mounted by the root, it arrives here.
+        navBar,
+        sharedDialogOpen: nav.sharedDialogOpen,
+        navDialog: nav.navDialog,
+        getPauseMenu: (i) => $(`#vp-pause-${i}`),
+        navPause: nav.navPause,
+        setPauseActor,
+        playerEdge,
+        press: (action, source, player) => virtualController.press(action, source, player),
+        release: (action, source, player) => virtualController.release(action, source, player),
+        modalInput: gameHooks.modalInput,
+        hasModal: gameHooks.hasModal,
+        joinPlayer: gameHooks.joinPlayer,
+        respawnPlayer: gameHooks.respawnPlayer,
+        clearWaitingBadge: gameHooks.clearWaitingBadge,
+        wizardStep: gameHooks.wizardStep,
+        wizardTick: gameHooks.wizardTick,
+    });
+    /*
+     * AND THE ENGINE POLLS, because whoever mounts polls. ⚠️ The game loop is the CARTRIDGE's (`core/loop.startLoop` is
+     * called by it), so the root has nowhere to hang a frame — it opens its own, as it already does for the scan and the
+     * camera. A gamepad read every frame is the price written in ADR-0224's negative consequence.
+     */
+    let padFrameHandle = 0;
+    const anyPadConnected = () => (win.navigator?.getGamepads?.() ?? []).some(Boolean);
+    const pollPad = () => { gamepad.pollPads(); padFrameHandle = win.requestAnimationFrame(pollPad); };
+    const stopPollingPad = () => { if (padFrameHandle)
+        win.cancelAnimationFrame(padFrameHandle); padFrameHandle = 0; };
+    /*
+     * ⚠️ THE LOOP EXISTS ONLY WHILE A GAMEPAD IS CONNECTED, and that is pillar 1 deciding: a `requestAnimationFrame` that
+     * never sleeps costs battery on a school Chromebook, and the vast majority of machines will never see a gamepad.
+     * 📌 `gamepadconnected` is the event the specification requires to arrive before the pad appears in the list, and the
+     * query at boot covers the root born with one already connected (another cartridge's `mount()`, for example).
+     * 📌 A host WITHOUT frames — the node project is one — is a capability of the environment and stays quiet (ADR-0169):
+     * with no frames there is no game running for the gamepad to drive.
+     */
+    const startPollingPad = () => { if (padFrameHandle || typeof win.requestAnimationFrame !== 'function')
+        return; padFrameHandle = win.requestAnimationFrame(pollPad); };
+    win.addEventListener('gamepadconnected', startPollingPad);
+    win.addEventListener('gamepaddisconnected', () => { if (!anyPadConnected())
+        stopPollingPad(); });
+    if (anyPadConnected())
+        startPollingPad();
+    const gazeRegion = $('#game-region');
+    if (canCaptureMedia && gazeRegion) {
+        // PLAYING THROUGH THE WEBCAM (ADR-0215): one stored position, off · hands · face · eyes; `ui/camera-control` starts only the control at
+        // that position. Each control opens the camera itself and lets it go when the position moves on.
+        const visionLoop = {
+            requestFrame: (cb) => win.requestAnimationFrame(cb), cancelFrame: (h) => win.cancelAnimationFrame(h),
+            now: () => win.performance.now(), every: (cb, ms) => win.setInterval(cb, ms), stopEvery: (h) => win.clearInterval(h),
+        };
+        const cameraDeps = {
+            t: translator.t, doc, region: gazeRegion, base: doc.baseURI, hasFile: hasHeavyFile, loop: visionLoop, controller: virtualController, say: srSay, alert: srAlert,
+            report: (rowNode) => { if (!measuredProblems.includes(rowNode))
+                measuredProblems.push(rowNode); },
+            turnOff: () => state.setCameraControlValue('off'),
+        };
+        // the eyes: the relative reading and the four-zone cycle (ADR-0213), presses from `olhos`, the eye lines and the regions' outlines
+        const eyes = createEyeControl(cameraDeps);
+        // the face: the Dev's face map (ADR-0210), presses from `rosto`, the eyes, brows and lips lines
+        const face = createFaceControl({ ...cameraDeps, openFeed: videoFeed(doc, win.navigator.mediaDevices) });
+        // the hands: the Gesture Recognizer and the Dev's hands map (ADR-0210), presses from `gestos`, the hands' lines (issue #191)
+        const hands = createHandControl({ ...cameraDeps, openFeed: videoFeed(doc, win.navigator.mediaDevices) });
+        const cameraControls = { eyes, face, hands };
+        stateOn('cameraControl', (mode) => { followCameraMode(mode, cameraControls); });
+        followCameraMode(state.cameraControl, cameraControls);
+        whenDisposed(() => { followCameraMode('off', cameraControls); }); // the camera closes with the root that opened it (ADR-0220)
+    }
+    /*
+     * 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».
+     */
+    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,
+            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)),
+            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); });
+    }
+    /*
+    /*
+     * THE FLASH SAMPLER LIVES IN `platform/flash-sampler` (ADR-0221, issue #203); what stays here is what only the root
+     * knows: which is THIS cartridge's world canvas, and where a failure goes.
+     */
+    const sampleWorldFlashes = (ms) => sampleFlashes({
+        canvas: () => {
+            const declaredWorld = cartridge.declaration.world();
+            const eventTarget = declaredWorld.kind === 'element' ? $(declaredWorld.selector) : null;
+            return eventTarget?.tagName === 'CANVAS' ? eventTarget : eventTarget?.querySelector('canvas') ?? null;
+        },
+        scratch: () => doc.createElement('canvas'),
+        frame: typeof win.requestAnimationFrame === 'function' ? (cb) => { win.requestAnimationFrame(cb); } : undefined,
+        report: (rowNode) => { measuredProblems.push(rowNode); },
+    }, ms);
+    function unmountAll() {
+        closeReadingThread();
+        followCartridgeMappings(null);
+        removeReachNotice();
+        hudMounted?.remove();
+        hudMounted = null;
+        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.
+        while (rootScenes.pop()) { /* each scene's `exit()` IS its teardown */ }
+    }
+    function dispose() {
+        unmountAll();
+        // 📌 The gamepad's polling loop belongs to the ROOT since ADR-0224, so it dies with it: a `requestAnimationFrame` that
+        // survives `dispose()` reads the Gamepad API forever, in a root that has no players any more (ADR-0220).
+        stopPollingPad();
+        for (const release of endOfLife.splice(0))
+            release(); // drained as it goes: a second `dispose()` finds nothing to release
+        listeners.releaseAll();
     }
     return {
-        get declaration() { return cartucho.declaration; },
+        get declaration() { return cartridge.declaration; },
         get declines() { return declines(); },
-        mount: montar,
-        unmount: desmontar,
-        pausa,
+        mount: mountAll,
+        unmount: unmountAll,
+        dispose,
+        pause: pauseControls,
         tts,
+        reading,
+        captionSound: writeSoundCaption,
+        gameSpeed: () => state.gameSpeed,
+        menuIndexOn: () => state.menuIndexOn,
+        t: translator.t,
+        localeReady: translator.ready,
+        say: srSay,
+        alert: srAlert,
+        mirrorAnnouncements: announcer.mirrorTo,
+        libras: { isOpen: libras.isOpen, say: libras.say, tick: libras.tick, toggle: () => { libras.toggle(translator.t); } },
+        settings: state,
+        input,
+        keyboardConfig,
+        audio: mixer,
+        crt,
+        lq,
+        measureFlashes: sampleWorldFlashes,
         overlays,
         nav,
         keyboard,
+        controller: virtualController,
         sonar,
-        aplicarFiltroDeVisao,
-        cenas: cenasDaRaiz,
+        applyVisionFilter: setVisionFilter,
+        scenes: rootScenes,
+        onLocaleChange: (fn) => { localeListeners.push(fn); },
         cvdFilters,
-        get problems() { return [...problemasDoHospedeiro, ...problemasDoCartucho()]; },
-        aoFalhar,
-        get alcance() { return alcanceAtual; },
+        get problems() { return [...hostProblems, ...stylesheetMissing(), ...measureCartridgeProblems(), ...translator.dictionaryGaps(), ...measuredProblems, ...storageOutsideScope()]; },
+        onFailure: announceFailure,
+        get reach() { return currentReach; },
     };
 }