@the-inclusionist/engine 7.0.1 → 8.0.0-rc.2

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

@@ -32,38 +32,61 @@
 //
 // ========================= DECLINAR NÃO É MENTIR =========================
 // O quiz recusou o sonar e o pad em vez de inventar tiles e uma caixa de colisão falsos, e essa distinção é o
-// que separa um achado de um verde falso. Aqui ela vira TIPO: um jogo sem menu de pausa declara
-// `semMenuDePausa: true` em vez de devolver `null` de um getter e torcer. O que se declina fica registrado no
-// objeto devolvido, e um consumidor pode ser auditado pelo que recusou.
+// que separa um achado de um verde falso. Aqui ela vira TIPO: um jogo que não tem uma peça declara-o num
+// campo em vez de devolver `null` de um getter e torcer. O que se declina fica registrado no objeto devolvido,
+// e um consumidor pode ser auditado pelo que recusou.
+// ⚠️ E ESTE PARÁGRAFO NÃO NOMEIA NENHUM DOS CAMPOS, o que parece esquisito e é medido: o
+// `tests/declinio-morto` conta MENÇÕES, incluindo as de comentário, e fá-lo de propósito — «falhar para o lado
+// de vivo é a direcção certa deste erro», porque uma acusação falsa desliga um gate. A consequência é que usar
+// um declínio como EXEMPLO em prosa o faz parecer lido, e um campo genuinamente morto deixa de ser acusado.
+// 📌 O primeiro rascunho desta nota fez exactamente isso, e o crivo apanhou-o no mesmo minuto.
 //
 // ========================= O QUE ISTO AINDA NÃO FAZ, DITO AQUI E NÃO ESCONDIDO =========================
 // Não liga render, física, tiles nem o sonar — nada disso é de todo jogo, e o achado 9 mostra que o sonar hoje
 // exige seis coisas de plataforma. Não substitui o boot do `main.js`, que tem catorze anos de ordem própria.
 // O que ele cobre é o que o quiz provou ser IDÊNTICO em qualquer jogo: idioma, leitor de tela, mixer, voz,
 // pilha de diálogos, filtros de daltonismo, teclado remapeável e navegação de menu.
-import { initI18n } from '../core/i18n.js';
+import { initI18n, idiomaPronto } from '../core/i18n.js';
+import { entradaDe } from '../input/state.js';
 import { criarAvisoDeQueda } from '../ui/loop-crash.js';
 import { initFocusTrap, focaveisNoDom } from '../ui/focus-trap.js';
 import { mostrarAvisoDeAlcance } from '../ui/reach-notice.js';
 import { alcance, transportesPadrao } from '../input/transports.js';
-import { presetActions } from '../core/actions.js';
+import { presetActions, ACTIONS } from '../core/actions.js';
 import { t } from '../core/i18n.js';
 import { srSay, srAlert } from '../core/a11y-sr.js';
+import { initPauseIcons, iconsMarkup } from '../ui/pause-icons.js';
+// O módulo INTEIRO: o on do barramento de eventos, para a barra montada continuar a dizer a verdade.
+import * as state from '../core/state.js';
+import { vlibrasOpen, toggleLibras } from '../ui/vlibras.js';
 import { conformanceProblems } from '../core/contract.js';
 import { criarPilha } from '../core/scenes.js';
 import { createTts } from '../platform/tts.js';
-import { ensureAC, catNode, audioOut, soundOn, volume, audioCat, initAudioMixer, tonePan, audioCtx } from '../platform/audio.js';
+import { ensureAC, catNode, audioOut, soundOn, volume, audioCat, initAudioMixer, tonePan, audioCtx, setCatGain } from '../platform/audio.js';
 import { createAudioSonar } from '../platform/audio-sonar.js';
-import { VIZ_BY_KEY } from '../render/viz-modes.js';
+// A raiz é a camada que PODE conhecer os dois eixos: `render/` está abaixo dela, e é dela a tarefa de
+// responder ao `platform/audio-sonar`, que não pode importar daqui sem inverter uma aresta (#104).
+import { ehCego, ehBaixaVisao, PADRAO } from '../render/viz-axes.js';
 import { OVERLAY_SCOPE_SELECTOR } from '../ui/settings-panel.js';
 import { LOGICAL_W } from '../core/constants.js';
 import { initSettingsPanel } from '../ui/settings-panel.js';
 import { initMenuNav } from '../ui/menu-nav.js';
 import { initKeyboardRuntime } from '../input/keyboard-runtime.js';
-import { kb, initKB } from '../input/keyboard.js';
+import { kb, initKB, registrarMapeamentoDoTeclado } from '../input/keyboard.js';
+import { registrarMapeamentoDoPad } from '../input/pad-defaults.js';
+import { baixarPesados } from '../platform/pesados.js';
 import { installCvdFilters } from '../render/cvd-matrices.js';
 /** Os ids que os painéis emprestados exigem do documento. Achado 6: sem eles o painel abre VAZIO, sem erro. */
 const MARCACAO_EXIGIDA = ['#game-region', '#sr-status', '#sr-alert'];
