@vestra-player/sdk 1.6.17 → 1.6.19

package/dist/plugin/testing/core-actions.js

@@ -0,0 +1,371 @@
+/**
+ * The player's core actions (`host/<id>` commands): their enabled rules and
+ * reasons, what running one does, stepping and sequences.
+ *
+ * Part of `TestHost` (`./index.ts`): functions over the host and its private
+ * state (`Internals`, `./internals.ts`) that the class delegates to.
+ * Internal to the SDK; not exported from `@vestra-player/sdk/testing`.
+ */
+import { HostError } from "../../wire.js";
+import { validStep } from "../player.js";
+import { hostText } from "./i18n.js";
+import { sourceIntent, audioCondition } from "./media.js";
+export function coreFacts(host, _inner) {
+    const s = host.source;
+    const ready = s.phase === "ready";
+    const ended = s.phase === "ended";
+    return {
+        ready,
+        ended,
+        toggle: (s.capabilities.pause && ready) || (ended && s.capabilities.restart),
+        step: s.capabilities.seek && ready && s.position !== null,
+        rate: s.capabilities.rate && ready,
+        close: s.capabilities.close && s.phase !== "empty",
+    };
+}
+/** Why one frame that way is impossible (B07), or null; the player's rules. */
+export function frameCheck(host, inner, forward) {
+    const s = host.source;
+    const unsupported = hostText(host, inner, "Not supported by the current source");
+    const noBack = hostText(host, inner, "The current source cannot step back a frame");
+    if (s.phase !== "ready" && s.phase !== "ended")
+        return unsupported;
+    if (s.kind !== "media")
+        return forward ? unsupported : noBack;
+    if (s.hasVideo === false)
+        return hostText(host, inner, "No video");
+    if (forward && s.phase !== "ready")
+        return unsupported;
+    if (!forward && !s.capabilities.seek)
+        return noBack;
+    return null;
+}
+/** The same enabled rules and reasons as the player's core actions. */
+export function coreState(host, inner, action) {
+    const f = coreFacts(host, inner);
+    const s = host.source;
+    const unsupported = hostText(host, inner, "Not supported by the current source");
+    const rule = {
+        "play-pause": [f.toggle, f.ready ? s.paused : null, unsupported],
+        stop: [f.close, null, unsupported],
+        previous: [
+            !!host.sequence?.canPrevious,
+            null,
+            hostText(host, inner, "No previous item"),
+        ],
+        next: [
+            !!host.sequence?.canNext,
+            null,
+            hostText(host, inner, "No next item"),
+        ],
+        "frame-back": [
+            !frameCheck(host, inner, false),
+            null,
+            frameCheck(host, inner, false) ?? unsupported,
+        ],
+        "frame-forward": [
+            !frameCheck(host, inner, true),
+            null,
+            frameCheck(host, inner, true) ?? unsupported,
+        ],
+        "seek-backward": [f.step, null, unsupported],
+        "seek-forward": [f.step, null, unsupported],
+        "rate-normal": [f.rate, s.rate === 1, unsupported],
+        "rate-down": [f.rate, null, unsupported],
+        "rate-up": [f.rate, null, unsupported],
+        "volume-up": [true, null, unsupported],
+        "volume-down": [true, null, unsupported],
+        mute: [true, s.output.muted, unsupported],
+    };
+    const [enabled, checked, reason] = rule[action];
+    return { enabled, checked, busy: false, reason: enabled ? null : reason };
+}
+export function registerCoreActions(host, inner) {
+    // As the player declares them (host/src/core_actions.rs `declarations`,
+    // player 0.7.6): title, menu path (empty: the command palette only), order,
+    // group, default bindings, repeat, radio. Close and Play/Pause are in the
+    // menu; the rest left it for the panels and the command palette (seek,
+    // frame and speed with the playback plugin's panel, volume and mute with
+    // the audio plugin's, Previous and Next with the slim menu).
+    const table = [
+        ["stop", "Close", ["Close"], 120, "open", ["F4"], false],
+        [
+            "play-pause",
+            "Play/Pause",
+            ["Play/Pause"],
+            201,
+            "domain",
+            ["Space", "Mouse:LeftClick"],
+            false,
+        ],
+        ["previous", "Previous", [], 0, "domain", ["PageUp", "Mouse:X2"], false],
+        ["next", "Next", [], 0, "domain", ["PageDown", "Mouse:X1"], false],
+        ["frame-back", "Previous Frame", [], 0, "domain", ["D"], true],
+        ["frame-forward", "Next Frame", [], 0, "domain", ["F"], true],
+        ["seek-backward", "Back 5 s", [], 0, "domain", ["ArrowLeft"], true],
+        ["seek-forward", "Forward 5 s", [], 0, "domain", ["ArrowRight"], true],
+        ["rate-normal", "Normal", [], 0, "domain", ["Z"], false, true],
+        ["rate-down", "Slower 0.1", [], 0, "domain", ["X"], false],
+        ["rate-up", "Faster 0.1", [], 0, "domain", ["C"], false],
+        [
+            "volume-up",
+            "Volume +",
+            [],
+            0,
+            "domain",
+            ["ArrowUp", "Mouse:WheelUp"],
+            true,
+        ],
+        [
+            "volume-down",
+            "Volume −",
+            [],
+            0,
+            "domain",
+            ["ArrowDown", "Mouse:WheelDown"],
+            true,
+        ],
+        ["mute", "Mute", [], 0, "domain", ["M"], false],
+    ];
+    for (const [id, fixed, path, order, group, bindings, repeat, radio,] of table) {
+        // The seek items carry the step (`setStepSeek`): the player
+        // registers them again when it changes (core_actions.rs `seek_title`).
+        const seek = id === "seek-forward"
+            ? "Forward"
+            : id === "seek-backward"
+                ? "Back"
+                : null;
+        const titleOf = () => seek === null
+            ? fixed
+            : `${seek} ${String(Math.round(host.stepSeek * 1000) / 1000)} s`;
+        const declaration = {
+            path,
+            order,
+            group,
+            radio: radio ?? false,
+            bindings,
+            repeat,
+        };
+        Object.defineProperties(declaration, {
+            title: { get: titleOf, enumerable: true },
+        });
+        const command = {
+            declaration,
+            // The player's own words in the player's language.
+            get display() {
+                const leaf = titleOf();
+                const step = /^(Back|Forward) (\S+) s$/.exec(leaf);
+                const title = step
+                    ? hostText(host, inner, `${step[1]} {} s`, [step[2]])
+                    : hostText(host, inner, leaf);
+                return {
+                    title,
+                    path: path.length
+                        ? [...path.slice(0, -1).map((s) => hostText(host, inner, s)), title]
+                        : [],
+                };
+            },
+            get state() {
+                return coreState(host, inner, id);
+            },
+            set state(_value) { },
+            revision: 1,
+            async run() {
+                // Like the player's menu: a disabled or busy command does not run.
+                const state = coreState(host, inner, id);
+                if (state.busy || !state.enabled)
+                    throw new HostError("command", `host/${id} is ${state.busy ? "busy" : "disabled"}`);
+                await host.request("host.run", { action: id });
+                await host.settle();
+            },
+        };
+        host.coreCommands.set(`host/${id}`, command);
+    }
+}
+export function runCore(host, inner, action, seconds) {
+    const state = coreState(host, inner, action);
+    if (!state.enabled)
+        throw new HostError("unavailable", state.reason ?? "unavailable");
+    host.coreRuns.push(action);
+    const s = host.source;
+    const time = (t) => {
+        if (t === null)
+            return "--:--";
+        const w = Math.max(0, Math.floor(t));
+        const mm = String(Math.floor(w / 60) % 60).padStart(2, "0");
+        const ss = String(w % 60).padStart(2, "0");
+        return w >= 3600 ? `${Math.floor(w / 3600)}:${mm}:${ss}` : `${mm}:${ss}`;
+    };
+    const rateText = (r) => String(Math.round(r * 100) / 100);
+    switch (action) {
+        case "play-pause":
+            if (s.phase === "ended")
+                sourceIntent(host, inner, { kind: "restart" });
+            else
+                sourceIntent(host, inner, {
+                    kind: "control",
+                    control: { kind: "pause", paused: !s.paused },
+                });
+            host.osd.push(hostText(host, inner, s.phase !== "ended" && !s.paused ? "Paused" : "Playing"));
+            return;
+        case "stop":
+            sourceIntent(host, inner, { kind: "close" });
+            return;
+        case "previous":
+        case "next":
+            host.emit("sequence.step", { direction: action });
+            return;
+        case "frame-back":
+        case "frame-forward":
+            host.steps.push({
+                unit: "frame",
+                direction: action === "frame-back" ? "backward" : "forward",
+            });
+            return;
+        case "seek-backward":
+        case "seek-forward": {
+            const step = seconds ?? host.stepSeek;
+            const delta = action === "seek-forward" ? step : -step;
+            const base = s.position ?? 0;
+            let target = Math.max(0, Math.min(s.duration ?? Infinity, base + delta));
+            // Keyframe mode, as the player: forward on the first keyframe at or
+            // after the target (none: the exact target), backward on the last at
+            // or before it; only sources with moving video that can seek.
+            const keyframes = host.stepSeekKeyframes &&
+                host.keyframes !== null &&
+                s.hasVideo !== false &&
+                s.capabilities.seek;
+            if (keyframes && target !== base) {
+                const keys = host.keyframes;
+                target =
+                    delta > 0
+                        ? (keys.find((k) => k >= target) ?? target)
+                        : keys
+                            .filter((k) => k <= target)
+                            .reduce((a, k) => Math.max(a, k), 0);
+            }
+            sourceIntent(host, inner, {
+                kind: "control",
+                control: { kind: "seek", seconds: target },
+            });
+            host.coreSeeks.push({
+                action,
+                seconds: step,
+                keyframes,
+                landed: target,
+            });
+            host.osd.push(hostText(host, inner, delta < 0 ? "Back {} s: {} / {}" : "Forward {} s: {} / {}", [Math.abs(delta), time(target), time(s.duration)]));
+            return;
+        }
+        case "rate-normal":
+        case "rate-down":
+        case "rate-up": {
+            const rate = action === "rate-normal"
+                ? 1
+                : Math.max(0.25, Math.min(4, Math.round((s.rate + (action === "rate-up" ? 0.1 : -0.1)) * 100) / 100));
+            sourceIntent(host, inner, {
+                kind: "control",
+                control: { kind: "rate", rate },
+            });
+            host.osd.push(hostText(host, inner, "Speed: {}x", [rateText(rate)]));
+            return;
+        }
+        case "volume-up":
+        case "volume-down": {
+            // Like the player: up stops at 100 (a louder volume set through
+            // setOutput stays), down steps by 5 to 0.
+            const volume = action === "volume-up"
+                ? Math.max(s.output.volume, Math.min(100, Math.round(s.output.volume + 5)))
+                : Math.max(0, Math.min(200, Math.round(s.output.volume - 5)));
+            host.setSource({ output: { volume, muted: false } });
+            host.osd.push(hostText(host, inner, "Volume: {}%", [volume]));
+            return;
+        }
+        case "mute":
+            host.setSource({ output: { ...s.output, muted: !s.output.muted } });
+            host.osd.push(hostText(host, inner, s.output.muted ? "Mute: Off" : "Mute: On"));
+            return;
+    }
+}
+export function windowFacts(host, _inner) {
+    return {
+        fullscreen: host.mainWindow.fullscreen,
+        // Like player 0.6.3: never maximized while fullscreen.
+        maximized: host.mainWindow.maximized && !host.mainWindow.fullscreen,
+        videoArea: { ...host.mainWindow.videoArea },
+        pictureInPicture: { ...host.mainWindow.pictureInPicture },
+        appearance: host.appearance,
+        fileTypes: host.fileTypes(),
+        language: host.language,
+        locale: host.locale,
+    };
+}
+/** The default handlers of this area's wire methods, by method name. */
+export function coreActionsHandlers(host, inner) {
+    return {
+        "player.setStepSeek": (p) => {
+            if (!validStep(p.seconds))
+                throw new HostError("invalid", "seconds must be 0.1..3600 in tenths");
+            if (p.keyframes !== undefined &&
+                p.keyframes !== null &&
+                typeof p.keyframes !== "boolean")
+                throw new HostError("invalid", "keyframes must be a boolean");
+            // Written as a pair, as the player does.
+            host.stepSeek = p.seconds;
+            host.stepSeekKeyframes = p.keyframes === true;
+        },
+        "player.step": (p) => {
+            audioCondition(host, inner, p.expected);
+            const s = host.source;
+            const reason = p.unit === "keyframe"
+                ? s.phase === "ready" && s.capabilities.seek && s.hasVideo !== false
+                    ? null
+                    : hostText(host, inner, "Not supported by the current source")
+                : frameCheck(host, inner, p.direction === "forward");
+            if (reason)
+                throw new HostError("unsupported", reason);
+            host.steps.push({ unit: String(p.unit), direction: String(p.direction) });
+        },
+        "sequence.set": (p) => {
+            host.sequence = p.flags;
+            host.setSource({
+                sequence: {
+                    next: host.sequence?.canNext ?? false,
+                    previous: host.sequence?.canPrevious ?? false,
+                },
+            });
+        },
+        "sequence.step": (p) => {
+            const direction = String(p.direction);
+            const can = direction === "next"
+                ? host.sequence?.canNext
+                : host.sequence?.canPrevious;
+            if (!can)
+                throw new HostError("unavailable", `cannot go ${direction}`);
+            host.emit("sequence.step", { direction });
+        },
+        "player.chapters": () => ({
+            sourceId: host.source.stamp.generation,
+            chapters: host.source.kind === "media" &&
+                ["ready", "ended"].includes(host.source.phase)
+                ? structuredClone(host.chapters)
+                : [],
+        }),
+        "player.setLoop": (p) => {
+            if (host.source.kind === "producer")
+                throw new HostError("unsupported", "a generated stream cannot loop");
+            audioCondition(host, inner, p.expected);
+            const loop = p.loop;
+            if (loop && !host.source.capabilities.seek)
+                throw new HostError("unsupported", "the source cannot seek");
+            if (loop &&
+                !(loop.a >= 0 &&
+                    loop.a < loop.b &&
+                    loop.b <= (host.source.duration ?? 0)))
+                throw new HostError("invalid", "loop needs 0 <= a < b <= duration");
+            host.setSource({
+                loop: loop && { a: loop.a, b: loop.b, count: loop.count ?? null },
+            });
+        },
+    };
+}

