@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/input/gamepad.js

@@ -2,617 +2,444 @@
 // input/gamepad.ts — gamepad READING (stdDirs/padActions/bindActive/padMapFor) + the poll dispatcher
 // (pollPads) + the accessibility MAPPING WIZARD (openPadWiz/openPadWizFor/closePadWiz/padWizTick). Pure
 // button->action logic is separated from the DI runtime (initGamepad(ctx)): the Gamepad API is injected
-// (ctx.getGamepads, so tests feed a fake pad with no browser) and every cross-subsystem call (menu nav, quiz,
-// join/respawn, phase, overlays) is injected too — never reaches `document`/`navigator` or imports game.js.
+// (ctx.getGamepads, so tests feed a fake pad with no browser) and every cross-subsystem call (menu nav, modal,
+// join/respawn, pause, overlays) is injected too — it never reaches `document`/`navigator`.
 // Boundary: this module only READS buttons/axes and maps them to actions; the physical button ARTWORK/labels
-// (PAD_DESIGNS) and the on-screen touch pad are input/devices.ts + input/touch (a parallel extraction) — not here.
-import { t } from '../core/i18n.js';
+// (PAD_DESIGNS) and the on-screen touch pad are input/devices.ts + input/touch — not here.
 import { EDGE_BY_ACTION, edgeAllowed } from './edges.js';
-import { migrarMapaDeControle } from './vocabulary-migration.js';
-import { GAMEPAD_STANDARD } from './default-bindings.js';
-import { tabelaDoPad } from './pad-defaults.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];
-    return typeof v === 'object' && v !== null ? v : undefined;
-}
-// [axisValue, up, down, left, right] — os 8 passos de um D-pad "POV hat" (eixo alto do DirectInput), repouso ~1.286.
-const HAT_STEPS = [
-    [-1, 1, 0, 0, 0], [-0.7143, 1, 0, 0, 1], [-0.4286, 0, 0, 0, 1], [-0.1429, 0, 1, 0, 1],
-    [0.1429, 0, 1, 0, 0], [0.4286, 0, 1, 1, 0], [0.7143, 0, 0, 1, 0], [1, 1, 0, 1, 0],
-];
-/** Direções pelas FONTES PADRÃO: stick 0/1 (zona morta PAD_DEAD), D-pad 12-15, e o "hat" nos eixos >=6 (POV do
- *  DirectInput). Controles com os dois direcionais mapeados ficam com ambos vivos (dedo no stick não mata o D-pad). */
-export function stdDirs(gp) {
-    const b = (i) => !!(gp.buttons[i] && gp.buttons[i].pressed);
-    const ax = (i) => gp.axes[i] || 0;
-    const d = { left: ax(0) < -PAD_DEAD || b(14), right: ax(0) > PAD_DEAD || b(15), up: ax(1) < -PAD_DEAD || b(12), down: ax(1) > PAD_DEAD || b(13) };
-    for (let i = 6; i < gp.axes.length; i++) {
-        const v = gp.axes[i];
-        if (typeof v !== 'number' || Math.abs(v) > 1.001)
-            continue; // fora do repouso do hat
-        for (const [hv, u, dn, l, r] of HAT_STEPS) {
-            if (Math.abs(v - hv) <= 0.09) {
-                if (u)
-                    d.up = true;
-                if (dn)
-                    d.down = true;
-                if (l)
-                    d.left = true;
-                if (r)
-                    d.right = true;
-                break;
-            }
-        }
-    }
-    return d;
-}
-/** Está o binding `bd` ativo agora neste gamepad? Digital = pressed; analógico ({ax,s}) = limiar por sinal
- *  (metade do curso); hat ({av,v}) = valor exato do passo (±0.13 — os 8 passos distam ~0.286). */
-export function bindActive(gp, bd) {
-    if (!bd)
-        return false;
-    if (bd.b != null)
-        return !!(gp.buttons[bd.b] && gp.buttons[bd.b].pressed);
-    if (bd.ax != null)
-        return ((gp.axes[bd.ax] || 0) * (bd.s ?? 0)) > 0.5;
-    if (bd.av != null)
-        return Math.abs((gp.axes[bd.av] || 0) - (bd.v ?? 0)) <= 0.13;
-    return false;
-}
-/** 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 function padActions(gp, custom, tabela = GAMEPAD_STANDARD) {
-    if (custom && !custom._skip) {
-        const A = (k) => bindActive(gp, bindingAt(custom, k));
-        const sd = stdDirs(gp);
-        return {
-            left: A('left') || sd.left, right: A('right') || sd.right, up: A('up') || sd.up, down: A('down') || sd.down,
-            action2: A('action2'), action1: A('action1'), action4: A('action4'), action3: A('action3'), _start: A('action2') || A('start'), _pause: A('start'),
-        };
-    }
-    const b = (i) => !!(gp.buttons[i] && gp.buttons[i].pressed);
-    const sd = stdDirs(gp);
-    // ⚠️ OS ÍNDICES SAEM DA TABELA DECLARADA, e não de literais aqui. Enquanto eram literais, esta linha e
-    // `input/default-bindings` DISCORDAVAM e nada notava — a mesma forma de defeito que o gate do toque
-    // apanhou: duas tabelas que concordam entre si não provam nada sobre um terceiro que as lê.
-    //
-    // ⚠️ E A DISCORDÂNCIA ERA REAL: aqui estava `action1: b(2) || b(5) || b(7)`, ou seja X, R1 e R2 todos a
-    // correr, enquanto a tabela declara R1 como `rightShoulder` e R2 como `rightTrigger`. O ADR-0086 registrou
-    // esta mudança como o asterisco do seu «zero movimento»: nenhum VERBO muda de botão, mas `run` perde dois
-    // dos seus três. Quem usava R1 para correr sente — e é o preço de os quatro ombros existirem.
-    // 📌 A TABELA CHEGA POR PARÂMETRO desde o ADR-0115: é a fábrica da engine COM o padrão deste jogo por cima,
-    // resolvida em `input/pad-defaults`. O padrão da assinatura é o da engine, então quem chamava com dois
-    // argumentos continua a ler exactamente o que lia.
-    // ⚠️ E ela só decide neste ramo, que é o certo: o ramo de cima é o mapa que a CRIANÇA gravou no assistente,
-    // e o padrão de um jogo não se sobrepõe a uma escolha dela.
-    const B = tabela;
-    const at = (a) => { const i = B[a]; return typeof i === 'number' ? b(i) : false; };
-    return {
-        left: sd.left, right: sd.right, up: sd.up, down: sd.down,
-        action1: at('action1'), action2: at('action2'), action3: at('action3'), action4: at('action4'),
-        leftShoulder: at('leftShoulder'), leftTrigger: at('leftTrigger'),
-        rightShoulder: at('rightShoulder'), rightTrigger: at('rightTrigger'),
-        // ⚠️ `start` COMO POSIÇÃO, e não só como os derivados abaixo. Faltava, e o gate da tabela foi quem
-        // o encontrou: quem quisesse saber «o START está apertado?» tinha de ler `_start`, que começa por
-        // underscore e quer dizer outra coisa (fecha diálogo, e aceita a ação 2 também).
-        start: at('start'), select: at('select'),
-        // `_start` e `_pause` são DERIVADOS e não posições: «fecha diálogo» aceita a ação 2 ou o START, «pausa»
-        // só o START. Ficam escritos aqui porque descrevem o que a raiz faz com duas posições, não uma terceira.
-        _start: at('action2') || at('start'), _pause: at('start'),
-    };
-}
+import { createPadWizard, PADWIZ_ORDER as ORDEM_DO_ASSISTENTE } from './pad-wizard.js';
+// 📌 The pad's frame memory, the stored maps and the game's button table arrive through the ctx, built once by the root
+// (ADR-0232 D4): as module state, two roots on one page shared a pad's previous frame and each other's maps.
+// 📌 `oneButton` (the motor empathy's one-button mode, issue #120) arrives through the ctx, as `input/keydown`'s does:
+// the settings store is built by the root and passed in (ADR-0232, issue #207). The field is REQUIRED, which is what the
+// old live import defended — an optional field would make the accommodation exist only where someone remembered it
+// (ADR-0077's M3 argument); a required one does not compile without it.
+// ---------------------------------------------------------------------------------------------
+// Gamepad API surface (minimal, adapter-friendly — mirrors the real Gamepad/GamepadButton shape)
 // ---------------------------------------------------------------------------------------------
-// Wizard data (a ORDEM dos passos + a animação de demonstração; as PALAVRAS vêm do jogo)
+// 🔴 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 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)
 // ---------------------------------------------------------------------------------------------
 /**
- * A ORDEM em que o assistente pergunta. SÓ a ordem.
- *
- * ⚠️ 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.
+ * 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).
  *
- * 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.
+ * ⚠️ NO WORDS HERE: the word comes from `ctx.actionLabel`, which the game supplies through its preset (ADR-0074 —
+ * platformer vocabulary, in one language, inside the engine was the defect this removed). What stays is what really
+ * is the engine's: the sequence of the questions — directions first, actions next, system last —, an ergonomic
+ * decision of the wizard and not of the game.
  *
- * ⚠️ 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.
+ * ⚠️ 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. 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;
 /**
- * AS POSIÇÕES QUE O MODO DE UM BOTÃO NÃO CORTA. Pausar é a SAÍDA, não uma jogada.
+ * WHAT EACH ABSENCE MEANS, AS DATA (ADR-0224). A table and not ten `??` scattered through whoever mounts: the meaning
+ * of an absence is a DECISION, and a composition root should hold only wiring — ten decisions in it are ten branches in
+ * a function the ratchet already watches (ADR-0221, erratum).
  *
- * ⚠️ 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.
+ * ⚠️ `worldRunning` is not here because its absence has no universal answer: it depends on whoever mounts knowing
+ * which menus they have open. It comes in as a parameter, which also makes it the only absence a host can answer.
  */
