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

package/dist-pkg/ui/settings-motion.js

@@ -16,6 +16,7 @@ import { CRT, CRT_DEFAULT, applyCrt } from '../render/crt.js';
 import { defaultReducedMotion } from '../core/state.js';
 import { markChanged, markMenuChanged } from './changed-mark.js';
 import { t } from '../core/i18n.js';
+import { CHAVES_DE_CENA, ANIMACOES_DO_PERSONAGEM, lerCenaGuardada, guardarCena } from './motion-scene.js';
 /**
  * Alvo → CHAVE i18n do rótulo. CHAVES, e não texto, pelo motivo de sempre: uma tabela de `const` com texto
  * resolve UMA vez, no import, e fica congelada no idioma do boot.
@@ -112,10 +113,20 @@ export function getSelectedPlayer() { return selectedPlayer; }
 /** Chamado de fora (ex.: o atalho "anim" do menu de pausa) antes de open(). */
 export function setSelectedPlayer(i) { selectedPlayer = i; }
 export function initSettingsMotion(ctx) {
+    /*
+     * ⚠️ RESOLVIDAS UMA VEZ, NO ARRANQUE, e não a cada uso. O `rm` é mutado in-place e partilhado por
+     * REFERÊNCIA com quem desenha a cena; resolvê-lo a cada leitura criaria um objecto novo por chamada, o
+     * interruptor deixaria de alcançar o desenho, e não haveria erro nenhum — o menu diria «reduzido» e a cena
+     * continuaria a mexer-se.
+     */
+    const rm = ctx.rm ?? lerCenaGuardada();
+    const rmKeys = ctx.rmKeys ?? CHAVES_DE_CENA;
+    const rmChar = ctx.rmChar ?? ANIMACOES_DO_PERSONAGEM;
+    const saveRM = ctx.saveRM ?? (() => guardarCena(rm));
     function reflectMotionBtn() {
         const b = ctx.$('#opt-animation');
         if (b)
-            b.classList.toggle('is-on', ctx.rmKeys.some((k) => ctx.rm[k]));
+            b.classList.toggle('is-on', rmKeys.some((k) => rm[k]));
     }
     function updateMotionMaster() {
         reflectMotionBtn();
@@ -123,7 +134,7 @@ export function initSettingsMotion(ctx) {
         if (!m)
             return;
         const player = ctx.getPlayers()[selectedPlayer];
-        const allFrozen = allMotionFrozen(ctx.rmKeys, ctx.rm, ctx.rmChar, player);
+        const allFrozen = allMotionFrozen(rmKeys, rm, rmChar, player);
         m.textContent = motionMasterLabel(allFrozen);
         ctx.toggleBtn(m, allFrozen);
     }
@@ -142,11 +153,13 @@ export function initSettingsMotion(ctx) {
             tabs.querySelectorAll('button[data-ap]').forEach((b) => b.addEventListener('click', () => {
                 selectedPlayer = Number(b.dataset.ap);
                 render();
+                // A prosa volta para o rodapé depois de as linhas serem reconstruídas (CLAUDE.md §4, #109).
+                ctx.fillExplain?.(ctx.$('#animation .overlay__card'));
             }));
         }
         const player = ctx.getPlayers()[selectedPlayer];
-        const charRows = buildCharRowsHtml(ctx.rmChar, player);
-        const sceneRows = buildSceneRowsHtml(ctx.rmKeys, ctx.rm, RM_LABEL, RM_SOON);
+        const charRows = buildCharRowsHtml(rmChar, player);
+        const sceneRows = buildSceneRowsHtml(rmKeys, rm, RM_LABEL, RM_SOON);
         const crtRows = crtToggleRowHtml(t(CRT_LBL.scan), 'scan', !!CRT.scan) + crtToggleRowHtml(t(CRT_LBL.vig), 'vig', !!CRT.vig) + crtRoundRowHtml(t(CRT_LBL.round), CRT.round);
         el.innerHTML =
             `<h3 class="panel-sub">Personagem${ctx.getNumPlayers() > 1 ? ' · Jogador ' + (selectedPlayer + 1) : ''} <span class="panel-sub__tag">por jogador</span></h3>${charRows}` +
@@ -174,11 +187,11 @@ export function initSettingsMotion(ctx) {
         }));
         el.querySelectorAll('button[data-rm]').forEach((b) => b.addEventListener('click', () => {
             const k = b.dataset.rm;
-            ctx.rm[k] = !ctx.rm[k];
-            ctx.saveRM();
+            rm[k] = !rm[k];
+            saveRM();
             render();
             updateMotionMaster();
-            ctx.srSay(sceneMotionAnnouncement(t(RM_LABEL[k]), ctx.rm[k]));
+            ctx.srSay(sceneMotionAnnouncement(t(RM_LABEL[k]), rm[k]));
         }));
         updateMotionMaster();
         refreshMarks();
