@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/ui/pause-icons.d.ts

@@ -1,146 +1,101 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import type { PlayerView } from '../core/entity.js';
 import type { NavKeys } from '../input/edges.js';
-import { type Tema, type Correcao, type VisualState } from '../render/viz-axes.js';
+import type { Translate, Translator } from '../core/i18n.js';
+import { type PauseMenuButton, type PauseSub } from './pause-markup.js';
+import { type PauseIcon } from '../core/pause-icon-catalogue.js';
+import { type Theme, type Correction, type VisualState } from '../render/viz-axes.js';
 import type { MotionSceneFlags, MotionSceneKey, MotionCharDef } from './settings-motion.js';
-import type { AudioCatState } from './settings-audio.js';
+import type { AudioCatState } from './audio-choices.js';
+import { type MediaQuery } from '../core/setting-defaults.js';
+import { type CameraControl } from '../core/camera-cycle.js';
 /**
- * A LEGENDA de um ícone da barra de acessibilidade — uma função, e não três cópias da mesma expressão.
+ * THE THREE POSITIONS OF ☝️ (ADR-0218): how the child's presses are read.
  *
- * 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`.
- *
- * 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.
+ * They are not three settings but three READINGS of the same press, which is why one icon holds them and why they are shown as
+ * one position. `standard` is the press as it arrives; `sticky` makes a tap last until the next one (ADR-0113); `scan` offers
+ * the game's positions one at a time and lets any press take the one showing.
  */
