@the-inclusionist/engine 8.0.0 → 10.0.0

package/dist-pkg/core/visual-cycles.d.ts

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** The high-contrast levels, as `player.viz` values. The first one is «off». */
+export declare const CONTRAST_LEVELS: readonly string[];
+/** The colour-correction cycle, as `player.viz` values. */
+export declare const CVD_SEQ: readonly string[];
+/**
+ * The i18n keys of the announced colour-correction names, indexed like `CVD_SEQ`.
+ *
+ * ⚠️ POSITION 0 IS `cvd.tricro` AND NOT `cvd.off`, AND THE TWO KEYS DO NOT SWAP. This list names the four CHOICES of the
+ * cycle, so position 0 is a way of seeing — trichromatic vision, the one that needs no correction — and it says so. `cvd.off`
+ * is the FALLBACK for `viz` values that are no correction at all, and 13 of the 16 modes are exactly that: the three
+ * simulations, the three contrast levels, the five low-vision ones and blind mode. Announcing «trichromatic vision» there
+ * would be the software asserting what the child sees while she simulates not seeing. The choice is named; the fallback is off.
+ */
+export declare const CVD_NAMES: readonly string[];
+/** The next contrast step. A `viz` that is not in the list — a correction filter, say — counts as index 0. */
+export declare function nextContrast(cur: string | undefined): string;
+/**
+ * The next colour-correction step.
+ *
+ * 🔴 NOTE THE ASYMMETRY WITH `nextContrast`, and it is the reason the two live in one file: an unknown `viz` lands on index
+ * **1** (`fix-protan`) and not on 0. It is the monolith's rule, kept verbatim (`idx = idx<0 ? 1 : (idx+1)%seq.length`), and the effect on
+ * the child is concrete: starting from a mode that is not a correction, contrast switches on at its first level while
+ * correction skips «normal» and goes straight into protanopia. Apart, a reader fixes one by the other and deletes a decision
+ * without knowing it existed.
+ */
+export declare function nextCvd(cur: string | undefined): {
+    idx: number;
+    mode: string;
+};

package/dist-pkg/core/visual-cycles.js

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// core/visual-cycles — THE TWO CYCLES OF VISUAL ACCESSIBILITY, and the asymmetry between them (ADR-0221; issue #203).
+//
+// High contrast and colour correction are two choices a child steps through from the quick bar, and they used to live in two
+// different modules: the list of levels in `ui/settings-visual`, the steps and the names in `ui/pause-icons`. 🔴 They are here
+// together because the thing that costs most to maintain only reads when both are in sight — their ASYMMETRY, written below
+// and deliberate.
+//
+// ⚠️ A LEAF MODULE: zero imports, zero DOM, zero storage. Two lists and two small sums.
+//
+// 📌 What it does NOT decide: which cycle the bar offers, or when. That belongs to the icon (`ui/pause-icons`) and to the panel
+// (`ui/settings-visual`), the two surfaces through which the same choice is asked for.
+/** The high-contrast levels, as `player.viz` values. The first one is «off». */
+export const CONTRAST_LEVELS = ['normal', 'hc-direto', 'hc-direto-45', 'hc-direto-7'];
+/** The colour-correction cycle, as `player.viz` values. */
+export const CVD_SEQ = ['normal', 'fix-protan', 'fix-deuter', 'fix-tritan'];
+/**
+ * The i18n keys of the announced colour-correction names, indexed like `CVD_SEQ`.
+ *
+ * ⚠️ POSITION 0 IS `cvd.tricro` AND NOT `cvd.off`, AND THE TWO KEYS DO NOT SWAP. This list names the four CHOICES of the
+ * cycle, so position 0 is a way of seeing — trichromatic vision, the one that needs no correction — and it says so. `cvd.off`
+ * is the FALLBACK for `viz` values that are no correction at all, and 13 of the 16 modes are exactly that: the three
+ * simulations, the three contrast levels, the five low-vision ones and blind mode. Announcing «trichromatic vision» there
+ * would be the software asserting what the child sees while she simulates not seeing. The choice is named; the fallback is off.
+ */
+export const CVD_NAMES = ['cvd.tricro', 'cvd.protan', 'cvd.deuter', 'cvd.tritan'];
+/*
+ * 🔴 `CVD_LABELS` DID NOT COME ALONG — IT WAS DELETED. It sat in the declared debt of `ui/pause-icons`
+ * (`docs/6-DevOps-SRE/exports-without-consumer.json`) — published and measured to have no consumer anywhere — and its own
+ * comment called it «the label `iconLabel` uses», which had stopped being true at some point with nobody noticing. A debt
+ * ledger exists to SHRINK: moving it house would have carried it another year. What `iconLabel` uses is `CVD_NAMES`.
+ */
+/** The next contrast step. A `viz` that is not in the list — a correction filter, say — counts as index 0. */
+export function nextContrast(cur) {
+    let idx = CONTRAST_LEVELS.indexOf(cur);
+    idx = idx < 0 ? 0 : idx;
+    return CONTRAST_LEVELS[(idx + 1) % CONTRAST_LEVELS.length];
+}
+/**
+ * The next colour-correction step.
+ *
+ * 🔴 NOTE THE ASYMMETRY WITH `nextContrast`, and it is the reason the two live in one file: an unknown `viz` lands on index
+ * **1** (`fix-protan`) and not on 0. It is the monolith's rule, kept verbatim (`idx = idx<0 ? 1 : (idx+1)%seq.length`), and the effect on
+ * the child is concrete: starting from a mode that is not a correction, contrast switches on at its first level while
+ * correction skips «normal» and goes straight into protanopia. Apart, a reader fixes one by the other and deletes a decision
+ * without knowing it existed.
+ */
+export function nextCvd(cur) {
+    let idx = CVD_SEQ.indexOf(cur);
+    idx = idx < 0 ? 1 : (idx + 1) % CVD_SEQ.length;
+    return { idx, mode: CVD_SEQ[idx] };
+}

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

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** The CONTRAST axis. `padrao` is not the absence of a theme: it is the game's own drawn theme. */
+export type Theme = 'padrao' | 'hc3' | 'hc45' | 'hc7';
+/** The COLOUR CORRECTION axis. `tricro` = trichromatic vision, and it is a name, not an absence. */
+export type Correction = 'tricro' | 'protan' | 'deuter' | 'tritan';
+/** The simulation, which is NOT an axis. `null` = none running. */
+export type Simulation = null | 'sim-protan' | 'sim-deuter' | 'sim-tritan' | 'lv-blur' | 'lv-haze' | 'lv-tunnel' | 'lv-macular' | 'lv-diabetic' | 'blind';
+/** The visual state of ONE player. Replaces the single `p.viz` string. */
+export interface VisualState {
+    readonly tema: Theme;
+    readonly correcao: Correction;
+    readonly simulacao: Simulation;
+}

