@vestra-player/sdk 1.6.16 → 1.6.18

package/dist/plugin/testing/layout.js

@@ -0,0 +1,622 @@
+/**
+ * Views, panels and tabs: `ui.*` windows and mounts, `layout.*`, property
+ * writes with row patches and parts, images, and the timeline layer.
+ *
+ * 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 { TIMELINE_LIMITS } from "../timeline.js";
+import { UI_VALUE_LIMITS, valueLimitProblem } from "../values.js";
+import { applyOps, PATCH_OPS } from "../patch.js";
+import { isTextValue } from "../../i18n.js";
+import { taken } from "./transport.js";
+import { windowFacts } from "./core-actions.js";
+import { declaredText, shownValues, hostText } from "./i18n.js";
+export const kebab = (name) => name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+export const SLOT_LABELS = {
+    bottom: "bottom bar",
+    sidebar: "sidebar",
+    backdrop: "video backdrop",
+    adjust: "adjust column",
+};
+/** The view a panel's writes are kept under (the player's, per slot). */
+export const mountView = (slot) => slot === "bottom" ? "$mount" : `$mount:${slot}`;
+/**
+ * A patch's ops checked against an array of `length` rows, as the player
+ * checks them (`ui_patch.rs`): in order, each on the result of the ones
+ * before; at most {@link PATCH_OPS}; the result at most
+ * `UI_VALUE_LIMITS.arrayRows` rows.
+ */
+/** The player takes no Markdown documents in parts of a value (`invalid`). */
+export function noMarkdownParts(rows) {
+    if (JSON.stringify(rows).includes('"$vestraMarkdown"'))
+        throw new HostError("invalid", "a value sent in parts holds no Markdown documents");
+}
+export function patchOps(ops, length) {
+    if (!Array.isArray(ops))
+        throw new HostError("invalid", "patch.ops requires an array");
+    if (ops.length > PATCH_OPS)
+        throw new HostError("limit", `a patch carries at most ${PATCH_OPS} operations`);
+    const index = (op, key) => {
+        const value = op[key];
+        if (!Number.isInteger(value) || value < 0)
+            throw new HostError("invalid", `patch op ${key} requires a non-negative integer`);
+        return value;
+    };
+    const count = (op) => {
+        const value = index(op, "count");
+        if (value === 0)
+            throw new HostError("invalid", "patch op count must be at least 1");
+        return value;
+    };
+    const past = (what) => new HostError("invalid", `${what} is past the end of the list`);
+    let len = length;
+    return ops.map((raw) => {
+        const op = (raw ?? {});
+        switch (op.op) {
+            case "set": {
+                const at = index(op, "at");
+                if (at >= len)
+                    throw past(`set at ${at}`);
+                if (!("row" in op))
+                    throw new HostError("invalid", "patch op set requires row");
+                return { op: "set", at, row: op.row };
+            }
+            case "insert": {
+                const at = index(op, "at");
+                const rows = op.rows;
+                if (!Array.isArray(rows) || rows.length === 0)
+                    throw new HostError("invalid", "patch op insert requires rows");
+                if (at > len)
+                    throw past(`insert at ${at}`);
+                len += rows.length;
+                if (len > UI_VALUE_LIMITS.arrayRows)
+                    throw new HostError("limit", `UI array exceeds ${UI_VALUE_LIMITS.arrayRows} rows`);
+                return { op: "insert", at, rows: rows };
+            }
+            case "remove": {
+                const at = index(op, "at");
+                const n = count(op);
+                if (at + n > len)
+                    throw past(`remove ${n} at ${at}`);
+                len -= n;
+                return { op: "remove", at, count: n };
+            }
+            case "move": {
+                const from = index(op, "from");
+                const n = count(op);
+                const to = index(op, "to");
+                if (from + n > len || to + n > len)
+                    throw past(`move ${n} from ${from} to ${to}`);
+                return { op: "move", from, count: n, to };
+            }
+            default:
+                throw new HostError("invalid", "patch op must be set, insert, remove or move");
+        }
+    });
+}
+export function timelineChanged(host, _inner) {
+    host.emit("timeline.changed", {
+        marks: host.timeline.marks,
+        ranges: host.timeline.ranges,
+    });
+}
+export function resetWrites(_host, inner, view) {
+    for (const slot of [...inner.writes.keys()])
+        if (slot.startsWith(`${view}\u0000`))
+            inner.writes.delete(slot);
+    for (const slot of [...inner.parts.keys()])
+        if (slot.startsWith(`${view}\u0000`))
+            inner.parts.delete(slot);
+}
+/**
+ * A property write as the player takes it, returning the value the
+ * property shows after it: a whole `value`, or a `patch` of the array
+ * `current` applying on the write numbered `base` (code `stale`
+ * otherwise). The result is checked against the value limits whole: the
+ * player counts the rows a patch keeps too.
+ */
+export function writeProperty(host, inner, view, property, p, current) {
+    const slot = `${view}\u0000${property}`;
+    const patch = p.patch;
+    // A whole array sent in parts (player 0.6.0, SDK 1.5.46): every part but
+    // the last carries `more`; the player holds them and writes the whole
+    // value at the last, as here (`undefined`: held, nothing shown yet).
+    const more = p.more === true;
+    const held = inner.parts.get(slot);
+    inner.parts.delete(slot);
+    if (more && patch === undefined) {
+        const rows = shownValues(host, inner, p.value);
+        if (!Array.isArray(rows))
+            throw new HostError("invalid", "a value sent in parts is an array");
+        noMarkdownParts(rows);
+        checkValues(host, inner, { [property]: rows });
+        inner.parts.set(slot, {
+            seq: typeof p.seq === "number" ? p.seq : 0,
+            rows,
+        });
+        return undefined;
+    }
+    if (patch !== undefined && held && patch.base === held.seq) {
+        const ops = patchOps(patch.ops, held.rows.length);
+        const resolved = ops.map((op) => op.op === "set"
+            ? { ...op, row: shownValues(host, inner, op.row) }
+            : op.op === "insert"
+                ? { ...op, rows: op.rows.map((row) => shownValues(host, inner, row)) }
+                : op);
+        noMarkdownParts(resolved.flatMap((op) => op.op === "set" ? [op.row] : op.op === "insert" ? op.rows : []));
+        const rows = applyOps(held.rows, resolved);
+        checkValues(host, inner, { [property]: rows });
+        if (more) {
+            inner.parts.set(slot, { seq: patch.seq, rows });
+            return undefined;
+        }
+        seeImages(host, inner, [rows]);
+        inner.writes.set(slot, patch.seq);
+        return rows;
+    }
+    if (patch !== undefined && more)
+        throw new HostError("stale", "the property changed since the write this patch applies on; send the whole value");
+    if (patch === undefined) {
+        const value = shownValues(host, inner, p.value);
+        checkValues(host, inner, { [property]: value });
+        seeImages(host, inner, [value]);
+        inner.writes.set(slot, typeof p.seq === "number" ? p.seq : 0);
+        return value;
+    }
+    const { base, seq } = patch;
+    if (!Number.isInteger(base) ||
+        !Number.isInteger(seq) ||
+        base < 0 ||
+        seq < 1)
+        throw new HostError("invalid", "patch.base and patch.seq require non-negative integers (seq ≥ 1)");
+    const stale = () => new HostError("stale", "the property changed since the write this patch applies on; send the whole value");
+    if ((inner.writes.get(slot) ?? 0) !== base || !Array.isArray(current))
+        throw stale();
+    const ops = patchOps(patch.ops, current.length);
+    const resolved = ops.map((op) => op.op === "set"
+        ? { ...op, row: shownValues(host, inner, op.row) }
+        : op.op === "insert"
+            ? { ...op, rows: op.rows.map((row) => shownValues(host, inner, row)) }
+            : op);
+    const value = applyOps(current, resolved);
+    checkValues(host, inner, { [property]: value });
+    seeImages(host, inner, resolved.flatMap((op) => op.op === "set" ? [op.row] : op.op === "insert" ? op.rows : []));
+    inner.writes.set(slot, seq);
+    return value;
+}
+/**
+ * Refuse property values over the player's limits ({@link UI_VALUE_LIMITS})
+ * with `limit`, naming the property, as the player does.
+ */
+export function checkValues(_host, _inner, values) {
+    for (const [property, value] of Object.entries(values)) {
+        const problem = valueLimitProblem(value);
+        if (problem)
+            throw new HostError("limit", `${property}: ${problem}`);
+    }
+}
+/**
+ * A panel's or settings page's initial properties, as the player keeps
+ * them: one over the limits is left out (the property keeps its default)
+ * and reported with `ui.error`, the request itself succeeds.
+ */
+export function initialValues(host, _inner, values) {
+    const kept = {};
+    for (const [property, value] of Object.entries(values)) {
+        const problem = valueLimitProblem(value);
+        if (problem)
+            host.emit("ui.error", {
+                code: "limit",
+                message: `${property}: ${problem}`,
+            });
+        else
+            kept[property] = value;
+    }
+    return kept;
+}
+export function seeImages(host, _inner, values) {
+    const see = (value) => {
+        const path = host.imagePath(value);
+        if (path !== null) {
+            const { ref, maxSide } = value;
+            host.images.push({
+                path,
+                ref: Number(ref),
+                ...(maxSide === undefined ? {} : { maxSide }),
+            });
+        }
+        else if (value !== null && typeof value === "object")
+            for (const item of Object.values(value))
+                see(item);
+    };
+    for (const value of Object.values(values))
+        see(value);
+}
+export function addPanel(host, _inner, slot, panel) {
+    const state = host.layout[slot];
+    if (state)
+        state.panels = [...(state.panels ?? []), panel];
+    else {
+        // The adjust column starts hidden, as the player's.
+        const shown = slot !== "adjust";
+        host.layout[slot] = {
+            owner: panel.owner,
+            preferred: shown,
+            effective: shown,
+            reason: shown ? null : "userHidden",
+            detached: false,
+            panels: [panel],
+        };
+    }
+}
+export function removePanel(host, _inner, slot, owner) {
+    const state = host.layout[slot];
+    if (!state)
+        return;
+    const panels = state.panels ?? [];
+    const index = panels.findIndex((panel) => panel.owner === owner);
+    const rest = panels.filter((panel) => panel.owner !== owner);
+    if (rest.length === 0) {
+        host.layout[slot] = null;
+        return;
+    }
+    state.panels = rest;
+    if (state.owner === owner)
+        state.owner = (rest[index] ?? rest[rest.length - 1]).owner;
+}
+/** The panel a request is about: its `slot`, else the only one. */
+export function panelFor(host, _inner, p) {
+    const slot = typeof p.slot === "string" ? p.slot : undefined;
+    const panel = slot ? host.panels.get(slot) : host.panel;
+    if (!panel)
+        throw new HostError("missing", "owner has no ready mount");
+    return panel;
+}
+/** Implements `TestHost.mountOther`. */
+export function mountOther(host, inner, slot, plugin, options = {}) {
+    if (inner.others.has(plugin))
+        throw new Error(`${plugin} already has a panel`);
+    const owner = inner.nextOwner++;
+    if (slot === "backdrop") {
+        if (host.backdrop)
+            throw new Error("the backdrop is taken");
+        host.backdrop = { owner: plugin, effective: true };
+    }
+    else {
+        if (slot === "bottom" && host.layout.bottom)
+            throw new Error("the bottom bar is taken");
+        addPanel(host, inner, slot, {
+            owner,
+            plugin,
+            title: options.title ?? plugin,
+        });
+    }
+    inner.others.set(plugin, { slot, owner });
+    host.emit("window.state", windowFacts(host, inner));
+}
+/** Implements `TestHost.unmountOther`. */
+export function unmountOther(host, inner, plugin) {
+    const other = inner.others.get(plugin);
+    if (!other)
+        throw new Error(`${plugin} has no panel`);
+    inner.others.delete(plugin);
+    if (other.slot === "backdrop")
+        host.backdrop = null;
+    else
+        removePanel(host, inner, other.slot, other.owner);
+    host.emit("window.state", windowFacts(host, inner));
+}
+/** Implements `TestHost.mounted`. */
+export function mounted(host, _inner, slot) {
+    if (slot !== undefined) {
+        const panel = host.panels.get(slot);
+        if (!panel)
+            throw new Error(`no panel mounted in the ${slot}`);
+        return panel;
+    }
+    if (host.panels.size > 1)
+        throw new Error(`panels are mounted in ${[...host.panels.keys()].join(", ")}: name the slot`);
+    if (!host.panel)
+        throw new Error("no panel mounted");
+    return host.panel;
+}
+/** Implements `TestHost.setTimelineRanges`. */
+export function setTimelineRanges(host, inner, pluginId, ranges) {
+    if (ranges.length)
+        host.timeline.rangeLayers.set(pluginId, ranges.map((r) => ({
+            start: r.start,
+            end: r.end,
+            style: r.style,
+            title: r.title ?? null,
+        })));
+    else
+        host.timeline.rangeLayers.delete(pluginId);
+    timelineChanged(host, inner);
+}
+/** Implements `TestHost.setTimelineLayer`. */
+export function setTimelineLayer(host, inner, pluginId, marks) {
+    if (marks.length)
+        host.timeline.layers.set(pluginId, marks.map((m) => ({
+            time: m.time,
+            kind: m.kind,
+            title: m.title ?? null,
+        })));
+    else
+        host.timeline.layers.delete(pluginId);
+    timelineChanged(host, inner);
+}
+/** The default handlers of this area's wire methods, by method name. */
+export function layoutHandlers(host, inner) {
+    return {
+        "ui.open": (p) => {
+            const id = String(p.id);
+            if (host.windows.has(id))
+                throw new HostError("conflict", "view already exists");
+            resetWrites(host, inner, `w:${id}`);
+            const properties = shownValues(host, inner, p.properties);
+            checkValues(host, inner, properties);
+            seeImages(host, inner, properties);
+            host.windows.set(id, {
+                file: String(p.file),
+                visible: true,
+                props: { ...properties },
+                callbacks: p.callbacks,
+                userClose() {
+                    host.windows.delete(id);
+                    host.emit("ui.closed", { view: id });
+                },
+                emit(callback, ...args) {
+                    const name = kebab(callback);
+                    if (!this.callbacks.includes(name))
+                        throw new Error(`window ${id} did not register callback ${name}`);
+                    host.emit("ui.callback", { view: id, callback: name, args });
+                },
+            });
+        },
+        "ui.set": (p) => {
+            const window = host.windows.get(String(p.id));
+            if (!window)
+                throw new HostError("missing", "view not found");
+            const property = String(p.property);
+            const next = writeProperty(host, inner, `w:${String(p.id)}`, property, p, window.props[property]);
+            // A part of a value sent in parts is held until the last (player 0.6.0).
+            if (next !== undefined)
+                window.props[property] = next;
+        },
+        "ui.show": (p) => {
+            const window = host.windows.get(String(p.id));
+            if (!window)
+                throw new HostError("missing", "view not found");
+            window.visible = p.visible === true;
+        },
+        "ui.close": (p) => {
+            if (!host.windows.delete(String(p.id)))
+                throw new HostError("missing", "view not found");
+        },
+        "ui.mount": (p) => {
+            if (!(String(p.slot) in SLOT_LABELS))
+                throw new HostError("invalid", "unknown mount slot");
+            // One panel per slot and plugin (player 0.7.6).
+            if (host.panels.has(String(p.slot)))
+                throw new HostError("conflict", "this plugin already has a panel in this slot");
+            // Like the player: one panel in the bottom bar and the backdrop, any
+            // number of tabs in the sidebar (player 0.7.3; 0.4.x to 0.7.2 took 8)
+            // and in the adjust column (player 0.7.6).
+            const holder = p.slot === "backdrop"
+                ? host.backdrop?.owner
+                : p.slot === "bottom"
+                    ? host.layout.bottom?.panels?.[0]?.plugin
+                    : undefined;
+            if (holder !== undefined || (p.slot === "bottom" && host.layout.bottom))
+                throw taken(hostText(host, inner, "The {} is used by {}", [
+                    hostText(host, inner, SLOT_LABELS[String(p.slot)]),
+                    String(holder),
+                ]));
+            const properties = initialValues(host, inner, shownValues(host, inner, p.properties));
+            seeImages(host, inner, properties);
+            const panelSlot = String(p.slot);
+            resetWrites(host, inner, mountView(panelSlot));
+            host.panels.set(panelSlot, {
+                slot: panelSlot,
+                file: String(p.file),
+                component: String(p.component),
+                visible: true,
+                props: { ...properties },
+                locks: null,
+                emit(callback, ...args) {
+                    host.emit("ui.callback", {
+                        view: "$mount",
+                        slot: panelSlot,
+                        callback: kebab(callback),
+                        args,
+                    });
+                },
+            });
+            if (p.slot === "backdrop") {
+                host.backdrop = { owner: host.manifestId, effective: true };
+                return { status: "ready", prepareMs: 0, shellGeneration: 1 };
+            }
+            const slot = String(p.slot);
+            addPanel(host, inner, slot, {
+                owner: 1,
+                plugin: host.manifestId,
+                title: typeof p.title === "string" && p.title
+                    ? host.translate(p.title)
+                    : host.manifestId,
+            });
+            return { status: "ready", prepareMs: 0, shellGeneration: 1 };
+        },
+        "ui.unmount": (p) => {
+            // The slot's panel, or without one every panel (as the player).
+            const slots = typeof p.slot === "string" ? [p.slot] : [...host.panels.keys()];
+            for (const slot of slots) {
+                if (!host.panels.delete(slot))
+                    continue;
+                if (slot === "backdrop")
+                    host.backdrop = null;
+                else
+                    removePanel(host, inner, slot, 1);
+            }
+        },
+        "ui.menu": (p) => {
+            if (!host.panels.size)
+                throw new HostError("unavailable", "panel not shown");
+            const panel = panelFor(host, inner, p);
+            const tabs = panel.slot === "sidebar" || panel.slot === "adjust"
+                ? host.layout[panel.slot]
+                : null;
+            if (tabs && tabs.owner !== 1)
+                throw new HostError("unavailable", "the panel's tab is not the current one");
+            const items = p.items;
+            for (const id of items)
+                if (id !== null && !host.commands.has(id))
+                    throw new HostError("missing", `command ${id} not registered`);
+            host.menus.push({ items, x: Number(p.x), y: Number(p.y) });
+        },
+        "layout.state": () => ({
+            ...host.layout,
+            backdrop: host.backdrop && {
+                owner: 1,
+                effective: host.backdrop.effective,
+            },
+        }),
+        "layout.set": (p) => {
+            const slot = String(p.slot);
+            if (!["bottom", "sidebar", "adjust"].includes(slot))
+                throw new HostError("invalid", "unknown slot");
+            const state = host.layout[slot];
+            if (!state)
+                throw new HostError("missing", "no panel at this position");
+            if (p.detached !== undefined && slot === "bottom")
+                throw new HostError("invalid", "the bottom bar cannot be detached");
+            if (p.detached === true && slot === "adjust")
+                throw new HostError("invalid", "the adjust column cannot be detached");
+            if (p.active !== undefined && p.active !== null) {
+                const panel = state.panels?.find((entry) => entry.plugin === p.active);
+                if (!panel)
+                    throw new HostError("missing", `${String(p.active)} has no panel at this position`);
+                state.owner = panel.owner;
+            }
+            if (typeof p.visible === "boolean") {
+                const out = state.preferred && state.effective;
+                state.preferred = p.visible;
+                // In fullscreen a column switched on by a toggle (`reveal: false`)
+                // stays collapsed at the edge; `show()` and `setVisible` pop it out.
+                const collapsed = p.visible &&
+                    p.reveal === false &&
+                    slot !== "bottom" &&
+                    host.mainWindow.fullscreen &&
+                    !state.detached &&
+                    !out;
+                state.effective = p.visible && !collapsed;
+                state.reason = !p.visible
+                    ? "userHidden"
+                    : collapsed
+                        ? "fullscreen"
+                        : null;
+                const panel = host.panels.get(slot);
+                if (panel)
+                    panel.visible = p.visible;
+            }
+            if (typeof p.detached === "boolean")
+                state.detached = p.detached;
+        },
+        "ui.setMount": (p) => {
+            const panel = panelFor(host, inner, p);
+            const property = String(p.property);
+            const next = writeProperty(host, inner, mountView(panel.slot), property, p, panel.props[property]);
+            // A part of a value sent in parts is held until the last (player 0.6.0).
+            if (next !== undefined)
+                panel.props[property] = next;
+        },
+        "timeline.marks": () => ({
+            marks: host.timeline.marks,
+            ranges: host.timeline.ranges,
+        }),
+        "timeline.set": (p) => {
+            if (p.sourceId !== undefined &&
+                p.sourceId !== host.source.stamp.generation)
+                return { applied: false };
+            const sent = p.marks;
+            const duration = host.source.duration;
+            if (!Array.isArray(sent) || sent.length > 1000)
+                throw new HostError("invalid", "a layer holds at most 1000 marks");
+            const marks = sent.map((mark) => ({ ...mark }));
+            for (const mark of marks) {
+                const time = mark.time;
+                if (typeof time !== "number" ||
+                    !Number.isFinite(time) ||
+                    time < 0 ||
+                    (duration !== null && time > duration))
+                    throw new HostError("invalid", `time ${time} is outside the media`);
+                if (!["chapter", "bookmark", "marker"].includes(String(mark.kind)))
+                    throw new HostError("invalid", "kind is chapter, bookmark or marker");
+                // A text value is shown translated (`plugin.i18n.text`).
+                if (isTextValue(mark.title))
+                    mark.title = declaredText(host, inner, mark.title, "title");
+                if (mark.title !== undefined &&
+                    mark.title !== null &&
+                    (typeof mark.title !== "string" || [...mark.title].length > 100))
+                    throw new HostError("invalid", "title must be ≤ 100 characters");
+            }
+            host.setTimelineLayer(host.manifestId, marks.map((m) => ({
+                time: m.time,
+                kind: String(m.kind),
+                title: m.title ?? null,
+            })));
+            return { applied: true };
+        },
+        // Player 0.7.6: the layer's ranges, replaced on their own.
+        "timeline.setRanges": (p) => {
+            if (p.sourceId !== undefined &&
+                p.sourceId !== host.source.stamp.generation)
+                return { applied: false };
+            const sent = p.ranges;
+            const duration = host.source.duration;
+            if (!Array.isArray(sent) || sent.length > TIMELINE_LIMITS.ranges)
+                throw new HostError("invalid", `a layer holds at most ${TIMELINE_LIMITS.ranges} ranges`);
+            const ranges = sent.map((range) => ({ ...range }));
+            for (const range of ranges) {
+                const { start, end } = range;
+                const time = (t) => typeof t === "number" && Number.isFinite(t) && t >= 0;
+                if (!time(start) || !time(end))
+                    throw new HostError("invalid", "start and end must be numbers ≥ 0");
+                if (end <= start)
+                    throw new HostError("invalid", `end ${end} must be after start ${start}`);
+                // As the player (timeline.rs): 1e-6 s of rounding past the end is allowed.
+                if (duration !== null && end > duration + 1e-6)
+                    throw new HostError("invalid", `end ${end} is after the end of the media`);
+                if (!["selection", "region"].includes(String(range.style)))
+                    throw new HostError("invalid", "style is selection or region");
+                if (isTextValue(range.title))
+                    range.title = declaredText(host, inner, range.title, "title");
+                if (range.title !== undefined &&
+                    range.title !== null &&
+                    (typeof range.title !== "string" ||
+                        [...range.title].length > TIMELINE_LIMITS.titleChars))
+                    throw new HostError("invalid", `title must be ≤ ${TIMELINE_LIMITS.titleChars} characters`);
+            }
+            host.setTimelineRanges(host.manifestId, ranges.map((r) => ({
+                start: r.start,
+                end: r.end,
+                style: String(r.style),
+                title: r.title ?? null,
+            })));
+            return { applied: true };
+        },
+        "ui.interaction": (p) => {
+            const { slot: _, ...locks } = p;
+            panelFor(host, inner, p).locks = locks;
+        },
+        "ui.markdownScan": (p) => {
+            const text = String(p.text);
+            const images = [
+                ...text.matchAll(/!\[[^\]]*\]\((https?:\/\/[^)\s]+)\)/g),
+            ].map((m) => m[1]);
+            return { images: [...new Set(images)].slice(0, 64) };
+        },
+    };
+}

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

