@the-inclusionist/engine 10.0.0 → 11.0.0

package/dist-pkg/ui/session-clock.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { readSession, clockWords, clockDigits } from '../core/session-clock.js';
+/** One tick a second: the digits move by the second, and the hour's pie by a tenth of a degree, which reads as continuous. */
+const TICK_MS = 1000;
+/** Writes `text` into `node` only when it changed — a rewrite is a repaint, and on school hardware a repaint costs. */
+function write(node, text) {
+    if (node.textContent !== text)
+        node.textContent = text;
+}
+/**
+ * Builds the clock's three parts: the label and the digits in a column, the pie to their right.
+ *
+ * 🔴 THE PARTS ARE `aria-hidden`: they are the picture, and the image's name is what a listener gets. ARIA calls an image's
+ * children presentational, but not every accessibility API prunes them — Gecko keeps a graphic's children unless it has exactly
+ * one text child, and NVDA then read «TEMPO. 56:07.» instead of the words (the Dev, 2026-09-25). Hidden here, no API has any
+ * text under the image to hand out. Gate: `tests/quiz-accessibility-tree.browser.test.js`, on the browser's own tree.
+ */
+function build(doc) {
+    const part = (cls) => { const n = doc.createElement('span'); n.className = cls; return n; };
+    const el = doc.createElement('div');
+    el.className = 'session-clock';
+    el.setAttribute('role', 'img');
+    const text = part('session-clock-text');
+    const label = part('session-clock-label');
+    const digits = part('session-clock-digits');
+    const pie = part('session-clock-pie');
+    text.setAttribute('aria-hidden', 'true');
+    pie.setAttribute('aria-hidden', 'true');
+    text.append(label, digits);
+    el.append(text, pie);
+    return { el, label, digits, pie };
+}
+/** Mounts the clock in its slot, draws it now, and redraws it every second until `remove()`; `null` where it cannot. */
+export function mountSessionClock(ctx) {
+    const { slot, performance: clock, setInterval: every } = ctx;
+    if (!slot || typeof slot.appendChild !== 'function' || !clock || typeof every !== 'function')
+        return null;
+    const { el, label, digits, pie } = build(ctx.doc);
+    slot.appendChild(el);
+    const timer = clock; // the guard's answer, kept for the tick
+    const start = timer.now();
+    let look = null;
+    function refresh() {
+        const reading = readSession(timer.now() - start);
+        const next = reading.over ? 'red' : 'running';
+        pie.style.setProperty('--left', reading.left.toFixed(4));
+        write(label, ctx.t('clock.label'));
+        write(digits, clockDigits(reading.leftMs));
+        const words = clockWords(reading);
+        const name = ctx.t(words.key, { minutes: words.minutes });
+        if (el.getAttribute('aria-label') !== name)
+            el.setAttribute('aria-label', name);
+        if (next !== 'running' && look === 'running')
+            ctx.announce(name);
+        if (next !== look)
+            el.dataset.look = next;
+        look = next;
+        ctx.drawn();
+    }
+    refresh();
+    const handle = every(refresh, TICK_MS);
+    return {
+        el,
+        refresh,
+        remove: () => { ctx.clearInterval?.(handle); el.remove(); },
+    };
+}

package/dist-pkg/ui/settings-aac.d.ts

