@the-inclusionist/engine 10.0.0 → 11.0.0

package/dist-pkg/i18n/pt.js

@@ -29,10 +29,13 @@ const pt = {
     // de cima é para quem ESCUTA, esta diz QUAL botão, porque quem a lê tem outras pessoas à volta.
     'hud.waitBadge': 'Jogador {n}: aperte um botão do SEU teclado ou de um controle livre para entrar',
     'sr.libras.loading': 'Intérprete de Libras ainda carregando — tente de novo em instantes.',
-    // ⚠️ Esta frase não é lida: é SINALIZADA. Ela vai para o widget do VLibras no instante em que o modo liga, e é a primeira
-    // coisa que o intérprete diz a quem acabou de o chamar — curta de propósito, e uma saudação, não um estado de sistema.
-    'sr.libras.on': 'Olá! O intérprete de Libras está ligado.',
+    // told to a deaf child when the sonar asks for signing and no interpreter can sign: what she keeps matters as much as what
+    // she lost (ADR-0234)
+    'sr.deaf.noSigning': 'Sem intérprete de Libras agora: as legendas e o texto continuam na tela.',
+    // the accessible name of the interpreter's frame, in front of the screen while it signs (ADR-0234)
+    'sr.deaf.interpreter': 'Intérprete de Libras',
     'sr.eyes.needsInternet': 'O controle pelo olhar ainda não chegou a este aparelho: ele desce na primeira vez que o jogo abre com internet.',
+    'sr.eyes.failed': 'O controle pelo olhar não conseguiu começar neste aparelho.',
     // the eye control's words over the game (ADR-0213 §6): a region tells a preparing look which way to go, the opposite of itself
     'gaze.lookHere': 'Olhe aqui',
     'gaze.loading': 'Carregando...',
@@ -44,6 +47,7 @@ const pt = {
     'sr.face.ready': 'Pronto: já pode jogar com o rosto.',
     'sr.face.noCamera': 'O controle pelo rosto precisa da câmera, e ela não abriu. Permita a câmera para esta página.',
     'sr.face.needsInternet': 'O controle pelo rosto ainda não chegou a este aparelho: ele desce na primeira vez que o jogo abre com internet.',
+    'sr.face.failed': 'O controle pelo rosto não conseguiu começar neste aparelho.',
     'sr.face.stopped': 'O controle pelo rosto parou de receber imagens da câmera.',
     'sr.face.slow': 'O controle pelo rosto está lento neste aparelho e pode não responder.',
     'sr.eyes.lookMiddle': 'Olhe para o meio da tela e não mexa os olhos até eu dizer pronto.',
@@ -66,6 +70,13 @@ const pt = {
     'hud.barra': '{nome}: {azuis} de primeira, {verdes} com ajuda, {vermelhos} sem acertar',
     'hud.barra.sobe': 'o nível sobe',
     'hud.barra.desce': 'o nível desce',
+    // The score in the HUD row is drawn as five digits (ADR-0238, ADR-0239); a listener hears the number itself, not the zeros.
+    'hud.points': '{count} {name}',
+    // The session clock's accessible name (ADR-0236): the time left in words, never «0:45». Rewritten each whole minute.
+    'clock.left': 'Tempo de jogo: faltam {minutes} minutos',
+    'clock.left.one': 'Tempo de jogo: falta 1 minuto',
+    'clock.over': 'Tempo de jogo: acabou',
+    'clock.label': 'TEMPO', // the small word over the clock's digits (ADR-0239)
     // O NOME do que este jogo junta. Currículo não se traduz (pilar 3), mas "moedas" não é currículo — é um
     // substantivo comum da interface, e a criança que joga em inglês tem de ouvir "coins". Por isso o nome
     // atravessa por `{nome}` JÁ RESOLVIDO pelo jogo, e a chave mora aqui.
@@ -144,6 +155,7 @@ const pt = {
     'pause.motivo.ajuda': 'Este jogo ainda não disse o que cada botão faz.',
     'pause.motivo.addplayer': 'Quem decide quantos jogadores podem jogar é o jogo.',
     'pause.motivo.opcoesdojogo': 'Este jogo não tem opções próprias.',
+    'pause.motivo.caa': 'Menu desabilitado',
     // Acessibilidade (leitores de tela)
     // Controles de toque — rótulos das 9 posições e das 9 ações mapeáveis (painel #touchcfg) e os anúncios.
     // Rótulo é MOLDURA inteira: em inglês "(cima)" vira "(up)" e a seta fica onde está, então a seta viaja
@@ -243,6 +255,17 @@ const pt = {
     'input.standard': 'padrão',
     'input.sticky': 'não precisa segurar',
     'scan.nothing': 'cancelar',
+    // One-button scanning inside a menu: that menu's own steps (ADR-0218 erratum of 2026-09-26, interface log).
+    'scan.menu.next': 'próximo',
+    'scan.menu.confirm': 'confirmar',
+    'scan.menu.back': 'voltar',
+    'scan.menu.previous': 'anterior',
+    // ...and, on a control with a value, the sideways step (the interface log's entry on the sideways step).
+    'scan.menu.increase': 'aumentar',
+    'scan.menu.decrease': 'diminuir',
+    // ...and the engine's two doors, offered in play after the game's own words (ADR-0218 §3).
+    'scan.door.menus': 'menu',
+    'scan.door.pause': 'pausar',
     'input.scan': 'um botão só',
     'icon.contrast': 'Alto contraste',
     'icon.cvd': 'Correção de daltonismo',
@@ -254,7 +277,7 @@ const pt = {
     'icon.velocidade.valor': '{pct}%',
     'icon.blind.dica': 'Joga-se pelo som: a navegação sonora diz o que a tela mostra.',
     'icon.tts.dica': 'O jogo lê em voz alta o que está escrito na tela.',
-    'icon.libras.dica': 'Um intérprete de Libras mostra em sinais o que o jogo diz.',
+    'icon.libras.dica': 'Os sons ganham legenda, e o sonar chama um intérprete de Libras para o que está na tela.',
     'icon.tea.dica': 'Deixa o jogo mais calmo ou em silêncio, para quem se sobrecarrega com estímulos.',
     'icon.altmove.dica': 'Como os seus toques são lidos: do jeito padrão; ou com um toque que liga e outro que desliga, sem segurar; ou com um botão só, em que o jogo mostra cada coisa por vez e você aperta na que quer.',
     'sr.icon.inputMode': 'Jeito de apertar: {v}.',
@@ -273,9 +296,11 @@ const pt = {
     'sr.voice.noMicrophone': 'O controle por voz precisa do microfone, e ele não abriu. Permita o microfone para esta página.',
     'sr.voice.failed': 'O comando de voz não conseguiu começar neste aparelho.',
     'sr.voice.needsInternet': 'O controle por voz ainda não chegou a este aparelho: ele desce na primeira vez que o jogo abre com internet.',
+    'sr.reading.failed': 'A leitura em voz alta não conseguiu começar neste idioma, neste aparelho.',
     'sr.hands.ready': 'Pronto: já pode jogar com gestos das mãos.',
     'sr.hands.noCamera': 'O controle por gestos precisa da câmera, e ela não abriu. Permita a câmera para esta página.',
     'sr.hands.needsInternet': 'O controle por gestos ainda não chegou a este aparelho: ele desce na primeira vez que o jogo abre com internet.',
+    'sr.hands.failed': 'O controle por gestos não conseguiu começar neste aparelho.',
     'sr.hands.stopped': 'O controle por gestos parou de receber imagens da câmera.',
     'sr.hands.slow': 'O controle por gestos está lento neste aparelho e pode não responder.',
     'icon.menu': 'Menu',
@@ -359,6 +384,8 @@ const pt = {
     'pad.glyph.square': 'quadrado',
     'pad.glyph.triangle': 'triângulo',
     'pad.wiz.step': '{n} de {total} — aperte: {acao}',
+    'pad.wiz.stepStart': '{n} de {total} — aperte o botão que você quer como START (ele pausa o jogo)',
+    'pad.wiz.stepSelect': '{n} de {total} — aperte o botão que você quer como SELECT (ele abre os menus)',
     '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.',
@@ -413,6 +440,7 @@ const pt = {
     'audio.noSystemVoices': '(sem vozes do sistema)',
     'sr.tts.engineNoLanguage': 'Este motor ainda não fala este idioma — por enquanto, use a voz do navegador.',
     'sr.tts.noNeuralForLanguage': 'Ainda não há voz neural para este idioma — seguindo com a voz do navegador, que fala a língua certa.',
+    'sr.tts.noVoiceForLanguage': 'Este aparelho não tem voz em {language}: essa parte não é lida em voz alta, mas continua na tela.',
     // ⚠️ NÃO diz «para este idioma» (ADR-0094): sem motor neural nesta montagem, não há voz neural em idioma
     // nenhum, e a outra frase faria a criança trocar de idioma à procura do que não está lá.
     'sr.tts.neuralNotBundled': 'Esta versão do jogo não traz voz neural — seguindo com a voz do navegador.',
@@ -495,12 +523,13 @@ const pt = {
     'audio.cat.earcons': 'Earcons',
     'audio.cat.tts': 'Narração',
     'audio.cat.sonar': 'Sonar',
-    'audio.cat.guard': 'Guarda de beirada',
-    'audio.cat.guide': 'Pista / guia auditivo',
     'audio.cat.volumeDe': 'Volume de {c}',
     'audio.navsound.grupo': 'Sons de navegação',
     'audio.cane': 'Batida da bengala',
     'audio.cane.dica': 'De quanto em quanto chão a bengala bate. Uma batida por bloco é mais calma; a cada meio bloco dá mais detalhe.',
+    // the two positions of the cycle row «◀ Batida da bengala: … ▶» (ADR-0130 rule 3)
+    'audio.cane.block': 'uma por bloco',
+    'audio.cane.halfBlock': 'a cada meio bloco',
     'audio.menuindex': 'Índice falado dos menus',
     'audio.menuindex.dica': 'O leitor de tela diz "3 de 7" ao andar num menu, para saber onde se está sem contar.',
     'audio.tts.dica': 'O jogo lê em voz alta o que está escrito na tela.',
@@ -528,6 +557,7 @@ const pt = {
     'audio.voz': 'Voz',
     'audio.voz.nenhuma': 'Nenhuma voz',
     'audio.semVoz': 'Não há voz que fale este idioma.',
+    'audio.comVoz': 'Agora há uma voz que fala este idioma.',
     'sr.audio.voz': 'Voz: {nome}.',
     'audio.ttsTest': 'Testar a voz',
     'audio.ttsTest.dica': 'Fala uma frase de exemplo com a voz escolhida agora.',
@@ -551,59 +581,31 @@ const pt = {
     'aac.letras': 'Letras maiúsculas',
     'aac.letras.dica': 'Ligado: o jogo inteiro em caixa alta, como a alfabetização brasileira costuma começar. '
         + 'Desligado: maiúsculas e minúsculas, a escrita do dia a dia.',
-    'aac.emPreparo': 'em preparação',
-    'aac.aguardandoNegociacao': 'aguardando negociação',
+    'aac.noLicence': 'sem licença',
     'aac.secao.agora': 'Disponível agora',
     'aac.secao.agoraTag': 'funciona sem rede',
-    'aac.secao.preparo': 'Em preparação',
-    'aac.secao.preparoTag': 'licença resolvida; falta o trabalho',
-    'aac.secao.negociacao': 'Aguardando negociação',
-    'aac.secao.negociacaoTag': 'a permissão não é nossa',
+    'aac.section.pictograms': 'Pictogramas',
+    'aac.section.pictogramsTag': 'cada um só com licença',
     'sr.aac.escolha': 'Comunicação: {v}.',
     'sr.aac.reset': 'Comunicação restaurada ao padrão: letras maiúsculas, como a alfabetização costuma começar.',
     'pause.caa': 'Comunicação',
     'sr.aac.caixaAltaOn': 'Letras maiúsculas ligadas: o jogo inteiro em caixa alta.',
     'sr.aac.caixaAltaOff': 'Letras maiúsculas desligadas: maiúsculas e minúsculas.',
-    'sr.quiz.bemVindo': 'Quiz. Use as setas para escolher e Enter para responder.',
+    // The quiz's welcome: the frame is here, the child's own keys cross as `{mover}`/`{responder}` (consumer-quiz `welcomeText`).
+    'sr.quiz.bemVindo': 'Quiz. Use {mover} para escolher e {responder} para responder.',
+    'sr.quiz.bemVindo.soEscolher': 'Quiz. Use {mover} para escolher.',
+    'sr.quiz.bemVindo.soResponder': 'Quiz. Use {responder} para responder.',
+    'sr.quiz.bemVindo.semTeclas': 'Quiz. Toque numa resposta para responder.',
+    'sr.quiz.teclas.duas': '{a} e {b}',
     // AS PERGUNTAS DO QUIZ. O quiz NÃO é uma disciplina de idioma, logo nem a excepção do `CLAUDE.md` §A FRONTEIRA
     // se aplica: «o ENUNCIADO SEMPRE TRADUZ». Eram literais em pt-BR dentro do cartucho até 23/09, e trocar a
     // bandeira mudava a moldura da engine sem tocar na atividade (ADR-0225).
     'quiz.pageTitle': 'The Inclusionist — quiz de demonstração',
-    'quiz.p1': 'Qual animal põe ovos e tem bico?',
-    'quiz.p1.a': 'Gato',
-    'quiz.p1.b': 'Galinha',
-    'quiz.p1.c': 'Cavalo',
-    'quiz.p1.d': 'Peixe',
-    'quiz.p2': 'Quantos lados tem um triângulo?',
-    'quiz.p2.a': 'Três',
-    'quiz.p2.b': 'Quatro',
-    'quiz.p2.c': 'Cinco',
-    'quiz.p2.d': 'Dois',
-    'quiz.p3': 'Qual destas é uma fruta?',
-    'quiz.p3.a': 'Alface',
-    'quiz.p3.b': 'Cenoura',
-    'quiz.p3.c': 'Banana',
-    'quiz.p3.d': 'Batata',
-    'quiz.pos.up': 'Acima',
-    'quiz.pos.down': 'Abaixo',
-    'quiz.pos.confirm': 'Confirmar',
-    'quiz.comoJogar.ler': 'Leia a pergunta no alto da tela.',
-    'quiz.comoJogar.escolher': 'Escolha a resposta com as setas e confirme.',
-    'quiz.pos.back': 'Voltar',
-    'quiz.pos.sonar': 'Sonar',
-    'quiz.pos.falar': 'Dizer a resposta',
+    'quiz.carregando': 'Carregando…',
     'quiz.ouvindo': 'Estou ouvindo. Diga a resposta.',
-    'quiz.naoEntendi': 'Ouvi «{texto}», que não é nenhuma das alternativas. Diga de novo ou escolha com as setas.',
     'quiz.ouviNada': 'Não ouvi nada. Diga de novo ou escolha com as setas.',
     'quiz.semLeitura': 'Este aparelho não consegue ouvir agora. Escolha com as setas.',
-    'quiz.resposta.certa': 'Certo! {certa}.',
-    'quiz.resposta.errada': 'Ainda não. A resposta certa é {certa}.',
-    'quiz.fim': 'Fim! {n} de {m}.',
     'quiz.alternativas': 'Alternativas',
-    'quiz.acom.hints': 'Dicas',
-    'quiz.acom.textPace': 'Ritmo do texto',
-    'quiz.acom.lexicalDifficulty': 'Dificuldade das palavras',
-    'quiz.acom.wordHighlight': 'Realce de palavras',
     'sr.nav.sonarFound': 'Sonar: {alvo} {lado}, {dist}.',
     // `sr.nav.coin` ficou para o JOGO nomear o alvo (item 19): o sonar recebe o nome por `nameAt`, campo 3 do
     // contrato. `sr.nav.target` e o que ele diz quando o jogo declara um alvo SEM nome — melhor uma palavra
@@ -686,13 +688,6 @@ const pt = {
     'sr.motor.easyOff': 'Modo Fácil desligado.',
     'sr.motor.toggleMoveOn': 'Não precisa segurar, ligado: um toque liga e outro desliga.',
     'sr.motor.toggleMoveOff': 'Não precisa segurar, 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.',
     // ===================== AJUDA (menu de pausa) + rótulo de nível =====================
@@ -777,7 +772,6 @@ const pt = {
     '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.',
@@ -793,8 +787,9 @@ const pt = {
     // ⚠️ 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.notice.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. '
+        + 'Sem elas, o jogo mostra a Cookie: uma letra ligada parecida, mas que não é a ronde da escola.',
     'font.desc.greatvibes': 'caligráfica inglesa',
     'font.desc.pinyon': 'caligráfica inglesa',
     'font.desc.ufcook': 'blackletter alemã',

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

@@ -5,7 +5,6 @@ import { type PadMaps } from './pad-wizard.js';
 import type { PadTableFor } from './pad-defaults.js';
 import type { LiveInput } from './state.js';
 import { type PadLike, type GetGamepads, type PadMap, type ActionKey } from './pad-reading.js';
-export type { DomQuery } from '../core/dom-query.js';
 /**
  * The ORDER in which the wizard asks. ONLY the order — the same list `input/pad-wizard` walks, where it lives apart
  * from any game (issue #182).
@@ -17,7 +16,8 @@ export type { DomQuery } from '../core/dom-query.js';
  *
  * ⚠️ AND AN ACTION THE GAME DOES NOT NAME IS NOT ASKED. `input/pad-wizard` skips it, because a game that does not use
  * the position has nothing to map on it — and asking would produce a mute step or, worse, a step saying `action7` out
- * loud.
+ * loud. The exception is the system's two: START and SELECT are always asked, in the engine's words, because no game may
+ * name them and no pad may lack them (ADR-0144, erratum of 2026-09-26).
  */
 export declare const PADWIZ_ORDER: readonly string[];
 interface WizBase {
@@ -46,15 +46,14 @@ export interface WizState {
 import type { NavKeys } from './edges.js';
 import type { ModalIntent } from './keydown.js';
 import type { DomQuery } from '../core/dom-query.js';
-export type { NavKeys } from './edges.js';
 /** The minimal player shape this module reads/writes — DERIVED from core/entity, not retyped. There is no `quiz`
  *  here (ADR-0033): the question is `ctx.hasModal(i)` and the answer is an INTENT, so this module never reads the
  *  game's object. */
 export type GamepadPlayer = PlayerView<'pad' | 'quit' | 'waiting' | 'easy' | 'jumpEdge' | 'runEdge' | 'leftEdge' | 'rightEdge' | 'swapEdge' | 'specialEdge'>;
 /**
  * WHAT ONLY THE CARTRIDGE KNOWS ABOUT ITS WORLD (ADR-0224). The engine mounts this transport — as it mounts touch, the
- * eyes, the face, the hands, the voice and the scan —, and 📏 of `GamepadCtx`'s 25 doors the root answers 23 with what
- * it already has. These are the ones left, and they are the ones nothing in the engine can know.
+ * eyes, the face, the hands, the voice and the scan —, and the root answers every door of `GamepadCtx` it can with what it
+ * already has. These are the ones left, and they are the ones nothing in the engine can know.
  *
  * 🎯 **ALL OPTIONAL, AND EVERY ABSENCE HAS A WRITTEN MEANING** — never guessed (ADR-0113 clause 3, ADR-0169). A
  * cartridge that declares nothing has a working pad; what depends on its world simply does not happen. Refusing the
@@ -154,9 +153,15 @@ export interface GamepadCtx {
     worldRunning: () => boolean;
     /** Is the pause menu open? (START here RESUMES.) */
     pauseMenu: () => boolean;
-    /** Pause and resume. The root stacks the scene; only the intent leaves from here. */
+    /**
+     * Pause and resume. The root stacks the scene; only the intent leaves from here. ⚠️ `pause` carries no seat: it is the
+     * mapping wizard's, which stops everything while a pad is mapped. START in play is PRESSED for the pad's seat (`press`).
+     * `resume` names the seat whose START asks it — the wizard's own resume is seat 0's, whose quick pause `pause` opened —, because
+     * the root decides whether that seat's START reaches this screen's pause: on a shared screen only the first seat's does
+     * (ADR-0144, erratum of 2026-09-26).
+     */
     pause: () => void;
-    resume: () => void;
+    resume: (seat: number) => void;
     /** Demonstration (attract) mode. */
     isAttractActive: () => boolean;
     stopAttract: () => void;
@@ -174,6 +179,12 @@ export interface GamepadCtx {
     navBar: (i: number, k: NavKeys, hasStart: boolean) => void;
     sharedDialogOpen: () => HTMLElement | null;
     navDialog: (dlg: HTMLElement, k: NavKeys) => void;
+    /**
+     * Does this seat's pad steer the menus open on this screen — the dialog on top and the pause card? On a screen several players
+     * share, only the first's does (ADR-0144, erratum of 2026-09-26): another seat's d-pad and buttons move, press and close
+     * nothing there. Absent: every seat's does — each has a screen of her own. The same question `ui/menu-nav` asks of a key.
+     */
+    leadsTheScreen?: (seat: number) => boolean;
     /** The player's pause screen. `HTMLElement` and not `{ hidden: boolean }`: the structural minimum works for READING,
      *  but this module HANDS the menu to `navPause`, which needs the whole element — and in parameter position the
      *  minimal slice inverts (ADR-0039). */
@@ -185,9 +196,10 @@ export interface GamepadCtx {
      * THIS EDGE IS THIS PLAYER'S, AND IT CAME FROM THE PAD (ADR-0113 clause 4, issue #127).
      *
      * 🔴 REQUIRED: without it the input state's `playerEdge` has no caller for the pad, so `inputOf(i).inUse` answers
-     * `teclado` for everyone — and the latch read is the keyboard's even with the pad in hand. 📌 Pass
-     * `createLatchedEdge(() => players, { store, input })` from `input/latch-edge`, not the raw one: it also resolves this
-     * device's latch on the player.
+     * `teclado` for everyone — and the latch read is the keyboard's even with the pad in hand. 📌 The latch is resolved where the
+     * pad's press lands: the root's virtual controller tells `pressedBy`, which records this edge through `input/latch-edge` too,
+     * so the root passes the raw one here. A host whose `press` does not reach such a door passes
+     * `createLatchedEdge(() => players, { store, input, holdsKeys })` instead.
      *
      * ⚠️ The gamepad is the transport that stays identifiable without the key set — it goes through `padCur` —, and that
      * is exactly why a gap here is invisible: the module knows which pad the edge came from, and the automaton does not.
@@ -204,9 +216,17 @@ export interface GamepadCtx {
      * 📌 REQUIRED, and ADR-0223's erratum says why: an optional door is one more field a game can forget, and forgetting
      * it brings back the silence this work exists to end. The root passes its virtual controller's `press`.
      */
-    press: (action: ActionKey, source: 'gamepad', player: number) => boolean;
+    press: (action: ActionKey | 'start' | 'select', source: 'gamepad', player: number) => boolean;
     /** Release the POSITION. The controller lets go of the key it held and delivers the release — only for a press the game heard. */
     release: (action: ActionKey, source: 'gamepad', player: number) => void;
+    /**
+     * ONE BUTTON ONLY (ADR-0218 §4): asked once per frame in which a button of a pad WENT DOWN — a position, START or SELECT.
+     * `true`: one-button scanning took it as «take the one shown», and nothing else of that pad's frame happens. It is the question
+     * the virtual controller asks of every press (`takeShown` there); the pad asks it too because it also steers the pause card,
+     * a panel, the quick bar and the title, and opens and leaves the pause, by itself and without pressing a position.
+     * Absent: every press is itself.
+     */
+    takeShown?: () => boolean;
     /**
      * The player's OWN modal: the engine delivers the INTENT, the game decides (ADR-0033).
      *
@@ -229,6 +249,16 @@ export interface GamepadCtx {
     wizardStep: (position: string | null) => void;
     /** One tick of the wizard's clock for that demonstration (`GamepadGameHooks.wizardTick`). */
     wizardTick: () => void;
+    /**
+     * THIS TRANSPORT'S OWN WIZARD HAS CLOSED (ADR-0248), whichever way it ended — saved, cancelled, or closed by the root. Called
+     * once per close, AFTER `#padwiz` is hidden and after the resume of a game the wizard paused, so whoever owns the focus
+     * returns it to what is really in front. The root answers by giving the focus back to whoever held it when the wizard
+     * opened (`overlays.restoreFocus('padwiz')`).
+     * 🔴 REQUIRED (ADR-0248, as ADR-0224 did for the door): the code that knows the wizard ended is this module, the code that owns
+     * the focus is the root — an optional port is one more field a game can forget, and forgetting it drops a screen-reader
+     * child's focus on `<body>`.
+     */
+    wizardClosed: () => void;
 }
 export interface GamepadApi {
     pollPads(): void;
@@ -241,3 +271,4 @@ export interface GamepadApi {
     getPadWiz(): WizState | null;
 }
 export declare function initGamepad(ctx: GamepadCtx): GamepadApi;
+export {};

package/dist-pkg/input/gamepad.js

@@ -20,8 +20,8 @@ import { createPadWizard, PADWIZ_ORDER as ORDEM_DO_ASSISTENTE } from './pad-wiza
 // 🔴 WHAT A PAD IS DOING lives in `input/pad-reading`: it is the PURE half — buttons and axes in, positions out. Here
 // is the wiring, which can only be read with a ctx in hand: the conductor that polls the pads every frame and decides
 // where the reading goes.
-// ⚠️ NO ALIAS: a re-export would keep alive a path the surface snapshot does not see, and the migration note is what
-// says where each name went.
+// ⚠️ NO ALIAS: a re-export would keep alive a published path nothing in the engine imports (issue #204), and the
+// migration note is what says where each name went.
 import { padActions, oneButtonAtOnce, } from './pad-reading.js';
 // ---------------------------------------------------------------------------------------------
 // Wizard data (the ORDER of the steps; the WORDS and the demonstration come from the game)
@@ -37,7 +37,8 @@ import { padActions, oneButtonAtOnce, } from './pad-reading.js';
  *
  * ⚠️ AND AN ACTION THE GAME DOES NOT NAME IS NOT ASKED. `input/pad-wizard` skips it, because a game that does not use
  * the position has nothing to map on it — and asking would produce a mute step or, worse, a step saying `action7` out
- * loud.
+ * loud. The exception is the system's two: START and SELECT are always asked, in the engine's words, because no game may
+ * name them and no pad may lack them (ADR-0144, erratum of 2026-09-26).
  */
 export const PADWIZ_ORDER = ORDEM_DO_ASSISTENTE;
 /**
@@ -121,7 +122,7 @@ export function initGamepad(ctx) {
             const ov = ctx.$('#padwiz');
             if (ov)
                 ov.hidden = true;
-            // no phantom edges: the button still HELD from the last step (START) must not pause or act on resume
+            // no phantom edges: the button still HELD from the last step (SELECT) must not open the menus or act on resume
             try {
                 const pads = ctx.getGamepads() ?? [];
                 const gp = pads[gi];
@@ -136,8 +137,10 @@ export function initGamepad(ctx) {
             if (padWizAutoResume) {
                 padWizAutoResume = false;
                 if (ctx.pauseMenu())
-                    ctx.resume();
+                    ctx.resume(0);
             }
+            // last: the overlay is hidden and the game resumed, so the focus goes back to what is really in front (ADR-0248)
+            ctx.wizardClosed();
         },
     });
     function openPadWiz() {
@@ -179,6 +182,7 @@ export function initGamepad(ctx) {
         const startEdge = cur._start && !padPrevStart[gi];
         padPrevStart[gi] = cur._start;
         const pauseEdge = cur._pause && !prev._pause;
+        const selectEdge = !!cur.select && !prev.select;
         const edge = (k) => cur[k] && !prev[k];
         const released = (k) => !!prev[k] && !cur[k];
         padCur[gi] = cur;
@@ -189,7 +193,7 @@ export function initGamepad(ctx) {
             yes: edge('action2') || (withStart && startEdge), no: edge('action3'),
             up: edge('up'), down: edge('down'), left: edge('left'), right: edge('right'),
         });
-        return { gp, gi, owner, players, cur, startEdge, pauseEdge, edge, released, navKeys };
+        return { gp, gi, owner, players, cur, startEdge, pauseEdge, selectEdge, edge, released, navKeys };
     }
     /** Did any of the six menu intents happen this frame? */
     // 📌 The `!!` is what `NavKeys` asks for: its six fields are OPTIONAL, because not every transport produces them all.
@@ -227,21 +231,36 @@ export function initGamepad(ctx) {
         } // only P1 chooses
         ctx.navTitle(k); // the title menu, navigable by pad
     }
-    /** The pause card: START resumes, and the d-pad navigates the shared dialog or the seat's own menu. */
+    /** A menu is open: START resumes, action 4 is pressed, and the d-pad navigates the quick bar, the shared dialog or the seat's own card. */
     function steerPause(f) {
+        const pi = f.owner < 0 ? 0 : f.owner;
         if (f.pauseEdge) {
-            ctx.resume();
+            ctx.resume(pi);
+            return;
+        } // START resumes — if this seat's START reaches this screen's pause (the root's)
+        if (ctx.leadsTheScreen && !ctx.leadsTheScreen(pi))
+            return; // another seat of a shared screen steers none of its menus
+        // ACTION 4 IS PRESSED, as the keyboard's key rises: no menu intent reads it, and the controller hands it to the menus as the
+        // seat's key, which the root answers where it answers the keyboard's — in the quick pause, the menus' second door (ADR-0155
+        // erratum «Ambos»). The pad decides nothing about it; one frame, one door, as SELECT.
+        if (f.edge('action4')) {
+            ctx.press('action4', 'gamepad', pi);
             return;
-        } // START resumes
+        }
         const k = f.navKeys();
         if (!anyIntent(k))
             return;
+        // THE QUICK BAR FIRST, in the order `ui/menu-nav` steers a key: the quick pause (ADR-0155 §1) is a menu, so its frames come
+        // HERE and never reach `steerGame`'s bar. START was answered above, so the bar's exits here are back, and START by `resume`.
+        if (ctx.onBar(pi)) {
+            ctx.navBar(pi, k, false);
+            return;
+        }
         const dlg = ctx.sharedDialogOpen();
         if (dlg) {
             ctx.navDialog(dlg, k);
             return;
         }
-        const pi = f.owner < 0 ? 0 : f.owner;
         const menu = ctx.getPauseMenu(pi);
         if (menu && !menu.hidden)
             ctx.navPause(menu, pi, k);
@@ -297,11 +316,14 @@ export function initGamepad(ctx) {
     }
     /** The real game: START pauses, the modal eats the d-pad, and the rest becomes an action flag. */
     function playRound(f, p) {
+        // START IS PRESSED FOR THIS PAD'S SEAT, as SELECT is: the virtual controller hands it to the engine (`systemPress`), which
+        // answers it as that seat's START key — its own quick pause, and START again leaves it (ADR-0155, ADR-0144 §1 and its
+        // erratum of 2026-09-26). A seatless `pause()` here froze seat 0's quick pause whoever pressed.
         if (f.pauseEdge) {
-            ctx.pause();
+            ctx.press('start', 'gamepad', f.owner);
             ctx.setPauseActor(f.owner);
             return;
-        } // START pauses (everyone pauses; each screen navigates its own)
+        }
         if (ctx.hasModal(f.owner)) { // the pad navigates the player's OWN modal (the others' game goes on)
             // What left this module is the MEANING — the grid's ±1/±3 and the Braille detour, which are the game's decision.
             const hit = MODAL_BY_POSITION.find(([position]) => f.edge(position));
@@ -339,12 +361,14 @@ export function initGamepad(ctx) {
         // that is the game's, because while the mode is on nothing else from this pad is the game's.
         //
         // Both exits arrive together: `especial` (action 3) is the project's BACK — the east button: B on Xbox, ◯ on
-        // PlayStation, A on Nintendo — and `startEdge` is the button that opens the pause, where this was entered. A child
+        // PlayStation, A on Nintendo — and `pauseEdge` is the button that opens the pause, where this was entered. A child
         // who is lost goes back the way they came, one who knows the game tries the usual back; both work.
+        // ⚠️ START ALONE, not `startEdge`: that one fires on action 2 too («close a dialog»), and passed here it made the confirm
+        // LEAVE the bar instead of pressing the icon under the cursor.
         if (f.owner >= 0 && ctx.onBar(f.owner)) {
             const k = f.navKeys();
-            if (f.startEdge || anyIntent(k))
-                ctx.navBar(f.owner, k, !!f.startEdge);
+            if (f.pauseEdge || anyIntent(k))
+                ctx.navBar(f.owner, k, f.pauseEdge);
             return;
         }
         if (f.owner < 0) {
@@ -367,6 +391,8 @@ export function initGamepad(ctx) {
             ctx.stopAttract();
         return true;
     }
+    /** Did a button go down on this frame — any position, START or SELECT? A button held is one press, not one a frame. */
+    const wentDown = (f) => f.startEdge || f.pauseEdge || f.selectEdge || PAD_POSITIONS.some((k) => f.edge(k));
     /** A physical button used -> the on-screen pad goes away (the keyboard's rule): any of the nine positions read. */
     function hideTouchPadIfHeld(f) {
         if (ctx.isTouchMode() && (f.cur._start || PAD_POSITIONS.some((k) => f.cur[k])))
@@ -378,6 +404,13 @@ export function initGamepad(ctx) {
      * screen), the pad should navigate as on the title — the safe behaviour — instead of doing nothing.
      */
     function steerFrame(f) {
+        // SELECT OPENS THE MENUS wherever the keyboard's F does — in play and in the quick pause (ADR-0155) — and it is PRESSED,
+        // not decided here: the virtual controller hands the position to the engine, which answers it as F (ADR-0144 §1). An open
+        // card or panel refuses it there. A pad nobody has seated yet is seat 0's, as on the pause card below.
+        if (f.selectEdge) {
+            ctx.press('select', 'gamepad', f.owner < 0 ? 0 : f.owner);
+            return;
+        }
         if (ctx.pauseMenu())
             steerPause(f);
         else if (ctx.worldRunning())
@@ -402,6 +435,8 @@ export function initGamepad(ctx) {
             const f = readPad(gp, ctx.getPlayers());
             releaseWhatCameUp(f); // before every branch: the finger leaves the button wherever it likes (ADR-0223)
             hideTouchPadIfHeld(f);
+            if (wentDown(f) && ctx.takeShown?.())
+                continue; // one button only: the button is the switch (ADR-0218 §4)
             if (!winOverlayTook(f))
                 steerFrame(f);
         }

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

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** The part of a key event's target this reads — an `Element` satisfies it; `window`/`document` have no `closest`. */
+export interface KeyTargetLike {
+    readonly isContentEditable?: boolean;
+    closest?(selector: string): unknown;
+}
+/** The keys a focused button answers natively: Enter presses it on the key's press, Space on its release. */
+export declare const BUTTON_ACTIVATION_KEYS: ReadonlySet<string>;
+/**
+ * Whether a key pressed with the focus on `target` is being typed into a field — input, textarea, select or contenteditable, in
+ * the game region or anywhere on the page. Then every key is the field's: Enter and every character.
+ *
+ * 📌 ASKED BY THE ENGINE'S SYSTEM KEYS TOO, and not only by the delivery. START and SELECT never reach play, so they never pass
+ * through `keyGoesToGame`: their own listeners (`boot/create-game`) ask this. 📏 Before they did, Enter typed into a text field
+ * opened the quick pause, and «half» typed into one paused on the `h` and opened the menus on the `f`.
+ */
+export declare function keyTypedIntoField(target: KeyTargetLike | null): boolean;
+/**
+ * Whether the key `code` presses the engine's own control that has the focus (`ownControls`, a selector): Space or Enter on it.
+ *
+ * 📌 ASKED BY THE QUICK PAUSE TOO, and not only by the delivery. `Enter` is `start`, and START in play opens the quick pause — so
+ * Enter on a focused ☰ paused instead of pressing ☰, while Space pressed it (📏 measured on the served quiz). A focused button is
+ * activated by Enter as well as Space; that press is the button's, and the pause does not take it.
+ */
+export declare function keyPressesOwnControl(code: string, target: KeyTargetLike | null, ownControls: string): boolean;
+/**
+ * Whether the key `code`, pressed with the focus on `target`, is play's to hear. `false`: it belongs to what has the focus — a
+ * field, or the engine's own control it activates (`ownControls`, a selector) — and keeps its default.
+ */
+export declare function keyGoesToGame(code: string, target: KeyTargetLike | null, ownControls: string): boolean;

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

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// input/key-default — WHICH KEY THE GAME HEARS, AND WHICH KEEPS ITS BROWSER DEFAULT (ADR-0111 errata of 2026-09-26).
+//
+// The engine owns the keyboard (ADR-0111): it turns a key into a position and carries the position to the game. One key press
+// is one action, and that makes two rules, which are one rule seen from two sides:
+//   · A KEY THE GAME HEARD IS SPENT. The keyboard conductor cancels its default, or Space on a focused `<button>` was the game's
+//     `action2` AND the button's click on the release.
+//   · A KEY THAT WENT TO SOMETHING ELSE IS NOT ALSO PLAYED. It keeps its default, and the game does not hear it. That is what
+//     this module answers, before the engine delivers:
+//       · a key typed into an editable field (input, textarea, select, contenteditable): typing is the field's;
+//       · a key that ACTIVATES one of the engine's own focused controls (`ownControls`, the accessibility bar, in the tab order
+//         in play): Space and Enter press a focused button, and that press is the control's.
+//     📏 Both used to keep their default AND be delivered. On the served quiz, Space on ☰ opened the menus and answered a
+//     question; Space typed into a text field answered one too.
+//
+// 📌 ONLY THE ACTIVATION KEYS on the engine's control, and not every key: a focused button does nothing native with an arrow or
+// a letter, so an arrow pressed after Tab left the focus on ☰ is still the child moving in the game — held back, it would be
+// lost, and the game would stop answering until she clicked somewhere else.
+//
+// Not decided here: a key refused by an open menu, or consumed by the engine's menus, is the menus' (`input/virtual-controller`,
+// `ui/menu-nav`); a key mapped to no position was never the game's.
+//
+// Pure: it is told the key and where the focus was; it answers a decision. No document, no event.
+const EDITABLE = 'input, textarea, select';
+/** The keys a focused button answers natively: Enter presses it on the key's press, Space on its release. */
+export const BUTTON_ACTIVATION_KEYS = new Set(['Space', 'Enter', 'NumpadEnter']);
+/**
+ * Whether a key pressed with the focus on `target` is being typed into a field — input, textarea, select or contenteditable, in
+ * the game region or anywhere on the page. Then every key is the field's: Enter and every character.
+ *
+ * 📌 ASKED BY THE ENGINE'S SYSTEM KEYS TOO, and not only by the delivery. START and SELECT never reach play, so they never pass
+ * through `keyGoesToGame`: their own listeners (`boot/create-game`) ask this. 📏 Before they did, Enter typed into a text field
+ * opened the quick pause, and «half» typed into one paused on the `h` and opened the menus on the `f`.
+ */
+export function keyTypedIntoField(target) {
+    if (!target || typeof target.closest !== 'function')
+        return false;
+    return !!target.isContentEditable || !!target.closest(EDITABLE);
+}
+/**
+ * Whether the key `code` presses the engine's own control that has the focus (`ownControls`, a selector): Space or Enter on it.
+ *
+ * 📌 ASKED BY THE QUICK PAUSE TOO, and not only by the delivery. `Enter` is `start`, and START in play opens the quick pause — so
+ * Enter on a focused ☰ paused instead of pressing ☰, while Space pressed it (📏 measured on the served quiz). A focused button is
+ * activated by Enter as well as Space; that press is the button's, and the pause does not take it.
+ */
+export function keyPressesOwnControl(code, target, ownControls) {
+    if (!target || typeof target.closest !== 'function')
+        return false;
+    return BUTTON_ACTIVATION_KEYS.has(code) && !!target.closest(ownControls);
+}
+/**
+ * Whether the key `code`, pressed with the focus on `target`, is play's to hear. `false`: it belongs to what has the focus — a
+ * field, or the engine's own control it activates (`ownControls`, a selector) — and keeps its default.
+ */
+export function keyGoesToGame(code, target, ownControls) {
+    if (!target || typeof target.closest !== 'function')
+        return true; // no element had the focus: nothing else to go to
+    return !keyTypedIntoField(target) && !keyPressesOwnControl(code, target, ownControls);
+}

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

@@ -2,10 +2,6 @@
 import type { ControlledPlayer } from '../core/entity.js';
 import type { KeyScheme } from '../core/entity.js';
 import type { KBDefaults } from '../input/keyboard.js';
-/** action -> list of physical key codes (KeyboardEvent.code), e.g. {action2:['KeyJ','Space']}. It lives in `core/entity`,
- *  whose `ctrl: KeyScheme | null` makes it the owner — the same line was once written in six modules. Re-exported for
- *  whoever already imported it from here. */
-export type { KeyScheme } from '../core/entity.js';
 /** `input/keyboard`'s `KBDefaults` ({solo,p2,p3,p4}), which owns it. The local name survives because consumers use it. */
 export type KeyboardConfig = KBDefaults;
 /** Minimal player shape this module needs: only `ctrl` is read/written — derived from core/entity.

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

@@ -6,7 +6,6 @@ import type { KeyScheme } from '../core/entity.js';
  * touches it, not a module import — a test hands in its own, and two roots never write each other's map.
  */
 export type KeyboardStore = Pick<Store, 'getJSON' | 'setJSON' | 'remove'>;
-export type { KeyScheme } from '../core/entity.js';
 /**
  * THE SET OF keyboard SCHEMES — solo plus those for 2, 3 and 4 players.
  *