@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/ui/pause-icons.js

@@ -1,117 +1,142 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-// ui/pause-icons — the PER-SCREEN pause menu (`.screen-pause`) and the accessibility icon bar (`.pi-btn`).
-// Extracted VERBATIM from game.js (Estágio 4): PAUSE_ICONS, buildScreenPause, calmMode/applyCalm, iconAct,
-// iconLabel, reflectIconBtn, reflectPauseIcons and hasPrivateOutput.
+// ui/pause-icons — the PER-SCREEN pause card (`.screen-pause`) and the accessibility quick bar (`.pi-btn`).
 //
-// WHY THE ICON BAR IS ITS OWN SLICE: the ten `.pi-btn` buttons are the ONLY place in the game where a state
-// owned by another subsystem (blind mode, TTS, Libras, TEA/reduced-motion, toggle-keys, contrast, CVD) is both
-// mutated AND read back as an `aria-label`. That round-trip — "the label must tell the truth about the state" —
-// is the whole reason `iconLabel` exists, and it is what the pure functions below make testable in node.
+// WHY THE QUICK BAR IS ITS OWN MODULE: its buttons are the ONLY place where a state owned by another subsystem (blind
+// mode, TTS, Libras, calm mode, the input mode, contrast, colour correction, camera, voice, speed, language) is both
+// changed AND read back as an `aria-label`. That round-trip — «the label must tell the truth about the state» — is why
+// `computeIconLabel` exists, and it is what the pure functions below make testable in node.
 //
-// `iconAct` IS A DISPATCHER (its ctx list is long by nature: seven subsystems, one button each), so it is
-// implemented here as a TABLE (`ICON_ACTS`) rather than the original if/else chain. Same order, same
-// guards, same announcements — only the shape changed.
+// Each icon's action is a row of a TABLE (`ICON_ACTS`), not a chain of `if`s: the list of subsystems is long by nature,
+// one button each.
 //
-// WHAT STAYS IN game.js (injected):
-//   · `pauseActor`      — read by the gamepad (input/gamepad.ts ctx) and the keyboard router, and by
-//                         openHelp()/openOptions(); this module only WRITES it (`setPauseActor`).
-//   · `pauseActs`       — the `.pm-btn` action table; every entry calls a panel that still lives in game.js
-//                         (openTypo/openAudio/openMovement/motion.open/openVisual/empathy.open/printMode/
-//                         quitGame/openHelp/setPhase/applyLetra/setQuizLevel/joinPlayer/fitsN/vpScreens).
-//                         Injected LAZILY (`getPauseActs`) because it is a `const` declared ~1200 lines below
-//                         the init site — an eager reference would hit its temporal dead zone.
-//   · `vpPause`         — the array of built pause screens; game.js rebuilds it in buildGameHud() and reads it
-//                         in setPhase/navPause/printMode/pauseSelect/__incl. Injected as a getter.
-//   · `rm`/`saveRM`     — the reduced-motion flags object, co-owned with ui/settings-motion (same reference).
-//   · `PM_BTNS`/`QL_NAME` — owned by ui/activities-menu; injected, never copied.
-import { t } from '../core/i18n.js';
-import { CONTRAST_LEVELS } from './settings-visual.js';
-import { CURTO_DO_TEMA, CURTO_DA_CORRECAO } from './visual-axes-panel.js';
-import { proximoTema, proximaCorrecao, temAltoContraste, PADRAO, } from '../render/viz-axes.js';
-import { anunciarItem } from './item-announcement.js';
-import { rotuloAcessivel } from '../core/rotulo-acessivel.js';
-import { passoNoAnel } from '../core/anel.js'; // da FOLHA, e não de ui/menu-nav: ver a nota lá
-// LIGAÇÃO VIVA (ESM): o índice pode ser desligado no menu, e o valor aqui acompanha sem assinatura.
-import { menuIndexOn, DEFAULTS, setModoCegoValue } from '../core/state.js';
-// ⚠️ IMPORT DIRETO DE `platform/storage`, e não uma peça a mais no `ctx`, e a escolha é sobre quem pode
-// esquecer: `initPauseIcons` é chamado pela raiz de composição de CADA jogo, e um `store` injetado é um
-// campo que um consumidor pode omitir — e omiti-lo faria o nível TEA voltar a não persistir, em silêncio,
-// exactamente no jogo que se esqueceu. É a mesma forma que `ui/fonts` usa, e `ui/` depender de `platform/`
-// não inverte camada nenhuma.
-import * as store from '../platform/storage.js';
-import { definirAlternanciaDeMarcha } from './settings-motor.js';
-import { recusaDaAlternancia } from './latch-refusal.js';
-import { PM_BTNS, PM_OPTIONS_BTNS } from './activities-menu.js';
-import { CHAVES_DE_CENA, ANIMACOES_DO_PERSONAGEM, lerCenaGuardada, guardarCena } from './motion-scene.js';
+// INJECTED, not owned here:
+//   · `setPauseActor` — who opened the card; the panels open scoped to that player. This module only WRITES it.
+//   · `getPauseActs`  — the `.pm-btn` action table (`ui/shell` or the host's own), asked when an item is pressed, so it
+//                       can be wired after this module.
+//   · the pause screens, asked through a getter: the host rebuilds them when the number of screens changes.
+//   · `rm`/`saveRM`   — the reduced-motion flags, shared with ui/settings-motion (same reference).
+//   · `matchMedia`    — the browser's media query, for the reduced-motion default when nothing is stored (ADR-0232).
+//   · `PM_BTNS` and the other lists of buttons are `ui/pause-buttons`', imported, never copied.
+import { flagOf, nextLocale, LANGUAGE_NAME } from './locale-flags.js';
+/*
+ * 🔴 THE TWO VISUAL CYCLES MOVED HOUSE to `core/visual-cycles` (ADR-0221, issue #203). They lived in TWO modules — the list of
+ * levels in the panel, the steps and the names here — and the thing that costs most to maintain is the ASYMMETRY between them,
+ * which only reads with both in sight. See the header there.
+ */
+import { SHORT_THEME, SHORT_CORRECTION } from './visual-axes-panel.js';
+/*
+ * 🔴 CALM MODE MOVED HOUSE (ADR-0221, issue #203). It is not about ICONS: it is about what a child who cannot bear noise needs
+ * the engine to silence, and the icon is only one of the surfaces she asks through. It lives in `core/calm-mode`, a leaf
+ * module — zero imports, zero DOM — which is why the destructive clamp of level 1 can be measured without mounting anything.
+ */
+import { CALM_NAMES, CALM_AUDIO_CATS, nextCalmMode, sanitiseTeaLevel, calmAudioPlan, calmMotionPlan } from '../core/calm-mode.js';
+/*
+ * 🔴 THE MARKUP MOVED HOUSE to `ui/pause-markup` (ADR-0221, issue #203). Building the strings and wiring the elements the
+ * browser makes from them are two jobs that do not need each other; what is left in this file is the second one. See the
+ * header there for why the icon catalogue had to leave before the markup could.
+ */
+import { quickBarMarkup, screenPauseMarkup, } from './pause-markup.js';
+/*
+ * 🔴 THE ICON CATALOGUE MOVED HOUSE to `core/pause-icon-catalogue` (ADR-0221, issue #203): WHICH icons exist and in what order
+ * is DATA, and this file is about what they DO. See the header there for why the data had to leave first.
+ */
+import { PAUSE_ICONS, pauseIcon } from '../core/pause-icon-catalogue.js';
+import { nextTheme, nextCorrection, hasHighContrast, DEFAULT_VISUAL, } from '../render/viz-axes.js';
+import { announceItem } from './item-announcement.js';
+import { keepInView } from './menu-items.js';
+import { accessibleLabel } from '../core/accessible-label.js';
+import { stepInRing } from '../core/ring.js'; // from the LEAF, not from ui/menu-nav: see the note there
+// A LIVE BINDING (ESM): the index can be turned off in the menu, and the value here follows without a subscription.
+// The stateless half (ADR-0232): the defaults, the reduced-motion question and the 📷 cycle are vocabulary, not the store.
+import { DEFAULTS, defaultReducedMotion } from '../core/setting-defaults.js';
+import { nextCameraControl } from '../core/camera-cycle.js';
+/** The word for each position of the 📷 cycle (ADR-0215). */
+const CAMERA_MODE_NAME = { off: 'state.off', hands: 'camera.hands', face: 'camera.face', eyes: 'camera.eyes' };
+/**
+ * The word for each position. Private again since 2026-09-21: it was exported for the motor panel's row, and the Dev took that
+ * row out («Tire a linha de acessibilidade motora») — the icon is the only surface of this setting now.
+ */
+const INPUT_MODE_NAME = { standard: 'input.standard', sticky: 'input.sticky', scan: 'input.scan' };
+/**
+ * Which of the three is showing. The SCAN WINS over the latch on purpose: with one button there is nothing to hold, so a stored
+ * latch would otherwise make the icon claim a position the child is not in.
+ */
+export function inputModeOf(s) {
+    return s.switchScan ? 'scan' : s.toggleMove ? 'sticky' : 'standard';
+}
 /**
- * A LEGENDA de um ícone da barra de acessibilidade — uma função, e não três cópias da mesma expressão.
+ * The next position. A GAME THAT HOLDS NO KEY has nothing for the latch to hold, so the icon offers standard and one button:
+ * a cycle never stops where nothing would happen (ADR-0155), and a word that promised what this game cannot do would teach a
+ * child that her setting is broken (ADR-0106 §5).
  *
- * Ela é escrita em TRÊS momentos que parecem diferentes e são o mesmo: o cursor direcional pousa no ícone
- * (`ui/menu-nav`), o dedo o aciona, e o mouse ou o foco passa por cima. Enquanto eram três linhas soltas, o
- * índice do ADR-0044 teria de ser acrescentado em três lugares — e a chance de um ficar para trás é a mesma
- * que este repositório já pagou dezesseis vezes com o `DomQuery`.
+ * 📌 THE DEVICE TAKES NOTHING AWAY (ADR-0249): on eyes, face, gestures and speech the latch starts as the game answers
+ * `holdsKeys()`, and the child may turn it on or off like on any other device — so all three positions are offered there too.
+ */
+function inputModeOrder(holdsKeys) {
+    return holdsKeys ? ['standard', 'sticky', 'scan'] : ['standard', 'scan'];
+}
+export function nextInputMode(m, holdsKeys) {
+    const order = inputModeOrder(holdsKeys);
+    const i = order.indexOf(m);
+    return order[(i < 0 ? 0 : i + 1) % order.length];
+}
+// The rule for applying an input mode is written in the icon's own action, where it happens: the ☝️ is the only surface of
+// this setting.
+import { nextGameSpeed } from '../core/game-speed.js';
+import { KEYS } from '../platform/storage-keys.js';
+import { setMoveLatch } from './settings-mobility.js';
+import { PM_BTNS, PM_OPTIONS_BTNS, PM_GAME_BTNS } from './pause-buttons.js';
+import { aacMenuLocked } from './aac-sets.js';
+import { SCENE_KEYS, CHARACTER_ANIMATIONS, readStoredScene, storeScene } from './motion-scene.js';
+/**
+ * Hover and focus on a bar's icons write its NAME in the bar's `.pause-icons-cap` and ask for its EXPLANATION.
  *
- * O `aria-label` já conta o ESTADO ("Alto contraste, ativado"): é ele que o `reflectIconBtn` reescreve a cada
- * mudança, e é por isso que a legenda o lê de volta em vez de recompor o texto por conta própria.
+ * Shared by the per-screen quick bars and the bar the engine mounts in `#title-icons`: two copies of this wiring is
+ * how one bar showed the name and the other did not — the Dev found the engine's bar silent on hover and on the
+ * cursor. Leaving an icon falls back to the CURSOR of the bar's mode when there is one (`.pi-sel`): it is the only
+ * thing saying where that cursor is.
  */