+/**
+ * Onde a engine procura a barra de acessibilidade quando o jogo não declara `host.a11yBarHost`.
+ *
+ * ⚠️ NÃO ENTROU NA `MARCACAO_EXIGIDA` de propósito, e a diferença é de mensagem e não de rigor. Aquela lista
+ * produz «marcação ausente: #x», que é o que se diz de um id que o jogo esqueceu. Aqui o que falta não é um
+ * id — é a barra inteira, e cinco jogos do catálogo não a têm porque ninguém lhes disse que a deviam ter. A
+ * frase própria pode explicar O QUE se perde, e é isso que a torna útil a quem a lê pela primeira vez.
+ */
+const SELETOR_BARRA_A11Y = '#title-icons';
 /**
  * Liga a engine para um jogo declarado.
  *
@@ -108,6 +131,11 @@ export function createGame(o) {
         getSoundOn: () => soundOn, getVolume: () => volume, getAudioCat: () => audioCat,
         carregarVozNeural: o.carregarVozNeural,
     });
+    if (!o.carregarVozNeural && !declines.semVozNeural) {
+        problems.push('sem voz neural: declare `carregarVozNeural` (uma linha — ver ADR-0094) ou `declines.semVozNeural`. '
+            + 'Sem ela a criança que não lê fica com a voz do sistema, que em Chromebook de escola pode não existir '
+            + 'em português');
+    }
     /**
      * O FILTRO DE VISÃO, aplicado ao MUNDO QUE O JOGO DECLAROU (ADR-0087).
      *
@@ -147,25 +175,236 @@ export function createGame(o) {
     const cvdFilters = installCvdFilters(o.host.cvdHost ?? null);
     if (!cvdFilters)
         problems.push('sem host de filtros (<svg>): a correção de daltonismo não foi montada');
+    // 4c. A BARRA DE ACESSIBILIDADE DA PRIMEIRA TELA. Ver a nota em `EngineHost.a11yBarHost`: cinco dos seis
+    //     jogos do catálogo não têm nenhuma, e nada o dizia. Isto não a monta — diz que ela falta, que é o
+    //     passo que tira o silêncio. A frase nomeia a saída, como as outras deste bloco fazem.
+    const a11yBar = o.host.a11yBarHost ?? $(SELETOR_BARRA_A11Y);
+    if (!a11yBar) {
+        problems.push(`sem barra de acessibilidade na primeira tela: declare \`host.a11yBarHost\` ou ponha um ${SELETOR_BARRA_A11Y} no documento. Sem ela a criança não alcança modo cego, TTS, alto contraste nem Libras antes de começar`);
+    }
+    /*
+     * ⚠️ E AGORA A ENGINE MONTA-A (ADR-0106 §4, etapa 2). Até 2026-09-08 esta raiz só REPORTAVA a ausência, e o
+     * registo dizia porquê: «reportar não é oferecer — cinco jogos continuam sem barra até alguém agir na
+     * linha». A etapa 1 tirou dos sete campos acidentais a obrigação de virem do jogo, e a 3 deu lista padrão
+     * ao menu; com isso o `PauseIconsCtx` deixou de exigir seja o que for que esta raiz não saiba responder.
+     *
+     * ⚠️ NÃO É `buildQuickBar`, e a diferença tem dono: aquele põe `tabIndex = -1` nos botões porque durante a
+     * partida dez paradas de tabulação separam a criança do jogo (ADR-0044 item 7). Na primeira tela não se
+     * está a jogar, e tirar os ícones da ordem de tabulação ali seria escondê-los de quem navega por teclado —
+     * exactamente a pessoa para quem eles existem.
+     */
+    /**
+     * O LEITOR DO MODO CEGO — e ele tem de ler ONDE O ESCRITOR PADRÃO ESCREVE.
+     *
+     * 🔴 ESTAS DUAS METADES GANHARAM PADRÃO EM DIAS DIFERENTES E NÃO SE FALAVAM, o que produziu um defeito que
+     * nenhum teste podia ver. O escritor recebeu o padrão da engine na etapa 1b do ADR-0106
+     * (`ui/pause-icons` → `ctx.setModoCego ?? setModoCegoValue`), que grava no `core/state`. O leitor ficou com
+     * o `() => false` que já cá estava — uma CONSTANTE. Num jogo que não injecta `isBlindMode`:
+     *
+     *   1. a criança carrega no ícone → `setModoCego(!false)` → o modo LIGA de verdade;
+     *   2. o reflexo lê `false` → o ícone diz «desligado» e o anúncio diz o mesmo;
+     *   3. ela carrega outra vez → `setModoCegoValue(!false)` = `true` OUTRA VEZ → a guarda de igualdade do
+     *      `core/state` devolve cedo → nada acontece.
+     *
+     * ⚠️ O modo cego ligava uma vez e NÃO HAVIA COMO DESLIGAR — um jogo que começa a descrever tudo em voz alta
+     * e não se cala, sem erro em lado nenhum. Para quem não depende dele, é o jogo a ficar inutilizável.
+     *
+     * 📌 UMA CONSTANTE E NÃO A EXPRESSÃO REPETIDA NOS DOIS SÍTIOS, porque a repetição É o defeito: duas
+     * respostas à mesma pergunta divergem, e foi assim que esta divergiu. `import * as state` dá ligação VIVA,
+     * então isto lê o valor de agora e não o do arranque.
+     */
+    const lerModoCego = o.isBlindMode ?? (() => state.modoCego);
+    const pauseIcons = initPauseIcons({
+        doc,
+        /*
+         * A RESPOSTA DO JOGO, lida da declaração (ADR-0115). Sem ela o ícone `altmove` não é montado.
+         *
+         * ⚠️ LIDA UMA VEZ, NO ARRANQUE, e a razão não é economia — é a criança. O campo é uma FUNÇÃO porque o
+         * ADR-0084 diz que um jogo muda de exigência entre fases, mas a COMPOSIÇÃO DA BARRA não pode mudar
+         * debaixo da mão de quem está a usá-la: um ícone que aparece e some entre fases é pior do que um que
+         * nunca esteve lá, e para quem navega por teclado desloca a ordem de tabulação a meio.
+         * 📌 Logo a leitura correcta do contrato é «este jogo segura teclas em ALGUMA fase» — um jogo que segura
+         * a pé e nada dentro de um veículo declara `true`, e o registo não disse isto porque a pergunta só
+         * aparece quando se monta a barra.
+         */
+        seguraTeclas: o.declaration.seguraTeclas(),
+        getPlayers: () => o.players ?? [],
+        getNumPlayers: () => (o.players ?? [null]).length,
+        srSay, srAlert,
+        // ⚠️ NÃO `instanceof HTMLElement`: esse é um GLOBAL DO NAVEGADOR, e lê-lo onde ele não existe LANÇA —
+        // não devolve falso. Escrito assim na etapa 2, fazia o `reflectPauseIcons` rebentar em qualquer ambiente
+        // sem DOM. É o mesmo erro de forma do ACHADO 15 no cabeçalho deste ficheiro: alcançar o global por baixo
+        // de quem injectou o documento. A pergunta certa é a mesma que o `barraUsavel` faz — sabe ser uma barra?
+        getA11yBars: () => (barraUsavel && a11yBar ? [a11yBar] : []),
+        getModoCego: lerModoCego,
+        getAudioCat: () => audioCat,
+        setCatGain,
+        /*
+         * ⚠️ QUEM RESPONDE PELO APARELHO EM USO É A RAIZ, e é aqui que o autómato do ADR-0109 ganha o primeiro
+         * leitor. `input/state.entradaDe(i)` devolve `PADRAO` para quem nunca produziu uma aresta, logo isto
+         * nunca é `undefined` e o ícone nunca escreve numa chave torta.
+         *
+         * 📌 E é a RAIZ que o passa, não o ícone que o importa: `ui/` a ler estado de módulo de `input/` seria
+         * uma aresta nova entre camadas para poupar um argumento. A composição é o trabalho deste ficheiro.
+         */
+        transporteEmUso: (i) => entradaDe(i).emUso,
+        reflectTtsPanel: () => { },
+        reflectTtsPanelEnabled: false,
+        isLibrasOn: vlibrasOpen,
+        toggleLibras,
+    });
+    /*
+     * ⚠️ O HOSPEDEIRO TEM DE SABER SER UMA BARRA, e perguntar isso não é zelo: `a11yBarHost` é `Element` no
+     * tipo, e um consumidor pode passar um duplo, um nó de outro documento, ou um elemento de um `<svg>`. Sem
+     * esta guarda, um objecto sem `addEventListener` derruba o BOOT INTEIRO — e derrubá-lo por causa da barra
+     * de acessibilidade seria tirar o jogo a toda a gente para não o dar a ninguém.
+     *
+     * Não sabendo, é `problems` como qualquer outra lacuna do hospedeiro: o consumidor lê e conserta.
+     */
+    const barraUsavel = !!a11yBar
+        && typeof a11yBar.addEventListener === 'function'
+        && 'innerHTML' in a11yBar;
+    if (a11yBar && !barraUsavel) {
+        problems.push('o elemento da barra de acessibilidade não aceita conteúdo nem clique: os ícones não foram montados');
+    }
+    if (a11yBar && barraUsavel) {
+        a11yBar.innerHTML = iconsMarkup(pauseIcons.iconesMontados);
+        a11yBar.addEventListener('click', (e) => {
+            const botao = e.target?.closest('.pi-btn');
+            if (!botao)
+                return;
+            pauseIcons.iconAct(botao.dataset.pi ?? '', 0);
+            pauseIcons.reflectIconsIn(a11yBar, 0);
+            // O anúncio lê o `aria-label` DEPOIS do reflexo, porque é ele que carrega o estado NOVO — anunciar
+            // antes diria o estado que a criança acabou de deixar.
+            srSay(botao.getAttribute('aria-label') ?? '');
+        });
+        pauseIcons.reflectIconsIn(a11yBar, 0);
+        /*
+         * ⚠️ E OUTRA VEZ QUANDO O IDIOMA DO ARRANQUE CHEGAR — sem isto a barra fica no idioma de RECUO.
+         *
+         * O `initI18n` aplica pt de forma síncrona (para a página nunca ficar em branco) e, se o idioma
+         * preferido for outro, PEDE a troca — que é assíncrona, porque en/es são chunks sob demanda. Esta
+         * marcação nasce nesse intervalo. 📏 Medido num navegador em 2026-09-08, com `lang="en"`: a barra
+         * servia cinco rótulos em inglês e três ainda em português, na mesma linha de ícones.
+         *
+         * 📌 O `idiomaPronto()` existe exactamente para isto, e o cabeçalho dele já descreve o defeito noutro
+         * lugar: «o `applyDom` conserta o markup ESTÁTICO, mas o que o JavaScript monta tinha capturado o
+         * texto de pt e ninguém reconstruía». A barra é a instância nova, criada quando a ENGINE passou a
+         * montá-la (ADR-0106 etapa 2).
+         *
+         * ⚠️ É O `idiomaPronto()` E NÃO O EVENTO `i18n:change`, de propósito: o evento é a troca de idioma EM
+         * EXECUÇÃO, e o próprio `core/i18n` declara essa pergunta como sendo do Dev («QUANDO a interface se
+         * reconstrói ao trocar de idioma em execução»). Isto responde só a pergunta do ARRANQUE, que aquele
+         * mesmo comentário diz não ter duas respostas.
+         */
+        void idiomaPronto().then(() => { pauseIcons.reflectIconsIn(a11yBar, 0); });
+        /*
+         * ⚠️ E ELA TEM DE CONTINUAR A DIZER A VERDADE quando o estado muda NOUTRO SÍTIO. O modo cego liga-se
+         * também pelo painel de áudio e pela simulação de empatia; sem esta assinatura, o ícone da barra ficaria
+         * a dizer «desligado» com `aria-pressed=false` depois de a criança o ter ligado — o controlo a mentir o
+         * estado, que é a família de defeito que o `reflectTTS` e o `#opt-modocego` já custaram a este projeto.
+         *
+         * 📌 SÓ O MODO CEGO, e a limitação é medida e não preguiça: dos ícones que esta raiz monta, ele é o ÚNICO
+         * cujo estado tem evento (`EventoDoJogo` tem `modoCego`; TTS, Libras, TEA e alternância não emitem nada).
+         * Os outros continuam a refletir-se ao clique, que é o caminho por onde hoje eles mudam.
+         */
+        state.on('modoCego', () => { pauseIcons.reflectIconsIn(a11yBar, 0); });
+    }
+    // 4d. QUEM ABRIU A PAUSA, quando há mais de um assento — o achado 3 da auditoria do `game-soccer`.
+    //
+    // ⚠️ O PAINEL DE CONTROLE É PARAMETRIZADO PELO ASSENTO: `render(selPlayer)` desenha as posições DAQUELE
+    // esquema, e não há selector de assento — o `#ctrl-players` é uma FRASE, não abas. Quem decide o assento é
+    // o consumidor, passando o ator da pausa: «edita o controle de quem abriu o menu».
+    //
+    // ⚠️ E É AQUI QUE ISTO FICA MUDO. O `setPauseActor` desta raiz é `() => {}` — literal, logo abaixo. Um jogo
+    // montado por `createGame` com dois assentos deixa a criança do SEGUNDO sem como remapear, e nada o diz.
+    // Não é a mesma coisa que declarar `semAtorDePausa`: essa é uma ausência declarada, e uma ausência
+    // declarada é uma escolha. Esta era uma ausência por omissão, que é a forma de defeito do ADR-0106 §2.
+    const assentos = (o.players ?? []).length;
+    if (assentos > 1 && !declines.semAtorDePausa) {
+        problems.push(`declarou ${assentos} jogadores e não registra o ator da pausa: o painel de controle edita sempre o `
+            + 'assento 0, então ninguém além do primeiro consegue remapear. Declare `declines.semAtorDePausa` se '
+            + 'for de propósito');
+    }
+    /*
+     * 4e. O CARTÃO DE PAUSA DA PRIMEIRA TELA — e isto fecha um LAÇO QUE ESTAVA ABERTO.
+     *
+     * 📏 MEDIDO EM 2026-09-08, nos seis jogos do catálogo local: `#vp-pause-0` é procurado por esta raiz (o
+     * `getPauseMenu` do `initMenuNav`, mais abaixo) e **NENHUM jogo o cria**. `git grep vp-pause` devolve zero
+     * em `game-platformer`, `game-soccer`, `pixi-15-puzzle`, `2048`, `whackwhack` e `game-chess`. Ou seja: a
+     * engine inventou uma convenção, procurou-a, não a achou, e concluiu em silêncio que nenhum jogo tem menu
+     * de pausa — que é a MESMA forma de defeito do ADR-0106 §2, desta vez cometida pela engine contra si mesma.
+     *
+     * Agora ela cria o que procura — e para TODO jogo, desde o ADR-0120 e outra vez desde o ADR-0122: o
+     * declínio saiu, porque a razão de ele existir foi construída fora por este mesmo ADR-0106, e porque a
+     * regra é do Dev — a pausa e os ícones de acessibilidade estão em todo jogo, logo são da engine.
+     */
+    const hospedeiroDaPausa = o.host.pauseHost ?? $('#game-region');
+    const pausaUsavel = !!hospedeiroDaPausa && typeof hospedeiroDaPausa.appendChild === 'function';
+    if (!pausaUsavel) {
+        problems.push('sem sítio para o menu de pausa: declare `host.pauseHost` ou tenha um #game-region que aceite filhos. '
+            + 'Sem ele a criança não alcança os ajustes durante a partida — e NÃO há como declinar: desde o '
+            + 'ADR-0122 a pausa é da engine em todo jogo, e o que este jogo declara é só ONDE ela cabe');
+    }
+    if (hospedeiroDaPausa && pausaUsavel) {
+        const cartao = pauseIcons.buildScreenPause(0);
+        // ⚠️ O ID É O QUE A PRÓPRIA ENGINE PROCURA, logo abaixo, no `getPauseMenu`. Montar sem o pôr deixaria o
+        // laço tão aberto como estava — o cartão existiria e a navegação de menu continuaria a não o achar.
+        cartao.id = 'vp-pause-0';
+        hospedeiroDaPausa.appendChild(cartao);
+    }
     // 4b. NAVEGAÇÃO SONORA. Só o contrato entra: nada de tile, caixa de colisão ou array de moedas.
     const sonar = createAudioSonar({
         topology: () => o.declaration.topology(),
         targetsOf: (i) => o.declaration.targetsOf(i),
         nameAt: (at) => o.declaration.nameAt(at),
+        // Campo 2 + o barramento do mixer: o que o GUIA CONTÍNUO precisa e o bipe não precisava (#84 item 2). O
+        // `roleAt` é o que deixa a rota contornar parede; o `catNode`/`audioOut`/`getVolume` são o que põem um
+        // grafo PERMANENTE no mesmo cursor de volume que todo o resto do áudio usa.
+        roleAt: (at) => o.declaration.roleAt(at),
         tonePan, srSay, narrate: (texto) => tts.narrate(texto),
-        VIZ_BY_KEY, getModoCego: o.isBlindMode ?? (() => false), LOGICAL_W,
+        catNode, audioOut, getVolume: () => volume,
+        // ⚠️ A RESPOSTA, E NÃO A TABELA (#104). O `platform/audio-sonar` recebia o `VIZ_BY_KEY` e atravessava-o
+        // com `pl.viz`; ele deixou de saber o que é um modo visual, e quem responde é aqui — a raiz é a única
+        // camada que conhece os dois eixos E pode importar de `render/`.
+        visaoComprometida: (pl) => {
+            const v = pl.visual;
+            return !!v && (ehCego(v) || ehBaixaVisao(v));
+        },
+        getModoCego: lerModoCego, LOGICAL_W,
         // O jogador DERIVADO do foco: campo 4 respondendo "onde a criança está". Um jogo que não fornece lista
         // ainda tem sonar, e é isso que faz a pilha de acessibilidade não ser acessório.
         getPlayers: o.sonarPlayers ?? (() => {
             const f = o.declaration.focusOf(0);
-            return f ? [{ i: 0, x: f.at.x, y: f.at.y, viz: 'normal' }] : [];
+            return f ? [{ i: 0, x: f.at.x, y: f.at.y, visual: PADRAO }] : [];
         }),
         getNumPlayers: () => (o.players ?? [null]).length,
         getAudioCtx: () => audioCtx, getSoundOn: () => soundOn, getAudioCat: () => audioCat,
     });
     // 5. Teclado remapeável — o melhor recorte da base (achado 11): esquema de teclas, sem mundo.