package/dist-pkg/core/visual-state.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// core/visual-state — the SHAPE of a child's visual state: the two axes and the simulation that is not one (ADR-0076).
+//
+// Types only, in core because `core/entity` holds a player's state and may not import upward (ADR-0173, issue #167);
+// `render/viz-axes` keeps the same names and the functions that apply them.
+export {};

package/dist-pkg/educational/activities-registry.d.ts

@@ -22,7 +22,7 @@ export interface ActivityDef {
 export declare const DEFAULT_ACTIVITY_ID = "ludico";
 /** True when `id` names a real catalog entry. */
 export declare function isValidActivityId(id: string): boolean;
-/** Same check, spelled as the game.js call sites read it (`ACTIVITIES[id]` truthiness). */
+/** Same check, under the name `game-platformer`'s title menu (`ui/activities-menu`) calls it by. */
 export declare function hasActivity(id: string): boolean;
 /** The activity definition for `id`, or `undefined` if unknown (mirrors `ACTIVITIES[id]`). */
 export declare function getActivity(id: string): ActivityDef | undefined;

package/dist-pkg/educational/activities-registry.js

@@ -2,7 +2,7 @@
 // educational/activities-registry — the ACTIVITIES catalog: every playable activity's id → metadata
 // (category, display name, sub-label, description, fraction denominators, "pick numbers" flag). This module
 // owns only the CATALOG + id validation — it does NOT hold the current selection (that stays `activity` +
-// `setActivityValue` in core/state.ts, per ADR/plano-modularizacao-mapa).
+// `setActivityValue` in core/state.ts, per ADR/plan-modularization-map).
 //
 // ============================ POR QUE ISTO NÃO MORA EM `game/` (ADR-0032) ============================
 // Isto é CURRÍCULO, não jogo. `alf1..alf5` são as hipóteses da psicogênese de Ferreiro; `mat1..mat6` e as
@@ -25,13 +25,14 @@
 //     independe de língua". "Tabuada", "Divisão" e "Soma e subtração com meios" nomeiam operações que
 //     existem iguais em qualquer língua, e o lúdico ("Coletar 10 moedas") nem currículo é.
 //
-// MECANICAMENTE: quem traduz declara `nomeKey`/`dKey`; quem não traduz não declara. Este módulo continua sem
-// importar NADA — guarda a CHAVE, e quem resolve é o ponto de exibição (`nomeDaAtividade` em
-// ui/activities-menu), pelo mesmo motivo de `TOUCH_ACT_LABELS` e `PAD_GLYPH_SPOKEN`: uma `const` de módulo é
-// avaliada uma vez no import, e texto já resolvido congelaria o idioma no boot.
+// MECHANICALLY: an activity that translates declares `nomeKey`/`dKey`; one that does not, declares neither. This
+// module still imports NOTHING — it keeps the KEY, and the display point resolves it (`nomeDaAtividade` in the title
+// menu, `ui/activities-menu`, which left for `game-platformer` with ADR-0174), for the same reason as
+// `TOUCH_ACT_LABELS` and `PAD_GLYPH_SPOKEN`: a module `const` is evaluated once at import, and text already resolved
+// would freeze the boot language.
 //
-// O gate é `tests/atividades-matematica-traduzem.node.test.js`, e ele vigia os DOIS lados: atividade
-// traduzível sem chave reprova, e atividade de alfabetização COM chave reprova também.
+// The gate went with the menu: `game-platformer`'s `tests/atividades-matematica-traduzem.node.test.js`, which watches
+// BOTH sides — a translatable activity without a key fails, and a literacy activity WITH a key fails too.
 const ACTIVITIES_DATA = [
     ['ludico', { cat: 'ludico', nome: 'Coletar 10 moedas', nomeKey: 'act.ludico.nome' }],
     ['alf1', { cat: 'alf', nome: 'Descobrindo palavras', sub: 'BABA • BOLA • BEBE', d: 'Elaborado para ajudar a superar as hipóteses pré-silábicas.' }],
@@ -60,7 +61,7 @@ export const DEFAULT_ACTIVITY_ID = 'ludico';
 export function isValidActivityId(id) {
     return ACTIVITIES.has(id);
 }
-/** Same check, spelled as the game.js call sites read it (`ACTIVITIES[id]` truthiness). */
+/** Same check, under the name `game-platformer`'s title menu (`ui/activities-menu`) calls it by. */
 export function hasActivity(id) {
     return isValidActivityId(id);
 }

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

@@ -2,23 +2,23 @@
 /** 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';
+export type Band = '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;
+export type Reason = 'acertos-de-primeira' | 'quatro-seguidas' | 'resolvidas-no-piso' | 'dentro-da-zona' | 'janela-incompleta';
+export interface Verdict {
+    faixa: Band;
+    motivo: Reason;
     /** −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;
+export declare const WINDOW = 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;
+export declare const LEVEL_UP_TARGET = 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;
+export declare const MISSES_IN_A_ROW_THAT_DROP = 4;
 /**
  * O piso de chute de um tipo de questão: a fração de questões que a sorte pura resolve.
  *
@@ -30,14 +30,14 @@ export declare const FALHAS_SEGUIDAS_QUE_DESCEM = 4;
  * 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;
+export declare function guessFloor(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;
+export declare function resultadoDaQuestao(rightOnAttempt: 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;
 /**
@@ -62,4 +62,4 @@ export declare function falhasSeguidas(historico: readonly ResultadoDaQuestao[])
  * «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;
+export declare function bandOf(historico: readonly ResultadoDaQuestao[], piso: number, windowSize?: number): Verdict;

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

@@ -32,11 +32,11 @@
 //
 // 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;
+export const WINDOW = 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;
+export const LEVEL_UP_TARGET = 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;
+export const MISSES_IN_A_ROW_THAT_DROP = 4;
 /**
  * O piso de chute de um tipo de questão: a fração de questões que a sorte pura resolve.
  *
@@ -48,16 +48,16 @@ export const FALHAS_SEGUIDAS_QUE_DESCEM = 4;
  * 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) {
+export function guessFloor(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;
+    let chanceOfMissingAll = 1;
     for (let i = 0; i < t; i++)
-        falhaTudo *= (alternativas - 1 - i) / (alternativas - i);
-    return 1 - falhaTudo;
+        chanceOfMissingAll *= (alternativas - 1 - i) / (alternativas - i);
+    return 1 - chanceOfMissingAll;
 }
 /**
  * As tentativas de UMA questão colapsam num resultado.
@@ -65,10 +65,10 @@ export function pisoDeChute(alternativas, tentativas) {
  * `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))
+export function resultadoDaQuestao(rightOnAttempt) {
+    if (rightOnAttempt === null || !Number.isFinite(rightOnAttempt))
         return 'falhou';
-    return acertouNaTentativa <= 1 ? 'primeira' : 'mediada';
+    return rightOnAttempt <= 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) {
@@ -99,17 +99,17 @@ export function falhasSeguidas(historico) {
  * «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) {
+export function bandOf(historico, piso, windowSize = WINDOW) {
+    if (falhasSeguidas(historico) >= MISSES_IN_A_ROW_THAT_DROP) {
         return { faixa: 'frustracao', motivo: 'quatro-seguidas', efeito: -1 };
     }
-    if (historico.length < janela) {
+    if (historico.length < windowSize) {
         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)
+    const ultimas = historico.slice(-windowSize);
+    const dePrimeira = ultimas.filter((r) => r === 'primeira').length / windowSize;
+    const resolvidas = ultimas.filter((r) => r !== 'falhou').length / windowSize;
+    if (dePrimeira >= LEVEL_UP_TARGET)
         return { faixa: 'proficiente', motivo: 'acertos-de-primeira', efeito: 1 };
     if (resolvidas <= piso)
         return { faixa: 'frustracao', motivo: 'resolvidas-no-piso', efeito: -1 };

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

@@ -16,38 +16,38 @@ export type Segmento = 'azul' | 'verde' | 'vermelho';
  * `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';
+export type BarColour = 'nenhuma' | 'laranja' | 'roxa';
 /**
- * O VEREDICTO, visto daqui: a fatia mínima do que o `faixaDe` devolve.
+ * O VEREDICTO, visto daqui: a fatia mínima do que o `bandOf` 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 {
+export interface ReadVerdict {
     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
+ * Dez, e tem de ser a mesma `WINDOW` 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;
+export declare const BAR_SEGMENTS = 10;
 /** Uma barra pronta a desenhar. Tudo aqui é derivado; não há nada para mutar. */
-export interface Barra {
+export interface Bar {
     /** 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
+    /** Os segmentos, do mais ANTIGO para o mais novo, no máximo `BAR_SEGMENTS`. 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;
+    readonly cor: BarColour;
     /** O veredicto que produziu a cor, tal como entrou. */
-    readonly veredicto: VeredictoLido;
+    readonly veredicto: ReadVerdict;
 }
 /**
  * Um resultado de questão vira uma cor. É a tradução inteira, e é 1 para 1 de propósito.
@@ -59,7 +59,7 @@ export interface Barra {
  */
 export declare function corDoSegmento(r: Resultado): Segmento;
 /** O que se sabe além do histórico e do veredicto. */
-export interface Contexto {
+export interface Context {
     /**
      * ⚠️ 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
@@ -80,7 +80,7 @@ export interface Contexto {
  * 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;
+export declare function barOf(skill: string, historico: readonly Resultado[], veredicto: ReadVerdict, ctx?: Context): Bar;
 /**
  * O histórico DEPOIS de a barra ter sinalizado — porque «sobe» leva consigo «e a contagem zera».
  *
@@ -93,4 +93,4 @@ export declare function barraDe(skill: string, historico: readonly Resultado[],
  *
  * 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[];
+export declare function afterSignalling(historico: readonly Resultado[], barra: Bar): readonly Resultado[];

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

@@ -4,10 +4,10 @@
 // ========================= 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:
+// que já existe no `bandOf` 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`;
+//   · «oito azuis sobem»            é o `LEVEL_UP_TARGET = 0.8` — 8 de primeira em 10;
+//   · «quatro vermelhos seguidos»   é o `MISSES_IN_A_ROW_THAT_DROP = 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.»
@@ -19,7 +19,7 @@
 //
 // ⚠️ 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
+// `the-inclusionist-knowledge-tree` do ADR-0058). Este módulo não tem, portanto, como chamar o `bandOf`; 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.
@@ -39,11 +39,11 @@
 /**
  * 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
+ * Dez, e tem de ser a mesma `WINDOW` 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;
+export const BAR_SEGMENTS = 10;
 /**
  * Um resultado de questão vira uma cor. É a tradução inteira, e é 1 para 1 de propósito.
  *
@@ -63,8 +63,8 @@ export function corDoSegmento(r) {
  * 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);
+export function barOf(skill, historico, veredicto, ctx = {}) {
+    const segmentos = historico.slice(-BAR_SEGMENTS).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'
@@ -84,6 +84,6 @@ export function barraDe(skill, historico, veredicto, ctx = {}) {
  *
  * 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) {
+export function afterSignalling(historico, barra) {
     return barra.cor === 'nenhuma' ? historico : [];
 }