@the-inclusionist/engine 10.0.0 → 11.0.0

package/dist-pkg/ui/libras-avatar-load.js

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// ui/libras-avatar-load — WHAT THE DELIVERY SHIPPED FOR THE FREE PLAYER, AND OPENING IT (ADR-0234, route B, phase B2).
+//
+// The half of `ui/libras-avatar-player` that talks to the delivery: where its files are, whether it shipped the avatar at all
+// (its manifest, which only `inclusionist-heavy --libras` writes), the canvas the avatar is drawn on, the stage built on it from
+// the avatar's bytes — within a time, or not at all — and the clips, each fetched and prepared once. Every answer is a value,
+// never a throw: a delivery without the avatar, a device without WebGL and a clip that cannot be read are reasons, which the
+// player hands to deaf mode and deaf mode to `problems` (ADR-0169).
+import { LIBRAS_GLOSSES_FILE } from './libras-glosses.js';
+import { LIBRAS_NOT_INSTALLED } from './vlibras.js';
+import { LIBRAS_AVATAR_FOLDER, LIBRAS_AVATAR_MANIFEST, avatarManifestOf } from './libras-avatar-plan.js';
+/**
+ * Why a delivery with no avatar cannot sign, and the fix (ADR-0169): the reason `NO_INTERPRETER` gives, word for word — the
+ * root's interpreter answers a delivery built without `--libras` exactly as a root with no player would.
+ */
+export const NOT_SHIPPED = LIBRAS_NOT_INSTALLED;
+/** Why a request that waited across a `hide()` or the root's end was not signed. */
+export const RELEASED = 'the interpreter was taken off the screen before it signed';
+/** The addresses under `base`, or `null` where it resolves nothing — a host whose document has no address finds no avatar. */
+export function avatarPlace(base, folder = LIBRAS_AVATAR_FOLDER) {
+    try {
+        const at = new URL(folder, base);
+        return { folder: at.href, manifest: new URL(LIBRAS_AVATAR_MANIFEST, at).href, glosses: new URL(LIBRAS_GLOSSES_FILE, at).href };
+    }
+    catch {
+        return null;
+    }
+}
+/** A JSON file of the delivery, or `null` — no fetch, no file, not JSON. */
+async function readJson(fetchFile, url) {
+    if (!fetchFile)
+        return null;
+    try {
+        const resp = await fetchFile(url);
+        return resp.ok ? await resp.json() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The delivery's manifest, or `null` for a delivery that did not ship the avatar. */
+export const readManifest = async (fetchFile, place) => avatarManifestOf(await readJson(fetchFile, place.manifest));
+/** The canvas the avatar is drawn on: the bottom right, in front of the screen, watched and never operated. */
+export function avatarCanvas(doc, title) {
+    const canvas = doc.createElement('canvas');
+    canvas.setAttribute('role', 'img');
+    canvas.setAttribute('aria-label', title);
+    canvas.tabIndex = -1; // the keyboard stays with the game
+    canvas.hidden = true;
+    Object.assign(canvas.style, {
+        position: 'fixed', right: '0', bottom: '0', width: 'max(25vw, 200px)', height: 'max(50vh, 200px)', border: '0',
+        background: 'transparent', pointerEvents: 'none', zIndex: '2147483000',
+    });
+    doc.body.append(canvas);
+    return canvas;
+}
+const reasonOf = (failure) => (failure instanceof Error ? failure.message : String(failure));
+async function build(canvas, o, wanted) {
+    const { fetchFile } = o; // called bare, as `FetchFile` says
+    if (!fetchFile)
+        return { reason: NOT_SHIPPED };
+    try {
+        const resp = await fetchFile(o.avatarUrl);
+        if (!resp.ok) {
+            return { reason: `the Libras avatar could not be read from the delivery (HTTP ${resp.status}) — build it again with `
+                    + '`inclusionist-heavy <folder> --libras`' };
+        }
+        const stage = await o.loadStage(canvas, await resp.arrayBuffer());
+        if (!wanted()) {
+            stage.dispose();
+            return { reason: RELEASED };
+        } // given up on or released meanwhile: nothing is kept
+        return { stage };
+    }
+    catch (failure) {
+        return { reason: `the Libras avatar cannot be drawn here: ${reasonOf(failure)}` };
+    }
+}
+/**
+ * Builds the stage on `canvas` from the delivery's avatar: the stage, or why not — an avatar the delivery cannot give, a device
+ * that cannot draw it, a load past `timeoutMs`. `wanted()` is asked when the stage arrives: false, and it is released at once.
+ * `cancel()` answers «released» now and clears the timer, so nothing of a released root outlives it.
+ */
+export function openAvatar(canvas, o, wanted) {
+    let answer = () => { };
+    const stopped = new Promise((resolve) => { answer = resolve; });
+    const timer = o.win.setTimeout(() => {
+        answer({ reason: `the Libras avatar did not load within ${Math.round(o.timeoutMs / 1000)} s` });
+    }, o.timeoutMs);
+    const done = Promise.race([build(canvas, o, wanted), stopped]).then((r) => { o.win.clearTimeout(timer); return r; });
+    return { done, cancel: () => { o.win.clearTimeout(timer); answer({ reason: RELEASED }); } };
+}
+const isClipJson = (data) => {
+    const c = data;
+    return !!c && typeof c.duration === 'number' && Array.isArray(c.tracks);
+};
+/**
+ * A clip's address under the avatar's folder, SPELLED AS A URL SPELLS ITS NAME — which is the address the delivery's list keeps it
+ * under offline (`libras/offline-avatar.json`, ADR-0234 phase B3). Escaping the name first (`&` as `%26`, as `encodeURIComponent`
+ * does) asks another address, which the server answers online and the checked cache never holds: PRIMEIRO&ORDINAL and
+ * SEGUNDO&ORDINAL went unsigned offline. 📌 No clip name carries `%`, `#`, `?` or `\`, which a URL reads as something other than
+ * a name — `tests/libras-avatar-delivery.node.test.js` holds that over the pins.
+ */
+const clipAddress = (file, folder) => new URL(file, folder).href;
+/**
+ * Makes each clip of `names` playable on `stage`, fetching the ones it has not got — once each, remembered in `ready` — and
+ * answers the names whose file could not be read or prepared.
+ */
+export async function prepareClips(stage, names, manifest, place, fetchFile, ready) {
+    const one = async (name) => {
+        const w = manifest.clips.get(name);
+        if (!w)
+            return false;
+        const json = await readJson(fetchFile, clipAddress(w.file, place.folder));
+        if (!isClipJson(json))
+            return false;
+        try {
+            stage.prepare(name, json, w.from);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const read = await Promise.all(names.map((name) => {
+        let loading = ready.get(name);
+        if (!loading) {
+            loading = one(name);
+            ready.set(name, loading);
+        }
+        return loading;
+    }));
+    return names.filter((_, i) => !read[i]);
+}

package/dist-pkg/ui/libras-avatar-plan.d.ts

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * Where the delivery puts the free player's avatar, clips, manifest and glosses, beside the game's page (`inclusionist-heavy --libras`):
+ * written in the catalogue, whose delivery list keeps these files offline (ADR-0234, phase B3), and re-exported here where the
+ * player and the delivery script already read it.
+ */
+export { LIBRAS_AVATAR_FOLDER } from '../platform/heavy-catalogue.js';
+/** The manifest the delivery writes in that folder: the avatar's file and every clip it carries, with its window. */
+export declare const LIBRAS_AVATAR_MANIFEST = "manifest.json";
+/**
+ * How long two clips overlap, fading one into the other, in seconds. Every clip is at least 1.2 s (📏 the 655 of the delivery:
+ * 1.2–7.1 s, median 2.47 s), and the overlap never exceeds half of either clip, so no clip is swallowed by its neighbours.
+ */
+export declare const CROSS_FADE_S = 0.3;
+/** One clip the delivery carries: its file under the folder, and the stretch of it that is played. */
+export interface ClipWindow {
+    readonly file: string;
+    /** The clip's length in seconds, as exported. */
+    readonly duration: number;
+    /**
+     * Where the sign starts, in seconds — 0 for every clip but one: the export of FALA begins at a stray keyframe 1404 frames
+     * before the sign (46.8 s at 30 fps), which the delivery's pins name, so the player plays from the sign and not from the stray.
+     */
+    readonly from: number;
+    /**
+     * Where the hand is held up, `[up, down]` in seconds of the played window — only for the clips a word is spelled with (a letter
+     * or a digit): a chained letter starts at `up` and hands over at `down`. E's is its whole clip. Absent, the clip plays whole.
+     */
+    readonly held?: readonly [number, number];
+}
+/** The delivery's manifest, read: the avatar's file and the clips by name. */
+export interface AvatarManifest {
+    readonly avatar: string;
+    readonly clips: ReadonlyMap<string, ClipWindow>;
+}
+/**
+ * The manifest the delivery wrote, or `null` for anything else — no file, a fallback page, another format: a delivery that did
+ * not ship the avatar. A clip entry of the wrong shape is left out, not trusted; a `held` of the wrong shape is dropped.
+ */
+export declare function avatarManifestOf(data: unknown): AvatarManifest | null;
+/** How long a clip plays: its window, from `from` to its end. */
+export declare const playedLength: (w: ClipWindow) => number;
+/**
+ * One clip to play: a sign, or a letter of a word being fingerspelled (`spells`, the word; `word`, its place in the gloss — two
+ * letters are of one word, and chained, only when both are the same).
+ */
+export interface SignStep {
+    readonly clip: string;
+    readonly spells?: string;
+    readonly word?: number;
+}
+/** A word the avatar could not sign: no clip of its own, and letters it has no clip for. */
+export interface UnsignedWord {
+    readonly word: string;
+    readonly missing: readonly string[];
+}
+export interface SignPlan {
+    readonly steps: readonly SignStep[];
+    readonly unsigned: readonly UnsignedWord[];
+}
+/**
+ * The clips a gloss is signed with, in order: a token with a clip is its clip; any other is fingerspelled from the letter and
+ * digit clips, as written (capitals, accents stripped, Ç kept); a word with a letter the avatar lacks is left out whole and
+ * listed.
+ */
+export declare function planSigns(gloss: string, carried: (name: string) => boolean): SignPlan;
+/**
+ * What the avatar left out of a text, said for `problems` (the `unsigned` of a `SignResult`): the words, and the letters it
+ * lacks clips for. `undefined` when it left nothing out.
+ */
+export declare function unsignedText(unsigned: readonly UnsignedWord[]): string | undefined;
+/**
+ * Everything a request left out: the words it could neither sign nor spell, and the clips the delivery could not give (`unread`).
+ * `undefined` when it left nothing out.
+ */
+export declare function leftOutText(unsigned: readonly UnsignedWord[], unread: readonly string[]): string | undefined;
+/** Why a request with nothing left to sign was not signed. */
+export declare const nothingSigned: (leftOut: string | undefined) => string;
+/** A clip to put on the stage now: fading in over `fade` seconds from what is there, starting `at` seconds into its window. */
+export interface StartClip {
+    readonly clip: string;
+    readonly fade: number;
+    readonly at: number;
+}
+export interface SignSequencer {
+    /** Replaces whatever was being signed with `steps`; returns the clip to start now (none for no steps). */
+    readonly play: (steps: readonly SignStep[]) => StartClip[];
+    /** Moves the clock `dt` seconds: the clips to start, and whether the last one just reached its end («stopped»). */
+    readonly tick: (dt: number) => {
+        readonly starts: StartClip[];
+        readonly finished: boolean;
+    };
+    /** Drops the queue: nothing more starts, and nothing finishes. */
+    readonly stop: () => void;
+}
+/**
+ * The queue's clock. `lengthOf` is a clip's played length (`playedLength`), `heldOf` where a letter's hand is held up
+ * (`playedSpans`: a spelled word's letters are chained through it; none, and every clip plays whole). Two neighbours overlap by
+ * `fade`, never by more than half of the stretch either plays; the first clip of a queue fades in only when a pose is already on
+ * the stage (a queue that replaced another, or the one held since the last), and appears at once otherwise.
+ */
+export declare function createSignSequencer(lengthOf: (clip: string) => number, fade?: number, heldOf?: (clip: string) => readonly [number, number] | undefined): SignSequencer;

package/dist-pkg/ui/libras-avatar-plan.js

@@ -0,0 +1,211 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// ui/libras-avatar-plan — WHAT THE FREE PLAYER SIGNS, IN WHICH ORDER, AND WHEN EACH CLIP STARTS (ADR-0234, route B, phase B2).
+//
+// Route B signs with LAViD-UFPB's own sign sources, exported once to ONE avatar and ONE three.js clip per sign
+// (`scripts/libras-export.mjs`, phase B1). This module is the player's pure half — no three.js, no DOM — so the queue, the
+// timing and the fingerspelling are held in node (`tests/libras-avatar-plan.node.test.js`); `ui/libras-avatar-stage` plays what
+// it decides and `ui/libras-avatar-player` puts it behind the `Interpreter` port.
+//
+// THE GLOSS IS THE DELIVERY'S: its build-time glosses (`ui/libras-glosses`), where a word with no clip is already written as
+// the child reads it on the screen. A token the delivery carries a clip for is signed; any other is FINGERSPELLED letter by
+// letter from the clips named by a single letter or digit — the word as written, capitals, accents stripped but Ç kept, a letter
+// of the manual alphabet with a clip of its own (`provisionalGloss`, the build's own spelling rule).
+// 📌 A word whose letters the avatar does not all carry is LEFT OUT WHOLE, and said: spelling only the letters it has would
+// show the child another word («ENTROU» with only its O is «O»).
+//
+// THE TIMING: each clip plays its window once, and the next one starts `CROSS_FADE_S` before it ends, fading in while the other
+// fades out — almost every exported clip starts and ends in the same pose (arms down), so the overlap joins them without passing
+// through the avatar's rest. 📏 13 of the 655 do not: the letter E holds its raised handshape from its first frame to its last,
+// NÃO_OUVIR keeps the right arm at the avatar's rest, and eleven (CASA and SIM among them) rest their hands lower. The last one
+// plays to its end and its final pose is held: that moment is the player's «stopped».
+//
+// 📌 A SPELLED WORD IS SIGNED WITH THE HAND HELD UP BETWEEN ITS LETTERS (the Dev, interface log 2026-09-26). Each letter's and
+// digit's clip rises from the arms-down pose, holds its handshape and falls back; the delivery's manifest says where it is held
+// (`ClipWindow.held`, measured on the clip: `scripts/libras-export.mjs` `heldWindow`). Inside one spelled word, a letter after the
+// first starts where its hand is up, and a letter before the last hands over where its hand starts down — the cross-fade joins
+// two held handshapes — so the hand rises at the first letter and comes down only after the last. E, still from its first frame
+// to its last, is held for its whole clip and the chain passes through it. A sign keeps its whole clip, a word of one letter is
+// unchanged, and a letter the manifest gives no window plays whole. 📏 On a served delivery «PÕE» went from 4.37 s to 2.86 s and
+// «TRIÂNGULO» from 12.60 s to 5.35 s.
+import { provisionalGloss } from './libras-glosses.js';
+/**
+ * Where the delivery puts the free player's avatar, clips, manifest and glosses, beside the game's page (`inclusionist-heavy --libras`):
+ * written in the catalogue, whose delivery list keeps these files offline (ADR-0234, phase B3), and re-exported here where the
+ * player and the delivery script already read it.
+ */
+export { LIBRAS_AVATAR_FOLDER } from '../platform/heavy-catalogue.js';
+/** The manifest the delivery writes in that folder: the avatar's file and every clip it carries, with its window. */
+export const LIBRAS_AVATAR_MANIFEST = 'manifest.json';
+/**
+ * How long two clips overlap, fading one into the other, in seconds. Every clip is at least 1.2 s (📏 the 655 of the delivery:
+ * 1.2–7.1 s, median 2.47 s), and the overlap never exceeds half of either clip, so no clip is swallowed by its neighbours.
+ */
+export const CROSS_FADE_S = 0.3;
+const isWindow = (w) => {
+    const c = w;
+    return !!c && typeof c.file === 'string' && typeof c.duration === 'number' && c.duration > 0
+        && (c.from === undefined || (typeof c.from === 'number' && c.from >= 0 && c.from < c.duration));
+};
+/** A `held` inside the played window, up before down; anything else is no window, and the clip plays whole. */
+const heldIn = (held, length) => {
+    if (!Array.isArray(held) || held.length !== 2)
+        return undefined;
+    const [up, down] = held;
+    return typeof up === 'number' && typeof down === 'number' && up >= 0 && down > up && down <= length ? [up, down] : undefined;
+};
+/**
+ * The manifest the delivery wrote, or `null` for anything else — no file, a fallback page, another format: a delivery that did
+ * not ship the avatar. A clip entry of the wrong shape is left out, not trusted; a `held` of the wrong shape is dropped.
+ */
+export function avatarManifestOf(data) {
+    const m = data;
+    if (!m || m.format !== 1 || typeof m.avatar !== 'string' || !m.avatar || typeof m.clips !== 'object' || m.clips === null)
+        return null;
+    const clips = new Map();
+    for (const [name, w] of Object.entries(m.clips)) {
+        if (isWindow(w))
+            clips.set(name, windowRead(w));
+    }
+    return { avatar: m.avatar, clips };
+}
+/** A clip entry of the right shape, as the player keeps it: `from` defaulted, `held` only when it is inside the window. */
+function windowRead(w) {
+    const from = w.from ?? 0;
+    const held = heldIn(w.held, w.duration - from);
+    return { file: w.file, duration: w.duration, from, ...(held ? { held } : {}) };
+}
+/** How long a clip plays: its window, from `from` to its end. */
+export const playedLength = (w) => w.duration - w.from;
+/** A gloss token that is not a sign: punctuation (`[PONTO]`) or a template hole the lookup left (`{n}`). */
+const NOT_A_SIGN = /^\[.*\]$|^\{.*\}$/u;
+/**
+ * The clips a gloss is signed with, in order: a token with a clip is its clip; any other is fingerspelled from the letter and
+ * digit clips, as written (capitals, accents stripped, Ç kept); a word with a letter the avatar lacks is left out whole and
+ * listed.
+ */
+export function planSigns(gloss, carried) {
+    const steps = [];
+    const unsigned = [];
+    gloss.split(/\s+/u).forEach((token, word) => {
+        if (!token || NOT_A_SIGN.test(token))
+            return;
+        if (carried(token)) {
+            steps.push({ clip: token });
+            return;
+        }
+        const letters = [...provisionalGloss(token).replace(/\s+/gu, '')];
+        if (!letters.length)
+            return;
+        const missing = [...new Set(letters.filter((c) => !carried(c)))];
+        if (missing.length) {
+            unsigned.push({ word: token, missing });
+            return;
+        }
+        for (const c of letters)
+            steps.push({ clip: c, spells: token, word });
+    });
+    return { steps, unsigned };
+}
+/**
+ * What the avatar left out of a text, said for `problems` (the `unsigned` of a `SignResult`): the words, and the letters it
+ * lacks clips for. `undefined` when it left nothing out.
+ */
+export function unsignedText(unsigned) {
+    if (!unsigned.length)
+        return undefined;
+    const words = [...new Set(unsigned.map((u) => `«${u.word}»`))];
+    const letters = [...new Set(unsigned.flatMap((u) => u.missing))].sort();
+    const one = words.length === 1;
+    return `${words.join(', ')} ${one ? 'lacks a sign of its' : 'lack a sign of their'} own and could not be fingerspelled: `
+        + `the avatar lacks the clips for ${letters.join(', ')}`;
+}
+/**
+ * Everything a request left out: the words it could neither sign nor spell, and the clips the delivery could not give (`unread`).
+ * `undefined` when it left nothing out.
+ */
+export function leftOutText(unsigned, unread) {
+    const parts = [unsignedText(unsigned), unread.length ? `the clips of ${unread.map((n) => `«${n}»`).join(', ')} could not be read from the delivery` : ''];
+    return parts.filter(Boolean).join('; ') || undefined;
+}
+/** Why a request with nothing left to sign was not signed. */
+export const nothingSigned = (leftOut) => `none of the text could be signed: ${leftOut ?? 'it holds not a single word'}`;
+/**
+ * WHAT OF EACH CLIP IS PLAYED: all of it, except inside a spelled word, where two neighbouring letters are CHAINED — the first
+ * ends where its hand starts down, the next starts where its hand is up (`held`). Two steps are chained only when they spell the
+ * same word (`word`) and both have a window; so the first letter keeps its rise, the last its fall, a word of one letter and a
+ * sign are whole.
+ */
+function playedSpans(steps, lengthOf, heldOf) {
+    const oneWord = (a, b) => a.spells !== undefined && a.word !== undefined
+        && b.word === a.word && b.spells === a.spells;
+    const chained = steps.map((s, i) => {
+        const next = steps[i + 1];
+        return !!next && oneWord(s, next) && !!heldOf(s.clip) && !!heldOf(next.clip);
+    });
+    return steps.map((s, i) => [
+        i > 0 && chained[i - 1] ? heldOf(s.clip)[0] : 0,
+        chained[i] ? heldOf(s.clip)[1] : lengthOf(s.clip),
+    ]);
+}
+/**
+ * The queue's clock. `lengthOf` is a clip's played length (`playedLength`), `heldOf` where a letter's hand is held up
+ * (`playedSpans`: a spelled word's letters are chained through it; none, and every clip plays whole). Two neighbours overlap by
+ * `fade`, never by more than half of the stretch either plays; the first clip of a queue fades in only when a pose is already on
+ * the stage (a queue that replaced another, or the one held since the last), and appears at once otherwise.
+ */
+export function createSignSequencer(lengthOf, fade = CROSS_FADE_S, heldOf = () => undefined) {
+    let queue = [];
+    let spans = [];
+    /** The step on the stage now; -1 when none is playing. */
+    let index = -1;
+    /** Seconds into the current step's stretch. */
+    let elapsed = 0;
+    /** Whether a pose is on the stage: after the first clip, the last frame of the last one is held. */
+    let shown = false;
+    const lengthAt = (i) => spans[i][1] - spans[i][0];
+    const overlapAfter = (i) => (i + 1 < queue.length ? Math.min(fade, lengthAt(i) / 2, lengthAt(i + 1) / 2) : 0);
+    return {
+        play: (steps) => {
+            queue = steps;
+            spans = playedSpans(steps, lengthOf, heldOf);
+            elapsed = 0;
+            index = steps.length ? 0 : -1;
+            if (!steps.length)
+                return [];
+            const start = { clip: steps[0].clip, fade: shown ? Math.min(fade, lengthAt(0) / 2) : 0, at: spans[0][0] };
+            shown = true;
+            return [start];
+        },
+        tick: (dt) => {
+            const starts = [];
+            if (index < 0)
+                return { starts, finished: false };
+            elapsed += Math.max(0, dt);
+            for (;;) {
+                const length = lengthAt(index);
+                if (index + 1 < queue.length) {
+                    const handOver = length - overlapAfter(index);
+                    if (elapsed < handOver)
+                        break;
+                    elapsed -= handOver;
+                    index += 1;
+                    starts.push({ clip: queue[index].clip, fade: overlapAfter(index - 1), at: spans[index][0] + elapsed });
+                    continue;
+                }
+                if (elapsed < length)
+                    break;
+                index = -1;
+                queue = [];
+                spans = [];
+                return { starts, finished: true };
+            }
+            return { starts, finished: false };
+        },
+        stop: () => {
+            index = -1;
+            queue = [];
+            spans = [];
+            elapsed = 0;
+        },
+    };
+}

package/dist-pkg/ui/libras-avatar-player.d.ts

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+import type { Interpreter } from './vlibras.js';
+import type { AvatarStage } from './libras-avatar-stage.js';
+/** What the free interpreter is built over. Every port is the host's. */
+export interface LibrasAvatarPorts {
+    /** The host's document: the avatar's canvas is created in it and put in front of the screen. */
+    readonly doc: Document;
+    /** The host's window: it keeps the timers and draws the frames. */
+    readonly win: Pick<Window, 'setTimeout' | 'clearTimeout' | 'requestAnimationFrame' | 'cancelAnimationFrame'> & {
+        readonly devicePixelRatio?: number;
+    };
+    /** The host's `fetch`, for the delivery's manifest, avatar, clips and glosses; `undefined` where it has none. */
+    readonly fetch: ((url: string) => Promise<Response>) | undefined;
+    /** The page's address the delivery's folders are resolved against (`document.baseURI`). */
+    readonly base: string;
+    /** The avatar's accessible name, read when its canvas is made — the page's language at that moment. */
+    readonly title: () => string;
+    /** Where the avatar, the clips, the manifest and the glosses are, under `base`. The delivery's folder unless a test points elsewhere. */
+    readonly avatarFolder?: string;
+    /** How long the avatar may take to load before the request is answered «unavailable». */
+    readonly loadTimeoutMs?: number;
+    /** How long the avatar stays after it stopped signing before it leaves. `LEAVE_AFTER_MS` unless a test says. */
+    readonly leaveAfterMs?: number;
+    /** Builds the stage on the canvas from the avatar's bytes. `ui/libras-avatar-stage`, imported when first needed, unless a test says. */
+    readonly loadStage?: (canvas: HTMLCanvasElement, avatar: ArrayBuffer) => Promise<AvatarStage>;
+}
+/** Builds the free interpreter over the avatar the delivery shipped — or, where it shipped none, «signing unavailable». */
+export declare function createLibrasAvatarInterpreter(ports: LibrasAvatarPorts): Interpreter;