package/dist/plugin/testing/declarations.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The player's checks of a command declaration (capabilities/commands.rs,
+ * commands.rs), with its codes and messages.
+ *
+ * Part of `TestHost` (`./index.ts`): functions over the host and its private
+ * state (`Internals`, `./internals.ts`) that the class delegates to.
+ * Internal to the SDK; not exported from `@vestra-player/sdk/testing`.
+ */
+import { HostError } from "../../wire.ts";
+/**
+ * The player's refusal of a declaration (commands.rs `CommandError`): code
+ * `invalid`, `conflict` or `limit`, its message prefixed as the player's.
+ */
+export declare const commandInvalid: (message: string) => HostError;
+export declare const commandConflict: (message: string) => HostError;
+/**
+ * The player's check of a command text (commands.rs `text`): 1 to `limit`
+ * UTF-8 bytes, no control character (`char::is_control`: C0, DEL and C1)
+ * and no whitespace at either end (`str::trim`: Unicode White_Space).
+ */
+export declare function commandText(value: string, label: string, limit: number): void;
+/**
+ * A menu text (title or path segment) as the player keys it: a string as
+ * declared, a text value by its English rendering (capabilities/commands.rs
+ * `menu_text`).
+ */
+export declare function menuTextKey(value: unknown): string;
+/**
+ * The declaration checks of the player's `Registry::register`, in its
+ * order, on the keyed title and path (`@<id>` already replaced).
+ */
+export declare function checkDeclaration(id: string, title: string, path: readonly string[], declaration: {
+    group?: unknown;
+    order?: unknown;
+    bindings?: unknown;
+    home?: unknown;
+}, category?: string | null): void;

