@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/input/transport-in-use.d.ts

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * The devices a child plays through. Closed: a new transport has to decide its rule here.
+ *
+ * The values stay Portuguese because they are stored — `latch-scope.latchKey` puts the transport name in the
+ * key — and renaming a stored value loses what the child saved.
+ */
+export type TransportName = 'teclado' | 'gamepad' | 'toque' | 'olhos' | 'rosto' | 'gestos' | 'fala';
+/**
+ * THE UNION AS A VALUE, because there is one place where it has to be checked at runtime.
+ *
+ * ⚠️ IT EXISTS BECAUSE OF A BOUNDARY, and that is the only reason that justifies it: `input/synthetic-source`
+ * reads the transport from an EXPANDO hung on a `KeyboardEvent` — an object this code did not build and that
+ * any script on the page can build. A value crossing that boundary is not a `TransportName` because TypeScript
+ * says so; it is a `string` until someone checks it. Without the list, `'olho'` would enter the origin map as a
+ * phantom transport, and nothing would say so.
+ *
+ * 📌 This is not the list-beside-the-union defect this repository has already undone three times (`RM_KEYS`,
+ * the reduced-motion labels, the storage keys), because the guard below belongs to the COMPILER: the two cannot
+ * diverge. A copy that cannot diverge is a projection, not a second source.
+ */
+export declare const TRANSPORT_NAMES: readonly ["teclado", "gamepad", "toque", "olhos", "rosto", "gestos", "fala"];
+/**
+ * Is this thing that came from outside really a transport?
+ *
+ * ⚠️ The question is not about security — every script on this page is ours, and whoever wanted to lie would
+ * use a VALID value. It is about correctness: it keeps a wrong or missing stamp from becoming a silent entry in
+ * `keySource`, the structure the whole latch depends on.
+ */
+export declare function isTransportName(v: unknown): v is TransportName;
+/**
+ * THE FOUR THAT REQUIRE EXPLICIT ENABLING and, once enabled, rule over all the others (rule 4).
+ *
+ * ⚠️ It is the same list as `ONE_COMMAND_AT_A_TIME` in `input/latch-scope`, and the match is no accident: these
+ * are the transports that send one command at a time. What ADR-0109 added — that enabling them turns latching on
+ * for the rest — is the model of `latchNow`, which ADR-0113 superseded; since ADR-0249 their own latch starts as
+ * the game's `holdsKeys()` and the child may change it.
+ */
+export declare const NEED_ENABLING: ReadonlySet<TransportName>;
+/** The transport that turns latching on by itself, with no priority involved (rule 2). */
+export declare const LATCH_OF_THEIR_OWN: ReadonlySet<TransportName>;
+export interface InputState {
+    /** Which device this player is using NOW. */
+    readonly inUse: TransportName;
+    /**
+     * Was the camera/microphone enabled? ⚠️ Once `true`, it NEVER goes back to `false` through an edge — only an
+     * explicit decision turns it off, and ADR-0109 §4 says the child does not own that decision. See
+     * `disableAssisted`.
+     */
+    readonly assistedOn: boolean;
+}
+/**
+ * THE INITIAL STATE: keyboard, without latching.
+ *
+ * ⚠️ Rule 1 says "pad AND keyboard, both without latching", and that is why the default can name just one
+ * without lying: between the two, the answer to the only question this module asks — is latching on? — is the
+ * SAME. `inUse` only starts telling them apart when someone wants to SHOW the current device, which is another
+ * question, and ADR-0109 explicitly leaves it undecided.
+ */
+export declare const DEFAULT_INPUT_STATE: InputState;
+/**
+ * IS LATCHING ON NOW? — ⚠️ **DO NOT ASK THIS FUNCTION.** See the paragraph below.
+ *
+ * ⚠️ The assisted priority comes FIRST, and the order is the whole of rule 4: while it is on, no other device
+ * turns latching off — not even the keyboard, which otherwise would. Swapping these two lines is the defect that
+ * would lock a child out of their own game, and it is silent.
+ *
+ * @deprecated 🔴 **THIS FUNCTION IMPLEMENTS THE MODEL ADR-0113 SUPERSEDED**, and stays exported because it is
+ * published surface (`./input/*.js`) and because the record has historical value — not because it is the answer.
+ *
+ * ADR-0109 decided latching **by device alone**: assisted on → yes; touch → yes; everything else → no. ADR-0113
+ * withdrew that clause, with the Dev's reason: latching is a **caps lock stored with the controller's mapping**,
+ * and the value the child saved counts.
+ *
+ * 🔴 THE DIVERGENCE HAS A CONCRETE CHILD, and it is the one who prompted the record: someone with a motor
+ * difficulty who plays on the KEYBOARD and saved latching on. This function returns `false` for them —
+ * `teclado` is not in `LATCH_OF_THEIR_OWN` — and that is exactly the control they would lose.
+ * `latch-scope.latchOf` returns `true`, because it reads what they saved.
+ *
+ * ⚠️ AND THE TOUCH CLAUSE FELL TOO: under ADR-0113 touch is a transport like the others — its value is a choice
+ * and is stored. Eyes, face, gestures and speech differ only in where their DEFAULT comes from — the game's
+ * `holdsKeys()` (ADR-0249, `latch-scope.latchDefaultFromGame`) — and their value is a choice too.
+ *
+ * **The right answer is `latch-scope.latchOf(inputState.inUse, reading)`.** The role left to this module is
+ * what its name says: WHICH transport is in use — which is what feeds that first argument.
+ * `tests/latching-per-transport.node.test.js` asserts this function still has no consumer.
+ */
+export declare function latchNow(inputState: InputState): boolean;
+/**
+ * AN EDGE ARRIVED, with its origin. Returns the NEW state.
+ *
+ * ⚠️ An edge from an assisted transport does NOT enable it. Enabling is an explicit act (rule 4: they "have to
+ * be enabled"), and letting an edge do it would mean a webcam false positive — a shadow, a second face passing
+ * by — locked latching on for everyone without anyone asking.
+ */
+export declare function afterEdge(inputState: InputState, origin: TransportName): InputState;
+/** The child (or whoever is with them) enabled the camera/microphone. From here on, latching is law. */
+export declare function enableAssisted(inputState: InputState): InputState;
+/**
+ * DISABLE the assisted transports. It exists, and ADR-0109 says whose it is: NOT the child's during a match.
+ *
+ * ⚠️ It stays exported because turning the camera off has to be possible somewhere — switching users, closing
+ * the game, an adult reconfiguring. What §4 forbids is offering it as a button beside the game. A function that
+ * exists and is not offered differs from a function that does not exist: the first says where the decision
+ * lives.
+ */
+export declare function disableAssisted(inputState: InputState): InputState;

