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

package/dist-pkg/educational/adaptive-engine.d.ts

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** O que sobra de uma questão depois de as tentativas dela colapsarem. */
+export type ResultadoDaQuestao = 'primeira' | 'mediada' | 'falhou';
+/** A faixa em que a criança está, e o que ela manda fazer com o nível. */
+export type Faixa = 'proficiente' | 'zona' | 'frustracao';
+/** Por que a faixa é essa. Existe para o anúncio ao leitor de tela e para a barra do ADR-0049 poderem dizer
+ *  a razão em vez de só o resultado — e para um teste poder distinguir duas faixas iguais por motivos
+ *  diferentes, que é onde um motor adaptativo erra sem dar sinal. */
+export type Motivo = 'acertos-de-primeira' | 'quatro-seguidas' | 'resolvidas-no-piso' | 'dentro-da-zona' | 'janela-incompleta';
+export interface Veredicto {
+    faixa: Faixa;
+    motivo: Motivo;
+    /** −1 desce, 0 mantém, +1 sobe. O ADR-0048 §5 chama a isto o efeito da faixa. */
+    efeito: -1 | 0 | 1;
+}
+/** Quantas questões a janela olha. Dez é o número do registo. */
+export declare const JANELA = 10;
+/** A fração de acertos DE PRIMEIRA a partir da qual se sobe. 0,80 = 8 em 10, e vale para qualquer tipo. */
+export declare const ALVO_DE_SUBIDA = 0.8;
+/** Quantas QUESTÕES falhadas seguidas descem o nível na hora. Quatro, porque 0,40⁴ < 5%. */
+export declare const FALHAS_SEGUIDAS_QUE_DESCEM = 4;
+/**
+ * O piso de chute de um tipo de questão: a fração de questões que a sorte pura resolve.
+ *
+ * Sorteio SEM reposição — quem erra uma alternativa não a volta a escolher —, então a chance de falhar as
+ * `tentativas` todas é o produto de `(alternativas−1−i)/(alternativas−i)`, e o piso é o complemento.
+ *
+ * ⚠️ ELE É PARÂMETRO E NÃO CONSTANTE, e a issue #92 pede isso pelo nome: «o módulo recebe o piso como
+ * parâmetro, não o embute». Uma atividade de duas alternativas tem piso 0,50 com uma tentativa; uma de dez
+ * com uma tentativa tem 0,10. Embutir o 0,60 do caso de cinco faria o motor julgar todas as outras pela
+ * aritmética da errada.
+ */
+export declare function pisoDeChute(alternativas: number, tentativas: number): number;
+/**
+ * As tentativas de UMA questão colapsam num resultado.
+ *
+ * `acertouNaTentativa` é 1-based; `null` quando a criança não acertou em nenhuma. É aqui que quatro tentativas
+ * erradas deixam de poder ser confundidas com quatro questões falhadas: elas produzem UM `'falhou'`.
+ */
+export declare function resultadoDaQuestao(acertouNaTentativa: number | null): ResultadoDaQuestao;
+/** Quantas questões terminaram em falha, contadas do fim para trás até à primeira que não falhou. */
+export declare function falhasSeguidas(historico: readonly ResultadoDaQuestao[]): number;
+/**
+ * A faixa da criança nesta habilidade, dado o histórico de questões e o piso de chute do tipo.
+ *
+ * A ORDEM DAS PERGUNTAS É A DECISÃO, e é esta:
+ *
+ *   1. QUATRO FALHAS SEGUIDAS descem na hora — antes de tudo, e mesmo com a janela incompleta. Não é um
+ *      atalho: quatro questões falhadas seguidas é o evento de 2,56%, e ele não fica mais provável por a
+ *      criança ter respondido poucas questões. Esperar a janela fechar seria deixá-la mais seis questões
+ *      num nível que já se sabe alto.
+ *   2. JANELA INCOMPLETA mantém. ⚠️ Esta regra NÃO está na issue #92 e é decisão minha, declarada: com três
+ *      questões respondidas, «resolvidas ≤ piso» dispararia com duas falhas, e rebaixar uma criança por duas
+ *      questões é exactamente o erro que a unidade-questão existe para evitar. A regra da janela pede dez
+ *      questões porque é sobre dez que a aritmética foi feita.
+ *   3. ≥ 80% DE PRIMEIRA sobe.
+ *   4. RESOLVIDAS NO PISO OU ABAIXO descem.
+ *   5. O resto é a zona, que é onde se quer estar.
+ *
+ * ⚠️ O CORTE DE BAIXO É `≤` E NÃO `<`, e a diferença é uma questão inteira: a tabela do registo diz «≤ 6 das
+ * últimas 10», e 6/10 é exactamente o piso de 0,60 do caso de cinco alternativas. A prosa da mesma issue diz
+ * «abaixo do piso», que é o resumo e não a regra. Quem seguir a prosa deixa a criança um nível acima com um
+ * desempenho que o chute puro reproduz.
+ */
+export declare function faixaDe(historico: readonly ResultadoDaQuestao[], piso: number, janela?: number): Veredicto;