package/dist/plugin/testing/declarations.js

@@ -0,0 +1,80 @@
+/**
+ * The player's checks of a command declaration (capabilities/commands.rs,
+ * commands.rs), with its codes and messages.
+ *
+ * Part of `TestHost` (`./index.ts`): functions over the host and its private
+ * state (`Internals`, `./internals.ts`) that the class delegates to.
+ * Internal to the SDK; not exported from `@vestra-player/sdk/testing`.
+ */
+import { HostError } from "../../wire.js";
+import { COMMAND_LIMITS } from "../../commands.js";
+import { isTextValue, textKey, textProblem } from "../../i18n.js";
+/**
+ * The player's refusal of a declaration (commands.rs `CommandError`): code
+ * `invalid`, `conflict` or `limit`, its message prefixed as the player's.
+ */
+export const commandInvalid = (message) => new HostError("invalid", `invalid command: ${message}`);
+export const commandConflict = (message) => new HostError("conflict", `command conflict: ${message}`);
+/**
+ * The player's check of a command text (commands.rs `text`): 1 to `limit`
+ * UTF-8 bytes, no control character (`char::is_control`: C0, DEL and C1)
+ * and no whitespace at either end (`str::trim`: Unicode White_Space).
+ */
+export function commandText(value, label, limit) {
+    const bytes = Buffer.byteLength(value, "utf8");
+    if (bytes === 0 ||
+        bytes > limit ||
+        /^\p{White_Space}|\p{White_Space}$/u.test(value) ||
+        /\p{Cc}/u.test(value))
+        throw commandInvalid(`${label} requires 1..=${limit} bytes, no controls or surrounding whitespace`);
+}
+/**
+ * A menu text (title or path segment) as the player keys it: a string as
+ * declared, a text value by its English rendering (capabilities/commands.rs
+ * `menu_text`).
+ */
+export function menuTextKey(value) {
+    if (typeof value === "string")
+        return value;
+    if (!isTextValue(value))
+        throw new HostError("invalid", "title and path segments are strings or texts");
+    if ("$vestraList" in value)
+        throw new HostError("invalid", "a menu text is a string or a text, not a list");
+    const problem = textProblem(value);
+    if (problem)
+        throw new HostError("invalid", problem);
+    return textKey(value);
+}
+/**
+ * The declaration checks of the player's `Registry::register`, in its
+ * order, on the keyed title and path (`@<id>` already replaced).
+ */
+export function checkDeclaration(id, title, path, declaration, category = null) {
+    commandText(id, "localId", COMMAND_LIMITS.idBytes);
+    if (!/^[A-Za-z0-9._-]+$/.test(id))
+        throw commandInvalid("localId permits ASCII letters, digits, '.', '_' and '-'");
+    commandText(title, "title", COMMAND_LIMITS.titleBytes);
+    if (path.length > COMMAND_LIMITS.depth)
+        throw commandInvalid(`menu path allows at most ${COMMAND_LIMITS.depth} segments`);
+    for (const segment of path)
+        commandText(segment, "path segment", COMMAND_LIMITS.segmentBytes);
+    const group = declaration.group ?? "domain";
+    if (typeof group !== "string")
+        throw new HostError("invalid", "group is a string");
+    commandText(group, "group", COMMAND_LIMITS.groupBytes);
+    // Player 0.7.6: the category and the home command's local id.
+    if (category !== null)
+        commandText(category, "category", COMMAND_LIMITS.categoryBytes);
+    const home = declaration.home;
+    if (home !== undefined && home !== null) {
+        if (typeof home !== "string")
+            throw new HostError("invalid", "home is a command id");
+        commandText(home, "home", COMMAND_LIMITS.idBytes);
+        if (!/^[A-Za-z0-9._-]+$/.test(home))
+            throw commandInvalid("home permits ASCII letters, digits, '.', '_' and '-'");
+    }
+    const order = declaration.order ?? 0;
+    if (!Number.isInteger(order) ||
+        Math.abs(order) > COMMAND_LIMITS.order)
+        throw commandInvalid("order must be within ±1000000");
+}

