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

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,37 @@ 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.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ã',
     '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,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`.
 //
-// ⚠️ 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.
+// ✅ 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` — `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.
+//
+// ⚠️ 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:
@@ -28,11 +46,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 +83,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 +227,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

@@ -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,23 +55,30 @@ 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;
 /**
- * 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[];
@@ -163,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).
      *