-export function legendaDoIcone(barra, el) {
-    const icones = [...barra.querySelectorAll('.pi-btn')];
-    // A regra "rótulo declarado vence" nasceu AQUI e valia só para os dez ícones. Virou `core/rotulo-acessivel`
-    // e agora vale para o menu inicial e para a lista de pausa também — uma resposta para "como se chama este
-    // controle", e não três.
-    return anunciarItem({ rotulo: rotuloAcessivel(el), posicao: icones.indexOf(el) + 1, total: icones.length }, menuIndexOn);
+export function wireBarCaption(bar, explain) {
+    const cap = bar.querySelector('.pause-icons-cap');
+    const captionFor = (b) => {
+        if (cap)
+            cap.textContent = accessibleLabel(b); // name and state only: «N de M» is spoken, never written (ADR-0167)
+        explain(b.dataset.pi ?? null);
+    };
+    const restoreCaption = () => {
+        const cursor = bar.querySelector('.pi-sel');
+        if (cursor) {
+            captionFor(cursor);
+            return;
+        }
+        if (cap)
+            cap.textContent = '';
+        explain(null);
+    };
+    bar.querySelectorAll('.pi-btn').forEach((b) => {
+        b.addEventListener('mouseenter', () => captionFor(b));
+        b.addEventListener('focus', () => captionFor(b));
+        b.addEventListener('mouseleave', restoreCaption);
+        b.addEventListener('blur', restoreCaption);
+    });
 }
-/** The accessibility shortcut bar at the top of every pause screen (and of the splash `#title-icons`).
- *  Sound-bound icons (blind/TTS) require a private audio output; webcam/voice are still `soon`.
- *  VERBATIM from game.js in order and behaviour; the names became i18n keys in the Fase-5 pass. */
-// `n` é a CHAVE i18n do nome do ícone (o emoji `e` não traduz — é o mesmo glifo em toda língua).
-export const PAUSE_ICONS = [
-    { k: 'blind', e: '🦯', n: 'icon.blind' },
-    { k: 'tts', e: '🗨️', n: 'icon.tts' },
-    { k: 'libras', e: '🤟', n: 'icon.libras' },
-    { k: 'tea', e: '🧩', n: 'icon.tea' },
-    { k: 'altmove', e: '☝️', n: 'icon.altmove' }, // ☝️ e não 🦾: o gesto é UM DEDO tocando, que é o que a alternância pede (pedido do Dev)
-    { k: 'contrast', e: '🌗', n: 'icon.contrast' },
-    { k: 'cvd', e: '🚥', n: 'icon.cvd' },
-    { k: 'face', e: '🧑', n: 'icon.face', soon: true },
-    { k: 'eyes', e: '👀', n: 'icon.eyes', soon: true },
-    { k: 'voice', e: '👄', n: 'icon.voice', soon: true },
-];
-const ICON_BY_KEY = new Map(PAUSE_ICONS.map((ic) => [ic.k, ic]));
-export function pauseIcon(k) { return ICON_BY_KEY.get(k); }
-/** TEA cycle: 0 = normal · 1 = calmo (reduces) · 2 = silencioso (switches off). Never touches TTS/blind mode. */
-export const CALM_NAMES = ['calm.off', 'calm.quiet', 'calm.silent'];
 /**
- * O nível TEA guardado, saneado. Fora de 0..2 devolve o padrão — dado do navegador é dado de fora, e um
- * nível inventado escolheria `CALM_NAMES[3]`, que é `undefined`, e o anúncio ao leitor de tela sairia vazio.
+ * What an icon of the quick bar SAYS — one function, not three copies of the same expression. It is spoken at moments
+ * that look different and are the same (the cursor lands on the icon, a finger activates it), and the `aria-label` it
+ * reads already carries the STATE («Alto contraste, ativado»): `reflectIconBtn` rewrites it on every change, which is why
+ * this reads it back instead of rebuilding the text.
  */
-export function saneiaNivelTea(bruto) {
-    return Number.isInteger(bruto) && bruto >= 0 && bruto < CALM_NAMES.length ? bruto : DEFAULTS.calmMode;
+function iconCaption(t, barEl, el, menuIndexOn) {
+    const icons = [...barEl.querySelectorAll('.pi-btn')];
+    // «A declared label wins» is `core/accessible-label`'s rule, shared with the pause list and every menu: one answer to
+    // «what is this control called».
+    return announceItem(t, { label: accessibleLabel(el), position: icons.indexOf(el) + 1, total: icons.length }, menuIndexOn);
 }
-/** Lê o nível TEA do armazenamento. Chamado no `init`, nunca no import. */
-function lerNivelTea() {
-    return saneiaNivelTea(store.getNum(store.KEYS.tea, DEFAULTS.calmMode));
+/** Reads the calm level from storage, sanitised. Called in `init`, never on import. */
+function readTeaLevel(store) {
+    return sanitiseTeaLevel(store.getNum(KEYS.tea, DEFAULTS.calmMode), DEFAULTS.calmMode);
 }
-/** The audio categories `applyCalm` governs. TTS/sonar/guarda/guia stay untouched — a calm player still needs them. */
-export const CALM_AUDIO_CATS = ['ambient', 'music', 'earcons', 'other', 'interact'];
-/** Colour-vision-deficiency cycle, in `player.viz` values. */
-export const CVD_SEQ = ['normal', 'fix-protan', 'fix-deuter', 'fix-tritan'];
-/** i18n keys of the CVD announcement names, indexed the same as CVD_SEQ.
- *
- * ⚠️ POSITION 0 IS `cvd.tricro` AND NOT `cvd.off`, AND THE TWO KEYS ARE NOT INTERCHANGEABLE.
- * This list names the four CHOICES of the cycle, so position 0 is a way of seeing — trichromatic
- * vision, the one that needs no correction — and it is said as one. `cvd.off` below is a FALLBACK
- * for `s.viz` values that are not corrections at all, and 13 of the 16 viz modes are exactly that:
- * the three simulations, the three contrast levels, the five low-vision modes and blind mode.
- * Announcing "trichromatic vision" there would have the software assert what the child sees, while
- * she is simulating not seeing it. The choice is named; the fallback is switched off. */
-export const CVD_NAMES = ['cvd.tricro', 'cvd.protan', 'cvd.deuter', 'cvd.tritan'];
-/** `player.viz` → i18n key of the label used by iconLabel (anything else falls back to the 'off' key). */
-export const CVD_LABELS = {
-    'fix-protan': 'cvd.protan', 'fix-deuter': 'cvd.deuter', 'fix-tritan': 'cvd.tritan',
-};
-/** A player has private output when nobody else is on the same sink. Single screen ⇒ always private.
- *  Pure form of game.js's hasPrivateOutput (see the report: it had no other caller left). */
+/** A player has private output when nobody else is on the same sink. Single screen ⇒ always private. */
 export function hasPrivateOutputIn(list, count, i) {
     if (count <= 1)
         return true;
@@ -120,234 +145,216 @@ export function hasPrivateOutputIn(list, count, i) {
         return false;
     return !list.some((q, j) => j !== i && q && q.audioSink === p.audioSink);
 }
-/** TEA cycle step. */
-export function nextCalmMode(cur) { return (cur + 1) % 3; }
-/** Next high-contrast level. An unlisted `viz` (e.g. a CVD filter) is treated as index 0 ⇒ jumps to 'hc-direto'. */
-export function nextContrast(cur) {
-    let idx = CONTRAST_LEVELS.indexOf(cur);
-    idx = idx < 0 ? 0 : idx;
-    return CONTRAST_LEVELS[(idx + 1) % CONTRAST_LEVELS.length];
-}
-/** Next CVD filter. NOTE the asymmetry with nextContrast: an unlisted `viz` maps to index 1 ('fix-protan'),
- *  not 0 — verbatim from game.js (`idx = idx<0 ? 1 : (idx+1)%seq.length`). */
-export function nextCvd(cur) {
-    let idx = CVD_SEQ.indexOf(cur);
-    idx = idx < 0 ? 1 : (idx + 1) % CVD_SEQ.length;
-    return { idx, mode: CVD_SEQ[idx] };
-}
-/** What `applyCalm` does to ONE audio category, given the TEA level. Extracted so the (destructive) volume
- *  clamp at level 1 is visible and testable — see the report. */
-export function calmAudioPlan(calmMode, vol) {
-    if (calmMode === 0)
-        return { on: true, vol };
-    if (calmMode === 1)
-        return { on: true, vol: Math.min(vol, 0.3) };
-    return { on: false, vol };
-}
-/** What `applyCalm` does to the scene/character reduced-motion flags. */
-export function calmMotionPlan(calmMode) {
-    return { sceneReduced: calmMode >= 1, charFrozen: calmMode === 2 };
-}
 /** The `aria-label` of one icon — it MUST reflect the current state, on/off or level. This is the whole
  *  point of the function: a toggle that looks pressed but does not say so is invisible to a screen reader. */
-export function computeIconLabel(k, s) {
-    const ic = ICON_BY_KEY.get(k);
+export function computeIconLabel(t, k, s) {
+    const ic = pauseIcon(k);
     if (!ic)
         return '';
-    // O estado vira SEMPRE um parâmetro (`{v}`), nunca uma concatenação: 'on'/'off' eram palavras inglesas
-    // presas numa frase em português, e uma língua que anteponha o estado ao nome precisa do dicionário para
-    // reordenar. `nomeDoIcone: estado` é a moldura; o estado é o conteúdo, e ele também é traduzido.
-    if (ic.soon)
-        return t('icon.soon', { nome: t(ic.n) });
-    const rotulo = (v) => t('icon.state', { nome: t(ic.n), v: t(v) });
-    if (k === 'blind')
-        return rotulo(s.modoCego ? 'state.on' : 'state.off');
-    if (k === 'tts')
-        return rotulo(s.ttsOn ? 'state.on' : 'state.off');
-    if (k === 'libras')
-        return rotulo(s.librasOn ? 'state.on' : 'state.off');
-    // TEA e daltonismo usam um nome CURTO aqui, diferente do nome do botão: o rótulo já diz o nível, e
-    // repetir a lista de níveis do nome ("(calmo / silencioso)", "(protan/deutan/tritan)") a diria duas vezes.
-    // Era assim antes da conversão, com o texto curto embutido — preservado, não reinventado.
-    if (k === 'tea')
-        return t('icon.state', { nome: t('icon.tea.short'), v: t(CALM_NAMES[s.calmMode]) });
-    if (k === 'altmove')
-        return rotulo(s.toggleMove ? 'state.on' : 'state.off');
-    if (k === 'contrast')
-        return rotulo(CURTO_DO_TEMA[s.visual.tema]);
-    if (k === 'cvd')
-        return t('icon.state', { nome: t('icon.cvd.short'), v: t(CURTO_DA_CORRECAO[s.visual.correcao]) });
-    return t(ic.n);
+    const state = STATE_OF_ICON[k];
+    // The state is ALWAYS a parameter (`{v}`), never a concatenation: a language that puts the state before the name needs
+    // the dictionary to reorder it. «name: state» is the frame; the state is the content, and it is translated too.
+    return state ? t('icon.state', { nome: t(SHORT_NAME[k] ?? ic.n), v: state(t, s) }) : t(ic.n);
 }
-/** Pure form of reflectIconBtn's branching. A `soon` icon lands on all-false — it never claims to be on. */
+const onOff = (t, on) => t(on ? 'state.on' : 'state.off');
+/** What each icon with a state says after its name, already in the child's language. An icon not here has no state to say. */
+const STATE_OF_ICON = {
+    blind: (t, s) => onOff(t, s.blindMode),
+    tts: (t, s) => onOff(t, s.ttsOn),
+    libras: (t, s) => onOff(t, s.librasOn),
+    tea: (t, s) => t(CALM_NAMES[s.calmMode]),
+    altmove: (t, s) => t(INPUT_MODE_NAME[inputModeOf(s)]),
+    contrast: (t, s) => t(SHORT_THEME[s.visual.tema]),
+    cvd: (t, s) => t(SHORT_CORRECTION[s.visual.correcao]),
+    camera: (t, s) => t(CAMERA_MODE_NAME[s.camera ?? 'off']),
+    voice: (t, s) => onOff(t, s.voice),
+    // a language's own name is not translated: «Español» reads the same in every interface
+    idioma: (_t, s) => LANGUAGE_NAME[(s.locale ?? 'pt')] ?? LANGUAGE_NAME.pt,
+    velocidade: (t, s) => t('icon.velocidade.valor', { pct: Math.round((s.speed ?? 1) * 100) }),
+};
+/**
+ * Calm mode and colour correction have a SHORT name key for the label, because the button's name once carried the list of
+ * levels («(calmo / silencioso)», «(protan/deutan/tritan)») and the label already says the level. ⚠️ In the three
+ * dictionaries the short key now equals the long one word for word: the distinction has no subject left, and merging the
+ * keys is a dictionary change.
+ */
+const SHORT_NAME = { tea: 'icon.tea.short', cvd: 'icon.cvd.short' };
+const ICON_VISUAL = Object.freeze({
+    blind: (s) => ({ on: s.blindMode, dis: !s.privateOutput }),
+    tts: (s) => ({ on: s.ttsOn, dis: !s.privateOutput || !!s.noVoice }),
+    libras: (s) => ({ on: s.librasOn }),
+    tea: (s) => ({ on: s.calmMode === 2, calm: s.calmMode === 1 }),
+    // ⚠️ AND IT IS NEVER GREYED OUT: every device may be in any of its positions (ADR-0249), and what a game cannot hold the
+    // CYCLE tells by not offering it — greying the icon would take the one-button scan away with it.
+    altmove: (s) => ({ on: inputModeOf(s) !== 'standard' }),
+    contrast: (s) => ({ on: hasHighContrast(s.visual) }),
+    velocidade: (s) => ({ on: (s.speed ?? 1) < 1 }),
+    camera: (s) => ({ on: (s.camera ?? 'off') !== 'off' }),
+    voice: (s) => ({ on: !!s.voice }),
+    // ⚠️ THE TWO-TONE BACKGROUND IS THIS ICON'S «ON» SIGNAL, and it reads the correction AXIS — so it still says the same when
+    // the high-contrast theme is on too, and the child's correction does not vanish from the icon that exists to show it.
+    cvd: (s) => ({ cvd: s.visual.correcao !== 'tricro' ? `pi-cvd-${s.visual.correcao}` : '' }),
+});
+/** At rest: an icon the table does not name shows nothing. */
+const ICON_VISUAL_AT_REST = Object.freeze({ on: false, dis: false, calm: false, cvd: '', active: false });
+/** Pure form of reflectIconBtn's branching. */
 export function computeIconVisual(k, s) {
-    let on = false, dis = false, calm = false, cvd = '';
-    if (k === 'blind') {
-        on = s.modoCego;
-        dis = !s.privateOutput;
-    }
-    else if (k === 'tts') {
-        on = s.ttsOn;
-        dis = !s.privateOutput;
-    }
-    else if (k === 'libras') {
-        on = s.librasOn;
-    }
-    else if (k === 'tea') {
-        on = s.calmMode === 2;
-        calm = s.calmMode === 1;
-    }
-    else if (k === 'altmove') {
-        on = s.toggleMove;
-        dis = !!s.alternanciaExigida;
-    }
-    else if (k === 'contrast') {
-        on = temAltoContraste(s.visual);
-    }
-    else if (k === 'cvd') {
-        // ⚠️ O FUNDO DE DUAS CORES É O SINAL DE LIGADO deste ícone, e agora ele lê o EIXO da correção — que
-        // continua a dizer o mesmo quando o tema também está ligado, coisa que a chave única não conseguia: com
-        // `hc-direto-7` no campo, a correção da criança desaparecia do ícone que existe para a mostrar.
-        if (s.visual.correcao !== 'tricro')
-            cvd = 'pi-cvd-' + s.visual.correcao;
-    }
-    return { on, dis, calm, cvd, active: on || calm || !!cvd };
+    const v = { ...ICON_VISUAL_AT_REST, ...ICON_VISUAL[k]?.(s) };
+    // 📌 `active` is DERIVED, declared by no rule: it is the `aria-pressed`, and no icon should be able to say it is pressed
+    // without showing why.
+    return { ...v, active: v.on || v.calm || !!v.cvd };
 }
 /** The CSS classes reflectIconBtn clears before applying a fresh visual — in the original order. */
 export const ICON_STATE_CLASSES = ['pi-calm', 'pi-cvd-protan', 'pi-cvd-deuter', 'pi-cvd-tritan'];
-// --- markup (pure string builders; the DOM shell below just assigns them) ---
-/** One `.pi-btn`. `soon` icons get `.pi-soon` and the "under construction" suffix baked into the aria-label.
- *  The label is the RESTING one: reflectIconBtn overwrites it with the stateful label as soon as the bar is
- *  reflected. `ic.n` is an i18n key, so it must be resolved here too — the markup is rendered once at build
- *  time and would otherwise ship the raw key to a screen reader. */
-export function iconBtnMarkup(ic) {
-    return '<button class="pi-btn' + (ic.soon ? ' pi-soon' : '') + '" type="button" data-pi="' + ic.k +
-        '" aria-label="' + (ic.soon ? t('icon.soon', { nome: t(ic.n) }) : t(ic.n)) + '">' + ic.e + '</button>';
-}
-export function iconesQueAccionam(escritores) {
-    // ⚠️ POR ÍCONE, e não um booleano para os dois — e foi uma MUTAÇÃO SOBREVIVENTE que o mostrou. Com uma
-    // única bandeira, `&&` e `||` produziam o mesmo resultado nos casos que eu tinha escrito, porque todos
-    // tiravam os DOIS escritores. O `&&` escondia um ícone que FUNCIONA quando só um escritor falta, e o `||`
-    // mostrava um que NÃO funciona. Os dois erram, em direcções opostas, e a pergunta certa nunca foi «este
-    // jogo tem escritores visuais» — é «este ÍCONE tem quem o accione».
-    // 📌 E o `altmove` entra pela MESMA porta, que é o achado: «este jogo segura teclas?» é a mesma pergunta
-    // que «este ícone tem quem o accione», feita a um campo do contrato em vez de a um escritor injectado.
-    // Um terceiro ramo, e não uma regra nova.
-    return PAUSE_ICONS.filter((ic) => (ic.k === 'contrast' ? escritores.tema
-        : ic.k === 'cvd' ? escritores.correcao
-            : ic.k === 'altmove' ? escritores.seguraTeclas()
-                : true));
-}
 /**
- * OS TRÊS ITENS QUE A ENGINE ACCIONA SOZINHA, e que por isso nunca dependem do `getPauseActs` de um jogo.
+ * WHO ACTIVATES EACH ICON — one question per icon, and an icon nothing locks is offered.
  *
- * 📏 Lidos do despacho, e não decididos aqui: `options`/`pmback` trocam qual lista está no cartão e
- * `acessibilidade` leva o cursor à barra rápida — os três são tratados neste módulo e voltam antes de a
- * tabela do jogo ser consultada.
+ * PER ICON, not one flag for the whole bar: with one flag, a single missing writer would either hide an icon that WORKS
+ * or show one that does NOT. The question is «does this ICON have something to activate it». A table, so adding an icon
+ * is adding a row.
  */
-export const ITENS_DA_ENGINE = new Set(['options', 'pmback', 'acessibilidade']);
+const ICON_IS_ACTIONABLE = Object.freeze({
+    contrast: (w) => w.theme,
+    cvd: (w) => w.correction,
+    // «Does this game hold keys?» is the same question, asked of a contract field rather than an injected writer.
+    // AND A SECOND HALF (ADR-0218): «one button only» has a subject wherever the game declares a position to scan, so a game
+    // holding no key (the quiz demo) still has a ☝️. A game that declares nothing has none: a scan of nothing is the dead
+    // button of ADR-0106 §5 paid for in seconds.
+    altmove: (w) => w.holdsKeys() || (w.declaredPositions?.() ?? 0) > 0,
+    // The same question asked of the typography cycle (ADR-0149): the icon exists when someone knows how to walk it.
+    // `Boolean(...)` and not the raw field: it is optional, and the conversion is written rather than left to a `filter`.
+    tipografia: (w) => Boolean(w.typography),
+    // the hourglass exists where time runs by itself (ADR-0180): a turn game has nothing to slow
+    velocidade: (w) => Boolean(w.clock?.()),
+    camera: (w) => Boolean(w.camera),
+    // 👄 exists where there is a MICROPHONE to ask for, the same rule as the camera's (ADR-0106 §5)
+    voice: (w) => Boolean(w.microphone),
+    menu: (w) => Boolean(w.menus),
+});
+export function iconsThatAct(writers) {
+    // ABSENCE FROM THE TABLE MEANS YES: an icon no rule locks depends on nobody to work, and hiding it for lack of a row
+    // would take away from the child a way that exists.
+    return PAUSE_ICONS.filter((ic) => ICON_IS_ACTIONABLE[ic.k]?.(writers) ?? true);
+}
 /**
- * OS ITENS DO MENU QUE ESTE JOGO CONSEGUE MESMO ACCIONAR (ADR-0106 §5).
- *
- * ⚠️ HOJE UM ITEM SEM ACÇÃO É UM BOTÃO MORTO, E EM SILÊNCIO. O despacho faz `const fn = acts[act]; if (fn)
- * fn();` — quem carrega num item que o jogo não implementou não recebe erro, não recebe anúncio, não recebe
- * nada. Para quem vê, parece que o clique falhou; para quem navega por leitor de tela, o menu leu-lhe um
- * item que não existe. É exactamente o que o §5 chama de pior do que a ausência: «uma barra que oferece um
- * caminho e depois o recusa ensina-lhe que o caminho não é para ela».
+ * THE ITEMS THE ENGINE ACTIVATES BY ITSELF, which therefore never depend on a game's `getPauseActs`. Read from the
+ * dispatch, not decided here: `options`, `opcoesdojogo` and `pmback` change which list is on the card, and
+ * `acessibilidade` takes the cursor to the quick bar — all four are handled in this module before the game's table is
+ * consulted. What belongs to the game is the CONTENT of the list `opcoesdojogo` opens.
+ */
+const ENGINE_ITEMS = new Set(['options', 'opcoesdojogo', 'pmback', 'acessibilidade']);
+/**
+ * Why a pause item is locked, in the child's words (ADR-0161). A key per item where the reason is particular to it —
+ * «Número de jogadores»: the GAME decides how many (ADR-0147) — and one general reason for the rest. Resolved at every
+ * refresh, so it follows the language of the moment the card opens.
  */
-export function itensQueAccionam(botoes, acts) {
-    return botoes.filter((b) => ITENS_DA_ENGINE.has(b.act) || typeof acts[b.act] === 'function');
+const OWN_REASONS = new Set(['ajuda', 'addplayer', 'opcoesdojogo', 'caa']);
+function itemReason(t, act) {
+    return t(OWN_REASONS.has(act) ? `pause.motivo.${act}` : 'pause.motivo');
 }
 /**
- * A LISTA RAIZ, com uma regra a mais: `options` é uma PORTA, e uma porta para uma sala vazia também é um
- * botão morto.
- *
- * ⚠️ Esta é a parte que um filtro item-a-item não apanha. Se todos os painéis de ajuste forem filtrados —
- * um jogo que não monta nenhum —, o item `options` sobrevive (a engine acciona-o) e abre uma lista sem nada.
- * A criança atravessa uma porta e fica presa num submenu vazio, cuja única saída é o `pmback` que também
- * sumiu com ele.
+ * A door the ENGINE keeps locked whatever the game hands over. Today one: `caa`, the AAC menu, disabled until a
+ * pictogram set is licensed (ADR-0233 erratum). Its reason is only «menu disabled» — no licence explanation reaches the
+ * child — and a game's own `caa` action does not unlock it.
  */
-export function raizQueAcciona(raiz, opcoes, acts) {
-    const opcoesVivas = itensQueAccionam(opcoes, acts).filter((b) => b.act !== 'pmback');
-    const viva = itensQueAccionam(raiz, acts);
-    return opcoesVivas.length > 0 ? viva : viva.filter((b) => b.act !== 'options');
+function lockedByEngine(act) {
+    return act === 'caa' && aacMenuLocked();
 }
-/** The whole icon bar. Used by the pause screen AND by the splash `#title-icons` (which built the same string
- *  by hand in game.js — that duplication dies with this export).
- *  O parâmetro é ADITIVO e o padrão é a lista inteira: quem já chamava sem argumentos não muda de resultado. */
-export function iconsMarkup(icones = PAUSE_ICONS) {
-    return icones.map(iconBtnMarkup).join('');
+/**
+ * THE MENU ITEMS THIS GAME CAN ACTUALLY ACTIVATE. The others are not hidden: they stay on the card, LOCKED with their
+ * reason said (ADR-0161) — an item that does nothing when pressed, and says nothing, reads to a screen-reader user as an
+ * item that does not exist.
+ */
+function itemsThatAct(buttons, acts) {
+    return buttons.filter((b) => !lockedByEngine(b.act) && (ENGINE_ITEMS.has(b.act) || typeof acts[b.act] === 'function'));
 }
-/** One `.pm-btn`. Dynamic labels (`letra`/`nivel`) are rendered eagerly and carry NO `data-i18n`, so
- *  i18n.applyDom() cannot overwrite them. */
 /**
- * ⚠️ O RÓTULO DINÂMICO ENTRA PRONTO (item 19), e a mudança conserta DUAS coisas de uma vez.
- *
- * A linha era `'📚 Nível ' + level + ' · ' + qlName[level]` — e ela tinha dois defeitos que só se enxergam
- * juntos:
- *
- *   1. FRONTEIRA. `level` vinha de `core/state.quizLevel` e `qlName` de uma tabela do jogo. Um menu de pausa
- *      da ENGINE montava o rótulo de uma atividade de alfabetização — conteúdo pedagógico, não mecânica.
- *   2. IDIOMA. "Nível" é pt-BR CRU dentro de um módulo de engine. O gate do item 14 vigia o `main.js` e não
- *      alcança `ui/`, então esta linha atravessou a i18n inteira sem ser vista. Num build em inglês, o menu
- *      de pausa de uma criança dizia "📚 Nível 2 · …".
- *
- * Agora o jogo entrega a frase montada (`dynLabel`), e a engine só a coloca no botão. O jogo é quem sabe o
- * que é um nível, quem sabe o nome dele e quem sabe em que idioma dizê-lo.
+ * THE ROOT LIST, with one more rule: `options` is a DOOR, and a door to an empty room acts no more than a dead button.
+ * An item-by-item filter misses this: the engine activates `options` itself, so it would pass and open a list with
+ * nothing in it.
  */
-export function pmBtnMarkup(b, dynLabel, tr) {
-    const dyn = b.letra || b.nivel;
-    const lbl = dynLabel(b) ?? (dyn ? (b.lbl ?? '') : tr('pause.' + b.act));
-    return '<button class="pm-btn' + (b.letra ? ' pm-letra' : '') + (b.nivel ? ' pm-nivel' : '') +
-        '" role="menuitem" type="button" data-act="' + b.act + '"' +
-        (dyn ? '' : (' data-i18n="pause.' + b.act + '"')) + '>' + lbl + '</button>';
+export function rootThatActs(rootEl, options, acts, 
+// An OPTIONAL fourth argument defaulting to the EMPTY list: a game that declares nothing of its own is exactly that
+// case, so the default is also the right answer.
+fromGame = []) {
+    const howManyAct = (bs) => itemsThatAct(bs, acts).filter((b) => b.act !== 'pmback').length;
+    let alive = itemsThatAct(rootEl, acts);
+    if (howManyAct(options) === 0)
+        alive = alive.filter((b) => b.act !== 'options');
+    // The same rule for the game's own door (ADR-0146): a game with nothing of its own gets no live «game options».
+    // ADR-0182: a door whose room the ENGINE draws from the cartridge's rows is live through its action, with no list behind it
+    if (howManyAct(fromGame) === 0 && typeof acts.opcoesdojogo !== 'function')
+        alive = alive.filter((b) => b.act !== 'opcoesdojogo');
+    return alive;
 }
 /**
- * Os itens navegáveis de um cartão de pausa — os da lista VISÍVEL, e só eles.
+ * The navigable items of a pause card — those of the VISIBLE list, and only those.
  *
- * Uma constante porque TRÊS módulos a consultam (a navegação em `ui/menu-nav`, a seleção inicial em
- * `ui/shell` e a troca de submenu aqui). Enquanto fosse `.pm-btn` escrito três vezes, bastaria um deles
- * esquecer o `:not([hidden])` para o anel atravessar para a lista invisível — e a criança ouviria itens de um
- * menu que não está na tela.
+ * One constant because THREE modules ask (navigation in `ui/menu-nav`, the first selection in `ui/shell` and the list
+ * switch here): if one of them forgot `:not([hidden])`, the ring would step into the invisible list and the child would
+ * hear items of a menu that is not on screen. `:not([hidden])` on the ITEM too: a hidden item must not be reached nor
+ * counted in «N de M» (a locked one is not hidden — it is reached, and says why).
  */
-export const PM_ITENS_VISIVEIS = '.pause-menu:not([hidden]) .pm-btn';
-/** O innerHTML de UMA `.pause-menu`: a lista, e só ela. */
-export function pauseMenuHtml(bs, sub, dynLabel, tr) {
-    return '<div class="pause-menu" role="menu" data-sub="' + sub + '"' + (sub === 'raiz' ? '' : ' hidden') + '>' +
-        bs.map((b) => pmBtnMarkup(b, dynLabel, tr)).join('') + '</div>';
-}
+export const PM_VISIBLE_ITEMS = '.pause-menu:not([hidden]) .pm-btn:not([hidden])';
+/**
+ * THE DOORS INSIDE THE CARD, and which list each opens. They do nothing to the game — they change which list is on
+ * screen — so they live here and not in the action table, which lives in `ui/shell` and does not know the card.
+ * `pmback` always returns to the ROOT, from either list. A table and not a chain of `if`s: a fourth list is one more
+ * row, not one more branch.
+ */
+const DOOR_TO_LIST = Object.freeze({ options: 'opcoes', opcoesdojogo: 'jogo', pmback: 'raiz' });
+/**
+ * The other direction of the same table: the item of the root that opens each list. It is where «back» puts the cursor
+ * (ADR-0130 rule 1), and the name a list is announced by (`ui/where-the-child-is`). The root has no door.
+ */
+export const LIST_DOOR = Object.freeze({ raiz: null, opcoes: 'options', jogo: 'opcoesdojogo' });
 /**
- * Troca a lista visível de UM cartão de pausa, e põe o cursor no PRIMEIRO item da lista que entrou.
+ * Switches the visible list of ONE pause card, and puts the cursor on the FIRST item of the list that came in.
  *
- * Livre (e não um método do `init`) de propósito: `ui/menu-nav` precisa dela para o "não" voltar da lista de
- * opções à raiz, e não tem acesso às tabelas de botões. Como as duas listas já existem no markup, a troca é
- * só DOM — nada a re-renderizar, nada a injetar.
+ * Free-standing (not a method of `init`) on purpose: `ui/menu-nav` needs it for «no» to go back to the root, and it has no
+ * access to the button tables. Every list already exists in the markup, so the switch is DOM only.
  */
-export function mostrarSubmenuDaPausa(sp, sub) {
+export function showPauseOptions(sp, sub) {
     sp.querySelectorAll('.pause-menu').forEach((m) => { m.hidden = m.dataset.sub !== sub; });
-    const primeiro = sp.querySelector(PM_ITENS_VISIVEIS);
-    sp.querySelectorAll('.pm-sel,.pi-sel').forEach((b) => b.classList.remove('pm-sel', 'pi-sel'));
-    if (primeiro)
-        primeiro.classList.add('pm-sel');
-    return primeiro;
+    const first = sp.querySelector(PM_VISIBLE_ITEMS);
+    sp.querySelectorAll('.pi-sel').forEach((b) => b.classList.remove('pi-sel'));
+    markPauseItem(sp, first);
+    return first;
 }
 /**
- * A BARRA RÁPIDA DE ACESSIBILIDADE — dez alternadores e a legenda que os explica (ADR-0044, item 7).
- *
- * Saiu do cartão de pausa e passou a viver no HUD. O motivo é de uso, não de arrumação: é DURANTE a partida
- * que uma criança precisa mudar um ajuste que está a atrapalhando, e não depois de pausar. E o motivo
- * secundário é estrutural — sem ela, o cartão deixa de ter duas zonas e vira uma LISTA, o que é o que
- * finalmente autoriza o anel (a XAG 106 permite laço para menu linear e o proíbe para grade).
+ * PUTS THE CARD'S CURSOR ON `el` — the one place every move of it goes through, whatever moved it: the arrows and the pad
+ * (`ui/menu-nav`), a finger, a held press, a door between lists, «back». The card selects by class, not by browser focus,
+ * so nothing scrolls it by itself: an item past the visible part of a long list would be marked where the child cannot see
+ * it. So the list is scrolled HERE, inside the card, until the item is wholly in view (issue #134, `keepInView`).
+ */
+export function markPauseItem(sp, el) {
+    if (!el)
+        return;
+    sp.querySelectorAll('.pm-sel').forEach((b) => b.classList.remove('pm-sel'));
+    el.classList.add('pm-sel');
+    keepInView(el);
+}
+/**
+ * «BACK» FROM A LIST OF THE CARD: the root comes in with the cursor on THE ITEM THAT OPENED the list being left, not on
+ * the root's first item (ADR-0130 rule 1). A child who went into «Opções», looked, and came back is where she was; landing
+ * on «Voltar» would send her walking the root again to find her place, and a child who cannot see the mark would not even
+ * know she had been moved.
  *
- * A LEGENDA VIAJA JUNTO. Ela é a dica que substitui, para quem não vê, o `title` que só o mouse revela;
- * deixá-la no cartão tornaria a barra do HUD muda.
+ * Opening the card is another question and keeps `showPauseOptions(sp, 'raiz')`: a card opens on item 1 (ADR-0158).
+ * A door that is gone or hidden leaves the cursor on the first item, which is all there is to return to.
  */
-export function quickBarMarkup(icones = PAUSE_ICONS) {
-    return '<div class="pause-icons" role="group" aria-label="' + t('pause.iconBarAria') + '">' + iconsMarkup(icones) +
-        '</div><p class="pause-icons-cap" aria-live="polite"></p>';
+export function backToRoot(sp) {
+    const left = sp.querySelector('.pause-menu:not([hidden])')?.dataset.sub;
+    const first = showPauseOptions(sp, 'raiz');
+    const door = left ? LIST_DOOR[left] : null;
+    const opener = door ? [...sp.querySelectorAll(PM_VISIBLE_ITEMS)].find((b) => b.dataset.act === door) : undefined;
+    if (!opener || opener === first)
+        return first;
+    markPauseItem(sp, opener);
+    return opener;
 }
-export function acaoNaBarra(k, temStart) {
-    if (temStart || k.no)
+export function barAction(k, hasStart) {
+    if (hasStart || k.no)
         return 'sair';
     if (k.yes)
         return 'ativar';
@@ -355,130 +362,98 @@ export function acaoNaBarra(k, temStart) {
         return 'andar';
     return 'nada';
 }
-/** The full innerHTML of a `.screen-pause`. Pure — every input is a parameter. */
-export function screenPauseMarkup(o) {
-    // O NOME ACESSÍVEL DO DIÁLOGO passa pelo dicionário. Era texto cru, e MEDIDO num jogo em inglês o efeito
-    // era este: o título visível dizia "Paused" e o nome do diálogo, "Menu de pausa do jogador 1". Quem enxerga
-    // lia em inglês; quem escuta recebia o menu anunciado em português — a mesma assimetria do item 4 do
-    // ADR-0044, um nível acima. E `aria-label`, não `aria-labelledby`: o `<h2>` é rótulo VISUAL, e é por isso
-    // que escondê-lo num quadro apertado não tira o nome do diálogo de quem escuta.
-    return '<div class="pause-card" role="dialog" aria-modal="true" aria-label="' + t('pause.cardAria', { n: o.player + 1 }) + '">' +
-        '<h2><span data-i18n="pause.title">' + o.t('pause.title') + '</span>' + (o.numPlayers > 1 ? ' · Jogador ' + (o.player + 1) : '') + '</h2>' +
-        pauseMenuHtml(o.pmButtons, 'raiz', o.dynLabel, o.t) +
-        pauseMenuHtml(o.optionsButtons, 'opcoes', o.dynLabel, o.t) +
-        '<p class="pause-legend"></p></div>';
-}
 // ---------------------------------------------------------------------------------------------
 // DOM-facing shell
 // ---------------------------------------------------------------------------------------------
 export function initPauseIcons(ctx) {
-    // ⚠️ O NÍVEL TEA PASSOU A PERSISTIR EM 2026-09-07 (issue #61). Este comentário dizia «deliberately NOT
-    // persisted — verbatim: game.js never wrote it to storage», e o **verbatim** é o que o desqualificava como
-    // decisão: foi PRESERVADO na extração do monólito, não escolhido. O ADR-0028 diz que todo menu persiste, e
-    // este é um controlo de menu que vive na barra rápida.
+    const { t } = ctx.translator;
+    // THE CALM LEVEL PERSISTS (issue #61; ADR-0028: every menu setting persists). The child who uses the SILENT mode is the
+    // one for whom unexpected noise costs most, and a setting that is forgotten is a daily chore, not a setting.
     //
-    // O custo de não persistir era da criança que mais precisa dele: quem usa o modo SILENCIOSO voltava a
-    // pô-lo a cada sessão — e é para quem o barulho inesperado custa mais. Um ajuste que se esquece não é um
-    // ajuste, é uma tarefa diária.
-    //
-    // ⚠️ LÊ NO INIT, NUNCA NO IMPORT: a regra vale para todo o projeto e aqui tem custo concreto — um teste que
-    // importasse este módulo passaria a depender do `localStorage` do ambiente, e um nível herdado de outro
-    // caso é uma falha que aparece longe da causa.
-    let calmMode = lerNivelTea();
+    // READ IN INIT, NEVER ON IMPORT: a test importing this module would otherwise depend on the environment's storage, and a
+    // level inherited from another case is a failure that shows up far from its cause.
+    let calmMode = readTeaLevel(ctx.store);
     const P = () => ctx.getPlayers();
     /*
-     * ⚠️ A ALTERNÂNCIA DE MARCHA PASSOU A TER PADRÃO DA ENGINE (ADR-0106 §4, etapa 1b). Quem injecta continua a
-     * mandar; quem não injecta deixa de ficar sem ela — que era o caso dos cinco jogos sem barra.
-     *
-     * O `store` vem do import directo deste módulo e não do `ctx`, porque é assim que este ficheiro já persiste
-     * o resto: uma chave injectada é um campo que um consumidor pode omitir, e omiti-la faria escrever num nome
-     * torto.
+     * THE MOVEMENT LATCH HAS AN ENGINE DEFAULT (ADR-0106 §4): a host that injects one still rules; a host that does not is
+     * no longer left without it. The `store` is the page's, from the ctx (ADR-0232).
      */
     const setToggleMove = ctx.setToggleMove
-        ?? ((i, on) => definirAlternanciaDeMarcha({
-            players: P(), store, srSay: ctx.srSay, getNumPlayers: ctx.getNumPlayers,
-            // ⚠️ ATRAVESSA, e não se resolve aqui: o ícone e o painel têm de escrever a MESMA coisa. Resolver
-            // o aparelho num deles e não no outro é como duas superfícies da mesma engine passam a discordar.
-            transporteEmUso: ctx.transporteEmUso,
+        ?? ((i, on) => setMoveLatch({
+            t, players: P(), store: ctx.store, srSay: ctx.srSay, getNumPlayers: ctx.getNumPlayers,
+            // Passed through, not resolved here: the icon and the panel must write the SAME thing, and resolving the
+            // device in one of them only is how two surfaces of the same engine come to disagree.
+            transportInUse: ctx.transportInUse,
         }, i, on));
     /*
-     * ⚠️ O MODO CEGO IDEM, e aqui o padrão é literalmente o que o `core/state` já decidiu que um setter faz:
-     * «grava, persiste, avisa» — e nada mais. Os efeitos de jogo (refazer os extras do nível) são REACÇÃO, e
-     * quem reage assina `on('modoCego', …)`. O anúncio não se perde para quem não injecta: este ícone já diz
-     * `sr.icon.blindOn`/`Off` por si, logo abaixo.
+     * BLIND MODE LIKEWISE: the default is exactly what `core/state` decided a setter does — write, persist, notify — and
+     * nothing more. Game effects are REACTIONS, subscribed with `on('blindMode', …)`. The announcement is not lost for a host
+     * that injects nothing: this icon says `sr.icon.blindOn`/`Off` itself, below.
      */
-    const setModoCego = ctx.setModoCego ?? setModoCegoValue;
-    /** O documento onde se constroi. Resolvido a cada uso, e por globalThis — em node o identificador
-     *  document nem existe, e um ?? sobre ele lançaria ReferenceError em vez de cair no padrão. */
-    const docDaMontagem = () => ctx.doc ?? globalThis.document;
+    const writeBlindMode = ctx.setBlindMode ?? ((on) => { ctx.settings.setBlindModeValue(on); });
     /*
-     * ⚠️ O CONTRASTE E A COR SÓ APARECEM SE HOUVER QUEM OS ESCREVA (ADR-0106 §5).
-     *
-     * 📏 Medido em 2026-09-08, e é o que separa este caso dos outros seis campos «acidentais»: eles eram estado
-     * que um cartucho calhou de guardar, e a engine pôde reclamá-los. Estes precisam de um
-     * `render/viz-setters`, cujo contexto pede **34 campos** do grafo de render de UM jogo — `parallaxLayers`,
-     * `decoSprites`, `getPowerups`, `rebuildCoins`, `worldSprite`. O `createGame` não monta isso, e um quiz não
-     * tem nada disso para montar. A engine não pode dar um padrão aqui; o que ela pode é não FINGIR.
+     * CONTRAST AND COLOUR ONLY APPEAR IF SOMEONE CAN WRITE THEM (ADR-0106 §5): the theme and the correction are written by
+     * the host (`setPlayerTheme`/`setPlayerCorrection`), and without a writer the engine does not pretend.
      *
-     * Decidido uma vez, no arranque, e não a cada montagem de barra: o conjunto de escritores de um consumidor
-     * não muda a meio de uma partida, e recalcular por tela faria as telas discordarem entre si.
+     * Decided once, at start, not per bar: a host's set of writers does not change mid-game, and recomputing per screen
+     * would let the screens disagree.
      */
-    const iconesDoJogo = iconesQueAccionam({
-        tema: Boolean(ctx.setTemaDoJogador),
-        correcao: Boolean(ctx.setCorrecaoDoJogador),
-        // 📌 Sem `Boolean(...)`: os dois de cima perguntam «existe escritor?» a um campo opcional; este é uma
-        // RESPOSTA que o jogo deu, e envolvê-la faria um `undefined` de um ctx mal montado virar `false` —
-        // esconder o controle em silêncio, que é metade do defeito que este campo existe para não cometer.
-        seguraTeclas: ctx.seguraTeclas,
+    const gameIcons = iconsThatAct({
+        theme: Boolean(ctx.setPlayerTheme),
+        correction: Boolean(ctx.setPlayerCorrection),
+        // No `Boolean(...)`: the two above ask an optional field «is there a writer?»; this is an ANSWER the game gave, and
+        // wrapping it would turn a badly wired ctx's `undefined` into `false` — hiding the control silently.
+        holdsKeys: ctx.holdsKeys,
+        // the same question the scan asks (ADR-0218): how many positions this game would give it to offer
+        declaredPositions: ctx.declaredPositions,
+        typography: Boolean(ctx.cycleTypography),
+        // mounted when the root can answer the clock question; shown or hidden per cartridge in `reflectIconBtn` (ADR-0142)
+        clock: () => Boolean(ctx.clock),
+        camera: Boolean(ctx.camera),
+        microphone: Boolean(ctx.microphone),
+        menus: Boolean(ctx.openMenus),
     });
     /*
-     * ⚠️ RESOLVIDOS UMA VEZ, no arranque, pela mesma razão do `settings-motion`: o `rm` é mutado in-place e
-     * partilhado por REFERÊNCIA com quem desenha a cena, e resolvê-lo a cada uso criaria um objecto novo por
-     * chamada — o interruptor deixaria de alcançar o desenho, sem erro nenhum.
-     *
-     * 📌 O `getPauseActs` fica FUNÇÃO e não valor, porque a laziness dele é a razão de ele existir assim: no
-     * cartucho a tabela é um `const` declarado ~1200 linhas abaixo, e lê-la aqui cairia na zona morta temporal.
+     * RESOLVED ONCE, at start, as in `settings-motion`: `rm` is mutated in place and shared by REFERENCE with whoever draws
+     * the scene, and resolving it on each use would make a new object per call — the switch would stop reaching the drawing,
+     * with no error at all.
      */
-    const rm = ctx.rm ?? lerCenaGuardada();
-    const rmKeys = ctx.rmKeys ?? CHAVES_DE_CENA;
-    const rmChar = ctx.rmChar ?? ANIMACOES_DO_PERSONAGEM;
-    const saveRM = ctx.saveRM ?? (() => guardarCena(rm));
+    const rm = ctx.rm ?? readStoredScene(ctx.store, defaultReducedMotion(ctx.matchMedia));
+    const rmKeys = ctx.rmKeys ?? SCENE_KEYS;
+    const rmChar = ctx.rmChar ?? CHARACTER_ANIMATIONS;
+    const saveRM = ctx.saveRM ?? (() => storeScene(ctx.store, rm));
     /*
-     * ⚠️ ESTES TRÊS SÃO LIDOS A CADA CHAMADA, e não resolvidos uma vez como o `rm` acima. A diferença é
-     * deliberada e um teste apanhou-me a errá-la: congelar `ctx.getPauseActs` no arranque partiu um caso que
-     * TROCA a tabela depois do `init` — e trocar depois é legítimo, porque a laziness deste campo existe
-     * precisamente por a tabela chegar tarde. Um padrão não pode custar a ligação tardia que o campo tem.
-     *
-     * O `rm` é o contrário e por isso fica congelado: ali o que importa é a IDENTIDADE do objecto, partilhada
-     * por referência com quem desenha a cena.
+     * THESE THREE ARE READ ON EACH CALL, not resolved once like `rm` above: a host may replace the action table after `init`
+     * (it can arrive late), and a default must not cost that late binding. `rm` is the opposite — what matters there is the
+     * object's IDENTITY, shared by reference with whoever draws the scene.
      *
-     * A anotação de tipo é necessária: sem ela o padrão `() => ({})` infere `{}`, que não aceita indexação por
-     * string, e o compilador passaria a recusar `acts[act]` — o despacho inteiro.
+     * The type annotation is needed: without it the default `() => ({})` infers `{}`, which does not accept string indexing,
+     * and the compiler would refuse `acts[act]` — the whole dispatch.
      */
     const dynLabel = (b) => (ctx.dynLabel ? ctx.dynLabel(b) : null);
     const getPauseActs = () => (ctx.getPauseActs ? ctx.getPauseActs() : {});
     const setPauseActor = (i) => { if (ctx.setPauseActor)
         ctx.setPauseActor(i); };
     function hasPrivateOutput(i) { return hasPrivateOutputIn(P(), ctx.getNumPlayers(), i); }
-    /** A recusa da alternância para este jogador agora, ou `null`. Recalculada: o aparelho em uso muda. */
-    function recusaAgora(i) { return ctx.transporteEmUso ? recusaDaAlternancia(ctx.transporteEmUso(i)) : null; }
     function iconState(i) {
         const p = P()[i] || {};
         const cat = ctx.getAudioCat();
         return {
-            modoCego: ctx.getModoCego(),
+            blindMode: ctx.getBlindMode(),
             ttsOn: !!(cat && cat.tts && cat.tts.on),
             librasOn: ctx.isLibrasOn(),
             calmMode,
             toggleMove: !!p.toggleMove,
-            // ⚠️ `DEFAULTS.viz` E NÃO `''` (issue #61). A cadeia vazia funcionava por ACIDENTE: não casa
-            // `hc-direto` nem `fix-*`, então os dois ícones ficavam apagados pelo motivo certo por engano. O padrão
-            // passou a ter nome em `core/state`, e `render/viz-modes` já declarava esse modo com `kind:'normal'` —
-            // o que não faz nada. Dizer o padrão em vez de o deduzir é o que torna a marca do ADR-0029 possível
-            // aqui, porque ela lê `DEFAULTS` e mais nada.
-            visual: p.visual ?? PADRAO,
+            switchScan: ctx.settings.switchScan,
+            voice: ctx.settings.voiceControl,
+            // The NAMED default, not an empty value that only happened to match nothing: ADR-0029's changed-mark reads the
+            // default and nothing else.
+            visual: p.visual ?? DEFAULT_VISUAL,
+            speed: ctx.settings.gameSpeed,
+            camera: ctx.settings.cameraControl,
+            locale: ctx.translator.locale(),
             privateOutput: hasPrivateOutput(i),
-            alternanciaExigida: recusaAgora(i) !== null,
+            noVoice: !!ctx.noVoice?.(),
         };
     }
     // --- TEA ---------------------------------------------------------------------------------
@@ -505,14 +480,15 @@ export function initPauseIcons(ctx) {
     }
     // --- icon actions (the dispatcher, as a table) ---------------------------------------------
     const ICON_ACTS = {
+        menu: (i) => { ctx.openMenus?.(i); },
         blind: () => {
-            setModoCego(!ctx.getModoCego());
-            ctx.srSay(t(ctx.getModoCego() ? 'sr.icon.blindOn' : 'sr.icon.blindOff'));
+            writeBlindMode(!ctx.getBlindMode());
+            ctx.srSay(t(ctx.getBlindMode() ? 'sr.icon.blindOn' : 'sr.icon.blindOff'));
         },
         tts: () => {
             const cat = ctx.getAudioCat();
             if (!cat || !cat.tts)
-                return; // a guarda que `iconLabel` e `applyCalm` já tinham e esta ação não
+                return; // the same guard `iconLabel` and `applyCalm` have
             cat.tts.on = !cat.tts.on;
             ctx.setCatGain('tts');
             if (ctx.reflectTtsPanelEnabled)
@@ -525,66 +501,127 @@ export function initPauseIcons(ctx) {
         },
         tea: () => {
             calmMode = nextCalmMode(calmMode);
-            store.set(store.KEYS.tea, calmMode); // ADR-0028: todo menu persiste. Ver a nota no `let` acima.
+            ctx.store.set(KEYS.tea, calmMode); // ADR-0028: every menu setting persists. See the note at the `let` above.
             applyCalm();
             ctx.srSay(t('sr.icon.tea', { v: t(CALM_NAMES[calmMode]) }));
         },
+        /*
+         * ☝️ CYCLES THREE READINGS OF A PRESS (ADR-0218): standard · no holding needed · one button only.
+         *
+         * 📌 ENTERING THE SCAN LEAVES THE LATCH WHERE IT IS, and leaving it turns the latch off. The scan wins in `inputModeOf`, so
+         * the position shown is never ambiguous; and because the latch writer announces by itself, it is called ONLY where it
+         * changes something — otherwise the child would hear «no holding needed, off» when what ended was the scan.
+         */
         altmove: (i) => {
             // verbatim: `players[i].toggleMove` with no `||{}` guard (unlike contrast/cvd below).
-            setToggleMove(i, !P()[i].toggleMove);
+            const latched = !!P()[i].toggleMove;
+            const next = nextInputMode(inputModeOf({ toggleMove: latched, switchScan: ctx.settings.switchScan }), ctx.holdsKeys());
+            ctx.settings.setSwitchScanValue(next === 'scan');
+            // 📌 ENTERING THE SCAN LEAVES THE LATCH WHERE SHE PUT IT — the scan wins in `inputModeOf`, so the position shown is never
+            // ambiguous and coming back out returns her to the choice she had made. Leaving it writes the position she walked to.
+            // ⚠️ And the latch writer ANNOUNCES BY ITSELF, so it is called only where it changes something: otherwise the child would
+            // hear «não precisa segurar, desligado» when what ended was the scan.
+            // 📌 On every device, eyes and voice included (ADR-0249): the write goes under the transport in use, and that stored
+            // choice is what wins over the game's default the next time that transport presses.
+            if (next !== 'scan' && latched !== (next === 'sticky')) {
+                setToggleMove(i, next === 'sticky');
+                return;
+            }
+            ctx.srSay(t('sr.icon.inputMode', { v: t(INPUT_MODE_NAME[next]) }));
         },
-        // ⚠️ OS DOIS ÍCONES DEIXARAM DE SE APAGAR UM AO OUTRO (#104). Eles SEMPRE ciclaram dentro do seu eixo —
-        // `nextContrast` e `nextCvd` existem separados desde sempre —, mas escreviam os dois no mesmo campo, e
-        // por isso mexer num zerava o outro. O snapshot dizia isso como se fosse desenho: «they overwrite each
-        // other; that is by design». Agora cada um escreve no seu eixo e o outro fica onde estava.
-        // ⚠️ AS DUAS GUARDAS NÃO SÃO CINTO E SUSPENSÓRIOS. Sem escritor, o ícone nem sequer é montado
-        // (`iconesDoJogo`), então este ramo não deveria ser alcançável pela barra — mas `iconAct` é EXPORTADO e
-        // qualquer consumidor pode chamá-lo por chave. Sem a guarda, essa chamada rebentaria; com ela, não faz
-        // nada e não anuncia — que é o mesmo que dizer a verdade: este jogo não tem por onde.
+        // Each of the two icons writes its OWN axis (#104), so changing one leaves the other where it was.
+        // ⚠️ THE TWO GUARDS ARE NOT BELT AND BRACES. Without a writer the icon is not even mounted (`gameIcons`), so the bar
+        // cannot reach this branch — but `iconAct` is EXPORTED and any host can call it by key. Without the guard that call
+        // would throw; with it, nothing happens and nothing is announced — which is the truth: this game has no way to do it.
         contrast: (i) => {
-            if (!ctx.setTemaDoJogador)
+            if (!ctx.setPlayerTheme)
                 return;
-            const v = proximoTema((P()[i] || {}).visual ?? PADRAO);
-            ctx.setTemaDoJogador(i, v.tema);
-            ctx.srSay(t('sr.visual.contrast', { v: t(CURTO_DO_TEMA[v.tema]) }));
+            const v = nextTheme((P()[i] || {}).visual ?? DEFAULT_VISUAL);
+            ctx.setPlayerTheme(i, v.tema);
+            ctx.srSay(t('sr.visual.contrast', { v: t(SHORT_THEME[v.tema]) }));
+        },
+        /*
+         * THE TYPOGRAPHY CYCLE (ADR-0149 §1): one press changes the letter CASE and the FACE at once. The guard is the one
+         * written at `contrast` above, for the same reason.
+         *
+         * It ANNOUNCES THE FACE, NOT THE POSITION: «position 3 of 5» tells nobody anything; the face's name is what the child
+         * recognises — the same reason ADR-0074 forbids `action2` from reaching a person.
+         */
+        tipografia: () => {
+            if (!ctx.cycleTypography)
+                return;
+            const face = ctx.cycleTypography();
+            if (face)
+                ctx.srSay(t('sr.typo.font', { fam: face }));
+        },
+        /*
+         * PLAYING THROUGH THE WEBCAM (ADR-0215) and BY SPEAKING (ADR-0189, issue #184): each writes the child's answer, one stored key.
+         *
+         * 🔴 A POSITION THAT STARTS A CONTROL IS ANNOUNCED BY THE CONTROL, NOT HERE. At this line nothing has started: the control
+         * starts after the write, asynchronously, and answers either way — «Pronto: já pode jogar…» when it is really on, or the
+         * reason assertively when it cannot start (and the answer goes back to off). Saying the position here told the child
+         * «Comando de voz: ligado» over a button that read «desligado», on every press where the microphone or the runtime failed.
+         * Off is true the moment it is written, so off is still said here.
+         */
+        camera: () => {
+            const v = nextCameraControl(ctx.settings.cameraControl);
+            ctx.settings.setCameraControlValue(v);
+            if (v === 'off')
+                ctx.srSay(t('sr.icon.camera', { v: t('state.off') }));
+        },
+        voice: () => {
+            const v = !ctx.settings.voiceControl;
+            ctx.settings.setVoiceControlValue(v);
+            if (!v)
+                ctx.srSay(t('sr.icon.voice', { v: t('state.off') }));
+        },
+        // THE LANGUAGE (the Dev, 2026-09-16): the next flag; `setLocale` stores it and every surface redraws on `i18n:change`. Said in the NEW
+        // language, once it has loaded.
+        idioma: () => {
+            const v = nextLocale(ctx.translator.locale());
+            void ctx.translator.setLocale(v).then(() => ctx.srSay(t('sr.icon.idioma', { v: LANGUAGE_NAME[v] })));
+        },
+        // THE GAME SPEED (ADR-0180): one step down, wrapping at 50%; stored, and felt on the next frame of `startLoop`.
+        velocidade: () => {
+            const v = nextGameSpeed(ctx.settings.gameSpeed);
+            ctx.settings.setGameSpeedValue(v);
+            ctx.srSay(t('sr.icon.velocidade', { pct: Math.round(v * 100) }));
         },
         cvd: (i) => {
-            if (!ctx.setCorrecaoDoJogador)
+            if (!ctx.setPlayerCorrection)
                 return;
-            const v = proximaCorrecao((P()[i] || {}).visual ?? PADRAO);
-            ctx.setCorrecaoDoJogador(i, v.correcao);
-            ctx.srSay(t('sr.icon.cvd', { v: t(CURTO_DA_CORRECAO[v.correcao]) }));
+            const v = nextCorrection((P()[i] || {}).visual ?? DEFAULT_VISUAL);
+            ctx.setPlayerCorrection(i, v.correcao);
+            ctx.srSay(t('sr.icon.cvd', { v: t(SHORT_CORRECTION[v.correcao]) }));
         },
     };
     function iconAct(k, i) {
-        const ic = ICON_BY_KEY.get(k);
-        if (ic && ic.soon) {
-            ctx.srAlert(t('sr.icon.underConstruction', { nome: t(ic.n) }));
+        // locked like the panel's row (ADR-0185): the same reason, said, and nothing turned on
+        if (k === 'tts' && ctx.noVoice?.()) {
+            ctx.srAlert(t('audio.semVoz'));
             return;
         }
         if ((k === 'blind' || k === 'tts') && !hasPrivateOutput(i)) {
             ctx.srAlert(t('sr.icon.needsPrivateOutput'));
             return;
         }
-        // ⚠️ A MESMA RECUSA DO PAINEL, na mesma forma que as duas acima: DIZER e voltar. Aceitar o clique e
-        // ignorá-lo é a outra metade do que o ADR-0076 proíbe, e aqui há um agravante — este ícone e o
-        // `#opt-altmove` escrevem o MESMO valor, logo um a aceitar enquanto o outro recusa daria à criança dois
-        // botões que discordam sobre o mesmo ajuste.
-        if (k === 'altmove') {
-            const recusa = recusaAgora(i);
-            if (recusa) {
-                ctx.srAlert(t(recusa.chave));
-                return;
-            }
-        }
+        // No refusal for `altmove` (ADR-0249): no device locks the latch, and what a game cannot hold the CYCLE leaves out.
         const act = ICON_ACTS[k];
         if (act)
             act(i);
     }
     // --- reflection --------------------------------------------------------------------------
-    function iconLabel(k, i) { return computeIconLabel(k, iconState(i)); }
+    function iconLabel(k, i) { return computeIconLabel(t, k, iconState(i)); }
     function reflectIconBtn(b, i) {
         const k = b.dataset.pi || '';
+        // the hourglass follows the CURRENT cartridge's clock (ADR-0180): a turn game mounted later hides it, a clock game shows it
+        if (k === 'velocidade')
+            b.hidden = !ctx.clock?.();
+        if (k === 'idioma') {
+            const flag = flagOf(ctx.translator.locale());
+            if (b.innerHTML !== flag)
+                b.innerHTML = flag;
+        }
         const st = iconState(i);
         const v = computeIconVisual(k, st);
         b.classList.remove(...ICON_STATE_CLASSES);
@@ -595,26 +632,44 @@ export function initPauseIcons(ctx) {
         b.classList.toggle('pi-on', v.on);
         b.classList.toggle('pi-dis', v.dis);
         /*
-         * 🔴 A ISSUE #128, E ELA É DE UMA LINHA: `pi-dis` é CLASSE CSS. A criança que enxerga vê o ícone
-         * apagado; a que navega por leitor de tela não recebe nada — o botão anuncia-se accionável e não
-         * responde. `aria-disabled` espelha o mesmo facto para quem ouve.
-         *
-         * ⚠️ E `aria-disabled` e NÃO `disabled`: o segundo tira o botão da ordem de tabulação, e quem navega
-         * por teclado deixaria de o alcançar — logo deixaria de poder ouvir POR QUE ele não responde. É a
-         * mesma escolha que o `#opt-altmove` faz no painel, pela mesma razão.
+         * `pi-dis` is a CSS class (issue #128): a child who sees gets a greyed icon, a child on a screen reader gets nothing — the
+         * button announces itself actionable and does not respond. `aria-disabled` mirrors the same fact for whoever listens.
+         * `aria-disabled` and NOT `disabled`: the latter takes the button out of the tab order, and a keyboard user could no
+         * longer reach it — nor hear WHY it does not respond.
          */
         if (v.dis)
             b.setAttribute('aria-disabled', 'true');
         else
             b.removeAttribute('aria-disabled');
-        b.setAttribute('aria-pressed', String(v.active));
-        // ⚠️ TODO ÍCONE RECEBE RÓTULO, `soon` INCLUÍDO — e o guarda que aqui estava dizia por que não: «`soon`
-        // buttons keep the label the markup gave them (same string)». A segunda metade continua certa (não há
-        // estado a reportar), mas «mesma string» era verdade só enquanto a marcação e o reflexo corressem no
-        // MESMO IDIOMA — e desde que a engine passou a montar a barra (ADR-0106 etapa 2) deixam de correr.
-        // O `initI18n` carrega en/es de forma assíncrona; a marcação nasce em pt e só o reflexo a corrige.
-        // 📌 Medido num navegador: cinco ícones em inglês e três ainda em «(em construção)», na mesma barra.
-        b.setAttribute('aria-label', computeIconLabel(k, st));
+        // the ☰ opens something and holds no state: a pressed/unpressed button would announce a toggle
+        if (k === 'menu')
+            b.removeAttribute('aria-pressed');
+        else
+            b.setAttribute('aria-pressed', String(v.active));
+        // ⚠️ EVERY icon is relabelled here, including the ones that carry no state — because the markup and this reflection do not
+        // run in the same language. `initI18n` loads en/es asynchronously, so the markup is born in pt and only the reflection
+        // corrects it. 📌 Measured in a browser back when a guard skipped some of them: five icons in English and three still in
+        // Portuguese, on the same bar.
+        b.setAttribute('aria-label', computeIconLabel(t, k, st));
+        refreshCursorCaption(b);
+    }
+    /**
+     * THE NAME UNDER THE ROW FOLLOWS THE LABEL OF THE ICON UNDER THE CURSOR (ADR-0159 rule 10, ADR-0167). The caption is the
+     * visible half of what the cursor says, and the reflection is how a state changed ELSEWHERE reaches the icon — the 🦯, 📷
+     * and 👄 through the root's `stateOn`, the 🗣 through the mixer's `onCatChange` (ADR-0247). Written only on a move or a press,
+     * the caption kept the state the child had left while the label spoke the new one.
+     *
+     * Only the CURSOR's icon (`.pi-sel`, which lives only on the bars `getA11yBars` hands over): another icon's name under the
+     * row would move the cursor's only visible mark. And only when the text CHANGED: the per-screen bar's caption is a live
+     * region, and the same words rewritten are said again.
+     */
+    function refreshCursorCaption(b) {
+        if (!b.classList.contains('pi-sel'))
+            return;
+        const cap = ctx.getA11yBars().find((bar) => bar.contains(b))?.querySelector('.pause-icons-cap');
+        const text = accessibleLabel(b); // name and state only: «N de M» is spoken, never written (ADR-0167)
+        if (cap && cap.textContent !== text)
+            cap.textContent = text;
     }
     function reflectIconsIn(root, i) {
         if (!root)
@@ -622,111 +677,137 @@ export function initPauseIcons(ctx) {
         root.querySelectorAll('.pi-btn').forEach((b) => reflectIconBtn(b, i));
     }
     /**
-     * Reflete os ícones de TODAS as telas. Varre as BARRAS e não mais os cartões de pausa: desde o item 7 do
-     * ADR-0044 os ícones vivem no HUD, e um cartão de pausa não contém `.pi-btn` nenhum.
+     * THE CARDS THIS INSTANCE BUILT. Private: whoever built them keeps them, which asks nothing of any host — a ctx field
+     * would be one more thing every game had to remember to pass.
      */
-    /**
-     * OS CARTÕES QUE ESTA INSTÂNCIA CONSTRUIU. Privado, e é a resposta a um problema que eu próprio criei.
-     *
-     * ⚠️ O `PauseIconsCtx` tinha um `getPauseScreens` e eu removi-o hoje, com razão: tinha ZERO leitores. Agora
-     * este módulo precisa de alcançar os cartões — e a saída certa NÃO é repor o campo. Quem os construiu foi
-     * ele; guardar o que construiu não pede nada a consumidor nenhum, e um campo de ctx é mais uma coisa que
-     * cada um dos 300 jogos teria de se lembrar de passar.
+    const cards = [];
+    /*
+     * `refreshPauseItems` LOCKS THE ITEMS THIS GAME CANNOT ACTIVATE — recomputed, not decided at start. The action table can
+     * arrive after the card is built (`getPauseActs` is asked when needed), so deciding at build time would lose for good
+     * every item whose action exists only later. The host calls `reflectPauseIcons()` when the pause opens and when a
+     * cartridge is mounted, so the card is right at the moment the child sees it.
      */
-    const cartoes = [];
     /**
-     * ESCONDE OS ITENS QUE ESTE JOGO NÃO CONSEGUE ACCIONAR — recalculado, e não decidido no arranque.
+     * THE CARD'S NAME — what is SEEN and what is HEARD — repainted in the current language.
      *
-     * ⚠️ ESTA FUNÇÃO EXISTE POR UM DEFEITO DE TEMPO. O cartão era FILTRADO no `buildScreenPause`, e o
-     * `getPauseActs` é um getter precisamente porque a tabela CHEGA TARDE — «`pauseActs` is a `const` declared
-     * far below the init site», diz o próprio campo. Um consumidor que siga esse padrão documentado montava um
-     * cartão sem os itens cuja acção só existiu depois do boot, e nunca mais os recuperava.
+     * The markup is born before an asynchronously loaded dictionary arrives, and an `aria-label` set once cannot be corrected
+     * later by `applyDom`, which only reaches `[data-i18n]` and `[data-i18n-aria]`. Nor would `data-i18n-aria` do: `applyDom`
+     * calls `t(k)` without parameters, and this key carries the seat number — the child would hear «Player {n} pause menu»,
+     * braces included. So it is repainted on each `reflectPauseIcons()`, i.e. when the pause opens.
      *
-     * 📌 A avaliação passou para o ÚLTIMO instante possível: o `ui/shell` chama `reflectPauseIcons()` quando a
-     * fase vira `pause-menu`, ou seja quando a pausa ABRE. O §5 continua respeitado — a criança nunca vê um
-     * item que não acciona —, e agora também vê os que passaram a accionar.
+     * The one who lost was the one who LISTENS (ADR-0044 item 4): to a sighted child the card was entirely in the right
+     * language, and nothing looked wrong.
      */
-    function refrescarItensDaPausa() {
+    function renameCard(cardEl, i) {
+        const card = cardEl.querySelector('.pause-card');
+        if (card)
+            card.setAttribute('aria-label', t('pause.cardAria', { n: i + 1 }));
+        const seat = cardEl.querySelector('h2 .pause-seat');
+        if (seat)
+            seat.textContent = ctx.getNumPlayers() > 1 ? t('pause.cardSeat', { n: i + 1 }) : '';
+    }
+    function refreshPauseItems() {
         const acts = getPauseActs();
-        const raiz = ctx.pmButtons ?? PM_BTNS;
-        const opcoes = ctx.optionsButtons ?? PM_OPTIONS_BTNS;
-        const vivos = new Set([
-            ...raizQueAcciona(raiz, opcoes, acts).map((b) => b.act),
-            ...itensQueAccionam(opcoes, acts).map((b) => b.act),
+        const rootEl = ctx.pmButtons ?? PM_BTNS;
+        const options = ctx.optionsButtons ?? PM_OPTIONS_BTNS;
+        const fromGame = ctx.gameButtons ?? PM_GAME_BTNS;
+        const actingItems = new Set([
+            ...rootThatActs(rootEl, options, acts, fromGame).map((b) => b.act),
+            ...itemsThatAct(options, acts).map((b) => b.act),
+            ...itemsThatAct(fromGame, acts).map((b) => b.act),
         ]);
-        // ⚠️ `filter(Boolean)`: os cartões são indexados por JOGADOR, e montar só a tela 2 deixa um buraco no
-        // índice 0. Um `for…of` sobre array esparso entrega `undefined`, e foi o que rebentou à primeira.
-        for (const cartao of cartoes.filter(Boolean)) {
-            for (const btn of cartao.querySelectorAll('.pm-btn')) {
-                // ⚠️ `hidden` e não `remove()`: reaparecer tem de ser possível, porque a tabela pode crescer outra vez
-                // (um jogo que só liga «sair» depois da primeira fase). Remover seria decidir uma vez de novo.
-                btn.hidden = !vivos.has(btn.dataset.act ?? '');
+        // An explicit index, not `filter(Boolean)`: the cards are indexed by PLAYER, building only screen 2 leaves a hole at
+        // index 0, and closing the hole would renumber the seats in the card's name. The `undefined` guard is written by hand.
+        for (let i = 0; i < cards.length; i++) {
+            const cardEl = cards[i];
+            if (!cardEl)
+                continue;
+            renameCard(cardEl, i);
+            for (const btn of cardEl.querySelectorAll('.pm-btn')) {
+                // LOCKED WITH ITS REASON, NOT HIDDEN (ADR-0161, superseding ADR-0106 §5 here): a card that changed shape from game
+                // to game hid from the child that an option exists. The cursor still stops on the item and it still counts;
+                // reaching or pressing it says why. And not `remove()`: the table can grow later.
+                const act = btn.dataset.act ?? '';
+                if (actingItems.has(act)) {
+                    btn.removeAttribute('aria-disabled');
+                    delete btn.dataset.motivo;
+                }
+                else {
+                    btn.setAttribute('aria-disabled', 'true');
+                    btn.dataset.motivo = itemReason(t, act);
+                }
             }
         }
     }
     function reflectPauseIcons() {
         ctx.getA11yBars().forEach((bar, i) => reflectIconsIn(bar, i));
-        refrescarItensDaPausa();
+        refreshPauseItems();
     }
     // --- the pause screen ----------------------------------------------------------------------
     /**
-     * Troca a lista visível E ANUNCIA o primeiro item da lista que entrou.
-     *
-     * O anúncio não é enfeite: quem não enxerga acabou de mudar de menu e o cursor pulou para outro lugar. Sem
-     * a fala, a única pista de que a tela mudou seria o silêncio. O índice "N de M" vem junto (item 3), e é ele
-     * que diz de quantos itens é a lista nova.
+     * Switches the visible list AND ANNOUNCES the first item of the list that came in. Not decoration: a child who cannot see
+     * has just changed menus and the cursor jumped; without speech the only clue would be silence. The «N de M» index comes
+     * with it (ADR-0044 item 3) and says how many items the new list has.
      */
-    function anunciarLista(sp, sub) {
-        const primeiro = mostrarSubmenuDaPausa(sp, sub);
-        if (!primeiro)
+    function announceList(sp, sub) {
+        // «back» lands on the door that opened the list being left (ADR-0130 rule 1); any other door, on the first item
+        const cursor = sub === 'raiz' ? backToRoot(sp) : showPauseOptions(sp, sub);
+        if (!cursor)
             return;
-        const itens = [...sp.querySelectorAll(PM_ITENS_VISIVEIS)];
-        ctx.srSay(anunciarItem({ rotulo: primeiro.textContent || '', posicao: 1, total: itens.length }, menuIndexOn));
+        const items = [...sp.querySelectorAll(PM_VISIBLE_ITEMS)];
+        ctx.srSay(announceItem(t, { label: cursor.textContent || '', position: items.indexOf(cursor) + 1, total: items.length }, ctx.settings.menuIndexOn));
     }
-    /* ===================== O MODO `accessibility` (ADR-0044, item 7) ===================== */
+    /* ===================== THE `accessibility` MODE (ADR-0044 item 7) ===================== */
     /**
-     * Quem está com o direcional dirigindo a BARRA em vez do personagem.
-     *
-     * Vida de RODADA (ADR-0038): mora no closure desta instância, não é persistido, e some com a partida. Um
-     * modo de entrada que sobrevivesse ao reinício seria a armadilha voltando pela porta dos fundos — a criança
-     * abriria o jogo no dia seguinte e o personagem não andaria.
+     * Who has the d-pad steering the BAR instead of the character. ROUND lifetime (ADR-0038): it lives in this instance's
+     * closure, is not persisted, and goes with the round — an input mode that survived a restart would be the trap coming
+     * back: the child would open the game the next day and the character would not move.
      */
-    const naBarra = new Set();
-    /** O cursor da barra da tela `i`, ou o primeiro ícone quando ainda não há cursor. */
-    function iconeSelecionado(bar) {
+    const onBar = new Set();
+    /** Screen `i`'s bar cursor, or the first icon when there is no cursor yet. */
+    function selectedIcon(bar) {
         return bar.querySelector('.pi-sel') || bar.querySelector('.pi-btn');
     }
-    /** Põe o cursor num ícone, escreve a legenda e ANUNCIA — a legenda é o canal de quem não vê o ícone. */
-    function selecionarIcone(bar, el) {
+    /** Puts the cursor on an icon, writes the caption and ANNOUNCES — speech is the channel of whoever cannot see the icon. */
+    function selectIcon(i, bar, el) {
         bar.querySelectorAll('.pi-sel').forEach((x) => x.classList.remove('pi-sel'));
         el.classList.add('pi-sel');
         const cap = bar.querySelector('.pause-icons-cap');
         if (cap)
-            cap.textContent = legendaDoIcone(bar, el);
-        ctx.srSay(legendaDoIcone(bar, el));
+            cap.textContent = accessibleLabel(el);
+        ctx.srSay(iconCaption(t, bar, el, ctx.settings.menuIndexOn)); // the spoken one carries the place (ADR-0167)
+        ctx.explainIcon?.(i, el.dataset.pi ?? null);
     }
     /**
-     * ENTRA no modo: o direcional passa a dirigir a barra da tela `i`, e o jogo VOLTA a rodar.
+     * ENTERS the mode: the d-pad now steers screen `i`'s bar.
+     *
+     * It does NOT resume the game (ADR-0155): START is the QUICK PAUSE, the bar is used with the game FROZEN, and resuming on
+     * entry would unfreeze the world the instant the child asked it to stop. Whoever enters decides the phase.
      *
-     * O anúncio diz como SAIR, e diz na hora de entrar. É a linha que desarma a armadilha que o próprio
-     * ADR-0044 anotou como consequência negativa desta decisão: quem não enxerga aperta a direção, o personagem
-     * não anda, e sem esta frase não há nada na tela que explique — porque a tela não é o canal dessa criança.
+     * The announcement says how to LEAVE, at the moment of entering — the line that disarms the trap ADR-0044 recorded as a
+     * negative consequence: a child who cannot see presses a direction, the character does not move, and nothing on screen
+     * explains why, because the screen is not that child's channel.
      */
-    function entrarNaBarra(i) {
+    function enterBarMode(i) {
         const bar = ctx.getA11yBars()[i];
-        const primeiro = bar && iconeSelecionado(bar);
-        if (!bar || !primeiro)
+        const first = bar && selectedIcon(bar);
+        if (!bar || !first)
             return;
-        naBarra.add(i);
-        const acts = getPauseActs();
-        if (acts.resume)
-            acts.resume(); // volta à tela normal: o modo é para usar DURANTE a partida
+        onBar.add(i);
         ctx.srSay(t('sr.a11y.barEnter'));
-        selecionarIcone(bar, primeiro);
+        selectIcon(i, bar, first);
     }
-    /** SAI do modo e devolve o direcional ao personagem. Anuncia, porque a devolução também é informação. */
-    function sairDaBarra(i) {
-        if (!naBarra.delete(i))
+    /**
+     * LEAVES the mode and gives the d-pad back to the character. It announces, because giving it back is information too.
+     *
+     * `silent` is for leaving the bar for ANOTHER screen, not for the game — SELECT, which swaps the quick pause for the card
+     * (ADR-0155): «back to the game» said there would be a lie, with the card opening on top.
+     *
+     * `onLeaveBar` runs on EVERY exit — Back, START or whoever calls this — because the root must unfreeze the game by any
+     * door. An exit only one path knew would leave the child on the other back at the character in a stopped world.
+     */
+    function leaveBarMode(i, silent = false) {
+        if (!onBar.delete(i))
             return;
         const bar = ctx.getA11yBars()[i];
         if (bar) {
@@ -735,113 +816,116 @@ export function initPauseIcons(ctx) {
             if (cap)
                 cap.textContent = '';
         }
-        ctx.srSay(t('sr.a11y.barExit'));
+        ctx.explainIcon?.(i, null);
+        if (!silent)
+            ctx.srSay(t('sr.a11y.barExit'));
+        ctx.onLeaveBar?.(i, silent);
     }
-    /** A tela `i` está com o direcional na barra? É o que o roteamento de entrada pergunta a cada quadro. */
-    const naBarraDe = (i) => naBarra.has(i);
+    /** Is screen `i`'s d-pad on the bar? What input routing asks every frame. */
+    const isOnBar = (i) => onBar.has(i);
     /**
-     * UM PASSO dentro do modo. `temStart` é a borda do botão que abre a pausa — a segunda saída.
+     * ONE STEP inside the mode. `hasStart` is the edge of the button that opens the pause — the second way out.
      *
-     * A barra é uma fileira, então as QUATRO direções andam nela: para quem navega sem ver, "cima" numa lista
-     * de uma linha só não pode ser um beco. E anda em ANEL, como todo menu do jogo desde o item 1.
+     * The bar is one row, so all FOUR directions move along it: for someone navigating without sight, «up» in a one-row list
+     * must not be a dead end. And it moves in a RING, like every menu of the game (ADR-0044 item 1).
      */
-    function navBar(i, k, temStart = false) {
-        if (!naBarra.has(i))
+    function navBar(i, k, hasStart = false) {
+        if (!onBar.has(i))
             return;
         const bar = ctx.getA11yBars()[i];
         if (!bar)
             return;
-        const acao = acaoNaBarra(k, temStart);
-        if (acao === 'sair') {
-            sairDaBarra(i);
+        const action = barAction(k, hasStart);
+        if (action === 'sair') {
+            leaveBarMode(i);
             return;
         }
-        const icones = [...bar.querySelectorAll('.pi-btn')];
-        if (!icones.length)
+        const icons = [...bar.querySelectorAll('.pi-btn')];
+        if (!icons.length)
             return;
-        const cur = iconeSelecionado(bar);
-        const idx = cur ? icones.indexOf(cur) : 0;
-        if (acao === 'ativar') {
-            setPauseActor(i);
-            if (cur)
-                cur.click();
+        // never null here: the bar has an icon, and `selectedIcon` falls back to the first one
+        const cur = selectedIcon(bar);
+        // the click goes through the bar's own listener, which records who pressed it (`setPauseActor`)
+        if (action === 'ativar') {
+            cur.click();
             return;
         }
-        if (acao === 'andar') {
-            const d = (k.down || k.right) ? 1 : -1;
-            selecionarIcone(bar, icones[passoNoAnel(icones.length, idx, d)]);
-        }
+        if (action === 'andar')
+            selectIcon(i, bar, icons[stepInRing(icons.length, icons.indexOf(cur), (k.down || k.right) ? 1 : -1)]);
     }
     function buildScreenPause(i) {
-        const sp = docDaMontagem().createElement('div');
+        const sp = ctx.doc.createElement('div');
         sp.className = 'screen-pause';
         sp.hidden = true;
         sp.dataset.player = String(i);
         /*
-         * ⚠️ MONTA A LISTA INTEIRA E ESCONDE DEPOIS — e a versão anterior desta linha FILTRAVA aqui, o que estava
-         * errado por uma razão de TEMPO. O comentário que estava neste sítio dizia «montar é o primeiro instante
-         * em que a resposta existe»; não é. O `getPauseActs` é um getter precisamente porque a tabela chega
-         * TARDE — «`pauseActs` is a `const` declared far below the init site», diz o próprio campo —, e o
-         * `createGame` monta durante o próprio `createGame(...)`. Filtrar aqui apagava para sempre todo item cuja
-         * acção só passou a existir depois do boot.
-         *
-         * Quem decide o que se VÊ é o `refrescarItensDaPausa`, a cada `reflectPauseIcons()` — que o `ui/shell`
-         * dispara quando a fase vira `pause-menu`, ou seja quando a pausa ABRE. O §5 continua respeitado (a
-         * criança nunca vê um item que não acciona) e agora também vê os que passaram a accionar.
+         * BUILDS THE WHOLE LIST, and `refreshPauseItems` decides which items act — here and on every `reflectPauseIcons()`.
+         * Filtering at build time would lose for good every item whose action exists only after the boot (see above).
          */
         sp.innerHTML = screenPauseMarkup({
             player: i,
             numPlayers: ctx.getNumPlayers(),
             pmButtons: ctx.pmButtons ?? PM_BTNS,
             optionsButtons: ctx.optionsButtons ?? PM_OPTIONS_BTNS,
+            gameButtons: ctx.gameButtons ?? PM_GAME_BTNS,
             dynLabel: dynLabel, t,
         });
-        cartoes[i] = sp;
-        refrescarItensDaPausa(); // o §5 vale já na montagem, e não só na primeira abertura
+        cards[i] = sp;
+        refreshPauseItems(); // the lock holds from the build, not only from the first opening
         sp.addEventListener('click', (e) => {
-            const target = e.target;
-            const b = target && target.closest('.pm-btn');
-            if (b) {
-                setPauseActor(i);
-                const act = b.dataset.act || '';
-                // NAVEGAÇÃO DENTRO DO CARTÃO fica aqui, e não na tabela de ações: `options` e `pmback` não fazem nada
-                // ao jogo — trocam qual lista está na tela. A tabela vive em `ui/shell`, que não conhece este `sp`.
-                if (act === 'options' || act === 'pmback') {
-                    anunciarLista(sp, act === 'options' ? 'opcoes' : 'raiz');
-                    return;
-                }
-                // `acessibilidade` leva o cursor à BARRA RÁPIDA. Enquanto ela mora dentro do cartão, "entrar no modo"
-                // é pôr o cursor nela — e a saída continua sendo a saída da pausa, que é a mesma de sempre. Quando o
-                // item 7 levar a barra para o HUD, esta linha o segue; o que o item SIGNIFICA não muda.
-                if (act === 'acessibilidade') {
-                    entrarNaBarra(i);
-                    return;
-                }
-                const acts = getPauseActs();
-                const fn = acts[act];
-                if (fn)
-                    fn();
-                return;
-            }
+            const b = e.target?.closest('.pm-btn');
+            if (b)
+                pressPauseItem(i, sp, b);
         });
         return sp;
     }
+    /** One item of screen `i`'s pause card pressed — a locked one, a door between its lists, the quick bar, or an action. */
+    function pressPauseItem(i, sp, b) {
+        // 🔴 THE CURSOR GOES WHERE THE CHILD PRESSED (ADR-0130 rule 1). A finger or a mouse opens a panel without walking the
+        // arrows, and the mark stayed on the item the arrows had last reached — so «back» from the panel returned her to an
+        // item she never chose. The keyboard's press is already on its item; this is the pointer's half.
+        markPauseItem(sp, b);
+        // LOCKED (ADR-0161): pressing it SAYS the reason and does nothing — neither door nor action.
+        if (b.getAttribute('aria-disabled') === 'true') {
+            const reason = b.dataset.motivo ?? '';
+            ctx.srSay(reason);
+            ctx.explainItem?.(reason);
+            return;
+        }
+        setPauseActor(i);
+        const act = b.dataset.act || '';
+        // «Opções do jogo» with the cartridge's rows opens the engine's panel (ADR-0182), not the list a host may pass
+        const doorWithPanel = act === 'opcoesdojogo' && typeof getPauseActs().opcoesdojogo === 'function';
+        if (DOOR_TO_LIST[act] && !doorWithPanel) {
+            announceList(sp, DOOR_TO_LIST[act]);
+            return;
+        }
+        // `acessibilidade` takes the cursor to the QUICK BAR. The item is not in the engine's root (ADR-0151); only a list a
+        // GAME passes reaches it, and for that list the card closes and the bar is used — explicitly, since `enterBar` does
+        // not resume by itself (ADR-0155).
+        if (act === 'acessibilidade') {
+            getPauseActs().resume?.();
+            enterBarMode(i);
+            return;
+        }
+        const fn = getPauseActs()[act];
+        if (fn)
+            fn();
+    }
     /**
-     * A BARRA RÁPIDA de uma tela: os dez alternadores, a legenda, e a fiação dos dois.
+     * One screen's QUICK BAR: the toggles, the caption, and their wiring.
      *
-     * Ela é IRMÃ da `.screen-exp` e não filha, e isso é a decisão do #82 aplicada: a barra é CONTROLE, não
-     * experiência. O modo empatia degrada a experiência de propósito — simulação é criar dificuldade onde a
-     * facilidade não existe —, e degradar o que existe para DAR acesso seria o contrário do que ele serve.
+     * A SIBLING of `.screen-exp`, not a child (#82): the bar is CONTROL, not experience. Empathy mode degrades the experience
+     * on purpose — a simulation creates difficulty — and degrading what exists to GIVE access would be the opposite.
      */
     function buildQuickBar(i) {
-        const bar = docDaMontagem().createElement('div');
+        const bar = ctx.doc.createElement('div');
         bar.className = 'screen-a11y';
         bar.dataset.player = String(i);
-        bar.innerHTML = quickBarMarkup(iconesDoJogo);
-        // FORA DA ORDEM DE TABULAÇÃO durante a partida (ADR-0044, item 7). Dez paradas entre a criança e o jogo
-        // seria o preço de deixá-los lá — e o alcance por teclado não se perde: ele passa a ser o modo
-        // `accessibility`, que se abre pela pausa. A barra do TÍTULO não é afetada: lá não se está jogando, e o
-        // `tabindex` é posto AQUI, no elemento, e não no markup que as duas compartilham.
+        bar.innerHTML = quickBarMarkup(ctx.translator, gameIcons);
+        // OUT OF THE TAB ORDER during play (ADR-0044 item 7): a stop per icon between the child and the game would be the price
+        // of leaving them in, and keyboard reach is not lost — it becomes the `accessibility` mode, opened from the pause. The
+        // bar the root mounts in `#title-icons` is unaffected: the `tabindex` is set HERE, on the element, not in the shared markup.
         bar.querySelectorAll('.pi-btn').forEach((b) => { b.tabIndex = -1; });
         const cap = bar.querySelector('.pause-icons-cap');
         bar.addEventListener('click', (e) => {
@@ -852,39 +936,25 @@ export function initPauseIcons(ctx) {
             iconAct(ib.dataset.pi || '', i);
             reflectPauseIcons(); // must run BEFORE reading the label back — that is what makes the caption honest
             if (cap)
-                cap.textContent = legendaDoIcone(bar, ib);
-        });
-        // Legenda = o `aria-label` do botão, para que passar o mouse ou focar diga a MESMA verdade que um leitor
-        // de tela anunciaria. Uma fonte só para quem vê e para quem escuta.
-        //
-        // E ELA SOME AO SAIR. Antes ficava: a última explicação apontada permanecia por cima do jogo até alguém
-        // apontar outra. Numa barra que agora vive na TELA DE JOGO isso é uma faixa de texto parada em cima da
-        // partida — o Dev viu e disse o que é: explicação só enquanto o mouse estiver no botão.
-        //
-        // A EXCEÇÃO É O CURSOR DO MODO `accessibility`: quando ele está pousado num ícone, a legenda é a única
-        // coisa que diz onde ele está, e apagá-la ao mexer o mouse cegaria o modo. Daí a pergunta pelo `.pi-sel`.
-        const limpar = () => { if (cap && !bar.querySelector('.pi-sel'))
-            cap.textContent = ''; };
-        bar.querySelectorAll('.pi-btn').forEach((b) => {
-            const show = () => { if (cap)
-                cap.textContent = legendaDoIcone(bar, b); };
-            b.addEventListener('mouseenter', show);
-            b.addEventListener('focus', show);
-            b.addEventListener('mouseleave', limpar);
-            b.addEventListener('blur', limpar);
+                cap.textContent = accessibleLabel(ib);
         });
+        // Caption = the button's `aria-label`, so hovering or focusing says the SAME truth a screen reader would announce: one
+        // source for whoever sees and whoever listens. It GOES AWAY on leaving — a bar on the play screen must not leave a strip
+        // of text over the game (the Dev: an explanation only while the pointer is on the button). The exception is the
+        // `accessibility` mode's CURSOR: when it sits on an icon the caption is the only thing saying where it is, hence the
+        // `.pi-sel` check in `wireBarCaption`.
+        wireBarCaption(bar, (k) => ctx.explainIcon?.(i, k));
         return bar;
     }
     return {
-        buildScreenPause, buildQuickBar, entrarNaBarra, sairDaBarra, naBarraDe, navBar,
-        iconesMontados: iconesDoJogo,
+        buildScreenPause, buildQuickBar, enterBar: enterBarMode, leaveBar: leaveBarMode, onBar: isOnBar, navBar,
+        mountedIcons: gameIcons,
         iconAct, iconLabel, reflectIconBtn, reflectIconsIn, reflectPauseIcons,
-        // ⚠️ O `setCalmMode` PERSISTE TAMBÉM, e sanea. Ele é a outra porta para o mesmo valor — se só o ciclo do
-        // ícone gravasse, um nível posto por aqui sobreviveria à sessão e não ao fecho da aba, que é a metade
-        // pior do defeito: o ajuste parece ter pegado e some depois.
+        // `setCalmMode` PERSISTS TOO, and sanitises: it is the other door to the same value, and a level set here that only
+        // lasted the session would look applied and then vanish.
         applyCalm,
         getCalmMode: () => calmMode,
-        setCalmMode: (n) => { calmMode = saneiaNivelTea(n); store.set(store.KEYS.tea, calmMode); },
+        setCalmMode: (n) => { calmMode = sanitiseTeaLevel(n, DEFAULTS.calmMode); ctx.store.set(KEYS.tea, calmMode); },
         iconState,
     };
 }