package/dist/plugin/testing/i18n.d.ts

@@ -0,0 +1,28 @@
+import type { TemplateArgs, TextValue } from "../types.ts";
+import type { TextJson } from "../../i18n.ts";
+import type { TestHost } from "./index.ts";
+import type { Handler, Internals } from "./internals.ts";
+/** Texts only the test host uses, with their Chinese of SDK 1.5.8. */
+export declare const TEST_ZH_HANS: Readonly<Record<string, string>>;
+/**
+ * A text of a request as the player shows it, refused as the player
+ * refuses it: a string is a template (formatted with `args`, if given), a
+ * text value carries its own arguments.
+ */
+export declare function shownText(host: TestHost, _inner: Internals, text: unknown, args: unknown, what: string): string;
+/** A declared text: a string is translated as it is, a text rendered. */
+export declare function declaredText(host: TestHost, inner: Internals, text: unknown, what: string): string;
+/** Property values with their text values shown, as the player does first. */
+export declare function shownValues<T>(host: TestHost, inner: Internals, values: T): T;
+/** A text of the player itself, in the player's language (see `locale`). */
+export declare function hostText(_host: TestHost, inner: Internals, text: string, args?: TemplateArgs): string;
+/** A declared menu path and title as the player shows them. */
+export declare function commandDisplay(host: TestHost, inner: Internals, path: readonly (string | TextJson)[], title: string | TextJson, reason?: TextValue | null, category?: string | TextJson | null): {
+    title: string;
+    path: string[];
+    reason: string | null;
+};
+/** Implements `TestHost.translate`. */
+export declare function translate(host: TestHost, inner: Internals, text: TextValue, args?: TemplateArgs): string;
+/** The default handlers of this area's wire methods, by method name. */
+export declare function i18nHandlers(host: TestHost, _inner: Internals): Record<string, Handler>;

