@the-inclusionist/engine 6.36.1

package/dist-pkg/core/scenes.js

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// core/scenes — A PILHA DE CENAS (item 22, opção C3 do ADR-0030). Módulo-FOLHA: zero dependências, zero I/O.
+//
+// ========================= O QUE ELA SUBSTITUI, E POR QUE NÃO É UM ENUM MAIOR =========================
+// Hoje o jogo tem `phase: 'title' | 'playing' | 'paused'` em `core/state`, lido por doze módulos. O ADR-0030
+// registra C1 — alargar essa união — como NÃO-OPÇÃO, e a razão é curta: um segundo jogo continuaria amarrado
+// ao NOSSO enum. Um jogo com tela de mapa, um com tela de resultados, um com senha entre sessões (item 23)
+// precisariam pedir uma constante nova na engine para existir.
+//
+// Uma PILHA não tem esse problema porque não tem vocabulário: ela sabe que há cenas empilhadas e nada sobre o
+// que cada uma significa. `title/playing/paused` vira `[titulo]`, `[jogo]`, `[jogo, pausa]` — e um mapa de
+// fases vira `[mapa]` sem que este arquivo mude uma linha.
+//
+// ========================= AS TRÊS REGRAS, E O QUE CADA UMA PRESERVA =========================
+// Elas não são convenção de biblioteca: cada uma reproduz um comportamento que o jogo já tem.
+//
+//   · `update` SÓ NO TOPO. É o congelamento da pausa. Hoje ele é `if (phase !== 'playing') return` espalhado;
+//     aqui é estrutural — uma cena que não está no topo não recebe tempo, ponto.
+//   · `draw` DE BAIXO PARA CIMA. É o menu de pausa desenhado SOBRE o mundo, com o mundo ainda visível. Se
+//     desenhasse só o topo, pausar apagaria o jogo da tela.
+//   · `input` SÓ NO TOPO, e ele DIZ se consumiu. É a mesma forma que o ADR-0033 deu à entrada modal: quem
+//     está por cima decide, e o que ele não quer volta a descer. Sem o retorno, a pilha teria de adivinhar.
+//
+// ========================= O QUE ELA NÃO FAZ =========================
+// Não desenha, não escuta evento, não conhece PIXI nem DOM. Recebe `dt` e devolve nada; recebe uma intenção e
+// devolve um booleano. É o que a torna testável sem navegador e importável dos dois lados da fronteira.
+/**
+ * Cria uma pilha vazia.
+ *
+ * ⚠️ `enter`/`exit` são chamados em TRY/CATCH? NÃO — e é decisão, não esquecimento. Um erro dentro de
+ * `enter()` significa que a cena não montou; engolir isso deixaria a pilha num estado que ninguém declarou, e
+ * o sintoma apareceria três quadros depois, longe da causa. As chamadas de `update`/`draw`/`input` também
+ * propagam: a engine não é o lugar de decidir que o erro de um jogo não importa.
+ */
+export function criarPilha() {
+    const pilha = [];
+    return {
+        push(s) {
+            pilha[pilha.length - 1]?.exit?.();
+            pilha.push(s);
+            s.enter?.();
+        },
+        pop() {
+            const fora = pilha.pop() ?? null;
+            fora?.exit?.();
+            pilha[pilha.length - 1]?.enter?.();
+            return fora;
+        },
+        replace(s) {
+            // NÃO é `this.pop()` seguido de `this.push(s)`: isso daria `enter()` à cena de baixo por um instante,
+            // e ela reapareceria no topo entre as duas chamadas. Trocar é UMA transição, não duas.
+            const fora = pilha.pop() ?? null;
+            fora?.exit?.();
+            pilha.push(s);
+            s.enter?.();
+        },
+        top() { return pilha[pilha.length - 1] ?? null; },
+        nomes() { return pilha.map((s) => s.nome); },
+        update(dt) { pilha[pilha.length - 1]?.update?.(dt); },
+        draw() { for (const s of pilha)
+            s.draw?.(); },
+        input(intent) { return pilha[pilha.length - 1]?.input?.(intent) === true; },
+    };
+}

package/dist-pkg/core/screens.d.ts

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** Colunas e linhas da grade para `n` telas. */
+export interface ScreenGrid {
+    cols: number;
+    rows: number;
+}
+/**
+ * A grade para `n` jogadores: 1 -> 1x1 · 2 -> 2x1 · 3 e 4 -> 2x2.
+ * `n` menor que 1 devolve a grade de uma tela, e não zero colunas.
+ */
+export declare function screenGrid(n: number): ScreenGrid;
+/** Dimensões em pixels de arte da grade de `n` telas (320x180 por tela — o pixel canônico do ADR-0010). */
+export declare function screenBaseSize(n: number): {
+    w: number;
+    h: number;
+};

