@the-inclusionist/engine 6.36.1

package/dist-pkg/platform/interruptible-speech.js

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/interruptible-speech — FALAR O ÚLTIMO PEDIDO, E CALAR O ANTERIOR NA HORA (ADR-0044, item 2).
+//
+// ========================= O DEFEITO QUE ISTO SUBSTITUI =========================
+// O motor neural falava assim:
+//
+//     speak: (text) => { if (busy) next = text; else speakNow(text); }   // fila de 1
+//
+// Uma FILA, e de tamanho um. Varrendo cinco itens de menu, a criança ouvia o PRIMEIRO inteiro e depois o
+// ÚLTIMO — os três do meio sumiam em silêncio, porque cada novo pedido sobrescrevia o `next`. É lento E
+// perde informação, e as duas coisas doem no mesmo lugar: a pessoa que não enxerga navega POR ESCUTA, e a
+// escuta estava vários itens atrás do foco.
+//
+// A XAG 106 diz o que fazer, e diz por quê: se a narração do item em foco ainda está sendo lida e o foco
+// muda, "a narração do elemento original deve PARAR IMEDIATAMENTE, e a do novo elemento começar".
+//
+// ========================= AS DUAS COISAS QUE ISTO GARANTE =========================
+//
+//   1. CALA ANTES DE SINTETIZAR, não depois. Síntese neural leva tempo; parar só quando o áudio novo fica
+//      pronto deixaria a voz velha falando durante a espera — o item errado, com convicção. Silêncio é a
+//      resposta certa: a criança sabe que se moveu, e o silêncio confirma.
+//
+//   2. GERAÇÃO, e é o que impede a corrida. `sintetizar` é assíncrono, e dois pedidos podem terminar fora
+//      de ordem: o segundo fica pronto primeiro, começa a tocar, e o primeiro chega depois e o atropela —
+//      a criança ouviria o item que ela JÁ passou, por cima do atual. Cada pedido carrega o seu número; o
+//      que voltar com número velho é descartado, em cada um dos dois `await`.
+//
+// ========================= POR QUE É UM MÓDULO, E NÃO UMA LINHA NO `tts` =========================
+// Porque assim se pode PROVAR. O bloco neural vive dentro de um `import()` dinâmico que só resolve com o
+// runtime de 25,6 MB presente; testá-lo lá dentro exigiria o motor de verdade. Aqui a política é pura —
+// recebe "como sintetizar", "como tocar" e "como parar" — e o teste de node exercita a corrida e a
+// interrupção com falsos, em milissegundos.
+export function criarFalaInterrompivel(motor) {
+    let tocando = null;
+    let geracao = 0;
+    /** Cala o que estiver tocando. O `try` existe porque parar uma fonte já terminada lança em alguns motores. */
+    function pararTudo() {
+        if (tocando !== null) {
+            try {
+                motor.parar(tocando);
+            }
+            catch (e) { /* fonte já encerrada — parar de novo não é erro */ }
+            tocando = null;
+        }
+    }
+    async function falar(texto) {
+        const minha = ++geracao; // reivindica a vez ANTES de qualquer espera
+        pararTudo(); // garantia 1: silêncio imediato, não ao fim da síntese
+        if (!texto)
+            return;
+        try {
+            const audio = await motor.sintetizar(texto);
+            if (minha !== geracao)
+                return; // garantia 2: chegou tarde — outro pedido já assumiu
+            pararTudo(); // de novo: alguém pode ter começado a tocar durante a espera
+            const fonte = motor.tocar(audio, () => { if (tocando === fonte)
+                tocando = null; });
+            if (minha !== geracao) {
+                if (fonte !== null) {
+                    try {
+                        motor.parar(fonte);
+                    }
+                    catch (e) { /* noop */ }
+                }
+                return;
+            }
+            tocando = fonte;
+        }
+        catch (e) {
+            // Síntese falhou para ESTE texto. Não é motivo para derrubar a narração inteira: o próximo pedido
+            // tenta de novo, e o silêncio de um item é melhor que um motor morto.
+        }
+    }
+    return {
+        falar: (texto) => { void falar(texto); },
+        calar: () => { geracao++; pararTudo(); }, // o `++` invalida o que estiver sintetizando agora
+        falando: () => tocando !== null,
+    };
+}

