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

package/dist-pkg/input/transporte-em-uso.js

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// input/transporte-em-uso — A ALTERNÂNCIA SEGUE O APARELHO EM USO (ADR-0109), na metade pura.
+//
+// ========================= O QUE ESTE MÓDULO É =========================
+// O autómato das quatro regras do ADR-0109 §1, sem DOM, sem armazenamento e sem eventos. Recebe ARESTAS com
+// origem e devolve estado; quem pergunta «há alternância agora?» pergunta ao estado.
+//
+//   1. Por padrão, controle e teclado, ambos SEM alternância.
+//   2. Clique de mouse ou toque na tela → controles de tela COM alternância.
+//   3. Apertar tecla devolve o teclado SEM alternância; usar o controle faz o mesmo.
+//   4. Câmera e microfone precisam ser habilitados; habilitados, ligam a alternância em TODOS os outros
+//      controles, SEM possibilidade de desligar. São prioridade.
+//
+// ⚠️ POR QUE ISTO É UM AUTÓMATO E NÃO UM VALOR GUARDADO — e é o que o ADR-0109 supersede do ADR-0104 §C. A
+// alternância era uma ESCOLHA guardada por transporte, e a issue #114 mediu que a fiação dela não era
+// escrevível: a origem da aresta é apagada à porta (`input/state.keys` é `Set<string>` de CÓDIGOS, e o toque
+// e a webcam escrevem lá dentro). O Dev decidiu o COMPORTAMENTO, e o comportamento escolhe o mecanismo.
+//
+// ⚠️ E A REGRA 3 É A RAZÃO DE PRECISAR DE DUAS COISAS, não de uma. «Apertar uma tecla devolve o teclado sem
+// alternância» são DOIS factos: um EVENTO cuja origem tem de ser conhecida, e um MODO que persiste até à
+// troca seguinte. Uma aresta não guarda estado; um modo guardado não detecta a própria troca. Nenhuma metade
+// exprime a regra; juntas exprimem. Este ficheiro é a segunda metade — o MODO.
+//
+// 📌 A imagem do Dev, mantida porque diz a coisa: é um CAPS-LOCK NUM TECLADO COM MEMÓRIA. Modo e não estado
+// momentâneo; lembrado por aparelho; trocar de aparelho não apaga o que o outro lembra.
+/**
+ * A UNIÃO COMO VALOR, porque há um sítio onde ela tem de ser verificada em runtime.
+ *
+ * ⚠️ EXISTE POR CAUSA DE UMA FRONTEIRA, e é a única razão que a justifica: o `input/origem-sintetica` lê o
+ * transporte de um EXPANDO pendurado num `KeyboardEvent` — um objecto que este código não construiu e que
+ * qualquer script da página pode construir. Um valor que atravessa essa fronteira não é um `Transporte` por
+ * o TypeScript o dizer; é uma `string` até alguém a conferir. Sem lista, `'olho'` entrava no mapa de origens
+ * como transporte fantasma, e nada o diria.
+ *
+ * 📌 Não é o defeito da lista-ao-lado-da-união que este repositório já desfez três vezes (o `RM_KEYS`, os
+ * rótulos de movimento reduzido, as chaves de armazenamento), porque a guarda abaixo é do COMPILADOR: as duas
+ * não podem divergir. Uma cópia que não pode divergir é uma projecção, não uma segunda fonte.
+ */
+export const TRANSPORTES = ['teclado', 'gamepad', 'toque', 'olhos', 'rosto', 'gestos', 'fala'];
+const _COBRE_OS_TRANSPORTES = true;
+void _COBRE_OS_TRANSPORTES;
+/**
+ * Isto que veio de fora é mesmo um transporte?
+ *
+ * ⚠️ A pergunta não é de segurança — os scripts desta página são todos da casa, e quem quisesse mentir usaria
+ * um valor VÁLIDO. É de correcção: impede que um carimbo errado ou ausente vire uma entrada silenciosa no
+ * `origemDaTecla`, que é a estrutura de que a alternância inteira depende.
+ */
+export function ehTransporte(v) {
+    return typeof v === 'string' && TRANSPORTES.includes(v);
+}
+/**
+ * OS QUATRO QUE EXIGEM HABILITAÇÃO EXPLÍCITA e, uma vez habilitados, mandam em todos (regra 4).
+ *
+ * ⚠️ É a mesma lista do `UM_COMANDO_DE_CADA_VEZ` do `input/latch-scope`, e a coincidência não é acaso: são
+ * os transportes de quem NÃO CONSEGUE SEGURAR NADA. O que o ADR-0109 acrescenta é que eles não ligam a
+ * alternância só para si — ligam-na para o resto, porque quem usa a webcam pode também tocar na tela, e uma
+ * alternância que se desliga ao mudar de aparelho é uma armadilha para exactamente essa pessoa.
+ */
+export const EXIGEM_HABILITACAO = new Set(['olhos', 'rosto', 'gestos', 'fala']);
+/** O transporte que liga a alternância por si só, sem prioridade nenhuma envolvida (regra 2). */
+export const COM_ALTERNANCIA_PROPRIA = new Set(['toque']);
+/**
+ * O ESTADO INICIAL: teclado, sem alternância.
+ *
+ * ⚠️ A regra 1 diz «controle E teclado, ambos sem alternância», e é por isso que o padrão pode nomear um só
+ * sem mentir: entre os dois a resposta à única pergunta que este módulo faz — há alternância? — é a MESMA.
+ * O `emUso` só passa a distingui-los quando alguém quiser MOSTRAR o aparelho corrente, que é outra questão
+ * e o ADR-0109 deixa-a explicitamente por decidir.
+ */
+export const PADRAO = Object.freeze({ emUso: 'teclado', assistidaLigada: false });
+/**
+ * HÁ ALTERNÂNCIA AGORA? — ⚠️ **NÃO PERGUNTE ISTO A ESTA FUNÇÃO.** Ver o parágrafo abaixo.
+ *
+ * ⚠️ A prioridade da assistida vem PRIMEIRO, e a ordem é a regra 4 inteira: enquanto ela estiver ligada,
+ * nenhum outro aparelho a desliga — nem o teclado, que noutro caso a desligaria. Inverter estas duas linhas
+ * é o defeito que trancaria uma criança fora do próprio jogo, e é silencioso.
+ *
+ * @deprecated 🔴 **ESTA FUNÇÃO IMPLEMENTA O MODELO QUE O ADR-0113 SUPERSEDEU**, e fica exportada por ser
+ * superfície publicada (`./input/*.js`) e por o registo ter valor histórico — não por ser a resposta.
+ *
+ * O ADR-0109 decidia a alternância **só pelo aparelho**: assistida ligada → sim; toque → sim; todo o resto
+ * → não. O ADR-0113 retirou essa cláusula, com a razão do Dev: a alternância é um **caps-lock guardado com
+ * o mapeamento do controle**, e o valor que a criança gravou vale.
+ *
+ * 🔴 A DIVERGÊNCIA TEM UMA CRIANÇA CONCRETA, e é a que motivou o registo: quem tem dificuldade motora, joga
+ * no TECLADO e gravou a alternância ligada. Esta função devolve `false` para ela — `teclado` não está em
+ * `COM_ALTERNANCIA_PROPRIA` — e é exactamente o controle que lhe seria retirado. O `latch-scope.alternanciaDe`
+ * devolve `true`, porque lê o que ela gravou.
+ *
+ * ⚠️ E A CLÁUSULA DO TOQUE TAMBÉM CAIU: sob o ADR-0113 o toque é um transporte como os outros — o valor dele
+ * é escolha e fica guardado. Só olhos, rosto, gestos e fala podem recusar-se a DESLIGAR, e essa metade vive
+ * em `latch-scope.alternanciaSempreLigada`, com um conjunto diferente deste e a responder a outra pergunta.
+ *
+ * **A resposta certa é `latch-scope.alternanciaDe(estado.emUso, leitura)`.** O papel que sobra a este
+ * módulo é o que o nome dele diz: QUAL transporte está em uso — que é o que alimenta aquele primeiro
+ * argumento. `tests/alternancia-por-transporte.node.test.js` afirma que esta função continua sem consumidor.
+ */
+export function alternanciaAgora(estado) {
+    if (estado.assistidaLigada)
+        return true;
+    return COM_ALTERNANCIA_PROPRIA.has(estado.emUso);
+}
+/**
+ * UMA ARESTA CHEGOU, com a sua origem. Devolve o estado NOVO.
+ *
+ * ⚠️ Uma aresta de um transporte assistido NÃO o habilita. Habilitar é um acto explícito (regra 4: «precisam
+ * ser habilitados»), e deixar uma aresta fazê-lo significaria que um falso positivo da webcam — uma sombra,
+ * um segundo rosto a passar — trancava a alternância de toda a gente sem ninguém ter pedido.
+ */
+export function aposAresta(estado, origem) {
+    if (estado.emUso === origem)
+        return estado; // sem mudança: devolve o MESMO objecto, não uma cópia
+    return { emUso: origem, assistidaLigada: estado.assistidaLigada };
+}
+/** A criança (ou quem a acompanha) habilitou câmera/microfone. Daqui em diante a alternância é lei. */
+export function habilitarAssistida(estado) {
+    return estado.assistidaLigada ? estado : { emUso: estado.emUso, assistidaLigada: true };
+}
+/**
+ * DESABILITAR a assistida. Existe, e o ADR-0109 diz de quem é: NÃO é da criança durante a partida.
+ *
+ * ⚠️ Fica exportada porque desligar a câmera tem de ser possível em algum lugar — trocar de utilizador,
+ * fechar o jogo, um adulto a reconfigurar. O que o §4 proíbe é oferecê-la como um botão ao lado do jogo.
+ * Uma função que existe e não é oferecida é diferente de uma função que não existe: a primeira diz onde a
+ * decisão mora.
+ */
+export function desabilitarAssistida(estado) {
+    return estado.assistidaLigada ? { emUso: estado.emUso, assistidaLigada: false } : estado;
+}

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