package/dist-pkg/core/screens.js

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// core/screens — a grade de telas do multiplayer, num só lugar.
+//
+// O jogo divide a janela em uma tela por jogador (pilar: multiplayer em telas SEPARADAS, sem split-screen —
+// ADR-0010). Quantas colunas e quantas linhas isso dá era uma conta de uma linha copiada em CINCO lugares:
+// ui/layout.ts (escala inteira), render/crt.ts (só as linhas, para o passo do scanline), ui/hud.ts (posição
+// de cada `.player-screen`), e no game.js em configureRender() e fitsN().
+//
+// A quinta cópia estava DIVERGENTE: `cols = n<=2 ? n : 2`, sem a guarda de `n<=1`. Para n>=1 as duas contas
+// concordam, então a divergência nunca chegou a aparecer — com n=0 uma devolve 1 e a outra devolve 0, e
+// dividir por 0 colunas daria NaN em toda a geometria. Vale a pena guardar essa história: a cópia errada
+// sobreviveu justamente porque o caso onde ela erra é inalcançável hoje, e não porque alguém a conferiu.
+//
+// Módulo FOLHA de propósito: zero dependências, nem de estado. `n` é parâmetro, nunca `numPlayers` global —
+// é isso que deixa a conta testável e que permite o render, o layout e o HUD importarem daqui sem que um
+// passe a depender do outro.
+/**
+ * A grade para `n` jogadores: 1 -> 1x1 · 2 -> 2x1 · 3 e 4 -> 2x2.
+ * `n` menor que 1 devolve a grade de uma tela, e não zero colunas.
+ */
+export function screenGrid(n) {
+    return { cols: n <= 1 ? 1 : (n <= 2 ? n : 2), rows: n <= 2 ? 1 : 2 };
+}
+/** Dimensões em pixels de arte da grade de `n` telas (320x180 por tela — o pixel canônico do ADR-0010). */
+export function screenBaseSize(n) {
+    const { cols, rows } = screenGrid(n);
+    return { w: 320 * cols, h: 180 * rows };
+}