package/dist-pkg/platform/speech.d.ts

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+export declare function gameSay(text: string): void;

package/dist-pkg/platform/speech.js

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/speech.ts — voz do LETRAMENTO (gameSay): fala pt-BR SEMPRE-ativa (independe do toggle 'Narração
+// (TTS)' do mixer), pela voz nativa do navegador. Escolhe uma voz pt-BR e evita pt-PT. Módulo-folha (só áudio).
+// O TTS do MENU (narrate/ttsSpeak + motores neurais Piper/Kokoro/…) é outro caminho, gated pelo mixer — fica no game.js.
+import { soundOn, volume } from './audio.js';
+function ptbrVoice() {
+    try {
+        const vs = (window.speechSynthesis && window.speechSynthesis.getVoices()) || [];
+        if (!vs.length)
+            return null;
+        return vs.find((v) => /pt[-_]?br/i.test(v.lang)) || vs.find((v) => /pt/i.test(v.lang) && /bras|brazil/i.test(v.name)) || vs.find((v) => /pt/i.test(v.lang) && !/pt[-_]?pt/i.test(v.lang)) || null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+// FORÇA pt-BR (não usa a voz do mixer, que pode ser pt-PT). Volume ×1.4 para a fala soar acima dos efeitos.
+export function gameSay(text) {
+    if (!text || !soundOn)
+        return;
+    try {
+        const ss = window.speechSynthesis;
+        if (!ss)
+            return;
+        ss.cancel();
+        const u = new SpeechSynthesisUtterance(text);
+        u.lang = 'pt-BR';
+        const v = ptbrVoice();
+        if (v)
+            u.voice = v;
+        u.volume = Math.min(1, volume * 1.4);
+        ss.speak(u);
+    }
+    catch (e) { /* noop */ }
+}

package/dist-pkg/platform/storage.d.ts

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+export declare function get(key: string, fallback: string): string;
+export declare function get(key: string, fallback?: null): string | null;
+export declare function set(key: string, value: string | number | boolean): boolean;
+export declare function remove(key: string): void;
+export declare function getBool(key: string, fallback?: boolean): boolean;
+export declare function setBool(key: string, on: boolean): void;
+export declare function getNum(key: string, fallback?: number): number;
+export declare function getJSON<T = unknown>(key: string, fallback?: T | null): T | null;
+export declare function setJSON(key: string, obj: unknown): void;
+/**
+ * Nome completo de uma chave do escopo DO JOGO.
+ *
+ * ⚠️ O ID ENTRA COMO ARGUMENTO, e ele já foi uma constante aqui (`JOGO_ID = 'inclusionist'`). Pelo teste do
+ * ADR-0080 — *um segundo jogo quereria um valor diferente aqui?* — a resposta é sim e é imediata: dois jogos
+ * no mesmo perfil de navegador colidiam em `activity`, `quizlevel`, `cenario`, `tabsel`, `fracnot` e em toda
+ * gravação `attract_*`. Um sobrescrevia o progresso do outro sem erro nenhum.
+ *
+ * ⚠️ E O ID NÃO VEM DA DECLARAÇÃO, que era o desenho óbvio. Ele não pode: `game/state` lê o armazenamento no
+ * IMPORT, e o import corre antes de qualquer `createGame()`. Um id vindo da declaração chegaria depois de as
+ * três chaves já terem sido resolvidas — contra vazio, e em silêncio. Quem sabe o próprio id é o JOGO, que o
+ * passa como constante sua; o ADR-0080 proíbe a ENGINE de o saber, não o jogo.
+ */
+export declare function kJogo(jogo: string, nome: string): string;
+/**
+ * Lê a chave NOVA; se ela ainda não existe, herda o valor da LEGADA. Só de leitura: quem grava, grava na nova.
+ * É o que permite renomear chave sem um passo de migração e sem perder o ajuste de ninguém.
+ */
+export declare function getComLegado(nova: string, legada: string, fallback: string): string;
+export declare function getComLegado(nova: string, legada: string, fallback?: null): string | null;
+/** O par de `getComLegado` para valor em JSON — a herança tem de valer para os dois formatos, senão metade
+ *  das chaves migra e a outra metade some, que é o pior dos dois mundos. */
+export declare function getJSONComLegado<T = unknown>(nova: string, legada: string, fallback?: T | null): T | null;
+export declare const KEYS: {
+    onebtn: string;
+    wheelchair: string;
+    modocego: string;
+    caneDiv: string;
+    hearingloss: string;
+    activity: (jogo: string) => string;
+    activityLegado: string;
+    quizlevel: (jogo: string) => string;
+    quizlevelLegado: string;
+    cenario: (jogo: string) => string;
+    cenarioLegado: string;
+    tabsel: (jogo: string) => string;
+    tabselLegado: string;
+    fracnot: (jogo: string) => string;
+    fracnotLegado: string;
+    viz: string;
+    lq: string;
+    cbsafe: string;
+    ownercolors: string;
+    outfg: string;
+    outbg: string;
+    hcrole: string;
+    juice: string;
+    crt: string;
+    crtLegacy: string;
+    ttsEngine: string;
+    ttsVoice: string;
+    lang: string;
+    letterCase: string;
+    captions: string;
+    menuIndex: string;
+    fontKey: string;
+    padDesign: string;
+    padDir: string;
+    touchmap: string;
+    padBtnMm: string;
+    padGapMm: string;
+    padStickMm: string;
+    padTravelMm: string;
+    padDpadMm: string;
+    reducedMotion: string;
+    toggleMoveLegacy: string;
+    vizP: (i: number) => string;
+    sinkP: (i: number) => string;
+    easyP: (i: number) => string;
+    toggleMoveP: (i: number) => string;
+    toggleRunP: (i: number) => string;
+    rmWalkP: (i: number) => string;
+    rmBreathP: (i: number) => string;
+    rmFlavorP: (i: number) => string;
+    attract: (jogo: string, cen: string) => string;
+    attractLegado: (cen: string) => string;
+};

package/dist-pkg/platform/storage.js

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/storage.ts — Camada única de persistência (localStorage) — módulo-folha. À prova de exceção:
+// localStorage LANÇA em file:// e no modo privado de alguns navegadores, e isso derrubava o boot inteiro (por
+// isso todo acesso é try/catch). Centralizar aqui: um lugar para trocar a estratégia (namespacing, IndexedDB…)
+// sem caçar ~60 pontos. Migração gradual — nem todo game.js usa isto ainda.
+export function get(key, fallback = null) {
+    try {
+        const v = localStorage.getItem(key);
+        return v == null ? fallback : v;
+    }
+    catch {
+        return fallback;
+    }
+}
+export function set(key, value) {
+    try {
+        localStorage.setItem(key, String(value));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function remove(key) { try {
+    localStorage.removeItem(key);
+}
+catch { /* noop */ } }
+export function getBool(key, fallback = false) { const v = get(key, null); return v == null ? fallback : v === '1'; }
+export function setBool(key, on) { set(key, on ? '1' : '0'); }
+export function getNum(key, fallback = 0) {
+    const v = get(key, null);
+    const n = v == null ? NaN : parseFloat(v);
+    return isFinite(n) ? n : fallback;
+}
+export function getJSON(key, fallback = null) {
+    try {
+        const s = get(key, null);
+        return s == null ? fallback : JSON.parse(s);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function setJSON(key, obj) { try {
+    set(key, JSON.stringify(obj));
+}
+catch { /* noop */ } }
+/* ===================== os DOIS escopos (save com namespace, ADR-0027 passo 7) ===================== */
+//
+// O namespacing óbvio — um prefixo por jogo em TUDO — seria um defeito de acessibilidade grave, e vale dizer
+// por quê antes de dizer o que foi feito.
+//
+// Uma criança cega configura o modo cego, a bengala, a voz, a velocidade da narração. Uma criança daltônica
+// escolhe a correção. Uma criança disléxica escolhe a fonte. Se cada jogo do catálogo tivesse o próprio
+// espaço de nomes, ela teria de REFAZER tudo isso em cada jogo do catálogo — e quem mais depende dos ajustes
+// é justamente quem tem menos margem para refazê-los. (O número que estava aqui era 35, do plano que morreu
+// em 2026-08-28; o catálogo do MVP são 300+ jogos, o que só torna o argumento mais forte.)
+//
+// Então são DOIS escopos, e a linha entre eles não é técnica, é de quem a coisa pertence:
+//
+//   · COMPARTILHADO (`incl_*`, como sempre foi) — o que pertence à CRIANÇA: acessibilidade, tipografia,
+//     idioma, voz, controles, toque. Segue com ela de jogo em jogo, de propósito. O segundo consumidor (o
+//     quiz) já lê a fonte escolhida no jogo de plataforma, e isso está CERTO.
+//   · DO JOGO (`incl.<jogo>.*`) — o que pertence a ESTA partida: atividade, nível, cenário, gravação da
+//     demonstração. Dois jogos com um "nível 3" não são o mesmo nível 3.
+//
+// A LEITURA HERDA DA CHAVE ANTIGA e a escrita vai só para a nova (`getComLegado`). Sem passo de migração no
+// boot, porque `core/state` lê no IMPORT — uma migração agendada chegaria tarde. E a chave velha fica onde
+// está: é dado da criança, não meu para apagar, e a sua permanência é o que torna um retorno possível.
+/**
+ * Nome completo de uma chave do escopo DO JOGO.
+ *
+ * ⚠️ O ID ENTRA COMO ARGUMENTO, e ele já foi uma constante aqui (`JOGO_ID = 'inclusionist'`). Pelo teste do
+ * ADR-0080 — *um segundo jogo quereria um valor diferente aqui?* — a resposta é sim e é imediata: dois jogos
+ * no mesmo perfil de navegador colidiam em `activity`, `quizlevel`, `cenario`, `tabsel`, `fracnot` e em toda
+ * gravação `attract_*`. Um sobrescrevia o progresso do outro sem erro nenhum.
+ *
+ * ⚠️ E O ID NÃO VEM DA DECLARAÇÃO, que era o desenho óbvio. Ele não pode: `game/state` lê o armazenamento no
+ * IMPORT, e o import corre antes de qualquer `createGame()`. Um id vindo da declaração chegaria depois de as
+ * três chaves já terem sido resolvidas — contra vazio, e em silêncio. Quem sabe o próprio id é o JOGO, que o
+ * passa como constante sua; o ADR-0080 proíbe a ENGINE de o saber, não o jogo.
+ */
+export function kJogo(jogo, nome) { return 'incl.' + jogo + '.' + nome; }
+export function getComLegado(nova, legada, fallback = null) {
+    const v = get(nova, null);
+    if (v !== null)
+        return v;
+    const antigo = get(legada, null);
+    return antigo !== null ? antigo : fallback;
+}
+/** O par de `getComLegado` para valor em JSON — a herança tem de valer para os dois formatos, senão metade
+ *  das chaves migra e a outra metade some, que é o pior dos dois mundos. */
+export function getJSONComLegado(nova, legada, fallback = null) {
+    const v = getJSON(nova, null);
+    if (v !== null)
+        return v;
+    const antigo = getJSON(legada, null);
+    return antigo !== null ? antigo : fallback;
+}
+// Registro das chaves conhecidas (documentação em UM lugar; a fonte de verdade ainda é o uso). Vai sendo
+// completado à medida que os lotes migram. Chaves com {i}/{cen}/{id} são parametrizadas por jogador/cenário/controle.
+export const KEYS = {
+    // empatia motora/auditiva
+    onebtn: 'incl_onebtn', wheelchair: 'incl_wheelchair', modocego: 'incl_modocego', caneDiv: 'incl_cane_div',
+    hearingloss: 'incl_hearingloss',
+    // atividade / quiz / cenário — ESCOPO DO JOGO (ver os dois escopos acima). `*Legado` é o nome antigo, de
+    // onde a leitura herda uma vez; a escrita vai só para o novo.
+    //
+    // ⚠️ SÃO FUNÇÕES DO ID DO JOGO, e as da criança são strings. A diferença de FORMA é o que impede o engano:
+    // não há como prefixar por engano uma preferência da criança, porque ela não tem onde receber o id — e não
+    // há como esquecer de escopar uma chave da partida, porque sem o argumento não compila. A regra que antes
+    // vivia só num comentário passou a viver no tipo.
+    activity: (jogo) => kJogo(jogo, 'activity'), activityLegado: 'incl_activity',
+    quizlevel: (jogo) => kJogo(jogo, 'quizlevel'), quizlevelLegado: 'incl_quizlevel',
+    cenario: (jogo) => kJogo(jogo, 'cenario'), cenarioLegado: 'incl_cenario',
+    tabsel: (jogo) => kJogo(jogo, 'tabsel'), tabselLegado: 'incl_tabsel',
+    fracnot: (jogo) => kJogo(jogo, 'fracnot'), fracnotLegado: 'incl_fracnot',
+    // visual / contraste / cor
+    viz: 'incl_viz', lq: 'incl_lq', cbsafe: 'incl_cbsafe', ownercolors: 'incl_ownercolors',
+    outfg: 'incl_outfg', outbg: 'incl_outbg', hcrole: 'incl_hcrole', juice: 'incl_juice', crt: 'incl_crt2',
+    crtLegacy: 'incl_crt', // formato antigo (booleano); crt.ts migra p/ incl_crt2 na 1ª leitura (fresh)
+    // áudio / voz / i18n
+    ttsEngine: 'incl_tts_engine', ttsVoice: 'incl_tts_voice', lang: 'incl_lang', // audiocat_{k}
+    // comunicação / legendas (ADR-0028: todo menu persiste)
+    letterCase: 'incl_lettercase', captions: 'incl_captions',
+    menuIndex: 'incl_menuindex', // "6 de 10" no fim do anuncio de item (ADR-0044, item 3)
+    // tipografia / controles / toque
+    fontKey: 'incl_font_k', padDesign: 'incl_paddesign', padDir: 'incl_paddir', touchmap: 'incl_touchmap',
+    padBtnMm: 'incl_padbtnmm', padGapMm: 'incl_padgapmm', padStickMm: 'incl_padstickmm',
+    padTravelMm: 'incl_padtravelmm', padDpadMm: 'incl_paddpadmm',
+    // movimento reduzido (objeto inteiro num JSON so) + a chave antiga de alternar-movimento, que
+    // loadPlayerA11y ainda le uma vez para migrar quem vinha da versao anterior
+    reducedMotion: 'inclusionist.reducedmotion.v1', toggleMoveLegacy: 'inclusionist.togglemove',
+    // POR JOGADOR — parametrizadas pelo indice da tela. Eram sufixos '_p'+i montados a mao em varios
+    // pontos do game.js; virar funcao aqui e o que impede que um deles escreva num nome torto.
+    vizP: (i) => 'incl_viz_p' + i,
+    sinkP: (i) => 'incl_sink_p' + i,
+    easyP: (i) => 'incl_easy_p' + i,
+    toggleMoveP: (i) => 'incl_togglemove_p' + i,
+    toggleRunP: (i) => 'incl_togglerun_p' + i, // alternância do botão de CORRER (irmã da de movimento)
+    rmWalkP: (i) => 'incl_rmWalk_p' + i,
+    rmBreathP: (i) => 'incl_rmBreath_p' + i,
+    rmFlavorP: (i) => 'incl_rmFlavor_p' + i,
+    // demo/attract: uma gravação por cenário (fn em vez de string — chave parametrizada). ESCOPO DO JOGO: a
+    // gravação é de uma fase DESTE jogo e não faz sentido nenhum em outro.
+    attract: (jogo, cen) => kJogo(jogo, 'attract_' + cen),
+    attractLegado: (cen) => 'incl_attract_' + cen,
+};

package/dist-pkg/platform/tts.d.ts

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+interface TtsEngine {
+    id: string;
+    speak: (text: string) => void;
+}
+export interface TtsCtx {
+    srSay: (t: string) => void;
+    srAlert: (t: string) => void;
+    ensureAC: () => AudioContext | null;
+    catNode: (cat: string) => AudioNode | null;
+    audioOut: () => AudioNode | null;
+    getSoundOn: () => boolean;
+    getVolume: () => number;
+    getAudioCat: () => Record<string, {
+        on: boolean;
+    }> | null;
+}
+export interface Tts {
+    narrate: (text: string) => void;
+    ttsSpeak: (text: string) => boolean;
+    loadTTS: () => void;
+    speakWebSpeech: (text: string) => boolean;
+    getEngineSel: () => string;
+    setEngineSel: (v: string) => void;
+    getEngine: () => TtsEngine | null;
+    getVoiceObj: () => SpeechSynthesisVoice | null;
+    setVoiceObj: (v: SpeechSynthesisVoice | null) => void;
+    readonly loading: boolean;
+    readonly failed: boolean;
+    readonly narrateCount: number;
+}
+export declare function createTts(ctx: TtsCtx): Tts;
+export {};

package/dist-pkg/platform/tts.js

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/tts — narração por voz. Motor NEURAL Piper pt-BR carregado LAZY (import de CDN + cache OPFS → a 2ª sessão fala
+// offline), com FALLBACK imediato p/ a voz nativa do navegador (Web Speech) enquanto o neural não chega. narrate() é o
+// ponto de entrada, gated pelo toggle 'Narração (TTS)' do mixer (audioCat.tts.on) — independe das legendas. As funções de
+// PAINEL (populateTTSEngines/Voices/reflectTTS) ficam no game.js (→ ui/settings-audio, #38→#54) e usam get/setEngineSel +
+// get/setVoiceObj daqui. Injeção por closure. Ver docs/plano-tts-fase-f5.md + docs/5-Refactoring/plano-modularizacao-mapa.md.
+import * as store from './storage.js';
+import { t, bcp47 } from '../core/i18n.js';
+import { criarFalaInterrompivel } from './interruptible-speech.js';
+// ⚠️ MIGRAÇÃO PENDENTE (ADR-0022): esta implementação com @mintplex-labs/piper-tts-web será SUBSTITUÍDA por
+// sherpa-onnx-wasm (loader universal, modelos VITS/Piper + Kokoro-multi-lang carregados de qq URL R2 em runtime via
+// FS.writeFile; lazy-fetch; eSpeak/Web Speech de fallback). @mintplex-labs foi descontinuado e só carrega 2 vozes pt-BR.
+// Enquanto a migração não vem: a lib vem do npm (code-split pelo Vite no 1º uso), modelo do HF em cache OPFS. (#69→#38)
+/**
+ * Voz NEURAL por idioma, indexada pela etiqueta BCP-47 de core/i18n. Só o pt-BR tem uma hoje, e essa ausência
+ * é agora CONSULTÁVEL em vez de presumida: `loadTTS` pergunta à tabela se existe voz para o idioma corrente,
+ * em vez de carregar a portuguesa aconteça o que acontecer.
+ *
+ * Era `TTS_SOURCES['pt-BR']` escrito à mão no ponto de uso, o que fazia o jogo em inglês baixar 25,6 MB de
+ * voz portuguesa para ler texto em inglês com fonética errada — pior que não ter voz neural nenhuma, porque
+ * gasta a banda da escola para entregar algo ininteligível.
+ */
+const TTS_SOURCES = {
+    'pt-BR': { engine: 'piper', voice: 'pt_BR-faber-medium' },
+};
+export function createTts(ctx) {
+    let ttsEngine = null, ttsLoading = false, ttsFailed = false, _ttsPct = 0, _narrateCount = 0;
+    let _ttsVoiceObj = null; // voz do Web Speech selecionada
+    let ttsEngineSel = store.get(store.KEYS.ttsEngine, null) || 'webspeech'; // webspeech | piper | kokoro | kitten | espeak
+    function speakWebSpeech(text) {
+        try {
+            const ss = window.speechSynthesis;
+            if (!ss)
+                return false;
+            ss.cancel();
+            // `u.lang` era 'pt-BR' fixo. Com o jogo em inglês ou espanhol isso pedia ao navegador uma voz
+            // PORTUGUESA para um texto que não é português — e o resultado não é sotaque, é ininteligível: a
+            // fonética errada aplicada às letras erradas. Segue o idioma do jogo.
+            const u = new SpeechSynthesisUtterance(text);
+            u.lang = bcp47();
+            if (_ttsVoiceObj)
+                u.voice = _ttsVoiceObj;
+            u.rate = 1;
+            u.volume = Math.min(1, ctx.getVolume() * 1.4);
+            ss.speak(u);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    function loadTTS() {
+        if (ttsEngine || ttsLoading || ttsFailed)
+            return;
+        if (ttsEngineSel !== 'piper') { // Kokoro/Kitten/eSpeak NG ainda não entraram
+            if (ttsEngineSel !== 'webspeech')
+                ctx.srAlert(t('sr.tts.engineNoLanguage'));
+            return;
+        }
+        // O Piper só tem voz para os idiomas em TTS_SOURCES. Sem voz para o idioma corrente, NÃO se baixa a de
+        // outro idioma: avisa e segue na voz do navegador, que fala a língua certa.
+        const fonte = TTS_SOURCES[bcp47()];
+        if (!fonte) {
+            ctx.srAlert(t('sr.tts.noNeuralForLanguage'));
+            return;
+        }
+        ttsLoading = true;
+        const t0 = performance.now();
+        ctx.srSay(t('sr.tts.downloading'));
+        import('@mintplex-labs/piper-tts-web').then(async (mod) => {
+            const session = await mod.TtsSession.create({ voiceId: fonte.voice,
+                progress: (p) => { if (!p || !p.total)
+                    return; const pct = Math.round(p.loaded * 100 / p.total); if (pct >= _ttsPct + 25 && pct < 100) {
+                    _ttsPct = pct;
+                    ctx.srSay(t('sr.tts.progress', { pct }));
+                } },
+                logger: () => { } });
+            // A FILA DE UM SAIU (ADR-0044, item 2). Ela era `if (busy) next = text; else speakNow(text)`, e o
+            // efeito, varrendo cinco itens de menu, era ouvir o PRIMEIRO inteiro e depois o ÚLTIMO — os três do
+            // meio sumiam, porque cada pedido sobrescrevia o `next`. Lento e lacunar, e quem não enxerga navega
+            // POR ESCUTA: a escuta ficava vários itens atrás do foco.
+            //
+            // A política agora mora em `platform/interruptible-speech`, pura e testada com falsos. Aqui só se
+            // diz COMO sintetizar, tocar e parar — o quando é lá, com a guarda de geração que impede uma síntese
+            // lenta de atropelar a mais nova.
+            const fala = criarFalaInterrompivel({
+                sintetizar: async (texto) => {
+                    const wav = await session.predict(texto);
+                    const ac = ctx.ensureAC();
+                    if (!ac)
+                        throw new Error('AudioContext unavailable'); // o `catch` de lá trata: silêncio deste item, motor vivo
+                    return ac.decodeAudioData(await wav.arrayBuffer());
+                },
+                tocar: (buf, aoTerminar) => {
+                    const ac = ctx.ensureAC();
+                    if (!ac)
+                        return null;
+                    const src = ac.createBufferSource();
+                    src.buffer = buf;
+                    src.connect(ctx.catNode('tts') || ctx.audioOut() || ac.destination);
+                    src.onended = aoTerminar;
+                    src.start();
+                    return src;
+                },
+                parar: (src) => { src.stop(); },
+            });
+            ttsEngine = { id: 'piper', speak: (text) => { fala.falar(text); } };
+            ttsLoading = false;
+            try {
+                window.speechSynthesis && window.speechSynthesis.cancel();
+            }
+            catch (e) { /* noop */ }
+            narrate(t('sr.tts.ready', { s: ((performance.now() - t0) / 1000).toFixed(0) })); // já sai NA voz nova
+        }).catch(() => { ttsLoading = false; ttsFailed = true; ctx.srAlert(t('sr.tts.loadFailed')); });
+    }
+    function ttsSpeak(text) {
+        if (ttsEngineSel !== 'webspeech') {
+            if (ttsEngine && ttsEngine.id === ttsEngineSel && ttsEngine.speak) {
+                try {
+                    ttsEngine.speak(text);
+                }
+                catch (e) { /* noop */ }
+                return true;
+            }
+            loadTTS(); // motor neural (baixando/indisponível) → cai no fallback
+        }
+        return speakWebSpeech(text); // fallback imediato: Web Speech, no idioma do jogo
+    }
+    function narrate(text) {
+        const cat = ctx.getAudioCat();
+        if (!ctx.getSoundOn() || !cat || !cat.tts || !cat.tts.on || !text)
+            return;
+        _narrateCount++;
+        ttsSpeak(text);
+    }
+    return {
+        narrate, ttsSpeak, loadTTS, speakWebSpeech,
+        getEngineSel: () => ttsEngineSel, setEngineSel: (v) => { ttsEngineSel = v; },
+        getEngine: () => ttsEngine, getVoiceObj: () => _ttsVoiceObj, setVoiceObj: (v) => { _ttsVoiceObj = v; },
+        get loading() { return ttsLoading; }, get failed() { return ttsFailed; }, get narrateCount() { return _narrateCount; },
+    };
+}

package/dist-pkg/render/camera.d.ts

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** Um tamanho em pixels de mundo ou de tela. Só isto: a câmera não precisa saber de mais nada. */
+export interface Tamanho {
+    w: number;
+    h: number;
+}
+/** Onde a câmera está, ANTES de arredondar. O arredondamento é do desenho, não da conta — ver `prender`. */
+export interface Camera {
+    camX: number;
+    camY: number;
+}
+/**
+ * Prende a câmera dentro do mundo.
+ *
+ * ⚠️ MUNDO MENOR QUE A TELA: `mundo.w - tela.w` fica NEGATIVO, o `min` devolve esse negativo e o `max(0, …)`
+ * o zera — a câmera encosta no canto superior esquerdo e sobra vazio à direita e abaixo. É o comportamento
+ * que já existia e está preservado de propósito; o mapa de hoje (896×992 contra 320×180) nunca chega lá, mas
+ * uma fase pequena chegaria, e é melhor que o caso esteja escrito do que descoberto.
+ */
+export declare function prender(cam: Camera, mundo: Tamanho, tela: Tamanho): Camera;
+/** Põe `(alvoX, alvoY)` no CENTRO da tela e prende no mundo. O alvo é um ponto — quem tem corpo o converte. */
+export declare function enquadrar(alvoX: number, alvoY: number, mundo: Tamanho, tela: Tamanho): Camera;
+/**
+ * Aplica o tremor (JUICE) e PRENDE DE NOVO.
+ *
+ * A segunda prisão não é zelo: sem ela o tremor empurra a câmera para fora do mundo na beirada da fase e a
+ * criança vê o vazio atrás do cenário — justamente no momento em que alguma coisa explodiu e ela está olhando.
+ *
+ * @param amp amplitude em px (0 = sem tremor; `render/fx.shakeAmp`, que decai linearmente)
+ * @param rx deslocamento horizontal já sorteado, em [-1, 1]
+ * @param ry idem, vertical
+ */
+export declare function tremer(cam: Camera, mundo: Tamanho, tela: Tamanho, amp: number, rx: number, ry: number): Camera;
+/** A zona-morta, em pixels de TELA. `{w:0,h:0}` = sem zona: a câmera cola no alvo, que é o de hoje. */
+export interface ZonaMorta {
+    readonly w: number;
+    readonly h: number;
+}
+export interface CameraObj {
+    /** Onde a câmera está, sem tremor, pré-arredondamento. */
+    readonly base: Camera;
+    /** Segue o alvo respeitando a zona-morta e prende no mundo. Devolve a base nova. */
+    seguir(alvoX: number, alvoY: number): Camera;
+    /** Centra no alvo AGORA, ignorando a zona-morta: nascimento, renascimento, troca de fase. */
+    pular(alvoX: number, alvoY: number): Camera;
+    /** Base + tremor, preso no mundo. NÃO altera a base — ver o cabeçalho. */
+    quadro(amp: number, rx: number, ry: number): Camera;
+    /** Mundo e/ou tela mudaram (fase nova, viewport dividido). Reprende a base no que passou a valer. */
+    redimensionar(mundo?: Tamanho, tela?: Tamanho): Camera;
+}
+/**
+ * Cria uma câmera com alvo, zona-morta, prisão no mundo e tremor.
+ *
+ * ⚠️ ZONA ZERO É O COMPORTAMENTO DE HOJE, e não por coincidência: com `w = h = 0` a correção de `seguir` vira
+ * `alvo - tela/2`, que é `enquadrar` letra por letra. É o que permite trocar o `placeCam` por esta câmera sem
+ * mudar um pixel do que a criança vê, e escolher um valor de zona depois, como decisão separada.
+ */
+export declare function criarCamera(mundo: Tamanho, tela: Tamanho, zona?: ZonaMorta): CameraObj;