package/dist-pkg/input/transport-in-use.js

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// input/transport-in-use — THE LATCH FOLLOWS THE DEVICE IN USE (ADR-0109), the pure half.
+//
+// ========================= WHAT THIS MODULE IS =========================
+// The automaton of ADR-0109 §1's four rules, with no DOM, no storage and no events. It takes EDGES with their
+// origin and returns state; whoever asks "is latching on now?" asks the state.
+//
+//   1. By default, pad and keyboard, both WITHOUT latching.
+//   2. A mouse click or a touch on the screen → on-screen controls WITH latching.
+//   3. Pressing a key returns the keyboard WITHOUT latching; using the pad does the same.
+//   4. Camera and microphone have to be enabled; once enabled, they turn latching on for ALL the other
+//      controls, with NO way to turn it off. They take priority.
+//
+// ⚠️ WHY THIS IS AN AUTOMATON AND NOT A STORED VALUE — and it is what ADR-0109 supersedes of ADR-0104 §C.
+// Latching was a CHOICE stored per transport, and issue #114 measured that its wiring could not be written: the
+// edge's origin is erased at the door (`input/state.keys` is a `Set<string>` of CODES, and touch and the webcam
+// write into it). The Dev decided the BEHAVIOUR, and the behaviour picks the mechanism.
+//
+// ⚠️ AND RULE 3 IS WHY IT TAKES TWO THINGS, not one. "Pressing a key returns the keyboard without latching" is
+// TWO facts: an EVENT whose origin must be known, and a MODE that persists until the next switch. An edge keeps
+// no state; a stored mode does not detect its own switch. Neither half expresses the rule; together they do.
+// This file is the second half — the MODE.
+//
+// 📌 The Dev's image, kept because it says the thing: it is a CAPS LOCK ON A KEYBOARD WITH MEMORY. A mode and
+// not a momentary state; remembered per device; switching devices does not erase what the other remembers.
+/**
+ * THE UNION AS A VALUE, because there is one place where it has to be checked at runtime.
+ *
+ * ⚠️ IT EXISTS BECAUSE OF A BOUNDARY, and that is the only reason that justifies it: `input/synthetic-source`
+ * reads the transport from an EXPANDO hung on a `KeyboardEvent` — an object this code did not build and that
+ * any script on the page can build. A value crossing that boundary is not a `TransportName` because TypeScript
+ * says so; it is a `string` until someone checks it. Without the list, `'olho'` would enter the origin map as a
+ * phantom transport, and nothing would say so.
+ *
+ * 📌 This is not the list-beside-the-union defect this repository has already undone three times (`RM_KEYS`,
+ * the reduced-motion labels, the storage keys), because the guard below belongs to the COMPILER: the two cannot
+ * diverge. A copy that cannot diverge is a projection, not a second source.
+ */
+export const TRANSPORT_NAMES = ['teclado', 'gamepad', 'toque', 'olhos', 'rosto', 'gestos', 'fala'];
+const _COVERS_THE_TRANSPORTS = true;
+void _COVERS_THE_TRANSPORTS;
+/**
+ * Is this thing that came from outside really a transport?
+ *
+ * ⚠️ The question is not about security — every script on this page is ours, and whoever wanted to lie would
+ * use a VALID value. It is about correctness: it keeps a wrong or missing stamp from becoming a silent entry in
+ * `keySource`, the structure the whole latch depends on.
+ */
+export function isTransportName(v) {
+    return typeof v === 'string' && TRANSPORT_NAMES.includes(v);
+}
+/**
+ * THE FOUR THAT REQUIRE EXPLICIT ENABLING and, once enabled, rule over all the others (rule 4).
+ *
+ * ⚠️ It is the same list as `ONE_COMMAND_AT_A_TIME` in `input/latch-scope`, and the match is no accident: these
+ * are the transports that send one command at a time. What ADR-0109 added — that enabling them turns latching on
+ * for the rest — is the model of `latchNow`, which ADR-0113 superseded; since ADR-0249 their own latch starts as
+ * the game's `holdsKeys()` and the child may change it.
+ */
+export const NEED_ENABLING = new Set(['olhos', 'rosto', 'gestos', 'fala']);
+/** The transport that turns latching on by itself, with no priority involved (rule 2). */
+export const LATCH_OF_THEIR_OWN = new Set(['toque']);
+/**
+ * THE INITIAL STATE: keyboard, without latching.
+ *
+ * ⚠️ Rule 1 says "pad AND keyboard, both without latching", and that is why the default can name just one
+ * without lying: between the two, the answer to the only question this module asks — is latching on? — is the
+ * SAME. `inUse` only starts telling them apart when someone wants to SHOW the current device, which is another
+ * question, and ADR-0109 explicitly leaves it undecided.
+ */
+export const DEFAULT_INPUT_STATE = Object.freeze({ inUse: 'teclado', assistedOn: false });
+/**
+ * IS LATCHING ON NOW? — ⚠️ **DO NOT ASK THIS FUNCTION.** See the paragraph below.
+ *
+ * ⚠️ The assisted priority comes FIRST, and the order is the whole of rule 4: while it is on, no other device
+ * turns latching off — not even the keyboard, which otherwise would. Swapping these two lines is the defect that
+ * would lock a child out of their own game, and it is silent.
+ *
+ * @deprecated 🔴 **THIS FUNCTION IMPLEMENTS THE MODEL ADR-0113 SUPERSEDED**, and stays exported because it is
+ * published surface (`./input/*.js`) and because the record has historical value — not because it is the answer.
+ *
+ * ADR-0109 decided latching **by device alone**: assisted on → yes; touch → yes; everything else → no. ADR-0113
+ * withdrew that clause, with the Dev's reason: latching is a **caps lock stored with the controller's mapping**,
+ * and the value the child saved counts.
+ *
+ * 🔴 THE DIVERGENCE HAS A CONCRETE CHILD, and it is the one who prompted the record: someone with a motor
+ * difficulty who plays on the KEYBOARD and saved latching on. This function returns `false` for them —
+ * `teclado` is not in `LATCH_OF_THEIR_OWN` — and that is exactly the control they would lose.
+ * `latch-scope.latchOf` returns `true`, because it reads what they saved.
+ *
+ * ⚠️ AND THE TOUCH CLAUSE FELL TOO: under ADR-0113 touch is a transport like the others — its value is a choice
+ * and is stored. Eyes, face, gestures and speech differ only in where their DEFAULT comes from — the game's
+ * `holdsKeys()` (ADR-0249, `latch-scope.latchDefaultFromGame`) — and their value is a choice too.
+ *
+ * **The right answer is `latch-scope.latchOf(inputState.inUse, reading)`.** The role left to this module is
+ * what its name says: WHICH transport is in use — which is what feeds that first argument.
+ * `tests/latching-per-transport.node.test.js` asserts this function still has no consumer.
+ */
+export function latchNow(inputState) {
+    if (inputState.assistedOn)
+        return true;
+    return LATCH_OF_THEIR_OWN.has(inputState.inUse);
+}
+/**
+ * AN EDGE ARRIVED, with its origin. Returns the NEW state.
+ *
+ * ⚠️ An edge from an assisted transport does NOT enable it. Enabling is an explicit act (rule 4: they "have to
+ * be enabled"), and letting an edge do it would mean a webcam false positive — a shadow, a second face passing
+ * by — locked latching on for everyone without anyone asking.
+ */
+export function afterEdge(inputState, origin) {
+    if (inputState.inUse === origin)
+        return inputState; // no change: returns the SAME object, not a copy
+    return { inUse: origin, assistedOn: inputState.assistedOn };
+}
+/** The child (or whoever is with them) enabled the camera/microphone. From here on, latching is law. */
+export function enableAssisted(inputState) {
+    return inputState.assistedOn ? inputState : { inUse: inputState.inUse, assistedOn: true };
+}
+/**
+ * DISABLE the assisted transports. It exists, and ADR-0109 says whose it is: NOT the child's during a match.
+ *
+ * ⚠️ It stays exported because turning the camera off has to be possible somewhere — switching users, closing
+ * the game, an adult reconfiguring. What §4 forbids is offering it as a button beside the game. A function that
+ * exists and is not offered differs from a function that does not exist: the first says where the decision
+ * lives.
+ */
+export function disableAssisted(inputState) {
+    return inputState.assistedOn ? { inUse: inputState.inUse, assistedOn: false } : inputState;
+}

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