package/dist-pkg/core/state.d.ts

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * ========================= O BARRAMENTO, TIPADO (Fase C do plano) =========================
+ *
+ * Era `emit(evt: string, val: unknown)`. Duas coisas erradas numa assinatura só:
+ *
+ *   · O NOME ERA `string`. Um `emit('viz', …)` em vez de `'vizMode'` não é erro em lugar nenhum — é
+ *     SILÊNCIO. O assinante certo nunca é chamado, nada fica vermelho, e a única pista é um painel que
+ *     parou de se atualizar. Hoje são dezessete pontos de emissão e cada nome aparece UMA vez; a chance de
+ *     digitar errado é exatamente a chance de escrever a próxima linha.
+ *   · A CARGA ERA `unknown`. Quem assinasse tinha de converter, e a conversão é onde a mentira entra.
+ *
+ * Agora `EventoDoJogo` é um mapa nome → carga, e `emit`/`on` são genéricos sobre ele. Nome inexistente não
+ * compila; carga errada não compila.
+ *
+ * ⚠️ POR QUE ISTO EXISTE ANTES DE TER ASSINANTE. Hoje o barramento tem ZERO `on()` em produção (só o teste
+ * assina). Um mecanismo sem uso normalmente é dívida — mas este precisa nascer tipado, não ser retipado
+ * depois: o ADR-0031 já exige que painéis e atividades se redesenhem quando a criança muda idioma ou fonte,
+ * e a casca do `demos` vai reagir a ajuste durante a partida. O primeiro assinante chega com o contrato
+ * pronto, em vez de chegar e ser seguido por uma migração.
+ */
+export interface EventoDoJogo {
+    numPlayers: number;
+    vizMode: string;
+    modoCego: boolean;
+    letterCase: LetterCase;
+    captionsOn: boolean;
+    menuIndexOn: boolean;
+    cbSafe: boolean;
+    ownerColors: boolean;
+    hcOutlineFg: OutlineLevel;
+    hcOutlineBg: OutlineLevel;
+    caneBlockDiv: number;
+    wheelchair: boolean;
+    oneButton: boolean;
+}
+type Ouvinte<K extends keyof EventoDoJogo> = (val: EventoDoJogo[K]) => void;
+/** Assina `evt`. Devolve a função que cancela — guardar o retorno é mais barato que lembrar do `off`. */
+export declare function on<K extends keyof EventoDoJogo>(evt: K, fn: Ouvinte<K>): () => void;
+export declare function off<K extends keyof EventoDoJogo>(evt: K, fn: Ouvinte<K>): void;
+/**
+ * Avisa os assinantes de `evt`. EXPORTADO desde 2026-08-25 (item 19) porque `game/state` emite pelos mesmos
+ * canais: um segundo mapa de assinantes seria um segundo barramento, e quem assinasse `coins` no lugar errado
+ * simplesmente não seria avisado — sem erro, sem teste vermelho.
+ *
+ * O `try` em volta de cada assinante NÃO é preguiça: um ouvinte que estoura não pode impedir os outros de
+ * receber. Um painel quebrado derruba o painel; não derruba o jogo.
+ */
+export declare function emit<K extends keyof EventoDoJogo>(evt: K, val: EventoDoJogo[K]): void;
+export declare let vizMode: string;
+export declare function initVizMode(mode: string): void;
+export declare function setVizModeValue(mode: string): void;
+/**
+ * OS PADRÕES, com nome. Um valor por linha, e cada um usado em DOIS lugares: a leitura do boot (quando não há
+ * nada gravado) e o "restaurar padrões" do menu que o contém (ADR-0028).
+ *
+ * Existe porque a alternativa é escrever o mesmo padrão duas vezes — uma no `store.getBool(chave, X)` e outra
+ * no reset — e este repositório já mostrou quatro vezes o que acontece com duas cópias que ninguém obriga a
+ * concordar. Aqui a divergência seria pior que as anteriores: um reset que restaura um valor DIFERENTE do que
+ * o jogo usa quando nunca foi configurado deixa a criança num terceiro estado, que não é nem o dela nem o de
+ * fábrica, e que ela não tem como nomear para pedir ajuda.
+ *
+ * `as const` + `Object.freeze` de propósito: um padrão que alguém consiga escrever em tempo de execução deixa
+ * de ser padrão.
+ */
+/**
+ * O padrão do MOVIMENTO REDUZIDO não é uma constante — é o que o sistema operacional pede.
+ *
+ * Mora aqui, ao lado do DEFAULTS, porque a regra do ADR-0029 é que existe UMA fonte sobre o que é padrão, e
+ * um padrão calculado não deixa de ser padrão por não caber num objeto congelado. Quem lê isto: a carga do
+ * boot (main.js) e o "restaurar padrões" do menu de sensibilidade visual.
+ *
+ * Por que importa que o reset leia isto em vez de `false`: numa máquina cujo dono pediu menos movimento,
+ * devolver `false` RELIGARIA a animação — o reset passaria a fazer, sozinho, exatamente o que a WCAG 2.3.3
+ * existe para impedir, e faria isso na tela de quem já tinha dito que não aguenta.
+ *
+ * `matchMedia` é guardado: este módulo roda no projeto `node` dos testes, onde `window` não existe.
+ */
+export declare function defaultReducedMotion(): boolean;
+export declare const DEFAULTS: Readonly<{
+    readonly modoCego: false;
+    readonly caneBlockDiv: 1;
+    readonly captionsOn: true;
+    readonly menuIndexOn: true;
+    readonly wheelchair: false;
+    readonly oneButton: false;
+    readonly easy: false;
+    readonly toggleMove: false;
+    readonly toggleRun: false;
+    readonly cbSafe: false;
+    readonly ownerColors: true;
+    readonly lq: 0;
+    readonly hcOutlineFg: 1;
+    readonly hcOutlineBg: 1;
+    readonly letterCase: "upper";
+}>;
+export declare let modoCego: boolean;
+export declare function setModoCegoValue(on: boolean): void;
+/**
+ * Um tile do portão. O portão é uma LISTA deles, não um objeto com posição — escrevi `{x, y}` na primeira
+ * versão e o navegador me desmentiu: `gate` é `[{tx:29,ty:36}, {tx:30,ty:36}, …]`.
+ *
+ * O `tsc` não podia pegar. Quem chama `setLevelExtras` é o `main.js`, que é JavaScript, então o tipo declarado
+ * aqui não tinha do outro lado nada que o contradissesse. É um argumento concreto para o `createGame()` do
+ * passo 4 nascer em TypeScript: enquanto o composition root for JS, todo contrato que só ele exercita é uma
+ * afirmação sem verificador.
+ *
+ * Mínimo ESTRUTURAL, como o `PlayerQuiz`: o `MapGateTile` de verdade mora em `game/level-geometry` e é
+ * atribuível a este. `core/` não importa de `game/`.
+ */
+export interface GateTile {
+    readonly tx: number;
+    readonly ty: number;
+}
+export type LetterCase = 'mixed' | 'upper';
+export declare let letterCase: LetterCase;
+export declare function setLetterCaseValue(c: LetterCase): void;
+export declare let captionsOn: boolean;
+export declare function setCaptionsOnValue(on: boolean): void;
+export declare let menuIndexOn: boolean;
+export declare function setMenuIndexOnValue(on: boolean): void;
+export declare let cbSafe: boolean;
+export declare function setCbSafeValue(on: boolean): void;
+export declare let ownerColors: boolean;
+export declare function setOwnerColorsValue(on: boolean): void;
+/** Espessura de contorno: 0 nenhum · 1 fino · 2 grosso. Fora da faixa satura, não rejeita. */
+export type OutlineLevel = 0 | 1 | 2;
+export declare let hcOutlineFg: OutlineLevel;
+export declare function setOutlineFgValue(v: number): void;
+export declare let hcOutlineBg: OutlineLevel;
+export declare function setOutlineBgValue(v: number): void;
+export declare let caneBlockDiv: number;
+export declare function setCaneBlockDivValue(div: number): void;
+export declare let wheelchair: boolean;
+export declare function setWheelchairValue(on: boolean): void;
+export declare let oneButton: boolean;
+export declare function setOneButtonValue(on: boolean): void;
+export {};

