@the-inclusionist/engine 9.0.0 → 11.0.0

package/dist-pkg/platform/speech.d.ts

@@ -1,2 +1,24 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-export declare function gameSay(text: string): void;
+/**
+ * THE BROWSER'S SPEECH, lent by whoever holds the window (the composition root, from `host.win`). The same port
+ * `platform/tts` receives. `synth()` is asked at every utterance and may answer `null`: a browser without speech synthesis.
+ */
+export interface SpeechPort {
+    synth(): SpeechSynthesis | null;
+    utterance(text: string): SpeechSynthesisUtterance;
+}
+/** What the literacy voice reads: the browser's speech, and the master sound it obeys. */
+export interface GameVoice extends SpeechPort {
+    soundOn(): boolean;
+    volume(): number;
+}
+/**
+ * Says `text`, a word the game gives in `language` (BCP-47), with a voice of that language chosen by the rule narration's parts
+ * use (ADR-0243 §2): the exact tag, else a voice of the same language. REQUIRED, because an optional language would default to
+ * one, and that default — pt-BR whatever the page said — is what ADR-0243 §4 removed.
+ *
+ * 🔴 A DEVICE THAT LISTS VOICES AND NONE OF THE LANGUAGE says nothing (§3): a wrong accent is learned. A device that lists NONE
+ * yet — the browser fills the list late — is asked by the tag alone, and it picks its own voice for the language.
+ * Volume ×1.4 so the speech sits above the effects, capped at 1.
+ */
+export declare function gameSay(voice: GameVoice, text: string, language: string): void;

package/dist-pkg/platform/speech.js