@@ -1,176 +1,149 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import { type Action } from '../core/actions.js';
 /**
- * QUANTOS LUGARES CADA TRANSPORTE REAL TEM, e de onde cada número vem. Estavam medidos e viviam só no teste;
- * um número que só existe num teste não chega a criança nenhuma.
+ * HOW MANY PLACES EACH REAL TRANSPORT HAS, and where each number comes from. They were measured and lived only in
+ * the test; a number that exists only in a test reaches no child.
  *
- *   · `gamepad: 17` — a Gamepad API «standard» declara dezassete botões. Não é escolha nossa.
- *   · `toque: 9` — `TOUCH_DEFAULT` (input/devices) nomeia nove slots, e são nove desde sempre.
- *   · `teclado: ACTIONS.length` — ⚠️ e este é o que precisou de decisão.
+ *   · `gamepad: 17` — the Gamepad API's "standard" mapping declares seventeen buttons. Not our choice.
+ *   · `toque: 13` — `TOUCH_DEFAULT` (input/devices) names thirteen slots: the nine plus ADR-0160's four shoulders.
+ *   · `teclado: ACTIONS.length` — ⚠️ and this is the one that needed a decision.
  *
- * ⚠️ O NÚMERO DO TECLADO NÃO É O NÚMERO DE TECLAS, e também não é o número de ligações do esquema atual. Não
- * é o de teclas porque cem teclas não são cem lugares que uma criança encontra e lembra; não é o do esquema
- * porque o esquema cresce, e o limite passaria a ser a configuração e não o aparelho.
+ * ⚠️ THE KEYBOARD'S NUMBER IS NOT THE NUMBER OF KEYS, nor the number of bindings in the current scheme. Not the keys,
+ * because a hundred keys are not a hundred places a child finds and remembers; not the scheme, because the scheme
+ * grows, and the limit would become the configuration instead of the device.
  *
- * É `ACTIONS.length` porque o que limita um teclado, na prática deste produto, é O VOCABULÁRIO QUE A ENGINE
- * SABE NOMEAR: um transporte que cobre todas as posições que existem não tem como ser o curto. Derivado e não
- * escrito à mão de propósito — quando o vocabulário crescer (foi de nove para catorze em 2026-09-06), este
- * número cresce com ele e nunca passa a mentir.
+ * It is `ACTIONS.length` because what limits a keyboard, in this product's practice, is THE VOCABULARY THE ENGINE
+ * CAN NAME: a transport that covers every position that exists cannot be the short one. Derived and not written by
+ * hand on purpose — when the vocabulary grows (it went from nine to fourteen), this number grows with it and never
+ * starts lying.
  */
