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

package/app/public/vendor/fonts.css

@@ -127,3 +127,24 @@
 @font-face{font-family:'Fondamento';font-style:normal;font-weight:400;font-display:swap;
   src:url('fonts/fondamento-400-ext.woff2') format('woff2');
   unicode-range:U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF;}
+
+/* ===== Playwrite — as OITO das Américas (ADR-0108 §2, issue #87 item 3) =====
+ * A mão que cada país ensina a escrever. Os EUA entram com AS DUAS que ensinam — escolher uma seria
+ * escolher pela criança. São variáveis no peso (100–400) e cada família é UM ficheiro: a Google não as
+ * corta por unicode-range, então não há metade `-ext` para carregar depois. SIL OFL 1.1, como as outras. */
+@font-face{font-family:'Playwrite BR';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-br.woff2') format('woff2');}
+@font-face{font-family:'Playwrite US Trad';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-us-trad.woff2') format('woff2');}
+@font-face{font-family:'Playwrite US Modern';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-us-modern.woff2') format('woff2');}
+@font-face{font-family:'Playwrite CA';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-ca.woff2') format('woff2');}
+@font-face{font-family:'Playwrite MX';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-mx.woff2') format('woff2');}
+@font-face{font-family:'Playwrite AR';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-ar.woff2') format('woff2');}
+@font-face{font-family:'Playwrite CL';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-cl.woff2') format('woff2');}
+@font-face{font-family:'Playwrite CO';font-style:normal;font-weight:100 400;font-display:swap;
+  src:url('fonts/playwrite-co.woff2') format('woff2');}

package/dist-pkg/boot/create-game.d.ts

@@ -11,6 +11,7 @@ import { type SettingsPanelApi } from '../ui/settings-panel.js';
 import { type MenuNavApi } from '../ui/menu-nav.js';
 import type { NavKeys } from '../input/edges.js';
 import { type KeyboardRuntime } from '../input/keyboard-runtime.js';
+import { type RelatorioPesado } from '../platform/pesados.js';
 /** O que o jogo empresta do documento. Tudo opcional menos `doc`/`win`: o que faltar vira `problems`. */
 export interface EngineHost {
     readonly doc: Document;
@@ -48,8 +49,9 @@ export interface EngineHost {
      * ONDE O CARTÃO DE PAUSA da primeira tela é pendurado. Ausente, a engine usa `#game-region`.
      *
      * ⚠️ Existe pela mesma razão do `a11yBarHost`: a engine pode OFERECER a pausa, mas não sabe onde ela cabe
-     * no desenho de um jogo alheio. Um jogo que não tem pausa nenhuma declara `declines.semMenuDePausa` —
-     * declinar é escolha registada, não ter é omissão, e o ADR-0106 §2 é inteiro sobre a diferença.
+     * no desenho de um jogo alheio. 📌 E desde o ADR-0120 ONDE já não é SE: a pausa deixou de ser declinável, e
+     * o que sobra deste campo é o lugar. Um hospedeiro que não aceite filhos vira linha de `problems`, que é a
+     * diferença entre a engine não saber e a engine calar-se.
      */
     readonly pauseHost?: Element | null;
 }
@@ -60,8 +62,6 @@ export interface EngineHost {
  * "pausado" para navegar os próprios menus, porque a engine não tinha por onde ouvir "eu não tenho fases".
  */
 export interface Declinios {
-    /** Sem menu de pausa por tela (um quiz não tem). */
-    readonly semMenuDePausa?: boolean;
     /** Sem assistente de mapeamento de controle. */
     readonly semAssistenteDePad?: boolean;
     /** Sem "ator da pausa" — quem apertou o botão que abriu o menu. */
@@ -144,6 +144,35 @@ export interface CreateGameOptions {
      * painel de áudio deixa de OFERECER o motor neural, em vez de o oferecer e nunca o carregar.
      */
     readonly carregarVozNeural?: CarregarVozNeural;
+    /**
+     * BAIXAR AS COISAS PESADAS NO PRIMEIRO CARREGAMENTO? Padrão **sim** (ADR-0110 (b), ADR-0116, ADR-0119).
+     *
+     * As quatro vozes neurais são ~241 MB e descem em SEGUNDO PLANO, uma de cada vez, sem bloquear o jogo: a
+     * criança joga enquanto elas chegam, e o que não pode acontecer é ela voltar no segundo dia, sem rede, e
+     * descobrir que a voz nunca foi buscada. O pilar 8 é «primeiro dia ONLINE, depois offline-first», e o
+     * ADR-0116 tirou a contradição que travava isto — instalar já é um acto de rede.
+     *
+     * ⚠️ PÔR `false` É PARA QUEM TEM RAZÃO PARA O FAZER, e a razão que já existe é um TESTE: um caso que monte
+     * o arranque num navegador de verdade não pode disparar 241 MB contra o Hugging Face. Um jogo em produção
+     * que o desligue está a decidir que a criança dele fica sem voz neural offline.
+     *
+     * 📌 E o ADR-0117 diz que quem devia pagar isto uma vez é a PLATAFORMA, não cada cartucho — a Cache Storage
+     * é particionada por origem, e num site só os 241 MB descem uma vez para todos os jogos. Enquanto a
+     * plataforma não os pede, é o jogo que os pede: melhor descer duas vezes do que nunca.
+     */
+    readonly baixarPesados?: boolean;
+    /**
+     * O QUE ACONTECEU COM CADA COISA PESADA, à medida que acontece. Ausente = ninguém está a ver.
+     *
+     * ⚠️ É AQUI E NÃO EM `problems` porque a descarga é de FUNDO: `problems` é devolvido sincronamente pelo
+     * `createGame`, e uma linha que chegue depois disso entra num vector que o leitor já leu. O ADR-0110 pede
+     * que uma busca falhada seja REPORTADA — reportar é ter um canal que existe quando a notícia chega, e não
+     * empurrar para uma lista que já foi entregue.
+     *
+     * 📌 A engine não inventa superfície nenhuma com isto: quem sabe onde cabe «faltam 241 MB» na tela de um
+     * jogo é o jogo. `pesoPorBaixar(relatorio)` dá o número para a frase.
+     */
+    readonly aoProgredirPesados?: (r: RelatorioPesado) => void;
     /**
      * Como se descobre que cada transporte está aqui. Ausente = a engine pergunta ao aparelho.
      *

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

@@ -32,9 +32,14 @@
 //
 // ========================= 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
@@ -67,7 +72,9 @@ 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'];
@@ -209,6 +216,18 @@ export function createGame(o) {
     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,
@@ -317,15 +336,16 @@ export function createGame(o) {
      * 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. Quem declina (`semMenuDePausa`) continua sem nada e sem acusação — declinar
-     * é escolha; não ter é omissão.
+     * 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 = declines.semMenuDePausa ? null : (o.host.pauseHost ?? $('#game-region'));
+    const hospedeiroDaPausa = o.host.pauseHost ?? $('#game-region');
     const pausaUsavel = !!hospedeiroDaPausa && typeof hospedeiroDaPausa.appendChild === 'function';
-    if (!declines.semMenuDePausa && !pausaUsavel) {
+    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 `declines.semMenuDePausa` é como se diz '
-            + 'que isso é de propósito');
+            + '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);
@@ -363,6 +383,21 @@ export function createGame(o) {
         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();
     // ⚠️ 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
@@ -378,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,
@@ -522,5 +557,31 @@ export function createGame(o) {
                 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/contract.d.ts

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
+import type { Action } from './actions.js';
 /** Gênero gramatical do nome. `n` = neutro/indefinido (o pt-BR usa o masculino como default nesse caso). */
 export type Gender = 'm' | 'f' | 'n';
 /** Um nome que pode ser FALADO (leitor de tela) e SINALIZADO (Libras, que traduz o mesmo texto). */
@@ -194,6 +195,28 @@ export interface GameDeclaration {
      * em silêncio, que é o defeito que o ADR-0084 nomeou.
      */
     holdsAtOnce(): number;
+    /**
+     * ESTE JOGO SEGURA ALGUMA TECLA? — e a resposta não é derivável de mais nada. (ADR-0115.)
+     *
+     * 🔴 A ALTERNÂNCIA EXISTE PARA UMA CRIANÇA CONCRETA: quem não consegue MANTER uma tecla premida carrega uma
+     * vez para andar e outra para parar. Num jogo onde nada se segura — um quiz, um tabuleiro, um puzzle de
+     * peças — não há nada a travar, e o controle passa a ser uma opção que **não faz nada**. A criança abre o
+     * menu de acessibilidade, liga o ajuste de que depende, e não acontece nada: ela aprende que o ajuste está
+     * partido. É o botão morto que o ADR-0106 §5 proíbe.
+     *
+     * ⚠️ E O `holdsAtOnce` ACIMA NÃO RESPONDE ISTO, o que foi o achado que obrigou a este campo: ele conta
+     * POSIÇÕES SIMULTÂNEAS e recusa zero, porque zero faria a aritmética do alcance passar por vacuidade. O
+     * `consumer-quiz` declara **1 sem segurar coisa nenhuma**. «Um de cada vez» e «um SEGURADO» são o mesmo
+     * número, e toda decisão a jusante vinha a ler um número que responde a outra pergunta.
+     *
+     * ⚠️ OBRIGATÓRIO, e a obrigatoriedade É a decisão — a mesma do `holdsAtOnce`, pela mesma frase do Dev:
+     * «não declarar é ter a acessibilidade programada no controle pro sorte». Um campo opcional faria um jogo
+     * que ESQUECE a linha perder a alternância em silêncio, e quem paga é a criança com dificuldade motora.
+     *
+     * 📌 FUNÇÃO e não valor, pelo ADR-0084: um jogo muda de exigência entre fases. A pé segura-se uma direcção;
+     * o mesmo jogo dentro de um veículo pode não segurar nada.
+     */
+    seguraTeclas(): boolean;
     /**
      * ESTE JOGO PRECISA DE UM PONTEIRO — posição contínua? (ADR-0112.)
      *
@@ -213,6 +236,43 @@ export interface GameDeclaration {
      * FUNÇÃO e não valor, pela mesma razão das outras: uma actividade pode desenhar numa fase e não noutra.
      */
     needsPointer?(): boolean;
+    /**
+     * O MAPEAMENTO DE TECLADO QUE ESTE JOGO QUER — por número de jogadores e por assento (ADR-0115).
+     *
+     * A precedência é a que o registo pede, e ela cabe entre duas linhas que já existiam no `input/keyboard`:
+     * **fábrica da engine → padrão do JOGO → remapeamento da CRIANÇA.** Devolver `null` (ou não declarar) deixa
+     * a fábrica da engine intacta, que é o comportamento de sempre.
+     *
+     * PARCIAL de propósito: um jogo que só queira trocar o `action1` troca o `action1`. A fusão já existe — é o
+     * `Object.assign` que sobrepõe o dado guardado —, então esta é mais uma camada no mesmo sítio e não uma
+     * segunda forma de fundir.
+     *
+     * ⚠️ OPCIONAL, e aqui, ao contrário do `seguraTeclas`, o silêncio tem um lado seguro: sem declaração o jogo
+     * fica com a fábrica da engine, que é jogável e é o que ele já tem hoje. Não há lado errado na ausência.
+     *
+     * ⚠️ E LEVA O ASSENTO porque o teclado de dois jogadores não é o de um: as setas mudam de dono, e um padrão
+     * que não soubesse o assento daria as mesmas teclas a duas crianças. `jogadores` é 1, 2, 3 ou 4; `assento` é
+     * o índice dentro desse arranjo.
+     *
+     * 📌 O irmão do CONTROLE é o campo logo abaixo, e chegou um commit depois: o obstáculo era que o assento
+     * ainda não se conhecia no ponto em que a tabela de botões é lida, e a saída foi subi-lo no laço.
+     */
+    mapeamentoDoTeclado?(jogadores: number, assento: number): Partial<Record<Action, readonly string[] | null>> | null;
+    /**
+     * O MAPEAMENTO DE BOTÕES QUE ESTE JOGO QUER NO CONTROLE — mesma pergunta, outro aparelho (ADR-0115).
+     *
+     * Índices de botão da Gamepad API «standard», parciais: `{ action1: 3 }` troca só essa. `null` num botão diz
+     * «esta posição não existe neste jogo», que é diferente de a deixar na fábrica.
+     *
+     * ⚠️ A PRECEDÊNCIA TEM UMA DIFERENÇA DE SÍTIO QUE VALE SABER: no teclado, o que a criança remapeou é uma
+     * camada POR CIMA desta; no controle, o mapa que ela gravou no assistente é um RAMO inteiro — se ele existe,
+     * este padrão não é consultado. Nos dois casos ela ganha, que é o que importa.
+     *
+     * 📌 E leva o assento pela mesma razão do teclado, ainda que por um caminho diferente: dois controles são
+     * dois aparelhos, mas o JOGO pode querer arranjos distintos por assento (o guarda-redes e o atacante não
+     * fazem o mesmo).
+     */
+    mapeamentoDoPad?(jogadores: number, assento: number): Partial<Record<Action, number | null>> | null;
     readonly tick: TickOwner;
     /** O papel do que está em `at`. É o campo 2, e é o que substitui `roleOf`. */
     roleAt(at: Spot): Role;

package/dist-pkg/core/contract.js

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 // core/contract — OS SETE CAMPOS. A interface que o ADR-0030 escolheu como o eixo da engine.
 //
+// ⚠️ ESTE FICHEIRO NÃO TINHA IMPORT NENHUM, e o único que ganhou é `import type` — apagado na compilação, logo
+// o módulo publicado continua sem dependência de execução. O que entra é o VOCABULÁRIO das catorze posições
+// (ADR-0074), e ele tinha de entrar: um campo que fala de mapeamento e escrevesse as suas próprias chaves
+// seria a segunda cópia da união que o `core/actions` existe para ser a primeira.
+//
 // ========================= O QUE ISTO É, E O QUE NÃO É =========================
 // Não é um framework nem uma classe-base. É a ÚNICA coisa que a pilha de acessibilidade sabe sobre um jogo.
 // O ADR-0027 mediu que as três funções que MAIS pareciam genéricas eram as três mais amarradas à plataforma —
@@ -126,6 +131,17 @@ export function conformanceProblems(d) {
             p.push('holdsAtOnce: must be an integer >= 1 - a game that holds nothing cannot be played');
         }
     }
+    // ⚠️ E ESTA É A OUTRA PERGUNTA, que o número acima parecia responder e não responde (ADR-0115). A mensagem
+    // diz o que a ausência CUSTA, e não só o que falta: sem ela, um jogo que nada segura oferece um controle de
+    // acessibilidade que não faz nada, e um que segura tudo pode não o oferecer a quem depende dele.
+    if (typeof d.seguraTeclas !== 'function') {
+        p.push('seguraTeclas: missing - declare whether any key is HELD in this game (latching is offered only where something can be held, and a game that holds nothing must not show a control that does nothing)');
+    }
+    else if (typeof d.seguraTeclas() !== 'boolean') {
+        // Um valor não-booleano seria truthy e ofereceria a alternância a toda a gente — o mesmo defeito
+        // silencioso que o `needsPointer` recusa logo abaixo, e pela mesma razão.
+        p.push('seguraTeclas: must return a boolean - a non-boolean is truthy and would offer latching in a game where nothing is held');
+    }
     // ⚠️ OPCIONAL, MAS NÃO IMPUNE. Ausente é a resposta `false` e não é problema — ver a nota no campo. O que
     // se recusa é declará-lo MAL: um `needsPointer: true` (valor em vez de função) seria sempre verdadeiro por
     // ser um objecto, e um que devolvesse `'sim'` também. Nos dois casos o jogo julgaria ter declarado, o
@@ -144,6 +160,32 @@ export function conformanceProblems(d) {
             p.push('needsPointer: must return a boolean - a non-boolean would be truthy and refuse devices this game can actually use');
         }
     }
+    // ⚠️ E O MESMO PARA O MAPEAMENTO, com uma razão própria: aqui um valor em vez de uma função não seria um
+    // erro barulhento, seria um mapeamento SILENCIOSAMENTE ignorado — a fábrica da engine ficava, e a criança
+    // jogava com um teclado que o autor do jogo julga ter mudado. E devolver algo que não é objecto nem `null`
+    // atravessaria o `Object.assign` sem escrever nada, que é a mesma ausência com outra roupa.
+    if (d.mapeamentoDoTeclado !== undefined) {
+        if (typeof d.mapeamentoDoTeclado !== 'function') {
+            p.push('mapeamentoDoTeclado: must be a function - write `mapeamentoDoTeclado: (jogadores, assento) => ({ action1: ["KeyQ"] })`, because the keyboard of two players is not the keyboard of one');
+        }
+        else {
+            const m = d.mapeamentoDoTeclado(1, 0);
+            if (m !== null && (typeof m !== 'object' || Array.isArray(m))) {
+                p.push('mapeamentoDoTeclado: must return an object or null - anything else is merged into nothing, and this game keeps the engine factory while its author believes otherwise');
+            }
+        }
+    }
+    if (d.mapeamentoDoPad !== undefined) {
+        if (typeof d.mapeamentoDoPad !== 'function') {
+            p.push('mapeamentoDoPad: must be a function - write `mapeamentoDoPad: (jogadores, assento) => ({ action1: 3 })`, because two seats may want different arrangements');
+        }
+        else {
+            const m = d.mapeamentoDoPad(1, 0);
+            if (m !== null && (typeof m !== 'object' || Array.isArray(m))) {
+                p.push('mapeamentoDoPad: must return an object or null - anything else is merged into nothing, and this game keeps the engine factory while its author believes otherwise');
+            }
+        }
+    }
     if (d.tick !== 'player' && d.tick !== 'clock')
         p.push('tick: must be "player" or "clock"');
     for (const f of ['roleAt', 'nameAt', 'focusOf', 'objectiveOf', 'targetsOf']) {

package/dist-pkg/i18n/en.js

@@ -580,6 +580,17 @@ const en = {
     'font.desc.andika': 'based on Sassoon; the fruit of research into how children read and write',
     'font.desc.opendyslexic': 'Letters weighted at the bottom, so they do not flip upside down as you read.',
     'font.desc.fondamento': 'Pen calligraphy, for the handwriting activities.',
+    'font.desc.pw.br': 'School cursive taught in Brazil.',
+    'font.desc.pw.ustrad': 'School cursive taught in the USA — traditional.',
+    'font.desc.pw.usmod': 'School cursive taught in the USA — modern.',
+    'font.desc.pw.ca': 'School cursive taught in Canada.',
+    'font.desc.pw.mx': 'School cursive taught in Mexico.',
+    'font.desc.pw.ar': 'School cursive taught in Argentina.',
+    'font.desc.pw.cl': 'School cursive taught in Chile.',
+    'font.desc.pw.co': 'School cursive taught in Colombia.',
+    'font.desc.ronde': 'French ronde, the joined handwriting taught at school.',
+    'font.off.ronde': 'Install one of these three on the device: Ronde Script, OPTIFrench-Script or Merveille. '
+        + 'They are free for personal use, which is why they cannot ship inside the game.',
     'font.desc.greatvibes': 'English calligraphy',
     'font.desc.pinyon': 'English calligraphy',
     'font.desc.ufcook': 'German blackletter',

package/dist-pkg/i18n/es.js

@@ -578,6 +578,17 @@ const es = {
     'font.desc.andika': 'basada en la Sassoon; fruto de la investigación sobre cómo leen y escriben los niños',
     'font.desc.opendyslexic': 'Letras con la base más pesada, para que no se den vuelta al leer.',
     'font.desc.fondamento': 'Caligráfica de pluma, para las actividades de escritura a mano.',
+    'font.desc.pw.br': 'Cursiva escolar de Brasil.',
+    'font.desc.pw.ustrad': 'Cursiva escolar de EE. UU. — tradicional.',
+    'font.desc.pw.usmod': 'Cursiva escolar de EE. UU. — moderna.',
+    'font.desc.pw.ca': 'Cursiva escolar de Canadá.',
+    'font.desc.pw.mx': 'Cursiva escolar de México.',
+    'font.desc.pw.ar': 'Cursiva escolar de Argentina.',
+    'font.desc.pw.cl': 'Cursiva escolar de Chile.',
+    'font.desc.pw.co': 'Cursiva escolar de Colombia.',
+    'font.desc.ronde': 'Ronde francesa, la letra ligada que se enseña en la escuela.',
+    'font.off.ronde': 'Instale en el dispositivo una de estas tres: Ronde Script, OPTIFrench-Script o Merveille. '
+        + 'Son gratuitas para uso personal, y por eso no pueden venir dentro del juego.',
     'font.desc.greatvibes': 'caligráfica inglesa',
     'font.desc.pinyon': 'caligráfica inglesa',
     'font.desc.ufcook': 'blackletter alemana',

package/dist-pkg/i18n/pt.js

@@ -653,6 +653,20 @@ const pt = {
     'font.desc.andika': 'baseada na Sassoon; fruto de pesquisa sobre como crianças leem e escrevem',
     'font.desc.opendyslexic': 'Letras com a base mais pesada, para não virarem de cabeça para baixo ao ler.',
     'font.desc.fondamento': 'Caligráfica de pena, para as atividades de escrita à mão.',
+    'font.desc.pw.br': 'Cursiva escolar do Brasil.',
+    'font.desc.pw.ustrad': 'Cursiva escolar dos EUA — tradicional.',
+    'font.desc.pw.usmod': 'Cursiva escolar dos EUA — moderna.',
+    'font.desc.pw.ca': 'Cursiva escolar do Canadá.',
+    'font.desc.pw.mx': 'Cursiva escolar do México.',
+    'font.desc.pw.ar': 'Cursiva escolar da Argentina.',
+    'font.desc.pw.cl': 'Cursiva escolar do Chile.',
+    'font.desc.pw.co': 'Cursiva escolar da Colômbia.',
+    'font.desc.ronde': 'Ronde francesa, a letra de mão que se ensina na escola.',
+    // ⚠️ AS TRÊS PELO NOME, e não «uma fonte ronde» (ADR-0108 §4): um adulto não consegue agir sobre uma
+    // categoria. A frase existe para ser executável — abrir o navegador, procurar UM destes três nomes,
+    // instalar. Nomear a categoria seria a mesma linha morta que este catálogo já removeu duas vezes.
+    'font.off.ronde': 'Instale no aparelho uma destas três: Ronde Script, OPTIFrench-Script ou Merveille. '
+        + 'Elas são gratuitas para uso pessoal, e por isso não podem vir dentro do jogo.',
     'font.desc.greatvibes': 'caligráfica inglesa',
     'font.desc.pinyon': 'caligráfica inglesa',
     'font.desc.ufcook': 'blackletter alemã',

package/dist-pkg/input/default-bindings.js

@@ -6,20 +6,28 @@
 // físicos — L1, R2, X, A — são BINDING e vivem no transporte, não no vocabulário. Este é o ficheiro onde eles
 // vivem. Um transporte novo (fala, olhar, toque) traz a sua tabela e não toca em `core/actions`.
 //
-// ⚠️ METADE DISTO ESTÁ LIGADA, e a linha que dizia o contrário morreu com a issue #103 (fechada em 06/09).
-// Ela dizia «NADA AQUI ESTÁ LIGADO AINDA … a migração é a issue #103», e era verdade no dia em que foi
-// escrita. Hoje:
+// ✅ AS TRÊS ESTÃO LIGADAS, e esta nota já mentiu duas vezes — cada versão dela era verdade no dia em que foi
+// escrita e deixou de ser sem ninguém a corrigir. A primeira dizia «NADA AQUI ESTÁ LIGADO AINDA» (morreu com a
+// issue #103, 06/09); a segunda dizia que só o gamepad estava, e morreu com a issue #118, que uniu as duas
+// tabelas de teclado. 📏 Medido em 2026-09-09:
 //
-//   · `GAMEPAD_STANDARD` — LIGADO. `input/gamepad.ts:129` lê os índices desta tabela em vez de literais, e a
-//     ligação apanhou uma discordância real: `action1` corria em X, R1 e R2 enquanto a tabela declarava R1 e
-//     R2 como ombro e gatilho.
-//   · `KEYBOARD_SOLO` / `KEYBOARD_DUO` — NÃO LIGADOS. O jogo continua a usar o `KB_DEFAULTS` de
-//     `input/keyboard.ts`, que declara OITO das quatorze posições. Unir as duas é a issue #118, e o que
-//     impede a união hoje não é trabalho: é decidir se `KeyScheme` deixa de ser um `Record` aberto, e onde
-//     moram as seis posições que faltam num teclado dividido por quatro.
+//   · `GAMEPAD_STANDARD` — `input/gamepad.ts:129` lê os índices desta tabela em vez de literais, e a ligação
+//     apanhou uma discordância real: `action1` corria em X, R1 e R2 enquanto a tabela declarava R1 e R2 como
+//     ombro e gatilho.
+//   · `KEYBOARD_SOLO` / `KEYBOARD_DUO` — `input/keyboard.ts:73` constrói o `KB_DEFAULTS` a partir delas
+//     (`vivo(KEYBOARD_SOLO)` e `KEYBOARD_DUO.map(vivo)`). Deixaram de ser duas listas paralelas: são a MESMA
+//     decisão, derivada, e por isso a divergência de antes não pode voltar por esquecimento.
 //
-// ⚠️ ENQUANTO AS DUAS EXISTIREM, ELAS NÃO PODEM DIVERGIR EM SILÊNCIO, e `tests/teclado-duas-tabelas` é quem
-// o garante. Nasceu vermelho: a `Space` do jogador 1 em dupla estava numa e não na outra.
+// ⚠️ E A DERIVAÇÃO É POR CÓPIA PROFUNDA (`vivo` faz JSON round-trip), em DUAS camadas — verificado antes de
+// escrito, porque a primeira versão desta linha dizia mais do que é verdade. `input/keyboard.ts` copia estas
+// tabelas para o `KB_DEFAULTS`, e copia OUTRA VEZ para o `kb` mutável. O remapeamento da criança muta o `kb`
+// («remapear uma tecla MUTA o objeto», diz o `setKB`), logo ele já não alcançaria isto nem sem a primeira
+// cópia. O que a primeira camada compra é o resto: `KB_DEFAULTS` é exportado, e sem ela qualquer consumidor
+// que lhe escrevesse dentro alterava o padrão de fábrica desta tabela para toda a gente.
+//
+// 📌 A LIÇÃO QUE ESTA NOTA CARREGA AGORA É SOBRE SI PRÓPRIA: um comentário que descreve estado de ligação
+// apodrece a cada entrega. Este diz a DATA da medição, para que a próxima pessoa saiba contra o que a
+// comparar em vez de acreditar.
 //
 // ========================= A SIMETRIA DO TECLADO, QUE NÃO É DECORAÇÃO =========================
 // O padrão que o Dev especificou apoia-se num bloco do QWERTY:

package/dist-pkg/input/gamepad.d.ts

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import type { PlayerView } from '../core/entity.js';
+import { type TabelaDoPad } from './pad-defaults.js';
 export interface PadButtonLike {
     pressed: boolean;
 }
@@ -54,7 +55,7 @@ export declare function bindActive(gp: PadLike, bd: PadBinding | null | undefine
 /** Ações do frame para este gamepad. `custom` = mapa salvo pelo wizard para este `gp.id` (null/`_skip` = usa o
  *  mapa PADRÃO da Gamepad API "standard": 0=pulo · 1=especial · 2/5/7=correr · 3=troca · 9=START). Direções
  *  custom caem de volta em stdDirs quando o binding do usuário não está ativo (D-pad/stick continuam vivos). */
-export declare function padActions(gp: PadLike, custom: PadMap | null): PadActions;
+export declare function padActions(gp: PadLike, custom: PadMap | null, tabela?: TabelaDoPad): PadActions;
 /**
  * O MODO DE UM BOTÃO, APLICADO AO CONTROLE — a metade que faltava da empatia motora (issue #120).
  *
@@ -170,6 +171,19 @@ export interface GamepadCtx {
     navPause: (menu: HTMLElement, playerIndex: number, k: NavKeys) => void;
     /** Qual jogador abre o submenu de a11y em seguida (game.js's `pauseActor`). */
     setPauseActor: (playerIndex: number) => void;
+    /**
+     * ESTA ARESTA É DESTE JOGADOR, E VEIO DO CONTROLE (ADR-0113 cláusula 4, issue #127).
+     *
+     * 🔴 OBRIGATÓRIO, e a razão foi medida em 2026-09-09: `input/state.arestaDoJogador` tinha ZERO chamadores
+     * em produção, logo `entradaDe(i).emUso` respondia `teclado` a toda a gente — e a alternância lida era a do
+     * teclado mesmo com o controle na mão. 📌 Passe `criarArestaComAlternancia(() => players)` de
+     * `input/latch-edge`, e não o cru: é ela que também resolve a alternância deste aparelho no jogador.
+     *
+     * ⚠️ O gamepad era o ÚNICO transporte que sobrevivia identificável sem isto — ele nunca passou pelo
+     * conjunto de teclas, passa por `padCur` —, e é exactamente por isso que a falta aqui era invisível: o
+     * módulo sabe de que controle veio a aresta, e o autómato não.
+     */
+    arestaDoJogador: (jogador: number, origem: 'gamepad') => void;
     /**
      * MODAL do PRÓPRIO jogador: a engine entrega a INTENÇÃO, o jogo decide (ADR-0033).
      *