package/dist-pkg/core/state.js

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// core/state.ts — estado/cena do jogo (FONTE ÚNICA). Módulo-folha. As 8 mega-variáveis migram do game.js
+// UMA A UMA, lidas como binding vivo (import) e escritas por setter.
+// Bus mínimo (Map<evento, Set<fn>>) para os poucos leitores "de longe" que virão com os outros subsistemas.
+import * as store from '../platform/storage.js'; // persistência (as mega-vars com chave leem/gravam aqui)
+const _subs = new Map();
+/** Assina `evt`. Devolve a função que cancela — guardar o retorno é mais barato que lembrar do `off`. */
+export function on(evt, fn) {
+    if (!_subs.has(evt))
+        _subs.set(evt, new Set());
+    _subs.get(evt).add(fn);
+    return () => off(evt, fn);
+}
+export function off(evt, fn) {
+    const s = _subs.get(evt);
+    if (s)
+        s.delete(fn);
+}
+/**
+ * Avisa os assinantes de `evt`. EXPORTADO desde 2026-08-25 (item 19) porque `game/state` emite pelos mesmos
+ * canais: um segundo mapa de assinantes seria um segundo barramento, e quem assinasse `coins` no lugar errado
+ * simplesmente não seria avisado — sem erro, sem teste vermelho.
+ *
+ * O `try` em volta de cada assinante NÃO é preguiça: um ouvinte que estoura não pode impedir os outros de
+ * receber. Um painel quebrado derruba o painel; não derruba o jogo.
+ */
+export function emit(evt, val) {
+    const s = _subs.get(evt);
+    if (s)
+        for (const fn of s) {
+            try {
+                fn(val);
+            }
+            catch (e) { /* noop */ }
+        }
+}
+// ========================= `phase` SAIU DAQUI (ADR-0030 C3, passo 3 da Fase B) =========================
+// Ele não virou campo de fábrica como os outros doze de RODADA: virou uma PILHA. `core/scenes` já existia,
+// testado e sem consumidor; agora a raiz de composição o usa, e `title`/`playing`/`paused` são
+// `[titulo]`, `[jogo]` e `[jogo, pausa]`.
+//
+// A diferença que motivou a troca: `phase === 'paused'` APAGAVA a informação de que há um jogo por baixo. A
+// pilha a mantém, e é dela que sai "o mundo continua desenhado, mas não recebe tempo".
+//
+// E o ADR-0030 registra ALARGAR a união (`'mapa' | 'resultado' | …`) como NÃO-OPÇÃO: um segundo jogo
+// continuaria amarrado ao NOSSO vocabulário, e teria de pedir uma constante nova à engine para existir. Por
+// isso os três nomes não moram em módulo nenhum da engine — moram na raiz, que é este jogo. Quem é engine
+// recebe BOOLEANOS: `mundoRodando()`, `menuDePausa()`, `telaDeTitulo`. É a mesma correção que o
+// `consumer-quiz` obrigou a fazer no `menu-nav` (`getPhase()` → `isNavigable()`), registrada em
+// `core/constants` como o erro a não repetir.
+/* (`quizLevel` SAIU daqui em 2026-08-25, item 19 — está em `game/state`. É o nível da atividade de
+ *  alfabetização: conteúdo pedagógico, e nem sequer mecânica de engine. A regra é a do ADR-0033, aplicada ao
+ *  estado: o estado COMPARTILHADO guarda o que a engine possui — acessibilidade, idioma, dispositivo.) */
+// ========================= O RESTO DA RODADA SAIU DAQUI (ADR-0038, Fase B) =========================
+// `ended`, `decorSeed`, `grassDensity`, `selVizPlayer` e `pauseActor` foram para `core/run-state`, na
+// segunda fatia do passo 2. Nenhum deles persiste — que é o critério do corte —, e todos eram importados
+// APENAS pelo composition root, o que manteve a mudança em dois arquivos, como na primeira fatia.
+//
+// O CLAMP do `grassDensity` foi junto, e ele é a razão de aquele setter existir: a fração vinha protegida só
+// para quem entrasse pelo `window.__incl`, e qualquer outro caminho podia gravar 5 ou -1. Deixá-lo para trás
+// transformaria a fábrica num `let` com nome novo.
+//
+// E a fatia grande saiu em 2026-08-26: `players` e `numPlayers`, com quatorze importadores CADA. Com o
+// `phase` indo para a pilha de cenas no mesmo dia, a RODADA saiu INTEIRA daqui — este módulo é só de PÁGINA
+// agora, e `tests/lifetime-gate.node.test.ts` afirma isso a cada rodada de testes.
+// ========================= `cenario` E `activity` SAÍRAM DAQUI (ADR-0038, Fase B) =========================
+// Os dois eram estado de JOGO morando na engine — a mesma exceção que o `coins` e o `quizLevel` já haviam
+// deixado no item 19. O corte por LIFETIME do ADR-0038 os classifica como GAME: ambos são persistidos em
+// chave `kJogo()`, que é o critério mecânico, e ambos viajam com o cartucho quando o jogo mudar de
+// repositório (ADR-0036).
+//
+// Moram agora em `game/state`, com a MESMA forma — binding vivo + setter que persiste e emite. O que mudou
+// foi só o endereço, e é isso que torna a mudança conferível.
+//
+// Um consumidor precisou de mais que um import novo: `ui/activities-menu` é ENGINE, e o gate de fronteira
+// proíbe engine importar de `game/` (a lista dele esvaziou em 2026-08-25). Ele passou a receber
+// `getActivityId`/`setActivityId` por injeção, que é o que a raiz de composição existe para fazer.
+// --- vizMode: modo visual/cor ativo (persistido em incl_viz). A validação (VIZ_CYCLE) e o default por
+//     prefers-contrast ficam no game.js. initVizMode NÃO persiste (o default de mídia deve seguir o SO a cada
+//     boot; persistir travaria o rastreio de prefers-contrast). Mudanças do usuário usam setVizModeValue. ---
+export let vizMode = 'normal';
+export function initVizMode(mode) { vizMode = mode; }
+export function setVizModeValue(mode) { vizMode = mode; store.set('incl_viz', mode); emit('vizMode', mode); }
+/* (`coins` SAIU daqui em 2026-08-25, item 19 — está em `game/state`. Ele era `unknown[]` porque `core/` não
+ *  podia conhecer o tipo, e esse `unknown` era o SINTOMA: um estado que não consegue declarar o próprio tipo
+ *  está na camada errada. Do outro lado da fronteira ele é `unknown[]` ainda, mas por escolha de quem pode
+ *  decidir — e o `game/coins` que o consome sabe exatamente o que há dentro.) */
+// ========================= `players` E `numPlayers` SAÍRAM DAQUI (ADR-0038, Fase B) =========================
+// Os dois são RODADA pelo critério mecânico do ADR-0038 — nenhum é persistido —, e moram em
+// `core/run-state`, na instância que a raiz de composição possui.
+//
+// O `players` era o caso mais caro de todos os treze. Um `export let` é um binding vivo COMPARTILHADO: dois
+// jogos na mesma página (que é o que a casca do `demos` faz, ADR-0036) veriam a MESMA lista, e o segundo
+// começaria com os jogadores do primeiro ainda dentro. Não haveria erro em lugar nenhum — só uma criança a
+// mais na tela.
+//
+// A referência continua sendo mutada NO LUGAR (`push`/`length`/`players[i]`), e é por isso que a rodada não
+// tem setter para ela: trocar a lista inteira deixaria para trás as referências que os módulos já guardaram.
+// Quem entra e quem sai é `game/session`, e só ele recebe a lista mutável.
+//
+// (O tipo continua sendo `Player[]` — a visão da ENGINE. Cada jogo acrescenta campos e estreita por conta
+//  própria, que é o que o ADR-0033 desenhou.)
+/**
+ * OS PADRÕES, com nome. Um valor por linha, e cada um usado em DOIS lugares: a leitura do boot (quando não há
+ * nada gravado) e o "restaurar padrões" do menu que o contém (ADR-0028).
+ *
+ * Existe porque a alternativa é escrever o mesmo padrão duas vezes — uma no `store.getBool(chave, X)` e outra
+ * no reset — e este repositório já mostrou quatro vezes o que acontece com duas cópias que ninguém obriga a
+ * concordar. Aqui a divergência seria pior que as anteriores: um reset que restaura um valor DIFERENTE do que
+ * o jogo usa quando nunca foi configurado deixa a criança num terceiro estado, que não é nem o dela nem o de
+ * fábrica, e que ela não tem como nomear para pedir ajuda.
+ *
+ * `as const` + `Object.freeze` de propósito: um padrão que alguém consiga escrever em tempo de execução deixa
+ * de ser padrão.
+ */
+/**
+ * O padrão do MOVIMENTO REDUZIDO não é uma constante — é o que o sistema operacional pede.
+ *
+ * Mora aqui, ao lado do DEFAULTS, porque a regra do ADR-0029 é que existe UMA fonte sobre o que é padrão, e
+ * um padrão calculado não deixa de ser padrão por não caber num objeto congelado. Quem lê isto: a carga do
+ * boot (main.js) e o "restaurar padrões" do menu de sensibilidade visual.
+ *
+ * Por que importa que o reset leia isto em vez de `false`: numa máquina cujo dono pediu menos movimento,
+ * devolver `false` RELIGARIA a animação — o reset passaria a fazer, sozinho, exatamente o que a WCAG 2.3.3
+ * existe para impedir, e faria isso na tela de quem já tinha dito que não aguenta.
+ *
+ * `matchMedia` é guardado: este módulo roda no projeto `node` dos testes, onde `window` não existe.
+ */
+export function defaultReducedMotion() {
+    return !!(typeof window !== 'undefined' && window.matchMedia && window.matchMedia('(prefers-reduced-motion: reduce)').matches);
+}
+export const DEFAULTS = Object.freeze({
+    // auditiva
+    modoCego: false,
+    caneBlockDiv: 1,
+    captionsOn: true,
+    menuIndexOn: true, // o indice nasce LIGADO: quem nao sabe que ele existe e quem mais precisa dele
+    // motora
+    wheelchair: false,
+    oneButton: false,
+    easy: false, // por jogador (Modo Fácil)
+    toggleMove: false, // por jogador (movimento por alternância)
+    // A alternância do botão de CORRER nasce desligada de FÁBRICA — e liga sozinha no controle de tela, que é
+    // contexto e não escolha. A distinção importa para a marca do ADR-0029: ver `refreshMarks` em
+    // ui/settings-motor, que marca a ESCOLHA guardada e não o estado.
+    toggleRun: false, // por jogador (alternância do botão de correr)
+    // visual
+    cbSafe: false,
+    ownerColors: true,
+    lq: 0, // realce de contraste L→Q desligado
+    hcOutlineFg: 1,
+    hcOutlineBg: 1,
+    // comunicação (hoje só a caixa da letra; o menu de CAA do ADR-0028 amplia isto)
+    letterCase: 'upper',
+});
+// --- modoCego: MODO CEGO (A12e auditiva). Só as ajudas de áudio — bengala, sonar, guarda de beirada,
+//     narração —, sem tela preta; a simulação de cegueira do Modo Empatia é outra coisa e liga esta por cima.
+//
+//     Migrado do main.js (ADR-0027 passo 4 / #50). Era a variável com MAIS encanamento de injeção do projeto:
+//     dezesseis pontos em seis módulos passavam `getModoCego`/`setModoCego` por ctx, e a colisão a lia por
+//     closure. Estado que seis módulos consultam não é do composition root; e enquanto for, `createGame()` não
+//     pode existir sem capturá-la, que é justamente o teste de fronteira que o ADR-0027 quer rodar.
+//
+//     O SETTER FAZ TRÊS COISAS E SÓ TRÊS: grava, persiste, avisa. Os efeitos que o main.js pendurava no
+//     antigo `setModoCego` — refazer os extras do nível, refletir o painel, anunciar ao leitor de tela — NÃO
+//     entram aqui: são reação, e quem reage assina o evento. Um setter que sabe redesenhar a tela é um setter
+//     que nenhum teste consegue chamar. ---
+export let modoCego = store.getBool('incl_modocego', DEFAULTS.modoCego);
+export function setModoCegoValue(on) {
+    if (modoCego === on)
+        return; // a guarda VEM DO ORIGINAL: sem ela o anúncio repetiria a cada clique redundante
+    modoCego = on;
+    store.setBool('incl_modocego', on);
+    emit('modoCego', on);
+}
+export let letterCase = store.get(store.KEYS.letterCase, DEFAULTS.letterCase) === 'upper' ? 'upper' : 'mixed';
+export function setLetterCaseValue(c) {
+    if (letterCase === c)
+        return;
+    letterCase = c;
+    store.set(store.KEYS.letterCase, c);
+    emit('letterCase', c);
+}
+export let captionsOn = store.getBool(store.KEYS.captions, DEFAULTS.captionsOn);
+export function setCaptionsOnValue(on) {
+    const v = !!on;
+    if (captionsOn === v)
+        return;
+    captionsOn = v;
+    store.setBool(store.KEYS.captions, v);
+    emit('captionsOn', v);
+}
+// --- menuIndexOn: o "6 de 10" no fim do anuncio de cada item de menu (ADR-0044, item 3).
+//
+//     NASCE LIGADO, e a razao e a mesma do modo cego nascer com TTS e sonar: quem precisa do indice para se
+//     orientar nao tem como saber que ele existe se ele vier desligado. Quem NAO precisa descobre o ajuste
+//     lendo o menu, que e justamente a coisa que essa pessoa consegue fazer.
+//
+//     PERSISTE em `incl_menuindex` (escopo da CRIANCA, ADR-0027): a preferencia segue com ela de jogo em jogo.
+export let menuIndexOn = store.getBool(store.KEYS.menuIndex, DEFAULTS.menuIndexOn);
+export function setMenuIndexOnValue(on) {
+    const v = !!on;
+    if (menuIndexOn === v)
+        return;
+    menuIndexOn = v;
+    store.setBool(store.KEYS.menuIndex, v);
+    emit('menuIndexOn', v);
+}
+// --- cbSafe: PALETA SEGURA PARA DALTONISMO (Okabe-Ito). Não é um filtro sobre a imagem — é a escolha das
+//     cores de origem, aplicada IN-PLACE em PCOLOR para que todo mundo que já referencia a array veja a troca. ---
+export let cbSafe = store.getBool(store.KEYS.cbsafe, DEFAULTS.cbSafe);
+export function setCbSafeValue(on) {
+    const v = !!on;
+    if (cbSafe === v)
+        return;
+    cbSafe = v;
+    store.setBool(store.KEYS.cbsafe, v);
+    emit('cbSafe', v);
+}
+// --- ownerColors: no multijogador, cada item aparece na cor de QUEM pode pegá-lo. Desligado, todos veem a cor
+//     original — o que é preferível para quem não distingue as cores dos donos. ---
+export let ownerColors = store.getBool(store.KEYS.ownercolors, DEFAULTS.ownerColors);
+export function setOwnerColorsValue(on) {
+    const v = !!on;
+    if (ownerColors === v)
+        return;
+    ownerColors = v;
+    store.setBool(store.KEYS.ownercolors, v);
+    emit('ownerColors', v);
+}
+const nivelContorno = (v) => Math.max(0, Math.min(2, v | 0));
+// --- hcOutlineFg / hcOutlineBg: CONTORNOS do alto contraste, e são dois porque servem a critérios diferentes.
+//     `fg` contorna o primeiro plano — personagem e itens — e atende a WCAG 2.4.7 (foco visível). `bg` contorna
+//     o perímetro externo de plataforma, água e lava, delimitando navegável × não-navegável, e atende a
+//     WCAG 1.4.11 (contraste de componente ≥ 3:1). Confundi-los apagaria uma das duas garantias.
+//
+//     A saturação em 0..2 vem do original e é dupla: no boot (contra um localStorage corrompido) e na escrita
+//     (contra um chamador). No main.js isso obrigava a declarar com um valor provisório e reatribuir na linha
+//     seguinte, porque a leitura saturada não cabia no mesmo `let`; aqui a função a resolve de uma vez. ---
+export let hcOutlineFg = nivelContorno(store.getNum(store.KEYS.outfg, DEFAULTS.hcOutlineFg));
+export function setOutlineFgValue(v) {
+    const n = nivelContorno(v);
+    if (hcOutlineFg === n)
+        return;
+    hcOutlineFg = n;
+    store.set(store.KEYS.outfg, n);
+    emit('hcOutlineFg', n);
+}
+export let hcOutlineBg = nivelContorno(store.getNum(store.KEYS.outbg, DEFAULTS.hcOutlineBg));
+export function setOutlineBgValue(v) {
+    const n = nivelContorno(v);
+    if (hcOutlineBg === n)
+        return;
+    hcOutlineBg = n;
+    store.set(store.KEYS.outbg, n);
+    emit('hcOutlineBg', n);
+}
+// --- caneBlockDiv: espaçamento da batida da BENGALA, em blocos pisados. 1 = uma batida por bloco;
+//     2 = uma batida a cada meio bloco. Não é preferência de som: é a resolução com que uma criança cega
+//     mede a distância que andou, e por isso a colisão a lê a cada passo. ---
+export let caneBlockDiv = store.getNum('incl_cane_div', DEFAULTS.caneBlockDiv) || DEFAULTS.caneBlockDiv;
+export function setCaneBlockDivValue(div) {
+    const d = (+div) || 1; // o `|| 1` vem do original: um valor corrompido no localStorage viraria NaN e a
+    if (caneBlockDiv === d)
+        return; //  bengala pararia de bater, que é o modo de falha mais silencioso possível
+    caneBlockDiv = d;
+    store.set('incl_cane_div', d);
+    emit('caneBlockDiv', d);
+}
+// --- wheelchair: MODO CADEIRANTE. Muda a geometria do nível inteiro — degraus e escada viram rampas e
+//     elevadores, moedas descem para o chão, lava vira chão, e só voo e super-corrida sobrevivem como poderes.
+//     Por isso a colisão a lê: `isSolidType` responde diferente com ela ligada. ---
+export let wheelchair = store.getBool('incl_wheelchair', DEFAULTS.wheelchair);
+export function setWheelchairValue(on) {
+    if (wheelchair === on)
+        return;
+    wheelchair = on;
+    store.setBool('incl_wheelchair', on);
+    emit('wheelchair', on);
+}
+// --- oneButton: UM BOTÃO POR VEZ. Ignora combinações simultâneas, para quem não consegue pressionar duas
+//     teclas ao mesmo tempo. ---
+export let oneButton = store.getBool('incl_onebtn', DEFAULTS.oneButton);
+export function setOneButtonValue(on) {
+    if (oneButton === on)
+        return;
+    oneButton = on;
+    store.setBool('incl_onebtn', on);
+    emit('oneButton', on);
+}