-const FORA_DO_CORTE = new Set(['start', 'select', '_start', '_pause']);
+const SILENT_PAD_ANSWERS = Object.freeze({
+    navTitle: () => { }, // no title screen to navigate
+    attractActive: () => false, // no demonstration running
+    stopAttract: () => { }, // so nothing to stop
+    hasModal: () => false, // no open challenge: the d-pad belongs to the game
+    modalInput: () => { }, // and so nothing to feed
+    joinPlayer: () => false, // nobody joins a running game midway
+    respawnPlayer: () => { }, // an abandoned screen stays abandoned
+    clearWaitingBadge: () => { }, // the waiting badge is the game's HUD; with no game declaring it, it does not exist
+    wizardStep: () => { }, // the mapping wizard speaks, with no drawing
+    wizardTick: () => { }, // and so nothing animates
+});
 /**
- * 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á.
+ * The cartridge's answers with every absence already resolved. 📌 A field DECLARED as `undefined` is an absence like any
+ * other — spreading the raw object over the table would erase the answer with an `undefined`, which is the silent
+ * defect this function exists not to have.
+ */
+export function padGameAnswers(hooks, worldRunningWhenSilent) {
+    const declared = {};
+    for (const [name, answer] of Object.entries(hooks ?? {}))
+        if (answer !== undefined)
+            declared[name] = answer;
+    return { worldRunning: worldRunningWhenSilent, ...SILENT_PAD_ANSWERS, ...declared };
+}
+/**
+ * THE SEAT FIELDS, SEEDED BY THE ENGINE (ADR-0224). 📏 Measured: the players a cartridge declares are
+ * `{ ctrl, audioSink? }`, and this transport needs to know whose each pad is (`pad`), who is still waiting (`waiting`)
+ * and who left the screen (`quit`).
  *
- * 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.
+ * 🔴 IT SEEDS THE OBJECT ITSELF and returns the SAME list — copying would lose the seat on the next frame, because
+ * `takeSeat` writes into this object. That is also why there is no `.map`: the identity is what carries the state.
+ * 📌 It only touches whoever does not have the fields yet, so a cartridge that declares them keeps its own.
  */