@@ -22,11 +22,38 @@ export declare const LUGARES: Readonly<{
     toque: 9;
     teclado: 14;
 }>;
+/**
+ * QUANTAS POSIÇÕES O CONTROLE DE TELA SEGURA AO MESMO TEMPO. Dois, e é uma DECLARAÇÃO (ADR-0104 §B).
+ *
+ * ⚠️ E A DECISÃO É NÃO PERGUNTAR AO APARELHO. O `navigator.maxTouchPoints` existe, responde depressa, e
+ * MENTE — mente para cima: muitos aparelhos anunciam cinco e reconhecem dois. Um modelo assente nele falha
+ * exactamente no telemóvel barato da escola pública, que é o pilar 1 deste projeto, e falha em silêncio: a
+ * criança tenta correr e pular ao mesmo tempo, não acontece nada, e ela conclui que o jogo está partido.
+ *
+ * Um piso declarado não pode errar para cima. Ele erra para baixo — um aparelho que segurava três fica
+ * servido por dois —, e esse erro tem conserto: a opção do terceiro botão, PROVADA POR TESTE, porque um
+ * gesto real é a única evidência que um aparelho não consegue falsificar. Nada é recusado e nada é assumido.
+ *
+ * ⚠️ NÃO É UM REGISTO DE TETOS POR TRANSPORTE, e o ADR diz isso em `more-information`: só o toque tem número
+ * declarado. O `holds` do `Transport` é opcional justamente por isso — ausente significa «não há tecto
+ * conhecido», não «segura uma». Um registo de tetos para teclado e controle é uma mudança maior, e nada
+ * precisa dela hoje.
+ */
+export declare const SEGURA_TOQUE = 2;
 /** Como se descobre que cada transporte está aqui AGORA. Injetado: nenhuma destas perguntas é pura. */
 export interface Disponibilidade {
     gamepad: () => boolean;
     toque: () => boolean;
     teclado: () => boolean;
+    /**
+     * Há um RATO aqui? (ADR-0112)
+     *
+     * ⚠️ ELE NÃO É UM TRANSPORTE À PARTE, e é por isso que entra como uma pergunta e não como uma quarta linha
+     * do `transportesPadrao`: um rato sozinho não carrega as catorze posições. Ele é o SINAL CONTÍNUO ao lado
+     * do teclado — a frase do Dev, «no caso do teclado, o sinal contínuo passa a ser o mouse» —, e é o que dá
+     * fundação aos transportes 8 e 9 do ADR-0074, que aquele registo declarava como não tendo nenhuma.
+     */
+    rato: () => boolean;
 }
 /**
  * Os três transportes que esta engine sabe oferecer hoje.
@@ -44,14 +71,43 @@ export interface Transport {
     readonly id: string;
     /** Quantos lugares ATRIBUÍVEIS. É o número que a aritmética da garantia usa. */
     readonly slots: number;