package/dist-pkg/educational/adaptive-engine.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// educational/adaptive-engine — AS TRÊS FAIXAS, e as DUAS medidas que hoje viram uma (ADR-0048 §5/§6, #92).
+//
+// ========================= O DEFEITO QUE ISTO EXISTE PARA NÃO REPETIR =========================
+// Uma atividade com retentativa produz DUAS informações por questão e o jogo guarda uma: se acertou. A que se
+// perde é a que importa mais — **acertou de primeira** ou **acertou com apoio**. Sem essa distinção não há
+// zona de desenvolvimento proximal; há só dificuldade, que é uma escada sem corrimão.
+//
+// A retentativa É o apoio graduado. Uma criança que acerta na terceira está a aprender COM mediação, e é
+// exactamente essa a faixa em que se quer que ela fique. Deitar fora o número da tentativa transforma-a numa
+// criança «que acertou», indistinguível de quem acertou sozinha — e o motor sobe o nível dela.
+//
+// ========================= POR QUE A PROFICIÊNCIA É 8/10 DE PRIMEIRA =========================
+// A aritmética é o argumento inteiro, e por isso está presa por teste em vez de comentada:
+//
+//   · Chutar com 3 tentativas em 5 alternativas acerta em 60% das questões: 1 − (4/5 · 3/4 · 2/3) = 0,60.
+//     ⚠️ É POR ISSO que a proficiência lê acertos DE PRIMEIRA e não questões resolvidas: «8 de 10 resolvidas»
+//     é praticamente o que o chute puro produz, e promoveria por sorte.
+//   · Falhar QUATRO questões seguidas tem 0,40⁴ = 0,0256 de probabilidade — abaixo do corte de 5%. É por isso
+//     que quatro seguidas descem o nível na hora, sem esperar a janela fechar.
+//
+// ⚠️ A UNIDADE É A QUESTÃO, NUNCA A TENTATIVA, e confundi-las é o defeito caro: quatro tentativas erradas
+// acontecem dentro de UMA questão difícil e são normais; quatro QUESTÕES falhadas é o evento de 2,56%.
+// `resultadoDaQuestao` existe para que as tentativas colapsem numa questão ANTES de a faixa as ver — a
+// distinção é estrutural, e não uma regra que alguém tenha de lembrar.
+//
+// ========================= O QUE ESTE FICHEIRO NÃO FAZ =========================
+// Não guarda nada. Recebe a lista de resultados e devolve a faixa — onde vive o histórico por habilidade está
+// indecidido (ADR-0049 §5 diz, textualmente, que «a casa da barra está indecidida», e o ADR-0048 §6c manda-o
+// para um sistema que ainda não existe em repositório nenhum). A função pura constrói-se hoje; a persistência
+// não, e escrevê-la aqui seria decidir por omissão o que dois registos aceites deixaram em aberto.
+//
+// E não importa NADA, como toda a camada `educational/` (ADR-0032): ela é dado, e o gate de fronteira afere.
+/** Quantas questões a janela olha. Dez é o número do registo. */
+export const JANELA = 10;
+/** A fração de acertos DE PRIMEIRA a partir da qual se sobe. 0,80 = 8 em 10, e vale para qualquer tipo. */
+export const ALVO_DE_SUBIDA = 0.8;
+/** Quantas QUESTÕES falhadas seguidas descem o nível na hora. Quatro, porque 0,40⁴ < 5%. */
+export const FALHAS_SEGUIDAS_QUE_DESCEM = 4;
+/**
+ * O piso de chute de um tipo de questão: a fração de questões que a sorte pura resolve.
+ *
+ * Sorteio SEM reposição — quem erra uma alternativa não a volta a escolher —, então a chance de falhar as
+ * `tentativas` todas é o produto de `(alternativas−1−i)/(alternativas−i)`, e o piso é o complemento.
+ *
+ * ⚠️ ELE É PARÂMETRO E NÃO CONSTANTE, e a issue #92 pede isso pelo nome: «o módulo recebe o piso como
+ * parâmetro, não o embute». Uma atividade de duas alternativas tem piso 0,50 com uma tentativa; uma de dez
+ * com uma tentativa tem 0,10. Embutir o 0,60 do caso de cinco faria o motor julgar todas as outras pela
+ * aritmética da errada.
+ */
+export function pisoDeChute(alternativas, tentativas) {
+    if (!Number.isFinite(alternativas) || alternativas < 2)
+        return 0;
+    // O tecto é o número de ALTERNATIVAS, não uma a menos: com tantas tentativas quantas alternativas a
+    // criança esgota todas as erradas e a certeza é 1. Pedir mais não pode passar disso.
+    const t = Math.max(0, Math.min(Math.floor(tentativas), Math.floor(alternativas)));
+    let falhaTudo = 1;
+    for (let i = 0; i < t; i++)
+        falhaTudo *= (alternativas - 1 - i) / (alternativas - i);
+    return 1 - falhaTudo;
+}
+/**
+ * As tentativas de UMA questão colapsam num resultado.
+ *
+ * `acertouNaTentativa` é 1-based; `null` quando a criança não acertou em nenhuma. É aqui que quatro tentativas
+ * erradas deixam de poder ser confundidas com quatro questões falhadas: elas produzem UM `'falhou'`.
+ */
+export function resultadoDaQuestao(acertouNaTentativa) {
+    if (acertouNaTentativa === null || !Number.isFinite(acertouNaTentativa))
+        return 'falhou';
+    return acertouNaTentativa <= 1 ? 'primeira' : 'mediada';
+}
+/** Quantas questões terminaram em falha, contadas do fim para trás até à primeira que não falhou. */
+export function falhasSeguidas(historico) {
+    let n = 0;
+    for (let i = historico.length - 1; i >= 0 && historico[i] === 'falhou'; i--)
+        n++;
+    return n;
+}
+/**
+ * A faixa da criança nesta habilidade, dado o histórico de questões e o piso de chute do tipo.
+ *
+ * A ORDEM DAS PERGUNTAS É A DECISÃO, e é esta:
+ *
+ *   1. QUATRO FALHAS SEGUIDAS descem na hora — antes de tudo, e mesmo com a janela incompleta. Não é um
+ *      atalho: quatro questões falhadas seguidas é o evento de 2,56%, e ele não fica mais provável por a
+ *      criança ter respondido poucas questões. Esperar a janela fechar seria deixá-la mais seis questões
+ *      num nível que já se sabe alto.
+ *   2. JANELA INCOMPLETA mantém. ⚠️ Esta regra NÃO está na issue #92 e é decisão minha, declarada: com três
+ *      questões respondidas, «resolvidas ≤ piso» dispararia com duas falhas, e rebaixar uma criança por duas
+ *      questões é exactamente o erro que a unidade-questão existe para evitar. A regra da janela pede dez
+ *      questões porque é sobre dez que a aritmética foi feita.
+ *   3. ≥ 80% DE PRIMEIRA sobe.
+ *   4. RESOLVIDAS NO PISO OU ABAIXO descem.
+ *   5. O resto é a zona, que é onde se quer estar.
+ *
+ * ⚠️ O CORTE DE BAIXO É `≤` E NÃO `<`, e a diferença é uma questão inteira: a tabela do registo diz «≤ 6 das
+ * últimas 10», e 6/10 é exactamente o piso de 0,60 do caso de cinco alternativas. A prosa da mesma issue diz
+ * «abaixo do piso», que é o resumo e não a regra. Quem seguir a prosa deixa a criança um nível acima com um
+ * desempenho que o chute puro reproduz.
+ */
+export function faixaDe(historico, piso, janela = JANELA) {
+    if (falhasSeguidas(historico) >= FALHAS_SEGUIDAS_QUE_DESCEM) {
+        return { faixa: 'frustracao', motivo: 'quatro-seguidas', efeito: -1 };
+    }
+    if (historico.length < janela) {
+        return { faixa: 'zona', motivo: 'janela-incompleta', efeito: 0 };
+    }
+    const ultimas = historico.slice(-janela);
+    const dePrimeira = ultimas.filter((r) => r === 'primeira').length / janela;
+    const resolvidas = ultimas.filter((r) => r !== 'falhou').length / janela;
+    if (dePrimeira >= ALVO_DE_SUBIDA)
+        return { faixa: 'proficiente', motivo: 'acertos-de-primeira', efeito: 1 };
+    if (resolvidas <= piso)
+        return { faixa: 'frustracao', motivo: 'resolvidas-no-piso', efeito: -1 };
+    return { faixa: 'zona', motivo: 'dentro-da-zona', efeito: 0 };
+}