+    //
+    // ⚠️ O PADRÃO DO JOGO REGISTA-SE ANTES DO `initKB()`, e a ordem é a regra: quem lê o disco já tem de saber
+    // qual é a fábrica sobre a qual o dado da criança se sobrepõe (ADR-0115). Registar depois deixaria o
+    // primeiro arranque com a fábrica da ENGINE e o segundo com a do jogo — a pior espécie de defeito, porque
+    // desaparece quando alguém vai ver.
+    // 📌 E o registo aceita `null`, que é o que um jogo sem opinião produz: fica a fábrica da engine.
+    registrarMapeamentoDoTeclado(o.declaration.mapeamentoDoTeclado
+        ? (jogadores, assento) => o.declaration.mapeamentoDoTeclado(jogadores, assento)
+        : null);
+    // ⚠️ E O DO CONTROLE REGISTA-SE AQUI AINDA QUE ESTA RAIZ NÃO MONTE GAMEPAD NENHUM. Não é descuido: quem
+    // chama `initGamepad` é o cartucho, e é exactamente por isso que o registo não pode viver lá — seria mais
+    // um campo que um jogo pode esquecer, e esquecê-lo devolve o mapa da ENGINE a quem declarou outro, calado.
+    registrarMapeamentoDoPad(o.declaration.mapeamentoDoPad
+        ? (jogadores, assento) => o.declaration.mapeamentoDoPad(jogadores, assento)
+        : null);
     initKB();