@@ -1,34 +1,45 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-// platform/speech.ts — voz do LETRAMENTO (gameSay): fala pt-BR SEMPRE-ativa (independe do toggle 'Narração
-// (TTS)' do mixer), pela voz nativa do navegador. Escolhe uma voz pt-BR e evita pt-PT. Módulo-folha (só áudio).
-// O TTS do MENU (narrate/ttsSpeak + motores neurais Piper/Kokoro/…) é outro caminho, gated pelo mixer — fica no game.js.
-import { soundOn, volume } from './audio.js';
-function ptbrVoice() {
+// platform/speech.ts — the LITERACY voice (gameSay): speech that is ALWAYS on (independent of the mixer's narration toggle),
+// through the browser's native voice, in the language the game says its words are in (ADR-0243 §4). A helper that holds
+// nothing: it takes the browser's speech and the master sound as a parameter (ADR-0232 D4, erratum D3 point 2).
+// The MENU's TTS (narrate/ttsSpeak and the Kokoro neural engine) is another path, gated by the mixer — `platform/tts`.
+import { voiceOfLanguage } from './voice-plan.js';
+/** The device's voices, or none where the browser has not listed them yet or throws. */
+function listedVoices(ss) {
     try {
-        const vs = (window.speechSynthesis && window.speechSynthesis.getVoices()) || [];
-        if (!vs.length)
-            return null;
-        return vs.find((v) => /pt[-_]?br/i.test(v.lang)) || vs.find((v) => /pt/i.test(v.lang) && /bras|brazil/i.test(v.name)) || vs.find((v) => /pt/i.test(v.lang) && !/pt[-_]?pt/i.test(v.lang)) || null;
+        return ss.getVoices() || [];
     }
     catch (e) {
-        return null;
+        return [];
     }
 }
-// FORÇA pt-BR (não usa a voz do mixer, que pode ser pt-PT). Volume ×1.4 para a fala soar acima dos efeitos.
-export function gameSay(text) {
-    if (!text || !soundOn)
+/**
+ * Says `text`, a word the game gives in `language` (BCP-47), with a voice of that language chosen by the rule narration's parts
+ * use (ADR-0243 §2): the exact tag, else a voice of the same language. REQUIRED, because an optional language would default to
+ * one, and that default — pt-BR whatever the page said — is what ADR-0243 §4 removed.
+ *
+ * 🔴 A DEVICE THAT LISTS VOICES AND NONE OF THE LANGUAGE says nothing (§3): a wrong accent is learned. A device that lists NONE
+ * yet — the browser fills the list late — is asked by the tag alone, and it picks its own voice for the language.
+ * Volume ×1.4 so the speech sits above the effects, capped at 1.
+ */
+export function gameSay(voice, text, language) {
+    if (!text || !voice.soundOn())
         return;
     try {
-        const ss = window.speechSynthesis;
+        const ss = voice.synth();
         if (!ss)
             return;
         ss.cancel();
-        const u = new SpeechSynthesisUtterance(text);
-        u.lang = 'pt-BR';
-        const v = ptbrVoice();
+        const listed = listedVoices(ss);
+        const own = voiceOfLanguage(language, listed.map((v) => ({ locale: v.lang.replace('_', '-'), engine: 'webspeech', voice: v.name })));
+        if (listed.length && !own)
+            return;
+        const u = voice.utterance(text);
+        u.lang = language;
+        const v = listed.find((x) => x.name === own?.voice);
         if (v)
             u.voice = v;
-        u.volume = Math.min(1, volume * 1.4);
+        u.volume = Math.min(1, voice.volume() * 1.4);
         ss.speak(u);
     }
     catch (e) { /* noop */ }

package/dist-pkg/platform/storage-keys.d.ts

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * The full name of a key in the GAME's scope.
+ *
+ * ⚠️ THE ID COMES IN AS AN ARGUMENT; it was once a constant. By ADR-0080's test — *would a second game want a different
+ * value here?* — the answer is yes, at once: two games in the same browser profile collided on every game-scoped key, and
+ * one overwrote the other's progress with no error at all.
+ *
+ * ⚠️ AND THE ID DOES NOT COME FROM THE DECLARATION, the obvious design. It cannot: a game's state is read before any
+ * `createGame()`, so an id from the declaration would arrive after the keys were resolved — against nothing, in silence.
+ * Whoever knows its own id is the GAME, which passes it as its own constant; ADR-0080 forbids the ENGINE from knowing it,
+ * not the game.
+ */
+export declare function gameKey(gameId: string, keyName: string): string;
+export declare const KEYS: {
+    onebtn: string;
+    wheelchair: string;
+    modocego: string;
+    caneDiv: string;
+    hearingloss: string;
+    activity: (gameId: string) => string;
+    activityLegado: string;
+    quizlevel: (gameId: string) => string;
+    quizlevelLegado: string;
+    cenario: (gameId: string) => string;
+    cenarioLegado: string;
+    tabsel: (gameId: string) => string;
+    tabselLegado: string;
+    fracnot: (gameId: string) => string;
+    fracnotLegado: string;
+    viz: string;
+    lq: string;
+    cbsafe: string;
+    ownercolors: string;
+    outfg: string;
+    outbg: string;
+    hcrole: string;
+    juice: string;
+    crt: string;
+    crtLegacy: string;
+    ttsEngine: string;
+    ttsVoice: string;
+    ttsVoz: string;
+    lang: string;
+    letterCase: string;
+    captions: string;
+    tea: string;
+    menuIndex: string;
+    fontKey: string;
+    padDesign: string;
+    padDir: string;
+    touchmap: string;
+    padBtnMm: string;
+    padGapMm: string;
+    padStickMm: string;
+    padTravelMm: string;
+    padDpadMm: string;
+    reducedMotion: string;
+    toggleMoveLegacy: string;
+    /**
+     * @deprecated ⚠️ THE LEGACY visual-mode KEY — ONE value, from when only one fitted (issue #104).
+     *
+     * It is still READ, which is what keeps the child from losing what they chose; it is still WRITTEN while the controls
+     * write one value at a time, because an old reader does `if (v && VIZ_BY_KEY[v])` and would reject a JSON — writing
+     * the new shape HERE would erase their setting in silence, exactly the defect the migration exists not to commit.
+     */
+    vizP: (i: number) => string;
+    /**
+     * The two-axis VISUAL STATE, in JSON (ADR-0076, issue #104).
+     *
+     * ⚠️ A NEW KEY BESIDE THE OLD ONE, not the same key with new content. The same design as the `visual` field beside
+     * `viz`: both shapes coexist while both have readers, each reads the one it understands, and the old one dies only
+     * when nobody reads it. `migrateVisual` accepts both, so the fallback — new key absent, old key present — returns
+     * exactly what the child chose.
+     */
+    visualP: (i: number) => string;
+    sinkP: (i: number) => string;
+    easyP: (i: number) => string;
+    /**
+     * ⚠️ THE TWO BELOW ARE LEGACY KEYS (ADR-0104 §C, issue #114). They are still READ — it is the child's setting, and
+     * inheriting it keeps them from losing it — and never written again. What is written is the key WITH A TRANSPORT,
+     * because the toggle belongs to the DEVICE and not the person: turning it on for the touch pad, where nobody holds a
+     * virtual button comfortably, turned it on for the keyboard too, where holding a key is exactly what the child can do.
+     *
+     * ⚠️ AND THE NEW KEY DOES NOT LIVE HERE, on purpose. It is `latchKey`, in `input/latch-scope` — `platform/` does not
+     * import `input/`, the layer above. Building it here would need either a backwards edge or a second copy of the name.
+     * Whoever owns the name is whoever knows the transport rule.
+     */
+    toggleMoveP: (i: number) => string;
+    toggleRunP: (i: number) => string;
+    rmWalkP: (i: number) => string;
+    rmBreathP: (i: number) => string;
+    rmFlavorP: (i: number) => string;
+    attract: (gameId: string, scenery: string) => string;
+    attractLegado: (scenery: string) => string;
+};

package/dist-pkg/platform/storage-keys.js

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/storage-keys.ts — THE NAMES OF WHAT IS STORED: the register of known keys and the rule that scopes a game's key.
+//
+// 📌 A STATELESS MODULE ON PURPOSE (ADR-0232, issue #207): a key is a string, and a module that only needs the NAME must not
+// import `platform/storage`, which reaches `localStorage`, to get it. `input/touch` and `ui/settings-mobility` read and write
+// through an injected store and import only these names.
+//
+// 📌 WHY `platform/` AND NOT `core/` (ADR-0173): the table names places in the browser's persistent storage, and every module
+// that reads it is at `platform` or above — the storage itself, the input, the renderer, the panels, and the games. `core/`
+// reaches storage only through the port `core/state.createSettingsStore` receives (ADR-0178), which carries the keys it needs; putting
+// the table in `core/` would invite the core to name storage places again, the dependency ADR-0178 took out.
+//
+// 📌 THIS IS THE ONLY HOME OF `KEYS` (ADR-0232 D2b): `platform/storage` is a factory now and publishes no key table. The
+// port `core/state.createSettingsStore` receives carries the table beside the store — the root passes `{ ...store, KEYS }`.
+/**
+ * The full name of a key in the GAME's scope.
+ *
+ * ⚠️ THE ID COMES IN AS AN ARGUMENT; it was once a constant. By ADR-0080's test — *would a second game want a different
+ * value here?* — the answer is yes, at once: two games in the same browser profile collided on every game-scoped key, and
+ * one overwrote the other's progress with no error at all.
+ *
+ * ⚠️ AND THE ID DOES NOT COME FROM THE DECLARATION, the obvious design. It cannot: a game's state is read before any
+ * `createGame()`, so an id from the declaration would arrive after the keys were resolved — against nothing, in silence.
+ * Whoever knows its own id is the GAME, which passes it as its own constant; ADR-0080 forbids the ENGINE from knowing it,
+ * not the game.
+ */
+export function gameKey(gameId, keyName) { return 'incl.' + gameId + '.' + keyName; }
+// The register of known keys (documentation in ONE place; the source of truth is still their use). Keys taking an
+// argument are parameterised by player, scenery or game. The two scopes — the CHILD's `incl_*` and the GAME's
+// `incl.<game>.*` — are explained in `platform/storage`.
+export const KEYS = {
+    // motor/hearing empathy
+    onebtn: 'incl_onebtn', wheelchair: 'incl_wheelchair', modocego: 'incl_modocego', caneDiv: 'incl_cane_div',
+    hearingloss: 'incl_hearingloss',
+    // activity / quiz / scenery — the GAME's SCOPE (see the two scopes in `platform/storage`). `*Legado` is the old name, which
+    // the read inherits from once; the write goes to the new one only.
+    //
+    // ⚠️ THEY ARE FUNCTIONS OF THE GAME'S ID, and the child's are strings. The difference of SHAPE is what prevents the
+    // mistake: a child's preference cannot be prefixed by accident, because it has nowhere to take the id — and a
+    // play-through's key cannot be left unscoped, because without the argument it does not compile. The rule that once
+    // lived only in a comment lives in the type.
+    activity: (gameId) => gameKey(gameId, 'activity'), activityLegado: 'incl_activity',
+    quizlevel: (gameId) => gameKey(gameId, 'quizlevel'), quizlevelLegado: 'incl_quizlevel',
+    cenario: (gameId) => gameKey(gameId, 'cenario'), cenarioLegado: 'incl_cenario',
+    tabsel: (gameId) => gameKey(gameId, 'tabsel'), tabselLegado: 'incl_tabsel',
+    fracnot: (gameId) => gameKey(gameId, 'fracnot'), fracnotLegado: 'incl_fracnot',
+    // visual / contrast / colour
+    viz: 'incl_viz', lq: 'incl_lq', cbsafe: 'incl_cbsafe', ownercolors: 'incl_ownercolors',
+    outfg: 'incl_outfg', outbg: 'incl_outbg', hcrole: 'incl_hcrole', juice: 'incl_juice', crt: 'incl_crt2',
+    crtLegacy: 'incl_crt', // the old (boolean) format; render/crt migrates it to incl_crt2 on the first read
+    // audio / voice / i18n
+    ttsEngine: 'incl_tts_engine', ttsVoice: 'incl_tts_voice', ttsVoz: 'incl_tts_voz', lang: 'incl_lang', // audiocat_{k}
+    // communication / captions (ADR-0028: every panel persists)
+    letterCase: 'incl_lettercase', captions: 'incl_captions',
+    // ⚠️ THE AUTISM-SUPPORT LEVEL (calm / quiet) PERSISTS. It used not to: the extraction from the monolith PRESERVED "never
+    // written to storage" verbatim, which is not the same as deciding it. The cost fell on the child who needs it most —
+    // whoever uses quiet mode set it again every session, and unexpected noise costs them most. ADR-0028: every panel persists.
+    tea: 'incl_tea',
+    menuIndex: 'incl_menuindex', // the "6 of 10" at the end of an item's announcement (ADR-0044, item 3)
+    // typography / controls / touch
+    fontKey: 'incl_font_k', padDesign: 'incl_paddesign', padDir: 'incl_paddir', touchmap: 'incl_touchmap',
+    padBtnMm: 'incl_padbtnmm', padGapMm: 'incl_padgapmm', padStickMm: 'incl_padstickmm',
+    padTravelMm: 'incl_padtravelmm', padDpadMm: 'incl_paddpadmm',
+    // reduced motion (the whole object in one JSON) + the old toggle-movement key, still read once to migrate whoever came
+    // from the previous version
+    reducedMotion: 'inclusionist.reducedmotion.v1', toggleMoveLegacy: 'inclusionist.togglemove',
+    // PER PLAYER — parameterised by the screen's index. As functions here, no call site can write a crooked name.
+    /**
+     * @deprecated ⚠️ THE LEGACY visual-mode KEY — ONE value, from when only one fitted (issue #104).
+     *
+     * It is still READ, which is what keeps the child from losing what they chose; it is still WRITTEN while the controls
+     * write one value at a time, because an old reader does `if (v && VIZ_BY_KEY[v])` and would reject a JSON — writing
+     * the new shape HERE would erase their setting in silence, exactly the defect the migration exists not to commit.
+     */
+    vizP: (i) => 'incl_viz_p' + i,
+    /**
+     * The two-axis VISUAL STATE, in JSON (ADR-0076, issue #104).
+     *
+     * ⚠️ A NEW KEY BESIDE THE OLD ONE, not the same key with new content. The same design as the `visual` field beside
+     * `viz`: both shapes coexist while both have readers, each reads the one it understands, and the old one dies only
+     * when nobody reads it. `migrateVisual` accepts both, so the fallback — new key absent, old key present — returns
+     * exactly what the child chose.
+     */
+    visualP: (i) => 'incl_visual_p' + i,
+    sinkP: (i) => 'incl_sink_p' + i,
+    easyP: (i) => 'incl_easy_p' + i,
+    /**
+     * ⚠️ THE TWO BELOW ARE LEGACY KEYS (ADR-0104 §C, issue #114). They are still READ — it is the child's setting, and
+     * inheriting it keeps them from losing it — and never written again. What is written is the key WITH A TRANSPORT,
+     * because the toggle belongs to the DEVICE and not the person: turning it on for the touch pad, where nobody holds a
+     * virtual button comfortably, turned it on for the keyboard too, where holding a key is exactly what the child can do.
+     *
+     * ⚠️ AND THE NEW KEY DOES NOT LIVE HERE, on purpose. It is `latchKey`, in `input/latch-scope` — `platform/` does not
+     * import `input/`, the layer above. Building it here would need either a backwards edge or a second copy of the name.
+     * Whoever owns the name is whoever knows the transport rule.
+     */
+    toggleMoveP: (i) => 'incl_togglemove_p' + i,
+    toggleRunP: (i) => 'incl_togglerun_p' + i, // the RUN-button toggle (the movement one's sibling)
+    rmWalkP: (i) => 'incl_rmWalk_p' + i,
+    rmBreathP: (i) => 'incl_rmBreath_p' + i,
+    rmFlavorP: (i) => 'incl_rmFlavor_p' + i,
+    // demo/attract: one recording per scenery (a function, not a string — a parameterised key). The GAME's SCOPE: the
+    // recording is of a level of THIS game and means nothing in another.
+    attract: (gameId, scenery) => gameKey(gameId, 'attract_' + scenery),
+    attractLegado: (scenery) => 'incl_attract_' + scenery,
+};

package/dist-pkg/platform/storage.d.ts

@@ -1,117 +1,52 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
-export declare function get(key: string, fallback: string): string;
-export declare function get(key: string, fallback?: null): string | null;
-export declare function set(key: string, value: string | number | boolean): boolean;
-export declare function remove(key: string): void;
-export declare function getBool(key: string, fallback?: boolean): boolean;
-export declare function setBool(key: string, on: boolean): void;
-export declare function getNum(key: string, fallback?: number): number;
-export declare function getJSON<T = unknown>(key: string, fallback?: T | null): T | null;
-export declare function setJSON(key: string, obj: unknown): void;
 /**
- * Nome completo de uma chave do escopo DO JOGO.
- *
- * ⚠️ O ID ENTRA COMO ARGUMENTO, e ele já foi uma constante aqui (`JOGO_ID = 'inclusionist'`). Pelo teste do
- * ADR-0080 — *um segundo jogo quereria um valor diferente aqui?* — a resposta é sim e é imediata: dois jogos
- * no mesmo perfil de navegador colidiam em `activity`, `quizlevel`, `cenario`, `tabsel`, `fracnot` e em toda
- * gravação `attract_*`. Um sobrescrevia o progresso do outro sem erro nenhum.
+ * What the store wraps: the three methods of the Web Storage API it calls. A window's `localStorage` has this shape, and so
+ * does `memoryBackend()` — which is how a test, or a second root on the same page, gets storage nobody else writes.
+ */
+export interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/** The store every persisting module receives: typed reads with a fallback, writes that never throw. */
+export interface Store {
+    get(key: string, fallback: string): string;
+    get(key: string, fallback?: null): string | null;
+    /** `false` when the backend refused the write (quota, private mode, no storage at all). */
+    set(key: string, value: string | number | boolean): boolean;
+    remove(key: string): void;
+    getBool(key: string, fallback?: boolean): boolean;
+    setBool(key: string, on: boolean): void;
+    getNum(key: string, fallback?: number): number;
+    getJSON<T = unknown>(key: string, fallback?: T | null): T | null;
+    setJSON(key: string, obj: unknown): void;
+    /**
+     * Reads the NEW key; if it does not exist yet, inherits the LEGACY one's value. Read-only: whoever writes, writes to the
+     * new one. It is what lets a key be renamed without a migration step and without anyone losing a setting.
+     */
+    getWithLegacy(newKey: string, legacyKey: string, fallback: string): string;
+    getWithLegacy(newKey: string, legacyKey: string, fallback?: null): string | null;
+    /** `getWithLegacy`'s pair for a JSON value — the inheritance has to hold for both formats, or half the keys migrate and
+     *  the other half vanish, the worst of both worlds. */
+    getJsonWithLegacy<T = unknown>(newKey: string, legacyKey: string, fallback?: T | null): T | null;
+}
+/**
+ * THE STORE, built around the backend it is GIVEN (ADR-0232). `null` is a host with no storage at all: every read gives its
+ * fallback and every write reports `false` — the same answer a throwing `localStorage` gives, so the two cannot differ.
  *
- * ⚠️ E O ID NÃO VEM DA DECLARAÇÃO, que era o desenho óbvio. Ele não pode: `game/state` lê o armazenamento no
- * IMPORT, e o import corre antes de qualquer `createGame()`. Um id vindo da declaração chegaria depois de as
- * três chaves já terem sido resolvidas — contra vazio, e em silêncio. Quem sabe o próprio id é o JOGO, que o
- * passa como constante sua; o ADR-0080 proíbe a ENGINE de o saber, não o jogo.
+ * 📌 CLOSURES AND NOT METHODS ON `this`: `loadLocale({ ...store, ...hooks })` spreads the store into another object, and a
+ * method that read `this` would lose its backend in the spread.
  */
-export declare function kJogo(jogo: string, nome: string): string;
+export declare function createStorage(backend: StorageLike | null): Store;
 /**
- * Lê a chave NOVA; se ela ainda não existe, herda o valor da LEGADA. Só de leitura: quem grava, grava na nova.
- * É o que permite renomear chave sem um passo de migração e sem perder o ajuste de ninguém.
+ * A backend kept in memory, seeded with `entries` — for a host with no storage worth writing to, and for a test: a file that
+ * builds its own cannot inherit another file's keys nor race it for them (ADR-0232 driver D4, the browser suite's F9).
  */
-export declare function getComLegado(nova: string, legada: string, fallback: string): string;
-export declare function getComLegado(nova: string, legada: string, fallback?: null): string | null;
-/** O par de `getComLegado` para valor em JSON — a herança tem de valer para os dois formatos, senão metade
- *  das chaves migra e a outra metade some, que é o pior dos dois mundos. */
-export declare function getJSONComLegado<T = unknown>(nova: string, legada: string, fallback?: T | null): T | null;
-export declare const KEYS: {
-    onebtn: string;
-    wheelchair: string;
-    modocego: string;
-    caneDiv: string;
-    hearingloss: string;
-    activity: (jogo: string) => string;
-    activityLegado: string;
-    quizlevel: (jogo: string) => string;
-    quizlevelLegado: string;
-    cenario: (jogo: string) => string;
-    cenarioLegado: string;
-    tabsel: (jogo: string) => string;
-    tabselLegado: string;
-    fracnot: (jogo: string) => string;
-    fracnotLegado: string;
-    viz: string;
-    lq: string;
-    cbsafe: string;
-    ownercolors: string;
-    outfg: string;
-    outbg: string;
-    hcrole: string;
-    juice: string;
-    crt: string;
-    crtLegacy: string;
-    ttsEngine: string;
-    ttsVoice: string;
-    lang: string;
-    letterCase: string;
-    captions: string;
-    tea: string;
-    menuIndex: string;
-    fontKey: string;
-    padDesign: string;
-    padDir: string;
-    touchmap: string;
-    padBtnMm: string;
-    padGapMm: string;
-    padStickMm: string;
-    padTravelMm: string;
-    padDpadMm: string;
-    reducedMotion: string;
-    toggleMoveLegacy: string;
-    /**
-     * @deprecated ⚠️ A CHAVE LEGADA do modo visual — UM valor, do tempo em que só cabia um (issue #104).
-     *
-     * Continua a ser LIDA, e é isso que impede a criança de perder o que já escolheu; continua a ser ESCRITA
-     * enquanto os controles ainda escreverem um valor de cada vez, porque um leitor antigo (o cartucho na
-     * versão publicada) faz `if (v && VIZ_BY_KEY[v])` e rejeitaria um JSON — escrever a forma nova AQUI
-     * apagaria o ajuste dela em silêncio, que é exactamente o defeito que a migração existe para não cometer.
-     */
-    vizP: (i: number) => string;
-    /**
-     * O ESTADO VISUAL de dois eixos, em JSON (ADR-0076, issue #104).
-     *
-     * ⚠️ CHAVE NOVA AO LADO DA VELHA, e não a mesma chave com conteúdo novo. É o mesmo desenho que o campo
-     * `visual` usa ao lado do `viz`: as duas formas coexistem enquanto houver leitores das duas, cada um lê a
-     * que entende, e a velha só morre quando não sobrar quem a leia. `migrarVisual` aceita as duas, então o
-     * recuo — chave nova ausente, chave velha presente — devolve exactamente o que a criança escolheu.
-     */
-    visualP: (i: number) => string;
-    sinkP: (i: number) => string;
-    easyP: (i: number) => string;
-    /**
-     * ⚠️ AS DUAS DE BAIXO SÃO AS CHAVES LEGADAS desde 2026-09-08 (ADR-0104 §C, issue #114). Continuam a ser
-     * LIDAS — é o ajuste da criança, e a herança dele é o que a impede de o perder — e não voltam a ser
-     * escritas. O que se escreve é a chave COM TRANSPORTE, porque a alternância é do APARELHO e não da pessoa:
-     * ligá-la no controle de tela, onde ninguém segura um botão virtual com conforto, ligava-a também no
-     * teclado, onde segurar uma tecla é exactamente o que a criança sabe fazer.
-     *
-     * ⚠️ E A CHAVE NOVA NÃO MORA AQUI, de propósito. Ela é `chaveDaAlternancia`, em `input/latch-scope` — este
-     * ficheiro é módulo-FOLHA e `platform/` não importa de `input/`, que é a camada acima. Montá-la aqui
-     * exigiria ou uma aresta ao contrário ou uma segunda cópia do nome, e a segunda cópia é exactamente o que
-     * o comentário do bloco acima existe para impedir. O dono do nome é quem conhece a regra do transporte.
-     */
-    toggleMoveP: (i: number) => string;
-    toggleRunP: (i: number) => string;
-    rmWalkP: (i: number) => string;
-    rmBreathP: (i: number) => string;
-    rmFlavorP: (i: number) => string;
-    attract: (jogo: string, cen: string) => string;
-    attractLegado: (cen: string) => string;
-};
+export declare function memoryBackend(entries?: Iterable<readonly [string, string]>): StorageLike;
+/**
+ * THE KEYS OUTSIDE EVERY ENGINE SCOPE (study item E2): not the child's `incl_*` (and the older `inclusionist.*`), not a
+ * game's `incl.<game>.*`. 📏 Measured: pinball stores `pinball:*`. ⚠️ A game's data stored in the CHILD's scope
+ * (chess's `incl_chess_*`) is not seen: the engine's own `incl_` keys are not one closed list, so that question would
+ * accuse the engine.
+ */
+export declare function keysOutsideScopes(storedKeys: Iterable<string>): string[];