@@ -25,7 +25,9 @@ export declare function lettersRowSpec(t: Translate): ControlRowSpec;
  */
 export declare function aacRowSpec(t: Translate, s: AacSet): ControlRowSpec;
 /**
- * The menu's three sections, in decision order: the section says WHOSE turn it is to act.
+ * The menu's two sections: what works now (the letters switch), and the pictogram sets, each only with a licence
+ * (ADR-0233). Whether a set row is locked is the row's own business (its reason and its `disabled`), so a licence that
+ * arrives changes one row, not the sections.
  *
  * 📌 Each produces its own rows instead of filtering the catalogue, because the first does not come from the catalogue
  * — the letters are a switch and not a set, the Dev's decision that took them out of the list. A table whose first row

package/dist-pkg/ui/settings-aac.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 import { DEFAULTS } from '../core/setting-defaults.js';
-import { AAC_SETS, AAC_BY_KEY, aacReason } from './aac-sets.js';
+import { AAC_SETS, AAC_BY_KEY, aacMenuLocked, aacReason, aacSelectable } from './aac-sets.js';
 import { markChanged, markMenuChanged } from './changed-mark.js';
 import { controlRow, labelRow, sectionHeader } from './panel-widgets.js';
 import { toggleLabel } from './dom.js';
@@ -39,7 +39,9 @@ export function aacRowSpec(t, s) {
     };
 }
 /**
- * The menu's three sections, in decision order: the section says WHOSE turn it is to act.
+ * The menu's two sections: what works now (the letters switch), and the pictogram sets, each only with a licence
+ * (ADR-0233). Whether a set row is locked is the row's own business (its reason and its `disabled`), so a licence that
+ * arrives changes one row, not the sections.
  *
  * 📌 Each produces its own rows instead of filtering the catalogue, because the first does not come from the catalogue
  * — the letters are a switch and not a set, the Dev's decision that took them out of the list. A table whose first row
@@ -48,14 +50,9 @@ export function aacRowSpec(t, s) {
 export const AAC_SECTIONS = [
     { title: 'aac.secao.agora', tag: 'aac.secao.agoraTag', rows: (t) => [lettersRowSpec(t)] },
     {
-        title: 'aac.secao.preparo',
-        tag: 'aac.secao.preparoTag',
-        rows: (t) => AAC_SETS.filter((s) => s.tier !== 'negotiating').map((s) => aacRowSpec(t, s)),
-    },
-    {
-        title: 'aac.secao.negociacao',
-        tag: 'aac.secao.negociacaoTag',
-        rows: (t) => AAC_SETS.filter((s) => s.tier === 'negotiating').map((s) => aacRowSpec(t, s)),
+        title: 'aac.section.pictograms',
+        tag: 'aac.section.pictogramsTag',
+        rows: (t) => AAC_SETS.map((s) => aacRowSpec(t, s)),
     },
 ];
 /**
@@ -85,8 +82,8 @@ export function mountAacInside(t, ctx, list) {
 /**
  * A new row, with what the kit does not know about this panel: the set's key and the lock.
  *
- * No set is available today. A button that does nothing is worse than absence, because it spends trust — so it comes
- * locked, and the reason is already in `ariaLabel` for whoever navigates by keyboard.
+ * No set is licensed today (ADR-0233). A button that does nothing is worse than absence, because it spends trust — so an
+ * unlicensed set comes locked, and the reason is already in `ariaLabel` for whoever navigates by keyboard.
  */
 function newRow(ctx, spec) {
     const { row: row, control: control } = controlRow(ctx, spec);
@@ -96,7 +93,8 @@ function newRow(ctx, spec) {
     }
     const key = spec.id.replace('caa-set-', '');
     control.setAttribute('data-caa', key);
-    if (!AAC_BY_KEY[key]?.available)
+    const set = AAC_BY_KEY[key];
+    if (!set || !aacSelectable(set))
         control.setAttribute('disabled', '');
     return row;
 }
@@ -137,7 +135,27 @@ export function initSettingsAac(ctx) {
         markChanged(t, ctx.$('#caa-letras'), changed);
         markMenuChanged(t, ctx.$('[data-act="caa"]'), [changed]);
     }