package/dist-pkg/educational/segment-bar.d.ts

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * O que sobra de uma questão depois de as tentativas dela colapsarem.
+ *
+ * ⚠️ DECLARADO AQUI, e não importado do `adaptive-engine`, porque a camada não importa nada. As duas uniões
+ * são estruturalmente idênticas — em TypeScript isso basta para o valor de um atravessar para o outro sem
+ * conversão — e o caso `[Interface]` do gate afirma que continuam idênticas. Se alguém acrescentar um quarto
+ * resultado ao motor e esquecer este ficheiro, é lá que se descobre.
+ */
+export type Resultado = 'primeira' | 'mediada' | 'falhou';
+/** A cor de UM segmento. Uma questão, nunca uma tentativa. */
+export type Segmento = 'azul' | 'verde' | 'vermelho';
+/**
+ * A cor da barra INTEIRA, que é o veredicto do motor adaptativo a ficar visível.
+ *
+ * `nenhuma` não é «apagada» — é a barra a mostrar os seus segmentos, que é o estado normal. Laranja e roxa
+ * cobrem-nos porque são a única coisa que interessa naquele instante.
+ */
+export type CorDaBarra = 'nenhuma' | 'laranja' | 'roxa';
+/**
+ * O VEREDICTO, visto daqui: a fatia mínima do que o `faixaDe` devolve.
+ *
+ * Só `efeito` e `motivo`, e nem sequer a `faixa` — a barra não precisa de saber que a criança está «na zona»,
+ * precisa de saber se subiu, desceu ou ficou. `motivo` existe para o anúncio ao leitor de tela poder dizer a
+ * RAZÃO: «desceu porque quatro seguidas» é informação; «ficou laranja» é decoração.
+ */
+export interface VeredictoLido {
+    readonly efeito: -1 | 0 | 1;
+    readonly motivo: string;
+}
+/**
+ * Quantos segmentos a barra tem.
+ *
+ * Dez, e tem de ser a mesma `JANELA` que o motor adaptativo julga: uma barra que mostrasse doze questões
+ * enquanto o motor julga dez estaria a mostrar duas que não contam para o veredicto que a colore. O gate
+ * afirma a igualdade, porque este ficheiro não pode importar a constante.
+ */
+export declare const SEGMENTOS_DA_BARRA = 10;
+/** Uma barra pronta a desenhar. Tudo aqui é derivado; não há nada para mutar. */
+export interface Barra {
+    /** A árvore de habilidade desta barra. O ADR-0049 §5 manda uma barra POR habilidade, de uma a três, e o
+     *  segmento cai na barra da habilidade que a questão exercitou — sem isto, duas habilidades ligadas ao
+     *  mesmo tempo partilhariam um histórico e as faixas mediriam a média de duas crianças diferentes. */
+    readonly skill: string;
+    /** Os segmentos, do mais ANTIGO para o mais novo, no máximo `SEGMENTOS_DA_BARRA`. Menos do que isso no
+     *  começo da sessão: a barra enche-se, e não nasce cheia de espaços que pareçam erros. */
+    readonly segmentos: readonly Segmento[];
+    readonly cor: CorDaBarra;
+    /** O veredicto que produziu a cor, tal como entrou. */
+    readonly veredicto: VeredictoLido;
+}
+/**
+ * Um resultado de questão vira uma cor. É a tradução inteira, e é 1 para 1 de propósito.
+ *
+ * ⚠️ UMA QUESTÃO, NUNCA UMA TENTATIVA. Duas tentativas erradas não são um erro — são a tolerância; o
+ * segmento só fica vermelho depois da terceira. O `resultadoDaQuestao` do motor é quem faz esse colapso, e é
+ * por isso que esta função recebe o resultado e não o número de tentativas: se recebesse tentativas, uma
+ * questão difícil pintaria três vermelhos e desceria de nível uma criança que estava apenas a pensar.
+ */
+export declare function corDoSegmento(r: Resultado): Segmento;
+/** O que se sabe além do histórico e do veredicto. */
+export interface Contexto {
+    /**
+     * ⚠️ A CRIANÇA CHEGOU A COPIAR A RESPOSTA (ADR-0049): falhou as três tentativas, falhou as três da
+     * explicação, e a resposta apareceu para ela copiar. Aí «o nível desce IMEDIATAMENTE, sem esperar por
+     * quatro questões falhadas — a barra fica laranja de uma vez».
+     *
+     * É a única entrada que não vem do histórico nem do veredicto, e tem de existir separada porque o
+     * histórico não a distingue: copiar a resposta produz um `'falhou'` igual ao de quem errou três vezes e
+     * seguiu em frente. A diferença entre as duas é pedagógica, e é ela que decide se o nível desce agora ou
+     * daqui a três questões.
+     */
+    readonly copiouAResposta?: boolean;
+}
+/**
+ * A barra de uma habilidade: o histórico dela, colorido pelo veredicto que o motor já emitiu.
+ *
+ * ⚠️ O HISTÓRICO É O DA HABILIDADE, não o da sessão, e o veredicto tem de ser o DAQUELE histórico. Passar
+ * aqui o histórico misturado de duas habilidades é o defeito que o ADR-0049 §5 nomeia: as faixas passariam a
+ * medir a média de duas crianças diferentes. Quem chama separa; este módulo não tem como saber que não
+ * separou — nem tem como julgar, que é precisamente o ponto.
+ */
+export declare function barraDe(skill: string, historico: readonly Resultado[], veredicto: VeredictoLido, ctx?: Contexto): Barra;
+/**
+ * O histórico DEPOIS de a barra ter sinalizado — porque «sobe» leva consigo «e a contagem zera».
+ *
+ * ⚠️ O ZERAR ESTÁ ESCRITO PARA O ROXO E INFERIDO PARA O LARANJA, e a inferência fica declarada aqui em vez de
+ * escondida no código. O ADR-0049 §5 diz «ALL PURPLE — eight blues: the level rises, AND THE COUNT RESETS», e
+ * não diz nada equivalente para o laranja. Mas não zerar no laranja não é neutro: os quatro vermelhos
+ * continuariam na janela e a barra voltaria a mandar descer a CADA questão nova, até eles rolarem para fora
+ * — quatro descidas de nível onde a decisão foi uma. Um registo que manda descer de nível não pode, pelo
+ * mesmo facto, mandar descer quatro vezes.
+ *
+ * Fica como pergunta para o Dev; enquanto ele não a responder, esta é a leitura que não produz um defeito.
+ */
+export declare function aposSinalizar(historico: readonly Resultado[], barra: Barra): readonly Resultado[];