+    /**
+     * Quantas posições ele SEGURA AO MESMO TEMPO, quando isso é conhecido. Eixo diferente dos `slots`: o
+     * controle de tela tem nove lugares e segura dois.
+     *
+     * ⚠️ AUSENTE SIGNIFICA «NÃO HÁ TECTO CONHECIDO», e não «segura uma». Hoje só o toque declara um número
+     * (`SEGURA_TOQUE`), porque só sobre ele há decisão — ver a nota lá. Ler a ausência como zero faria todo
+     * transporte sem número reprovar de repente, que é o oposto do que um campo opcional deve fazer.
+     */
+    readonly holds?: number;
     /**
      * Está disponível NESTE aparelho, AGORA? Função e não valor: um controle é ligado no meio da partida, e
      * uma tela de toque aparece quando a criança gira o tablet.
      */
     readonly available: () => boolean;
+    /**
+     * Este transporte oferece um PONTEIRO — posição contínua (ADR-0112)?
+     *
+     * ⚠️ FUNÇÃO E NÃO BOOLEANO, pela mesma razão escrita no `available` acima: um rato é ligado no meio da
+     * partida, tal como um controle. Um valor fixo aqui responderia com o estado do arranque.
+     *
+     * ⚠️ AUSENTE SIGNIFICA «NÃO OFERECE», e aqui — ao contrário do `holds` — ler a ausência assim é o correcto:
+     * o ponteiro é uma capacidade que se DECLARA, e um transporte que não a declara não a tem. O `holds` é o
+     * oposto porque lá a ausência é «não há tecto conhecido», e lê-la como zero reprovaria todo o mundo.
+     */
+    readonly aponta?: () => boolean;
 }
 /** Este transporte carrega este conjunto de ações? Aritmética, como o ADR-0079 §3 a descreve. */
 export declare function carries(t: Transport, acoes: readonly Action[]): boolean;