-    const players = o.players ?? [{ ctrl: {} }];
+    // ⚠️ O ESQUEMA DE ARRANQUE ALCANÇA NADA, e diz isso com `null` em vez de com um objeto vazio (issue #118).
+    // Ele vive um instante — `assignControls()` logo abaixo substitui-o pelo esquema real —, mas enquanto vive
+    // é um `KeyScheme` como qualquer outro, e a única forma honesta de um esquema que não alcança nada é
+    // catorze ausências declaradas. Um `{}` fazia o tipo mentir sobre estar completo.
+    const semAlcance = Object.fromEntries(ACTIONS.map((a) => [a, null]));
+    const players = o.players ?? [{ ctrl: semAlcance }];
     const keyboard = initKeyboardRuntime({
         getKB: () => kb, getNumPlayers: () => players.length, getPlayers: () => players,
     });
@@ -174,7 +413,7 @@ export function createGame(o) {
     const nav = initMenuNav({
         $, getActiveElement: () => doc.activeElement,
         topVisibleOverlay: overlays.topVisibleOverlay, closeById: overlays.closeById,
-        getPauseMenu: declines.semMenuDePausa ? () => null : (i) => $(`#vp-pause-${i}`),
+        getPauseMenu: (i) => $(`#vp-pause-${i}`),
         setPhase: o.setPhase ?? (() => { }),
         setPauseActor: () => { },
         srSay,
@@ -182,10 +421,25 @@ export function createGame(o) {
         // que ele existe se vier desligado (a mesma razão de o modo cego nascer com TTS e sonar).
         comIndice: o.comIndice ?? (() => true),
         isNavigable: o.isNavigable ?? (() => true),
-        // Um hospedeiro que nao tenha barra de acessibilidade responde "nunca" e nunca chama nada — o modo e'
-        // opcional para o consumidor, obrigatorio para este jogo.
-        naBarraDe: o.naBarraDe ?? (() => false),
-        navBar: o.navBar ?? (() => { }),
+        /*
+         * ⚠️ ESTE PADRÃO ERA `() => false` / `() => {}`, E DESDE HOJE ISSO SERIA UM BURACO QUE EU ABRI. O
+         * comentário que estava aqui dizia «um hospedeiro que não tenha barra de acessibilidade responde nunca e
+         * nunca chama nada» — verdade até a etapa 2 do ADR-0106, quando esta raiz passou a MONTAR a barra.
+         *
+         * Com a barra montada e estes dois em no-op, ela existiria e **não se conseguiria navegar por teclado nem
+         * por controle**: alcançável só por ponteiro. Para uma criança cega, que navega por teclado, uma barra
+         * que ela não alcança é o mesmo que barra nenhuma — e é exactamente o «oferece o caminho e depois
+         * recusa-o» que o §5 do ADR-0106 proíbe.
+         *
+         * A engine responde com a SUA instância, que é a mesma que montou a barra. Quem injecta continua a mandar.
+         *
+         * ⚠️ E FICA UMA METADE POR LIGAR, dita aqui em vez de descoberta: o `navBar` do `ui/menu-nav` recebe
+         * `(i, k)` e não o terceiro argumento `temStart`, que é a borda do botão de pausa — a SEGUNDA saída do
+         * modo (ADR-0044 item 7). No cartucho ela chega por outra rota (o encaminhador do gamepad, `main.ts:1470`)
+         * que esta raiz ainda não monta. Logo: o direcional navega a barra; sair por START, por enquanto, não.
+         */
+        naBarraDe: o.naBarraDe ?? ((i) => pauseIcons.naBarraDe(i)),
+        navBar: o.navBar ?? ((i, k) => pauseIcons.navBar(i, k)),
         isCapturing: () => false,
         closePadWiz: () => { },
         whichPlayer: (code) => keyboard.whichPlayer(code),
@@ -243,9 +497,30 @@ export function createGame(o) {
         catch {
             return true;
         } },
+        /**
+         * O RATO (ADR-0112) — e a sonda é `any-pointer` de propósito, não `pointer`.
+         *
+         * ⚠️ `(pointer:fine)` descreve o ponteiro PRIMÁRIO, então um tablet com rato ligado responde «coarse» e
+         * o rato desaparecia — exactamente o aparelho que esta pergunta existe para achar. `any-pointer:fine` diz
+         * «ALGUM dos dispositivos apontadores é fino», que é a pergunta certa: para desenhar basta um.
+         *
+         * ⚠️ ELA ERRA, e a direcção do erro é a que se aceita: um stylus também responde `fine`, e é um ponteiro
+         * a sério — logo isso não é erro. O que pode faltar é um rato ligado depois do arranque, e por isso a
+         * sonda é uma FUNÇÃO, avaliada a cada pergunta, como as três acima.
+         */
+        rato: () => { try {
+            return win.matchMedia('(any-pointer:fine)').matches;
+        }
+        catch {
+            return false;
+        } },
     };
     const acoesDoJogo = o.preset ? presetActions(o.preset) : [];
-    const alcanceAqui = alcance(transportesPadrao(disponibilidade), acoesDoJogo);
+    // O segundo eixo entra aqui, e vem do jogo (ADR-0104 §A): quantas posições ele segura ao mesmo tempo.
+    // ⚠️ O TERCEIRO EIXO ENTRA AQUI (ADR-0112), e vem do jogo tal como os outros dois. `?? false` e não um
+    // padrão inventado: o campo é opcional de propósito — ver a nota nele —, e a ausência significa «este jogo
+    // não desenha», que é a resposta certa para a esmagadora maioria dos trezentos.
+    const alcanceAqui = alcance(transportesPadrao(disponibilidade), acoesDoJogo, o.declaration.holdsAtOnce(), o.declaration.needsPointer?.() ?? false);
     // ⚠️ SÓ APARECE QUANDO HÁ O QUE DIZER. Um aviso que aparece sempre deixa de ser lido, e um jogo cujas ações
     // cabem no toque não tem nada a avisar — que é o caso comum e tem de continuar silencioso.
     if (acoesDoJogo.length) {
@@ -264,5 +539,49 @@ export function createGame(o) {
         criar: (tag) => doc.createElement(tag),
         narrar: (texto) => tts.narrate(texto),
     });
-    return { declaration: o.declaration, tts, overlays, nav, keyboard, sonar, aplicarFiltroDeVisao, cenas: criarPilha(), cvdFilters, problems, declines, aoFalhar, alcance: alcanceAqui };
+    /*
+     * ⚠️ MOSTRAR REFAZ OS ITENS ANTES DE REVELAR, e a ordem é a regra: o §5 do ADR-0106 diz que a criança nunca
+     * vê um item que não acciona, e a tabela de acções deste jogo pode ter mudado desde a montagem. Revelar
+     * primeiro e refazer depois deixaria um piscar em que ela vê o que não pode usar.
+     */
+    const pausa = {
+        mostrar: (i) => {
+            pauseIcons.reflectPauseIcons();
+            const cartao = $(`#vp-pause-${i}`);
+            if (cartao)
+                cartao.hidden = false;
+        },
+        esconder: (i) => {
+            const cartao = $(`#vp-pause-${i}`);
+            if (cartao)
+                cartao.hidden = true;
+        },
+    };
+    /*
+     * AS COISAS PESADAS COMEÇAM A DESCER AQUI, e a linha é deliberadamente a ÚLTIMA coisa do arranque.
+     *
+     * ⚠️ SEM `await`. O arranque não espera por 241 MB — se esperasse, a primeira tela de uma escola com 3G
+     * ficaria em branco durante minutos e a criança concluiria que o jogo não abre. O `catch` vazio é a mesma
+     * regra escrita duas vezes: uma falha de rede aqui não pode derrubar um jogo que hoje nem usa a voz.
+     *
+     * 🔴 E O RELATÓRIO NÃO VAI PARA `problems`, embora a primeira versão o fizesse. Duas razões medidas, e a
+     * primeira é a que importa:
+     *
+     *  1. **CHEGA DEPOIS DE O LEITOR SE IR EMBORA.** `problems` é devolvido na linha abaixo, sincronamente; a
+     *     descarga é de fundo, logo TODA linha dela entraria num vector que o consumidor já leu. Quem faz
+     *     `if (motor.problems.length) …` não veria nada, e quem o lesse mais tarde veria uma lista que cresceu
+     *     depois do arranque. Um relatório que chega depois do leitor não é um relatório — é a forma exacta do
+     *     `srSay` a escrever onde não havia `#sr-status`.
+     *  2. **AFOGAVA O QUE SE PODE RESOLVER.** Sem rede — uma escola sem rede, que é o alvo e não a excepção —
+     *     são OITO falhas a empurrar para uma lista que o ADR-0106 §2 construiu para dizer o que FALTA NO
+     *     HOSPEDEIRO. A criança perde a barra de acessibilidade e a linha que o diz fica em nono lugar.
+     *
+     * 📌 O canal certo é o que a própria função já tem: `aoProgredir`, entregue a quem chama. Um consumidor que
+     * queira mostrar «faltam 241 MB» ou «a voz não desceu» tem por onde; a engine não inventa uma superfície.
+     */
+    if (o.baixarPesados !== false) {
+        void baixarPesados({ aoProgredir: o.aoProgredirPesados })
+            .catch(() => { });
+    }
+    return { declaration: o.declaration, pausa, tts, overlays, nav, keyboard, sonar, aplicarFiltroDeVisao, cenas: criarPilha(), cvdFilters, problems, declines, aoFalhar, alcance: alcanceAqui };
 }

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

@@ -1,23 +1,5 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 export declare const LOGICAL_W = 320, LOGICAL_H = 180, TILE = 16;
-export declare const COIN_TARGET = 10;
-export declare const TUNE: {
-    jumpVel: number;
-    waterJump: number;
-    waterJumpRun: number;
-    waterStrokeFrames: number;
-    trampBase: number;
-    trampMax: number;
-    gravity: number;
-    hWalk: number;
-    hRun: number;
-    climbSpeed: number;
-    maxFall: number;
-    waterMaxFall: number;
-    hTurbo: number;
-    ultraJumpVel: number;
-};
-export declare const JUMP_BASE: number;
 export declare const ANIM: {
     walkHold: number;
     runHold: number;
@@ -53,18 +35,8 @@ export type TileType = {
 export declare const TILE_TYPES: Record<number, TileType>;
 /** Machuca ao encostar (lava). */
 export declare const ehPerigo: (t: number) => boolean;
-/** Água: nada-se dentro, e o pulo funciona lá. */
-export declare const ehAgua: (t: number) => boolean;
-/** Escada: sobe e desce. */
-export declare const ehEscada: (t: number) => boolean;
 /** Trampolim: arremessa para cima. */
 export declare const ehTrampolim: (t: number) => boolean;
-/** Portão: barra até a chave abrir. */
-export declare const ehPortao: (t: number) => boolean;
-/** A chave que abre o portão. */
-export declare const ehChave: (t: number) => boolean;
-/** Ar de região secreta: o que a escuridão cobre até alguém entrar. */
-export declare const ehSecreto: (t: number) => boolean;
 export declare const TILE_COLOR: {
     0: string;
     1: string;

package/dist-pkg/core/constants.js

@@ -3,13 +3,22 @@
 // TUNE é objeto mutável (o painel de debug ajusta propriedades), mas NUNCA reatribuído → o import const
 // funciona (mutar propriedade é ok; reatribuir é que quebraria). Ver docs/plano-modularizacao.md.
 export const LOGICAL_W = 320, LOGICAL_H = 180, TILE = 16;
-export const COIN_TARGET = 10;
-export const TUNE = {
-    jumpVel: 3.5, waterJump: 3.5, waterJumpRun: 4, waterStrokeFrames: 30,
-    trampBase: 5, trampMax: 8, gravity: 0.15, hWalk: 2, hRun: 3, climbSpeed: 1.5,
-    maxFall: 7, waterMaxFall: 3, hTurbo: 4.5, ultraJumpVel: 10, // E12: power-ups (valores do José)
-};
-export const JUMP_BASE = TUNE.jumpVel * Math.sqrt(8 / 5); // ~4.43 (altura confortável)
+// ⚠️ `COIN_TARGET` e `TUNE` MUDARAM DE CASA EM 2026-09-07 — foram para `game/tuning.ts` do `game-platformer`
+// (issue #63, etapa B, decisão do Dev). Tinham ZERO importadores dentro desta árvore e TODOS do outro lado
+// da fronteira do pacote: não eram código morto, eram a superfície pública que o cartucho consumia.
+//
+// Uma engine que exporta a GRAVIDADE e a META DE MOEDAS está a decidir que todo jogo é uma plataforma de
+// coletar coisas. `TUNE` é gravidade, velocidade de nado e curso do trampolim — a física DAQUELE jogo; um
+// quiz não tem gravidade. `COIN_TARGET` é o objetivo, que é conteúdo.
+//
+// A etapa C (o segundo consumidor) é o que autorizou o corte: catorze achados, e nenhum reclama estes dois
+// para a engine. O `ui/debug-panel` continua a afinar o `TUNE` ao vivo — ele sempre o recebeu por INJEÇÃO
+// (`TUNE: Tune` no ctx), nunca por importação, e é por isso que a mudança não lhe custou nada.
+// ⚠️ `JUMP_BASE` SAIU EM 2026-09-07 (issue #63, etapa B, decisão do Dev). Não tinha um único consumidor:
+// nem na engine, nem no `game-platformer`, nem nos testes — fora UM, que verificava que
+// `JUMP_BASE === jumpVel * sqrt(8/5)`, ou seja **reafirmava a própria definição**. Um teste que não pode
+// falhar por motivo que importe, a manter viva uma constante que ninguém usa. A própria issue #63 já o
+// nomeava no seu «achado solto».
 // E15: cadência de animação (ticks por quadro) — regulável ao vivo no painel ?debug=true. Como TUNE, é objeto
 // mutável (o debug ajusta propriedades) mas NUNCA reatribuído → import const funciona. andar 6; correr 8 (~8fps,
 // pedido do José); idle 20; swim 24; cling 10; escada 8; flavor ~6s.
@@ -46,18 +55,26 @@ export const TILE_TYPES = {
 const prop = (t, k) => !!TILE_TYPES[t]?.[k];
 /** Machuca ao encostar (lava). */
 export const ehPerigo = (t) => prop(t, 'hazard');
-/** Água: nada-se dentro, e o pulo funciona lá. */
-export const ehAgua = (t) => prop(t, 'water');
-/** Escada: sobe e desce. */
-export const ehEscada = (t) => prop(t, 'ladder');
 /** Trampolim: arremessa para cima. */
 export const ehTrampolim = (t) => prop(t, 'tramp');
-/** Portão: barra até a chave abrir. */
-export const ehPortao = (t) => prop(t, 'gate');
-/** A chave que abre o portão. */
-export const ehChave = (t) => prop(t, 'key');
-/** Ar de região secreta: o que a escuridão cobre até alguém entrar. */
-export const ehSecreto = (t) => prop(t, 'secreto');
+// ⚠️ `ehAgua`, `ehEscada`, `ehPortao` e `ehSecreto` MUDARAM DE CASA EM 2026-09-07 — foram para
+// `game/tile-flags.ts` do `game-platformer` (issue #63, etapa B). Tinham zero importadores aqui dentro.
+//
+// E as duas que ficaram — `ehPerigo` e `ehTrampolim` — ficaram por um motivo MEDIDO, não por simetria: a
+// engine lê-as, e não por geometria. O `isSolidType` de `core/collision` torna perigo e trampolim SÓLIDOS
+// no modo cadeira de rodas, e perigo sólido no modo cego. É uma regra de ACESSIBILIDADE — a criança em
+// cadeira de rodas não cai no fosso — e essa é da engine.
+//
+//     A engine precisa de saber que um tile é PERIGO; não precisa de saber que ele é ESCADA.
+//
+// ⚠️ O QUE FICA POR DECIDIR, e está registado na #63: a `TILE_TYPES` acima continua a carregar as bandeiras
+// `water`, `ladder`, `gate`, `key` e `secreto`, que **nenhum módulo desta árvore lê**. Enquanto elas aqui
+// estiverem, o jogo faz perguntas sobre uma tabela que a engine publica. O fim honesto é a tabela mudar de
+// casa e o jogo declarar os papéis pelo `core/contract` (`roleOf`) — que é o mecanismo que já existe para
+// isso. Não é execução: é a fronteira seguinte, e ela é decisão do Dev.
+// ⚠️ `ehChave` SAIU EM 2026-09-07, pelo mesmo motivo e no mesmo passo que a `JUMP_BASE`: zero consumidores
+// em lado nenhum — engine, testes e cartucho. Os outros predicados de tile ficam por enquanto porque o
+// `game-platformer` os importa; estes dois não eram fronteira mal cortada, eram peso morto.
 export const TILE_COLOR = {
     0: '#0a0a14', 1: '#241f38', 2: '#6b6480', 3: '#2f6fae', 4: '#8a5a2b', 5: '#34e29b', 6: '#3a3a46',
     7: '#7fdcff', 8: '#ffd23f', 9: '#ff5b3a', 10: '#9a8a6f', 11: '#ffe06a', 12: '#3a86ff', 13: '#8a5cff', 14: '#ff6fae',