@the-inclusionist/engine 10.0.0 → 11.0.0

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

@@ -44,8 +44,17 @@ export interface Audio {
     setHearingLossGraph(on: boolean): void;
     /** The pause and title silence everything; playing brings it back. Acts only if the master exists — never makes one. */
     setMasterMuted(muted: boolean): void;
-    /** The mixer's live state per category, loaded from the store when the audio is built. Mutated by the panels. */
+    /**
+     * The mixer's live state per category, loaded from the store when the audio is built. Written in place — `on`, `vol`, or the
+     * whole category — by the panels, the bar and any game, and EVERY write that changes a value is told to `onCatChange`.
+     */
     readonly audioCat: Record<string, CatState>;
+    /**
+     * Listens to every change of a category — its `on` or its `vol` — WHOEVER made it: the engine's panels and bar, and a game
+     * writing `audio.audioCat.tts.on = false` itself (ADR-0247). Called with the category's key, after the value changed; a write
+     * of the value already there is no change. Answers the function that stops listening.
+     */
+    onCatChange(listener: (cat: string) => void): () => void;
     /** A category's bus, hanging off the master node. */
     catNode(cat: string): GainNode | null;
     /** Moves a category's bus to its state now, and keeps that state in the store. */

package/dist-pkg/platform/audio.js

@@ -23,6 +23,32 @@ function buildHearingChain(ac) {
     sp.connect(ac.destination);
     return { input: lp };
 }
+/**
+ * THE CATEGORIES AS THE MIXER HOLDS THEM, each write heard (ADR-0247). A game reaches the mixer itself (`Engine.audio`), and
+ * its door to a category is a plain property write — `audioCat.tts.on = false` — with no call after it that an event could
+ * hang on. So the write IS the door: `on` and `vol` are accessors that tell `changed`, and so is the category itself, whose
+ * replacement (`audioCat.tts = {…}`) is copied INTO the mixer's object — replaced, the object every surface reads would come
+ * apart from the one the engine and the game write, and no later write would be heard.
+ */
+function heardCategories(stored, changed) {
+    const cats = {};
+    for (const [k, first] of Object.entries(stored)) {
+        let on = first.on, vol = first.vol;
+        const live = {};
+        Object.defineProperties(live, {
+            on: { enumerable: true, get: () => on, set: (v) => { if (v !== on) {
+                    on = v;
+                    changed(k);
+                } } },
+            vol: { enumerable: true, get: () => vol, set: (v) => { if (v !== vol) {
+                    vol = v;
+                    changed(k);
+                } } },
+        });
+        Object.defineProperty(cats, k, { enumerable: true, get: () => live, set: (v) => { live.on = v.on; live.vol = v.vol; } });
+    }
+    return cats;
+}
 /** The last node before the output: a panner clamped to the two ears when a pan is asked, the gain itself when not. */
 function panned(ac, g, pan) {
     if (pan == null || !ac.createStereoPanner)
@@ -42,8 +68,15 @@ export function createAudio(deps) {
     let hearingLoss = false;
     let masterGain = null, hlChain = null;
     let footCount = 0;
-    const audioCat = loadAudioCat(deps.store);
+    const catListeners = new Set();
+    // a copy of the listeners, so one that stops listening while it is told does not skip the next
+    const audioCat = heardCategories(loadAudioCat(deps.store), (cat) => { for (const l of [...catListeners])
+        l(cat); });
     const catNodes = {};
+    function onCatChange(listener) {
+        catListeners.add(listener);
+        return () => { catListeners.delete(listener); };
+    }
     function ensureAC() {
         if (!audioCtx)
             audioCtx = deps.newContext();
@@ -174,7 +207,7 @@ export function createAudio(deps) {
         get volume() { return volume; }, setVolume: (v) => { volume = v; },
         get audioCtx() { return audioCtx; }, ensureAC, audioOut,
         get hearingLoss() { return hearingLoss; }, setHearingLossGraph, setMasterMuted,
-        audioCat, catNode, setCatGain,
+        audioCat, onCatChange, catNode, setCatGain,
         tone, tonePan, noiseHit,
         get footCount() { return footCount; },
     };

package/dist-pkg/platform/choose-by-voice.d.ts

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import { type VoskDeps, type VoskLoad } from './vosk-runtime.js';
+import { type VoiceListenerDeps } from './voice-listener.js';
+/** What a choice gives back: the index of the option said, or `null`; what was heard; why it ended. */
+export interface ChoiceHeard {
+    readonly chosen: number | null;
+    readonly heard: string;
+    /** One option said · more than one said in one sentence · no option in time · asked to stop. */
+    readonly ended: 'chosen' | 'unclear' | 'timeout' | 'asked';
+}
+export interface ChooseSettings {
+    /** The language the options are in — the content's, when it is not the page's (ADR-0225). Default: the page's. */
+    readonly language?: string;
+    /** How long to wait for an option. Default 10 s: time to think, and a microphone that is never forgotten open. */
+    readonly maxMs?: number;
+    /**
+     * Called once, when the ear is OPEN and a word said now would be heard — at once when the 👄's ear is lent, after the model
+     * has loaded when one had to be opened. Before it, a game says «loading», not «say the answer»: the first choice in a language
+     * waits a few seconds for its model, and a child told to speak into that wait is not heard (the Dev, 2026-09-27).
+     */
+    readonly onListening?: () => void;
+}
+/** A recogniser listening with a grammar: it can be stopped, and it may say which words its model knows. */
+export interface OpenedChoice {
+    stop(): Promise<void>;
+    /** The words the language's model knows, when they can be read — an option with a word outside them can never be chosen. */
+    readonly vocabulary?: () => Promise<ReadonlySet<string> | null>;
+}
+export interface VoiceChooserDeps {
+    /** The page's language (`core/i18n.bcp47`). */
+    readonly language: () => string;
+    /**
+     * Opens the command recogniser for `language` with this grammar and the microphone, calling `onHeard` with every text it hears
+     * — `final` when the sentence ended. REJECTS, with the reason, when the model or the microphone cannot be had.
+     */
+    readonly open: (language: string, grammar: readonly string[], onHeard: (text: string, final: boolean) => void) => Promise<OpenedChoice>;
+    readonly after: (fn: () => void, ms: number) => unknown;
+    readonly cancel: (handle: unknown) => void;
+    /** A line for `problems`, written once per reason (ADR-0169). */
+    readonly report: (line: string) => void;
+    /**
+     * An ear ALREADY LISTENING in `language`, lent for this choice with the grammar given — the 👄's (`ui/voice-control.borrow`) — or
+     * `null`. Borrowed, nothing is opened and nothing paused: one model and one microphone, however many choices.
+     */
+    readonly borrow?: (language: string, grammar: readonly string[], onHeard: (text: string, final: boolean) => void) => OpenedChoice | null;
+    /** Called before an ear of its own is opened and after it is let go: the root pauses the 👄 in between (one ear per word). */
+    readonly pause?: () => void;
+    readonly resume?: () => void;
+}
+export interface VoiceChooser {
+    choose(options: readonly string[], settings?: ChooseSettings): Promise<ChoiceHeard>;
+    /** Ends the choice in hand now: it answers `null`, `ended: 'asked'`. */
+    stop(): void;
+}
+/** What opening the command recogniser for a choice uses of the delivery and the browser, lent by the root (ADR-0232 D4). */
+export type CommandRecogniserDeps = Omit<VoskDeps, 'language'> & Pick<VoiceListenerDeps, 'getUserMedia' | 'createContext'> & {
+    /** How a language's model is had — the root's `keepVoskModels(…).load`, so it is loaded once; default a fresh load. */
+    readonly load?: (d: VoskDeps) => Promise<VoskLoad>;
+};
+/**
+ * THE `open` A CHOOSER IS GIVEN WHERE THE COMMAND RECOGNISER IS THE EAR: the language's model from the delivery, then the
+ * microphone with the grammar. A model that opened for a microphone that did not is let go before the refusal travels.
+ */
+export declare function openWithCommandRecogniser(d: CommandRecogniserDeps): VoiceChooserDeps['open'];
+/**
+ * The options a sentence names, in the order said, each once: read word by word, the LONGEST option that starts at each word —
+ * so «cavalo marinho» is one option and not also «cavalo» — accents and case aside, whole words only.
+ */
+export declare function optionsNamed(options: readonly string[], sentence: string): number[];
+export declare function createVoiceChooser(d: VoiceChooserDeps): VoiceChooser;

package/dist-pkg/platform/choose-by-voice.js

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// platform/choose-by-voice — A CHILD ANSWERS BY SAYING ONE OF THE OPTIONS THE GAME SHOWS (ADR-0256).
+//
+// The game passes the options it is showing and gets back which one was said. The recogniser hears a grammar of exactly those
+// options plus `[unk]`, so it can only answer with one of them or with «none of these» — never with the nearest option to a word
+// that was not one. 📏 Why not the reading (Whisper): the lab measured it at 1 of 7 on words said alone, and an option is one or
+// two words; the command recogniser, closed, heard 7 of 7.
+//
+// 🔴 TWO OPTIONS IN ONE SENTENCE ARE NOT AN ANSWER (the quiz's own rule, which moved here with the matching): a child who says
+// «gato ou galinha» is thinking out loud, and picking one of them would answer FOR her — and mark it wrong. So the choice is
+// decided at the END of a sentence, never on its first word: one option chooses, two or more end the choice unanswered, none
+// goes on listening. 📏 It costs the end of the sentence — the lab measured 1.3 s after the word against 0.4 s on the partial.
+//
+// What this module decides, and nothing else: the grammar an option set becomes, which options a sentence names, when the
+// listening ends, and that one choice at a time holds the microphone. Opening the recogniser and the microphone is the root's
+// (`open`), which lends the delivery, the cache and the browser (ADR-0232 D4).
+import { spokenText, compareKey } from './speech-recognition.js';
+import { loadVoskRuntime } from './vosk-runtime.js';
+import { startVoiceListening } from './voice-listener.js';
+const MAX_MS = 10_000;
+/**
+ * THE `open` A CHOOSER IS GIVEN WHERE THE COMMAND RECOGNISER IS THE EAR: the language's model from the delivery, then the
+ * microphone with the grammar. A model that opened for a microphone that did not is let go before the refusal travels.
+ */
+export function openWithCommandRecogniser(d) {
+    return async (language, grammar, onHeard) => {
+        // a device with no microphone is refused before 31 MiB of model are opened for nothing
+        if (!d.getUserMedia)
+            throw new Error('this device cannot open a microphone');
+        const load = await (d.load ?? loadVoskRuntime)({ ...d, language });
+        if (!load.ok)
+            throw new Error(`${load.missing.join(', ')} not on this device`);
+        try {
+            const listening = await startVoiceListening({
+                model: load.model, grammar, getUserMedia: d.getUserMedia, createContext: d.createContext,
+                onPartial: (text) => onHeard(text, false), onFinal: (text) => onHeard(text, true),
+            });
+            return { stop: () => listening.stop(), ...(load.vocabulary ? { vocabulary: load.vocabulary } : {}) };
+        }
+        catch (e) {
+            load.model.terminate?.();
+            throw e;
+        }
+    };
+}
+/**
+ * The options a sentence names, in the order said, each once: read word by word, the LONGEST option that starts at each word —
+ * so «cavalo marinho» is one option and not also «cavalo» — accents and case aside, whole words only.
+ */
+export function optionsNamed(options, sentence) {
+    const keys = options.map((o) => compareKey(o).split(' ').filter(Boolean));
+    const said = compareKey(sentence).split(' ').filter(Boolean);
+    const named = [];
+    for (let i = 0; i < said.length;) {
+        let best = -1;
+        keys.forEach((k, o) => {
+            if (k.length && k.every((w, j) => said[i + j] === w) && (best < 0 || k.length > keys[best].length))
+                best = o;
+        });
+        if (best < 0) {
+            i += 1;
+            continue;
+        }
+        if (!named.includes(best))
+            named.push(best);
+        i += keys[best].length;
+    }
+    return named;
+}
+export function createVoiceChooser(d) {
+    const said = new Set();
+    const once = (kind, line) => { if (!said.has(kind)) {
+        said.add(kind);
+        d.report(line);
+    } };
+    let inFlight = null;
+    let askToStop = null;
+    /** An option with a word the model does not know can never be heard: said to the adult, once per option and language. */
+    const reportUnsayable = async (opened, options, language) => {
+        const known = await opened.vocabulary?.().catch(() => null);
+        if (!known)
+            return;
+        for (const option of options) {
+            const lacking = spokenText(option).split(' ').filter((w) => w && !known.has(w));
+            if (lacking.length) {
+                once(`unsayable:${language}:${option}`, `choosing by voice: the option "${option}" has ${lacking.length === 1 ? 'a word' : 'words'} `
+                    + `the ${language} speech model does not know (${lacking.map((w) => `"${w}"`).join(', ')}) — the child cannot choose it by saying `
+                    + 'it, only with the arrows; reword it with words the model knows (ADR-0256)');
+            }
+        }
+    };
+    const run = async (options, settings) => {
+        const language = settings.language ?? d.language();
+        const grammar = [...new Set(options.map((o) => spokenText(o)).filter(Boolean))];
+        let heard = '';
+        let settle = () => { };
+        const answer = new Promise((resolve) => { settle = resolve; });
+        const end = (chosen, ended) => settle({ chosen, heard, ended });
+        // asked to stop while the microphone is still opening counts too: it is let go as soon as it opens
+        askToStop = () => end(null, 'asked');
+        const onHeard = (text, final) => {
+            const clean = text.replace(/\[unk\]/g, ' ').replace(/\s+/g, ' ').trim();
+            // 🔴 THE END OF A SENTENCE IS WHAT WAS HEARD, even empty: a partial the recogniser took back («happy», then nothing) is not
+            // an answer to show the child — measured on 2026-09-27, the quiz said «I heard happy» for a word the model had withdrawn
+            if (final || clean)
+                heard = clean;
+            if (!final || !clean)
+                return;
+            const named = optionsNamed(options, clean);
+            if (named.length === 1)
+                end(named[0], 'chosen');
+            else if (named.length > 1)
+                end(null, 'unclear');
+        };
+        const borrowed = d.borrow?.(language, grammar, onHeard) ?? null;
+        if (!borrowed)
+            d.pause?.();
+        try {
+            let opened;
+            try {
+                opened = borrowed ?? await d.open(language, grammar, onHeard);
+            }
+            catch (e) {
+                const why = e instanceof Error ? e.message : String(e);
+                once(`open:${language}`, `choosing by voice: the recogniser did not open for ${language} (${why}) — the child cannot answer an `
+                    + `option by saying it; build the delivery with \`--commands ${language.split('-')[0]}\` and allow the microphone (ADR-0256)`);
+                throw e;
+            }
+            void reportUnsayable(opened, options, language);
+            // a game's listener that throws must not take the child's answer with it
+            try {
+                settings.onListening?.();
+            }
+            catch { /* the game's own line, not the choice */ }
+            const timer = d.after(() => end(null, 'timeout'), settings.maxMs ?? MAX_MS);
+            const result = await answer;
+            d.cancel(timer);
+            await opened.stop().catch(() => { });
+            return result;
+        }
+        finally {
+            askToStop = null;
+            if (!borrowed)
+                d.resume?.();
+        }
+    };
+    return {
+        choose(options, settings = {}) {
+            // one microphone, one choice: a second caller waits on the first
+            if (inFlight)
+                return inFlight;
+            inFlight = run(options, settings).finally(() => { inFlight = null; });
+            return inFlight;
+        },
+        stop() { askToStop?.(); },
+    };
+}

package/dist-pkg/platform/font-library.d.ts

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { HeavyFile } from './heavy-catalogue.js';
+/** One face of a family: one file, and what its `@font-face` rule says of it. */
+export interface LibraryFace {
+    readonly file: string;
+    /** A weight (`400`) or a variable range (`100 900`), as `font-weight` takes it. */
+    readonly weight: string;
+    readonly style: string;
+    /** A key of `FontLibrary.ranges`; absent = the file covers the whole family (an author's original, ADR-0254). */
+    readonly range?: string;
+    readonly bytes: number;
+    readonly sha256: string;
+    /** The author's original this file was compressed from, for a family with a Reserved Font Name (ADR-0254). */
+    readonly from?: string;
+}
+/** A family of the library: its folder in the mirror, the licence its fonts state, and its faces. */
+export interface LibraryFamily {
+    readonly folder: string;
+    readonly licence: string;
+    readonly faces: readonly LibraryFace[];
+}
+/** The catalogue: the mirror's address, the unicode-ranges the faces share, and the families by name. */
+export interface FontLibrary {
+    readonly mirror: string;
+    readonly ranges: Readonly<Record<string, string>>;
+    readonly families: Readonly<Record<string, LibraryFamily>>;
+}
+/** The heavy-file id of a face: `font:<folder>:<file>`. */
+export declare const libraryFaceId: (family: LibraryFamily, face: LibraryFace) => string;
+/**
+ * Each FILE of these families as a heavy file: its address, its bytes and the sha256 its body must have to be kept. Once each —
+ * a variable file may be declared at two weights, and is kept once.
+ */
+export declare function libraryFiles(library: FontLibrary, families: readonly string[]): HeavyFile[];
+/**
+ * The `@font-face` rules of these families, each `src` at `href(address)` — the delivery's `heavy/` path, resolved against the
+ * page, where the service worker answers from the checked cache. A face with no range covers the whole family (ADR-0254).
+ */
+export declare function libraryFaceRules(library: FontLibrary, families: readonly string[], href: (url: string) => string): string;
+/**
+ * THE FAMILIES A CARTRIDGE DECLARED (`uses.fonts`), less the engine's own — they are packaged, and declaring one asks for
+ * nothing. `problem` names a declaration that is not a list of family names, which the engine cannot read.
+ */
+export declare function declaredFamilies(value: unknown, engineFamilies: ReadonlySet<string>): {
+    readonly asked: string[];
+    readonly problem: string | null;
+};
+/** The line of `problems` for a declared family the library does not hold (ADR-0169: the subject, the cost, the fix). */
+export declare function unknownFamilyLine(family: string): string;
+/** What the root lends the library's start: where the rules go, how a delivery path becomes an address, and where lines go. */
+export interface LibraryFontsPorts {
+    /** The families declared, the engine's own left out (`declaredFamilies`). */
+    readonly asked: readonly string[];
+    /** Writes the rules into the document (a `<style>` of the root's). */
+    readonly declare: (css: string) => void;
+    /** An upstream address → the address the page asks for it at (`heavy/` under the page). */
+    readonly href: (url: string) => string;
+    /** A line of `problems`. */
+    readonly report: (line: string) => void;
+    /** The catalogue; `loadFontLibrary` unless a case hands its own. */
+    readonly load?: () => Promise<FontLibrary>;
+}
+/** What the start answers: the files to keep in the checked cache, and the listener that turns their refusals into lines. */
+export interface LibraryFontsStarted {
+    readonly files: readonly HeavyFile[];
+    readonly onReport: (r: {
+        readonly id: string;
+        readonly outcome: string;
+        readonly error?: string;
+    }) => void;
+}
+/**
+ * DECLARES THE ASKED FAMILIES' FACES, and answers the files to keep. A family the library does not hold is said in `problems`;
+ * a file the delivery did not carry, or whose sha256 differs, is said once per family when its report arrives. Never throws: a
+ * catalogue that does not load is one line, and the game plays in its stack's next face.
+ */
+export declare function startLibraryFonts(p: LibraryFontsPorts): Promise<LibraryFontsStarted>;

package/dist-pkg/platform/font-library.js

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/** Loads the catalogue — its own chunk, fetched from the page's origin the first time a cartridge declares a family. */
+async function loadFontLibrary() {
+    return (await import('./font-library.json')).default;
+}
+/** The address a face is kept under in the checked cache — the mirror's, as every heavy file's upstream address is. */
+function libraryFaceUrl(library, family, face) {
+    return `${library.mirror}/${family.folder}/${face.file}`;
+}
+/** The heavy-file id of a face: `font:<folder>:<file>`. */
+export const libraryFaceId = (family, face) => `font:${family.folder}:${face.file}`;
+/**
+ * Each FILE of these families as a heavy file: its address, its bytes and the sha256 its body must have to be kept. Once each —
+ * a variable file may be declared at two weights, and is kept once.
+ */
+export function libraryFiles(library, families) {
+    const files = families.flatMap((name) => {
+        const family = library.families[name];
+        return family ? family.faces.map((face) => ({
+            id: libraryFaceId(family, face), url: libraryFaceUrl(library, family, face), bytes: face.bytes, sha256: face.sha256,
+        })) : [];
+    });
+    return files.filter((f, i) => files.findIndex((g) => g.id === f.id) === i);
+}
+/**
+ * The `@font-face` rules of these families, each `src` at `href(address)` — the delivery's `heavy/` path, resolved against the
+ * page, where the service worker answers from the checked cache. A face with no range covers the whole family (ADR-0254).
+ */
+export function libraryFaceRules(library, families, href) {
+    return families.flatMap((name) => {
+        const family = library.families[name];
+        if (!family)
+            return [];
+        return family.faces.map((face) => {
+            const range = face.range ? `unicode-range:${library.ranges[face.range]};` : '';
+            return `@font-face{font-family:'${name}';font-style:${face.style};font-weight:${face.weight};font-display:swap;`
+                + `src:url('${href(libraryFaceUrl(library, family, face))}') format('woff2');${range}}`;
+        });
+    }).join('\n');
+}
+/**
+ * THE FAMILIES A CARTRIDGE DECLARED (`uses.fonts`), less the engine's own — they are packaged, and declaring one asks for
+ * nothing. `problem` names a declaration that is not a list of family names, which the engine cannot read.
+ */
+export function declaredFamilies(value, engineFamilies) {
+    if (value === undefined || value === null)
+        return { asked: [], problem: null };
+    if (!Array.isArray(value) || value.some((f) => typeof f !== 'string' || !f.trim())) {
+        return { asked: [], problem: `fonts: \`uses.fonts\` is ${JSON.stringify(value)}, not a list of family names — no library face was `
+                + 'loaded, so the text the game draws in them falls back to the next face of its stack; declare `uses: { fonts: [\'Lato\'] }`' };
+    }
+    return { asked: [...new Set(value.map((f) => f.trim()))].filter((f) => !engineFamilies.has(f)), problem: null };
+}
+/** The line of `problems` for a declared family the library does not hold (ADR-0169: the subject, the cost, the fix). */
+export function unknownFamilyLine(family) {
+    return `font «${family}»: the game declares it in \`uses.fonts\`, and the engine's font library has no such family — the text `
+        + 'the game draws in it falls back to the next face of its stack; declare a family the library holds '
+        + '(`platform/font-library.json`), or leave it out';
+}
+/** The line of `problems` for a declared family the delivery did not carry, or whose file was refused. */
+function undeliveredLine(family, error) {
+    return `font «${family}»: the game declares it in \`uses.fonts\`, and it was not kept (${error}) — the text the game draws in it `
+        + 'falls back to the next face of its stack, and on a day without a network the face is not there at all; build the delivery '
+        + `with \`inclusionist-heavy <folder> --fonts "${family}"\``;
+}
+/**
+ * DECLARES THE ASKED FAMILIES' FACES, and answers the files to keep. A family the library does not hold is said in `problems`;
+ * a file the delivery did not carry, or whose sha256 differs, is said once per family when its report arrives. Never throws: a
+ * catalogue that does not load is one line, and the game plays in its stack's next face.
+ */
+export async function startLibraryFonts(p) {
+    try {
+        const library = await (p.load ?? loadFontLibrary)();
+        const held = p.asked.filter((f) => library.families[f]);
+        for (const f of p.asked)
+            if (!library.families[f])
+                p.report(unknownFamilyLine(f));
+        if (held.length)
+            p.declare(libraryFaceRules(library, held, p.href));
+        const familyOf = new Map(held.flatMap((f) => library.families[f].faces.map((face) => [libraryFaceId(library.families[f], face), f])));
+        const said = new Set();
+        return {
+            files: libraryFiles(library, held),
+            onReport: (r) => {
+                const family = familyOf.get(r.id);
+                if (!family || r.outcome !== 'falhou' || said.has(family))
+                    return;
+                said.add(family);
+                p.report(undeliveredLine(family, r.error ?? 'refused'));
+            },
+        };
+    }
+    catch (e) {
+        for (const f of p.asked)
+            p.report(undeliveredLine(f, `the font catalogue did not load: ${e instanceof Error ? e.message : String(e)}`));
+        return { files: [], onReport: () => { } };
+    }
+}