package/dist-pkg/educational/segment-bar.js

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// educational/segment-bar — A BARRA DE DEZ SEGMENTOS do ADR-0049 §5 (issue #93), e ela não decide nada.
+//
+// ========================= A BARRA NÃO PODE CONTAR, E ISSO É ESTRUTURAL =========================
+// A leitura literal da issue #93 produz um módulo com contadores próprios: «oito azuis → roxa, cinco
+// vermelhos → laranja». Escrevê-lo assim seria pôr no repositório uma SEGUNDA implementação de uma decisão
+// que já existe no `faixaDe` do motor adaptativo:
+//
+//   · «oito azuis sobem»            é o `ALVO_DE_SUBIDA = 0.8` — 8 de primeira em 10;
+//   · «quatro vermelhos seguidos»   é o `FALHAS_SEGUIDAS_QUE_DESCEM = 4`;
+//   · «cinco vermelhos espalhados»  é `resolvidas <= piso` — 5 falhadas em 10 dá 0,50, abaixo do piso 0,60.
+//
+// O próprio ADR-0049 diz isto em voz alta: «That is what makes every number in ADR-0048 §5 line up.»
+//
+// ⚠️ E AS DUAS CÓPIAS JÁ DISCORDARIAM HOJE, o que torna isto um defeito e não um gosto: «cinco espalhados»
+// só é o limiar quando o piso é 0,60, e o piso é PARÂMETRO — sai do número de alternativas da questão
+// (`pisoDoChute`). Num item de verdadeiro-ou-falso o piso é muito mais alto e menos falhas já bastam; a
+// barra escrita com o «cinco» literal continuaria a mostrar verde a uma criança que o motor já teria descido.
+//
+// ⚠️ POR ISSO O VEREDICTO ENTRA PRONTO, e é a arquitectura que o obriga em vez de a disciplina. O `educational/`
+// não importa NADA — nem os seus vizinhos (ADR-0032; a camada é DADO e viaja sozinha para o
+// `the-inclusionist-knowledge-tree` do ADR-0058). Este módulo não tem, portanto, como chamar o `faixaDe`; e
+// como também não recebe o `piso`, não tem sequer os números com que recalcular a regra. Ele SÓ pode
+// projectar o que lhe deram. Um gate consegue afirmar que duas implementações concordam; esta forma torna a
+// segunda implementação impossível de escrever aqui dentro.
+//
+// ========================= E ELA NÃO GUARDA NADA (ADR-0103) =========================
+// ⚠️ Este módulo não persiste e não pode vir a persistir. O ADR-0103 decidiu que a barra não vive em lado
+// nenhum — nem engine, nem cartucho, nem Bússola Escolar — e a razão é PEDAGÓGICA antes de jurídica: o
+// desenvolvimento oscila, a criança joga uma dada actividade talvez uma vez por semana, e um histórico
+// guardado achata a oscilação numa linha de tendência que lê um recuo normal como regressão. O argumento
+// jurídico permitiria guardar assim que a controladoria estivesse resolvida; este não permite nunca. Os dois
+// gates que o §confirmation daquele registo deixou em dívida são `tests/segment-bar.node.test.js` e
+// `tests/no-stored-history.node.test.js`.
+//
+// «Permanente» no ADR-0049 §5 quer dizer PERMANENTE ENTRE ACTIVIDADES DA MESMA SESSÃO — a actividade é o
+// veículo, a barra é a leitura da criança numa árvore de habilidade, e uma árvore sobrevive a uma
+// actividade. Não quer dizer permanente entre dias.
+/**
+ * Quantos segmentos a barra tem.
+ *
+ * Dez, e tem de ser a mesma `JANELA` que o motor adaptativo julga: uma barra que mostrasse doze questões
+ * enquanto o motor julga dez estaria a mostrar duas que não contam para o veredicto que a colore. O gate
+ * afirma a igualdade, porque este ficheiro não pode importar a constante.
+ */
+export const SEGMENTOS_DA_BARRA = 10;
+/**
+ * Um resultado de questão vira uma cor. É a tradução inteira, e é 1 para 1 de propósito.
+ *
+ * ⚠️ UMA QUESTÃO, NUNCA UMA TENTATIVA. Duas tentativas erradas não são um erro — são a tolerância; o
+ * segmento só fica vermelho depois da terceira. O `resultadoDaQuestao` do motor é quem faz esse colapso, e é
+ * por isso que esta função recebe o resultado e não o número de tentativas: se recebesse tentativas, uma
+ * questão difícil pintaria três vermelhos e desceria de nível uma criança que estava apenas a pensar.
+ */
+export function corDoSegmento(r) {
+    return r === 'primeira' ? 'azul' : r === 'mediada' ? 'verde' : 'vermelho';
+}
+/**
+ * A barra de uma habilidade: o histórico dela, colorido pelo veredicto que o motor já emitiu.
+ *
+ * ⚠️ O HISTÓRICO É O DA HABILIDADE, não o da sessão, e o veredicto tem de ser o DAQUELE histórico. Passar
+ * aqui o histórico misturado de duas habilidades é o defeito que o ADR-0049 §5 nomeia: as faixas passariam a
+ * medir a média de duas crianças diferentes. Quem chama separa; este módulo não tem como saber que não
+ * separou — nem tem como julgar, que é precisamente o ponto.
+ */
+export function barraDe(skill, historico, veredicto, ctx = {}) {
+    const segmentos = historico.slice(-SEGMENTOS_DA_BARRA).map(corDoSegmento);
+    // A rendição vence o veredicto porque ela É uma descida, decidida antes e por outro caminho. Escrevê-la
+    // como `|| efeito < 0` em vez de a testar primeiro daria o mesmo resultado hoje e mentiria sobre a ordem.
+    const cor = ctx.copiouAResposta ? 'laranja'
+        : veredicto.efeito > 0 ? 'roxa'
+            : veredicto.efeito < 0 ? 'laranja' : 'nenhuma';
+    return { skill, segmentos, cor, veredicto };
+}
+/**
+ * O histórico DEPOIS de a barra ter sinalizado — porque «sobe» leva consigo «e a contagem zera».
+ *
+ * ⚠️ O ZERAR ESTÁ ESCRITO PARA O ROXO E INFERIDO PARA O LARANJA, e a inferência fica declarada aqui em vez de
+ * escondida no código. O ADR-0049 §5 diz «ALL PURPLE — eight blues: the level rises, AND THE COUNT RESETS», e
+ * não diz nada equivalente para o laranja. Mas não zerar no laranja não é neutro: os quatro vermelhos
+ * continuariam na janela e a barra voltaria a mandar descer a CADA questão nova, até eles rolarem para fora
+ * — quatro descidas de nível onde a decisão foi uma. Um registo que manda descer de nível não pode, pelo
+ * mesmo facto, mandar descer quatro vezes.
+ *
+ * Fica como pergunta para o Dev; enquanto ele não a responder, esta é a leitura que não produz um defeito.
+ */
+export function aposSinalizar(historico, barra) {
+    return barra.cor === 'nenhuma' ? historico : [];
+}