@@ -200,10 +213,10 @@ export function initSettingsMotion(ctx) {
             mudou.push(changed);
             markChanged(el?.querySelector(sel)?.closest('.ctrl-row') ?? null, changed);
         };
-        for (const c of ctx.rmChar)
+        for (const c of rmChar)
             marcar(`[data-rmc="${c.prop}"]`, !!(player && player[c.prop]) !== padraoRm);
-        for (const k of ctx.rmKeys)
-            marcar(`[data-rm="${k}"]`, !!ctx.rm[k] !== padraoRm);
+        for (const k of rmKeys)
+            marcar(`[data-rm="${k}"]`, !!rm[k] !== padraoRm);
         marcar('[data-crt-tgl="scan"]', !!CRT.scan !== !!CRT_DEFAULT.scan);
         marcar('[data-crt-tgl="vig"]', !!CRT.vig !== !!CRT_DEFAULT.vig);
         marcar('[data-crt="round"]', CRT.round !== CRT_DEFAULT.round);
@@ -222,11 +235,11 @@ export function initSettingsMotion(ctx) {
     if (resetBtn)
         resetBtn.addEventListener('click', () => {
             const padraoRm = defaultReducedMotion();
-            for (const k of ctx.rmKeys)
-                ctx.rm[k] = padraoRm;
-            ctx.saveRM();
+            for (const k of rmKeys)
+                rm[k] = padraoRm;
+            saveRM();
             ctx.getPlayers().forEach((p, i) => {
-                for (const c of ctx.rmChar) {
+                for (const c of rmChar) {
                     p[c.prop] = padraoRm;
                     ctx.store.setBool('incl_' + c.prop + '_p' + i, padraoRm);
                 }
@@ -264,13 +277,13 @@ export function initSettingsMotion(ctx) {
     if (master)
         master.addEventListener('click', () => {
             const player = ctx.getPlayers()[selectedPlayer];
-            const allFrozen = allMotionFrozen(ctx.rmKeys, ctx.rm, ctx.rmChar, player);
+            const allFrozen = allMotionFrozen(rmKeys, rm, rmChar, player);
             const next = !allFrozen;
-            for (const k of ctx.rmKeys)
-                ctx.rm[k] = next;
-            ctx.saveRM();
+            for (const k of rmKeys)
+                rm[k] = next;
+            saveRM();
             if (player)
-                for (const c of ctx.rmChar) {
+                for (const c of rmChar) {
                     player[c.prop] = next;
                     ctx.store.setBool('incl_' + c.prop + '_p' + selectedPlayer, next);
                 }

package/dist-pkg/ui/settings-motor.d.ts

@@ -2,6 +2,7 @@
 import { toggleLabel } from './dom.js';
 import type { PlayerView } from '../core/entity.js';
 import type { DomQuery } from '../core/dom-query.js';
+import { type JogadorDaAlternancia as JogadorDaAlternanciaDaAresta } from '../input/latch-sync.js';
 /** Minimal DOM-selector shape (matches ui/dom.ts's `$`). */
 export type { DomQuery } from '../core/dom-query.js';
 /** Minimal platform/storage.ts shape this module needs. */
@@ -12,7 +13,7 @@ export interface MotorStore {
 }
 /** Minimal per-player shape this module reads/writes (core/state.ts's `players` entries carry much more). */
 /** As duas escolhas motoras por jogador: modo Fácil e teclas de alternância. */
-export type MotorPlayer = PlayerView<'easy' | 'toggleMove' | 'toggleRun'>;
+export type MotorPlayer = PlayerView<'easy' | 'toggleMove' | 'toggleRun' | 'walkDir'>;
 export interface SettingsMotorCtx {
     /** DOM selector (querySelector), injected — never reaches `document` globally. */
     $: DomQuery;
@@ -25,7 +26,27 @@ export interface SettingsMotorCtx {
     /** Live player count (core/state.ts's `numPlayers`); a getter because the value is reassigned over time. */
     getNumPlayers: () => number;
     /** SHARED setter (also used by the pause-menu quick icon `altmove`) — stays in game.js, injected. */
-    setToggleMove: (i: number, on: boolean) => void;
+    setToggleMove?: (i: number, on: boolean) => void;
+    /**
+     * ESTE JOGO SEGURA ALGUMA TECLA? — `GameDeclaration.seguraTeclas` (ADR-0115). Sem ele a linha da
+     * alternância fica AUSENTE deste painel.
+     *
+     * ⚠️ E A ENGINE NÃO DESENHA ESTA LINHA — o markup do `#opt-altmove` é do CARTUCHO, e a engine só o
+     * encontra pelo `$`. Logo «não oferecer» aqui não é deixar de renderizar: é tornar a linha ausente para
+     * toda a gente, com `hidden`, que a tira da tela E da árvore de acessibilidade. Um `aria-disabled` seria a
+     * resposta errada — essa é a da cláusula 3 do ADR-0113, onde o controle EXISTE e está travado com motivo.
+     *
+     * ⚠️ OBRIGATÓRIO, pela mesma razão que no `PauseIconsCtx`: não há padrão seguro. `true` deixa a linha num
+     * jogo onde ela não faz nada; `false` esconde-a de uma criança que depende dela.
+     */
+    seguraTeclas: boolean;
+    /**
+     * QUAL APARELHO ESTE JOGADOR ESTÁ A USAR (ADR-0113) — atravessa daqui para a escrita.
+     *
+     * ⚠️ Opcional pela mesma razão que na `EscritaDaAlternanciaCtx`: sem ele a escrita cai no que já fazia,
+     * e exigi-lo quebraria todo consumidor por causa de uma migração a meio.
+     */
+    transporteEmUso?: (jogador: number) => string;
     /**
      * A ALTERNÂNCIA DO BOTÃO DE CORRER. Injetada como a irmã acima e pelo mesmo motivo: quem persiste e anuncia
      * é a raiz de composição, que é quem conhece `players` e o armazenamento.
@@ -33,6 +54,19 @@ export interface SettingsMotorCtx {
     setToggleRun: (i: number, on: boolean) => void;
     /** Coin layout depends on any player's Modo Fácil (moedas no chão) — owned by the coin subsystem, injected. */
     rebuildCoins: () => void;
+    /**
+     * Move a prosa das linhas para o rodapé (`ui/settings-panel` → `fillExplain`). Chamado a CADA render.
+     *
+     * ⚠️ NÃO É OPCIONAL POR ELEGÂNCIA: `fillExplain` roda uma vez quando o overlay é frontalizado e move o
+     * `.opt-hint` de dentro de cada linha para o rodapé. Este painel RECONSTRÓI as linhas, e as linhas novas
+     * voltam com a prosa lá dentro — então a explicação aparece duas vezes, no rodapé e sob o rótulo, a
+     * partir do primeiro clique. O `CLAUDE.md` §4 regista exatamente isto, e a issue #109 já o consertou
+     * uma vez noutros painéis.
+     *
+     * Opcional na assinatura porque um consumidor pode montar o painel sem a casca (um teste, o segundo
+     * consumidor): sem casca não há rodapé para duplicar.
+     */
+    fillExplain?: (card: HTMLElement | null) => void;
 }
 export interface SettingsMotorApi {
     /** Re-renders #movement-players (kept `hidden`, per E3 — see playerTabsHTML) and (re)wires its buttons. */
@@ -52,8 +86,72 @@ export interface SettingsMotorApi {
 }
 /** localStorage key for a player's Modo Fácil flag (== platform/storage.ts's `easy_p{i}` pattern). */
 export declare function easyKey(i: number): string;
-/** localStorage key da alternância do botão de CORRER (== `toggleRunP` de platform/storage). */
+/**
+ * localStorage key da alternância do botão de CORRER, na forma LEGADA (sem transporte).
+ *
+ * ⚠️ ERA UMA CÓPIA DO LITERAL, com um comentário ao lado a dizer «== `toggleRunP` de platform/storage» — o
+ * que é a admissão do defeito escrita como se fosse documentação. Duas cópias de um nome mudam uma de cada
+ * vez, e o `platform/storage` já tinha escrito a razão de as chaves serem funções: «virar função aqui é o
+ * que impede que um deles escreva num nome torto». Agora delega, e há um nome só.
+ *
+ * ⚠️ E É A CHAVE LEGADA. O ADR-0104 §C pôs o TRANSPORTE no nome, porque a alternância é do aparelho e não da
+ * pessoa; esta continua a ser lida para herdar o que a criança já tinha, e não é escrita. A chave nova é
+ * `chaveDaAlternancia`, em `input/latch-scope`.
+ */
 export declare function toggleRunKey(i: number): string;
+/** localStorage key da alternância de MARCHA, por jogador. Delega, como os dois irmãos acima. */
+export declare function toggleMoveKey(i: number): string;
+/**
+ * A fatia mínima que a escrita da alternância de marcha toca.
+ *
+ * ⚠️ `walkDir` ENTRA, e não é detalhe: desligar a alternância tem de PARAR quem está a andar por travamento.
+ * Sem isso, a criança desliga o modo e a personagem continua a andar sozinha, sem tecla nenhuma premida —
+ * e não há erro nenhum a dizê-lo.
+ *
+ * ⚠️ E É FATIA PRÓPRIA, e não o `MotorPlayer`, porque os DOIS chamadores têm fatias diferentes: o painel
+ * motor traz `easy`/`toggleRun` que isto não lê, e o `PausePlayer` traz o visual e as três do movimento
+ * reduzido. Uma fatia mínima é o que deixa os dois passarem sem que nenhum tenha de carregar o do outro.
+ * `MotorPlayer` e `PausePlayer` ganharam `walkDir` — quebra declarada, porque o campo é do `PlayerBase` e
+ * todo jogador da engine já o tem.
+ *
+ * 📌 A DEFINIÇÃO MUDOU DE CASA (issue #127) e o NOME fica publicado aqui. Ela vive em `input/latch-sync`, ao
+ * lado da regra que a usa, porque a sincronização da aresta toca exactamente estes dois campos — duas cópias
+ * do mesmo tipo divergiriam no dia em que a regra ganhasse um terceiro. ⚠️ **Alias e não `export ... from`**:
+ * o retrato de nomes deixa re-exports de fora e leria a mudança de casa como remoção, que é a lição da etapa
+ * 1a do ADR-0106.
+ */
+export type JogadorDaAlternancia = JogadorDaAlternanciaDaAresta;
+/** O que a escrita precisa de saber. Tudo o que está aqui já vive no `SettingsMotorCtx` e no `PauseIconsCtx`. */
+export interface EscritaDaAlternanciaCtx {
+    readonly players: readonly JogadorDaAlternancia[];
+    readonly store: {
+        setBool(key: string, on: boolean): void;
+    };
+    readonly srSay: (msg: string) => void;
+    readonly getNumPlayers: () => number;
+    /**
+     * QUAL APARELHO ESTE JOGADOR ESTÁ A USAR (ADR-0113). `input/state.entradaDe(i).emUso` é quem responde.
+     *
+     * ⚠️ OPCIONAL DE PROPÓSITO, e a razão é o que acontece sem ele: a escrita cai exactamente no que já fazia
+     * hoje — só a chave por jogador. Torná-lo obrigatório quebraria todo consumidor que constrói este ctx,
+     * por causa de uma migração que ainda não terminou, e o `holdsAtOnce` já mostrou o que isso custa.
+     *
+     * 📌 E é INJECTADO em vez de importado: `ui/` a ler estado de módulo de `input/` é uma aresta nova entre
+     * duas camadas, para poupar um argumento. Este ctx já recebe tudo o resto assim.
+     */
+    readonly transporteEmUso?: (jogador: number) => string;
+}
+/**
+ * LIGA OU DESLIGA A ALTERNÂNCIA DE MARCHA DE UM JOGADOR — e agora é a engine que o faz (ADR-0106 §4).
+ *
+ * ⚠️ O COMENTÁRIO QUE JUSTIFICAVA A INJEÇÃO ARGUMENTAVA CONTRA ELA. Ele dizia: «SHARED setter (also used by
+ * the pause-menu quick icon `altmove`) — stays in game.js, injected». Ser partilhado por DUAS superfícies da
+ * engine é razão para a engine o possuir, não para o cartucho o guardar — e a medição de 2026-09-08 mostra
+ * que cada passo já era da engine: `toggleMove` e `walkDir` são campos do `PlayerBase`, a chave é do
+ * `platform/storage`, e `sr.motor.toggleMove*` são chaves i18n da engine. Não sobrava efeito de jogo nenhum,
+ * o que faz deste o mais limpo dos sete: aqui não há sequer um efeito colateral a injectar.
+ */
+export declare function definirAlternanciaDeMarcha(ctx: EscritaDaAlternanciaCtx, i: number, on: boolean): void;
 /** Clamps the selected player back to 0 once it falls outside 0..numPlayers-1 (e.g. player count dropped). */
 export declare function clampSelPlayer(sel: number, numPlayers: number): number;
 /** Whether ANY player currently uses Modo Fácil or alternância — lights the #opt-movement bar button. */

package/dist-pkg/ui/settings-motor.js

@@ -3,25 +3,91 @@
 // renderMovPlayers()/reflectFacil()/reflectAltMove()/setEasy() (~line 2136). Pure logic (per-player tab
 // clamp/view-model, the "any player active" predicate, the Modo Fácil announcement text) is separated from the
 // thin DOM-touching render/reflect functions. DI via initSettingsMotor(ctx): `$` (DOM selector), `srSay`,
-// `store` (platform/storage shape), `players`/`getNumPlayers` (core/state.ts's live state) and two setters that
-// stay OUTSIDE this module because they are shared with other UI surfaces: `setToggleMove` (also fired by the
-// pause-menu quick-icon `iconAct('altmove', …)`, unrelated to this panel) and `rebuildCoins` (coin subsystem,
-// Modo Fácil puts coins on the ground). Overlay open/close plumbing (frontOverlay, #movement hidden toggle,
+// `store` (platform/storage shape), `players`/`getNumPlayers` (core/state.ts's live state) and `rebuildCoins`
+// (coin subsystem, Modo Fácil puts coins on the ground).
+//
+// ⚠️ `setToggleMove` DEIXOU DE ESTAR NESSA LISTA em 2026-09-08 (ADR-0106 §4, etapa 1b), e o que ela dava como
+// razão era o argumento contrário: dizia que ele «fica fora deste módulo porque é PARTILHADO com outra
+// superfície da interface» — o ícone `altmove` da pausa. Ser partilhado por duas superfícies da ENGINE é razão
+// para a engine o possuir. `definirAlternanciaDeMarcha` mora aqui; o campo do `ctx` ficou OPCIONAL, então
+// quem injecta continua a mandar e quem não injecta deixa de ficar sem ele.
+// Overlay open/close plumbing (frontOverlay, #movement hidden toggle,
 // Escape handling, renderMapHub) is the SHARED helper used by every settings panel and stays in game.js.
 import { toggleLabel } from './dom.js';
 import { t } from '../core/i18n.js';
 import { markChanged, markMenuChanged } from './changed-mark.js';
 import { DEFAULTS } from '../core/state.js';
+// ⚠️ IMPORT DIRETO, e não uma peça a mais no `ctx`, pela mesma razão que o `ui/pause-icons` importa
+// `platform/storage`: um nome de chave injetado é um campo que um consumidor pode omitir, e omiti-lo aqui
+// faria o painel escrever num nome torto — que é o defeito que este import acaba de fechar.
+import { KEYS } from '../platform/storage.js';
+import { gravarAlternancia } from '../input/latch-store.js';
+import { aplicarAlternancia, BASE_DA_MARCHA, } from '../input/latch-sync.js';
+import { recusaDaAlternancia } from './latch-refusal.js';
 // ---------------------------------------------------------------------------------------------
 // Pure logic (no `document`, testable in node)
 // ---------------------------------------------------------------------------------------------
 /** localStorage key for a player's Modo Fácil flag (== platform/storage.ts's `easy_p{i}` pattern). */
 export function easyKey(i) {
-    return 'incl_easy_p' + i;
+    // ⚠️ ERA A ÚLTIMA CÓPIA DO LITERAL neste ficheiro, e o irmão logo abaixo (`toggleRunKey`) já regista por
+    // extenso porque isso é defeito: «duas cópias de um nome mudam uma de cada vez». O `platform/storage` diz o
+    // resto — as chaves são funções «para impedir que um deles escreva num nome torto». Passada em 2026-09-08,
+    // ao acrescentar o terceiro irmão; um gate afirma agora que os três concordam com o `KEYS`.
+    return KEYS.easyP(i);
 }
-/** localStorage key da alternância do botão de CORRER (== `toggleRunP` de platform/storage). */
+/**
+ * localStorage key da alternância do botão de CORRER, na forma LEGADA (sem transporte).
+ *
+ * ⚠️ ERA UMA CÓPIA DO LITERAL, com um comentário ao lado a dizer «== `toggleRunP` de platform/storage» — o
+ * que é a admissão do defeito escrita como se fosse documentação. Duas cópias de um nome mudam uma de cada
+ * vez, e o `platform/storage` já tinha escrito a razão de as chaves serem funções: «virar função aqui é o
+ * que impede que um deles escreva num nome torto». Agora delega, e há um nome só.
+ *
+ * ⚠️ E É A CHAVE LEGADA. O ADR-0104 §C pôs o TRANSPORTE no nome, porque a alternância é do aparelho e não da
+ * pessoa; esta continua a ser lida para herdar o que a criança já tinha, e não é escrita. A chave nova é
+ * `chaveDaAlternancia`, em `input/latch-scope`.
+ */
 export function toggleRunKey(i) {
-    return 'incl_togglerun_p' + i;
+    return KEYS.toggleRunP(i);
+}
+/** localStorage key da alternância de MARCHA, por jogador. Delega, como os dois irmãos acima. */
+export function toggleMoveKey(i) {
+    return KEYS.toggleMoveP(i);
+}
+/**
+ * LIGA OU DESLIGA A ALTERNÂNCIA DE MARCHA DE UM JOGADOR — e agora é a engine que o faz (ADR-0106 §4).
+ *
+ * ⚠️ O COMENTÁRIO QUE JUSTIFICAVA A INJEÇÃO ARGUMENTAVA CONTRA ELA. Ele dizia: «SHARED setter (also used by
+ * the pause-menu quick icon `altmove`) — stays in game.js, injected». Ser partilhado por DUAS superfícies da
+ * engine é razão para a engine o possuir, não para o cartucho o guardar — e a medição de 2026-09-08 mostra
+ * que cada passo já era da engine: `toggleMove` e `walkDir` são campos do `PlayerBase`, a chave é do
+ * `platform/storage`, e `sr.motor.toggleMove*` são chaves i18n da engine. Não sobrava efeito de jogo nenhum,
+ * o que faz deste o mais limpo dos sete: aqui não há sequer um efeito colateral a injectar.
+ */
+export function definirAlternanciaDeMarcha(ctx, i, on) {
+    const p = ctx.players[i];
+    if (!p)
+        return;
+    // 📌 A REGRA DE DESLIGAR MORA NUM SÍTIO SÓ desde a issue #127: `aplicarAlternancia` põe o valor E pára quem
+    // anda por travamento. Ela era duas linhas aqui, e passou a ser partilhada com a sincronização da aresta
+    // (`input/latch-sync`) — que resolve a MESMA pergunta ao trocar de aparelho. Duas cópias do «senão a
+    // personagem anda sozinha» divergiriam no dia em que uma delas mudasse.
+    aplicarAlternancia(p, on);
+    // ⚠️ AS DUAS CHAVES, E A ANTIGA NÃO SAI AINDA — é a forma do `p.visual` ao lado do `p.viz` (#104 etapa 1a),
+    // e pela mesma razão: quem LÊ ainda é o cartucho, por `KEYS.toggleMoveP(i)` (`main.ts:540`). Parar de a
+    // escrever agora faria a criança perder a escolha no arranque seguinte — o defeito que o ADR-0113 nomeia
+    // como a cláusula que decide se a decisão custa um ajuste real no dia em que sai.
+    ctx.store.setBool(toggleMoveKey(i), on);
+    // 📌 E a chave NOVA, quando se sabe o aparelho. `gravarAlternancia` recusa-se nos quatro assistidos, onde
+    // não há escolha a guardar (ADR-0113 cláusula 3) — e devolve `false` para quem chama desabilitar o
+    // controle com o motivo dito. Aqui a recusa não muda mais nada: o valor em memória continua a ser o que
+    // a regra resolve, e é ela que responde `true` naqueles quatro.
+    const transporte = ctx.transporteEmUso ? ctx.transporteEmUso(i) : null;
+    if (transporte)
+        gravarAlternancia((chave, ligada) => ctx.store.setBool(chave, ligada), BASE_DA_MARCHA, i, transporte, on);
+    // 📌 O ANÚNCIO É INCONDICIONAL, ao contrário do `aplicarAlternancia`, que devolve «mudou». A criança
+    // carregou no ícone: calar-se porque o valor já era esse deixaria o botão sem resposta para quem ouve.
+    ctx.srSay(playerPrefix(i, ctx.getNumPlayers()) + t(on ? 'sr.motor.toggleMoveOn' : 'sr.motor.toggleMoveOff'));
 }
 /** Clamps the selected player back to 0 once it falls outside 0..numPlayers-1 (e.g. player count dropped). */
 export function clampSelPlayer(sel, numPlayers) {
@@ -59,9 +125,40 @@ export function easyAnnouncement(i, numPlayers, on) {
 // DOM-facing (thin) — requires `document`/injected ctx
 // ---------------------------------------------------------------------------------------------
 export function initSettingsMotor(ctx) {
+    // ⚠️ RESOLVIDO UMA VEZ: quem injecta manda, quem não injecta passa a ter. A engine sabe fazê-lo sozinha
+    // desde 2026-09-08 — ver definirAlternanciaDeMarcha, e o comentário do campo, que argumentava contra si.
+    const setToggleMove = ctx.setToggleMove ?? ((i, on) => definirAlternanciaDeMarcha(ctx, i, on));
     let selMovPlayer = 0; // jogador selecionado no painel Acessibilidade motora
     const facilBtn = ctx.$('#opt-facil');
     const altMoveBtn = ctx.$('#opt-altmove');
+    /**
+     * A DICA ORIGINAL DA LINHA, guardada uma vez.
+     *
+     * ⚠️ AQUI A RECUSA VAI E VEM, e é essa a diferença para o precedente. O `render/viz-setters` ACRESCENTA
+     * o motivo à dica e nunca o retira, o que é correcto lá: aquela lista é reconstruída a cada render. Este
+     * botão é persistente e a criança pode largar a webcam e voltar ao teclado — sem guardar o texto de
+     * origem, o motivo acumular-se-ia na linha a cada troca de aparelho.
+     */
+    const altMoveRow = altMoveBtn?.closest('.ctrl-row') ?? null;
+    const altMoveHint = altMoveRow?.querySelector('.opt-hint') ?? null;
+    const dicaOriginal = altMoveHint?.textContent ?? '';
+    /*
+     * ADR-0115 · A LINHA SOME NUM JOGO QUE NÃO SEGURA NADA — e some para TODA A GENTE.
+     *
+     * 🔴 `hidden` e não `aria-disabled`: a criança que depende da alternância abre este painel para a ligar, e
+     * num quiz não há nada para ela ligar. Um controle desabilitado com um motivo continua a ser um controle
+     * que não faz nada — e ainda ocupa um lugar na navegação por teclado, entre dois que funcionam.
+     * 📌 A cláusula 3 do ADR-0113 é o caso oposto e continua intacta: lá o aparelho EXIGE a alternância, o
+     * controle existe, e fica `aria-disabled` COM o motivo, alcançável para que ela possa lê-lo.
+     * ⚠️ E a linha é do CARTUCHO: a engine não a criou e por isso não a destrói. `hidden` é reversível e
+     * idempotente; remover markup alheio não é nenhuma das duas coisas.
+     */
+    if (!ctx.seguraTeclas && altMoveRow)
+        altMoveRow.hidden = true;
+    /** A recusa DESTE jogador agora, ou `null`. Recalculada a cada reflexo: o aparelho em uso muda. */
+    function recusaAgora(i) {
+        return ctx.transporteEmUso ? recusaDaAlternancia(ctx.transporteEmUso(i)) : null;
+    }
     const toggleRunBtn = ctx.$('#opt-togglerun');
     // barra acende se QUALQUER jogador usa Fácil/alternância
     function reflectMovementBtn() {
@@ -122,6 +219,23 @@ export function initSettingsMotor(ctx) {
             altMoveBtn.classList.toggle('is-on', on);
             altMoveBtn.setAttribute('aria-pressed', String(on));
             altMoveBtn.textContent = onOffLabel(on);
+            /*
+             * ⚠️ A CLÁUSULA 3 DO ADR-0113 NA TELA: onde a alternância é exigida, o controle NÃO SOME — fica
+             * `aria-disabled` e o motivo entra na dica, que a casca (`ui/settings-panel.fillExplain`) move para o
+             * rodapé. Sumir ensinaria que a coisa não existe; deixá-lo activo faria a criança carregar e não
+             * perceber por que nada mudou.
+             *
+             * 📌 E `aria-disabled` e não `disabled`: um botão desabilitado de verdade SAI da ordem de tabulação, e
+             * quem navega por teclado deixaria de o alcançar — logo deixaria de poder LER o motivo. É a mesma
+             * escolha que a #128 nomeia como defeito quando é feita ao contrário (só classe CSS, sem `aria`).
+             */
+            const recusa = recusaAgora(selMovPlayer);
+            if (recusa)
+                altMoveBtn.setAttribute('aria-disabled', 'true');
+            else
+                altMoveBtn.removeAttribute('aria-disabled');
+            if (altMoveHint)
+                altMoveHint.textContent = recusa ? `${dicaOriginal} ${t(recusa.chave)}`.trim() : dicaOriginal;
         }
         reflectMovementBtn();
     }
@@ -151,13 +265,26 @@ export function initSettingsMotor(ctx) {
                 reflectAltMove();
             });
         });
+        // A prosa volta para o rodapé depois de as linhas serem reconstruídas (CLAUDE.md §4, #109).
+        ctx.fillExplain?.(ctx.$('#movement .overlay__card'));
     }
     if (facilBtn) {
         facilBtn.addEventListener('click', () => setEasy(selMovPlayer, !ctx.players[selMovPlayer].easy));
     }
     if (altMoveBtn) {
         altMoveBtn.addEventListener('click', () => {
-            ctx.setToggleMove(selMovPlayer, !ctx.players[selMovPlayer].toggleMove);
+            /*
+             * ⚠️ RECUSAR DIZENDO, E NÃO EM SILÊNCIO. O precedente (`render/viz-setters`) resolve isto não ligando
+             * ouvinte nenhum — pode, porque reconstrói a lista a cada render. Aqui o ouvinte é ligado uma vez, e
+             * um `return` mudo seria «aceitar o clique e ignorá-lo», que é a outra metade do que o ADR-0076
+             * proíbe. Então a recusa FALA: quem carregou fica a saber por quê, mesmo sem ver a dica.
+             */
+            const recusa = recusaAgora(selMovPlayer);
+            if (recusa) {
+                ctx.srSay(t(recusa.chave));
+                return;
+            }
+            setToggleMove(selMovPlayer, !ctx.players[selMovPlayer].toggleMove);
             reflectAltMove();
         });
     }
@@ -191,7 +318,7 @@ export function initSettingsMotor(ctx) {
                 if (p.easy)
                     setEasy(i, false);
                 if (p.toggleMove)
-                    ctx.setToggleMove(i, false);
+                    setToggleMove(i, false);
                 if (p.toggleRun)
                     ctx.setToggleRun(i, false);
             });

package/dist-pkg/ui/settings-typo.d.ts

@@ -29,6 +29,20 @@ export interface SettingsTypoCtx {
      * continua desenhando. O que ele não pode é desenhar prosa duplicada, e sem casca não há rodapé para duplicar.
      */
     fillExplain?: (card: HTMLElement | null) => void;
+    /**
+     * ESTA FAMÍLIA ESTÁ INSTALADA NO APARELHO? — em produção, `(f) => doc.fonts.check(\`16px "${f}"\`)`.
+     *
+     * É o que transforma o «enquanto» do ADR-0012 em código: a opção da Ronde fica desabilitada ENQUANTO
+     * nenhuma das três faces estiver presente, e volta a ficar disponível quando o adulto instalar uma.
+     *
+     * ⚠️ INJECTADO E NUNCA `document.fonts` LIDO AQUI, pela regra que este ficheiro já segue para o `$`: um
+     * global do navegador num módulo que corre em node é o ACHADO 15, e este projecto já pagou por ele com um
+     * boot rebentado.
+     * 📌 OPCIONAL, e aqui o padrão é mesmo seguro — ao contrário do `seguraTeclas` do `PauseIconsCtx`, onde os
+     * dois lados erravam. Sem detector a linha fica desabilitada COM a mensagem, e a mensagem diz ao adulto as
+     * três fontes que resolvem. O estado por omissão é o de hoje, e é accionável.
+     */
+    fonteInstalada?: (familia: string) => boolean;
 }
 export interface SettingsTypoApi {
     /** Re-renders #typo-list from current selection and (re)wires its buttons. Idempotent. */
@@ -38,8 +52,16 @@ export interface SettingsTypoApi {
     /** Currently selected font key. */
     getFontKey: () => string;
 }
-/** A key is selectable when it exists in the catalog and is not marked `.off` (licence pending, etc.). */
-export declare function isSelectableFont(k: string): boolean;
+/**
+ * A key is selectable when it exists in the catalog, is not marked `.off` (licence pending, etc.) — and is
+ * `geral`.
+ *
+ * ⚠️ O TERCEIRO TERMO ENTROU EM 2026-09-07 (issue #87), e sem ele o resto da mudança seria decoração: o menu
+ * deixaria de OFERECER as caligráficas e elas continuariam SELECIONÁVEIS por qualquer outro caminho — o
+ * `resolveFontKey` de uma chave guardada, um `data-font` num markup de consumidor. «Não está na lista» e «não
+ * pode ser escolhida» têm de ser a mesma afirmação, ou a lista é só uma sugestão.
+ */
+export declare function isSelectableFont(k: string, instalada?: (familia: string) => boolean): boolean;
 export { resolveFontKey, persistFontKey } from './fonts.js';
 import type { DomQuery } from '../core/dom-query.js';
 export interface FontCssTarget {
@@ -67,8 +89,30 @@ export interface TypoGroupView {
     g: string;
     rows: TypoRow[];
 }
+/**
+ * UMA linha da lista, a partir de uma face do catálogo. Extraída em 2026-09-07 (issue #87) porque o gate do
+ * mecanismo `.off` precisava de a exercitar com uma face de MENTIRA: as duas únicas entradas desligadas
+ * saíram do roster, e um caso que dependa da composição do catálogo reprova sempre que o roster muda.
+ *
+ * O mecanismo fica, e é preciso: o item 4 da #87 usa-o para a **Ronde**, que só pode ser oferecida se uma de
+ * três faces estiver instalada, porque duas delas são gratuitas apenas para uso pessoal e não podem ser
+ * empacotadas.
+ */
+export declare function linhaDaFonte(it: FontItem, fontKey: string, instalada?: (familia: string) => boolean): TypoRow;
 /** Pure view-model for the typography list: which row is selected/disabled and its note, per catalog group. */
-export declare function typoGroups(fontKey: string): TypoGroupView[];
-/** Full innerHTML for #typo-list, given the currently selected key. Pure string building — no DOM. */
-export declare function typoListHTML(fontKey: string): string;
+export declare function typoGroups(fontKey: string, instalada?: (familia: string) => boolean): TypoGroupView[];
+/**
+ * Full innerHTML for #typo-list, given the currently selected key. Pure string building — no DOM.
+ *
+ * ⚠️ É UM GRUPO DE RÁDIO SÓ, ATRAVESSANDO AS TRÊS SECÇÕES, e isso é a decisão e não um detalhe de
+ * marcação: a exclusividade é do MENU inteiro — uma fonte activa no total —, não de cada família. Três
+ * grupos diriam a quem escuta que dá para ter uma sans E uma serif ao mesmo tempo.
+ *
+ * ⚠️ E ISTO DEIXOU DE SER UM INTERRUPTOR EM 2026-09-07. Era `class="mode-btn switch"` + `aria-pressed` +
+ * `toggleLabel()`, ou seja dezassete interruptores independentes anunciando «Ligado»/«Desligado» para
+ * escolher UMA fonte. A emenda do ADR-0012 diz o contrário em tantas palavras: «THE MENU IS A CHOICE, NOT
+ * A TOGGLE […] One font is active; the others are alternatives, not switches.» O `switch` do
+ * `style.css:427` desenha uma chave de 52×28 px com bolinha — era o desenho de um estado que não existe.
+ */
+export declare function typoListHTML(fontKey: string, instalada?: (familia: string) => boolean): string;
 export declare function initSettingsTypo(ctx: SettingsTypoCtx): SettingsTypoApi;