@the-inclusionist/engine 10.0.0 → 11.0.0

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

@@ -2,8 +2,6 @@
 import type { Translate } from '../core/i18n.js';
 import type { PlayerView } from '../core/entity.js';
 import { type EdgeFlag } from './edges.js';
-/** ui/dom.ts `$` — injected; the module never reaches `document`. */
-export type { DomQuery } from '../core/dom-query.js';
 /** What this module reads and does with a `keydown` `KeyboardEvent`. */
 export interface KeydownEventLike {
     code: string;
@@ -23,8 +21,6 @@ export interface KeydownEventLike {
 export interface KeyupEventLike {
     code: string;
 }
-/** action -> list of physical codes. */
-export type { KeyScheme } from '../core/entity.js';
 /** The six input edges keydown raises on the player (consumed and cleared by the game's physics). */
 /**
  * What this module reads (and writes) of a player — and ONLY that. DERIVED from core/entity.
@@ -48,10 +44,9 @@ export interface ControlsSnapshot {
     action1: string[];
     gameKeys: string[];
 }
-/** The title menu's navigation intent — `NavKeys` from input/edges, re-exported under the name this module's callers
- *  already use (it was a fourth structural copy under another name). */
+/** The title menu's navigation intent — `NavKeys` from input/edges, under the local name this module reads by (it was a
+ *  fourth structural copy under another name). */
 import type { NavKeys as TitleNav } from './edges.js';
-export type { NavKeys as TitleNav } from './edges.js';
 /** EVERYTHING the decision needs to know about the world, in one object, built BEFORE any effect. */
 export interface KeydownSnapshot {
     /** Is the title screen on top? (Only Player 1 picks the game; the others hear a notice.) */
@@ -161,8 +156,7 @@ export declare const EASY_SHORTCUTS: ReadonlySet<string>;
 export declare const SCREEN_DIGITS: RegExp;
 /** Pause: Escape or the MAIN Enter. `NumpadEnter` does NOT pause. */
 export declare const PAUSE_KEYS: ReadonlySet<string>;
-export { EDGE_BY_ACTION, edgeAllowed } from './edges.js';
-export type { EdgeFlag } from './edges.js';
+export { EDGE_BY_ACTION } from './edges.js';
 /** Does the key count as JUMP for anybody? P1's alias OR any player's `action2` (it is what makes "anyone can press
  *  Play again" and "anyone confirms on the title" true). */
 export declare function isJumpKey(code: string, s: KeydownSnapshot): boolean;
@@ -244,8 +238,8 @@ export interface KeydownCtx {
      * THIS EDGE IS THIS PLAYER'S, AND IT CAME FROM HERE (ADR-0113 clause 4, issue #127) — `input/state.playerEdge`.
      *
      * 🔴 A REQUIRED FIELD: without a feeder, ADR-0109's automaton answers `teclado` for everyone through
-     * `inputOf(i).inUse` — forever, with no error. Then clause 3's refusal never fires: the child who plays by webcam can
-     * turn off the latch their input depends on, and nothing says so.
+     * `inputOf(i).inUse` — forever, with no error. Then the latch is read and written under the keyboard's key for a child
+     * playing by webcam, and the game's default for her device (ADR-0249) never applies.
      *
      * ⚠️ AND IT IS HERE THAT IT COUNTS, not on the keyboard, which is already the default: a stamped synthetic event
      * (`input/synthetic-source`) is how `olhos`/`rosto`/`gestos`/`fala` become the transport in use through this module.

package/dist-pkg/input/keydown.js

@@ -82,9 +82,9 @@ export const EASY_SHORTCUTS = new Set(['ControlLeft', 'ControlRight', 'ShiftLeft
 export const SCREEN_DIGITS = /^Digit[1234]$/;
 /** Pause: Escape or the MAIN Enter. `NumpadEnter` does NOT pause. */
 export const PAUSE_KEYS = new Set(['Escape', 'Enter']);
-// The table and the Easy rule live in input/edges.ts, shared with gamepad and touch-bindings. Re-exported under the old
-// name because whoever imports from here (tests and readers) expects to find it here.
-export { EDGE_BY_ACTION, edgeAllowed } from './edges.js';
+// The table lives in input/edges.ts, shared with gamepad and touch-bindings. Re-exported under the old name because the
+// engine's tests import it from here.
+export { EDGE_BY_ACTION } from './edges.js';
 /* --- pure predicates (exported: the test imports the piece instead of repeating the expression) --- */
 /** Does the key count as JUMP for anybody? P1's alias OR any player's `action2` (it is what makes "anyone can press
  *  Play again" and "anyone confirms on the title" true). */

package/dist-pkg/input/latch-edge.d.ts

@@ -17,10 +17,18 @@ export interface LatchedEdgeOptions {
     readonly store: LatchStore;
     /** The factory default. `DEFAULTS.toggleMove`, not a hand-written `false`: there is ONE source (ADR-0029). */
     readonly byDefault?: boolean;
+    /**
+     * DOES THE MOUNTED GAME HOLD ANY KEY NOW? — `GameDeclaration.holdsKeys` (ADR-0249), the latch's default on eyes, face,
+     * gestures and speech. A FUNCTION, called at every edge: a game changes its answer between stages (ADR-0084), and the
+     * next command must follow the stage it lands in. REQUIRED, like `holdsKeys` itself: `true` latches a quiz's every word,
+     * `false` stops a platform game's «direita» after one step, so no default is safe.
+     */
+    readonly holdsKeys: () => boolean;
 }
 /**
- * RETURNS THE `playerEdge` THAT ALSO RESOLVES THE TOGGLE — to hand to `initKeydown` and `initTouchBindings` in place of
- * the raw one.
+ * RETURNS THE `playerEdge` THAT ALSO RESOLVES THE TOGGLE. The root calls it from the virtual controller's `pressedBy`, the one
+ * door every transport's press goes through (ADR-0109 rule 3); a host without that door hands it to `initKeydown`,
+ * `initTouchBindings` and `initGamepad` in place of the raw one.
  *
  * ⚠️ IT RESOLVES AGAINST `inputOf(player).inUse` AND NOT `origin`, a difference of design and not of behaviour: today the
  * edge always sets in-use to the origin, so swapping one for the other is an EQUIVALENT mutation — recorded as such in the

package/dist-pkg/input/latch-edge.js

@@ -17,8 +17,9 @@
 import { DEFAULTS } from '../core/setting-defaults.js';
 import { syncLatch } from './latch-sync.js';
 /**
- * RETURNS THE `playerEdge` THAT ALSO RESOLVES THE TOGGLE — to hand to `initKeydown` and `initTouchBindings` in place of
- * the raw one.
+ * RETURNS THE `playerEdge` THAT ALSO RESOLVES THE TOGGLE. The root calls it from the virtual controller's `pressedBy`, the one
+ * door every transport's press goes through (ADR-0109 rule 3); a host without that door hands it to `initKeydown`,
+ * `initTouchBindings` and `initGamepad` in place of the raw one.
  *
  * ⚠️ IT RESOLVES AGAINST `inputOf(player).inUse` AND NOT `origin`, a difference of design and not of behaviour: today the
  * edge always sets in-use to the origin, so swapping one for the other is an EQUIVALENT mutation — recorded as such in the
@@ -38,6 +39,6 @@ export function createLatchedEdge(getPlayers, opts) {
         // half, because there is nowhere to write it.
         const p = getPlayers()[player];
         if (p)
-            syncLatch(p, latchStore, player, inputOf(player).inUse, fallback);
+            syncLatch(p, latchStore, player, inputOf(player).inUse, { byDefault: fallback, gameHoldsKeys: opts.holdsKeys() });
     };
 }

package/dist-pkg/input/latch-scope.d.ts

@@ -1,26 +1,18 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 /**
- * The transports that emit ONE COMMAND AT A TIME, on which the toggle is always on.
+ * The transports that emit ONE COMMAND AT A TIME, on which the latch's default is the game's `holdsKeys()` (ADR-0249).
  *
  * The values are transport names, which stay Portuguese like the rest of that vocabulary (`teclado`, `toque`): they are
  * stored, and renaming a stored value loses what the child saved.
  */
 export declare const ONE_COMMAND_AT_A_TIME: ReadonlySet<string>;
 /**
- * Is the toggle always on for this transport?
+ * Does this transport's latch start where the GAME says (ADR-0249)?
  *
- * ⚠️ "Always on" and "on by default" are different things, and the difference is ADR-0104 §C's: a default can be changed,
- * and changing it here would make the control unusable. So the stored value is not even read on these transports — see
- * `latchOf`.
+ * `true` on the four one-command transports: with nothing stored for them, the latch is the game's `holdsKeys()`. The
+ * option is offered on every transport alike; this answers only where the default comes from.
  */
-export declare function latchAlwaysOn(transport: string): boolean;
-/**
- * Should the option be OFFERED for this transport?
- *
- * The opposite of `latchAlwaysOn`, with a name of its own because a different caller asks: one decides the state, the
- * other whether to draw the button. A panel that drew the button and ignored the click would be worse than not drawing it.
- */
-export declare function latchIsOptional(transport: string): boolean;
+export declare function latchDefaultFromGame(transport: string): boolean;
 /**
  * The toggle's storage key, with the transport in its name.
  *
@@ -34,11 +26,14 @@ export declare function latchKey(base: string, player: number, transport: string
 /**
  * The OLD key, per player and without a transport. Still read, never written again.
  *
- * ⚠️ IT IS INHERITED BY EVERY TRANSPORT, and the choice takes a sentence to explain. The old value was set by the child in
- * some context, and there is no way to know which — the key did not record it, which is the defect. The ways out were
- * three: lose their setting, guess a transport, or inherit for all. Inheriting for all is the only one that takes nothing
- * from whoever depends on the setting, and the leak it keeps lasts only until the child touches the setting once on each
- * device. Losing the setting would cost more, and to whoever can least afford it.
+ * ⚠️ IT IS INHERITED BY THE KEYBOARD, THE PAD AND TOUCH, and the choice takes a sentence to explain. The old value was set
+ * by the child in some context, and there is no way to know which — the key did not record it, which is the defect. The
+ * ways out were three: lose their setting, guess a transport, or inherit for all. Inheriting is the only one that takes
+ * nothing from whoever depends on the setting, and the leak it keeps lasts only until the child touches the setting once
+ * on each device. Losing the setting would cost more, and to whoever can least afford it.
+ *
+ * 📌 NOT BY THE FOUR ONE-COMMAND TRANSPORTS (ADR-0249): there the default is the game's answer, and a value the child set
+ * on the keyboard is not a choice about how a spoken word or a look should behave in this game.
  *
  * It is also the pattern this repository chose for this same value before: the old key stays where it is — it is the
  * child's data, not mine to delete, and keeping it is what makes a way back possible.
@@ -52,15 +47,25 @@ export interface LatchReading {
     readonly fromLegacy: boolean | null;
     /** The factory default (`DEFAULTS.toggleMove` / `DEFAULTS.toggleRun`). */
     readonly byDefault: boolean;
+    /**
+     * THE GAME'S ANSWER, NOW: `GameDeclaration.holdsKeys()` (ADR-0249). The default on the one-command transports.
+     *
+     * ⚠️ READ WHEN THE LATCH IS RESOLVED, not once at boot: a game changes it between stages (ADR-0084), and a latch resolved
+     * from a stale answer would keep a quiz stage latched because the stage before it held keys. REQUIRED, like `holdsKeys`
+     * itself: both values can be wrong, so there is no safe default to fall back on.
+     */
+    readonly gameHoldsKeys: boolean;
 }
+/** The two defaults a resolution needs from outside storage — the factory's and the game's. */
+export type LatchDefaults = Pick<LatchReading, 'byDefault' | 'gameHoldsKeys'>;
 /**
  * This transport's toggle, resolved.
  *
- * The order: one-command transport → ALWAYS on, and nothing else is read · this transport's value · the legacy value ·
+ * The order: this transport's stored value · on a one-command transport, the game's `holdsKeys()` · the legacy value ·
  * the factory default.
  *
- * ⚠️ THE ONE-COMMAND TRANSPORT COMES FIRST, and not as a shortcut: if it read the stored value first, a child who had
- * turned the toggle off on the keyboard would inherit that `false` through the legacy key and be left with a gaze control
- * that does not respond — the worst defect possible, on the control of whoever has fewest alternatives.
+ * ⚠️ THE STORED VALUE COMES FIRST ON EVERY TRANSPORT (ADR-0249): the child's choice for this device wins over any default,
+ * including the game's. And a stored `false` is a VALUE, not an absence — the `!== null` is what keeps a latch the child
+ * turned off from coming back by itself.
  */
 export declare function latchOf(transport: string, l: LatchReading): boolean;

package/dist-pkg/input/latch-scope.js

@@ -14,45 +14,30 @@
 //
 // The key mapping is already kept per transport, and always was. This is the same thing.
 //
-// ========================= AND FOR FOUR TRANSPORTS IT IS NO CHOICE AT ALL =========================
-// ⚠️ Eyes, face, gestures and speech emit ONE COMMAND AT A TIME. There is no looking left and at the jump button at once;
-// no saying two words simultaneously. On them the toggle is not a preference — it is the only way the control works, and
-// offering it as an option would offer a child the choice of a control that does not work.
-//
-// This resolves, in passing, a tension ADR-0084 had with its own rule "a stored value means a choice": the toggle
-// switching itself on for the camera was an exception to that rule. It no longer is, because on these transports it was
-// never a stored value — it is a property of the transport.
-//
-// The rule was written before those four transports existed, so they arrived COVERED instead of arriving at an
-// exception someone would have to remember to open.
+// ========================= ON FOUR TRANSPORTS THE GAME SETS THE DEFAULT (ADR-0249) =========================
+// Eyes, face, gestures and speech emit ONE COMMAND AT A TIME: a word or a look is a tap, never a hold. Whether that tap
+// should keep going is the GAME's to say — in a platform game «direita» keeps the character walking, in a quiz «abaixo»
+// moves the cursor once — and the game already says it: `GameDeclaration.holdsKeys()`. So on these four the latch STARTS
+// as the game answers, and the child's stored choice for that transport, when there is one, wins (ADR-0104 §C: a default
+// is not a lock). Keyboard, pad and touch keep the factory default and the legacy inheritance below.
 //
 // A leaf module: it imports nothing, not even the `platform/storage` whose keys it builds.
 /**
- * The transports that emit ONE COMMAND AT A TIME, on which the toggle is always on.
+ * The transports that emit ONE COMMAND AT A TIME, on which the latch's default is the game's `holdsKeys()` (ADR-0249).
  *
  * The values are transport names, which stay Portuguese like the rest of that vocabulary (`teclado`, `toque`): they are
  * stored, and renaming a stored value loses what the child saved.
  */
 export const ONE_COMMAND_AT_A_TIME = new Set(['olhos', 'rosto', 'gestos', 'fala']);
 /**
- * Is the toggle always on for this transport?
+ * Does this transport's latch start where the GAME says (ADR-0249)?
  *
- * ⚠️ "Always on" and "on by default" are different things, and the difference is ADR-0104 §C's: a default can be changed,
- * and changing it here would make the control unusable. So the stored value is not even read on these transports — see
- * `latchOf`.
+ * `true` on the four one-command transports: with nothing stored for them, the latch is the game's `holdsKeys()`. The
+ * option is offered on every transport alike; this answers only where the default comes from.
  */
-export function latchAlwaysOn(transport) {
+export function latchDefaultFromGame(transport) {
     return ONE_COMMAND_AT_A_TIME.has(transport);
 }
-/**
- * Should the option be OFFERED for this transport?
- *
- * The opposite of `latchAlwaysOn`, with a name of its own because a different caller asks: one decides the state, the
- * other whether to draw the button. A panel that drew the button and ignored the click would be worse than not drawing it.
- */
-export function latchIsOptional(transport) {
-    return !latchAlwaysOn(transport);
-}
 /**
  * The toggle's storage key, with the transport in its name.
  *
@@ -68,11 +53,14 @@ export function latchKey(base, player, transport) {
 /**
  * The OLD key, per player and without a transport. Still read, never written again.
  *
- * ⚠️ IT IS INHERITED BY EVERY TRANSPORT, and the choice takes a sentence to explain. The old value was set by the child in
- * some context, and there is no way to know which — the key did not record it, which is the defect. The ways out were
- * three: lose their setting, guess a transport, or inherit for all. Inheriting for all is the only one that takes nothing
- * from whoever depends on the setting, and the leak it keeps lasts only until the child touches the setting once on each
- * device. Losing the setting would cost more, and to whoever can least afford it.
+ * ⚠️ IT IS INHERITED BY THE KEYBOARD, THE PAD AND TOUCH, and the choice takes a sentence to explain. The old value was set
+ * by the child in some context, and there is no way to know which — the key did not record it, which is the defect. The
+ * ways out were three: lose their setting, guess a transport, or inherit for all. Inheriting is the only one that takes
+ * nothing from whoever depends on the setting, and the leak it keeps lasts only until the child touches the setting once
+ * on each device. Losing the setting would cost more, and to whoever can least afford it.
+ *
+ * 📌 NOT BY THE FOUR ONE-COMMAND TRANSPORTS (ADR-0249): there the default is the game's answer, and a value the child set
+ * on the keyboard is not a choice about how a spoken word or a look should behave in this game.
  *
  * It is also the pattern this repository chose for this same value before: the old key stays where it is — it is the
  * child's data, not mine to delete, and keeping it is what makes a way back possible.
@@ -83,18 +71,18 @@ export function legacyLatchKey(base, player) {
 /**
  * This transport's toggle, resolved.
  *
- * The order: one-command transport → ALWAYS on, and nothing else is read · this transport's value · the legacy value ·
+ * The order: this transport's stored value · on a one-command transport, the game's `holdsKeys()` · the legacy value ·
  * the factory default.
  *
- * ⚠️ THE ONE-COMMAND TRANSPORT COMES FIRST, and not as a shortcut: if it read the stored value first, a child who had
- * turned the toggle off on the keyboard would inherit that `false` through the legacy key and be left with a gaze control
- * that does not respond — the worst defect possible, on the control of whoever has fewest alternatives.
+ * ⚠️ THE STORED VALUE COMES FIRST ON EVERY TRANSPORT (ADR-0249): the child's choice for this device wins over any default,
+ * including the game's. And a stored `false` is a VALUE, not an absence — the `!== null` is what keeps a latch the child
+ * turned off from coming back by itself.
  */
 export function latchOf(transport, l) {
-    if (latchAlwaysOn(transport))
-        return true;
     if (l.fromTransport !== null)
         return l.fromTransport;
+    if (latchDefaultFromGame(transport))
+        return l.gameHoldsKeys;
     if (l.fromLegacy !== null)
         return l.fromLegacy;
     return l.byDefault;

package/dist-pkg/input/latch-store.d.ts

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-import { type LatchReading } from './latch-scope.js';
+import { type LatchReading, type LatchDefaults } from './latch-scope.js';
 /** The minimum of `platform/storage` this needs. Injected, so the gate needs no browser. */
 export interface LatchStore {
     /** ⚠️ The RAW read, not `getBool`. See `readTriState`. */
@@ -21,24 +21,21 @@ export declare function readTriState(store: LatchStore, key: string): boolean |
 /**
  * THE WHOLE READING the rule asks for, built from storage.
  *
- * `base` is `togglemove` or `togglerun` — the two names that already exist in the child's storage.
+ * `base` is `togglemove` or `togglerun` — the two names that already exist in the child's storage. `defaults` carries what
+ * storage does not know: the factory default and the game's `holdsKeys()` answer now (ADR-0249).
  */
-export declare function readLatch(store: LatchStore, base: string, player: number, transport: string, fallback: boolean): LatchReading;
+export declare function readLatch(store: LatchStore, base: string, player: number, transport: string, defaults: LatchDefaults): LatchReading;
 /**
  * THIS PLAYER'S TOGGLE ON THIS TRANSPORT — the whole question, in one call.
  *
  * 📌 SWITCHING TRANSPORT SWITCHES THE ANSWER WITHOUT WRITING ANYTHING, clause 1 of ADR-0113 in code: the value belongs to
  * the controls' mapping, like a caps lock, and changing controls is changing mapping.
  */
-export declare function storedLatch(store: LatchStore, base: string, player: number, transport: string, fallback: boolean): boolean;
+export declare function storedLatch(store: LatchStore, base: string, player: number, transport: string, defaults: LatchDefaults): boolean;
 /**
- * WRITES THE CHILD'S CHOICE for the transport in use. Returns whether it wrote.
+ * WRITES THE CHILD'S CHOICE for the transport in use — on EVERY transport (ADR-0249).
  *
- * ⚠️ IT REFUSES ON ONE-COMMAND TRANSPORTS, and the refusal is a returned `false`, not a throw: on eyes, face, gestures and
- * speech the toggle is what makes the input work (ADR-0113 clause 3), so there is no choice to write. The caller uses the
- * answer to DISABLE the control WITH A REASON — the other half, which lives in the interface, not here.
- *
- * 📌 Writing anyway would be worse than useless: the child would touch the icon, the value would go to disk, and the game
- * would keep ignoring it — a control that lies about having worked.
+ * 📌 Eyes, face, gestures and speech included: their latch starts as the game answers `holdsKeys()`, and what is written
+ * here is the child changing that default for that device. The stored value is what `latchOf` reads first.
  */
-export declare function writeLatch(write: (key: string, isOn: boolean) => void, base: string, player: number, transport: string, isOn: boolean): boolean;
+export declare function writeLatch(write: (key: string, isOn: boolean) => void, base: string, player: number, transport: string, isOn: boolean): void;

package/dist-pkg/input/latch-store.js

@@ -3,8 +3,8 @@
 //
 // ========================= WHAT THIS MODULE IS, AND WHY IT IS APART =========================
 // `input/latch-scope` is the RULE and touches nothing: it takes a finished `LatchReading` and answers. This module is the
-// one thing that was missing between it and the world — whoever goes to storage for the three values the rule asks for,
-// and whoever writes what the child chooses.
+// one thing that was missing between it and the world — whoever goes to storage for the two stored values the rule asks
+// for, and whoever writes what the child chooses. The two defaults (the factory's and the game's) arrive as an argument.
 //
 // 📌 APART ON PURPOSE, not for tidiness: the rule is pure and has its own gate; mixing storage into it would make every
 // case of the rule build a fake `localStorage` to assert something that does not depend on it. The same split
@@ -13,7 +13,7 @@
 // ⚠️ AND WHAT IT DOES NOT DO: it does not know WHICH transport is in use. That is `input/transport-in-use`'s, and it
 // arrives here as an argument. A storage module that guessed the transport would write one child's choice under another
 // device's key — in silence, the defect ADR-0113 exists to prevent.
-import { latchKey, legacyLatchKey, latchOf, latchIsOptional, } from './latch-scope.js';
+import { latchKey, legacyLatchKey, latchOf, } from './latch-scope.js';
 /**
  * THREE STATES, NOT TWO: `true`, `false`, and NEVER WRITTEN.
  *
@@ -32,13 +32,15 @@ export function readTriState(store, key) {
 /**
  * THE WHOLE READING the rule asks for, built from storage.
  *
- * `base` is `togglemove` or `togglerun` — the two names that already exist in the child's storage.
+ * `base` is `togglemove` or `togglerun` — the two names that already exist in the child's storage. `defaults` carries what
+ * storage does not know: the factory default and the game's `holdsKeys()` answer now (ADR-0249).
  */
-export function readLatch(store, base, player, transport, fallback) {
+export function readLatch(store, base, player, transport, defaults) {
     return {
         fromTransport: readTriState(store, latchKey(base, player, transport)),
         fromLegacy: readTriState(store, legacyLatchKey(base, player)),
-        byDefault: fallback,
+        byDefault: defaults.byDefault,
+        gameHoldsKeys: defaults.gameHoldsKeys,
     };
 }
 /**
@@ -47,25 +49,18 @@ export function readLatch(store, base, player, transport, fallback) {
  * 📌 SWITCHING TRANSPORT SWITCHES THE ANSWER WITHOUT WRITING ANYTHING, clause 1 of ADR-0113 in code: the value belongs to
  * the controls' mapping, like a caps lock, and changing controls is changing mapping.
  */
-export function storedLatch(store, base, player, transport, fallback) {
-    return latchOf(transport, readLatch(store, base, player, transport, fallback));
+export function storedLatch(store, base, player, transport, defaults) {
+    return latchOf(transport, readLatch(store, base, player, transport, defaults));
 }
 /**
- * WRITES THE CHILD'S CHOICE for the transport in use. Returns whether it wrote.
+ * WRITES THE CHILD'S CHOICE for the transport in use — on EVERY transport (ADR-0249).
  *
- * ⚠️ IT REFUSES ON ONE-COMMAND TRANSPORTS, and the refusal is a returned `false`, not a throw: on eyes, face, gestures and
- * speech the toggle is what makes the input work (ADR-0113 clause 3), so there is no choice to write. The caller uses the
- * answer to DISABLE the control WITH A REASON — the other half, which lives in the interface, not here.
- *
- * 📌 Writing anyway would be worse than useless: the child would touch the icon, the value would go to disk, and the game
- * would keep ignoring it — a control that lies about having worked.
+ * 📌 Eyes, face, gestures and speech included: their latch starts as the game answers `holdsKeys()`, and what is written
+ * here is the child changing that default for that device. The stored value is what `latchOf` reads first.
  */
 // ⚠️ IT TAKES THE WRITER AND NOT A STORE: the mobility panel already has a `store: { setBool }` injected, and demanding an
 // object with raw `get`/`set` would force an adapter at the call site — where a second way of writing the same key is
 // born. A function is the minimum the write needs.
 export function writeLatch(write, base, player, transport, isOn) {
-    if (!latchIsOptional(transport))
-        return false;
     write(latchKey(base, player, transport), isOn);
-    return true;
 }

package/dist-pkg/input/latch-sync.d.ts

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import type { PlayerView } from '../core/entity.js';
 import { type LatchStore } from './latch-store.js';
+import type { LatchDefaults } from './latch-scope.js';
 /**
  * The MINIMUM OF THE PLAYER the toggle touches — two fields, neither of them part of the game's contract.
  *
@@ -39,8 +40,8 @@ export declare function applyLatch(p: LatchPlayer, on: boolean): boolean;
  * the answer **without writing to storage**. A sync that stored the resolved value would erase, on the first edge, the
  * choice the child made on the other device.
  *
- * ⚠️ AND ON THE FOUR ASSISTED TRANSPORTS IT ANSWERS `true` WITHOUT CONSULTING ANYTHING — the rule lives in `latch-scope`
- * with its reason: on eyes, face, gestures and speech the toggle is what makes the input work, and inheriting a `false`
- * the child chose on the keyboard would leave them with a gaze control that does not respond.
+ * ⚠️ ON THE FOUR ONE-COMMAND TRANSPORTS THE DEFAULT IS THE GAME'S (ADR-0249) — `defaults.gameHoldsKeys`, which the caller
+ * reads from `holdsKeys()` when it calls: a platform game keeps walking on «direita», a quiz moves once on «abaixo», and a
+ * choice the child stored for that transport wins over both. The rule lives in `latch-scope`.
  */
-export declare function syncLatch(p: LatchPlayer, store: LatchStore, player: number, transport: string, byDefault: boolean): boolean;
+export declare function syncLatch(p: LatchPlayer, store: LatchStore, player: number, transport: string, defaults: LatchDefaults): boolean;

package/dist-pkg/input/latch-sync.js

@@ -34,10 +34,10 @@ export function applyLatch(p, on) {
  * the answer **without writing to storage**. A sync that stored the resolved value would erase, on the first edge, the
  * choice the child made on the other device.
  *
- * ⚠️ AND ON THE FOUR ASSISTED TRANSPORTS IT ANSWERS `true` WITHOUT CONSULTING ANYTHING — the rule lives in `latch-scope`
- * with its reason: on eyes, face, gestures and speech the toggle is what makes the input work, and inheriting a `false`
- * the child chose on the keyboard would leave them with a gaze control that does not respond.
+ * ⚠️ ON THE FOUR ONE-COMMAND TRANSPORTS THE DEFAULT IS THE GAME'S (ADR-0249) — `defaults.gameHoldsKeys`, which the caller
+ * reads from `holdsKeys()` when it calls: a platform game keeps walking on «direita», a quiz moves once on «abaixo», and a
+ * choice the child stored for that transport wins over both. The rule lives in `latch-scope`.
  */
-export function syncLatch(p, store, player, transport, byDefault) {
-    return applyLatch(p, storedLatch(store, BASE_DA_MARCHA, player, transport, byDefault));
+export function syncLatch(p, store, player, transport, defaults) {
+    return applyLatch(p, storedLatch(store, BASE_DA_MARCHA, player, transport, defaults));
 }

package/dist-pkg/input/pad-reading.js

@@ -71,13 +71,18 @@ export function bindActive(gp, bd) {
     return false;
 }
 /** The snapshot when the CHILD recorded a map in the wizard: their directions fall back to the standard ones when the
- *  binding is not active, so the D-pad and the stick stay alive beside what they chose. */
+ *  binding is not active, so the D-pad and the stick stay alive beside what they chose.
+ *  ⚠️ `start` and `select` are read AS POSITIONS, as the table's reading does: the wizard asks them and stores them, and a
+ *  map read without `select` left a mapped pad with no door to the menus — not even as the one-button scan's switch
+ *  (ADR-0155, ADR-0218 §4). */
 function actionsFromTheSavedMap(gp, custom) {
     const A = (k) => bindActive(gp, bindingAt(custom, k));
     const sd = stdDirs(gp);
     return {
         left: A('left') || sd.left, right: A('right') || sd.right, up: A('up') || sd.up, down: A('down') || sd.down,
-        action2: A('action2'), action1: A('action1'), action4: A('action4'), action3: A('action3'), _start: A('action2') || A('start'), _pause: A('start'),
+        action2: A('action2'), action1: A('action1'), action4: A('action4'), action3: A('action3'),
+        start: A('start'), select: A('select'),
+        _start: A('action2') || A('start'), _pause: A('start'),
     };
 }
 /**

package/dist-pkg/input/pad-wizard.d.ts

@@ -69,7 +69,10 @@ export interface PadWizardCtx {
      *  the child the fourteen questions again at every visit, in silence. */
     maps: PadMaps;
     getGamepads: GetGamepads;
-    /** The position's name in the GAME's word and the language of now; `null` = the game does not use it (the step is skipped). */
+    /**
+     * The position's name in the GAME's word and the language of now; `null` = the game does not use it (the step is skipped).
+     * ⚠️ Not asked about `start` and `select`: the wizard always asks them, in the engine's words (`SYSTEM_WORDS`).
+     */
     actionLabel: (action: string) => string | null;
     /** Shows and says the wizard's sentence. */
     say: (phrase: string) => void;

package/dist-pkg/input/pad-wizard.js

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
+import { SYSTEM } from '../core/actions.js';
 import { migrateControlMap } from './vocabulary-migration.js';
+import { buttonName } from './touch.js';
 export const PADWIZ_ORDER = [
     // Directions first: they are what the child finds without thinking, and getting all four right gives confidence for
     // the other ten.
@@ -12,6 +14,29 @@ export const PADWIZ_ORDER = [
     // System last: `start` and `select` are usually the smallest and most hidden buttons.
     'start', 'select',
 ];
+/**
+ * 🔴 THE SYSTEM'S TWO ARE ALWAYS ASKED, IN THE ENGINE'S WORDS (ADR-0122, ADR-0144 §1 and its erratum of 2026-09-26, ADR-0155).
+ * A game's preset may not name `start` or `select` (ADR-0144 §4, ADR-0155 §4 — refused at boot), so a wizard that asked only
+ * what the game names never asked them, and every pad it mapped had no quick pause and no menus: the pause no game may decline,
+ * declined by the pad. They are the system's, and `core/actions` (`SYSTEM`) says the engine may name them — the legend printed
+ * on the pad. The host's labeller is not asked about them.
+ * 📌 Each carries its QUESTION and its NAME: the name is the word the question says (START, SELECT), and it is how the progress
+ * line lists the position once mapped — never its id (ADR-0074: no abstract name reaches a person).
+ */
+const SYSTEM_WORDS = {
+    start: { question: 'pad.wiz.stepStart', name: 'touch.start' },
+    select: { question: 'pad.wiz.stepSelect', name: 'touch.select' },
+};
+const systemWords = (action) => (SYSTEM.includes(action) ? SYSTEM_WORDS[action] : null);
+/**
+ * 🔴 THE DEFAULT POSITIONS (ADR-0144, erratum of 2026-09-26 — the Dev: «as posições padrões são up, down, left, right, 1, 2, 3, 4,
+ * L1, L2, R1, R2, START e SELECT»). A game that names no position still gets a pad the child can map: these fourteen, in this
+ * order, each asked by its button's name (`input/touch.buttonName`, ADR-0165 — the names printed on the virtual pad).
+ */
+const DEFAULT_ORDER = [
+    'up', 'down', 'left', 'right', 'action1', 'action2', 'action3', 'action4',
+    'leftShoulder', 'leftTrigger', 'rightShoulder', 'rightTrigger', 'start', 'select',
+];
 const KEY = (id) => 'incl_padmap_' + id;
 /**
  * THE CACHE OF STORED MAPS, one per ROOT (ADR-0232 D4). ⚠️ Not safe to share: two roots on two stores would read each
@@ -41,15 +66,35 @@ export function createPadWizard(ctx) {
     const { t } = ctx;
     let padWiz = null;
     /**
-     * Walks to the next step THIS game uses, or closes if there is none left. ONE function: after the last named step the
-     * wizard does not stay open pointing at a position the game does not use.
+     * THIS WIZARD'S STEPS, decided when it opens: the game's positions (`PADWIZ_ORDER`, those it names) and then START and SELECT;
+     * or, where the game names none, the fourteen defaults (`DEFAULT_ORDER`), all asked, in the engine's words.
+     */
+    let defaults = false;
+    let order = PADWIZ_ORDER;
+    const gameNamesAnyPosition = () => PADWIZ_ORDER.some((action) => systemWords(action) === null && !!ctx.actionLabel(action));
+    /** Is this step asked? Every default; else the game's positions when it names them; the system's two always (`SYSTEM_WORDS`). */
+    const asked = (action) => defaults || systemWords(action) !== null || !!ctx.actionLabel(action);
+    /**
+     * A position's word, the one its question said: the engine's for START and SELECT and for every default, the game's for the
+     * rest. ⚠️ A position the game no longer names (a cartridge mounted mid-wizard) has no word, and is left out rather than shown
+     * by its id.
+     */
+    const wordFor = (action) => {
+        const system = systemWords(action);
+        if (system)
+            return t(system.name);
+        return defaults ? buttonName(ctx.t, action) : ctx.actionLabel(action);
+    };
+    /**
+     * Walks to the next step asked, or closes if there is none left. ONE function: after the last step the wizard does not stay
+     * open pointing at a position nobody asks.
      */
     function advance() {
         if (!padWiz)
             return;
-        while (padWiz.step < PADWIZ_ORDER.length && !ctx.actionLabel(PADWIZ_ORDER[padWiz.step]))
+        while (padWiz.step < order.length && !asked(order[padWiz.step]))
             padWiz.step++;
-        if (padWiz.step >= PADWIZ_ORDER.length)
+        if (padWiz.step >= order.length)
             closeWizard(true);
     }
     function ask() {
@@ -58,21 +103,27 @@ export function createPadWizard(ctx) {
         advance();
         if (!padWiz)
             return; // it closed while advancing
-        const action = PADWIZ_ORDER[padWiz.step];
-        ctx.say(t('pad.wiz.step', { n: padWiz.step + 1, total: PADWIZ_ORDER.length, acao: ctx.actionLabel(action) }));
+        const action = order[padWiz.step];
+        const n = padWiz.step + 1, total = order.length;
+        const system = systemWords(action);
+        ctx.say(t(system?.question ?? 'pad.wiz.step', { n, total, acao: system ? '' : wordFor(action) }));
         ctx.onStep?.(action);
-        // The empty list's dash stays raw on purpose: it is punctuation, not language.
-        ctx.progress(t('pad.wiz.mapped', { lista: Object.keys(padWiz.map).join(' · ') || '—' }));
+        // What is mapped, in the words it was asked with (ADR-0074) — the map's keys are position ids. The empty list's dash stays
+        // raw on purpose: it is punctuation, not language.
+        const words = Object.keys(padWiz.map).map(wordFor).filter((word) => !!word);
+        ctx.progress(t('pad.wiz.mapped', { lista: words.join(' · ') || '—' }));
     }
     function wire(bd) {
         if (!padWiz)
             return;
-        padWiz.map[PADWIZ_ORDER[padWiz.step]] = bd;
+        padWiz.map[order[padWiz.step]] = bd;
         padWiz.step++;
         padWiz.release = true; // requires letting go before the next step
         advance();
     }
     function begin(gi, id, phrase) {
+        defaults = !gameNamesAnyPosition();
+        order = defaults ? DEFAULT_ORDER : PADWIZ_ORDER;
         padWiz = { gi, id, step: -1, base: null, map: {}, release: false, baseWait: gi >= 0, axTrack: null, timer: null };
         ctx.say(phrase);
         ctx.onStep?.(null);