+/**
+ * Este transporte SEGURA quantas o jogo pede ao mesmo tempo? (ADR-0104 §A.)
+ *
+ * ⚠️ TRANSPORTE SEM TECTO DECLARADO RESPONDE SIM, e a escolha é deliberada: o `holds` ausente quer dizer «não
+ * medimos isto», e recusar por falta de medida transformaria uma ignorância em acusação — o teclado e o
+ * controle passariam a reprovar todos os jogos por não terem número nenhum. Onde não há decisão, o modelo
+ * cala; é o toque que tem decisão, e é só ele que pode reprovar aqui.
+ */
+export declare function holds(t: Transport, pedidas: number): boolean;
 /**
  * Os transportes DISPONÍVEIS que carregam este conjunto.
  *
@@ -69,10 +125,20 @@ export declare function carriedBy(lista: readonly Transport[], acoes: readonly A
 export declare function reachable(lista: readonly Transport[], acoes: readonly Action[]): boolean;
 /** O que a tela de seleção precisa dizer, e o que ela precisa saber para o dizer. */
 export interface Alcance {
-    /** Verdadeiro = pelo menos um transporte disponível carrega o conjunto. */
+    /**
+     * Verdadeiro = pelo menos um transporte disponível carrega o conjunto **e segura quantas o jogo pede ao
+     * mesmo tempo**.
+     *
+     * ⚠️ A SEGUNDA METADE DESTA FRASE É NOVA (ADR-0104), e é o conserto do ponto cego que ninguém tinha
+     * nomeado: a plataforma declara nove ações, o toque tem nove lugares, o `ok` dizia sim — e correr, andar e
+     * pular ao mesmo tempo são três dedos que um telemóvel de dois não tem. O `ok` afirmava «dá para jogar»
+     * sobre um jogo que não dava, que é a pior coisa que este campo podia fazer.
+     */
     readonly ok: boolean;
     /** Quantas ações o jogo pede. */
     readonly pedidas: number;
+    /** Quantas ele pede SEGURAR ao mesmo tempo — o segundo eixo, e o que o `holdsAtOnce` declara. */
+    readonly seguraPedidas: number;
     /** Os que serviriam se estivessem ligados — a informação acionável: «ligue um controle». */
     readonly serviriamSeLigados: readonly string[];
     /** Os disponíveis que NÃO cabem, com quantos lugares têm. Para a frase dizer o número. */
@@ -80,6 +146,26 @@ export interface Alcance {
         readonly id: string;
         readonly slots: number;
     }[];
+    /**
+     * Os disponíveis que CHEGAM às ações mas não seguram quantas o jogo pede de uma vez, com o tecto deles.
+     *
+     * É a terceira frase do cartão da #112, e ela precisa dos dois números: «o controle de tela segura dois
+     * botões de cada vez e este jogo pede três». Sem o tecto, a frase diria que algo falta sem dizer o quê.
+     */
+    readonly naoSeguram: readonly {
+        readonly id: string;
+        readonly holds: number;
+    }[];
+    /** Este jogo declarou que precisa de PONTEIRO? (ADR-0112) */
+    readonly pedePonteiro: boolean;
+    /**
+     * Os disponíveis que chegam às acções E seguram quantas o jogo pede, e falham SÓ por não apontarem.
+     *
+     * ⚠️ SÓ QUEM FALHA APENAS NISTO, pela mesma regra que o `naoSeguram` já segue: um transporte em duas listas
+     * faria o cartão da #112 dizer dois problemas onde há um, e a criança leria dois motivos para a mesma
+     * recusa. A lista é vazia quando o jogo não pede ponteiro — não «todos», porque nenhum falhou.
+     */
+    readonly naoApontam: readonly string[];
 }
 /**
  * Mede o alcance ANTES de a criança começar.
@@ -87,4 +173,4 @@ export interface Alcance {
  * ⚠️ Devolve DADO e não texto. A frase é da interface e tem de passar por `t()`; devolver português daqui
  * repetiria o defeito que o `PADWIZ_STEPS` acabou de deixar de cometer.
  */