-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 function seatEveryPlayer(list) {
+    for (const p of list) {
+        const seat = p;
+        seat.pad ??= -1;
+        seat.waiting ??= false;
+        seat.quit ??= false;
+    }
+    return list;
 }
-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.
-    'up', 'down', 'left', 'right',
-    // O losango, na ordem em que o dedo o percorre neste projeto (ADR-0086 §2).
-    'action2', 'action1', 'action4', 'action3',
-    // ⚠️ OS QUATRO OMBROS FALTAVAM AQUI ATÉ 2026-09-06, e a falta era um buraco de acessibilidade e não uma
-    // omissão cosmética: o assistente existe PARA controles que não são «standard» — genéricos, adaptados,
-    // de uma mão —, e um jogo que declarasse `leftShoulder` não tinha por onde a criança o mapear. Cinco das
-    // quatorze posições eram inalcançáveis exatamente para quem mais precisa do assistente.
-    'leftShoulder', 'leftTrigger', 'rightShoulder', 'rightTrigger',
-    // Sistema por último: `start` e `select` costumam ser os botões mais pequenos e mais escondidos, e pedi-los
-    // no fim deixa a criança já habituada ao ritmo do assistente quando chega neles.
-    'start', 'select',
-];
-/** Demonstração animada de cada ação (frames reais do jogo) mostrada durante o passo correspondente do wizard. */
-export const PADWIZ_ANIM = {
-    up: { seq: ['escada/0', 'escada/1'], hold: 9, cls: 'pw-up' },
-    down: { seq: ['escada/1', 'escada/0'], hold: 9, cls: 'pw-down' },
-    left: { seq: ['andar/0', 'andar/1', 'andar/2', 'andar/3', 'andar/4', 'andar/5', 'andar/6', 'andar/7'], hold: 4, cls: 'pw-left', flip: 1 },
-    right: { seq: ['andar/0', 'andar/1', 'andar/2', 'andar/3', 'andar/4', 'andar/5', 'andar/6', 'andar/7'], hold: 4, cls: 'pw-right' },
-    action2: { seq: ['pulo/0', 'pulo/0', 'pulo/1', 'pulo/1'], hold: 7, cls: 'pw-jump' },
-    action1: { seq: ['correr/0', 'correr/1', 'correr/2', 'correr/3'], hold: 3, cls: 'pw-run' },
-    action4: { fx: '👟 🕷️ 🎈 🐇 🦘', cls: 'pw-swap', noimg: 1 },
-    action3: { seq: ['idle/0', 'idle/1', 'idle/2', 'idle/3'], hold: 8, fx: '✨', cls: 'pw-especial' },
-    start: { fx: 'PAUSA', cls: 'pw-start', noimg: 1 },
-};
+/** The eight positions THIS transport reads: the d-pad and the four actions. The shoulders and triggers a cartridge may
+ *  declare have no reading on the pad — the list says what is true today. */
+const PAD_POSITIONS = Object.freeze(['left', 'right', 'up', 'down', 'action1', 'action2', 'action3', 'action4']);
+/** Inside a modal the ORDER is the rule — `input/keydown`'s: a pad delivers a snapshot with no order of arrival, and
+ *  with left and confirm in the same frame it is this list that decides the child moves instead of confirming. */
+const MODAL_BY_POSITION = Object.freeze([
+    ['left', 'left'], ['right', 'right'], ['up', 'up'], ['down', 'down'], ['action2', 'confirm'], ['action3', 'erase'],
+]);
 export function initGamepad(ctx) {
-    const _padMaps = new Map(); // cache id -> mapa custom (evita reparsear JSON a cada frame)
-    let padWiz = null;
-    let padWizAutoResume = false; // wizard aberto automaticamente no meio do jogo -> retoma a fase ao fechar
-    let padWizAnim = null;
-    function padMapFor(id) {
-        // ⚠️ O MAPA SALVO PASSA PELO TRADUTOR NA LEITURA. Ele é indexado por AÇÃO — `{ jump: { b: 0 } }` — e um
-        // mapa gravado antes do ADR-0086 tem as chaves antigas, que `bindingAt` já não procura: o controle
-        // custom simplesmente pararia de responder, e o jogo cairia no mapa padrão sem dizer nada.
-        // É o mais caro dos três formatos a perder: um mapa destes existe porque alguém passou por um assistente
-        // de nove passos, botão a botão, quase sempre porque o controle NÃO é «standard» — e controles genéricos
-        // ou adaptados raramente são. Ver `input/vocabulary-migration.ts`.
-        if (!_padMaps.has(id)) {
-            _padMaps.set(id, migrarMapaDeControle(store.getJSON('incl_padmap_' + id, null)));
-        }
-        return _padMaps.get(id) ?? null;
-    }
-    function actionsFor(gp, tabela) { return padActions(gp, padMapFor(gp.id), tabela); }
-    // ----- wizard: anúncio + demo animada (DOM-facing, thin) -----
-    // ⚠️ 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 = frase;
-        ctx.srSay(frase);
-    }
-    function wizDemo(k) {
-        const d = ctx.$('#padwiz-demo');
-        const img = ctx.$('#padwiz-demo-img');
-        const fx = ctx.$('#padwiz-demo-fx');
-        if (!d)
-            return;
-        const a = k ? PADWIZ_ANIM[k] : null;
-        d.className = a ? a.cls : '';
-        padWizAnim = null;
-        if (fx)
-            fx.textContent = (a && a.fx) || '';
-        if (img) {
-            img.style.display = a && a.noimg ? 'none' : '';
-            img.style.transform = a && a.flip ? 'scaleX(-1)' : '';
-            if (a && a.seq) {
-                img.src = ctx.spriteBase + a.seq[0] + '.png';
-                padWizAnim = { seq: a.seq, hold: a.hold || 6, t: 0 };
+    const { t } = ctx;
+    const { padCur, padPrevAct, padPrevStart } = ctx.input;
+    let padWizAutoResume = false; // the wizard opened by itself mid-game -> resume when it closes
+    // the root's one cache of stored maps (input/pad-wizard): a map saved by the engine's own wizard is read here next frame
+    const padMapFor = (id) => ctx.padMaps.padMap(id);
+    function actionsFor(gp, table) { return padActions(gp, padMapFor(gp.id), table); }
+    // the wizard asks; what a position LOOKS like is drawn by the game (note CD), through the two hooks it may answer
+    const wizard = createPadWizard({
+        maps: ctx.padMaps, t,
+        getGamepads: () => ctx.getGamepads(),
+        actionLabel: (action) => ctx.actionLabel(action),
+        say: (phrase) => { const el = ctx.$('#padwiz-prompt'); if (el)
+            el.textContent = phrase; ctx.srSay(phrase); },
+        progress: (text) => { const pr = ctx.$('#padwiz-progress'); if (pr)
+            pr.textContent = text; },
+        srAlert: (phrase) => ctx.srAlert(phrase),
+        onStep: (position) => ctx.wizardStep(position),
+        onTick: () => ctx.wizardTick(),
+        onClose: (gi) => {
+            const ov = ctx.$('#padwiz');
+            if (ov)
+                ov.hidden = true;
+            // 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];
+                if (gp) {
+                    const c = actionsFor(gp);
+                    padCur[gi] = c;
+                    padPrevAct[gi] = c;
+                    padPrevStart[gi] = c._start;
+                }
             }
-            else if (!a)
-                img.src = ctx.spriteBase + 'idle/0.png';
-        }
-    }
-    function wizDemoTick() {
-        if (!padWizAnim)
-            return;
-        const a = padWizAnim;
-        a.t++;
-        const img = ctx.$('#padwiz-demo-img');
-        if (img)
-            img.src = ctx.spriteBase + a.seq[Math.floor(a.t / a.hold) % a.seq.length] + '.png';
-    }
-    /**
-     * Anda até o próximo passo que ESTE jogo usa, ou fecha se não houver mais.
-     *
-     * ⚠️ UMA FUNÇÃO SÓ, e antes eram duas com regras diferentes: `wizBind` incrementava e fechava no fim,
-     * `wizPrompt` saltava as não nomeadas. Depois do último passo nomeado o assistente ficava aberto a
-     * apontar para uma posição que o jogo não usa, e só fechava no tique seguinte — uma criança veria o
-     * assistente pendurado, sem pergunta nenhuma na tela.
-     */
-    function wizAvancar() {
-        if (!padWiz)
-            return;
-        while (padWiz.step < PADWIZ_ORDER.length && !ctx.rotuloDaAcao(PADWIZ_ORDER[padWiz.step]))
-            padWiz.step++;
-        if (padWiz.step >= PADWIZ_ORDER.length)
-            closePadWiz(true);
-    }
-    function wizPrompt() {
-        if (!padWiz)
-            return;
-        wizAvancar();
-        if (!padWiz)
-            return; // fechou ao avançar
-        const acao = PADWIZ_ORDER[padWiz.step];
-        const rotulo = ctx.rotuloDaAcao(acao);
-        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 = t('pad.wiz.mapped', { lista: Object.keys(padWiz.map).join(' · ') || '—' });
-    }
-    function wizBind(bd) {
-        if (!padWiz)
-            return;
-        padWiz.map[PADWIZ_ORDER[padWiz.step]] = bd;
-        padWiz.step++;
-        padWiz.release = true; // exige soltar antes do próximo passo (mesmo botão segurado não dobra pro passo seguinte)
-        wizAvancar(); // salta o que este jogo não usa, e fecha se o resto da lista for tudo isso
-    }
-    // ----- wizard: abrir/fechar -----
+            catch { /* a pad API that throws here only costs the edge baseline, never the closing */ }
+            if (padWizAutoResume) {
+                padWizAutoResume = false;
+                if (ctx.pauseMenu())
+                    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() {
         const ov = ctx.$('#padwiz');
         if (!ov)
             return;
         ov.hidden = false;
         ctx.frontOverlay(ov);
-        padWiz = { gi: -1, id: '', step: -1, base: null, map: {}, release: false, baseWait: false, axTrack: null, timer: null };
-        wizSay(t('pad.wiz.pressAny'));
-        wizDemo(null);
-        const pr = ctx.$('#padwiz-progress');
-        if (pr)
-            pr.textContent = '';
-        padWiz.timer = setInterval(padWizTick, 30);
+        wizard.open();
     }
-    // Wizard aberto AUTOMATICAMENTE (controle DirectInput sem mapa apertou algo): já sabemos qual controle é.
+    // The wizard opened BY ITSELF (a DirectInput pad with no map pressed something): we already know which pad it is.
     function openPadWizFor(gp) {
         const ov = ctx.$('#padwiz');
         if (!ov)
             return;
         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(t('pad.wiz.detected', { id: gp.id }));
-        wizDemo(null);
-        const pr = ctx.$('#padwiz-progress');
-        if (pr)
-            pr.textContent = '';
-        padWiz.timer = setInterval(padWizTick, 30);
+        wizard.openFor(gp);
     }
-    function closePadWiz(save) {
-        if (!padWiz)
-            return;
-        if (padWiz.timer != null)
-            clearInterval(padWiz.timer);
-        if (save && padWiz.id) {
-            store.setJSON('incl_padmap_' + padWiz.id, padWiz.map);
-            _padMaps.set(padWiz.id, padWiz.map);
-            ctx.srAlert(t('sr.pad.mapSaved', { id: padWiz.id }));
+    const closePadWiz = (save) => wizard.close(save);
+    const padWizTick = () => wizard.tick();
+    const cancelBtn = ctx.$('#padwiz-cancel');
+    if (cancelBtn)
+        cancelBtn.addEventListener('click', () => closePadWiz(false));
+    // ----- poll (called every frame of the loop) -----
+    /** This frame's reading for ONE pad: the actions now, the edges against the previous frame, and the seat. */
+    function readPad(gp, players) {
+        const gi = gp.index;
+        const prev = padPrevAct[gi] || {};
+        // ⚠️ THE SEAT IS READ BEFORE THE ACTIONS, and the reason is ADR-0115: this game's button table is declared PER SEAT,
+        // and it is read inside `actionsFor`. Read after, the actions would be taken before knowing whose pad it is — and a
+        // per-seat default would arrive late.
+        const owner = players.findIndex((p) => p.pad === gi);
+        // ⚠️ AND A PAD NOT YET ASSIGNED (`owner < 0`) READS SEAT 0, not "none": it is producing edges on the title screen,
+        // and an empty map there would leave the child with no way to choose their own game.
+        // THE MOTOR EMPATHY SIMULATION APPLIED TO THE PAD (issue #120). Without this line, a child with the one-button mode
+        // on and a pad in hand WAS NOT in the mode — and nothing anywhere said so.
+        const cur = oneButtonAtOnce(prev, actionsFor(gp, ctx.padTable(ctx.getNumPlayers(), owner < 0 ? 0 : owner)), ctx.oneButton());
+        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;
+        padPrevAct[gi] = cur;
+        // 📌 START counts as "yes" ONLY on the title: there it is the button that begins the game, and on the pause card or
+        // the bar it is the EXIT (ADR-0044 item 7). One parameter instead of three lists equal but for one term.
+        const navKeys = (withStart = false) => ({
+            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, 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.
+    const anyIntent = (k) => !!(k.yes || k.no || k.up || k.down || k.left || k.right);
+    /** A non-standard (DirectInput) pad with NO stored map pressed something: pause everything and open the wizard on it. */
+    function wizardTookOver(gp) {
+        if (gp.mapping === 'standard' || padMapFor(gp.id) || !gp.buttons.some((b) => b && b.pressed))
+            return false;
+        padWizAutoResume = ctx.worldRunning();
+        if (ctx.worldRunning())
+            ctx.pause();
+        openPadWizFor(gp);
+        return true;
+    }
+    /** A win: START/jump close the modal (Play again), and nothing from this pad reaches the game underneath it. */
+    function winOverlayTook(f) {
+        const winOv = ctx.$('#win-overlay');
+        if (!winOv || winOv.hidden)
+            return false;
+        if (f.startEdge) {
+            const b = ctx.$('#btn-again');
+            if (b)
+                b.click();
         }
-        else if (padWiz.id && !_padMaps.get(padWiz.id)) {
-            _padMaps.set(padWiz.id, { _skip: true }); // cancelou: usa o mapa PADRÃO nesta sessão (não persiste, evita reabrir em loop)
+        return true;
+    }
+    /** The title menu: the pad navigates, and in a multiplayer game only P1 chooses. */
+    function steerTitle(f) {
+        const k = f.navKeys(true);
+        if (!anyIntent(k))
+            return;
+        if (ctx.getNumPlayers() > 1 && f.owner > 0) {
+            ctx.srSay(t('sr.title.waitP1'));
+            return;
+        } // only P1 chooses
+        ctx.navTitle(k); // the title menu, navigable by pad
+    }
+    /** 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(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;
         }
-        const gi = padWiz.gi;
-        padWiz = null;
-        const ov = ctx.$('#padwiz');
-        if (ov)
-            ov.hidden = true;
-        // sem edges fantasmas: o botão ainda SEGURADO do último passo (START) não pode pausar/agir ao retomar
-        try {
-            const pads = ctx.getGamepads() ?? [];
-            const gp = pads[gi];
-            if (gp) {
-                const c = actionsFor(gp);
-                padCur[gi] = c;
-                padPrevAct[gi] = c;
-                padPrevStart[gi] = c._start;
-            }
+        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;
         }
-        catch { /* espelha o try/catch silencioso do original */ }
-        if (padWizAutoResume) {
-            padWizAutoResume = false;
-            if (ctx.menuDePausa())
-                ctx.retomar();
+        const dlg = ctx.sharedDialogOpen();
+        if (dlg) {
+            ctx.navDialog(dlg, k);
+            return;
         }
+        const menu = ctx.getPauseMenu(pi);
+        if (menu && !menu.hidden)
+            ctx.navPause(menu, pi, k);
     }
-    // ----- wizard: tick (roda a cada 30ms enquanto aberto) -----
-    function padWizTick() {
-        if (!padWiz)
+    /** Assignment BY ORDER OF ACTION: any button binds -> the 1st pad to act -> the 1st player without a pad. */
+    function takeSeat(f) {
+        if (!f.startEdge && !PAD_POSITIONS.some((k) => f.edge(k)))
             return;
-        wizDemoTick();
-        const pads = ctx.getGamepads() ?? [];
-        if (padWiz.gi < 0) {
-            for (const gp of pads) {
-                if (gp && gp.buttons.some((b) => b && b.pressed)) {
-                    padWiz.gi = gp.index;
-                    padWiz.id = gp.id;
-                    padWiz.baseWait = true;
-                    wizSay(t('pad.wiz.releaseAll', { id: gp.id }));
-                    break;
-                }
-            }
+        const waitI = f.players.findIndex((p) => p && p.waiting);
+        const free = waitI >= 0 ? waitI : f.players.findIndex((p) => p && p.pad < 0 && !p.quit);
+        if (free < 0) {
+            ctx.joinPlayer(f.gi);
             return;
         }
-        const gp = pads[padWiz.gi];
-        if (!gp)
-            return; // controle desconectado (ou índice ainda não populado): congela até voltar
-        if (padWiz.baseWait) {
-            if (!gp.buttons.some((b) => b && b.pressed)) {
-                padWiz.baseWait = false;
-                padWiz.base = { b: gp.buttons.map((x) => !!(x && x.pressed)), a: gp.axes.slice() };
-                padWiz.step = 0;
-                wizPrompt();
-            }
+        const seated = f.players[free];
+        seated.pad = f.gi;
+        if (seated.waiting) {
+            seated.waiting = false;
+            ctx.clearWaitingBadge(free);
+        }
+        ctx.srSay(t('sr.pad.assigned', { n: free + 1 }));
+    }
+    /**
+     * THE HALF OF THE SINGLE DOOR THAT PRESSES (ADR-0223): every position that WENT DOWN this frame goes to the virtual
+     * controller, stamped `gamepad` with this pad's seat. Returns the ones that reached the GAME — the controller's
+     * answer, which is what tells a game press from one a menu took.
+     *
+     * ⚠️ The EIGHT positions and not the six with an edge: those with an edge are a subset (`EDGE_BY_ACTION`), and up and
+     * down always travelled as held keys. All eight reach the cartridge.
+     */
+    function pressWhatWentDown(f) {
+        const reached = new Set();
+        for (const act of PAD_POSITIONS)
+            if (f.edge(act) && ctx.press(act, 'gamepad', f.owner))
+                reached.add(act);
+        return reached;
+    }
+    /**
+     * THE HALF THAT RELEASES, and it is UNCONDITIONAL on purpose (ADR-0223). A press is only born in the PLAY branch, but
+     * the finger leaves the button wherever it likes — a child who opens the pause with jump held would leave the key held
+     * forever if the release depended on the branch. The controller ignores the release of a press the game never heard,
+     * which is exactly the memory it exists to have.
+     *
+     * 📌 The pad is the only transport that reads STATE per frame instead of receiving events, so the release never
+     * arrives to it: it is computed against the previous frame.
+     */
+    function releaseWhatCameUp(f) {
+        if (f.owner < 0)
+            return; // a pad with no seat never pressed anything
+        for (const act of PAD_POSITIONS)
+            if (f.released(act))
+                ctx.release(act, 'gamepad', f.owner);
+    }
+    /** 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.press('start', 'gamepad', f.owner);
+            ctx.setPauseActor(f.owner);
             return;
         }
-        const base = padWiz.base;
-        if (padWiz.release) {
-            const idle = !gp.buttons.some((b, i) => b && b.pressed && !base.b[i]) && gp.axes.every((v, i) => Math.abs((v || 0) - base.a[i]) < 0.35);
-            if (idle) {
-                padWiz.release = false;
-                wizPrompt();
-            }
+        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));
+            if (hit)
+                ctx.modalInput(f.owner, hit[1]);
             return;
         }
-        // eixo em rastreio (~240ms): classifica pelo COMPORTAMENTO — varia continuamente = analógico (limiar por
-        // sinal); salta e FICA CONSTANTE = D-pad/POV hat (valor exato, ±0.13).
-        if (padWiz.axTrack) {
-            const t = padWiz.axTrack;
-            const v = gp.axes[t.i] || 0;
-            if (Math.abs(v - t.last) > 0.03)
-                t.changes++;
-            t.last = v;
-            if (Math.abs(v - base.a[t.i]) > Math.abs(t.v - base.a[t.i]))
-                t.v = v;
-            if (++t.ticks >= 8) {
-                const pv = t.v;
-                padWiz.axTrack = null;
-                wizBind(t.changes >= 2 ? { ax: t.i, s: pv > 0 ? 1 : -1 } : { av: t.i, v: Math.round(pv * 10000) / 10000 });
-            }
+        // The table and the Easy guard come from input/edges.ts, the SAME ones keydown and touch use — three hand-written
+        // copies had already drifted once (the touch one forgot `!p.easy`).
+        // 🔴 THE SINGLE DOOR FIRST (ADR-0223): the position goes to the virtual controller, which holds the child's key
+        // stamped `gamepad` and delivers the command to the cartridge. Only then is an edge raised — and only for a press
+        // that REACHED the game, which is the controller's answer.
+        const reachedPlay = pressWhatWentDown(f);
+        let hasAnyEdge = false;
+        for (const [act, flag] of EDGE_BY_ACTION) {
+            if (!reachedPlay.has(act))
+                continue;
+            hasAnyEdge = true;
+            if (edgeAllowed(act, p.easy))
+                p[flag] = true;
+        }
+        // 📌 THE PAD'S EDGE, and it counts EVEN WHEN EASY FILTERS IT (ADR-0113 clause 4): the child pressed the button —
+        // that the Easy Mode rule does not raise the game's flag does not change the fact that this is the device in use.
+        // Reading the same condition as `p[flag]` would leave a child in Easy Mode with the keyboard's latch while playing
+        // on the pad.
+        // ⚠️ AND IT IS HERE, in the PLAY branch, not the menu ones: `onBar`, the title and the pause are navigation, and the
+        // question this feeds — which latch holds NOW — is about playing.
+        if (hasAnyEdge)
+            ctx.playerEdge(f.owner, 'gamepad');
+    }
+    /** With the world moving: the quick bar first, then the seat, the abandoned screen, and finally the game. */
+    function steerGame(f) {
+        // ===================== THE `accessibility` MODE (ADR-0044, item 7) =====================
+        // With the game RUNNING, this player's d-pad steers the QUICK BAR and not the character. It comes before everything
+        // 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 `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.pauseEdge || anyIntent(k))
+                ctx.navBar(f.owner, k, f.pauseEdge);
             return;
         }
-        for (let i = 0; i < gp.buttons.length; i++) {
-            if (gp.buttons[i] && gp.buttons[i].pressed && !base.b[i]) {
-                wizBind({ b: i });
-                return;
-            }
+        if (f.owner < 0) {
+            takeSeat(f);
+            return;
         }
-        for (let i = 0; i < gp.axes.length; i++) {
-            const v = gp.axes[i] || 0;
-            if (Math.abs(v - base.a[i]) > 0.45) {
-                padWiz.axTrack = { i, v, last: v, changes: 0, ticks: 0 };
-                return;
-            }
+        const p = f.players[f.owner];
+        if (p.quit) {
+            if (f.startEdge)
+                ctx.respawnPlayer(f.owner);
+            return;
+        } // abandoned screen -> restart ONLY it
+        playRound(f, p);
+    }
+    /** In the demonstration, a pad button ends the demo — and the frame ends here, button or not. */
+    function attractTook(pads) {
+        if (!ctx.isAttractActive())
+            return false;
+        if (pads.some((gp) => gp && gp.buttons.some((b) => b && b.pressed)))
+            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])))
+            ctx.hideTouchControls();
+    }
+    /**
+     * Where this frame goes. The destinations ask for the facts, not a PHASE. The pause wins over a world running beneath
+     * it, and the title is derived by exclusion on purpose: in a scene this module does not know (a map, a results
+     * 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())
+            steerGame(f);
+        else
+            steerTitle(f);
     }
-    const cancelBtn = ctx.$('#padwiz-cancel');
-    if (cancelBtn)
-        cancelBtn.addEventListener('click', () => closePadWiz(false));
-    // ----- poll (chamado a cada frame do loop) -----
     function pollPads() {
-        if (padWiz)
-            return; // durante o wizard, os pads falam só com ele
+        if (wizard.state())
+            return; // during the wizard, the pads talk only to it
         const pads = ctx.getGamepads();
-        if (!pads)
-            return;
-        if (ctx.isAttractActive()) {
-            for (const gp of pads) {
-                if (gp && gp.buttons.some((b) => b && b.pressed)) {
-                    ctx.stopAttract();
-                    return;
-                }
-            } // botão de pad encerra a demo
+        if (!pads || attractTook(pads))
             return;
-        }
         for (const gp of pads) {
             if (!gp)
                 continue;
-            const gi = gp.index;
-            // controle fora do padrão (DirectInput) SEM mapa salvo apertou algo -> pausa geral + wizard direto
-            if (gp.mapping !== 'standard' && !padMapFor(gp.id) && gp.buttons.some((b) => b && b.pressed)) {
-                padWizAutoResume = ctx.mundoRodando();
-                if (ctx.mundoRodando())
-                    ctx.pausar();
-                openPadWizFor(gp);
+            // a non-standard (DirectInput) pad with NO saved map pressed something -> pause everything + the wizard directly
+            if (wizardTookOver(gp))
                 return;
-            }
-            const prev = padPrevAct[gi] || {};
-            // ⚠️ O ASSENTO SUBIU PARA AQUI, e a razão é o ADR-0115: a tabela de botões deste jogo é declarada POR
-            // ASSENTO, e ela é lida dentro do `actionsFor`. Enquanto o `owner` só se resolvia lá em baixo, por ramo,
-            // a leitura acontecia antes de se saber de quem era o controle — e um padrão por assento chegava tarde.
-            // 📌 Os ramos abaixo passaram a usar esta constante em vez de recalcularem a mesma linha três vezes.
-            const players = ctx.getPlayers();
-            const owner = players.findIndex((p) => p.pad === gi);
-            // ⚠️ E O CONTROLE AINDA NÃO ATRIBUÍDO (`owner < 0`) LÊ O ASSENTO 0, e não «nenhum»: ele está a produzir
-            // arestas na tela do título, e um mapa vazio ali deixaria a criança sem como escolher o próprio jogo.
-            // 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, tabelaDoPad(ctx.getNumPlayers(), owner < 0 ? 0 : owner)), 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)
-            }
-            const startEdge = cur._start && !padPrevStart[gi];
-            padPrevStart[gi] = cur._start;
-            const pauseEdge = cur._pause && !prev._pause;
-            const edge = (k) => cur[k] && !prev[k];
-            padCur[gi] = cur;
-            padPrevAct[gi] = cur;
-            const winOv = ctx.$('#win-overlay');
-            if (winOv && !winOv.hidden) { // Vitória: START/pulo fecham o modal (Jogar de novo)
-                if (startEdge) {
-                    const b = ctx.$('#btn-again');
-                    if (b)
-                        b.click();
-                }
-                continue;
-            }
-            // Os três ramos abaixo pediam a FASE; hoje pedem os fatos. O `telaDeTitulo` é derivado por exclusão
-            // de propósito: numa cena que este módulo não conheça (um mapa, uma tela de resultados), o controle
-            // deve navegar como no título — que é o comportamento seguro — em vez de não fazer nada.
-            const rodando = ctx.mundoRodando(), pausado = ctx.menuDePausa();
-            if (!rodando && !pausado) {
-                const k = { yes: edge('action2') || startEdge, no: edge('action3'), up: edge('up'), down: edge('down'), left: edge('left'), right: edge('right') };
-                const any = k.yes || k.no || k.up || k.down || k.left || k.right;
-                if (ctx.getNumPlayers() > 1 && owner > 0) {
-                    if (any)
-                        ctx.srSay(t('sr.title.waitP1'));
-                    continue;
-                } // só o J1 escolhe
-                if (any)
-                    ctx.navTitle(k); // menu inicial navegável pelo pad
-                continue;
-            }
-            if (pausado) {
-                const pi = owner < 0 ? 0 : owner;
-                if (pauseEdge) {
-                    ctx.retomar();
-                    continue;
-                } // START retoma
-                const k = { yes: edge('action2'), no: edge('action3'), up: edge('up'), down: edge('down'), left: edge('left'), right: edge('right') };
-                if (k.yes || k.no || k.up || k.down || k.left || k.right) {
-                    const dlg = ctx.sharedDialogOpen();
-                    if (dlg)
-                        ctx.navDialog(dlg, k);
-                    else {
-                        const menu = ctx.getPauseMenu(pi);
-                        if (menu && !menu.hidden)
-                            ctx.navPause(menu, pi, k);
-                    }
-                }
-                continue;
-            }
-            if (rodando) {
-                // ===================== O MODO `accessibility` (ADR-0044, item 7) =====================
-                // Com o jogo ANDANDO, o direcional deste jogador dirige a BARRA RÁPIDA e não o personagem. Vem antes
-                // de tudo o que é de jogo, porque enquanto o modo está ligado nada mais deste controle é de jogo.
-                //
-                // As DUAS saídas chegam juntas: `especial` é o VOLTAR do projeto (X no PlayStation, B no Xbox, A no
-                // Nintendo) e `startEdge` é o botão que abre a pausa — de onde se entrou aqui. Quem se perde tenta
-                // voltar por onde veio, e quem já conhece o jogo tenta o voltar de sempre; as duas dão certo.
-                if (owner >= 0 && ctx.naBarraDe(owner)) {
-                    const k = { yes: edge('action2'), no: edge('action3'), up: edge('up'), down: edge('down'), left: edge('left'), right: edge('right') };
-                    if (startEdge || k.yes || k.no || k.up || k.down || k.left || k.right)
-                        ctx.navBar(owner, k, !!startEdge);
-                    continue;
-                }
-                if (owner < 0) { // atribuição POR ORDEM DE AÇÃO: qualquer botão associa -> 1º controle a agir -> 1º jogador sem pad
-                    const anyEdge = edge('action2') || edge('action1') || edge('action4') || edge('action3') || startEdge || edge('left') || edge('right') || edge('up') || edge('down');
-                    if (anyEdge) {
-                        const waitI = players.findIndex((p) => p && p.waiting);
-                        const free = waitI >= 0 ? waitI : players.findIndex((p) => p && p.pad < 0 && !p.quit);
-                        if (free >= 0) {
-                            players[free].pad = gi;
-                            if (players[free].waiting) {
-                                players[free].waiting = false;
-                                ctx.clearWaitingBadge(free);
-                            }
-                            ctx.srSay(t('sr.pad.assigned', { n: free + 1 }));
-                        }
-                        else {
-                            ctx.joinPlayer(gi);
-                        }
-                    }
-                }
-                else if (players[owner].quit) {
-                    if (startEdge)
-                        ctx.respawnPlayer(owner); // tela abandonada -> recomeça SÓ ela
-                }
-                else {
-                    const p = players[owner];
-                    if (pauseEdge) {
-                        ctx.pausar();
-                        ctx.setPauseActor(owner);
-                        continue;
-                    } // START pausa (todos pausam; cada tela navega a sua)
-                    if (ctx.hasModal(owner)) { // o pad navega o modal do PRÓPRIO jogador (o jogo dos outros segue)
-                        // A ORDEM é a do original: esquerda, direita, cima, baixo, confirmar, apagar. O que saiu foi o
-                        // SIGNIFICADO — o ±1/±3 da grade e o desvio de Braille, que agora são decisão do jogo.
-                        const intent = edge('left') ? 'left' : edge('right') ? 'right'
-                            : edge('up') ? 'up' : edge('down') ? 'down'
-                                : edge('action2') ? 'confirm' : edge('action3') ? 'erase' : null;
-                        if (intent)
-                            ctx.modalInput(owner, intent);
-                        continue;
-                    }
-                    // A tabela e a guarda do Fácil vêm de input/edges.ts, as MESMAS que keydown e touch usam. Antes eram
-                    // seis `if` à mão aqui, seis lá e seis no toque — e o do toque tinha esquecido o `!p.easy`.
-                    let algumaAresta = false;
-                    for (const [act, flag] of EDGE_BY_ACTION) {
-                        if (edge(act))
-                            algumaAresta = true;
-                        if (edgeAllowed(act, p.easy) && edge(act))
-                            p[flag] = true;
-                    }
-                    // 📌 A ARESTA DO CONTROLE, e ela conta MESMO QUANDO O FÁCIL A FILTRA (ADR-0113 cláusula 4): a
-                    // criança carregou no botão — que a regra do Modo Fácil não levante a bandeira do jogo não muda
-                    // o facto de o aparelho em uso ser este. Ler a mesma condição do `p[flag]` faria uma criança em
-                    // Modo Fácil ficar com a alternância do teclado enquanto joga no controle.
-                    // ⚠️ E É AQUI, no ramo de JOGO, e não nos de menu: `naBarraDe`, o título e a pausa são navegação, e
-                    // a pergunta que isto alimenta — que alternância vale AGORA — é sobre jogar.
-                    if (algumaAresta)
-                        ctx.arestaDoJogador(owner, 'gamepad');
-                }
-            }
+            // ⚠️ `getPlayers()` IS READ HERE, once per pad, and not once before the loop: the seat branch WRITES into the list
+            // (`players[free].pad = gi`), and reading it only once would change what the next pad sees.
+            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);
         }
     }
-    return { pollPads, openPadWiz, openPadWizFor, closePadWiz, padWizTick, padMapFor, getPadWiz: () => padWiz };
+    return { pollPads, openPadWiz, openPadWizFor, closePadWiz, padWizTick, padMapFor, getPadWiz: () => wizard.state() };
 }