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

package/dist-pkg/i18n/pt.js

@@ -168,6 +168,10 @@ const pt = {
     'touch.dir.cross': 'cruz (D-pad)',
     'touch.dir.stick': 'analógico',
     'sr.touch.slotSet': '{slot}: {acao}.',
+    // ⚠️ SEM O NOME DA POSIÇÃO, de propósito: é uma que este jogo não nomeia, e o id interno (`action3`)
+    // não pode chegar a uma criança (ADR-0074). O anúncio EXISTE na mesma — quem navega por ouvido precisa de
+    // saber que a escolha aterrou. Gémeo do `sr.ctrl.keyTakenHereUnnamed`, que resolveu o mesmo em `7742ac0`.
+    'sr.touch.slotSetUnnamed': '{slot}: definido.',
     'sr.touch.dirSet': 'Direcional: {tipo}.',
     'sr.touch.presetChild': 'Controles no tamanho de mão de criança (6 a 12 anos).',
     'sr.touch.presetAdult': 'Controles no tamanho de mão de adulto.',
@@ -182,9 +186,17 @@ const pt = {
     'act.especial': 'Especial',
     'key.space': 'Espaço',
     'ctrl.change': 'Alterar',
+    'ctrl.pressing': 'Pressione…',
+    'ctrl.editingYours': 'Editando o seu controle — modo {modo}.',
+    'ctrl.mode.one': '1 jogador',
+    'ctrl.mode.many': '{n} jogadores',
     'ctrl.changeKeyAria': 'Alterar tecla de {acao} do Jogador {n}',
     'sr.ctrl.pressNewKey': 'Pressione a nova tecla para {acao} do Jogador {n}, ou Esc para cancelar.',
     'sr.ctrl.keyTaken': 'Essa tecla já é do Jogador {n}. Escolha outra, ou Esc para cancelar.',
+    'sr.ctrl.keyTakenHere': 'Essa tecla já é de {acao}. Escolha outra, ou Esc para cancelar.',
+    // ⚠️ SEM O NOME DA POSIÇÃO, de propósito: ela é uma que este jogo não nomeia, e o id interno (`action2`)
+    // não pode chegar a uma criança (ADR-0074). A frase diz a verdade que interessa — a tecla está ocupada.
+    'sr.ctrl.keyTakenHereUnnamed': 'Essa tecla já está em uso neste controle. Escolha outra, ou Esc para cancelar.',
     'sr.ctrl.reset': 'Controles restaurados ao padrão.',
     // Painel de áudio (#audio) — saídas por jogador, som/narração, bengala, motores de voz.
     'audio.playerN': 'Jogador {n}',
@@ -274,6 +286,11 @@ const pt = {
     'pad.glyph.circle': 'bola',
     'pad.glyph.square': 'quadrado',
     'pad.glyph.triangle': 'triângulo',
+    'pad.wiz.step': '{n} de {total} — aperte: {acao}',
+    'pad.wiz.mapped': 'Mapeados: {lista}',
+    'pad.wiz.pressAny': 'Aperte QUALQUER botão no controle que deseja mapear.',
+    'pad.wiz.detected': 'Controle novo detectado: {id}. O jogo pausou para você configurá-lo. SOLTE tudo para começar.',
+    'pad.wiz.releaseAll': 'Controle: {id}. Agora SOLTE tudo.',
     'menu.legendSpoken': 'Botão {sim} para confirmar, botão {nao} para voltar.',
     'sr.menu.fractionsIntro': 'Soma e subtração de frações: escolha a notação e o tipo.',
     'sr.menu.keepOneNotation': 'Deixe ao menos uma notação ligada.',
@@ -302,6 +319,21 @@ const pt = {
     // conclui que o jogo está partido. Estas frases existem para ela saber ANTES, e o que fazer.
     'reach.titulo': 'Este jogo usa {pedidas} ações.',
     'reach.curto': 'O {transporte} tem {lugares} lugares — não chegam para todas.',
+    // ⚠️ Diz os DOIS números, porque é a diferença entre eles que a criança (ou quem a acompanha) pode
+    // resolver. «Falta alguma coisa» manda procurar sem dizer o quê; «segura 2 e este jogo pede 3» diz que a
+    // saída é outro controle, e diz porquê.
+    'reach.naoSegura': 'O {transporte} segura {segura} botões de cada vez, e este jogo pede {pedidas} ao mesmo tempo.',
+    // ⚠️ A RECUSA DA SIMULAÇÃO (#104 / ADR-0076). Ela diz um FACTO SOBRE A DEMONSTRAÇÃO e o caminho de volta —
+    // nunca «desligue isso». Quem ligou o alto contraste ligou-o porque precisa dele para ver.
+    'eixo.tema.titulo': 'Tema (contraste)',
+    'eixo.tema.padrao': 'Tema padrão',
+    'eixo.correcao.titulo': 'Correção de cor',
+    'eixo.correcao.tricro': 'Visão tricromática',
+    'viz.escolher': 'Selecionar',
+    'viz.escolhido': '✓ Selecionado',
+    'sim.indisponivel.tema': 'Para ver a simulação, o tema precisa estar no padrão: por cima do alto contraste ela mostraria o que o tema faz, e não o que a deficiência faz.',
+    'sim.indisponivel.correcao': 'Para ver a simulação, a correção de cor precisa estar em visão tricromática: de uma tela já corrigida ela não mostraria nem a deficiência nem a correção.',
+    'sim.indisponivel.ambos': 'Para ver a simulação, o tema e a correção de cor precisam estar no padrão: por cima de um ajuste, a demonstração mostra o ajuste e não a deficiência.',
     'reach.ligue': 'Ligue {saida} e você joga com todas.',
     // Quando NADA resolveria: mandar ligar um controle seria mandar procurar o que não conserta.
     'reach.semSaida': 'Nenhum controle deste aparelho alcança todas. Dá para jogar assim mesmo, mas algumas ações vão ficar sem lugar.',
@@ -379,6 +411,8 @@ const pt = {
     'sr.quiz.wellDone': 'Muito bem! {palavra}. {n} de 3.',
     'sr.quiz.correctSoFar': 'Acertou! {n} de 3 para ganhar a moeda.',
     'menu.restoreDefaults': 'Restaurar padrões deste menu',
+    'menu.close': 'Fechar',
+    'menu.typo': 'Tipografia',
     'sr.audio.reset': 'Acessibilidade auditiva restaurada aos padrões. Os outros menus não mudaram.',
     'sr.empathy.reset': 'Modo empatia restaurado aos padrões: simulações desligadas. Correções de daltonismo e os outros menus não mudaram.',
     'sr.motor.reset': 'Modo Fácil e movimento por alternância restaurados aos padrões. O controle pelos olhos e o mapeamento de teclas continuam como estavam.',
@@ -488,6 +522,13 @@ const pt = {
     'sr.motor.easyOff': 'Modo Fácil desligado.',
     'sr.motor.toggleMoveOn': 'Movimento por alternância ligado: toque a direção para andar sem segurar; toque de novo para parar; segure para ir mais rápido. O pulo não interrompe a caminhada.',
     'sr.motor.toggleMoveOff': 'Movimento por alternância desligado.',
+    // ⚠️ O MOTIVO É UM FACTO SOBRE O APARELHO, NUNCA UMA REPREENSÃO (ADR-0113 cláusula 3). Estas frases
+    // dizem por que o botão não responde; «não desligue isto» repreenderia uma criança por mexer num ajuste
+    // de que ela depende. QUATRO chaves e não uma com `{aparelho}`: «os gestos» é plural e «o olhar» não.
+    'alt.exigida.olhos': 'O controle por olhar precisa das teclas de alternância para funcionar.',
+    'alt.exigida.rosto': 'O controle por rosto precisa das teclas de alternância para funcionar.',
+    'alt.exigida.gestos': 'Os gestos precisam das teclas de alternância para funcionar.',
+    'alt.exigida.fala': 'O comando de voz precisa das teclas de alternância para funcionar.',
     'sr.motor.toggleRunOn': 'Alternância do correr ligada.',
     'sr.motor.toggleRunOff': 'Alternância do correr desligada.',
     'sr.physics.runLatchOn': 'Correndo.',
@@ -601,18 +642,23 @@ const pt = {
     // Os NOMES das fontes (Atkinson Hyperlegible, Lexend, …) NÃO entram aqui: são nomes próprios e ficam no
     // catálogo, como os nomes dos motores de voz. O que traduz é o nome do GRUPO e a descrição — que é o texto
     // que explica à criança (ou a quem a acompanha) POR QUE aquela fonte existe na lista.
+    'font.grupo.rotulo': 'Família de letra',
     'font.group.sans': 'Sem serifa',
     'font.group.serif': 'Serifada',
     'font.group.hand': 'Manuscrita',
+    'font.group.arcade': 'Arcade',
     'font.desc.atkinson': 'feita pelo Braille Institute para pessoas com baixa visão (padrão do jogo)',
     'font.desc.lexend': 'feita para reduzir stress visual e atender pessoas disléxicas (ativa o espaçamento extra)',
     'font.desc.quattro': 'criada para diminuir a fadiga visual de quem passa muito tempo na tela',
     '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.greatvibes': 'caligráfica inglesa',
     'font.desc.pinyon': 'caligráfica inglesa',
     'font.desc.ufcook': 'blackletter alemã',
     'font.desc.ufmag': 'blackletter alemã',
     'font.desc.comicneue': 'bola e bastão (alfabetização)',
+    'font.desc.pressstart': 'pixel de 8 bits (HUD e título do jogo)',
     'font.desc.learningcurve': 'cursiva inglesa',
     'font.desc.kindergarten': 'cursiva brasileira',
     'font.off.pending': 'licença a confirmar — ainda não embarcada',

package/dist-pkg/input/default-bindings.d.ts

@@ -7,6 +7,35 @@ export type Binding<T> = T | null;
  * layout ABNT2/US e é a razão de nunca se usar `key` aqui.
  */
 export declare const KEYBOARD_SOLO: Readonly<Record<Action, Binding<readonly string[]>>>;
+/**
+ * Teclado, esquema de DOIS JOGADORES — as quatorze posições para cada um (ADR-0096).
+ *
+ * ⚠️ O JOGADOR 1 AQUI NÃO É O `KEYBOARD_SOLO`, e a diferença é UMA e obrigatória: as SETAS saem dele. No solo
+ * elas são um segundo caminho para o direcional; em dupla são o direcional DO OUTRO. Deixá-las nos dois faria
+ * os dois bonecos andarem juntos — um defeito que não dá erro em lado nenhum e que só se vê jogando a dois.
+ * `conflitosEntreTabelas` existe por causa desta linha.
+ *
+ * ⚠️ E A GEOMETRIA DO JOGADOR 2 É A MESMA DO JOGADOR 1, TRANSPOSTA PARA O TECLADO NUMÉRICO — o que faz a
+ * memória muscular atravessar de um lado da mesa para o outro:
+ *
+ *        7  8            /  *          ombros na linha DE CIMA
+ *     Y  U  I  O      7  8  9  +       gatilhos nas PONTAS da linha das ações
+ *        J  K            5  6
+ *
+ *   action1 U ↔ Numpad8 (cima-esquerda)   action4 I ↔ Numpad9 (cima-direita)
+ *   action2 J ↔ Numpad5 (baixo-esquerda)  action3 K ↔ Numpad6 (baixo-direita)
+ *
+ * O bloco `U I / J K` e o bloco `8 9 / 5 6` têm a MESMA forma, então a rotação de 45° que o cabeçalho deste
+ * ficheiro descreve para o Xbox vale igual para o jogador 2. Não é coincidência de teclado: é o que torna o
+ * padrão ensinável uma vez só.
+ *
+ * ⚠️ `Digit7`/`Digit8` (jogador 1) e `Numpad7` (jogador 2) SÃO TECLAS DIFERENTES, e é por isso que a
+ * especificação do Dev diz «alphanumeric» e «numeric» em tantas palavras. `KeyboardEvent.code` distingue-as
+ * sempre; `key` não — com Num Lock desligado o numérico chega como `ArrowUp`/`Home`, e um esquema lido por
+ * `key` juntaria o direcional do jogador 2 com as ações dele. Mais uma razão de este ficheiro só falar
+ * `code`.
+ */
+export declare const KEYBOARD_DUO: readonly Readonly<Record<Action, Binding<readonly string[]>>>[];
 /**
  * Gamepad, mapa PADRÃO da Gamepad API (`mapping: "standard"`), que é o que um controle de Xbox reporta.
  * O número é o índice em `gamepad.buttons`.
@@ -20,5 +49,16 @@ export declare const GAMEPAD_STANDARD: Readonly<Record<Action, Binding<number>>>
  * ação dupla intermitente que ninguém consegue reproduzir de propósito.
  */
 export declare function bindingProblems<T>(tabela: Readonly<Record<Action, Binding<T | readonly T[]>>>): string[];
+/**
+ * As teclas que DUAS OU MAIS tabelas reclamam para si. VAZIA quer dizer que os jogadores não se atropelam.
+ *
+ * ⚠️ ISTO É UM PROBLEMA DIFERENTE DO `bindingProblems`, E FOI POR ISSO QUE PRECISOU DE FUNÇÃO PRÓPRIA: aquele
+ * olha UMA tabela e apanha a mesma tecla em duas ações; este olha DUAS tabelas e apanha a mesma tecla em dois
+ * JOGADORES. Cada esquema do `KEYBOARD_DUO` passa no primeiro sozinho — e as setas, se ficassem nos dois,
+ * fariam os dois bonecos andarem juntos sem que nada reprovasse.
+ *
+ * A mensagem nomeia os dois donos, porque «tecla repetida» manda procurar o que a função já sabe.
+ */
+export declare function conflitosEntreTabelas<T>(tabelas: readonly Readonly<Record<Action, Binding<T | readonly T[]>>>[]): string[];
 /** As ações que este transporte NÃO alcança. É o que uma tela de seleção precisa dizer ANTES de a criança começar. */
 export declare function unreachable<T>(tabela: Readonly<Record<Action, Binding<T | readonly T[]>>>): Action[];

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

@@ -6,10 +6,20 @@
 // 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`.
 //
-// ⚠️ NADA AQUI ESTÁ LIGADO AINDA. `input/gamepad` e `input/keyboard` continuam a falar os oito nomes de
-// plataforma (`jump`, `run`, `swap`, `especial`); a migração é a issue #103. Esta tabela é o destino dela,
-// escrita agora porque o Dev especificou o padrão — e uma especificação que fica no chat é uma decisão
-// perdida.
+// ⚠️ 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:
+//
+//   · `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.
+//
+// ⚠️ 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.
 //
 // ========================= A SIMETRIA DO TECLADO, QUE NÃO É DECORAÇÃO =========================
 // O padrão que o Dev especificou apoia-se num bloco do QWERTY:
@@ -28,11 +38,18 @@
 // O gate deste ficheiro reprova tecla repetida, então o erro não teria passado de qualquer forma; o que a
 // simetria deu foi a tecla CERTA em vez de só a notícia de que havia uma errada.
 import { ACTIONS } from '../core/actions.js';
-// ⚠️ UMA TECLA QUE EXISTE HOJE E NÃO TEM LUGAR NESTA TABELA: `Space`. O esquema solo de `input/keyboard.ts`
-// tem `jump:['KeyJ','Space']` — a barra é um segundo atalho para o pulo desde sempre. A especificação do
-// padrão não a menciona, e pô-la em `action2` por conta própria seria decidir que o pulo mora ali: se o
-// preset da plataforma puser o pulo noutra posição, a barra segue o verbo errado, que é pior do que ela não
-// existir. Fica de fora, dita aqui, e é decisão do Dev — não de quem escreve a tabela.
+// ⚠️ A `Space` ESTÁ EM `action2`, E ISTO É A HISTÓRIA DE COMO LÁ FOI PARAR — porque este bloco dizia o
+// contrário e sobreviveu à decisão que o revogou.
+//
+// Ela ficou de fora da primeira versão desta tabela, e a razão estava certa: a barra é o segundo atalho do
+// pulo desde sempre, a especificação do padrão não a mencionava, e pô-la em `action2` por conta própria
+// seria decidir que o pulo mora ali. Se o preset da plataforma puser o pulo noutra posição, a barra segue o
+// verbo errado — pior do que ela não existir.
+//
+// O Dev decidiu (ADR-0086 §2) que o pulo mora em `action2`, e a barra voltou. O texto acima continuou a
+// dizer «fica de fora» durante todo esse tempo, ao lado de duas linhas que a declaram. Corrigido em
+// 2026-09-07, na mesma passagem da issue #118 — que trata exactamente desta classe de erro: um comentário
+// que descreve um estado que já passou.
 /**
  * Teclado, esquema SOLO. Códigos de `KeyboardEvent.code` — físicos, não a letra impressa, que muda com o
  * layout ABNT2/US e é a razão de nunca se usar `key` aqui.
@@ -58,6 +75,92 @@ export const KEYBOARD_SOLO = {
     start: ['KeyH', 'Enter'],
     select: ['KeyF'],
 };
+/**
+ * Teclado, esquema de DOIS JOGADORES — as quatorze posições para cada um (ADR-0096).
+ *
+ * ⚠️ O JOGADOR 1 AQUI NÃO É O `KEYBOARD_SOLO`, e a diferença é UMA e obrigatória: as SETAS saem dele. No solo
+ * elas são um segundo caminho para o direcional; em dupla são o direcional DO OUTRO. Deixá-las nos dois faria
+ * os dois bonecos andarem juntos — um defeito que não dá erro em lado nenhum e que só se vê jogando a dois.
+ * `conflitosEntreTabelas` existe por causa desta linha.
+ *
+ * ⚠️ E A GEOMETRIA DO JOGADOR 2 É A MESMA DO JOGADOR 1, TRANSPOSTA PARA O TECLADO NUMÉRICO — o que faz a
+ * memória muscular atravessar de um lado da mesa para o outro:
+ *
+ *        7  8            /  *          ombros na linha DE CIMA
+ *     Y  U  I  O      7  8  9  +       gatilhos nas PONTAS da linha das ações
+ *        J  K            5  6
+ *
+ *   action1 U ↔ Numpad8 (cima-esquerda)   action4 I ↔ Numpad9 (cima-direita)
+ *   action2 J ↔ Numpad5 (baixo-esquerda)  action3 K ↔ Numpad6 (baixo-direita)
+ *
+ * O bloco `U I / J K` e o bloco `8 9 / 5 6` têm a MESMA forma, então a rotação de 45° que o cabeçalho deste
+ * ficheiro descreve para o Xbox vale igual para o jogador 2. Não é coincidência de teclado: é o que torna o
+ * padrão ensinável uma vez só.
+ *
+ * ⚠️ `Digit7`/`Digit8` (jogador 1) e `Numpad7` (jogador 2) SÃO TECLAS DIFERENTES, e é por isso que a
+ * especificação do Dev diz «alphanumeric» e «numeric» em tantas palavras. `KeyboardEvent.code` distingue-as
+ * sempre; `key` não — com Num Lock desligado o numérico chega como `ArrowUp`/`Home`, e um esquema lido por
+ * `key` juntaria o direcional do jogador 2 com as ações dele. Mais uma razão de este ficheiro só falar
+ * `code`.
+ */
+export const KEYBOARD_DUO = Object.freeze([
+    {
+        // JOGADOR 1 — a mão esquerda anda (WASD), a direita age (UIJK). Sem as setas: são do jogador 2.
+        up: ['KeyW'],
+        down: ['KeyS'],
+        left: ['KeyA'],
+        right: ['KeyD'],
+        action1: ['KeyU'],
+        action2: ['KeyJ', 'Space'],
+        action3: ['KeyK'],
+        action4: ['KeyI'],
+        leftShoulder: ['Digit7'],
+        leftTrigger: ['KeyY'],
+        rightShoulder: ['Digit8'],
+        rightTrigger: ['KeyO'],
+        start: ['KeyH', 'Enter'],
+        select: ['KeyF'],
+    },
+    {
+        // JOGADOR 2 — as setas andam, o teclado numérico age. `Enter` fica com o jogador 1; o `NumpadEnter` não
+        // entra aqui de propósito, porque `ui/menu-nav` já o usa como CONFIRMAR em qualquer menu (KEY_YES) e
+        // `input/keydown` registra, verbatim, que ele NÃO pausa. Dar-lhe um terceiro trabalho seria sobrepor.
+        up: ['ArrowUp'],
+        down: ['ArrowDown'],
+        left: ['ArrowLeft'],
+        right: ['ArrowRight'],
+        action1: ['Numpad8'],
+        action2: ['Numpad5'],
+        action3: ['Numpad6'],
+        action4: ['Numpad9'],
+        leftShoulder: ['NumpadDivide'], // a tecla `/` do bloco numérico
+        leftTrigger: ['Numpad7'],
+        rightShoulder: ['NumpadMultiply'], // a tecla `*`
+        rightTrigger: ['NumpadAdd'], // a tecla `+`
+        /**
+         * ⚠️ `ShiftRight` É A PORTA DE SAÍDA, E ELA FALTAVA (#122).
+         *
+         * Um Chromebook não tem bloco numérico, e um Chromebook é o hardware que o pilar 1 nomeia. Medido em
+         * 2026-09-07: das catorze posições deste assento, **DEZ só se alcançam pelo numpad** — as oito ações
+         * mais o `start` e o `select`. A criança da segunda cadeira anda pelas setas, não age em nada, e **não
+         * consegue abrir o menu para consertar**, porque a tecla que abre o menu está no mesmo bloco que falta.
+         *
+         * Isso é o que a auditoria chamou de «um padrão do qual a criança não escapa», e o conserto que ela pede
+         * é textual: *«tornar o próprio padrão remapeável, e não trocar as teclas que ele escolheu».* As teclas
+         * ficam — o layout do numpad é melhor onde ele existe, é um bloco físico sob uma mão, e não tira nada ao
+         * primeiro jogador. O que entra é UMA porta que todo teclado tem, para o remapeamento ser alcançável.
+         *
+         * ⚠️ E É SÓ NO `start`, de propósito: da pausa alcança-se a tela de remapeamento, e de lá TODAS as outras
+         * treze posições. Uma porta chega para escapar; cada padrão a mais é uma tecla tirada do bolo comum, e
+         * este teclado já é repartido por duas crianças.
+         *
+         * `ShiftRight` porque existe em todo o teclado, fica ao lado do bloco de setas (a mesma mão que já as
+         * usa), não é tecla de texto — e está LIVRE nas quatro tabelas, o que foi medido e não suposto.
+         */
+        start: ['Numpad1', 'ShiftRight'],
+        select: ['Numpad0'],
+    },
+]);
 /**
  * Gamepad, mapa PADRÃO da Gamepad API (`mapping: "standard"`), que é o que um controle de Xbox reporta.
  * O número é o índice em `gamepad.buttons`.
@@ -116,6 +219,37 @@ export function bindingProblems(tabela) {
     }
     return p;
 }
+/**
+ * As teclas que DUAS OU MAIS tabelas reclamam para si. VAZIA quer dizer que os jogadores não se atropelam.
+ *
+ * ⚠️ ISTO É UM PROBLEMA DIFERENTE DO `bindingProblems`, E FOI POR ISSO QUE PRECISOU DE FUNÇÃO PRÓPRIA: aquele
+ * olha UMA tabela e apanha a mesma tecla em duas ações; este olha DUAS tabelas e apanha a mesma tecla em dois
+ * JOGADORES. Cada esquema do `KEYBOARD_DUO` passa no primeiro sozinho — e as setas, se ficassem nos dois,
+ * fariam os dois bonecos andarem juntos sem que nada reprovasse.
+ *
+ * A mensagem nomeia os dois donos, porque «tecla repetida» manda procurar o que a função já sabe.
+ */
+export function conflitosEntreTabelas(tabelas) {
+    const p = [];
+    const dono = new Map();
+    tabelas.forEach((tabela, i) => {
+        for (const acao of ACTIONS) {
+            const v = tabela[acao];
+            if (v === null || v === undefined)
+                continue;
+            for (const item of (Array.isArray(v) ? v : [v])) {
+                const chave = String(item);
+                const aqui = `p${i + 1}.${acao}`;
+                const anterior = dono.get(chave);
+                if (anterior)
+                    p.push(`cross: ${chave} is claimed by both ${anterior} and ${aqui}`);
+                else
+                    dono.set(chave, aqui);
+            }
+        }
+    });
+    return p;
+}
 /** As ações que este transporte NÃO alcança. É o que uma tela de seleção precisa dizer ANTES de a criança começar. */
 export function unreachable(tabela) {
     return ACTIONS.filter((a) => tabela[a] === null || tabela[a] === undefined);

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

@@ -56,21 +56,28 @@ export declare function bindActive(gp: PadLike, bd: PadBinding | null | undefine
  *  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;
 /**
- * A ORDEM em que o assistente pergunta. SÓ a ordem.
+ * O MODO DE UM BOTÃO, APLICADO AO CONTROLE — a metade que faltava da empatia motora (issue #120).
  *
- * ⚠️ ELA CARREGAVA AS PALAVRAS, EM PORTUGUÊS CRU, DENTRO DA ENGINE: `['action2', 'PULAR']`,
- * `['action1', 'CORRER / INTERAGIR']`. Era o defeito do ADR-0074 na sua forma mais visível — não só
- * vocabulário de plataforma dentro do motor, mas vocabulário de plataforma NUM IDIOMA SÓ, à frente de uma
- * criança, num ficheiro que o pilar 3 obriga a ser localizável.
+ * ⚠️ ELE VALIA SÓ NO TECLADO. `input/keydown.ts:407` solta todas as outras teclas de jogo quando uma nova
+ * chega com o modo ligado; `pollPads` não tinha equivalente nenhum, e `grep oneButton` neste ficheiro
+ * devolvia zero. Uma criança que ligasse o modo e tivesse um controle na mão **não estava no modo** — sem
+ * erro, sem aviso, sem sintoma, porque as definições continuavam a dizer que estava ligado.
  *
- * A palavra vem agora de `ctx.rotuloDaAcao`, que o jogo fornece pelo seu preset. Aqui fica o que é mesmo da
- * engine: a sequência em que se pergunta — direções primeiro, ação depois, sistema no fim —, que é uma
- * decisão de ergonomia do assistente e não do jogo.
+ * ⚠️ AS DIREÇÕES CONTAM, e é isso que torna a regra fiel ao teclado: lá, `isGameKeyCode` inclui as teclas
+ * de `p.ctrl`, que são as quatro direções — andar e pular não coexistem. Um filtro que poupasse as
+ * direções seria mais confortável e estaria a simular outra deficiência.
  *
- * ⚠️ E UMA AÇÃO QUE O JOGO NÃO NOMEIA NÃO É PERGUNTADA. `wizPrompt` salta-a, porque um jogo que não usa a
- * posição não tem o que mapear nela — e perguntar produziria um passo mudo, ou pior, um passo a dizer
- * `action7` em voz alta.
+ * ⚠️ E A ESCOLHA DE QUEM SOBREVIVE É DIFERENTE DA DO TECLADO, POR NECESSIDADE. No teclado a chegada nova
+ * ganha, porque HÁ uma chegada: o evento diz qual é. Um controle é lido por SONDAGEM — o que chega é um
+ * retrato, sem ordem. Então mantém-se a que já valia, e só quando ela solta é que a próxima assume. É o
+ * que impede o botão de correr de ser cortado porque o polegar encostou noutro, e é a mesma leitura de
+ * «segurar» que o ADR-0077 dá.
+ *
+ * A POLÍTICA é a mesma do `keydown`; a IMPLEMENTAÇÃO não pode ser partilhada hoje porque as formas do
+ * estado diferem — lá é um `Set` de códigos de tecla, aqui é um retrato de booleanos por posição. Unificar
+ * as duas é trabalho à parte, e escrevê-lo aqui é a alternativa a fingir que não há duas.
  */
+export declare function umBotaoPorVez(anterior: Readonly<Record<string, boolean | undefined>>, atual: PadActions, ligado: boolean): PadActions;
 export declare const PADWIZ_ORDER: readonly string[];
 export interface WizAnimDef {
     seq?: string[];

package/dist-pkg/input/gamepad.js

@@ -11,6 +11,15 @@ import { EDGE_BY_ACTION, edgeAllowed } from './edges.js';
 import { migrarMapaDeControle } from './vocabulary-migration.js';
 import { GAMEPAD_STANDARD } from './default-bindings.js';
 import { padCur, padPrevAct, padPrevStart, PAD_DEAD } from './state.js';
+// ⚠️ O `oneButton` ENTRA POR IMPORT, e não pelo `ctx` — ao contrário de `input/keydown`, que o recebe por
+// getter. A diferença não é de gosto: o `keydown` foi extraído quando o `oneButton` era um `let` do
+// `game.js`, e a regra da casa manda o que o JOGO reatribui entrar por getter. Hoje ele é `core/state`,
+// ou seja da ENGINE — e um getter obrigaria cada consumidor a lembrar-se de o passar.
+//
+// ⚠️ E ESQUECER É EXATAMENTE O DEFEITO QUE ISTO CONSERTA (issue #120). Um campo opcional no ctx faria a
+// acomodação existir só nos jogos onde alguém se lembrou dela, que é o argumento M3 do ADR-0077 com outro
+// substantivo. Binding vivo de `core/state`: não há por onde falhar.
+import * as estadoDoJogo from '../core/state.js';
 import * as store from '../platform/storage.js';
 function bindingAt(map, key) {
     const v = map[key];
@@ -117,6 +126,56 @@ export function padActions(gp, custom) {
  * posição não tem o que mapear nela — e perguntar produziria um passo mudo, ou pior, um passo a dizer
  * `action7` em voz alta.
  */
+/**
+ * AS POSIÇÕES QUE O MODO DE UM BOTÃO NÃO CORTA. Pausar é a SAÍDA, não uma jogada.
+ *
+ * ⚠️ Cortar o START prenderia a criança dentro da partida — é o mesmo raciocínio que põe «a saída
+ * primeiro» no ADR-0044 e que fez a armadilha de foco existir no ADR-0090. Uma acomodação que tranca não
+ * é acomodação. Os derivados (`_start`, `_pause`) também passam: eles descrevem o que a raiz faz com
+ * estas duas posições, não uma terceira.
+ */
+const FORA_DO_CORTE = new Set(['start', 'select', '_start', '_pause']);
+/**
+ * O MODO DE UM BOTÃO, APLICADO AO CONTROLE — a metade que faltava da empatia motora (issue #120).
+ *
+ * ⚠️ ELE VALIA SÓ NO TECLADO. `input/keydown.ts:407` solta todas as outras teclas de jogo quando uma nova
+ * chega com o modo ligado; `pollPads` não tinha equivalente nenhum, e `grep oneButton` neste ficheiro
+ * devolvia zero. Uma criança que ligasse o modo e tivesse um controle na mão **não estava no modo** — sem
+ * erro, sem aviso, sem sintoma, porque as definições continuavam a dizer que estava ligado.
+ *
+ * ⚠️ AS DIREÇÕES CONTAM, e é isso que torna a regra fiel ao teclado: lá, `isGameKeyCode` inclui as teclas
+ * de `p.ctrl`, que são as quatro direções — andar e pular não coexistem. Um filtro que poupasse as
+ * direções seria mais confortável e estaria a simular outra deficiência.
+ *
+ * ⚠️ E A ESCOLHA DE QUEM SOBREVIVE É DIFERENTE DA DO TECLADO, POR NECESSIDADE. No teclado a chegada nova
+ * ganha, porque HÁ uma chegada: o evento diz qual é. Um controle é lido por SONDAGEM — o que chega é um
+ * retrato, sem ordem. Então mantém-se a que já valia, e só quando ela solta é que a próxima assume. É o
+ * que impede o botão de correr de ser cortado porque o polegar encostou noutro, e é a mesma leitura de
+ * «segurar» que o ADR-0077 dá.
+ *
+ * A POLÍTICA é a mesma do `keydown`; a IMPLEMENTAÇÃO não pode ser partilhada hoje porque as formas do
+ * estado diferem — lá é um `Set` de códigos de tecla, aqui é um retrato de booleanos por posição. Unificar
+ * as duas é trabalho à parte, e escrevê-lo aqui é a alternativa a fingir que não há duas.
+ */
+export function umBotaoPorVez(
+// ⚠️ O ANTERIOR É TIPADO PELO QUE ESTA FUNÇÃO LÊ, e não por `PadActions`: o `padPrevAct[gi]` do laço é
+// `PadState`, mais frouxo, e exigir a forma completa obrigaria o chamador a um molde que não descreve o
+// que se passa aqui — só se pergunta «esta chave estava em baixo?».
+anterior, atual, ligado) {
+    if (!ligado)
+        return atual;
+    const cortaveis = Object.keys(atual).filter((k) => !FORA_DO_CORTE.has(k));
+    const ativas = cortaveis.filter((k) => atual[k] === true);
+    if (ativas.length <= 1)
+        return atual;
+    // A que já valia tem prioridade; sem nenhuma, a primeira do retrato assume.
+    const mantida = ativas.find((k) => anterior[k] === true) ?? ativas[0];
+    const saida = { ...atual };
+    for (const k of ativas)
+        if (k !== mantida)
+            saida[k] = false;
+    return saida;
+}
 export const PADWIZ_ORDER = [
     // Direções primeiro: são o que a criança encontra sem pensar, e acertar as quatro dá confiança para as
     // outras dez.
@@ -163,11 +222,15 @@ export function initGamepad(ctx) {
     }
     function actionsFor(gp) { return padActions(gp, padMapFor(gp.id)); }
     // ----- wizard: anúncio + demo animada (DOM-facing, thin) -----
-    function wizSay(t) {
+    // ⚠️ O PARÂMETRO CHAMAVA-SE `t`, E ERA ELE QUE FECHAVA A PORTA. Dentro desta função o `t` do
+    // `core/i18n` estava sombreado, então traduzir uma frase aqui era impossível sem primeiro reparar no
+    // sombreamento — e não há erro nenhum a apontá-lo. Foi assim que cinco frases em português cru ficaram a
+    // falar dentro do motor (#123): não por decisão, por um nome.
+    function wizSay(frase) {
         const el = ctx.$('#padwiz-prompt');
         if (el)
-            el.textContent = t;
-        ctx.srSay(t);
+            el.textContent = frase;
+        ctx.srSay(frase);
     }
     function wizDemo(k) {
         const d = ctx.$('#padwiz-demo');
@@ -224,11 +287,12 @@ export function initGamepad(ctx) {
             return; // fechou ao avançar
         const acao = PADWIZ_ORDER[padWiz.step];
         const rotulo = ctx.rotuloDaAcao(acao);
-        wizSay((padWiz.step + 1) + ' de ' + PADWIZ_ORDER.length + ' — aperte: ' + rotulo);
+        wizSay(t('pad.wiz.step', { n: padWiz.step + 1, total: PADWIZ_ORDER.length, acao: rotulo }));
         wizDemo(acao); // demonstração animada do que a ação FAZ
         const pr = ctx.$('#padwiz-progress');
+        // O travessão da lista vazia fica cru de propósito: é pontuação, não idioma.
         if (pr)
-            pr.textContent = 'Mapeados: ' + (Object.keys(padWiz.map).join(' · ') || '—');
+            pr.textContent = t('pad.wiz.mapped', { lista: Object.keys(padWiz.map).join(' · ') || '—' });
     }
     function wizBind(bd) {
         if (!padWiz)
@@ -246,7 +310,7 @@ export function initGamepad(ctx) {
         ov.hidden = false;
         ctx.frontOverlay(ov);
         padWiz = { gi: -1, id: '', step: -1, base: null, map: {}, release: false, baseWait: false, axTrack: null, timer: null };
-        wizSay('Aperte QUALQUER botão no controle que deseja mapear.');
+        wizSay(t('pad.wiz.pressAny'));
         wizDemo(null);
         const pr = ctx.$('#padwiz-progress');
         if (pr)
@@ -261,7 +325,7 @@ export function initGamepad(ctx) {
         ov.hidden = false;
         ctx.frontOverlay(ov);
         padWiz = { gi: gp.index, id: gp.id, step: -1, base: null, map: {}, release: false, baseWait: true, axTrack: null, timer: null };
-        wizSay('Controle novo detectado: ' + gp.id + '. O jogo pausou para você configurá-lo. SOLTE tudo para começar.');
+        wizSay(t('pad.wiz.detected', { id: gp.id }));
         wizDemo(null);
         const pr = ctx.$('#padwiz-progress');
         if (pr)
@@ -316,7 +380,7 @@ export function initGamepad(ctx) {
                     padWiz.gi = gp.index;
                     padWiz.id = gp.id;
                     padWiz.baseWait = true;
-                    wizSay('Controle: ' + gp.id + '. Agora SOLTE tudo.');
+                    wizSay(t('pad.wiz.releaseAll', { id: gp.id }));
                     break;
                 }
             }
@@ -405,8 +469,10 @@ export function initGamepad(ctx) {
                 openPadWizFor(gp);
                 return;
             }
-            const cur = actionsFor(gp);
             const prev = padPrevAct[gi] || {};
+            // ⚠️ A EMPATIA MOTORA APLICADA AO CONTROLE (issue #120). Sem esta linha, uma criança com o modo de
+            // um botão ligado e um pad na mão NÃO ESTAVA no modo — e nada em lado nenhum o dizia.
+            const cur = umBotaoPorVez(prev, actionsFor(gp), estadoDoJogo.oneButton);
             if (ctx.isTouchMode() && (cur.left || cur.right || cur.up || cur.down || cur.action2 || cur.action1 || cur.action4 || cur.action3 || cur._start)) {
                 ctx.hideTouchControls(); // botão físico usado -> some o gamepad virtual (mesma regra do teclado)
             }

package/dist-pkg/input/keyboard-runtime.d.ts

@@ -21,16 +21,14 @@ export interface KeyboardRuntimeCtx {
     /** The live players array (core/state.ts's `players`, mutated in place — never reassigned). */
     getPlayers(): KeyboardRuntimePlayer[];
 }
-/** Result of the old `applyControls()` mutation, as a value: `controls` + its per-action aliases (game.js's
- *  KJUMP/KLEFT/KRIGHT/KUP/KDOWN/KRUN) + the flattened `GAME_KEYS` list. */
 export interface ControlsState {
     controls: KeyScheme;
-    action2: string[];
-    left: string[];
-    right: string[];
-    up: string[];
-    down: string[];
-    action1: string[];
+    action2: readonly string[];
+    left: readonly string[];
+    right: readonly string[];
+    up: readonly string[];
+    down: readonly string[];
+    action1: readonly string[];
     gameKeys: string[];
 }
 export interface KeyboardRuntime {

package/dist-pkg/input/keyboard-runtime.js

@@ -7,6 +7,11 @@
 // being reassigned here: imported bindings can't be reassigned from outside their own module, so the game.js
 // wrapper is the one that copies the returned fields onto its own `let`s (same trap `core/state.ts` documents
 // for `coins`/`players`).
+import { ACTIONS } from '../core/actions.js';
+/** Result of the old `applyControls()` mutation, as a value: `controls` + its per-action aliases (game.js's
+ *  KJUMP/KLEFT/KRIGHT/KUP/KDOWN/KRUN) + the flattened `GAME_KEYS` list. */
+/** A lista que uma posição SEM ALCANCE devolve. Congelada e partilhada: ninguém deve escrever nela. */
+const VAZIO = Object.freeze([]);
 // ---------------------------------------------------------------------------------------------
 // Pure logic (no ctx, no `document` — directly testable with plain KeyScheme fixtures)
 // ---------------------------------------------------------------------------------------------
@@ -14,8 +19,12 @@
  *  (mirrors ui/settings-controls.ts's keyUsedByOther: a Map built over the scheme, not a re-scan per query). */
 function buildActionIndex(scheme) {
     const index = new Map();
-    for (const action in scheme) {
-        for (const code of scheme[action]) {
+    // ⚠️ O LAÇO PASSOU A SER SOBRE `ACTIONS` E NÃO SOBRE AS CHAVES DO OBJETO (issue #118). São a mesma lista
+    // agora que o `KeyScheme` é fechado — mas percorrer `ACTIONS` diz QUAL é a lista, e um esquema que ganhe
+    // uma chave a mais por engano deixa de a ver. E o `?? []` é o que trata a AUSÊNCIA DECLARADA: um `null`
+    // não é um esquema partido, é um teclado que não alcança aquela posição.
+    for (const action of ACTIONS) {
+        for (const code of scheme[action] ?? []) {
             if (!index.has(code))
                 index.set(code, action);
         }
@@ -65,12 +74,22 @@ export function initKeyboardRuntime(ctx) {
     function computeControlsState() {
         const kb = ctx.getKB();
         const controls = kb.solo; // alias do P1 — SEMPRE kb.solo, mesmo com numPlayers>1 (comportamento original; ver relato)
-        const { action2, left, right, up, down, action1 } = controls;
+        // Os apelidos são LISTAS, nunca `null`: quem os lê faz `.includes(code)` sem perguntar. Uma posição que o
+        // esquema não alcança vira lista vazia aqui — «não alcança» e «alcança com zero teclas» valem o mesmo
+        // para quem só pergunta se a tecla está lá.
+        //
+        // ⚠️ E DEVOLVE A MESMA REFERÊNCIA, não uma cópia. A primeira versão fazia `[...]` e um caso reprovou por
+        // identidade — corretamente: o apelido é o alias do P1, e um teste que afirma «é o mesmo array» está a
+        // afirmar que ninguém interpôs uma cópia entre o esquema vivo e quem o lê. Copiar aqui não custaria nada
+        // hoje e passaria a custar no dia em que alguém mutasse a lista no lugar.
+        const lista = (a) => controls[a] ?? VAZIO;
+        const action2 = lista('action2'), left = lista('left'), right = lista('right');
+        const up = lista('up'), down = lista('down'), action1 = lista('action1');
         const gameKeySet = new Set();
         ctx.getPlayers().forEach((_, i) => {
             const scheme = kbFor(i);
-            for (const action in scheme)
-                for (const code of scheme[action])
+            for (const action of ACTIONS)
+                for (const code of scheme[action] ?? [])
                     gameKeySet.add(code);
         });
         const gameKeys = gameKeySet.size ? [...gameKeySet] : [...action2, ...left, ...right, ...up, ...down];

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

@@ -20,6 +20,16 @@ export type KBDefaults = {
     p4: KeyScheme[];
 };
 export declare const KB_SCHEMES4: KeyScheme[];
+/**
+ * ⚠️ AS DUAS TABELAS DE TECLADO PASSARAM A SER UMA (issue #118). O solo e a dupla já não são escritos aqui:
+ * são CÓPIAS VIVAS do que `input/default-bindings` declara, que é onde o ADR-0096 pôs a decisão.
+ *
+ * Antes eram duas listas paralelas com oito posições cada, e as oito «coincidiam» — menos uma. A `Space` do
+ * jogador 1 em dupla estava numa e não na outra, e o custo era concreto: `ui/webcam.ts` sintetiza `Space`
+ * para «olhar para cima = pular», então entrar um segundo jogador tirava o PULO de quem joga com os olhos e
+ * deixava o andar. Nada errava em voz alta. Derivar em vez de repetir torna essa divergência impossível de
+ * voltar a existir, em vez de a apanhar depois de acontecer.
+ */
 export declare const KB_DEFAULTS: KBDefaults;
 export declare function loadKB(): KBDefaults;
 export declare function saveKB(kb: KBDefaults): void;