-export declare function alcance(lista: readonly Transport[], acoes: readonly Action[]): Alcance;
+export declare function alcance(lista: readonly Transport[], acoes: readonly Action[], seguraPedidas: number, pedePonteiro?: boolean): Alcance;

package/dist-pkg/input/transports.js

@@ -40,6 +40,24 @@ import { ACTIONS } from '../core/actions.js';
  * número cresce com ele e nunca passa a mentir.
  */
 export const LUGARES = Object.freeze({ gamepad: 17, toque: 9, teclado: ACTIONS.length });
+/**
+ * QUANTAS POSIÇÕES O CONTROLE DE TELA SEGURA AO MESMO TEMPO. Dois, e é uma DECLARAÇÃO (ADR-0104 §B).
+ *
+ * ⚠️ E A DECISÃO É NÃO PERGUNTAR AO APARELHO. O `navigator.maxTouchPoints` existe, responde depressa, e
+ * MENTE — mente para cima: muitos aparelhos anunciam cinco e reconhecem dois. Um modelo assente nele falha
+ * exactamente no telemóvel barato da escola pública, que é o pilar 1 deste projeto, e falha em silêncio: a
+ * criança tenta correr e pular ao mesmo tempo, não acontece nada, e ela conclui que o jogo está partido.
+ *
+ * Um piso declarado não pode errar para cima. Ele erra para baixo — um aparelho que segurava três fica
+ * servido por dois —, e esse erro tem conserto: a opção do terceiro botão, PROVADA POR TESTE, porque um
+ * gesto real é a única evidência que um aparelho não consegue falsificar. Nada é recusado e nada é assumido.
+ *
+ * ⚠️ NÃO É UM REGISTO DE TETOS POR TRANSPORTE, e o ADR diz isso em `more-information`: só o toque tem número
+ * declarado. O `holds` do `Transport` é opcional justamente por isso — ausente significa «não há tecto
+ * conhecido», não «segura uma». Um registo de tetos para teclado e controle é uma mudança maior, e nada
+ * precisa dela hoje.
+ */
+export const SEGURA_TOQUE = 2;
 /**
  * Os três transportes que esta engine sabe oferecer hoje.
  *
@@ -51,15 +69,32 @@ export const LUGARES = Object.freeze({ gamepad: 17, toque: 9, teclado: ACTIONS.l
  */
 export function transportesPadrao(d) {
     return [
+        // ⚠️ O GAMEPAD NÃO DECLARA PONTEIRO, e a ausência é medida e não esquecimento: o stick tem o sinal
+        // contínuo e a engine deita-o fora na fonte (`PAD_DEAD = 0.5`, `PadState = Record<string, boolean>`).
+        // Ligá-lo ao ponteiro é possível e traz de volta uma pergunta que o ADR-0112 já deixou nomeada — metade
+        // do curso morta é ergonomia certa para um BOTÃO e errada para um CURSOR.
         { id: 'gamepad', slots: LUGARES.gamepad, available: d.gamepad },
-        { id: 'teclado', slots: LUGARES.teclado, available: d.teclado },
-        { id: 'toque', slots: LUGARES.toque, available: d.toque },
+        // O teclado aponta QUANDO HÁ RATO — a cláusula do Dev, e a fundação dos transportes 8 e 9 do ADR-0074.
+        { id: 'teclado', slots: LUGARES.teclado, available: d.teclado, aponta: d.rato },
+        // O toque aponta por natureza: a superfície É o ponteiro, e é o mesmo dedo que carrega nos botões.
+        { id: 'toque', slots: LUGARES.toque, holds: SEGURA_TOQUE, available: d.toque, aponta: d.toque },
     ];
 }
 /** Este transporte carrega este conjunto de ações? Aritmética, como o ADR-0079 §3 a descreve. */
 export function carries(t, acoes) {
     return t.slots >= acoes.length;
 }
