@the-inclusionist/engine 10.0.0 → 11.0.0

package/dist-pkg/core/a11y-sr.d.ts

@@ -18,7 +18,7 @@ export interface Announcer {
     /** "Assertive" announcement (alert): interrupts and speaks now (errors, important warnings). */
     readonly alert: (text: string) => void;
     /**
-     * Sends every announcement of THIS announcer also to `sink` (the Libras interpreter's `say`), until the returned release
+     * Sends every announcement of THIS announcer also to `sink`, until the returned release
      * is called. One sink at a time: a second call replaces the first, and releasing a replaced sink changes nothing.
      */
     readonly mirrorTo: (sink: (text: string) => void) => () => void;

package/dist-pkg/core/a11y-sr.js

@@ -9,11 +9,9 @@
 // Now each root builds its own over the document and the frames its host lends. The factory stays PUBLISHED for a game
 // that must announce with no root at all — its boot failed before `createGame` returned (game-chess's rootless alert).
 //
-// THE LIBRAS MIRROR IS AN EXPLICIT SINK OF EACH ANNOUNCER, and nothing connects it by default. Today a game that wants
-// its announcements signed connects it (`Engine.mirrorAnnouncements(engine.libras.say)`); the games that do not, do not
-// sign — the behaviour before this factory, kept on purpose until the Dev decides (D4 decision DD1). Having the root
-// mirror everything is the one line `announcer.mirrorTo(libras.say)` in the root. The sink arrives by injection so this
-// core module never imports ui/ (ADR-0173).
+// THE MIRROR IS AN EXPLICIT SINK OF EACH ANNOUNCER, and nothing connects it by default. It was the Libras interpreter's
+// door; ADR-0234 closed that question (DD1): deaf mode signs what the sonar finds, when the child asks, and never the
+// announcements — so no queue of messages. The sink arrives by injection so this core module never imports ui/ (ADR-0173).
 const NO_MIRROR = () => { };
 export function createAnnouncer({ doc, raf }) {
     const nextFrame = (cb) => { if (raf)

package/dist-pkg/core/accommodations.d.ts

@@ -30,7 +30,10 @@ export declare const CONTRACT_KEYED: readonly ["visionSimulation", "audioDescrip
  * exact defect ADR-0145 was written about.
  */
 export declare const GAME_KEYED: readonly ["cameraSway", "easyMode", "wheelchairMode", "detectionLeniency", "intensity", "hints", "reducedCharacterMotion", "caneSpacing", "textPace", "lexicalDifficulty", "wordHighlight", "pieceSets", "distinguishableSuits", "timingWindow", "aimAssist", "repeatedInput", "ownerColors", "contrastOutlines"];
-/** What the child reads and hears for an accommodation: the name, and the sentence that explains it. */
+/**
+ * What the child reads and hears for an accommodation: the name, and the sentence that explains it — RESOLVED, in the page's
+ * language. A cartridge's ANSWER declares keys (`AccommodationKeys`), and `subjectWord` resolves them at every drawing.
+ */
 export interface AccommodationWord {
     /** «Wheelchair mode», «Board pieces». NEVER `wheelchairMode` — an id that reaches a person is a defect. */
     readonly label: string;
@@ -75,8 +78,21 @@ export declare function accommodationPresetProblems(p: AccommodationPreset | nul
 /** The accommodations only the game can answer. */
 export type GameKeyedAccommodation = (typeof GAME_KEYED)[number];
 /**
- * THE CARTRIDGE'S ANSWER, for every GAME_KEYED accommodation: its WORD when the accommodation has a subject in this
- * game, or `false` when it has none.
+ * What a cartridge DECLARES for an accommodation it has a subject for: the KEYS of its words in its own dictionary
+ * (`CreateGameOptions.dictionaries`). Keys and not words, so the row follows a language change (ADR-0232 D3, erratum of
+ * 2026-09-25; the rule and its measured defect are written on `core/actions.ActionKeys`).
+ */
+export interface AccommodationKeys {
+    /** The key of the name: «Wheelchair mode», «Board pieces». */
+    readonly labelKey: string;
+    /** The key of the SHORT form. Falls back to the name when absent. */
+    readonly shortKey?: string;
+    /** The key of the sentence the menu row explains itself with, in the footer (`CLAUDE.md` §4). */
+    readonly hintKey?: string;
+}
+/**
+ * THE CARTRIDGE'S ANSWER, for every GAME_KEYED accommodation: the KEYS of its word when the accommodation has a subject in
+ * this game, or `false` when it has none.
  *
  * 🔴 COMPLETE, NOT PARTIAL — and that is the difference from `AccommodationPreset`, and the decision. The Dev:
  * «Gênero não precisa responder todas as acomodações, mas sim o cartucho, obrigatoriamente.» A partial map lets
@@ -87,7 +103,7 @@ export type GameKeyedAccommodation = (typeof GAME_KEYED)[number];
  * always and CONTRACT_KEYED ones are derived from the contract, so neither is asked here — asking twice would let
  * the two answers disagree.
  */
-export type AccommodationAnswers = Readonly<Record<GameKeyedAccommodation, AccommodationWord | false>>;
+export type AccommodationAnswers = Readonly<Record<GameKeyedAccommodation, AccommodationKeys | false>>;
 /** Is it one of the accommodations the cartridge must answer? */
 export declare function isGameKeyed(x: unknown): x is GameKeyedAccommodation;
 /**
@@ -99,9 +115,11 @@ export declare function isGameKeyed(x: unknown): x is GameKeyedAccommodation;
  */
 export declare function accommodationAnswersProblems(a: unknown): string[];
 /**
- * Does this accommodation have a subject in this game? The question a panel asks before mounting a row.
+ * Does this accommodation have a subject in this game — and what is it called NOW? The question a panel asks before
+ * mounting a row, at every drawing.
  *
- * 📌 It returns the WORD, or `null` — never the id, never `true`: a row that mounts must have a name to show, and
- * «has a subject» without a word is the `action2` defect one level up.
+ * 📌 It returns the WORD, resolved through `word` (the root's translator, ADR-0232 D3), or `null` — never the id, never the
+ * key, never `true`: a row that mounts must have a name to show, and «has a subject» without a word is the `action2` defect
+ * one level up. A key the game's dictionaries lack is `null` here and a line of `problems` (`ui/declared-words`).
  */
-export declare function subjectWord(answers: AccommodationAnswers, k: GameKeyedAccommodation): AccommodationWord | null;
+export declare function subjectWord(answers: AccommodationAnswers, k: GameKeyedAccommodation, word: (key: string) => string | null): AccommodationWord | null;

package/dist-pkg/core/accommodations.js

@@ -21,7 +21,7 @@
 //   · GENERAL — there is text, sound, a screen and a menu in every game. The engine mounts these always.
 //   · CONTRACT_KEYED — the subject is answered by a declaration the contract ALREADY asks every game
 //     (`tick`, `holdsKeys()`, `needsPointer()`, `world()` × `topology()`, the players list). The engine can
-//     derive these without a genre, which is the `sonarPlayers` precedent: absent ⇒ derive from the contract.
+//     derive these without a genre, by the rule the engine keeps for what a contract already answers: absent ⇒ derive from the contract.
 //   · GAME_KEYED — nothing the engine holds answers it (genre, perspective, avatar, text, pieces, timing).
 //     The game — or the template of its genre — declares it.
 //
@@ -149,7 +149,7 @@ export function isGameKeyed(x) {
  */
 export function accommodationAnswersProblems(a) {
     if (a === null || a === undefined) {
-        return ['accommodations: missing - the cartridge must answer every game-keyed accommodation (ADR-0153): its word, or false'];
+        return ['accommodations: missing - the cartridge must answer every game-keyed accommodation (ADR-0153): the keys of its word, or false'];
     }
     if (!isKeyed(a))
         return [NOT_KEYED];
@@ -159,20 +159,37 @@ export function accommodationAnswersProblems(a) {
         : `accommodations: «${k}» is not in the catalogue - a game's own accommodation is an addition (ADR-0145 §2)`));
     return [...unanswered, ...strangers];
 }
-/** What is wrong with the cartridge's answer to ONE accommodation, or `null`: it must be written, and be `false` or a word. */
+/** What is wrong with the cartridge's answer to ONE accommodation, or `null`: it must be written, and be `false` or keys. */
 function answerProblem(answers, k) {
     if (!(k in answers))
-        return `accommodations: ${k} is not answered - write its word if it has a subject in this game, or false`;
+        return `accommodations: ${k} is not answered - write the keys of its word if it has a subject in this game, or false`;
     const v = answers[k];
-    return v === false || isWord(v) ? null : `accommodations: ${k} must be false or a word with a non-empty label`;
+    return v === false || isDeclared(v) ? null : `accommodations: ${k} must be false or { labelKey } naming a key of the game's dictionary`;
+}
+/** DECLARED KEYS: an object whose `labelKey` is text and not blank, and whose optional keys are text when present. */
+function isDeclared(v) {
+    if (!v || typeof v !== 'object')
+        return false;
+    const { labelKey, shortKey, hintKey } = v;
+    const optionalKey = (k) => k === undefined || typeof k === 'string';
+    return typeof labelKey === 'string' && labelKey.trim() !== '' && optionalKey(shortKey) && optionalKey(hintKey);
 }
 /**
- * Does this accommodation have a subject in this game? The question a panel asks before mounting a row.
+ * Does this accommodation have a subject in this game — and what is it called NOW? The question a panel asks before
+ * mounting a row, at every drawing.
  *
- * 📌 It returns the WORD, or `null` — never the id, never `true`: a row that mounts must have a name to show, and
- * «has a subject» without a word is the `action2` defect one level up.
+ * 📌 It returns the WORD, resolved through `word` (the root's translator, ADR-0232 D3), or `null` — never the id, never the
+ * key, never `true`: a row that mounts must have a name to show, and «has a subject» without a word is the `action2` defect
+ * one level up. A key the game's dictionaries lack is `null` here and a line of `problems` (`ui/declared-words`).
  */
-export function subjectWord(answers, k) {
+export function subjectWord(answers, k, word) {
     const v = answers[k];
-    return v && v.label.trim() ? v : null;
+    if (!v)
+        return null;
+    const label = word(v.labelKey);
+    if (!label || !label.trim())
+        return null;
+    const short = v.shortKey ? word(v.shortKey) : null;
+    const hint = v.hintKey ? word(v.hintKey) : null;
+    return { label, ...(short ? { short } : {}), ...(hint ? { hint } : {}) };
 }

package/dist-pkg/core/actions.d.ts

@@ -25,7 +25,10 @@ export declare const VERBS: readonly ["action1", "action2", "action3", "action4"
  * itself since 1983, and the child reads that legend before ours.
  */
 export declare const SYSTEM: readonly ["start", "select"];
-/** What the child reads and hears for a position: the name, and the sentence that explains it when they ask. */
+/**
+ * What the child reads and hears for a position: the name, and the sentence that explains it when they ask — RESOLVED, in
+ * the page's language. The engine builds these from the game's KEYS (`wordsOf`) each time it draws; a game declares keys.
+ */
 export interface ActionWord {
     /** "Jump", "Confirm", "Place piece". NEVER `action2` — an abstract name reaching a person is a defect. */
     readonly label: string;
@@ -45,14 +48,39 @@ export interface ActionWord {
     readonly hint?: string;
 }
 /**
- * The vocabulary of ONE game: for each position it uses, its word.
+ * What a game DECLARES for a position: the KEYS of its words in its own dictionary (`CreateGameOptions.dictionaries`).
+ *
+ * 🔴 KEYS AND NOT WORDS (ADR-0232 D3, erratum of 2026-09-25). A word handed over at boot is in the boot language forever:
+ * 📏 measured, a preset built with `t` in Portuguese still read «Acima» after `setLocale('en')`. A key is resolved by the
+ * root's translator each time the engine draws or speaks it, so changing the language changes every word at once
+ * (ADR-0225), and the game never needs to know how (ADR-0216).
+ */
+export interface ActionKeys {
+    /** The key of the name: «Jump», «Confirm». A key the game's dictionaries lack leaves the position unnamed, and `problems` says so. */
+    readonly labelKey: string;
+    /** The key of the SHORT name, for a legend under a glyph. Falls back to the name when absent. */
+    readonly shortKey?: string;
+    /** The key of the sentence that says what this button does, for the help and the remap screen. */
+    readonly hintKey?: string;
+}
+/**
+ * The vocabulary of ONE game: for each position it uses, the keys of its words.
  *
  * ⚠️ PARTIAL ON PURPOSE. A game declares ONLY the positions it uses. Requiring all fourteen would make a quiz invent a
  * name for a trigger it does not have, and an invented name ends up on a remap screen in front of a child.
  */
-export type ActionPreset = Partial<Readonly<Record<Action, ActionWord>>>;
+export type ActionPreset = Partial<Readonly<Record<Action, ActionKeys>>>;
+/** A preset RESOLVED into words, in the page's language — what the engine's surfaces read (`wordsOf`). */
+export type ActionWords = Partial<Readonly<Record<Action, ActionWord>>>;
 /** The positions this preset names, in the canonical order of `ACTIONS`. */
-export declare function presetActions(p: ActionPreset): Action[];
+export declare function presetActions(p: ActionPreset | ActionWords): Action[];
+/**
+ * THE GAME'S KEYS, RESOLVED NOW — called at every drawing, never kept (ADR-0232 D3 erratum).
+ *
+ * A position whose NAME resolves to nothing is left out, so every surface treats it as unnamed — the rule `labellerFrom`
+ * already applies: an absence is one step fewer, never a mute step, and never the key itself on screen.
+ */
+export declare function wordsOf(p: ActionPreset, word: (key: string) => string | null): ActionWords;
 /**
  * The question the engine asks the game when it has to SHOW an action: "what is this called?".
  *
@@ -68,22 +96,23 @@ export type ActionLabeller = (a: Action) => string;
  * the silent defect `speakableProblems` already chases elsewhere.
  *
  * It returns `null`, and the caller decides: the pad wizard DOES NOT ASK for an action the game does not name — if the
- * game does not use it, there is nothing to map. An absence becomes one step fewer, never a mute step.
+ * game does not use it, there is nothing to map. An absence becomes one step fewer, never a mute step. (`SYSTEM` is the
+ * exception there: the wizard asks START and SELECT in its own words, since no preset may name them — ADR-0144 erratum.)
  */
-export declare function labellerFrom(p: ActionPreset): (a: Action) => string | null;
+export declare function labellerFrom(p: ActionWords): (a: Action) => string | null;
 /**
  * The same, in the SHORT version — for a legend, where the word lives under a glyph.
  *
  * ⚠️ IT FALLS BACK TO `label`, and the fallback is the decision: a tight legend is worse than a neat one and better than
  * an empty one. Empty would also vanish for a screen reader user, which is the cost not accepted here.
  */
-export declare function shortLabellerFrom(p: ActionPreset): (a: Action) => string | null;
+export declare function shortLabellerFrom(p: ActionWords): (a: Action) => string | null;
 /**
  * Is a preset well formed? Returns the problems — EMPTY means conformant.
  *
- * ⚠️ WHAT IT CATCHES IS THE EMPTY LABEL, the same silent defect as `speakableProblems` in `core/contract`: a blank
- * `label` breaks nothing, warns nobody, and leaves the remap screen with a mute row — for a screen reader user, a button
- * that exists and has no name.
+ * ⚠️ WHAT IT CATCHES IS THE EMPTY KEY, the same silent defect as `speakableProblems` in `core/contract`: a blank
+ * `labelKey` breaks nothing, warns nobody, and leaves the remap screen with a mute row — for a screen reader user, a button
+ * that exists and has no name. Whether the key is IN the game's dictionaries is the root's question (`ui/declared-words`).
  */
 export declare function presetProblems(p: ActionPreset | null | undefined): string[];
 /**

package/dist-pkg/core/actions.js

@@ -59,6 +59,27 @@ export const SYSTEM = ['start', 'select'];
 export function presetActions(p) {
     return ACTIONS.filter((a) => p[a] !== undefined);
 }
+/** Resolves one declared key through `word`; a key that is not text resolves to nothing. */
+const resolved = (word, key) => (typeof key === 'string' && key.trim() ? word(key) : null);
+/**
+ * THE GAME'S KEYS, RESOLVED NOW — called at every drawing, never kept (ADR-0232 D3 erratum).
+ *
+ * A position whose NAME resolves to nothing is left out, so every surface treats it as unnamed — the rule `labellerFrom`
+ * already applies: an absence is one step fewer, never a mute step, and never the key itself on screen.
+ */
+export function wordsOf(p, word) {
+    const words = {};
+    for (const a of presetActions(p)) {
+        const keys = p[a];
+        const label = resolved(word, keys.labelKey);
+        if (!label)
+            continue;
+        const short = resolved(word, keys.shortKey);
+        const hint = resolved(word, keys.hintKey);
+        words[a] = { label, ...(short ? { short } : {}), ...(hint ? { hint } : {}) };
+    }
+    return words;
+}
 /**
  * Builds the translator from a preset.
  *
@@ -67,7 +88,8 @@ export function presetActions(p) {
  * the silent defect `speakableProblems` already chases elsewhere.
  *
  * It returns `null`, and the caller decides: the pad wizard DOES NOT ASK for an action the game does not name — if the
- * game does not use it, there is nothing to map. An absence becomes one step fewer, never a mute step.
+ * game does not use it, there is nothing to map. An absence becomes one step fewer, never a mute step. (`SYSTEM` is the
+ * exception there: the wizard asks START and SELECT in its own words, since no preset may name them — ADR-0144 erratum.)
  */
 export function labellerFrom(p) {
     return (a) => {
@@ -93,9 +115,9 @@ export function shortLabellerFrom(p) {
 /**
  * Is a preset well formed? Returns the problems — EMPTY means conformant.
  *
- * ⚠️ WHAT IT CATCHES IS THE EMPTY LABEL, the same silent defect as `speakableProblems` in `core/contract`: a blank
- * `label` breaks nothing, warns nobody, and leaves the remap screen with a mute row — for a screen reader user, a button
- * that exists and has no name.
+ * ⚠️ WHAT IT CATCHES IS THE EMPTY KEY, the same silent defect as `speakableProblems` in `core/contract`: a blank
+ * `labelKey` breaks nothing, warns nobody, and leaves the remap screen with a mute row — for a screen reader user, a button
+ * that exists and has no name. Whether the key is IN the game's dictionaries is the root's question (`ui/declared-words`).
  */
 export function presetProblems(p) {
     if (!p)
@@ -110,8 +132,8 @@ export function presetProblems(p) {
     }
     for (const a of named) {
         const w = p[a];
-        if (!w || !w.label || !w.label.trim()) {
-            problemas.push(`preset: ${a} has an empty label - the remap screen would show a nameless button`);
+        if (!w || typeof w.labelKey !== 'string' || !w.labelKey.trim()) {
+            problemas.push(`preset: ${a} has an empty labelKey - the remap screen would show a nameless button`);
         }
     }
     return problemas;

package/dist-pkg/core/contract.d.ts

@@ -74,8 +74,6 @@ export interface Spot {
     readonly y: number;
     readonly z?: number;
 }
-/** The dimension the topology declares. `hotspots` has no space, so no dimension. */
-export declare function dimension(t: Topology): number;
 export type Role = 'hazard' | 'climb' | 'water' | 'goal' | 'gate' | 'key' | 'structure' | 'free';
 /**
  * ⚠️ `zenith` AND `nadir` EXIST BECAUSE `up`/`down` ALREADY MEAN TWO THINGS. `ACTIONS` (core/actions) has `up` and

package/dist-pkg/core/contract.js

@@ -27,8 +27,6 @@
 // ========================= EVIDENCE =========================
 // Each field was born from a REAL consumer that used to guess, and ADR-0030 records that "the contract is enough" only
 // becomes a result when TWO presets exist.
-/** The dimension the topology declares. `hotspots` has no space, so no dimension. */
-export function dimension(t) { return t.kind === 'hotspots' ? 0 : t.size.length; }
 /** Axis `i` of a point, for whoever walks dimensions instead of naming them. */
 function axis(s, i) { return i === 0 ? s.x : i === 1 ? s.y : (s.z ?? 0); }
 function topologyProblems(d) {

package/dist-pkg/core/i18n.d.ts

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
+/** One language's dictionary: a key and its text. */
 type LocaleDict = Record<string, string>;
+/** The languages a page can switch to — a constant, so it stays a function of the module (ADR-0232 D3). */
+export declare function availableLocales(): string[];
 /**
  * The port the chosen language is kept through (ADR-0178): `platform/storage` has this shape.
  *
- * 🔴 AND IT CARRIES THE BROWSER TOO, since 2026-09-22 (ADR-0221 step 7g). This module used to write
- * `document.documentElement.lang`, dispatch on `window` and read `navigator.language` — three reaches into globals from
- * `core`, the layer ADR-0173 defines as «what the engine IS, without a browser». The health ratchet measured them (step 7d)
- * and the Dev chose to split rather than to move the module: the decisions stay here, the page effects arrive as two
- * optional hooks that `platform/locale-host` builds and the composition root passes in.
+ * 🔴 AND IT CARRIES THE BROWSER TOO (ADR-0221 step 7g): the page effects arrive as optional hooks that
+ * `platform/locale-host` builds and the composition root passes in, so `core` reaches no `document` or `window`.
  *
- * ⚠️ Both are OPTIONAL, and absent they mean «no page to tell»: a node test, a worker, a second engine in the same process.
- * Before this split those three lines threw there instead.
+ * ⚠️ The hooks are OPTIONAL, and absent they mean «no page to tell»: a node test, a worker, a second engine in the same
+ * process.
  */
 export interface LocalePort {
     get(key: string, fallback: string | null): string | null;
@@ -22,56 +22,21 @@ export interface LocalePort {
     readonly applied?: (locale: string, tag: string) => void;
     /** The language the host prefers when nothing is stored (the browser's `navigator.language`). */
     readonly preferred?: () => string | null;
+    /**
+     * Hears a language ANOTHER root on the same page switched to — the page's signal to its host (`i18n:change`).
+     * The LANGUAGE is the page's (`<html lang>` is one attribute), so every root follows it (ADR-0232 D3 erratum point 3).
+     */
+    readonly follow?: (react: (locale: string) => void) => void;
 }
-/** Gives this module the port for the chosen language; the composition root calls it before `initI18n`. */
-export declare function loadLocale(p: LocalePort): void;
-/**
- * Registers THIS game's keys for a language. Callable before the language exists — whoever registers `en` before any
- * `setLocale('en')` is served when the switch happens.
- *
- * ⚠️ IT DOES NOT RE-APPLY THE DOM, on purpose. `applyDom` needs a ROOT, and reaching the global `document` under the
- * caller's feet is a defect that already cost one fix. A consumer registering after the static markup was translated
- * calls `applyDom(root)` itself — and the normal case is to register at boot, before any text is on screen.
- */
-export declare function registerDict(code: string, entries: LocaleDict): string[];
 /** What a module that only TRANSLATES receives (ADR-0232 D3): a key and its `{param}`s in, the text of the page's language out. */
 export type Translate = (key: string, params?: Record<string, string | number>) => string;
-export declare function t(key: string, params?: Record<string, string | number>): string;
-export declare function getLocale(): string;
-export declare function bcp47(code?: string): string;
-declare function availableLocales(): string[];
-declare function applyDom(root: ParentNode): void;
-export declare function setLocale(code: string): Promise<void>;
-/**
- * Boot: applies pt (synchronously, so the page is never blank) and, if the preferred language is another, ASKS for the
- * switch — which is asynchronous, because the other locales are on-demand chunks.
- *
- * It still returns the locale synchronously and does NOT block on its own: whoever needs to wait calls `localeReady()`.
- *
- * `root` COMES IN instead of being read from the global: the composition root receives the host's document by
- * injection and had no way to pass it on while this line reached the global `document` under it. In a browser it is
- * the same; in the `node` project it is the difference between booting against a fake DOM and not booting.
- */
-export declare function initI18n(root: ParentNode): string;
+export declare function bcp47(code: string): string;
 /**
- * Resolves when the language chosen at boot has finished loading (at once, if it is pt).
+ * THE TRANSLATOR A ROOT BUILDS AND HANDS DOWN (ADR-0232 D3, and its errata).
  *
- * ========================= WHY THIS HAD TO EXIST =========================
- * When the language loaded LAST, after the HUD and the menus were built, pt cost nothing — and en/es cost half the
- * interface: `applyDom` fixes the STATIC markup (`data-i18n`), but what JavaScript builds had captured the pt text and
- * nobody rebuilt it. `t()` answered "City" and the button on screen said "Cidade".
- *
- * This answers the narrow question, which has one answer: the interface is not built before the language is known.
- * Switching language AT RUN TIME is a different question, answered by the redraw on `i18n:change` (ADR-0225).
- */
-export declare function localeReady(): Promise<void>;
-/**
- * THE TRANSLATOR A ROOT BUILDS AND HANDS DOWN (ADR-0232 D3, and its erratum of docs dac7a6d).
- *
- * The LANGUAGE is the page's — `<html lang>` is one attribute, so two roots in two languages would tell a screen reader one
- * of them wrongly — and it stays in this module. What a translator adds is the root's side: its `t`, its markup pass, and
- * the subscription to a change that its root can release. A module that only translates receives the bare `t`; one that
- * reads or sets the language receives this object.
+ * It holds everything that changes: the page's language as this root knows it, the dictionaries loaded, and the GAME's own
+ * dictionary, which no other root on the page reads. A module that only translates receives the bare `t`; one that reads or
+ * sets the language receives this object.
  */
 export interface Translator {
     readonly t: Translate;
@@ -79,12 +44,18 @@ export interface Translator {
     readonly locale: () => string;
     /** The BCP-47 tag of a language, the page's by default — what speech and recognition are given. */
     readonly bcp47: (code?: string) => string;
-    /** Switches the PAGE's language; every root on the page follows. */
+    /** Switches the PAGE's language; every root on the page follows (through the port's `follow`). */
     readonly setLocale: (code: string) => Promise<void>;
     /** Hears a language change; returns the release (the root passes this through its disposing door, ADR-0220). */
     readonly onChange: (react: (locale: string) => void) => () => void;
     /** Translates the declarative markup (`data-i18n`, `data-i18n-aria`) under `root`. */
     readonly applyDom: (root: ParentNode) => void;
+    /**
+     * Boot: translates `root` in pt (synchronously, so the page is never blank) and, if the stored or preferred language is
+     * another, ASKS for the switch — asynchronous, because the other locales are on-demand chunks. Returns the locale now;
+     * whoever needs to wait calls `ready()`. `root` comes in, never the global `document` (finding 15 of `boot/create-game`).
+     */
+    readonly init: (root: ParentNode) => string;
     /** Resolves when the language chosen at boot has loaded. */
     readonly ready: () => Promise<void>;
     /**
@@ -94,24 +65,18 @@ export interface Translator {
     readonly registerDict: (code: string, entries: LocaleDict) => string[];
     /** The keys this translator's game registered in one language and not another, for `problems` (study item E4). */
     readonly dictionaryGaps: () => string[];
+    /**
+     * A WORD THE GAME DECLARED, by its key (ADR-0232 D3 erratum of 2026-09-25): resolved in the page's language from THIS
+     * game's dictionary, falling back to its pt — and `null` when the game's dictionary has it in neither. Never the key: a
+     * key on screen is an identifier in front of a child. Whoever draws decides what an absent word means (a row not drawn).
+     */
+    readonly word: (key: string) => string | null;
+    /** Does this game's dictionary have `key` in any language? What `problems` asks of every declared key. */
+    readonly declares: (key: string) => boolean;
 }
 /**
- * Builds a translator, with a game dictionary of its OWN (ADR-0232 D3 erratum): what one root registers, another root on the
- * same page does not read. The language stays the page's.
- *
- * ⚠️ TRANSITIONAL: after its own dictionary it still reads the page-wide one that the module-level `registerDict` writes,
- * so a game that registers there before `createGame` keeps its words — until the Dev decides how a game translates what it
- * declares, and the module-level `t` and `registerDict` leave (issue #207).
+ * Builds a translator. `port` keeps the chosen language and tells the page (ADR-0178); without one there is no page to tell
+ * and nothing to keep, and `setLocale` refuses — a test that only translates needs none.
  */
-export declare function createTranslator(): Translator;
-declare const i18n: {
-    t: typeof t;
-    getLocale: typeof getLocale;
-    availableLocales: typeof availableLocales;
-    applyDom: typeof applyDom;
-    setLocale: typeof setLocale;
-    initI18n: typeof initI18n;
-    localeReady: typeof localeReady;
-    registerDict: typeof registerDict;
-};
-export default i18n;
+export declare function createTranslator(port?: LocalePort): Translator;
+export {};