package/dist/plugin/testing/i18n.js

@@ -0,0 +1,107 @@
+/**
+ * Texts as the player shows them: translation with the plugin's catalog, the
+ * player's own texts, menu display and the appearance and language settings.
+ *
+ * Part of `TestHost` (`./index.ts`): functions over the host and its private
+ * state (`Internals`, `./internals.ts`) that the class delegates to.
+ * Internal to the SDK; not exported from `@vestra-player/sdk/testing`.
+ */
+import { HostError } from "../../wire.js";
+import { THEMES } from "../appearance.js";
+import { format as formatTemplate, HOST_GROUPS, HOST_ZH_HANS, LOCALES, isTextValue, menuKeys, renderTemplateArgs, renderText, resolveTexts, textKey, textProblem, } from "../../i18n.js";
+/** Texts only the test host uses, with their Chinese of SDK 1.5.8. */
+export const TEST_ZH_HANS = {
+    "this site": "这个网站",
+    "External SRT": "外部 SRT",
+    "External ASS": "外部 ASS",
+};
+/**
+ * A text of a request as the player shows it, refused as the player
+ * refuses it: a string is a template (formatted with `args`, if given), a
+ * text value carries its own arguments.
+ */
+export function shownText(host, _inner, text, args, what) {
+    if (args !== undefined && args !== null) {
+        const problem = textProblem(args, "args");
+        if (problem)
+            throw new HostError("invalid", problem);
+    }
+    if (typeof text === "string")
+        return host.translate(text, (args ?? undefined));
+    if (!isTextValue(text))
+        throw new HostError("invalid", `${what} requires a string or a text`);
+    const problem = textProblem(text);
+    if (problem)
+        throw new HostError("invalid", `${what}: ${problem}`);
+    if (args !== undefined && args !== null)
+        throw new HostError("invalid", `${what}: a text value takes no args`);
+    return host.translate(text);
+}
+/** A declared text: a string is translated as it is, a text rendered. */
+export function declaredText(host, inner, text, what) {
+    return shownText(host, inner, text, undefined, what);
+}
+/** Property values with their text values shown, as the player does first. */
+export function shownValues(host, inner, values) {
+    const resolved = resolveTexts(values, inner.catalog, host.locale);
+    if ("problem" in resolved)
+        throw new HostError("invalid", resolved.problem);
+    return resolved.value;
+}
+/** A text of the player itself, in the player's language (see `locale`). */
+export function hostText(_host, inner, text, args) {
+    const zh = inner.locale === undefined || inner.locale === "zh-Hans";
+    const shown = (zh && (HOST_ZH_HANS[text] ?? TEST_ZH_HANS[text])) || text;
+    return args === undefined
+        ? shown
+        : formatTemplate(shown, args);
+}
+/** A declared menu path and title as the player shows them. */
+export function commandDisplay(host, inner, path, title, reason = null, category = null) {
+    const keys = menuKeys(path.map((segment) => typeof segment === "string" ? segment : textKey(segment)));
+    const display = {
+        title: host.translate(title),
+        // The player's submenus by key, everything else as declared.
+        path: keys.map((segment, index) => index < keys.length - 1 &&
+            HOST_GROUPS.includes(keys.slice(0, index + 1).join("/"))
+            ? hostText(host, inner, segment)
+            : host.translate((path[index] ?? segment))),
+    };
+    // Not enumerable: `deepEqual(display, { title, path })` keeps passing.
+    Object.defineProperty(display, "reason", {
+        value: reason === null ? null : host.translate(reason),
+        enumerable: false,
+    });
+    Object.defineProperty(display, "category", {
+        value: category === null ? null : host.translate(category),
+        enumerable: false,
+    });
+    return display;
+}
+/** Implements `TestHost.translate`. */
+export function translate(host, inner, text, args) {
+    if (typeof text !== "string")
+        return renderText(text, inner.catalog, host.locale);
+    const values = renderTemplateArgs(args, inner.catalog, host.locale);
+    return inner.catalog.template(text, values ?? null);
+}
+/** The default handlers of this area's wire methods, by method name. */
+export function i18nHandlers(host, _inner) {
+    return {
+        "appearance.setLanguage": (p) => {
+            const language = String(p.language);
+            if (language !== "system" &&
+                !LOCALES.includes(language))
+                throw new HostError("invalid", `unknown language ${language}`);
+            if (language !== host.language)
+                host.setLanguage(language);
+        },
+        "appearance.set": (p) => {
+            // Like the player: an id it does not have selects the default (the
+            // SDK's own `set` refuses one before it gets here).
+            const theme = THEMES.find((t) => t === p.theme) ?? THEMES[0];
+            if (theme !== host.appearance)
+                host.setAppearance(theme);
+        },
+    };
+}