+    /**
+     * THE MENU'S DOOR IS DISABLED while no pictogram set is licensed (ADR-0233 erratum), with the pause card's lock
+     * (ADR-0161): `aria-disabled` and the reason in `data-motivo`, which the menu navigation speaks on reach and writes in
+     * the footer. The reason is ONLY «menu disabled»: the licence story is not the child's to hear. No unlock branch: the
+     * catalogue is static, so a licensed set means the door is never locked in the first place.
+     */
+    function lockDoor() {
+        const door = ctx.$('[data-act="caa"]');
+        if (!door || !aacMenuLocked())
+            return;
+        door.setAttribute('aria-disabled', 'true');
+        door.dataset.motivo = t('pause.motivo.caa');
+    }
     function open() {
+        // A game that wires its own door to `open` meets the same lock: the reason is said and nothing opens, so no
+        // per-set licence row reaches the child.
+        if (aacMenuLocked()) {
+            lockDoor();
+            ctx.srSay(t('pause.motivo.caa'));
+            return;
+        }
         const ov = ctx.$('#caa');
         if (!ov)
             return;
@@ -174,6 +192,7 @@ export function initSettingsAac(ctx) {
     const closeBtn = ctx.$('#caa-close');
     if (closeBtn)
         closeBtn.addEventListener('click', close);
+    lockDoor();
     // ---- reset THIS menu's defaults (ADR-0028) ----
     // The menu has one choice, so the reset is one line — but where it returns to is worth saying: the default case,
     // where Brazilian literacy usually starts. A child who switched the case and can no longer read the screen needs a way

package/dist-pkg/ui/settings-audio.d.ts

@@ -5,7 +5,6 @@ import type { PlayerAudioOut } from '../platform/audio-sonar.js';
 import type { DomQuery } from '../core/dom-query.js';
 import type { PanelShellCtx } from './panel-shell.js';
 import { type TtsPanel, type VoiceSettingsStore } from './voice-settings.js';
-export type { DomQuery } from '../core/dom-query.js';
 /** Minimal platform/storage.ts shape this module needs (get/set only — no direct localStorage access). */
 export interface AudioStore {
     get(key: string, fallback?: string | null): string | null;
@@ -115,9 +114,14 @@ export interface SettingsAudioApi {
     renderAudio: () => void;
     /** Refreshes the #opt-modocego button. Exported because the host's blind-mode setter calls it directly. */
     reflectBlindMode: () => void;
-    /** Refreshes the #opt-tts button + #tts-engine selection. Exported because the pause-menu icon bar toggles
-     *  audioCat.tts.on itself and then calls this. */
+    /** Refreshes the #opt-tts button, the #tts-vol slider and the #tts-engine selection. */
     reflectTts: () => void;
+    /**
+     * Shows ONE mixer category as the mixer holds it now — its switch and its volume wherever this panel draws them, and the
+     * left-the-default marks — without redrawing anything else. The host calls it for every change the mixer tells
+     * (`Audio.onCatChange`, ADR-0247): a category written by a game, the bar or another panel.
+     */
+    reflectCategory: (cat: string) => void;
 }
 /**
  * MOUNTS THIS PANEL'S INSIDE — the controls and containers it reaches.
@@ -125,8 +129,9 @@ export interface SettingsAudioApi {
  * 🔴 IT IS THE LARGEST INVISIBLE CONTRACT OF THE PANELS: this file looks for `#opt-modocego`, `#cane-div`,
  * `#opt-menuindex`, `#opt-tts`, `#tts-vol` and more, and nothing in the type says so — which is why it builds them.
  *
- * ⚠️ AND EACH ONE'S TAG MATTERS, which makes this the worst place to guess: `#cane-div` and the voice selects have to be
- * `<select>` — the panel writes `.value` into them —, and the volumes have to be `<input type=range>`. On a `<button>`,
+ * ⚠️ AND EACH ONE'S TAG MATTERS, which makes this the worst place to guess: the voice selects have to be `<select>` — the
+ * panel writes `.value` into them —, the volumes `<input type=range>`, and `#cane-div` is the cycle row `caneRow` builds
+ * (a host's own `<select>` is still read). On a `<button>`,
  * writing `.value` gives no error at all: it creates a property nobody reads, and the child's choice vanishes silently.
  *
  * 📌 THE ORDER IS THE DECISION (ADR-0044 §2), from general to particular (see the composition below).

package/dist-pkg/ui/settings-audio.js

@@ -13,7 +13,7 @@ import { toggleLabel } from './dom.js';
 import { DEFAULTS } from '../core/setting-defaults.js';
 import { markChanged, markMenuChanged } from './changed-mark.js';
 import { defaultAudioCat } from '../platform/audio-mixer.js';
-import { controlRow, labelRow } from './panel-widgets.js';
+import { controlRow, labelRow, mountChoice, updateChoice } from './panel-widgets.js';
 /*
  * 🔴 THE VOICE SECTION LIVES IN `ui/voice-settings` (ADR-0221, issue #203): speech — the narration switch, the engine, the
  * voice, the rate, the spoken index and the test button — and the sound categories, cane, blind mode and outputs never
@@ -27,14 +27,50 @@ import { createVoiceSettings } from './voice-settings.js';
  * and the browser test drove the rest.
  */
 import { NAV_CATS, GEN_CATS, volPercent, navMasterVolume, parseCaneDiv, caneDivMessage, sinksSupported, sinkOptionLabel, sinkSelectValue, } from './audio-choices.js';
+/** The cane's two positions — one tap per block, one every half block — in the page's language. */
+function canePositions(t) {
+    return [{ value: '1', label: t('audio.cane.block') }, { value: '2', label: t('audio.cane.halfBlock') }];
+}
+/**
+ * THE CANE ROW, a CYCLE ROW «◀ Batida da bengala: uma batida por bloco ▶» (ADR-0130 rule 3: two positions).
+ *
+ * 🔴 It was the kit's `escolha`, a `<select>` nobody filled: offered to every game with a walker, it opened on nothing to
+ * choose. Two positions are a cycle, and the positions are the engine's words.
+ *
+ * 📌 THE `<strong>` STAYS, HIDDEN: it is where the game's word for the cane lands (`ui/audio-rows-that-apply`, ADR-0153),
+ * and `renderAudio` reads it into the cycle's own text. `hidden` keeps it out of the accessibility tree, so the name is
+ * heard once — from the control.
+ */
+function caneRow(t, ctx, spec) {
+    const row = ctx.create('div');
+    row.className = 'ctrl-row ctrl-row--passos';
+    const text = ctx.create('span');
+    const name = ctx.create('strong');
+    name.textContent = spec.label;
+    name.hidden = true;
+    text.appendChild(name);
+    if (spec.hint) {
+        const explanation = ctx.create('span');
+        explanation.className = 'opt-hint';
+        explanation.textContent = spec.hint;
+        text.appendChild(explanation);
+    }
+    row.appendChild(text);
+    // the pick is `initSettingsAudio`'s, which listens for the `change` every choice fires: this builder has no setter
+    const control = mountChoice(ctx, { label: spec.label, values: canePositions(t), current: '1' }, () => { });
+    control.id = spec.id;
+    row.appendChild(control);
+    return row;
+}
 /**
  * MOUNTS THIS PANEL'S INSIDE — the controls and containers it reaches.
  *
  * 🔴 IT IS THE LARGEST INVISIBLE CONTRACT OF THE PANELS: this file looks for `#opt-modocego`, `#cane-div`,
  * `#opt-menuindex`, `#opt-tts`, `#tts-vol` and more, and nothing in the type says so — which is why it builds them.
  *
- * ⚠️ AND EACH ONE'S TAG MATTERS, which makes this the worst place to guess: `#cane-div` and the voice selects have to be
- * `<select>` — the panel writes `.value` into them —, and the volumes have to be `<input type=range>`. On a `<button>`,
+ * ⚠️ AND EACH ONE'S TAG MATTERS, which makes this the worst place to guess: the voice selects have to be `<select>` — the
+ * panel writes `.value` into them —, the volumes `<input type=range>`, and `#cane-div` is the cycle row `caneRow` builds
+ * (a host's own `<select>` is still read). On a `<button>`,
  * writing `.value` gives no error at all: it creates a property nobody reads, and the child's choice vanishes silently.
  *
  * 📌 THE ORDER IS THE DECISION (ADR-0044 §2), from general to particular (see the composition below).
@@ -61,7 +97,8 @@ export function mountAudioInside(t, ctx, card, list) {
         // ⚠️ Their own short keys, not the bar's `icon.blind`/`icon.tts`: those carry «(navegação sonora)» and «(TTS)», and
         // a row keeps no explanation in parentheses (ADR-0158).
         { id: 'opt-modocego', label: t('audio.modocego') },
-        { id: 'cane-div', label: t('audio.cane'), hint: t('audio.cane.dica'), shape: 'escolha' },
+        // two positions, so a cycle row (ADR-0130 rule 3): built by `caneRow`, not by the kit
+        { id: 'cane-div', label: t('audio.cane'), hint: t('audio.cane.dica') },
         { container: '@lista' }, // the shell's list: sonar, guard and guide
         { id: 'opt-tts', label: t('audio.narracao'), hint: t('audio.tts.dica') },
         { id: 'tts-vol', label: t('audio.ttsVol'), shape: 'cursor' },
@@ -115,7 +152,7 @@ export function mountAudioInside(t, ctx, card, list) {
                 labelRow(rowNode, piece);
             continue;
         }
-        card.insertBefore(controlRow(ctx, piece).row, actions);
+        card.insertBefore(piece.id === 'cane-div' ? caneRow(t, ctx, piece) : controlRow(ctx, piece).row, actions);
     }
 }
 /**
@@ -364,31 +401,21 @@ export function initSettingsAudio(ctx) {
         }
         const players = ctx.getPlayers();
         const n = Math.max(1, ctx.getNumPlayers());
+        /*
+         * 🔴 A PLAYER'S OUTPUT IS A CHOICE, AND ITS SIZE PICKS THE CONTROL (ADR-0130 rule 3): «shared» and up to four devices are
+         * a cycle row «◀ Jogador 1: Fone USB ▶», more a dropdown. The size is the room's today — it is drawn again at every
+         * detection, so a fifth headset plugged in turns the rows into dropdowns.
+         */
+        const outputs = [{ value: '', label: t('audio.sinkShared') }, ...devices.map((d, k) => ({ value: d.deviceId, label: sinkOptionLabel(t, d, k) }))];
         for (let i = 0; i < n; i++) {
             const p = players[i];
+            const name = t('audio.playerN', { n: i + 1 });
             const row = make('div');
             row.className = 'ctrl-row';
-            const lbl = make('label');
-            lbl.textContent = t('audio.playerN', { n: i + 1 });
-            lbl.htmlFor = 'sink-p' + i;
-            const sel = make('select');
-            sel.className = 'vol';
-            sel.id = 'sink-p' + i;
-            const o0 = make('option');
-            o0.value = '';
-            o0.textContent = t('audio.sinkShared');
-            sel.appendChild(o0);
-            devices.forEach((d, k) => {
-                const o = make('option');
-                o.value = d.deviceId;
-                o.textContent = sinkOptionLabel(t, d, k);
-                sel.appendChild(o);
-            });
-            sel.value = sinkSelectValue(p);
-            sel.addEventListener('change', () => {
+            const choice = mountChoice(kitCtx(el), { label: name, values: outputs, current: sinkSelectValue(p) }, (value) => {
                 if (!p)
                     return;
-                p.audioSink = sel.value || null;
+                p.audioSink = value || null;
                 ctx.store.set('incl_sink_p' + i, p.audioSink || '');
                 if (p._ac) {
                     try {
@@ -400,8 +427,17 @@ export function initSettingsAudio(ctx) {
                 }
                 ctx.srSay(t(p.audioSink ? 'sr.audio.sinkChanged' : 'sr.audio.sinkDefault', { n: i + 1 }));
             });
-            row.appendChild(lbl);
-            row.appendChild(sel);
+            choice.id = 'sink-p' + i;
+            if (choice.tagName === 'SELECT') {
+                // a dropdown keeps its name beside it; a cycle row already carries it in its own text
+                const lbl = make('label');
+                lbl.textContent = name;
+                lbl.htmlFor = choice.id;
+                row.appendChild(lbl);
+            }
+            else
+                row.classList.add('ctrl-row--passos');
+            row.appendChild(choice);
             el.appendChild(row);
         }
     }
@@ -438,9 +474,7 @@ export function initSettingsAudio(ctx) {
         renderNavSound();
         drawBlindMode();
         voice.render();
-        const cd = ctx.$('#cane-div');
-        if (cd)
-            cd.value = String(ctx.getCaneBlockDiv());
+        reflectCane();
         void enumerateSinks(); // not awaited: fire and carry on (the asynchronous list updates by itself)
         refreshMarks();
     }
@@ -528,11 +562,28 @@ export function initSettingsAudio(ctx) {
             ctx.srSay(t(ctx.getBlindMode() ? 'sr.blind.on' : 'sr.blind.off'));
         });
     }
-    const caneDivSel = ctx.$('#cane-div');
-    if (caneDivSel) {
-        caneDivSel.value = String(ctx.getCaneBlockDiv());
-        caneDivSel.addEventListener('change', () => {
-            const div = parseCaneDiv(caneDivSel.value);
+    /**
+     * The cane's position in use. A host's own `<select>` gets its value; the engine's cycle row (`caneRow`) its words and
+     * value, with its name read from the row's hidden `<strong>` — where the game's word for the cane lands (ADR-0153).
+     */
+    function reflectCane() {
+        const cd = ctx.$('#cane-div');
+        if (!cd)
+            return;
+        const current = String(ctx.getCaneBlockDiv());
+        if (cd.tagName === 'SELECT') {
+            cd.value = current;
+            return;
+        }
+        const label = cd.closest('.ctrl-row')?.querySelector('strong')?.textContent || t('audio.cane');
+        updateChoice(cd, { label, values: canePositions(t), current });
+    }
+    const caneDiv = ctx.$('#cane-div');
+    if (caneDiv) {
+        reflectCane();
+        caneDiv.addEventListener('change', () => {
+            // a host's `<select>` holds its value; the engine's cycle row carries it in `data-value` (`mountChoice`)
+            const div = parseCaneDiv(caneDiv.tagName === 'SELECT' ? caneDiv.value : (caneDiv.dataset.value ?? ''));
             ctx.setCaneBlockDiv(div);
             ctx.srSay(caneDivMessage(t, div));
         });
@@ -596,5 +647,20 @@ export function initSettingsAudio(ctx) {
      * announce: the bar's icon already speaks for itself.
      */
     ctx.on('blindMode', () => { drawBlindMode(); }); // through the root's door: released by its `dispose()`
-    return { renderAudio, reflectBlindMode: drawBlindMode, reflectTts: voice.reflectTts };
+    /** One category, in place: the lists hold rows only once the panel has drawn them, and a row not there is not drawn here. */
+    function reflectCategory(k) {
+        if (k === 'tts')
+            voice.reflectTts();
+        for (const sel of ['#audio-list', '#navsound-list']) {
+            const list = ctx.$(sel);
+            if (list)
+                reflectCatRows(list, [k]);
+        }
+        const navMaster = ctx.$('#navsound-master');
+        const state = ctx.getAudioCat();
+        if (navMaster && state)
+            navMaster.value = String(navMasterVolume(state, NAV_CATS));
+        refreshMarks();
+    }
+    return { renderAudio, reflectBlindMode: drawBlindMode, reflectTts: voice.reflectTts, reflectCategory };
 }

package/dist-pkg/ui/settings-controls.d.ts

@@ -5,10 +5,6 @@ import type { KeyScheme } from '../core/entity.js';
 import { type Action } from '../core/actions.js';
 import type { KBDefaults } from '../input/keyboard.js';
 import type { KeydownEventLike } from '../input/keydown.js';
-/** Minimal DOM-selector shape (matches ui/dom.ts's `$`). */
-export type { DomQuery } from '../core/dom-query.js';
-/** action -> list of physical key codes (KeyboardEvent.code), e.g. {jump:['KeyJ','Space']}. */
-export type { KeyScheme } from '../core/entity.js';
 /** Opaque keyboard config (input/keyboard.ts's KBDefaults shape: {solo,p2,p3,p4}) — never indexed directly here;
  *  all per-player reads go through the injected `kbFor`, so this module stays decoupled from its exact shape. */
 /** `input/keyboard`'s `KBDefaults`, which is the owner. This module still does NOT INDEX the value — every per-player

package/dist-pkg/ui/settings-mobility.d.ts

@@ -4,8 +4,6 @@ import type { Translate } from '../core/i18n.js';
 import type { DomQuery } from '../core/dom-query.js';
 import { type LatchPlayer as JogadorDaAlternanciaDaAresta } from '../input/latch-sync.js';
 import type { PanelShellCtx } from './panel-shell.js';
-/** Minimal DOM-selector shape (matches ui/dom.ts's `$`). */
-export type { DomQuery } from '../core/dom-query.js';
 /** Minimal platform/storage.ts shape this module needs. */
 export interface MobilityStore {
     setBool(key: string, on: boolean): void;
@@ -35,8 +33,7 @@ export interface SettingsMobilityCtx {
      * panel.
      *
      * ⚠️ Not offering it means making the row absent for everyone, with `hidden`, which takes it off the screen AND out of
-     * the accessibility tree. An `aria-disabled` would be the wrong answer — that is clause 3 of ADR-0113, where the
-     * control EXISTS and is locked with a reason.
+     * the accessibility tree — not an `aria-disabled` row that stays in the tab order doing nothing.
      *
      * ⚠️ REQUIRED, for the same reason as in `PauseIconsCtx`: there is no safe default. `true` leaves the row in a game
      * where it does nothing; `false` hides it from a child who depends on it.
@@ -120,8 +117,8 @@ export declare function toggleMoveKey(i: number): string;
  * flags. A minimal slice lets both pass without either carrying the other's.
  *
  * 📌 THE DEFINITION LIVES IN `input/latch-sync` (issue #127), beside the rule that uses it, and the NAME stays published
- * here. ⚠️ **An alias and not `export ... from`**: the names snapshot leaves re-exports out and would read the change of
- * home as a removal (the lesson of ADR-0106 step 1a).
+ * here, as an alias (ADR-0106 step 1a). Since issue #204 the names snapshot reads a re-export too, so either form keeps
+ * the name in this module's snapshot.
  */
 export type LatchPlayer = JogadorDaAlternanciaDaAresta;
 /** What the write needs to know. Everything here already lives in `SettingsMobilityCtx` and `PauseIconsCtx`. */

package/dist-pkg/ui/settings-mobility.js

@@ -16,7 +16,6 @@ import { DEFAULTS } from '../core/setting-defaults.js';
 import { KEYS } from '../platform/storage-keys.js';
 import { writeLatch } from '../input/latch-store.js';
 import { applyLatch, BASE_DA_MARCHA, } from '../input/latch-sync.js';
-import { latchRefusal } from './latch-refusal.js';
 import { clampSelPlayer, anyMobilityActive, onOffLabel, playerTabsHTML, easyAnnouncement, playerPrefix } from './mobility-choices.js';
 import { controlRow, labelRow } from './panel-widgets.js';
 // ---------------------------------------------------------------------------------------------
@@ -64,10 +63,8 @@ export function setMoveLatch(ctx, i, on) {
     // reason: a cartridge may still READ it through `KEYS.toggleMoveP(i)`. Stopping writing it now would make the child
     // lose the choice at the next boot — the cost ADR-0113 names.
     ctx.store.setBool(toggleMoveKey(i), on);
-    // 📌 And the NEW key, when the device is known. `writeLatch` refuses on the four assisted transports, where there is no
-    // choice to store (ADR-0113 clause 3) — and returns `false` so a caller can disable the control with the reason said.
-    // Here the refusal changes nothing else: the in-memory value is still what the rule resolves, and the rule answers
-    // `true` on those four.
+    // 📌 And the NEW key, when the device is known — on every device (ADR-0249): on eyes, face, gestures and speech this is the
+    // child's choice overriding the game's `holdsKeys()` default for that transport.
     const transport = ctx.transportInUse ? ctx.transportInUse(i) : null;
     if (transport)
         writeLatch((key, isOn) => ctx.store.setBool(key, isOn), BASE_DA_MARCHA, i, transport, on);
@@ -164,32 +161,20 @@ export function initSettingsMobility(ctx) {
     let selMovPlayer = 0; // the player selected in the mobility panel
     const easyModeButton = ctx.$('#opt-facil');
     const altMoveBtn = ctx.$('#opt-altmove');
-    /**
-     * THE ROW'S ORIGINAL HINT, kept once.
-     *
-     * ⚠️ HERE THE REFUSAL COMES AND GOES: this button is persistent, and the child may put the webcam down and go back to
-     * the keyboard — without keeping the original text, the reason would pile up on the row with every device change.
-     */
     const altMoveRow = altMoveBtn?.closest('.ctrl-row') ?? null;
-    const altMoveHint = altMoveRow?.querySelector('.opt-hint') ?? null;
-    const originalHint = altMoveHint?.textContent ?? '';
     /*
      * ADR-0115 · THE ROW DISAPPEARS IN A GAME THAT HOLDS NOTHING — and disappears for EVERYONE.
      *
      * 🔴 `hidden` and not `aria-disabled`: the child who depends on the latch opens this panel to switch it on, and in a
      * quiz there is nothing to switch on. A control disabled with a reason is still a control that does nothing — and it
      * still takes a place in keyboard navigation, between two that work.
-     * 📌 Clause 3 of ADR-0113 is the opposite case and stays intact: there the device REQUIRES the latch, the control
-     * exists, and it is `aria-disabled` WITH the reason, reachable so it can be read.
+     * 📌 Where the game holds keys the row is offered on EVERY device, eyes and voice included (ADR-0249): there the latch
+     * starts as the game's answer, and this row is how the child changes it.
      * ⚠️ `hidden` and not removal: the row may be the page's own markup, and `hidden` is reversible and idempotent where
      * removing someone else's markup is neither.
      */
     if (!ctx.holdsKeys && altMoveRow)
         altMoveRow.hidden = true;
-    /** THIS player's refusal now, or `null`. Recomputed on every reflect: the device in use changes. */
-    function refusalFor(i) {
-        return ctx.transportInUse ? latchRefusal(ctx.transportInUse(i)) : null;
-    }
     const toggleRunBtn = ctx.$('#opt-togglerun');
     // the bar lights up if ANY player uses Easy Mode or a latch
     function reflectMovementBtn() {
@@ -249,23 +234,6 @@ export function initSettingsMobility(ctx) {
             altMoveBtn.classList.toggle('is-on', on);
             altMoveBtn.setAttribute('aria-pressed', String(on));
             altMoveBtn.textContent = onOffLabel(t, on);
-            /*
-             * ⚠️ CLAUSE 3 OF ADR-0113 ON SCREEN: where the latch is required, the control does NOT disappear — it is
-             * `aria-disabled` and the reason goes into the hint, which the shell (`ui/settings-panel.fillExplain`) moves to the
-             * footer. Disappearing would teach that the thing does not exist; leaving it active would make the child press it
-             * and not understand why nothing changed.
-             *
-             * 📌 And `aria-disabled`, not `disabled`: a really disabled button LEAVES the tab order, and a keyboard user could no
-             * longer reach it — so could no longer READ the reason. The same choice #128 names as a defect when made the other
-             * way (a CSS class only, no `aria`).
-             */
-            const refusal = refusalFor(selMovPlayer);
-            if (refusal)
-                altMoveBtn.setAttribute('aria-disabled', 'true');
-            else
-                altMoveBtn.removeAttribute('aria-disabled');
-            if (altMoveHint)
-                altMoveHint.textContent = refusal ? `${originalHint} ${t(refusal.key)}`.trim() : originalHint;
         }
         reflectMovementBtn();
     }
@@ -308,16 +276,6 @@ export function initSettingsMobility(ctx) {
         }
         if (altMoveBtn) {
             altMoveBtn.addEventListener('click', () => {
-                /*
-                 * ⚠️ REFUSE BY SAYING, NOT IN SILENCE. The listener is wired once, and a mute `return` would accept the click and
-                 * ignore it — the other half of what ADR-0076 forbids. So the refusal SPEAKS: whoever pressed learns why, even
-                 * without seeing the hint.
-                 */
-                const refusal = refusalFor(selMovPlayer);
-                if (refusal) {
-                    ctx.srSay(t(refusal.key));
-                    return;
-                }
                 setToggleMove(selMovPlayer, !ctx.players[selMovPlayer].toggleMove);
                 reflectAltMove();
             });

package/dist-pkg/ui/settings-motion.js

@@ -16,8 +16,8 @@ import { SCENE_KEYS, CHARACTER_ANIMATIONS, readStoredScene, storeScene } from '.
  * 📌 THE PURE HALF LIVES IN `ui/motion-choices` (ADR-0221), and the SUITE pointed at the seam:
  * `tests/settings-motion.node.test.js` exercises exactly these names, and the node project mounts no document.
  *
- * ⚠️ NO ALIAS: a re-export would keep alive a path nothing in here uses and make the surface snapshot lie, because it
- * does not see re-exports (issue #204).
+ * ⚠️ NO ALIAS: a re-export would keep alive a published path nothing in here uses — surface with no consumer
+ * (issue #204).
  */
 import { RM_LABEL, CRT_LBL, CRT_ROUND_LEVELS, clampSelectedPlayer, allMotionFrozen, motionMasterLabel, sceneMotionAnnouncement, crtToggleAnnouncement, crtLevelLabel, crtRoundAnnouncement, stopResumeAllAnnouncement, } from './motion-choices.js';
 /*

package/dist-pkg/ui/settings-panel.d.ts

@@ -62,6 +62,16 @@ export interface SettingsPanelApi {
     escapeTarget: () => string | null;
     /** The highest VISIBLE overlay in the stack. A z tie: the last in the DOM wins. */
     topVisibleOverlay: () => HTMLElement | null;
+    /**
+     * Draws the MODAL BOUNDARY at the front card (ADR-0130 rule 1): every visible layer under it — the other overlays and
+     * the pause cards — is `inert`, and nothing is when no overlay is open. Opening, `restoreFocus` and `closeById` call it themselves
+     * (the last two BEFORE any focus goes back, since an inert element refuses focus); a host whose dialogs can also be hidden by paths that
+     * return no focus calls it when a `hidden` changes — `createGame` does, from its observer.
+     *
+     * OPTIONAL in the type only: `initSettingsPanel` always returns it, and an API built elsewhere (a host's own double of
+     * this shell) keeps compiling without a boundary to draw.
+     */
+    syncLayers?: () => void;
     /** Registered ids, in order — for tests/debugging only. */
     registeredIds: () => string[];
 }