+/**
+ * Este transporte SEGURA quantas o jogo pede ao mesmo tempo? (ADR-0104 §A.)
+ *
+ * ⚠️ TRANSPORTE SEM TECTO DECLARADO RESPONDE SIM, e a escolha é deliberada: o `holds` ausente quer dizer «não
+ * medimos isto», e recusar por falta de medida transformaria uma ignorância em acusação — o teclado e o
+ * controle passariam a reprovar todos os jogos por não terem número nenhum. Onde não há decisão, o modelo
+ * cala; é o toque que tem decisão, e é só ele que pode reprovar aqui.
+ */
+export function holds(t, pedidas) {
+    return t.holds === undefined || t.holds >= pedidas;
+}
 /**
  * Os transportes DISPONÍVEIS que carregam este conjunto.
  *
@@ -85,12 +120,32 @@ export function reachable(lista, acoes) {
  * ⚠️ Devolve DADO e não texto. A frase é da interface e tem de passar por `t()`; devolver português daqui
  * repetiria o defeito que o `PADWIZ_STEPS` acabou de deixar de cometer.
  */
-export function alcance(lista, acoes) {
+export function alcance(lista, acoes, seguraPedidas, pedePonteiro = false) {
     const disponiveis = lista.filter((t) => t.available());
+    /**
+     * ⚠️ PADRÃO `false` E NÃO PARÂMETRO OBRIGATÓRIO: os trezentos jogos que não desenham não podem sentir esta
+     * mudança, e um quarto argumento exigido faria cada chamador existente decidir hoje uma coisa que não lhe
+     * diz respeito.
+     */
+    const apontaSeFor = (t) => !pedePonteiro || (!!t.aponta && t.aponta());
+    // ⚠️ «Serve» passou a ser TRÊS coisas. Foi DUAS na #114 (o `ok` dizia sim a quem não segurava três dedos), e
+    // é três desde o ADR-0112 — pela mesma razão das duas vezes: um `ok` verdadeiro sobre um jogo que a criança
+    // não consegue jogar é a pior coisa que este campo pode fazer.
+    const serve = (t) => carries(t, acoes) && holds(t, seguraPedidas) && apontaSeFor(t);
     return {
-        ok: reachable(lista, acoes),
+        ok: acoes.length > 0 && disponiveis.some(serve),
         pedidas: acoes.length,
-        serviriamSeLigados: lista.filter((t) => !t.available() && carries(t, acoes)).map((t) => t.id),
+        seguraPedidas,
+        pedePonteiro,
+        serviriamSeLigados: lista.filter((t) => !t.available() && serve(t)).map((t) => t.id),
         curtos: disponiveis.filter((t) => !carries(t, acoes)).map((t) => ({ id: t.id, slots: t.slots })),
+        naoApontam: disponiveis
+            .filter((t) => carries(t, acoes) && holds(t, seguraPedidas) && !apontaSeFor(t))
+            .map((t) => t.id),
+        // ⚠️ SÓ QUEM CHEGA, e não quem já reprovou por lugares. Um transporte que aparecesse nas duas listas
+        // faria o cartão dizer duas coisas sobre o mesmo defeito, e a criança leria dois problemas onde há um.
+        naoSeguram: disponiveis
+            .filter((t) => carries(t, acoes) && !holds(t, seguraPedidas))
+            .map((t) => ({ id: t.id, holds: t.holds })),
     };
 }

package/dist-pkg/input/vocabulary-migration.d.ts

@@ -1,5 +1,16 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-import type { KeyScheme } from '../core/entity.js';
+/**
+ * ⚠️ O DADO SALVO NÃO É UM `KeyScheme`, e a issue #118 tornou isso um erro de compilação em vez de uma
+ * suposição. Um `KeyScheme` é FECHADO nas quatorze posições e completo; o que está no navegador da criança é
+ * uma SOBREPOSIÇÃO — parcial por construção (`loadKB` funde-a sobre os padrões com `Object.assign`) e capaz
+ * de carregar chaves que este código não conhece, o que o cabeçalho de `migrarEsquema` já dizia com todas as
+ * letras: «chave desconhecida atravessa intacta».
+ *
+ * Dar-lhe o tipo fechado obrigaria este ficheiro a inventar as posições que faltam no dado antigo — quer
+ * dizer, a escrever teclas que a criança nunca escolheu, no exacto módulo que existe para não lhe perder o
+ * remapeamento. O tipo aberto é o honesto aqui, e é só aqui.
+ */
+export type EsquemaSalvo = Record<string, readonly string[]>;
 /**
  * Nome de plataforma → posição abstrata. **ADR-0086 §2**, e não o ADR-0074.
  *
@@ -38,11 +49,11 @@ export declare function migrarMapaDeToque(mapa: Record<string, string> | null |
 export declare function migrarMapaDeControle<T>(mapa: Record<string, T> | null | undefined): Record<string, T> | null;
 /** O objeto salvo, tal como `input/keyboard` o persiste. `p34` é o formato mais antigo de todos. */
 export interface SavedKB {
-    solo?: KeyScheme;
-    p2?: KeyScheme[];
-    p3?: KeyScheme[];
-    p4?: KeyScheme[];
-    p34?: (KeyScheme | null)[];
+    solo?: EsquemaSalvo;
+    p2?: EsquemaSalvo[];
+    p3?: EsquemaSalvo[];
+    p4?: EsquemaSalvo[];
+    p34?: (EsquemaSalvo | null)[];
 }
 /**
  * Traduz UM esquema salvo do vocabulário antigo para o abstrato.
@@ -53,6 +64,6 @@ export interface SavedKB {
  * sumirem. É também o que torna esta função IDEMPOTENTE: aplicada sobre um esquema já migrado, nenhuma chave
  * casa e o resultado é igual à entrada, o que importa porque `loadKB` pode correr mais de uma vez na sessão.
  */
-export declare function migrarEsquema(esquema: KeyScheme | null | undefined): KeyScheme | null;
+export declare function migrarEsquema(esquema: EsquemaSalvo | null | undefined): EsquemaSalvo | null;
 /** Traduz o objeto salvo inteiro — o esquema solo e as listas por contagem de jogadores. */
 export declare function migrarSalvo(s: SavedKB | null | undefined): SavedKB | null;

package/dist-pkg/platform/audio-earcons.d.ts

@@ -1,9 +1,37 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-interface SfxDef {
+/**
+ * A definição de UM earcon. A tabela é do JOGO (item 19); esta é a forma que a engine sabe tocar.
+ *
+ * ⚠️ EXPORTADA DESDE 2026-09-07 (#124), e a falta era um defeito de interface: o `game-platformer` declarava
+ * a sua própria cópia deste tipo, palavra por palavra, porque não tinha como o nomear. Uma forma que cada
+ * consumidor redescobre por cópia é uma forma que diverge — foi assim que cinco cópias de `Gfx` divergiram
+ * nesta árvore, e está escrito noutro módulo.
+ */
+export interface SfxDef {
+    /** O timbre. */
     t: OscillatorType;
+    /** A frequência inicial, em hertz. */
     f: number;
+    /** A duração, em segundos. */
     d: number;
+    /** A CHAVE de i18n da legenda (a11y surdez). Quem exibe resolve. */
     cap?: string;
+    /**
+     * A frequência FINAL, em hertz. Ausente = nota parada, que é o que sempre houve.
+     *
+     * ⚠️ ELE EXISTE PORQUE UM EARCON PRECISA DE PODER IR PARA ALGUM LADO (#124). Medido ao construir o
+     * `game-soccer`: marcar e sofrer golo têm de ser distinguíveis **só de ouvido** — uma criança cega ouve a
+     * sala reagir e precisa de saber para que lado antes de a narração chegar. O desenho óbvio é uma figura
+     * que SOBE para o golo dela e DESCE para o do outro, e a tabela não o sabia dizer. O que sobrava era
+     * agudo-e-longo contra grave-e-curto: distinguível, e menos informação do que o momento carrega.
+     *
+     * ⚠️ E A CAPACIDADE JÁ ESTAVA NESTE FICHEIRO, sem ser alcançável da tabela: o `doorSound` faz exatamente
+     * isto, com `frequency.exponentialRampToValueAtTime`. O conserto não é síntese nova — é abrir a porta.
+     *
+     * A rampa é EXPONENCIAL e não linear porque a altura é percebida em razão e não em diferença: uma rampa
+     * linear de 200 a 800 sobe depressa no início e devagar no fim, e ouve-se torta.
+     */
+    f2?: number;
 }
 export interface AudioEarconsCtx {
     SFX: Record<string, SfxDef | undefined>;
@@ -21,4 +49,3 @@ export interface AudioEarcons {
     doorSound: (mat: string) => void;
 }
 export declare function createAudioEarcons(ctx: AudioEarconsCtx): AudioEarcons;
-export {};

package/dist-pkg/platform/audio-earcons.js

@@ -30,6 +30,16 @@ export function createAudioEarcons(ctx) {
             g.gain.value = 0.0001;
             o.connect(g).connect(ctx.catNode('earcons') || ctx.audioOut() || ac.destination);
             const t = ac.currentTime, vol = ctx.getVolume();
+            // A FIGURA, quando a tabela pede uma (#124). `setValueAtTime` antes da rampa como no `doorSound`: sem
+            // ele o ponto de partida da curva fica por conta da implementação, e o glissando começa onde calhar.
+            //
+            // ⚠️ AS DUAS GUARDAS SÃO NECESSÁRIAS E NÃO ZELO. `exponentialRampToValueAtTime` LANÇA com alvo zero ou
+            // negativo — uma tabela com `f2: 0` mataria o earcon inteiro pelo `catch`, em silêncio. E `f2 === f`
+            // não é rampa nenhuma: pedi-la ao navegador seria trabalho para produzir a nota parada que já havia.
+            if (typeof c.f2 === 'number' && c.f2 > 0 && c.f2 !== c.f) {
+                o.frequency.setValueAtTime(c.f, t);
+                o.frequency.exponentialRampToValueAtTime(c.f2, t + c.d);
+            }
             g.gain.exponentialRampToValueAtTime(Math.max(0.02, 0.25 * vol), t + 0.01);
             g.gain.exponentialRampToValueAtTime(0.0001, t + c.d);
             o.start(t);

package/dist-pkg/platform/audio-nav.d.ts

@@ -14,7 +14,7 @@ export type { PlayerCtxOut };
  * globais ambientes em qualquer arquivo desta árvore. O motivo verdadeiro é de CAMADA: `_ac` e `_acOut` não
  * são da entidade da engine, e por isso o `core/entity` deixou de mencioná-los (ADR-0039, opção A1).
  */
-type Player = PlayerView<'x' | 'y' | 'facing' | 'viz' | 'i' | 'audioSink' | 'wnT' | 'guideT' | 'pad'> & PlayerAudioOut & Pick<ControlledPlayer, 'ctrl'>;
+type Player = PlayerView<'x' | 'y' | 'facing' | 'viz' | 'i' | 'audioSink' | 'wnT' | 'pad'> & PlayerAudioOut & Pick<ControlledPlayer, 'ctrl'>;
 export interface AudioNavCtx {
     tileAt: (x: number, y: number) => number;
     solidAt: (x: number, y: number) => boolean;