-export declare const LUGARES: Readonly<{
+export declare const SLOTS: Readonly<{
     gamepad: 17;
-    toque: 9;
+    toque: 13;
     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 {
+/** How each transport is found to be here NOW. Injected: none of these questions is pure. */
+export interface Availability {
     gamepad: () => boolean;
-    toque: () => boolean;
-    teclado: () => boolean;
+    touch: () => boolean;
+    keyboard: () => boolean;
     /**
-     * Há um RATO aqui? (ADR-0112)
+     * Is there a MOUSE here? (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.
+     * ⚠️ IT IS NOT A TRANSPORT OF ITS OWN, which is why it enters as a question and not as a fourth line of
+     * `defaultTransports`: a mouse alone does not carry the fourteen positions. It is the CONTINUOUS SIGNAL beside the
+     * keyboard — the Dev's sentence, «no caso do teclado, o sinal contínuo passa a ser o mouse» —, and it is what gives
+     * a foundation to ADR-0074's transports 8 and 9, which that record declared as having none.
      */
-    rato: () => boolean;
+    mouse: () => boolean;
 }
 /**
- * Os três transportes que esta engine sabe oferecer hoje.
+ * The three transports this engine knows how to offer today.
  *
- * ⚠️ A DETECÇÃO DO TECLADO É IMPRECISA E ISSO É ACEITÁVEL — mas só porque a tela que consome isto INFORMA em
- * vez de RECUSAR. Não há API que diga «há um teclado físico ligado»; o que o projeto já usa para a mesma
- * pergunta é `pointer:coarse && hover:none` (o `isCoarsePointer` do `game/session`), e um tablet COM teclado
- * responde «toque» a isso. Se a tela barrasse, esse tablet levaria uma recusa falsa num jogo que ele joga.
- * Como ela apenas diz o que falta e deixa continuar, o erro custa uma frase a mais e nunca uma porta fechada.
+ * ⚠️ THE KEYBOARD DETECTION IS IMPRECISE AND THAT IS ACCEPTABLE — but only because the screen that consumes this
+ * INFORMS instead of REFUSING. No API says "a physical keyboard is plugged in"; what the root asks is
+ * `pointer:coarse && hover:none`, and a tablet WITH a keyboard answers "touch" to that. If the screen blocked, that
+ * tablet would get a false refusal in a game it plays. Since it only says what is missing and lets the child go on,
+ * the error costs one extra sentence and never a closed door.
  */
-export declare function transportesPadrao(d: Disponibilidade): Transport[];
-/** Um transporte, como ele se declara. Zero significado: quantos lugares, e se está aqui agora. */
+export declare function defaultTransports(d: Availability): Transport[];
+/** A transport, as it declares itself. Zero meaning: how many places, and whether it is here now. */
 export interface Transport {
-    /** Identificador estável, para preferências salvas. Nunca chega a uma pessoa. */
+    /** A stable identifier, for saved preferences. Never reaches a person. */
     readonly id: string;
-    /** Quantos lugares ATRIBUÍVEIS. É o número que a aritmética da garantia usa. */
+    /** How many ASSIGNABLE places. It is the number the guarantee's arithmetic uses. */
     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.
+     * How many positions it HOLDS AT ONCE, when that is known. A different axis from `slots`: the on-screen control
+     * has thirteen places and holds two.
      *
-     * ⚠️ 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.
+     * ⚠️ ABSENT MEANS "NO KNOWN CEILING", not "holds one". Today only touch declares a number (`HOLDS_TOUCH`), because
+     * only about it is there a decision — see the note there. Reading the absence as zero would make every transport
+     * without a number suddenly fail, which is the opposite of what an optional field should do.
      */
     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.
+     * Is it available ON THIS device, NOW? A function and not a value: a pad gets plugged in mid-match, and a touch
+     * screen appears when the child turns the tablet.
      */
     readonly available: () => boolean;
     /**
-     * Este transporte oferece um PONTEIRO — posição contínua (ADR-0112)?
+     * Does this transport offer a POINTER — a continuous position (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.
+     * ⚠️ A FUNCTION AND NOT A BOOLEAN, for the same reason written on `available` above: a mouse gets plugged in
+     * mid-match, just like a pad. A fixed value here would answer with the state at boot.
      *
-     * ⚠️ 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.
+     * ⚠️ ABSENT MEANS "DOES NOT OFFER", and here — unlike `holds` — reading the absence that way is right: the pointer
+     * is a capability one DECLARES, and a transport that does not declare it does not have it. `holds` is the opposite
+     * because there the absence is "no known ceiling", and reading it as zero would fail everyone.
      */
-    readonly aponta?: () => boolean;
+    readonly points?: () => 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;
+/** Does this transport carry this set of actions? Arithmetic, as ADR-0079 §3 describes it. */
+export declare function carries(t: Transport, actions: readonly Action[]): boolean;
 /**
- * Os transportes DISPONÍVEIS que carregam este conjunto.
+ * The AVAILABLE transports that carry this set.
  *
- * ⚠️ Disponibilidade e capacidade são conferidas nesta ordem de propósito: um transporte que caberia mas não
- * está ligado não é resposta para uma criança que está à frente do aparelho agora.
+ * ⚠️ Availability and capacity are checked in this order on purpose: a transport that would fit but is not plugged
+ * in is no answer for a child sitting at the device now.
  */
-export declare function carriedBy(lista: readonly Transport[], acoes: readonly Action[]): Transport[];
+export declare function carriedBy(list: readonly Transport[], actions: readonly Action[]): Transport[];
 /**
- * A garantia do ADR-0079 §3, como pergunta de sim ou não.
+ * ADR-0079 §3's guarantee, as a yes-or-no question.
  *
- * ⚠️ CONJUNTO VAZIO DE AÇÕES DEVOLVE `false`, e não `true` por vacuidade. Um jogo que não declara ação
- * nenhuma não é um jogo que qualquer transporte serve — é um jogo que ninguém consegue jogar, e
- * `actionSetProblems` já o reprova. Devolver `true` aqui esconderia esse defeito atrás desta função.
+ * ⚠️ AN EMPTY SET OF ACTIONS RETURNS `false`, not a vacuous `true`. A game that declares no action is not a game any
+ * transport serves — it is a game nobody can play, and `actionSetProblems` already fails it. Returning `true` here
+ * would hide that defect behind this function.
  */
-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 {
+export declare function reachable(list: readonly Transport[], actions: readonly Action[]): boolean;
+/** What the selection screen has to say, and what it needs to know to say it. */
+export interface Reach {
     /**
-     * Verdadeiro = pelo menos um transporte disponível carrega o conjunto **e segura quantas o jogo pede ao
-     * mesmo tempo**.
+     * True = at least one available transport carries the set **and holds as many as the game asks at once**.
      *
-     * ⚠️ 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.
+     * ⚠️ THE SECOND HALF OF THIS SENTENCE (ADR-0104) fixed a blind spot nobody had named: the platformer declared nine
+     * actions, touch had nine places, `ok` said yes — and running, walking and jumping at once are three fingers a
+     * two-touch phone does not have. `ok` claimed "playable" about a game that was not, which is the worst thing this
+     * field could do.
      */
     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. */
-    readonly curtos: readonly {
+    /** How many actions the game asks for. */
+    readonly asked: number;
+    /** How many it asks to HOLD at once — the second axis, and what `holdsAtOnce` declares. */
+    readonly holdsAsked: number;
+    /** Those that would serve if they were plugged in — the actionable information: "plug in a pad". */
+    readonly wouldServeIfOn: readonly string[];
+    /** The available ones that DO NOT fit, with how many places they have. So the sentence can say the number. */
+    readonly short: readonly {
         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.
+     * The available ones that REACH the actions but do not hold as many as the game asks at once, with their ceiling.
      *
-     * É 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ê.
+     * It is the third sentence of #112's card, and it needs both numbers — the on-screen control holds two buttons at
+     * a time and this game asks for three. Without the ceiling, the sentence would say something is missing without
+     * saying what.
      */
-    readonly naoSeguram: readonly {
+    readonly cannotHold: readonly {
         readonly id: string;
         readonly holds: number;
     }[];
-    /** Este jogo declarou que precisa de PONTEIRO? (ADR-0112) */
-    readonly pedePonteiro: boolean;
+    /** Did this game declare that it needs a POINTER? (ADR-0112) */
+    readonly needsPointer: boolean;
     /**
-     * Os disponíveis que chegam às acções E seguram quantas o jogo pede, e falham SÓ por não apontarem.
+     * The available ones that reach the actions AND hold as many as the game asks, and fail ONLY by not pointing.
      *
-     * ⚠️ 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.
+     * ⚠️ ONLY THOSE THAT FAIL JUST ON THIS, by the same rule `cannotHold` follows: a transport on two lists would make
+     * #112's card state two problems where there is one, and the child would read two reasons for the same refusal.
+     * The list is empty when the game does not ask for a pointer — not "all of them", because none failed.
      */
-    readonly naoApontam: readonly string[];
+    readonly cannotPoint: readonly string[];
 }
 /**
- * Mede o alcance ANTES de a criança começar.
+ * Measures the reach BEFORE the child starts.
  *
- * ⚠️ 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.
+ * ⚠️ It returns DATA and not text. The sentence belongs to the interface and has to go through `t()`; returning
+ * prose from here would put a language in a module that has none.
  */
-export declare function alcance(lista: readonly Transport[], acoes: readonly Action[], seguraPedidas: number, pedePonteiro?: boolean): Alcance;
+export declare function reach(list: readonly Transport[], actions: readonly Action[], askedHolds: number, wantsPointer?: boolean): Reach;