package/dist-pkg/i18n/en.js

@@ -101,6 +101,7 @@ const en = {
     'touch.dir.cross': 'cross (D-pad)',
     'touch.dir.stick': 'analogue stick',
     'sr.touch.slotSet': '{slot}: {acao}.',
+    'sr.touch.slotSetUnnamed': '{slot}: set.',
     'sr.touch.dirSet': 'Directional: {tipo}.',
     'sr.touch.presetChild': 'Controls sized for a child hand (6 to 12 years).',
     'sr.touch.presetAdult': 'Controls sized for an adult hand.',
@@ -115,9 +116,15 @@ const en = {
     'act.especial': 'Special',
     'key.space': 'Space',
     'ctrl.change': 'Change',
+    'ctrl.pressing': 'Press…',
+    'ctrl.editingYours': 'Editing your controls — {modo} mode.',
+    'ctrl.mode.one': '1 player',
+    'ctrl.mode.many': '{n} players',
     'ctrl.changeKeyAria': 'Change the {acao} key for Player {n}',
     'sr.ctrl.pressNewKey': 'Press the new key for {acao}, Player {n}, or Esc to cancel.',
     'sr.ctrl.keyTaken': 'That key already belongs to Player {n}. Pick another, or Esc to cancel.',
+    'sr.ctrl.keyTakenHere': 'That key already belongs to {acao}. Choose another, or Esc to cancel.',
+    'sr.ctrl.keyTakenHereUnnamed': 'That key is already in use on this controller. Choose another, or Esc to cancel.',
     'sr.ctrl.reset': 'Controls restored to their defaults.',
     // Audio panel (#audio) — per-player outputs, sound/narration, cane, speech engines.
     'audio.playerN': 'Player {n}',
@@ -206,6 +213,11 @@ const en = {
     'pad.glyph.circle': 'circle',
     'pad.glyph.square': 'square',
     'pad.glyph.triangle': 'triangle',
+    'pad.wiz.step': '{n} of {total} — press: {acao}',
+    'pad.wiz.mapped': 'Mapped: {lista}',
+    'pad.wiz.pressAny': 'Press ANY button on the controller you want to map.',
+    'pad.wiz.detected': 'New controller detected: {id}. The game paused so you can set it up. RELEASE everything to start.',
+    'pad.wiz.releaseAll': 'Controller: {id}. Now RELEASE everything.',
     'menu.legendSpoken': 'Button {sim} to select, button {nao} to go back.',
     'sr.menu.fractionsIntro': 'Adding and subtracting fractions: choose the notation and the type.',
     'sr.menu.keepOneNotation': 'Keep at least one notation on.',
@@ -231,6 +243,16 @@ const en = {
     // ===== THE REACH NOTICE (issue #112, ADR-0079 section 3) =====
     'reach.titulo': 'This game uses {pedidas} actions.',
     'reach.curto': 'The {transporte} has {lugares} places - not enough for all of them.',
+    'reach.naoSegura': 'The {transporte} holds {segura} buttons at a time, and this game needs {pedidas} together.',
+    'eixo.tema.titulo': 'Theme (contrast)',
+    'eixo.tema.padrao': 'Default theme',
+    'eixo.correcao.titulo': 'Colour correction',
+    'eixo.correcao.tricro': 'Trichromatic vision',
+    'viz.escolher': 'Select',
+    'viz.escolhido': '✓ Selected',
+    'sim.indisponivel.tema': 'To see the simulation, the theme needs to be at its default: over high contrast it would show what the theme does, not what the condition does.',
+    'sim.indisponivel.correcao': 'To see the simulation, colour correction needs to be at trichromatic vision: from an already-corrected screen it would show neither the condition nor the correction.',
+    'sim.indisponivel.ambos': 'To see the simulation, both the theme and colour correction need to be at their defaults: over an adjustment, the demonstration shows the adjustment and not the condition.',
     'reach.ligue': 'Connect {saida} and you can use them all.',
     'reach.semSaida': 'No control on this device reaches all of them. You can still play, but some actions will have nowhere to go.',
     'reach.continuar': 'Play anyway',
@@ -304,6 +326,8 @@ const en = {
     'sr.quiz.wellDone': 'Well done! {palavra}. {n} out of 3.',
     'sr.quiz.correctSoFar': 'Correct! {n} out of 3 to win the coin.',
     'menu.restoreDefaults': 'Restore this menu to its defaults',
+    'menu.close': 'Close',
+    'menu.typo': 'Typography',
     'sr.audio.reset': 'Hearing accessibility restored to its defaults. The other menus did not change.',
     'sr.empathy.reset': 'Empathy mode restored to its defaults: simulations off. Colour-blindness corrections and the other menus did not change.',
     'sr.motor.reset': 'Easy Mode and latched movement restored to their defaults. Eye control and the key mapping are unchanged.',
@@ -397,6 +421,10 @@ const en = {
     'sr.motor.easyOff': 'Easy Mode off.',
     'sr.motor.toggleMoveOn': 'Tap-to-move on: tap a direction to walk without holding; tap again to stop; hold to go faster. Jumping does not interrupt the walk.',
     'sr.motor.toggleMoveOff': 'Tap-to-move off.',
+    'alt.exigida.olhos': 'Gaze control needs tap-to-move to work.',
+    'alt.exigida.rosto': 'Face control needs tap-to-move to work.',
+    'alt.exigida.gestos': 'Gesture control needs tap-to-move to work.',
+    'alt.exigida.fala': 'Voice command needs tap-to-move to work.',
     'sr.motor.toggleRunOn': 'Run toggle on.',
     'sr.motor.toggleRunOff': 'Run toggle off.',
     'sr.physics.runLatchOn': 'Running.',
@@ -541,18 +569,23 @@ const en = {
     'legend.run': 'run',
     'legend.swap': 'switch',
     // ===================== FONT CATALOGUE =====================
+    'font.grupo.rotulo': 'Letter family',
     'font.group.sans': 'Sans serif',
     'font.group.serif': 'Serif',
     'font.group.hand': 'Handwritten',
+    'font.group.arcade': 'Arcade',
     'font.desc.atkinson': 'made by the Braille Institute for people with low vision (the game default)',
     'font.desc.lexend': 'made to reduce visual stress and serve dyslexic readers (turns on the extra spacing)',
     'font.desc.quattro': 'built to ease the eye strain of long hours on a screen',
     'font.desc.andika': 'based on Sassoon; the fruit of research into how children read and write',
+    'font.desc.opendyslexic': 'Letters weighted at the bottom, so they do not flip upside down as you read.',
+    'font.desc.fondamento': 'Pen calligraphy, for the handwriting activities.',
     'font.desc.greatvibes': 'English calligraphy',
     'font.desc.pinyon': 'English calligraphy',
     'font.desc.ufcook': 'German blackletter',
     'font.desc.ufmag': 'German blackletter',
     'font.desc.comicneue': 'ball and stick (early literacy)',
+    'font.desc.pressstart': '8-bit pixel (game HUD and title)',
     'font.desc.learningcurve': 'English cursive',
     'font.desc.kindergarten': 'Brazilian cursive',
     'font.off.pending': 'licence to be confirmed — not shipped yet',

package/dist-pkg/i18n/es.js

@@ -102,6 +102,7 @@ const es = {
     'touch.dir.cross': 'cruceta (D-pad)',
     'touch.dir.stick': 'palanca analógica',
     'sr.touch.slotSet': '{slot}: {acao}.',
+    'sr.touch.slotSetUnnamed': '{slot}: asignado.',
     'sr.touch.dirSet': 'Direccional: {tipo}.',
     'sr.touch.presetChild': 'Controles del tamaño de una mano infantil (6 a 12 años).',
     'sr.touch.presetAdult': 'Controles del tamaño de una mano adulta.',
@@ -116,9 +117,15 @@ const es = {
     'act.especial': 'Especial',
     'key.space': 'Espacio',
     'ctrl.change': 'Cambiar',
+    'ctrl.pressing': 'Pulsa…',
+    'ctrl.editingYours': 'Editando tu mando — modo {modo}.',
+    'ctrl.mode.one': '1 jugador',
+    'ctrl.mode.many': '{n} jugadores',
     'ctrl.changeKeyAria': 'Cambiar la tecla de {acao} del Jugador {n}',
     'sr.ctrl.pressNewKey': 'Pulsa la nueva tecla para {acao} del Jugador {n}, o Esc para cancelar.',
     'sr.ctrl.keyTaken': 'Esa tecla ya es del Jugador {n}. Elige otra, o Esc para cancelar.',
+    'sr.ctrl.keyTakenHere': 'Esa tecla ya es de {acao}. Elige otra, o Esc para cancelar.',
+    'sr.ctrl.keyTakenHereUnnamed': 'Esa tecla ya está en uso en este control. Elige otra, o Esc para cancelar.',
     'sr.ctrl.reset': 'Controles restaurados a los valores predeterminados.',
     // Panel de audio (#audio) — salidas por jugador, sonido/narración, bastón, motores de voz.
     'audio.playerN': 'Jugador {n}',
@@ -207,6 +214,11 @@ const es = {
     'pad.glyph.circle': 'círculo',
     'pad.glyph.square': 'cuadrado',
     'pad.glyph.triangle': 'triángulo',
+    'pad.wiz.step': '{n} de {total} — pulsa: {acao}',
+    'pad.wiz.mapped': 'Asignados: {lista}',
+    'pad.wiz.pressAny': 'Pulsa CUALQUIER botón del mando que quieras configurar.',
+    'pad.wiz.detected': 'Mando nuevo detectado: {id}. El juego se pausó para que puedas configurarlo. SUELTA todo para empezar.',
+    'pad.wiz.releaseAll': 'Mando: {id}. Ahora SUELTA todo.',
     'menu.legendSpoken': 'Botón {sim} para confirmar, botón {nao} para volver.',
     'sr.menu.fractionsIntro': 'Suma y resta de fracciones: elige la notación y el tipo.',
     'sr.menu.keepOneNotation': 'Deja al menos una notación activada.',
@@ -231,6 +243,16 @@ const es = {
     // ===== EL AVISO DE ALCANCE (issue #112, ADR-0079 seccion 3) =====
     'reach.titulo': 'Este juego usa {pedidas} acciones.',
     'reach.curto': 'El {transporte} tiene {lugares} lugares: no alcanzan para todas.',
+    'reach.naoSegura': 'El {transporte} sostiene {segura} botones a la vez, y este juego pide {pedidas} al mismo tiempo.',
+    'eixo.tema.titulo': 'Tema (contraste)',
+    'eixo.tema.padrao': 'Tema predeterminado',
+    'eixo.correcao.titulo': 'Corrección de color',
+    'eixo.correcao.tricro': 'Visión tricromática',
+    'viz.escolher': 'Seleccionar',
+    'viz.escolhido': '✓ Seleccionado',
+    'sim.indisponivel.tema': 'Para ver la simulación, el tema tiene que estar en su valor predeterminado: sobre el alto contraste mostraría lo que hace el tema, y no lo que hace la deficiencia.',
+    'sim.indisponivel.correcao': 'Para ver la simulación, la corrección de color tiene que estar en visión tricromática: desde una pantalla ya corregida no mostraría ni la deficiencia ni la corrección.',
+    'sim.indisponivel.ambos': 'Para ver la simulación, el tema y la corrección de color tienen que estar en sus valores predeterminados: sobre un ajuste, la demostración muestra el ajuste y no la deficiencia.',
     'reach.ligue': 'Conecta {saida} y podrás usarlas todas.',
     'reach.semSaida': 'Ningún control de este aparato alcanza todas. Puedes jugar igual, pero algunas acciones quedarán sin lugar.',
     'reach.continuar': 'Jugar así',
@@ -304,6 +326,8 @@ const es = {
     'sr.quiz.wellDone': '¡Muy bien! {palavra}. {n} de 3.',
     'sr.quiz.correctSoFar': '¡Acertaste! {n} de 3 para ganar la moneda.',
     'menu.restoreDefaults': 'Restaurar los valores predeterminados de este menú',
+    'menu.close': 'Cerrar',
+    'menu.typo': 'Tipografía',
     'sr.audio.reset': 'Accesibilidad auditiva restaurada a sus valores predeterminados. Los demás menús no cambiaron.',
     'sr.empathy.reset': 'Modo empatía restaurado a sus valores predeterminados: simulaciones desactivadas. Las correcciones de daltonismo y los demás menús no cambiaron.',
     'sr.motor.reset': 'Modo Fácil y movimiento por alternancia restaurados a sus valores predeterminados. El control con los ojos y el mapeo de teclas siguen igual.',
@@ -397,6 +421,10 @@ const es = {
     'sr.motor.easyOff': 'Modo Fácil desactivado.',
     'sr.motor.toggleMoveOn': 'Movimiento por alternancia activado: toca la dirección para andar sin mantener; toca de nuevo para parar; mantén para ir más rápido. El salto no interrumpe la marcha.',
     'sr.motor.toggleMoveOff': 'Movimiento por alternancia desactivado.',
+    'alt.exigida.olhos': 'El control por mirada necesita el movimiento por alternancia para funcionar.',
+    'alt.exigida.rosto': 'El control por rostro necesita el movimiento por alternancia para funcionar.',
+    'alt.exigida.gestos': 'Los gestos necesitan el movimiento por alternancia para funcionar.',
+    'alt.exigida.fala': 'El comando de voz necesita el movimiento por alternancia para funcionar.',
     'sr.motor.toggleRunOn': 'Alternancia de correr activada.',
     'sr.motor.toggleRunOff': 'Alternancia de correr desactivada.',
     'sr.physics.runLatchOn': 'Corriendo.',
@@ -539,18 +567,23 @@ const es = {
     'legend.run': 'correr',
     'legend.swap': 'cambiar',
     // ===================== CATÁLOGO DE FUENTES =====================
+    'font.grupo.rotulo': 'Familia de letra',
     'font.group.sans': 'Sin serifa',
     'font.group.serif': 'Con serifa',
     'font.group.hand': 'Manuscrita',
+    'font.group.arcade': 'Arcade',
     'font.desc.atkinson': 'hecha por el Braille Institute para personas con baja visión (la predeterminada del juego)',
     'font.desc.lexend': 'hecha para reducir el estrés visual y atender a personas disléxicas (activa el espaciado extra)',
     'font.desc.quattro': 'creada para reducir la fatiga visual de quien pasa mucho tiempo ante la pantalla',
     'font.desc.andika': 'basada en la Sassoon; fruto de la investigación sobre cómo leen y escriben los niños',
+    'font.desc.opendyslexic': 'Letras con la base más pesada, para que no se den vuelta al leer.',
+    'font.desc.fondamento': 'Caligráfica de pluma, para las actividades de escritura a mano.',
     'font.desc.greatvibes': 'caligráfica inglesa',
     'font.desc.pinyon': 'caligráfica inglesa',
     'font.desc.ufcook': 'blackletter alemana',
     'font.desc.ufmag': 'blackletter alemana',
     'font.desc.comicneue': 'bola y palo (alfabetización)',
+    'font.desc.pressstart': 'píxel de 8 bits (HUD y título del juego)',
     'font.desc.learningcurve': 'cursiva inglesa',
     'font.desc.kindergarten': 'cursiva brasileña',
     'font.off.pending': 'licencia por confirmar — aún no incluida',