package/dist-pkg/core/tiles.d.ts

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+export declare const TYPE_GLYPH: Record<number, string>;
+export declare const TILE_NAME: Record<number, string>;
+export declare const GLYPH_TYPE: Record<string, number>;
+export declare function parseLevel(text: string): number[][];
+export declare function gridToGlyphs(grid: number[][]): string;
+export declare function selfTest(): {
+    ok: boolean;
+    unique: boolean;
+    invertible: boolean;
+    missing: number[];
+};

package/dist-pkg/core/tiles.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// core/tiles.ts — Legend de tiles + parser do mapa em texto-glifo (1 glifo significativo por tile). Módulo-folha,
+// ZERO deps. O jogo NÃO lê Tiled/Aseprite em runtime — só este texto-glifo, legível/diffável como ascii art.
+// tipo (0–14) → glifo. Terreno = símbolos; power-ups = LETRAS maiúsculas mnemônicas.
+export const TYPE_GLYPH = {
+    1: '.', // ar (iluminado)
+    0: ':', // ar escuro / região secreta
+    2: '#', // pedra / chão sólido
+    6: '=', // parede dura (sem quicar)
+    3: '~', // água
+    4: 'H', // escada
+    5: '^', // trampolim
+    9: 'x', // lava / perigo
+    10: '|', // portão
+    11: '*', // chave
+    7: 'S', // power-up super-pulo
+    8: 'F', // power-up voo
+    12: 'T', // power-up super-corrida (turbo)
+    13: 'U', // power-up ultra-pulo
+    14: 'C', // power-up ventosa (cling)
+};
+// tipo → nome legível (UI e editor de mapa). Uma verdade só.
+export const TILE_NAME = {
+    0: 'ar escuro/secreto', 1: 'ar', 2: 'pedra', 3: 'água', 4: 'escada', 5: 'trampolim', 6: 'parede',
+    7: 'super-pulo', 8: 'voo', 9: 'lava/perigo', 10: 'portão', 11: 'chave', 12: 'super-corrida',
+    13: 'ultra-pulo', 14: 'ventosa',
+};
+// glifo → tipo (inverso). Construído do TYPE_GLYPH para não divergir.
+export const GLYPH_TYPE = Object.fromEntries(Object.entries(TYPE_GLYPH).map(([t, g]) => [g, +t]));
+const AIR = 1; // glifo desconhecido / vazio à direita → ar iluminado
+// Texto-glifo → grid numérico. Preserva o comprimento de cada linha (mapa é irregular; o buildWorld preenche
+// o vazio à direita com ar). Linhas iniciadas por "#!" são meta (nome/autor) e são ignoradas — "#" sozinho é
+// parede, então o marcador de meta é "#!" no INÍCIO da linha.
+export function parseLevel(text) {
+    const rows = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (line.startsWith('#!'))
+            continue; // meta
+        if (line.length === 0)
+            continue; // linha vazia (ex.: \n final) — nossos mapas não têm linha vazia
+        const row = [];
+        for (const ch of line)
+            row.push(ch in GLYPH_TYPE ? GLYPH_TYPE[ch] : AIR);
+        rows.push(row);
+    }
+    return rows;
+}
+// Grid numérico → texto-glifo (para gerar o .map.txt e para o teste de ida-e-volta). Sem newline final.
+export function gridToGlyphs(grid) {
+    return grid.map((row) => row.map((t) => TYPE_GLYPH[t] ?? '.').join('')).join('\n');
+}
+// Sanidade: o legend é uma bijeção sobre 0..14? (glifos únicos e todos os tipos mapeados). Prova que a
+// conversão é sem perda para QUALQUER grid. Retorna {ok, unique, invertible, missing}.
+export function selfTest() {
+    const types = Array.from({ length: 15 }, (_, i) => i);
+    const glyphs = types.map((t) => TYPE_GLYPH[t]);
+    const missing = types.filter((t) => !(t in TYPE_GLYPH));
+    const unique = new Set(glyphs).size === glyphs.length;
+    const invertible = types.every((t) => GLYPH_TYPE[TYPE_GLYPH[t]] === t);
+    return { ok: missing.length === 0 && unique && invertible, unique, invertible, missing };
+}

package/dist-pkg/core/world.d.ts

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+declare function buildWorld(rawGrid: number[][]): number[][];
+export declare function buildWorldFromText(text: string): number[][];
+export { buildWorld };