@vestra-player/sdk 1.5.17 → 1.5.20

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.5.20
+
+Republishes 1.5.19, which was tagged but never published: its API documentation build failed (an example title and four undocumented `IMAGE_LIMITS` fields). Documentation only; the code is the same as 1.5.19 below.
+
+## 1.5.19
+
+Images in list rows, restarting a plugin, and keyframe step seeks (player 0.5.1). Additive; `apiVersion` stays `vestra/1`, and plugins that do not use the new members need no change. Requested by the plugin store (STORE-ROW-LOGO, STORE-RELOAD-BUILTIN) and the playback plugin (keyframe seeks); the online video plugins' search results need the same row images.
+
+- **`ImageRef` at any depth** (`PropData` includes `ImageRef`): an image from `ui.image` goes wherever the Slint type is `image`, also a field of a struct or a row of a model, for example `rows: [{ key, name, icon: plugin.ui.image(path) }]` with `struct Row { key: string, name: string, icon: image }`. Players before 0.5.1 refuse a nested image with `invalid`, as the SDK did until now. A nested image whose file fails the player's checks is drawn empty and the rest of the value is shown; a released image is refused at any depth. Rows with images update in place in the player (a `ListView` keeps its scroll position).
+- **`ui.image(path, { maxSide })`** and the new **`ImageOptions`**: decode the image scaled down, aspect kept, so that neither side is over `maxSide` (1–4096). Use about twice the drawn size for logos and thumbnails. Players before 0.5.1 refuse a reference with `maxSide`; without it the wire form is unchanged.
+- **Per-view image budget** (player 0.5.1): the images nested in one view's values may show at most 32 MB of decoded pixels together; a write past it is refused with `limit`. **`IMAGE_LIMITS`** (`@vestra-player/sdk/runtime` and `/testing`) lists the player's image limits.
+- **`ui.remoteImage(url, options?)`**: downloads an `https:` PNG or JPEG into `<dataDirectory>/.vestra-cache/images/` with the Markdown image rules (4 MB, 10 s, 4 at a time per plugin, a 32 MB cache refreshed after a day) and resolves with an `ImageRef`; rejects `unavailable` when the download fails. Works with any player; nested, with 0.5.1.
+- **`Packages.reload(id)`** (`plugins.manage`, player 0.5.1): stop a plugin and start it again from the same package with the same data, built-ins included; a stopped or failed one is just started. The disabled flag is never written. `invalid` for oneself or a disabled plugin, `missing` unknown, `busy` while it is being installed or reloaded; `packages.onChange` shows `starting`, then `running` or `failed`. Listed in `CAPABILITY_INFO["plugins.manage"].apis`.
+- **`Player.setStepSeek({ seconds, keyframes })`** (player 0.5.1): with `keyframes: true` the step seeks land on a keyframe (forward at or after position + step, backward at or before position − step, always moving), presses during a seek add up from the landed position, and the on-screen text shows the landed time. Sources without moving video seek exactly; the seek bar, `player.seek`, scrubs, chapters, loops and `player.step` are unaffected. A non-boolean `keyframes` is `invalid`.
+- **`Host.run("seek-backward" | "seek-forward", { seconds })`** (player 0.5.1): one step seek of another step, with the core's checks, mode, accumulation and text. In keyframe mode it resolves once the seek has landed. `seconds` with another action, or outside 0.1–3600 in tenths, is `invalid`. Older players ignore `seconds`: set `"minPlayerVersion": "0.5.1"`.
+- **`TestHost`**: nested images are recorded in `host.images` (with `maxSide`); `ui.remoteImage` is served from `host.remoteImages`; `packages.reload` is modelled (`starting`, then `running`; `packageCalls` method `"reload"`); `stepSeekKeyframes`, the test data `keyframes` and the log `coreSeeks` model keyframe step seeks, and `host.run` takes `seconds`. The test host lands each press at once (the player completes presses that add up together, with one text).
+- Docs: *Windows, panels, settings pages* (images in rows), *Playback* (Step seeks: exact or keyframe); `llms.txt` and `llms-full.txt` regenerated.
+
+## 1.5.18
+
+Fixes for Windows and for a vendored SDK, and built-ins that can no longer be disabled. `apiVersion` stays `vestra/1`; plugins that do not manage other plugins need no change.
+
+- **`TestHost` streams on Windows**: `openStream`'s default transport listened on a socket file in the temp folder, which Windows refuses (`listen EACCES`), so stream tests failed there. It now listens on a named pipe (`\\.\pipe\vestra-test-host-…-producer-<id>`) on Windows and on a Unix socket elsewhere. `producerTransport = "tcp"` still gives the player's own Windows transport (loopback TCP with a token).
+- **The CLI runs from an SDK outside any `node_modules`** (a copy with TypeScript on `NODE_PATH`, as the player's AI workshop vendors it): `dist/i18n-tools.js` resolved TypeScript with a bare ES module import, which ignores `NODE_PATH`, so `vestra-plugin` stopped at start with `ERR_MODULE_NOT_FOUND`. It now resolves TypeScript as the rest of the CLI does.
+- **Built-in plugins cannot be disabled** (user ruling, 2026-10-26: users manage third-party plugins only). The player and `TestHost` answer `packages.setEnabled(builtin, false)` with `unsupported`; a built-in an older player let the user disable runs again after the upgrade. `PluginInfo.builtin`, `Packages.setEnabled` and *Migrating off package rollback* say so; a plugin manager offers no action for a built-in.
+
 ## 1.5.17
 
 **Package rollback is removed**, as announced in 1.5.16: the player keeps no previous plugin version. `apiVersion` stays `vestra/1` (a patch release, as when 1.5.8 removed `PackageCandidate.trial()`); plugins that do not manage other plugins need no change. A plugin manager that still calls `rollback` or reads `previousVersion` no longer compiles. Migration: [Migrating off package rollback](docs/how-to/rollback-migration.md).

package/dist/capabilities.js

@@ -131,6 +131,7 @@ export const CAPABILITY_INFO = Object.freeze({
             "Packages.validate",
             "Packages.validateArchive",
             "Packages.setEnabled",
+            "Packages.reload",
             "Packages.uninstall",
         ],
         requires: [],

package/dist/commands.js

@@ -401,7 +401,6 @@ vestra.preferences | options | Settings ▸ Options… | F5
 vestra.hotkeys | keys | Settings ▸ Keyboard Shortcuts…
 vestra.hotkeys | mouse | Settings ▸ Mouse…
 vestra.hotkeys | ignore-defaults | Settings ▸ Ignore Default Shortcuts
-vestra.plugins | manage | Settings ▸ Plugin Manager…
 vestra.preferences | theme.vestra | Settings ▸ Appearance ▸ Vestra Dark
 vestra.preferences | theme.vestra-light | Settings ▸ Appearance ▸ Vestra Light
 vestra.visualizer | idle-logo | Settings ▸ Appearance ▸ Show Logo When Idle

package/dist/i18n-tools.d.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type TS from "typescript";
 /** A translatable text found in the sources. */
 export interface Message {
     context?: string;
@@ -27,7 +27,7 @@ export interface ExtractOptions {
     /** The plugin's production `.ts` / `.mts` files, relative to `directory`. */
     typescript: readonly string[];
     /** Compiler options for a program over those files (as `check` uses). */
-    compilerOptions?: ts.CompilerOptions;
+    compilerOptions?: TS.CompilerOptions;
 }
 export declare const pluralForms: (language: string) => "nplurals=1; plural=0;" | "nplurals=2; plural=(n != 1);";
 /** Find every translatable text of a plugin, in reference order. */

package/dist/i18n-tools.js

@@ -1,3 +1,11 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 /**
  * `vestra-plugin i18n extract` and `vestra-plugin i18n check`, and the
  * catalog step of `vestra-plugin build` (docs/how-to/i18n.md): find the
@@ -16,9 +24,19 @@
  * @module
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
+import { createRequire } from "node:module";
 import { join, relative, sep } from "node:path";
-import ts from "typescript";
+import { pathToFileURL } from "node:url";
 import { compileCatalog, keyOf, LOCALES, parsePo, placeholders, scanSlint, writePo, } from "./i18n.js";
+/**
+ * The SDK's TypeScript dependency, resolved the way the CLI resolves it
+ * (`compiler()` in bin/vestra-plugin.mjs): through `require` resolution from
+ * this package, which also searches `NODE_PATH`. A bare `import` of
+ * "typescript" would search only ancestor `node_modules` directories, so an
+ * SDK copied outside any (the player's AI workshop vendors one, and supplies
+ * TypeScript on `NODE_PATH`) could not start the CLI.
+ */
+const ts = (await import(__rewriteRelativeImportExtension(pathToFileURL(createRequire(import.meta.url).resolve("typescript")).href))).default;
 /** Locales whose plural has one form (`n == 1` and other are the same). */
 const ONE_FORM = new Set(["zh-Hans", "ja", "ko"]);
 export const pluralForms = (language) => ONE_FORM.has(language)

package/dist/player-runtime.d.ts

@@ -20,4 +20,4 @@ export { THEME_PALETTES } from "./palettes.ts";
 export { Catalog, HOST_ZH_HANS, LIST_SEPARATORS, LOCALES, MENU_KEYS, matchLocale, parsePo, rewriteSlint, renderText, scanSlint, TEXT_LIMITS, textKey, textProblem, } from "./i18n.ts";
 export { MANIFEST_FIELDS, MANIFEST_LIMITS } from "./manifest.ts";
 export { MARKDOWN_LIMITS } from "./plugin/markdown.ts";
-export { UI_VALUE_LIMITS } from "./plugin/values.ts";
+export { IMAGE_LIMITS, UI_VALUE_LIMITS } from "./plugin/values.ts";

package/dist/player-runtime.js

@@ -18,4 +18,4 @@ export { THEME_PALETTES } from "./palettes.js";
 export { Catalog, HOST_ZH_HANS, LIST_SEPARATORS, LOCALES, MENU_KEYS, matchLocale, parsePo, rewriteSlint, renderText, scanSlint, TEXT_LIMITS, textKey, textProblem, } from "./i18n.js";
 export { MANIFEST_FIELDS, MANIFEST_LIMITS } from "./manifest.js";
 export { MARKDOWN_LIMITS } from "./plugin/markdown.js";
-export { UI_VALUE_LIMITS } from "./plugin/values.js";
+export { IMAGE_LIMITS, UI_VALUE_LIMITS } from "./plugin/values.js";

package/dist/plugin/local.d.ts

@@ -4,4 +4,11 @@ import type { LocalServices } from "../wire.ts";
  * `ffmpeg` with each `PATHEXT` extension (`ffmpeg.exe` first by default).
  */
 export declare function executableNames(tool: string, platform?: NodeJS.Platform, pathext?: string | undefined): string[];
+/**
+ * Where a local stream listens: a Unix socket file `<name>.sock` in
+ * `directory` on macOS and Linux; on Windows a named pipe
+ * (`\\.\pipe\<directory's name>-<name>`), which Node's `net` listens on and
+ * connects to by that path (a socket file there fails with `EACCES`).
+ */
+export declare function localSocketPath(directory: string, name: string, platform?: NodeJS.Platform): string;
 export declare const systemServices: LocalServices;

package/dist/plugin/local.js

@@ -31,6 +31,18 @@ export function executableNames(tool, platform = process.platform, pathext = pro
         .filter((extension) => extension.startsWith("."));
     return [...new Set(extensions)].map((extension) => tool + extension);
 }
+/**
+ * Where a local stream listens: a Unix socket file `<name>.sock` in
+ * `directory` on macOS and Linux; on Windows a named pipe
+ * (`\\.\pipe\<directory's name>-<name>`), which Node's `net` listens on and
+ * connects to by that path (a socket file there fails with `EACCES`).
+ */
+export function localSocketPath(directory, name, platform = process.platform) {
+    if (platform !== "win32")
+        return join(directory, `${name}.sock`);
+    const scope = directory.split(/[\\/]/).filter(Boolean).at(-1) ?? "vestra";
+    return `\\\\.\\pipe\\${scope}-${name}`;
+}
 async function executable(path) {
     try {
         await access(path, constants.X_OK);

package/dist/plugin/markdown.d.ts

@@ -1,4 +1,5 @@
 import type { Json } from "../wire.ts";
+import type { Runtime } from "./runtime.ts";
 import type { ScopeImpl } from "./scope.ts";
 import type { MarkdownOptions, MarkdownRef } from "./types.ts";
 export declare const MARKDOWN_LIMITS: Readonly<{
@@ -37,4 +38,10 @@ export declare function httpsDownload(url: string, options: {
     maxBytes: number;
     signal: AbortSignal;
 }, fetchImpl?: typeof fetch): Promise<Uint8Array>;
+/**
+ * `ui.remoteImage`: the local copy of an `https:` image in
+ * `<dataDirectory>/.vestra-cache/images/` (the Markdown limits: 4 MB, 10 s,
+ * 4 at a time per plugin, 32 MB of cache, a day). Rejects `unavailable`.
+ */
+export declare function remoteImageFile(runtime: Runtime, url: string): Promise<string>;
 export declare function markdown(scope: ScopeImpl, text: string, options?: MarkdownOptions): Promise<MarkdownRef>;

package/dist/plugin/markdown.js

@@ -113,33 +113,12 @@ async function fetchImages(runtime, urls) {
         return {};
     const cache = join(data, ".vestra-cache", "markdown");
     await mkdir(cache, { recursive: true });
-    const download = runtime.local?.download ?? httpsDownload;
     const found = {};
     const queue = [...new Set(urls)].filter((u) => u.startsWith("https://"));
     const worker = async () => {
         for (let url = queue.shift(); url !== undefined; url = queue.shift()) {
-            const file = join(cache, createHash("sha256").update(url).digest("hex"));
             try {
-                const info = await stat(file).catch(() => null);
-                const now = Date.now();
-                if (info && now - info.mtimeMs < MARKDOWN_LIMITS.cacheMaxAgeMs) {
-                    const time = new Date(info.mtimeMs);
-                    await utimes(file, new Date(now), time).catch(() => { });
-                    found[url] = file;
-                    continue;
-                }
-                const bytes = await download(url, {
-                    maxBytes: MARKDOWN_LIMITS.imageBytes,
-                    signal: AbortSignal.timeout(MARKDOWN_LIMITS.imageTimeoutMs),
-                });
-                if (bytes.length > MARKDOWN_LIMITS.imageBytes)
-                    throw new Error("image too large");
-                if (!isPng(bytes) && !isJpeg(bytes))
-                    throw new Error("not a PNG or JPEG image");
-                const temporary = `${file}.${process.pid}.tmp`;
-                await writeFile(temporary, bytes);
-                await rename(temporary, file);
-                found[url] = file;
+                found[url] = (await cached(runtime, cache, url)).file;
             }
             catch {
                 // Shown as its alt text.
@@ -150,6 +129,67 @@ async function fetchImages(runtime, urls) {
     await trim(cache, new Set(Object.values(found)));
     return found;
 }
+/**
+ * The cached copy of `url` in `cache`, downloaded when missing or older than
+ * a day; throws why it could not be had. `fresh`: it was downloaded now.
+ */
+async function cached(runtime, cache, url) {
+    const file = join(cache, createHash("sha256").update(url).digest("hex"));
+    const info = await stat(file).catch(() => null);
+    const now = Date.now();
+    if (info && now - info.mtimeMs < MARKDOWN_LIMITS.cacheMaxAgeMs) {
+        const time = new Date(info.mtimeMs);
+        await utimes(file, new Date(now), time).catch(() => { });
+        return { file, fresh: false };
+    }
+    const download = runtime.local?.download ?? httpsDownload;
+    const bytes = await download(url, {
+        maxBytes: MARKDOWN_LIMITS.imageBytes,
+        signal: AbortSignal.timeout(MARKDOWN_LIMITS.imageTimeoutMs),
+    });
+    if (bytes.length > MARKDOWN_LIMITS.imageBytes)
+        throw new Error("image too large");
+    if (!isPng(bytes) && !isJpeg(bytes))
+        throw new Error("not a PNG or JPEG image");
+    const temporary = `${file}.${process.pid}.tmp`;
+    await writeFile(temporary, bytes);
+    await rename(temporary, file);
+    return { file, fresh: true };
+}
+/** `ui.remoteImage` downloads in flight and waiting, per plugin. */
+const slots = new WeakMap();
+/**
+ * `ui.remoteImage`: the local copy of an `https:` image in
+ * `<dataDirectory>/.vestra-cache/images/` (the Markdown limits: 4 MB, 10 s,
+ * 4 at a time per plugin, 32 MB of cache, a day). Rejects `unavailable`.
+ */
+export async function remoteImageFile(runtime, url) {
+    const data = runtime.dataDirectory;
+    if (!data)
+        throw failure("unavailable", "the plugin has no data directory");
+    const cache = join(data, ".vestra-cache", "images");
+    let slot = slots.get(runtime);
+    if (!slot)
+        slots.set(runtime, (slot = { active: 0, waiting: [] }));
+    const queue = slot;
+    if (queue.active >= MARKDOWN_LIMITS.concurrency)
+        await new Promise((go) => queue.waiting.push(go));
+    queue.active += 1;
+    try {
+        await mkdir(cache, { recursive: true });
+        const { file, fresh } = await cached(runtime, cache, url);
+        if (fresh)
+            await trim(cache, new Set([file]));
+        return file;
+    }
+    catch (error) {
+        throw failure("unavailable", `image ${url}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        queue.active -= 1;
+        queue.waiting.shift()?.();
+    }
+}
 /** Keep the cache under its size: drop the least recently used files not in use. */
 async function trim(cache, keep) {
     const files = [];

package/dist/plugin/packages.js

@@ -141,6 +141,11 @@ export const packages = (scope) => ({
             throw failure("invalid", "setEnabled takes an id and a boolean");
         await scope.runtime.host.packages.setEnabled(id, enabled);
     },
+    async reload(id) {
+        if (typeof id !== "string" || !id)
+            throw failure("invalid", "reload takes a plugin id");
+        await scope.runtime.host.packages.reload(id);
+    },
     uninstall: (id, options = {}) => change(scope, (requestId, revision) => scope.runtime.host.packages.uninstall(id, options.removeData === true, revision, requestId), id),
 });
 const info = (plugin) => Object.freeze({

package/dist/plugin/player.d.ts

@@ -4,6 +4,8 @@ import type { Runtime } from "./runtime.ts";
 import type { ScopeImpl } from "./scope.ts";
 import type { Conditional, Disposable, Player, PlayerState, PluginError } from "./types.ts";
 export declare const rawOf: (state: PlayerState) => SourceState | undefined;
+/** A step-seek length the player accepts: 0.1–3600 seconds in tenths. */
+export declare const validStep: (seconds: unknown) => seconds is number;
 export declare const sameStamp: (a: SourceStamp, b: SourceStamp) => boolean;
 export declare function abortError(): PluginError;
 /** One per plugin: the state store and the operation book client. */

package/dist/plugin/player.js

@@ -88,6 +88,12 @@ function decoding(hwdec) {
     return hwdec === "no" ? "software" : "hardware";
 }
 export const rawOf = (state) => raws.get(state);
+/** A step-seek length the player accepts: 0.1–3600 seconds in tenths. */
+export const validStep = (seconds) => typeof seconds === "number" &&
+    Number.isFinite(seconds) &&
+    seconds >= 0.1 &&
+    seconds <= 3600 &&
+    Math.abs(Math.round(seconds * 10) - seconds * 10) <= 1e-9;
 export const sameStamp = (a, b) => a.generation === b.generation && a.intentVersion === b.intentVersion;
 function sourceFailure(error) {
     return typeof error === "string"
@@ -529,13 +535,12 @@ export function player(scope) {
                 .refresh()
                 .catch(() => { });
         },
-        async setStepSeek({ seconds }) {
-            if (!Number.isFinite(seconds) ||
-                seconds < 0.1 ||
-                seconds > 3600 ||
-                Math.abs(Math.round(seconds * 10) - seconds * 10) > 1e-9)
+        async setStepSeek({ seconds, keyframes }) {
+            if (!validStep(seconds))
                 throw failure("invalid", "seconds must be 0.1–3600 in tenths");
-            await scope.runtime.host.step.setStepSeek(seconds);
+            if (keyframes !== undefined && typeof keyframes !== "boolean")
+                throw failure("invalid", "keyframes must be a boolean");
+            await scope.runtime.host.step.setStepSeek(seconds, keyframes);
         },
         async audioDevices() {
             const devices = await scope.runtime.host.audioOutput.devices();

package/dist/plugin/services.js

@@ -8,7 +8,7 @@ import { mkdir, open, rename, rm, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { failure } from "./runtime.js";
 import { systemServices } from "./local.js";
-import { playerOf } from "./player.js";
+import { playerOf, validStep } from "./player.js";
 const MAX_OUTPUT = 16 * 1024 * 1024;
 export const clipboard = (scope) => ({
     readText: () => scope.runtime.host.clipboard.readText(),
@@ -32,10 +32,17 @@ const ACTIONS = new Set([
     "mute",
 ]);
 export const host = (scope) => ({
-    async run(action) {
+    async run(action, options) {
         if (!ACTIONS.has(action))
             throw failure("invalid", `unknown host action ${String(action)}`);
-        await scope.runtime.host.host.run(action);
+        const seconds = options?.seconds;
+        if (options !== undefined) {
+            if (action !== "seek-backward" && action !== "seek-forward")
+                throw failure("invalid", `seconds applies only to seek-backward and seek-forward, not ${action}`);
+            if (!validStep(seconds))
+                throw failure("invalid", "seconds must be 0.1–3600 in tenths");
+        }
+        await scope.runtime.host.host.run(action, seconds);
         // Like the player's own controls: `player.state` shows the result.
         if (scope.runtime.can("playback.read"))
             await playerOf(scope.runtime)

package/dist/plugin/testing.d.ts

@@ -10,7 +10,7 @@ import { OSD_LIMITS } from "./osd.ts";
 import { SECRET_LIMITS } from "./services.ts";
 import { BINDING_INPUTS } from "./bindings.ts";
 import { THEME_PALETTES } from "../palettes.ts";
-import { UI_VALUE_LIMITS } from "./values.ts";
+import { IMAGE_LIMITS, UI_VALUE_LIMITS } from "./values.ts";
 import type { CommandDeclaration } from "../commands.ts";
 import type { SourceState } from "../source.ts";
 import type { SubtitleState } from "../subtitles.ts";
@@ -39,7 +39,7 @@ export { BINDING_INPUTS };
 /** The colours of the player's palettes, by `Theme` token. */
 export { THEME_PALETTES };
 /** The player's property value limits, which the test host enforces as well. */
-export { UI_VALUE_LIMITS };
+export { IMAGE_LIMITS, UI_VALUE_LIMITS };
 /**
  * The player's limits on one text value ({@link Text}, {@link TextList},
  * with everything nested in it), which the test host enforces as well:
@@ -618,14 +618,19 @@ export declare class TestHost implements Transport {
         title?: string | null;
     }[]): void;
     /**
-     * Runtime images written to views (`plugin.ui.image`), newest last. The
-     * SDK refuses images of released scopes before anything is sent.
+     * Runtime images written to views (`plugin.ui.image`,
+     * `plugin.ui.remoteImage`), whole values and (SDK 1.5.19) images nested
+     * in rows, newest last. The SDK refuses images of released scopes before
+     * anything is sent. The test host does not read the files, so it does not
+     * check the player's per-view budget (`IMAGE_LIMITS.viewBytes`).
      */
     readonly images: {
         /** The image file's path, as given to `ui.image`. */
         path: string;
         /** The SDK's reference number for that `ImageRef`. */
         ref: number;
+        /** Its `maxSide` option, when given. */
+        maxSide?: number;
     }[];
     /**
      * The file an image property shows, or `null` when the value is not a
@@ -917,8 +922,9 @@ export declare class TestHost implements Transport {
      */
     readonly jobs: Map<number, MediaJob>;
     /**
-     * `openStream`'s transport: a Unix socket (macOS, Linux) or, with `"tcp"`,
-     * loopback TCP where the plugin must send the token first (Windows).
+     * `openStream`'s transport: a local stream (a Unix socket on macOS and
+     * Linux, a named pipe on Windows) or, with `"tcp"`, loopback TCP where the
+     * plugin must send the token first, as the player on Windows answers.
      * Set it before the plugin calls `openStream`.
      */
     producerTransport: "unix" | "tcp";
@@ -1108,6 +1114,39 @@ export declare class TestHost implements Transport {
     constructor();
     /** The `player.setStepSeek` value in effect (default 5). */
     stepSeek: number;
+    /** The `player.setStepSeek` `keyframes` in effect (default `false`, SDK 1.5.19). */
+    stepSeekKeyframes: boolean;
+    /**
+     * Test data: the keyframe times (seconds, ascending) of the current
+     * source, for keyframe step seeks. `null` (the default): none modelled,
+     * and step seeks are exact even with `stepSeekKeyframes`.
+     *
+     * @example
+     * ```ts
+     * host.setSource({ phase: "ready", duration: 45, position: 12 });
+     * host.keyframes = [0, 10, 20, 30, 40];
+     * await plugin.player.setStepSeek({ seconds: 5, keyframes: true });
+     * await plugin.host.run("seek-forward");
+     * assert.equal(host.source.position, 20);
+     * assert.equal(host.osd.at(-1), "Forward 5 s: 00:20 / 00:45");
+     * ```
+     */
+    keyframes: number[] | null;
+    /**
+     * Every step seek the core ran (`seek-backward` / `seek-forward`, from a
+     * key, the menu or `host.run`), newest last: the step, whether it went to
+     * a keyframe, and where it landed.
+     */
+    readonly coreSeeks: {
+        /** `seek-backward` or `seek-forward`. */
+        action: string;
+        /** The step: `host.run`'s `seconds`, else `setStepSeek`'s. */
+        seconds: number;
+        /** It landed on a keyframe (`stepSeekKeyframes` and keyframes modelled). */
+        keyframes: boolean;
+        /** The new position. */
+        landed: number;
+    }[];
     /** Every `player.step`, newest last. */
     readonly steps: {
         /** `"frame"` or `"keyframe"`. */
@@ -1338,7 +1377,7 @@ export declare class TestHost implements Transport {
     /** Every `packages.setEnabled` / `uninstall` / `install`, newest last. */
     readonly packageCalls: {
         /** Which call. */
-        method: "setEnabled" | "uninstall" | "install";
+        method: "setEnabled" | "reload" | "uninstall" | "install";
         /** The target plugin id. */
         id: string;
         /** `setEnabled`'s value. */
@@ -1367,9 +1406,10 @@ export declare class TestHost implements Transport {
      */
     readonly candidates: Map<string, PackageManifest>;
     /**
-     * Remote Markdown images (`plugin.ui.markdown`): address → a local PNG or
-     * JPEG file served for it, or `null` for a failing download. Nothing is
-     * fetched from the network in tests; unknown addresses fail.
+     * Remote images (`plugin.ui.markdown`, `plugin.ui.remoteImage`): address
+     * → a local PNG or JPEG file served for it, or `null` for a failing
+     * download. Nothing is fetched from the network in tests; unknown
+     * addresses fail.
      */
     readonly remoteImages: Map<string, string | null>;
     /**