-export declare function legendaDoIcone(barra: ParentNode, el: HTMLElement): string;
-export interface PauseIcon {
-    /** `data-pi` key — the dispatch key of iconAct/iconLabel/reflectIconBtn. */
-    k: string;
-    /** The emoji glyph rendered inside the button. */
-    e: string;
-    /** i18n KEY of the base name; also the `aria-label` when the icon carries no state (or is `soon`). */
-    n: string;
-    /** Under construction: the button announces itself and does nothing else. */
-    soon?: boolean;
-}
-/** 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. */
-export declare const PAUSE_ICONS: readonly PauseIcon[];
-export declare function pauseIcon(k: string): PauseIcon | undefined;
-/** TEA cycle: 0 = normal · 1 = calmo (reduces) · 2 = silencioso (switches off). Never touches TTS/blind mode. */
-export declare const CALM_NAMES: readonly string[];
+export type InputMode = 'standard' | 'sticky' | 'scan';
 /**
- * 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.
+ * 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 declare function saneiaNivelTea(bruto: number): number;
-/** The audio categories `applyCalm` governs. TTS/sonar/guarda/guia stay untouched — a calm player still needs them. */
-export declare const CALM_AUDIO_CATS: readonly string[];
-/** Colour-vision-deficiency cycle, in `player.viz` values. */
-export declare const CVD_SEQ: readonly string[];
-/** 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 declare const CVD_NAMES: readonly string[];
-/** `player.viz` → i18n key of the label used by iconLabel (anything else falls back to the 'off' key). */
-export declare const CVD_LABELS: Readonly<Record<string, string>>;
-/** The slice of a player object the pause icons touch. `players` (core/state) is typed `unknown[]`. */
+export declare function inputModeOf(s: {
+    readonly toggleMove?: boolean;
+    readonly switchScan?: boolean;
+}): InputMode;
+export declare function nextInputMode(m: InputMode, holdsKeys: boolean): InputMode;
+import type { Store } from '../platform/storage.js';
 /**
- * A fatia que os ícones de pausa tocam — derivada de core/entity, e SEM assinatura de índice.
- *
- * Havia uma (`[prop: string]: unknown`), posta ali porque `applyCalm` escreve por nome calculado
- * (`p[c.prop] = …`). Era andaime: `c.prop` tem tipo `MotionCharProp`, que é a união literal
- * `'rmWalk' | 'rmBreath' | 'rmFlavor'`, e o TypeScript verifica acesso por chave literal sem precisar de
- * assinatura nenhuma — bastava que os três campos tivessem nome, que é o que a derivação deu.
+ * Hover and focus on a bar's icons write its NAME in the bar's `.pause-icons-cap` and ask for its EXPLANATION.
  *
- * E ela custava caro: uma assinatura de índice aceita QUALQUER propriedade, com valor `unknown`. Enquanto
- * existiu, um erro de digitação em qualquer campo deste objeto compilava em silêncio. Quem a denunciou foi
- * tipar `core/state.players` como `Player[]`: o compilador recusou converter um `Player` — que não tem
- * assinatura de índice — para ela, e essa recusa é a informação.
+ * 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 type PausePlayer = PlayerView<'visual' | 'toggleMove' | 'walkDir' | 'audioSink' | 'rmWalk' | 'rmBreath' | 'rmFlavor'>;
-/** One `.pm-btn` descriptor — the shape of game.js's PM_BTNS (owned by ui/activities-menu). */
-export interface PauseMenuButton {
-    act: string;
-    /** Só é lido quando o botão tem rótulo dinâmico; ver a nota em `PauseBtnDef` (ui/activities-menu). */
-    lbl?: string;
-    /** Dynamic label (the ABC cycle) — rendered from `lbl`, not from i18n, and NOT given `data-i18n`. */
-    letra?: boolean;
-    /** Dynamic label (the literacy level) — rendered from quizLevel + qlName. Currently dormant: no PM_BTNS
-     *  entry sets it, but the branch is live code and is ported verbatim. */
-    nivel?: boolean;
+export declare function wireBarCaption(bar: HTMLElement, explain: (k: string | null) => void): void;
+/**
+ * THE SETTINGS THE BAR READS AND WRITES — the page's settings store, built by the root (ADR-0232 D2c, issue #207). The
+ * names are `core/state`'s own, so the root passes the store itself; the reads are LIVE (a getter or a live binding),
+ * because another surface — the motion panel, a gamepad, a second screen — changes them between two presses.
+ */
+export interface PauseIconsSettings {
+    /** The «N de M» at the end of an announcement (ADR-0044 item 3). */
+    readonly menuIndexOn: boolean;
+    readonly gameSpeed: number;
+    setGameSpeedValue(speed: number): void;
+    readonly cameraControl: CameraControl;
+    setCameraControlValue(mode: CameraControl): void;
+    readonly voiceControl: boolean;
+    setVoiceControlValue(on: boolean): void;
+    readonly switchScan: boolean;
+    setSwitchScanValue(on: boolean): void;
+    /** The blind-mode writer used when the host injects no `setBlindMode`: write, persist, notify. */
+    setBlindModeValue(on: boolean): void;
 }
+/** What the bar reads and writes through: the calm level, the movement latch and the scene flags' default. */
+export type PauseIconsStore = Pick<Store, 'getNum' | 'set' | 'setBool' | 'getJSON' | 'setJSON'>;
+/**
+ * The slice of a player the pause icons touch — derived from core/entity, and WITHOUT an index signature: one would
+ * accept ANY property with an `unknown` value, so a typo in any field would compile silently. `applyCalm` writes by a
+ * computed name (`p[c.prop] = …`), and `c.prop` is the literal union `'rmWalk' | 'rmBreath' | 'rmFlavor'`, which TypeScript
+ * checks without any signature.
+ */
+export type PausePlayer = PlayerView<'visual' | 'toggleMove' | 'walkDir' | 'audioSink' | 'rmWalk' | 'rmBreath' | 'rmFlavor'>;
 /** Everything the label/visual of ONE icon depends on, gathered in one value. */
 export interface IconStateSnapshot {
-    modoCego: boolean;
+    blindMode: boolean;
     ttsOn: boolean;
     librasOn: boolean;
     calmMode: number;
     toggleMove: boolean;
     /**
-     * O estado visual em DOIS EIXOS (#104).
-     *
-     * ⚠️ ERA `viz: string`, E O COMENTÁRIO DIZIA: «shared by the contrast and CVD icons (they overwrite each
-     * other; **that is by design**)». Não era desenho — era o campo único a impor-se, e a frase é o defeito
-     * escrito como se fosse decisão. Os dois ícones sempre ciclaram DENTRO do seu eixo (`nextContrast` e
-     * `nextCvd` existem desde sempre, separados); só não tinham onde guardar o resultado sem apagar o vizinho.
+     * The visual state on TWO AXES (#104): the contrast icon cycles the theme and the colour icon cycles the correction,
+     * each within its own axis, and neither erases the other.
      */
     visual: VisualState;
+    /** Playing by SPEAKING (ADR-0189): the 👄 of the bar, on or off. */
+    voice?: boolean;
+    /** Playing with ONE button (ADR-0218): the third position of ☝️, which wins over the latch when it is on. */
+    switchScan?: boolean;
+    /** The game speed (ADR-0180), a step of `core/game-speed`; absent reads as 100%. */
+    speed?: number;
+    /** Playing through the webcam (ADR-0215); absent reads as off. */
+    camera?: CameraControl;
+    /** The current locale (`core/i18n`), for the language button. */
+    locale?: string;
     /** False disables the blind/TTS icons: those need an audio output nobody else is listening to. */
     privateOutput: boolean;
-    /**
-     * O aparelho em uso EXIGE a alternância? (ADR-0113 cláusula 3.)
-     *
-     * ⚠️ Em olhos, rosto, gestos e fala ela é o que faz a entrada funcionar, logo não há escolha a oferecer.
-     * O ícone fica desabilitado COM MOTIVO, como o painel — e não pode divergir dele: as duas superfícies
-     * escrevem o mesmo valor, e uma que aceitasse o clique enquanto a outra recusa deixaria a criança com
-     * dois botões que discordam sobre o mesmo ajuste.
-     *
-     * 🔴 OPCIONAL PORQUE O GATE DA FORMA ME APANHOU: eu escrevi-o obrigatório, e o
-     * `tests/superficie-publica` reprovou com «ENTROU como obrigatório» — que é uma MUDANÇA QUEBRANTE do
-     * pacote, porque quem constrói este snapshot passa a ter de o preencher. Foi para isto que o gate da
-     * FORMA (`2f2582f`) foi escrito, e é a primeira vez que ele apanha um campo A ENTRAR e não a sair.
-     * Ausente significa «ninguém me disse», que degrada para «não exijo» — o comportamento de hoje.
-     */
-    alternanciaExigida?: boolean;
+    /** No voice speaks the current language (ADR-0185): the narration icon is locked. Absent reads as a voice. */
+    noVoice?: boolean;
 }
-/** 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 declare function hasPrivateOutputIn(list: readonly PausePlayer[], count: number, i: number): boolean;
-/** TEA cycle step. */
-export declare function nextCalmMode(cur: number): number;
-/** Next high-contrast level. An unlisted `viz` (e.g. a CVD filter) is treated as index 0 ⇒ jumps to 'hc-direto'. */
-export declare function nextContrast(cur: string | undefined): string;
-/** 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 declare function nextCvd(cur: string | undefined): {
-    idx: number;
-    mode: string;
-};
-/** 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 declare function calmAudioPlan(calmMode: number, vol: number): {
-    on: boolean;
-    vol: number;
-};
-/** What `applyCalm` does to the scene/character reduced-motion flags. */
-export declare function calmMotionPlan(calmMode: number): {
-    sceneReduced: boolean;
-    charFrozen: boolean;
-};
 /** 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 declare function computeIconLabel(k: string, s: IconStateSnapshot): string;
+export declare function computeIconLabel(t: Translate, k: string, s: IconStateSnapshot): string;
 /** The visual state of one icon button. `active` is what becomes `aria-pressed`. */
 export interface IconVisual {
     /** `.pi-on` — the yellow "this is on" state. */
@@ -154,316 +109,275 @@ export interface IconVisual {
     /** aria-pressed: on OR calm OR a CVD tint. */
     active: boolean;
 }
-/** Pure form of reflectIconBtn's branching. A `soon` icon lands on all-false — it never claims to be on. */
+/** Pure form of reflectIconBtn's branching. */
 export declare function computeIconVisual(k: string, s: IconStateSnapshot): IconVisual;
 /** The CSS classes reflectIconBtn clears before applying a fresh visual — in the original order. */
 export declare const ICON_STATE_CLASSES: readonly string[];
-/** 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 declare function iconBtnMarkup(ic: PauseIcon): string;
 /**
- * OS ÍCONES QUE ESTE JOGO CONSEGUE MESMO ACCIONAR (ADR-0106 §5).
- *
- * ⚠️ NENHUMA ETAPA PODE ENTREGAR BOTÃO MORTO, e o registo diz porquê com todas as letras: «uma barra que
- * oferece a uma criança um caminho e depois o recusa é pior do que uma barra que ela vê que não está lá,
- * porque a primeira ensina-lhe que o caminho não é para ela».
- *
- * ⚠️ E O CONTRASTE E A COR SÃO O CASO REAL, medido em 2026-09-08 e diferente dos outros seis campos
- * «acidentais»: eles não são estado que um cartucho calhou de guardar — precisam de um `render/viz-setters`,
- * cujo contexto tem **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. Então aqui a engine não pode oferecer um padrão — o que ela pode é **não fingir**.
- *
- * ⚠️ Isto NÃO é o mesmo que `soon`. `soon` é «ainda não construímos»; isto é «este jogo não tem por onde», e
- * um botão que anuncia «em breve» diria a coisa errada.
+ * THE ICONS THIS GAME CAN ACTUALLY ACTIVATE (ADR-0106 §5): no stage may ship a dead button — «a bar that offers a child a
+ * way and then refuses it is worse than a bar she sees is not there, because the first teaches her the way is not for
+ * her». An icon with nothing to activate it is not mounted, rather than mounted to announce «soon».
  */
-export interface AccionaveisDoJogo {
-    /** Há quem escreva o TEMA (o alto contraste)? Sem ele, o ícone `contrast` não é montado. */
-    readonly tema: boolean;
-    /** Há quem escreva a CORREÇÃO de cor? Sem ela, o ícone `cvd` não é montado. */
-    readonly correcao: boolean;
+export interface ActionableIcons {
+    /** Is there anyone to write the THEME (high contrast)? Without it, the `contrast` icon is not mounted. */
+    readonly theme: boolean;
+    /** Is there anyone to write the colour CORRECTION? Without it, the `cvd` icon is not mounted. */
+    readonly correction: boolean;
     /**
-     * ESTE JOGO SEGURA ALGUMA TECLA? — `GameDeclaration.seguraTeclas`, o campo do ADR-0115.
+     * DOES THIS GAME HOLD ANY KEY? — `GameDeclaration.holdsKeys`, the field of ADR-0115.
      *
-     * 🔴 Sem ele o ícone `altmove` não é montado, e a AUSÊNCIA é a decisão. A alternância existe para quem não
-     * consegue manter uma tecla premida; num jogo onde nada se segura ela não tem o que travar, e um controle
-     * que não faz nada ensina a uma criança que o ajuste de que ela depende está partido.
+     * The latch exists for whoever cannot keep a key pressed; in a game where nothing is held it has nothing to hold, and a
+     * control that does nothing teaches a child that the setting she depends on is broken. On eyes, face, gestures and
+     * speech it is also the latch's default (ADR-0249) — read by the root at every command, not here.
      *
-     * ⚠️ E ISTO É UMA AUSÊNCIA DIFERENTE DA DO ADR-0113 cláusula 3, que também vive neste ficheiro: lá o
-     * controle fica DESABILITADO com o motivo, porque o aparelho EXIGE a alternância e ela não se pode
-     * desligar. Aqui não há nada a travar, e um controle que explica por que não faz nada continua a ser um
-     * controle que não faz nada.
+     * A FUNCTION, not a value (as in ADR-0084): an answer read once goes stale silently, and with one `createGame` serving
+     * several cartridges (ADR-0142) the icon would describe the game that booted first.
+     */
+    readonly holdsKeys: () => boolean;
+    /**
+     * HOW MANY POSITIONS THIS GAME DECLARED (`CreateGameOptions.preset`, ADR-0162) — what a scan would have to offer (ADR-0218).
+     * A function like its neighbour, so a cartridge mounted later answers for itself (ADR-0142); absent reads as none.
+     */
+    readonly declaredPositions?: () => number;
+    /**
+     * Does this game's time run by itself? (`tick: 'clock'`, ADR-0180.) Without it the hourglass is not mounted. A function,
+     * like `holdsKeys`, so a cartridge mounted later answers for itself (ADR-0142).
+     */
+    readonly clock?: () => boolean;
+    /**
+     * Does anyone know how to walk the typography cycle? (ADR-0149 §1.)
      *
-     * ⚠️ É FUNÇÃO E NÃO VALOR, e a razão é a mesma do ADR-0084: uma resposta lida uma vez envelhece em
-     * silêncio. Aqui envelhecia no pior sítio — o `reflectPauseIcons` existe justamente porque «a tabela de
-     * acções deste jogo pode ter mudado desde a montagem» (ADR-0106 §5), e refrescava a partir de um booleano
-     * congelado no arranque. Com um `createGame` a servir vários cartuchos (ADR-0142), o ícone descrevia o
-     * jogo que arrancou primeiro. O contrato nunca esteve errado: `GameDeclaration.seguraTeclas` já é função.
+     * OPTIONAL, absent meaning `false` — unlike `holdsKeys`, which is required because both of its values can be wrong.
+     * Here `false` hides an icon that would do nothing, which is exactly what ADR-0106 §5 wants.
      */
-    readonly seguraTeclas: () => boolean;
+    readonly typography?: boolean;
+    /** Can this device play through the webcam — is there a camera to ask for? Without it the 📷 is not mounted (ADR-0215). */
+    readonly camera?: boolean;
+    /** Is there a microphone to ask for? Without one the 👄 is not mounted. */
+    readonly microphone?: boolean;
+    /** Is there a card of menus to open? Without it the ☰ is not mounted. */
+    readonly menus?: boolean;
 }
 /**
- * @deprecated O nome dizia «escritores VISUAIS» e a pergunta deixou de ser só visual quando o `seguraTeclas`
- * entrou (ADR-0115). Use `AccionaveisDoJogo`. O alias fica para o consumidor não pagar duas quebras no mesmo
- * major — uma pelo campo novo e outra pelo nome.
- */
-export type EscritoresVisuais = AccionaveisDoJogo;
-export declare function iconesQueAccionam(escritores: AccionaveisDoJogo): readonly PauseIcon[];
-/**
- * OS TRÊS ITENS QUE A ENGINE ACCIONA SOZINHA, e que por isso nunca dependem do `getPauseActs` de um jogo.
- *
- * 📏 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.
- */
-export declare const ITENS_DA_ENGINE: ReadonlySet<string>;
-/**
- * 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».
+ * @deprecated The name said «VISUAL writers», and the question stopped being only visual when `holdsKeys` joined it
+ * (ADR-0115). Use `ActionableIcons`.
  */
-export declare function itensQueAccionam(botoes: readonly PauseMenuButton[], acts: Record<string, (() => void) | undefined>): readonly PauseMenuButton[];
+export type VisualWriters = ActionableIcons;
+export declare function iconsThatAct(writers: ActionableIcons): readonly PauseIcon[];
 /**
- * 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.
+ * 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 declare function raizQueAcciona(raiz: readonly PauseMenuButton[], opcoes: readonly PauseMenuButton[], acts: Record<string, (() => void) | undefined>): readonly PauseMenuButton[];
-/** 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 declare function iconsMarkup(icones?: readonly PauseIcon[]): string;
-/** One `.pm-btn`. Dynamic labels (`letra`/`nivel`) are rendered eagerly and carry NO `data-i18n`, so
- *  i18n.applyDom() cannot overwrite them. */
+export declare function rootThatActs(rootEl: readonly PauseMenuButton[], options: readonly PauseMenuButton[], acts: Record<string, (() => void) | undefined>, fromGame?: readonly PauseMenuButton[]): readonly PauseMenuButton[];
 /**
- * ⚠️ 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:
+ * The navigable items of a pause card — those of the VISIBLE list, and only those.
  *
- *   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.
+ * 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 declare function pmBtnMarkup(b: PauseMenuButton, dynLabel: (b: PauseMenuButton) => string | null, tr: (key: string) => string): string;
+export declare const PM_VISIBLE_ITEMS = ".pause-menu:not([hidden]) .pm-btn:not([hidden])";
 /**
- * Qual das duas listas o cartão de pausa está mostrando.
- *
- * DUAS listas no markup, UMA visível — e a escondida carrega `hidden`, que a tira da árvore de acessibilidade
- * inteira. É o que faz "um menu por tela" (ADR-0044 §5) valer para quem escuta e não só para quem vê, e é o
- * que permite o anel dar a volta DENTRO da lista visível sem nunca atravessar para a outra.
+ * 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 type PauseSub = 'raiz' | 'opcoes';
+export declare const LIST_DOOR: Readonly<Record<PauseSub, string | null>>;
 /**
- * Os itens navegáveis de um cartão de pausa — os da lista VISÍVEL, e só eles.
+ * Switches the visible list of ONE pause card, and puts the cursor on the FIRST item of the list that came in.
  *
- * 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.
+ * 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 declare const PM_ITENS_VISIVEIS = ".pause-menu:not([hidden]) .pm-btn";
-/** O innerHTML de UMA `.pause-menu`: a lista, e só ela. */
-export declare function pauseMenuHtml(bs: readonly PauseMenuButton[], sub: PauseSub, dynLabel: (b: PauseMenuButton) => string | null, tr: (key: string) => string): string;
+export declare function showPauseOptions(sp: HTMLElement, sub: PauseSub): HTMLElement | null;
 /**
- * Troca a lista visível de UM cartão de pausa, e põe o cursor no PRIMEIRO item da lista que entrou.
- *
- * 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.
+ * 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 declare function mostrarSubmenuDaPausa(sp: HTMLElement, sub: PauseSub): HTMLElement | null;
+export declare function markPauseItem(sp: HTMLElement, el: HTMLElement | null | undefined): void;
 /**
- * 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).
+ * «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 declare function quickBarMarkup(icones?: readonly PauseIcon[]): string;
+export declare function backToRoot(sp: HTMLElement): HTMLElement | null;
 /**
- * O QUE UMA INTENÇÃO SIGNIFICA DENTRO DO MODO `accessibility` (ADR-0044, item 7).
+ * WHAT AN INTENT MEANS INSIDE THE `accessibility` MODE (ADR-0044 item 7).
  *
- * O registro listou este modo entre as consequências NEGATIVAS da decisão, e disse por quê: "um modo em que
- * se entra e não se sabe sair é a própria armadilha de que este registro trata — então a saída dele (START ou
- * VOLTAR) é parte da decisão, e não um detalhe de implementação".
+ * The record lists this mode among the decision's NEGATIVE consequences, and says why: a mode one enters and does not
+ * know how to leave is the very trap the record is about — so its way out (START or BACK) is part of the decision.
  *
- * Daí a forma desta função: SAIR vem primeiro, e vem por DUAS portas. Não é redundância. VOLTAR é a saída de
- * tudo no jogo, e é o que quem já o conhece tenta primeiro; START é o botão que ABRE a pausa, e a pausa é de
- * onde se entrou aqui — quem se perde tenta voltar por onde veio. Ter só uma das duas seria apostar que a
- * criança adivinhe qual delas foi escolhida.
+ * Hence the shape: LEAVING comes first, through TWO doors. BACK is the way out of everything in the game, the one a child
+ * who knows it tries first; START is the button that OPENS the pause, and the pause is where this mode was entered from —
+ * whoever gets lost tries to go back the way they came. One door only would be betting that the child guesses which.
  *
- * E a precedência é decisão também: um controle registra mais de uma borda no mesmo quadro (dedos apertam
- * junto), e nesse quadro `sair` não pode ficar atrás de `ativar`.
+ * The precedence is a decision too: a controller can report more than one edge in the same frame (fingers press
+ * together), and in that frame leaving must not come after activating.
  */
-export type AcaoNaBarra = 'sair' | 'ativar' | 'andar' | 'nada';
-export declare function acaoNaBarra(k: NavKeys, temStart: boolean): AcaoNaBarra;
-export interface ScreenPauseMarkupOpts {
-    /** Screen/player index (0-based); the dialog label and the "· Jogador N" suffix are 1-based. */
-    player: number;
-    /** Live player count — the suffix only appears in multiplayer. */
-    numPlayers: number;
-    /** A lista RAIZ: os sete itens do ADR-0044, `resume` primeiro e `quit` último. */
-    pmButtons: readonly PauseMenuButton[];
-    /** O submenu de opções: os sete painéis de ajuste, com o "Voltar" na frente. */
-    optionsButtons: readonly PauseMenuButton[];
-    /** Rótulo pronto de um botão DINÂMICO, ou `null` se aquele botão não tem um. Quem monta a frase é o jogo. */
-    dynLabel: (b: PauseMenuButton) => string | null;
-    t: (key: string) => string;
-}
-/** The full innerHTML of a `.screen-pause`. Pure — every input is a parameter. */
-export declare function screenPauseMarkup(o: ScreenPauseMarkupOpts): string;
+export type BarAction = 'sair' | 'ativar' | 'andar' | 'nada';
+export declare function barAction(k: NavKeys, hasStart: boolean): BarAction;
 export interface PauseIconsCtx {
     /**
-     * O DOCUMENTO onde a pausa e a barra são CONSTRUÍDAS. Ausente, vale o global.
-     *
-     * ⚠️ ISTO É O ACHADO 15 OUTRA VEZ, e o `boot/create-game` já o descreve no próprio cabeçalho: «`initI18n()`
-     * chamava `applyDom(document)`, o GLOBAL, por baixo de quem a chamasse. Num navegador dá no mesmo e por
-     * isso sobreviveu; num teste de lógica pura é a diferença entre bootar e não bootar, e num futuro com dois
-     * documentos (uma engine em iframe, um editor ao lado do jogo) seria a diferença entre traduzir o documento
-     * certo e o outro.»
-     *
-     * 📏 Medido em 2026-09-08: as duas metades que constroem DOM (`buildScreenPause`, `buildQuickBar`) faziam
-     * `document.createElement` no global. Enquanto a raiz de composição de cada jogo era um `main.ts` a correr
-     * num navegador, dava no mesmo — e foi por isso que sobreviveu. Deixa de dar assim que a ENGINE monta,
-     * porque o `createGame` recebe o documento por `host.doc` e pode estar a montar noutro.
+     * The root's translator (ADR-0232 D3 erratum): its `t`, the page's language — the 🌐 shows it as a flag — and the setter
+     * the 🌐 switches it with. A Pick and not a bare `t`, because the bar reads and sets the language.
+     */
+    translator: Pick<Translator, 't' | 'locale' | 'setLocale'>;
+    /**
+     * The DOCUMENT where the pause card and the bar are BUILT. REQUIRED (ADR-0232 D4): `createGame` receives its document
+     * through `host.doc` and may be building in another one (an iframe, an editor beside the game), and a fallback to the
+     * global would put the card in the wrong document — or throw where there is none.
      */
-    doc?: Document;
-    /** Quantos jogadores/telas. Estado de RODADA (ADR-0038): vem da instância que a raiz possui.
-     *  Era `numPlayers`, um `let` de `core/state` importado como binding vivo — e um `let` de módulo
-     *  é compartilhado por qualquer segundo jogo que a mesma página carregue (D13 do `demos`). */
+    doc: Pick<Document, 'createElement'>;
+    /** How many players/screens. ROUND state (ADR-0038): it comes from the instance the host owns — a module-level
+     *  binding would be shared by a second game on the same page. */
     getNumPlayers: () => number;
-    /** Os jogadores. Estado de RODADA, pelo mesmo motivo. `readonly unknown[]` porque cada consumidor
-     *  estreita para a SUA fatia — o tipo real é do jogo, não da engine (ADR-0033). */
+    /** The players. ROUND state, for the same reason. `readonly unknown[]` because each consumer narrows to ITS slice —
+     *  the real type is the game's, not the engine's (ADR-0033). */
     getPlayers: () => readonly unknown[];
     /** aria-live "polite" — every successful toggle announces its NEW state. */
     srSay: (text: string) => void;
-    /** aria-live "assertive" — the two refusals (`soon` icon, shared audio output). */
+    /** aria-live "assertive" — the refusals (a shared audio output, no voice for the language). */
     srAlert: (text: string) => void;
     /**
-     * As BARRAS RÁPIDAS por tela (`.screen-a11y`), na ordem dos jogadores.
-     *
-     * Existe pelo mesmo motivo de `getPauseScreens`: `buildGameHud` REATRIBUI a array a cada remontagem, então
-     * o que se injeta é o getter e não a array. E existe separada da pausa porque, desde o item 7, a barra não
-     * mora mais dentro dela — o daltonismo é POR JOGADOR, e refletir os ícones exige achar a barra daquela tela.
+     * Called after EVERY exit from the bar mode, with the screen and whether it was silent. Absent, nothing happens. It lets
+     * the root unfreeze the game whichever door was used (ADR-0155) — the bar knows nothing of phases.
+     */
+    onLeaveBar?: (i: number, silent: boolean) => void;
+    /**
+     * The icon screen `i` is pointing at — by the cursor of the bar, or hover/focus — or `null` when nothing is. The
+     * root writes that icon's EXPLANATION in the footer (the Dev: the name below the row, what it does in the footer;
+     * `CLAUDE.md` §4, the three zones). Absent, the bar still shows the name.
+     */
+    explainIcon?: (i: number, k: string | null) => void;
+    /** A text for the screen footer — the reason of a locked pause item (ADR-0161) — or `null` to clear it. */
+    explainItem?: (text: string | null) => void;
+    /**
+     * The per-screen QUICK BARS (`.screen-a11y`), in player order. A getter, because the host rebuilds them when the number of
+     * screens changes. Separate from the pause card because the bar does not live inside it (ADR-0044 item 7) — colour
+     * correction is PER PLAYER, and reflecting the icons means finding that screen's bar.
      */
     getA11yBars: () => readonly HTMLElement[];
-    /** PM_OPTIONS_BTNS — o submenu de opções. Mesma dona, mesmo motivo: ninguém tem duas cópias de uma lista. */
+    /** PM_OPTIONS_BTNS — the options sub-list. */
     optionsButtons?: readonly PauseMenuButton[];
-    /** PM_BTNS — the `.pm-btn` list. Owned by ui/activities-menu; injected, never copied. */
+    /** The GAME's list (ADR-0146). Absent = `PM_GAME_BTNS`, which is only «back» — and the door drops by itself. */
+    gameButtons?: readonly PauseMenuButton[];
+    /** PM_BTNS — the root `.pm-btn` list (`ui/pause-buttons`). */
     pmButtons?: readonly PauseMenuButton[];
-    /** QL_NAME — literacy-level names, for the (dormant) `nivel` button. Same owner as pmButtons. */
     /**
-     * O RÓTULO de um botão dinâmico, pronto — ou `null` quando aquele botão não tem um (item 19).
-     *
-     * Era `quizLevel` (importado de `core/state`) mais `qlName` (tabela do jogo), e este módulo montava a
-     * frase. Um menu de pausa da ENGINE não sabe o que é nível de alfabetização, nem em que idioma dizê-lo.
-     * Função e não valor, porque o rótulo muda em execução — de nível E de idioma.
+     * The ready LABEL of a dynamic button, or `null` when that button has none. A function, because the label changes at run
+     * time — in value and in language. A pause card of the ENGINE does not know what a literacy level is, nor how to say it.
      */
-    /** O rótulo dinâmico, pronto — ou `null`. Ausente: nenhum botão deste jogo tem rótulo dinâmico. */
     dynLabel?: (b: PauseMenuButton) => string | null;
-    /** The `.pm-btn` action table. LAZY: `pauseActs` is a `const` declared far below the init site in game.js. */
+    /** The `.pm-btn` action table, asked when an item is pressed (so it can be wired after this module). */
     getPauseActs?: () => Record<string, (() => void) | undefined>;
-    /** Records which player opened the menu. `pauseActor` itself stays in game.js — the gamepad, the keyboard
-     *  router, openHelp() and openOptions() all read it there. */
+    /** Records which player opened the card; the panels open scoped to that player. */
     setPauseActor?: (i: number) => void;
-    getModoCego: () => boolean;
-    setModoCego?: (on: boolean) => void;
+    getBlindMode: () => boolean;
+    setBlindMode?: (on: boolean) => void;
     /**
-     * O mixer por categoria. NULO até `initAudioMixer()` — `platform/audio` o declara
-     * `Record<string, CatState> | null` porque o import dele é PURO (não lê localStorage), e quem inicializa
-     * é o boot do consumidor. Este ctx pedia não-nulo, o que era uma promessa que a fonte não faz.
+     * The mixer by category. NULL until `initAudioMixer()`: `platform/audio`'s import is PURE (it reads no storage), and the
+     * host's boot initialises it.
      */
     getAudioCat: () => Record<string, AudioCatState> | null;
     /** Re-applies a category's gain node after `on`/`vol` changed. */
     setCatGain: (k: string) => void;
-    /** Repaints the TTS row of the auditory panel. See BUG #1 in the report: in game.js this call is behind a
-     *  `typeof reflectTTS==='function'` guard on a symbol that no longer exists, so it never fires. The guard is
-     *  ported verbatim as `reflectTtsPanelEnabled` below rather than silently fixed. */
+    /** Repaints the TTS row of the auditory panel after the icon changes it. */
     reflectTtsPanel: () => void;
-    /** Verbatim port of game.js's dead guard: `typeof reflectTTS === 'function'`. Pass `false` to preserve
-     *  today's behaviour (the panel is NOT refreshed), `true` to restore the intended call. */
+    /**
+     * Whether the TTS icon also calls `reflectTtsPanel`. `createGame` passes `false`: it repaints the panel from the mixer's
+     * `onCatChange`, which hears this icon's write like any other (ADR-0247). A host without that listener passes `true`.
+     */
     reflectTtsPanelEnabled: boolean;
     isLibrasOn: () => boolean;
     toggleLibras: () => void;
+    /**
+     * THE PAGE'S STORE, built by the root (ADR-0232, issue #207): the calm level, the movement latch's default writer and the
+     * scene flags' default read and write through it. REQUIRED: a bar that stored nowhere would forget the calm level at every
+     * visit — for the child whom unexpected noise costs most — with no error at all.
+     */
+    store: PauseIconsStore;
+    /**
+     * THE PAGE'S SETTINGS STORE (ADR-0232 D2c): what the icons read and cycle — game speed, the camera and voice controls,
+     * switch scanning, the menu index — and the default blind-mode writer. REQUIRED: a bar reading settings from nowhere
+     * would show every icon at its default and write the child's choice where no game reads it.
+     */
+    settings: PauseIconsSettings;
     rm?: MotionSceneFlags;
     rmKeys?: readonly MotionSceneKey[];
     rmChar?: readonly MotionCharDef[];
     saveRM?: () => void;
+    /**
+     * The browser's media query (`win.matchMedia`), asked for `prefers-reduced-motion` when `rm` is absent and nothing is
+     * stored. MANDATORY and injected (ADR-0232, ADR-0227): this module reaches no global, and an optional port would let a
+     * host forget it and switch the animation back on for a child whose system asked for less.
+     */
+    matchMedia: MediaQuery;
     setToggleMove?: (i: number, on: boolean) => void;
     /**
-     * QUAL APARELHO ESTE JOGADOR ESTÁ A USAR (ADR-0113).
-     *
-     * 📌 O ícone `altmove` desta barra é a OUTRA superfície que escreve a alternância — a mesma razão pela
-     * qual o escritor voltou para a engine (ADR-0106 §4). Sem este campo, ele escreveria só a chave antiga
-     * enquanto o painel escreve as duas, e as duas superfícies divergiriam em silêncio.
+     * WHICH DEVICE THIS PLAYER IS USING (ADR-0113). The `altmove` icon is the OTHER surface that writes the latch, besides
+     * the panel: without this it would write a different key from the panel's, and the two surfaces would disagree silently.
      */
-    transporteEmUso?: (jogador: number) => string;
+    transportInUse?: (player: number) => string;
     setPlayerViz?: (i: number, mode: string) => void;
-    /** Os escritores POR EIXO (#104): mexer no tema não apaga a correção, e vice-versa. */
-    setTemaDoJogador?: (i: number, tema: Tema) => void;
-    setCorrecaoDoJogador?: (i: number, correcao: Correcao) => void;
+    /** The writers PER AXIS (#104): changing the theme does not erase the correction, and vice versa. */
+    setPlayerTheme?: (i: number, theme: Theme) => void;
+    setPlayerCorrection?: (i: number, correction: Correction) => void;
     /**
-     * ESTE JOGO SEGURA ALGUMA TECLA? — o valor de `GameDeclaration.seguraTeclas` (ADR-0115). Sem ele o ícone
-     * `altmove` não é montado.
-     *
-     * ⚠️ OBRIGATÓRIO, e vai contra a direcção do ADR-0106, que passou a tornar campos deste ctx OPCIONAIS para
-     * a engine poder montar sozinha. A excepção tem razão medida: os campos que ganharam padrão têm um padrão
-     * SEGURO — o modo cego começa desligado, a lista de botões vem da engine. Aqui não há: `true` monta um
-     * controle que pode não fazer nada, e `false` esconde um de que uma criança depende. Os dois lados erram, e
-     * é essa a condição que o `holdsAtOnce` já usou para ser obrigatório também.
-     *
-     * 📌 Quem passa pelo `createGame` não escreve isto: a raiz lê a declaração, que já é obrigatória. O campo
-     * só é visível para um cartucho que chame `initPauseIcons` por fora — e é exactamente esse que não pode
-     * ficar em silêncio.
+     * MOVES ONE STEP IN THE TYPOGRAPHY CYCLE and returns the face it landed on (ADR-0149 §1). ONE field, not two (read and
+     * write): the position belongs to whoever keeps the cycle; this module only needs the face's NAME to announce it.
+     * ABSENT = THE ICON IS NOT MOUNTED (ADR-0106 §5).
+     */
+    cycleTypography?: () => string | null;
+    /**
+     * DOES THIS GAME HOLD ANY KEY? — `GameDeclaration.holdsKeys` (ADR-0115). Without it the `altmove` icon is not mounted.
      *
-     * ⚠️ FUNÇÃO, não valor — ver a nota no campo homónimo de `EscritoresVisuais`. Um cartucho que monte isto
-     * por fora passa `() => this.declaration.seguraTeclas()` e não o resultado dela.
+     * ⚠️ REQUIRED, against ADR-0106's direction of making this ctx's fields optional: the fields that got a default have a
+     * SAFE one (blind mode starts off, the button lists come from the engine). This one has none — `true` mounts a control
+     * that may do nothing, `false` hides one a child depends on. Both are wrong, which is the same reason `holdsAtOnce` is
+     * required. Whoever goes through `createGame` never writes it: the root reads the declaration. A FUNCTION, not a value
+     * (see `ActionableIcons.holdsKeys`): a cartridge wiring this itself passes `() => declaration.holdsKeys()`.
      */
-    seguraTeclas: () => boolean;
+    holdsKeys: () => boolean;
+    /** How many positions the current game declared — what «one button only» would scan (ADR-0218). Absent reads as none. */
+    declaredPositions?: () => number;
+    /** Does the current game's time run by itself? (ADR-0180: the hourglass.) Optional; absent, no hourglass. */
+    clock?: () => boolean;
+    /** Can this device play through the webcam? (ADR-0215: the 📷.) Optional; absent, no 📷. */
+    camera?: boolean;
+    /** Can this device hear the child — is there a microphone to ask for? (issue #184: the 👄.) Absent, no 👄. */
+    microphone?: boolean;
+    /** Opens the menus of seat `i`, as SELECT does (the ☰). Optional; absent, no ☰. */
+    openMenus?: (i: number) => void;
+    /** Does no voice speak the current language? (ADR-0185: the narration icon locks.) Optional; absent, a voice. */
+    noVoice?: () => boolean;
 }
 export interface PauseIconsApi {
     /** Builds one `.screen-pause` (hidden), wired for click + hover/focus caption. Caller appends it. */
     buildScreenPause: (i: number) => HTMLElement;
-    /** Monta a BARRA RÁPIDA (`.screen-a11y`) da tela `i`, já fiada. Chamada por ui/hud.ts, uma por tela. */
+    /** Builds screen `i`'s QUICK BAR (`.screen-a11y`), already wired. Called by ui/hud.ts, one per screen. */
     buildQuickBar: (i: number) => HTMLElement;
     /**
-     * OS ÍCONES QUE ESTA INSTÂNCIA MONTA — já filtrados pelo §5 do ADR-0106.
-     *
-     * ⚠️ Existe para que quem monta a barra do TÍTULO não repita o filtro. A barra do título não pode usar
-     * `buildQuickBar` (ele põe `tabIndex = -1`, e o próprio comentário lá diz porquê: no título não se está a
-     * jogar), então ela chama `iconsMarkup` directamente — e sem este acessor teria de recalcular quais ícones
-     * accionam, que é uma segunda cópia da mesma decisão.
+     * THE ICONS THIS INSTANCE MOUNTS — already filtered by ADR-0106 §5. It exists so the bar the root mounts in
+     * `#title-icons` (which cannot use `buildQuickBar`: that one sets `tabIndex = -1`, for a game in play) does not repeat
+     * the filter — a second copy of the same decision.
      */
-    iconesMontados: readonly PauseIcon[];
-    /** ENTRA no modo `accessibility` da tela `i` — é o que o item `acessibilidade` da pausa faz. */
-    entrarNaBarra: (i: number) => void;
-    /** SAI do modo e devolve o direcional ao personagem. */
-    sairDaBarra: (i: number) => void;
-    /** A tela `i` está com o direcional na BARRA em vez de no personagem? Perguntado a cada quadro. */
-    naBarraDe: (i: number) => boolean;
-    /** Um passo dentro do modo. `temStart` é a borda do botão de pausa — a segunda saída (ADR-0044, item 7). */
-    navBar: (i: number, k: NavKeys, temStart?: boolean) => void;
-    /** Runs the icon `k` for screen `i`. Does NOT reflect — callers reflect after, as game.js always did. */
+    mountedIcons: readonly PauseIcon[];
+    /** ENTERS screen `i`'s `accessibility` mode — the bar half of the quick pause (ADR-0155). Does not touch the phase. */
+    enterBar: (i: number) => void;
+    /** LEAVES the mode and gives the d-pad back to the character. `silent` = leaving for another screen, not for the game. */
+    leaveBar: (i: number, silent?: boolean) => void;
+    /** Is screen `i`'s d-pad on the BAR instead of on the character? Asked every frame. */
+    onBar: (i: number) => boolean;
+    /** One step inside the mode. `hasStart` is the pause button's edge — the second way out (ADR-0044 item 7). */
+    navBar: (i: number, k: NavKeys, hasStart?: boolean) => void;
+    /** Runs the icon `k` for screen `i`. Does NOT reflect — callers reflect after. */
     iconAct: (k: string, i: number) => void;
     /** The state-reflecting `aria-label` of icon `k` for screen `i`. */
     iconLabel: (k: string, i: number) => string;