@@ -0,0 +1,55 @@
+import type { Json } from "../../wire.ts";
+import type { SourceState } from "../../source.ts";
+import type { TestHost } from "./index.ts";
+import type { Handler, Internals } from "./internals.ts";
+export declare function initialSource(): SourceState;
+export declare const readyCapabilities: {
+    pause: boolean;
+    seek: boolean;
+    rate: boolean;
+    restart: boolean;
+    close: boolean;
+    snapshotSource: boolean;
+};
+export declare function sourceIntent(host: TestHost, inner: Internals, intent: Record<string, Json>): {
+    ticket: Json;
+};
+/** The file resolver of this plugin that claims `source`, if any. */
+export declare function fileResolver(host: TestHost, _inner: Internals, source: string): string | null;
+/** Retire the producer that is the player's source, unless it is `keep`. */
+export declare function retireSelected(host: TestHost, inner: Internals, keep: number | null): void;
+/** Whether producer `id` is the player's source. */
+export declare function isCurrentProducer(host: TestHost, inner: Internals, id: number): boolean;
+/** Start resolving `source` for the open just made; its request id, or null. */
+export declare function startResolution(host: TestHost, inner: Internals, source: string, paused: boolean, operation?: number): number | null;
+/** Settle a resolution's open; `error` fails it. */
+export declare function settleResolution(host: TestHost, inner: Internals, requestId: number, error?: string): void;
+/** Resolutions whose open is no longer the source (or whose resolver left). */
+export declare function cancelResolutions(host: TestHost, inner: Internals): void;
+/** `sourceResolvers.register`: the player's rules for both forms. */
+export declare function registerResolver(host: TestHost, inner: Internals, p: Record<string, Json>): void;
+/** `sourceResolvers.respond` for a simulated file resolution. */
+export declare function respondResolution(host: TestHost, inner: Internals, p: Record<string, Json>): {
+    stamp: {
+        generation: number;
+        intentVersion: number;
+    };
+} | null;
+/** Audio track calls need ready media and the source the caller saw. */
+export declare function audioCondition(host: TestHost, _inner: Internals, expected: Json | undefined): void;
+/** `stale` unless `expected` is the current subtitle stamp. */
+export declare function subtitleExpected(host: TestHost, _inner: Internals, expected: Json): void;
+export declare function loadedSubtitles(host: TestHost, inner: Internals): Map<string, number>;
+/**
+ * The player's `SUBTITLE_LIMITS` for a new resource (`busy`, as the
+ * player reports them). External tracks in `subtitles.tracks` that this
+ * plugin did not load count as other plugins'. `totalBytes` is not
+ * modelled: one plugin's 4 files of at most 2 MiB stay below it, and the
+ * bytes of other plugins' tracks are unknown.
+ */
+export declare function subtitleRoom(host: TestHost, inner: Internals, resourceId: string): void;
+export declare function subtitleChange(host: TestHost, inner: Internals, expected: Json): void;
+/** Implements `TestHost.setSource`. */
+export declare function setSource(host: TestHost, _inner: Internals, patch: Partial<SourceState>): void;
+/** The default handlers of this area's wire methods, by method name. */
+export declare function mediaHandlers(host: TestHost, inner: Internals): Record<string, Handler>;