@vestra-player/sdk 1.5.33 → 1.5.34

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.5.34
+
+**Who must change: nobody.** Additions only, `apiVersion` stays `vestra/1`. A plugin that reads `SystemInfo.rendering` needs player 0.5.12 (`"minPlayerVersion": "0.5.12"`); older players leave the field out, and a plugin that does not read it sees no difference. Tests that load subtitles past the player's limits now fail with `busy` in `TestHost`, as they would in the player.
+
+- **`plugin.app.system()` reports the renderer** (player 0.5.12): `rendering` is `"gpu"` (render options apply) or `"software"` (they fail with `unsupported`), read at each call (an optional field: absent on players before 0.5.12, where the renderer is unknown), so a plugin can hide its render settings without creating `plugin.video.render()` to find out. No capability. It changes at most once while the player runs, from GPU to software when a window cannot show GPU frames. `TestHost` reports it from `videoRender.gpu`, so `failVideoRender("unsupported", …)` switches both.
+- **`SUBTITLE_LIMITS`** (`@vestra-player/sdk/testing`, `./runtime`): the player's limits on loaded subtitle files. Per source, 4 tracks of one plugin at once, 16 tracks of every plugin, 16 MiB of their files, 16 loads of one plugin and 128 of every plugin (removed tracks still count as loads); 2 loads of one plugin and 8 of every plugin in progress; a file of at most 2 MiB. A file over 2 MiB is `invalid`, the others `busy`. `TestHost` now enforces them with these codes (all but `totalBytes` and the all-plugin upload count, which one plugin cannot reach alone); external tracks a test adds to `subtitles.tracks` count as other plugins'. A new source drops the uploads of the old one (`uploads` entries carry `generation`). `Subtitles.load`, *Load subtitles from a plugin* and *Limits* name them.
+- Fix: a subtitle load the player refused no longer keeps one of the plugin's two upload slots. After a refused commit (`busy` at a track limit, `stale`, `invalid`…) the SDK now discards the upload, as it already did for a failure before the commit; before, two refusals on one source left the plugin unable to load any subtitle there until the source changed.
+
 ## 1.5.33
 
 1.5.32 was not published (a tag error).

package/dist/player-runtime.d.ts

@@ -17,6 +17,7 @@ export { BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BUILTIN_COMMANDS, BUILTIN_SUBMENUS
 export { BINDING_INPUTS } from "./plugin/bindings.ts";
 export { OSD_LIMITS } from "./plugin/osd.ts";
 export { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./plugin/services.ts";
+export { SUBTITLE_LIMITS } from "./plugin/subtitles.ts";
 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";

package/dist/player-runtime.js

@@ -15,6 +15,7 @@ export { BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BUILTIN_COMMANDS, BUILTIN_SUBMENUS
 export { BINDING_INPUTS } from "./plugin/bindings.js";
 export { OSD_LIMITS } from "./plugin/osd.js";
 export { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./plugin/services.js";
+export { SUBTITLE_LIMITS } from "./plugin/subtitles.js";
 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";

package/dist/plugin/subtitles.d.ts

@@ -1,3 +1,62 @@
 import type { ScopeImpl } from "./scope.ts";
 import type { Subtitles } from "./types.ts";
+/**
+ * The player's limits on subtitle files a plugin loads with
+ * {@link Subtitles.load}, which `TestHost` enforces with the player's codes.
+ * The track counts are per source: opening another file starts from zero.
+ * A file over `fileBytes` fails with `invalid`; every other limit fails with
+ * `busy`, and nothing is loaded.
+ *
+ * @remarks
+ * Each `load` uses a new resource on the source, and removing the track
+ * frees its place among the live tracks (`tracksPerPlugin`, `tracks`,
+ * `totalBytes`) but not among the loads (`loadsPerPlugin`, `loads`). So one
+ * plugin loads at most 16 files into one source, with at most 4 of them
+ * present at once.
+ *
+ * @example Replace the plugin's oldest subtitle when it has four
+ * The plugin keeps the files it loaded, newest last, and removes the oldest
+ * before a fifth would be refused with `busy`. A load the player still
+ * refuses (the source holds 16 tracks of every plugin, or this plugin
+ * already loaded 16 files into it) is reported on the OSD.
+ * ```ts
+ * import type { Plugin, PluginError, SubtitleTrack } from "@vestra-player/sdk";
+ * declare const plugin: Plugin;
+ * declare const bytes: Uint8Array;
+ * // ---cut---
+ * import { SUBTITLE_LIMITS } from "@vestra-player/sdk/testing";
+ *
+ * const loaded: SubtitleTrack[] = []; // this source's, newest last
+ * if (loaded.length >= SUBTITLE_LIMITS.tracksPerPlugin)
+ *   await plugin.subtitles.remove(loaded.shift()!);
+ * try {
+ *   loaded.push(await plugin.subtitles.load(bytes));
+ * } catch (error) {
+ *   if ((error as PluginError).code !== "busy") throw error;
+ *   await plugin.osd.show("No room for another subtitle on this file.");
+ * }
+ * ```
+ *
+ * @since 1.5.34
+ *
+ * @category Testing
+ */
+export declare const SUBTITLE_LIMITS: Readonly<{
+    /** UTF-8 bytes of one file; a larger one fails with `invalid` (2 MiB). */
+    readonly fileBytes: number;
+    /** Tracks one plugin has loaded into the current source at the same time (4). */
+    readonly tracksPerPlugin: 4;
+    /** Loaded tracks of every plugin in the current source at the same time (16). */
+    readonly tracks: 16;
+    /** Bytes of the loaded tracks of every plugin in the current source together (16 MiB). */
+    readonly totalBytes: number;
+    /** Loads by one plugin into the current source, removed tracks included (16). */
+    readonly loadsPerPlugin: 16;
+    /** Loads by every plugin into the current source, removed tracks included (128). */
+    readonly loads: 128;
+    /** Loads of one plugin in progress at the same time (2). */
+    readonly uploadsPerPlugin: 2;
+    /** Loads of every plugin in progress at the same time (8). */
+    readonly uploads: 8;
+}>;
 export declare function subtitles(scope: ScopeImpl): Subtitles;

package/dist/plugin/subtitles.js

@@ -3,6 +3,65 @@ import { createHash } from "node:crypto";
 import { isTextValue, textProblem } from "../i18n.js";
 import { Latest, failure, sleep, uncertain } from "./runtime.js";
 import { abortError } from "./player.js";
+/**
+ * The player's limits on subtitle files a plugin loads with
+ * {@link Subtitles.load}, which `TestHost` enforces with the player's codes.
+ * The track counts are per source: opening another file starts from zero.
+ * A file over `fileBytes` fails with `invalid`; every other limit fails with
+ * `busy`, and nothing is loaded.
+ *
+ * @remarks
+ * Each `load` uses a new resource on the source, and removing the track
+ * frees its place among the live tracks (`tracksPerPlugin`, `tracks`,
+ * `totalBytes`) but not among the loads (`loadsPerPlugin`, `loads`). So one
+ * plugin loads at most 16 files into one source, with at most 4 of them
+ * present at once.
+ *
+ * @example Replace the plugin's oldest subtitle when it has four
+ * The plugin keeps the files it loaded, newest last, and removes the oldest
+ * before a fifth would be refused with `busy`. A load the player still
+ * refuses (the source holds 16 tracks of every plugin, or this plugin
+ * already loaded 16 files into it) is reported on the OSD.
+ * ```ts
+ * import type { Plugin, PluginError, SubtitleTrack } from "@vestra-player/sdk";
+ * declare const plugin: Plugin;
+ * declare const bytes: Uint8Array;
+ * // ---cut---
+ * import { SUBTITLE_LIMITS } from "@vestra-player/sdk/testing";
+ *
+ * const loaded: SubtitleTrack[] = []; // this source's, newest last
+ * if (loaded.length >= SUBTITLE_LIMITS.tracksPerPlugin)
+ *   await plugin.subtitles.remove(loaded.shift()!);
+ * try {
+ *   loaded.push(await plugin.subtitles.load(bytes));
+ * } catch (error) {
+ *   if ((error as PluginError).code !== "busy") throw error;
+ *   await plugin.osd.show("No room for another subtitle on this file.");
+ * }
+ * ```
+ *
+ * @since 1.5.34
+ *
+ * @category Testing
+ */
+export const SUBTITLE_LIMITS = Object.freeze({
+    /** UTF-8 bytes of one file; a larger one fails with `invalid` (2 MiB). */
+    fileBytes: 2 * 1024 * 1024,
+    /** Tracks one plugin has loaded into the current source at the same time (4). */
+    tracksPerPlugin: 4,
+    /** Loaded tracks of every plugin in the current source at the same time (16). */
+    tracks: 16,
+    /** Bytes of the loaded tracks of every plugin in the current source together (16 MiB). */
+    totalBytes: 16 * 1024 * 1024,
+    /** Loads by one plugin into the current source, removed tracks included (16). */
+    loadsPerPlugin: 16,
+    /** Loads by every plugin into the current source, removed tracks included (128). */
+    loads: 128,
+    /** Loads of one plugin in progress at the same time (2). */
+    uploadsPerPlugin: 2,
+    /** Loads of every plugin in progress at the same time (8). */
+    uploads: 8,
+});
 const raws = new WeakMap();
 const targets = new WeakMap();
 const CHUNK = 32 * 1024;
@@ -283,11 +342,18 @@ export function subtitles(scope) {
                 return loaded;
             }
             catch (error) {
+                // Free the upload's slot (2 per plugin). Before the commit the
+                // discard is awaited, as it always was (an abort resolves once the
+                // upload is gone). After a refused commit the player still holds
+                // the upload; after one that took effect it was consumed and the
+                // discard is a harmless no-op. Sent, not awaited: the player handles
+                // it before any later request of this plugin.
+                const discard = host()
+                    .discard(uploadId)
+                    .catch(() => { });
                 if (!committing)
-                    await host()
-                        .discard(uploadId)
-                        .catch(() => { });
-                else if (error.code !== "missing")
+                    await discard;
+                if (committing && error.code !== "missing")
                     svc.owned.delete(resourceId);
                 throw error;
             }

package/dist/plugin/testing.d.ts

@@ -8,6 +8,7 @@ import { CAPABILITY_INFO, MESSAGE_LIMIT } from "../capabilities.ts";
 import type { CapabilityInfo } from "../capabilities.ts";
 import { OSD_LIMITS } from "./osd.ts";
 import { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./services.ts";
+import { SUBTITLE_LIMITS } from "./subtitles.ts";
 import { BINDING_INPUTS } from "./bindings.ts";
 import { THEME_PALETTES } from "../palettes.ts";
 import { IMAGE_LIMITS, UI_VALUE_LIMITS } from "./values.ts";
@@ -38,6 +39,8 @@ export { OSD_LIMITS };
 export { SECRET_LIMITS };
 /** The player's limits on `plugin.storage.session`. */
 export { SESSION_STORAGE_LIMITS };
+/** The player's limits on loaded subtitle files, which the test host enforces as well. */
+export { SUBTITLE_LIMITS };
 /** The names bindings are made of. */
 export { BINDING_INPUTS };
 /** The colours of the player's palettes, by `Theme` token. */
@@ -1270,7 +1273,10 @@ export declare class TestHost implements Transport {
         owner: string | null;
         /** The values the player holds. */
         values: RenderSettings;
-        /** `true`: GPU rendering; `false`: software rendering (`unsupported`). */
+        /**
+         * `true`: GPU rendering; `false`: software rendering (`unsupported`).
+         * `plugin.app.system()` reports it as `rendering`.
+         */
         gpu: boolean;
     };
     /**
@@ -1385,6 +1391,13 @@ export declare class TestHost implements Transport {
         bytes: Buffer[];
         /** The announced total size in bytes. */
         expected: number;
+        /**
+         * The source generation it was begun for; like the player, a new
+         * source drops the uploads of the old one.
+         *
+         * @since 1.5.34
+         */
+        generation?: number;
     }>;
     /** Snapshots taken with `media.capture`, by snapshot id. Wire-level. */
     readonly snapshots: Map<number, Json>;
@@ -1595,8 +1608,12 @@ export declare class TestHost implements Transport {
      * @since 1.5.25
      */
     readonly sessionStorage: Map<string, Json>;
-    /** What `plugin.app.system()` reports. */
-    systemInfo: WireSystemInfo;
+    /**
+     * What `plugin.app.system()` reports. Its `rendering` follows
+     * {@link TestHost.videoRender | videoRender.gpu} (`"gpu"` or
+     * `"software"`), so one switch covers the render options and the fact.
+     */
+    systemInfo: Omit<WireSystemInfo, "rendering">;
     /**
      * What `plugin.app` reports. Set it before {@link startPlugin}: the plugin
      * receives it once at start-up.

package/dist/plugin/testing.js

@@ -77,6 +77,7 @@ import { BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BUILTIN_COMMANDS, BUILTIN_SUBMENUS
 import { CAPABILITY_INFO, MESSAGE_LIMIT } from "../capabilities.js";
 import { OSD_LIMITS } from "./osd.js";
 import { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./services.js";
+import { SUBTITLE_LIMITS } from "./subtitles.js";
 import { BINDING_INPUTS } from "./bindings.js";
 import { THEME_PALETTES } from "../palettes.js";
 import { IMAGE_LIMITS, UI_VALUE_LIMITS, valueLimitProblem } from "./values.js";
@@ -104,6 +105,8 @@ export { OSD_LIMITS };
 export { SECRET_LIMITS };
 /** The player's limits on `plugin.storage.session`. */
 export { SESSION_STORAGE_LIMITS };
+/** The player's limits on loaded subtitle files, which the test host enforces as well. */
+export { SUBTITLE_LIMITS };
 /** The names bindings are made of. */
 export { BINDING_INPUTS };
 /** The colours of the player's palettes, by `Theme` token. */
@@ -1521,7 +1524,11 @@ export class TestHost {
      * @since 1.5.25
      */
     sessionStorage = new Map();
-    /** What `plugin.app.system()` reports. */
+    /**
+     * What `plugin.app.system()` reports. Its `rendering` follows
+     * {@link TestHost.videoRender | videoRender.gpu} (`"gpu"` or
+     * `"software"`), so one switch covers the render options and the fact.
+     */
     systemInfo = {
         os: "macos",
         name: "macOS",
@@ -3135,12 +3142,49 @@ export class TestHost {
             !["ready", "ended"].includes(this.source.phase))
             throw new HostError("unavailable", "audio tracks need ready media");
     }
-    #subtitleChange(expected) {
+    /** `stale` unless `expected` is the current subtitle stamp. */
+    #subtitleExpected(expected) {
         const stamp = this.subtitles.selection.stamp;
         const want = expected;
         if (want.generation !== stamp.generation ||
             want.revision !== stamp.revision)
             throw new HostError("stale", "subtitle selection changed");
+    }
+    /**
+     * The resources this plugin loaded into the current source (resource id →
+     * bytes), removed ones included: like the player, a removed track frees
+     * its place among the live tracks but not among the loads.
+     */
+    #subtitleResources = { generation: -1, bytes: new Map() };
+    #loadedSubtitles() {
+        const generation = this.source.stamp.generation;
+        if (this.#subtitleResources.generation !== generation)
+            this.#subtitleResources = { generation, bytes: new Map() };
+        return this.#subtitleResources.bytes;
+    }
+    /**
+     * 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.
+     */
+    #subtitleRoom(resourceId) {
+        const loaded = this.#loadedSubtitles();
+        if (loaded.has(resourceId))
+            return;
+        const external = this.subtitles.tracks.filter((t) => t.target.kind === "external");
+        const own = external.filter((t) => t.target.kind === "external" && loaded.has(t.target.resourceId));
+        const others = external.length - own.length;
+        if (loaded.size >= SUBTITLE_LIMITS.loadsPerPlugin ||
+            loaded.size + others >= SUBTITLE_LIMITS.loads ||
+            own.length >= SUBTITLE_LIMITS.tracksPerPlugin ||
+            external.length >= SUBTITLE_LIMITS.tracks)
+            throw new HostError("busy", "subtitle resource or counter limit exceeded");
+    }
+    #subtitleChange(expected) {
+        this.#subtitleExpected(expected);
+        const stamp = this.subtitles.selection.stamp;
         this.subtitles.selection.stamp = {
             generation: this.source.stamp.generation,
             revision: stamp.revision + 1,
@@ -3459,7 +3503,10 @@ export class TestHost {
         },
         "storage.session.delete": (p) => void this.sessionStorage.delete(sessionKey(p.key)),
         "storage.session.keys": () => [...this.sessionStorage.keys()].sort(byCodePoint),
-        "app.system": () => structuredClone(this.systemInfo),
+        "app.system": () => ({
+            ...structuredClone(this.systemInfo),
+            rendering: this.videoRender.gpu ? "gpu" : "software",
+        }),
         "clipboard.readText": () => this.clipboard.text,
         "clipboard.writeText": (p) => {
             if (typeof p.text !== "string")
@@ -4143,9 +4190,24 @@ export class TestHost {
         "subtitles.upload.begin": (p) => {
             if (p.generation !== this.source.stamp.generation)
                 throw new HostError("stale", "source generation changed");
+            const expectedBytes = Number(p.expectedBytes);
+            if (!Number.isSafeInteger(expectedBytes) ||
+                expectedBytes < 1 ||
+                expectedBytes > SUBTITLE_LIMITS.fileBytes)
+                throw new HostError("invalid", `a subtitle file has 1..${SUBTITLE_LIMITS.fileBytes} bytes`);
+            // Like the player: a new source drops the old one's uploads. A commit
+            // the player refused leaves its upload for `subtitles.upload.discard`,
+            // which the SDK sends after any failed load.
+            for (const [id, upload] of this.uploads)
+                if (upload.generation !== undefined &&
+                    upload.generation !== this.source.stamp.generation)
+                    this.uploads.delete(id);
+            if (this.uploads.size >= SUBTITLE_LIMITS.uploadsPerPlugin)
+                throw new HostError("busy", "upload memory, owner or active-token limit reached");
             this.uploads.set(Number(p.uploadId), {
                 bytes: [],
-                expected: Number(p.expectedBytes),
+                expected: expectedBytes,
+                generation: this.source.stamp.generation,
             });
             return {
                 generation: p.generation,
@@ -4163,9 +4225,8 @@ export class TestHost {
         },
         "subtitles.upload.discard": (p) => void this.uploads.delete(Number(p.uploadId)),
         "subtitles.commit": (p) => {
-            const upload = this.uploads.get(Number(p.uploadId));
-            if (!upload)
-                throw new HostError("missing", "upload");
+            // The player's order: the request's own fields, then `stale`, then
+            // the upload and its content, then the limits.
             const format = p.format === "ass" ? "ass" : "srt";
             const select = p.select === "none"
                 ? "none"
@@ -4179,12 +4240,18 @@ export class TestHost {
                     : null;
             if (title !== null && ([...title].length < 1 || [...title].length > 200))
                 throw new HostError("invalid", "subtitle title needs 1..200 characters");
+            this.#subtitleExpected(p.expected);
+            const upload = this.uploads.get(Number(p.uploadId));
+            if (!upload)
+                throw new HostError("missing", "upload");
             const bytes = Buffer.concat(upload.bytes);
             if (format === "ass" &&
                 !(/\[Script Info\]/i.test(bytes.toString()) &&
                     /\[Events\]/i.test(bytes.toString())))
                 throw new HostError("invalid", "ASS requires [Script Info] and [Events] sections");
+            this.#subtitleRoom(String(p.resourceId));
             this.#subtitleChange(p.expected);
+            this.#loadedSubtitles().set(String(p.resourceId), bytes.length);
             const target = {
                 kind: "external",
                 owner: 1,

package/dist/plugin/types.d.ts

@@ -3991,8 +3991,9 @@ export interface AppInfo {
  */
 export interface App extends AppInfo {
     /**
-     * The operating system and the displays, read when called (displays come
-     * and go). No capability. CPU and memory: Node's `os` module.
+     * The operating system, the displays and the renderer, read when called
+     * (displays come and go; the renderer can fall back from GPU to software
+     * once). No capability. CPU and memory: Node's `os` module.
      *
      * @capability None.
      * @throws `busy` (rejects) The player could not start the request (no
@@ -4034,6 +4035,46 @@ export interface SystemInfo {
     readonly arch: string;
     /** Primary display first; empty without a user interface. */
     readonly displays: readonly DisplayInfo[];
+    /**
+     * Which renderer draws the video now: `"gpu"` (the GPU renderer, so
+     * {@link RenderOptions | render options} apply) or `"software"` (they
+     * fail with `unsupported`). Read at each call. It changes at most once
+     * while the player runs, from `"gpu"` to `"software"` when a window
+     * cannot show GPU frames; the owner of the render options hears that
+     * switch through {@link RenderOptions.onStatus}.
+     *
+     * Absent (`undefined`) on players before 0.5.12, which do not report it:
+     * the renderer is then unknown, not software.
+     *
+     * Today the player renders on the GPU on macOS and in software on
+     * Windows, Linux and without a user interface (see
+     * [Platforms](../../docs/reference/platforms.md)); test this field
+     * rather than {@link SystemInfo.os}.
+     *
+     * @example Offer the HDR menu only where render options work
+     * The plugin adds its HDR command only when the player renders on the
+     * GPU, instead of creating the render options just to find out from a
+     * failed status. `system()` asks the player, which reports the renderer
+     * drawing at that moment; no capability is needed to ask. A player before
+     * 0.5.12 leaves the field out, so the test is for `"gpu"` exactly (an
+     * older player gets no HDR command).
+     * ```ts
+     * const { rendering } = await plugin.app.system();
+     * if (rendering === "gpu") {
+     *   const render = plugin.video.render(); // one handle, kept
+     *   plugin.commands.add({
+     *     id: "hdr",
+     *     path: ["@video", "HDR Tone Mapping"],
+     *     run: () => render.set({ toneMapping: "bt.2390", targetPeak: 250 }),
+     *   });
+     * }
+     * ```
+     *
+     * @player 0.5.12; older players leave it out (declare
+     * `"minPlayerVersion": "0.5.12"` when the plugin relies on it).
+     * @since 1.5.34
+     */
+    readonly rendering?: "gpu" | "software";
 }
 /**
  * One display in {@link SystemInfo.displays}.
@@ -6294,8 +6335,10 @@ export interface RenderSettings {
  *
  * Platforms: only macOS renders on the GPU. Under software rendering
  * (Windows, Linux, headless, fallback) every `set` fails with
- * `unsupported`. macOS OpenGL 4.1 has no compute shaders, so `peakDetect`
- * is accepted but has no effect; output is always SDR.
+ * `unsupported`; {@link SystemInfo.rendering} tells which renderer draws
+ * without creating the handle. macOS OpenGL 4.1 has no
+ * compute shaders, so `peakDetect` is accepted but has no effect; output
+ * is always SDR.
  *
  * @example Tone-map HDR video and hide the menu where it cannot work
  * On a GPU-rendering player HDR video is tone-mapped with BT.2390 for a
@@ -6591,7 +6634,10 @@ export interface Subtitles {
      *
      * Limits: SRT ≤ 2 MiB and ≤ 10,000 cues; ASS ≤ 2 MiB with `[Script Info]`
      * and `[Events]` and 1–20,000 `Dialogue:` lines. Convert other formats
-     * (VTT, SAMI) to SRT first.
+     * (VTT, SAMI) to SRT first. Per source, a plugin has at most 4 loaded
+     * tracks at once and loads at most 16 files (removed ones count), and
+     * every plugin together at most 16 tracks; see `SUBTITLE_LIMITS` in
+     * `@vestra-player/sdk/testing`.
      *
      * @capability subtitles.control and subtitles.read
      * @throws `invalid` (rejects) A bad `format` or `title`, or a file over the
@@ -6602,7 +6648,10 @@ export interface Subtitles {
      *   loading.
      * @throws `aborted` (rejects) `signal` aborted before the commit (an
      *   `AbortError`); the upload is discarded.
-     * @throws `busy` (rejects) Too many subtitle operations at once.
+     * @throws `busy` (rejects) Too many subtitle operations at once, or a
+     *   limit of `SUBTITLE_LIMITS` is reached (4 tracks of this plugin, 16
+     *   loads of this plugin or 16 tracks in the source, or another of its
+     *   limits); nothing is loaded.
      * @throws `capability` (rejects) The manifest does not declare
      *   `subtitles.control` and `subtitles.read`.
      *

package/dist/wire.d.ts

@@ -297,7 +297,7 @@ export interface LocalServices {
         signal: AbortSignal;
     }): Promise<Uint8Array>;
 }
-/** `app.system`: the operating system and the displays. */
+/** `app.system`: the operating system, the displays and the renderer. */
 export interface WireSystemInfo {
     os: "macos" | "windows" | "linux" | "other";
     name: string;
@@ -313,6 +313,8 @@ export interface WireSystemInfo {
         refreshRate: number | null;
         primary: boolean;
     }[];
+    /** Player 0.5.12; older players leave it out. */
+    rendering?: "gpu" | "software";
 }
 /**
  * Template arguments on the wire (`osd.show`, `osd.panel`, `dialogs.confirm`,

package/llms-full.txt

@@ -1,4 +1,4 @@
-# @vestra-player/sdk 1.5.33: full reference
+# @vestra-player/sdk 1.5.34: full reference
 
 > Everything needed to write a Vestra Player plugin (plugin API `vestra/1`): the guides, every public declaration of `@vestra-player/sdk` and `@vestra-player/sdk/testing` with its documentation, and the complete source of the example plugins. Generated from the SDK's sources by scripts/llms.mjs; the short index is llms.txt.
 
@@ -740,7 +740,7 @@ plugin.video.view() returns the VideoView: aspect override, fit (keep with bars,
 
 plugin.video.render() returns the RenderOptions of the GPU renderer: HDR to SDR tone mapping and the display's brightness, user shaders (`.glsl` files) and motion interpolation. Like the display layer they act at display time only, have one owner (independent of the display layer's owner) and merge writes.
 
-- **Only the GPU renderer has them.** Under software rendering every `set` fails with `unsupported`; see Reference: platforms for where the player renders on the GPU. Treat `unsupported` as "hide these settings", not as an error.
+- **Only the GPU renderer has them.** Under software rendering every `set` fails with `unsupported`; see Reference: platforms for where the player renders on the GPU. Treat `unsupported` as "hide these settings", not as an error. To know before creating the handle, read rendering from `plugin.app.system()` (player 0.5.12, no capability): `"gpu"` or `"software"`.
 - A shader that does not compile is reported later: the status first becomes `applied`, then `failed` with code `failed` and the compiler's first error line once mpv first uses the shader.
 
 ## Concept: Windows, panels, settings pages, dialogs and the OSD
@@ -1272,7 +1272,7 @@ if (english)
 
 #### Upload a file
 
-`load` takes the file's bytes: UTF-8 SRT, or ASS/SSA with `format: "ass"`, at most 2 MiB (SRT up to 10,000 cues, ASS up to 20,000 `Dialogue:` lines). Convert other formats (WebVTT, SAMI) to SRT first. The player adds an `external` track to the current source only, selects it unless `select: "none"`, and resolves with the track once the upload is committed.
+`load` takes the file's bytes: UTF-8 SRT, or ASS/SSA with `format: "ass"`, at most 2 MiB (SRT up to 10,000 cues, ASS up to 20,000 `Dialogue:` lines). Convert other formats (WebVTT, SAMI) to SRT first. The player adds an `external` track to the current source only, selects it unless `select: "none"`, and resolves with the track once the upload is committed. A plugin has at most 4 such tracks on a source at once and loads at most 16 files into it (removed ones count); past that `load` fails with `busy` (Limits).
 
 ```ts
 import { readFile } from "node:fs/promises";
@@ -2567,6 +2567,7 @@ The table lists the API whose documentation names a player version, newest last:
 | 0.5.3 | Scrub.seek |
 | 0.5.5 | SessionStorage |
 | 0.5.10 | CommandButton, CommandOptions.button |
+| 0.5.12 | SystemInfo.rendering |
 
 The Slint library carries no version tags: `Theme.danger` needs player 0.3.0; `@vestra/icons.slint` and the palette `vestra-light` need 0.4.0 (Theme).
 
@@ -2724,6 +2725,21 @@ plugin.storage.session (player 0.5.5). A key out of its rule, or a value that is
 | `SESSION_STORAGE_LIMITS.bytes` | 1048576 (1 MiB) | Bytes one plugin may hold at the same time: for every key, its UTF-8 bytes, its value written as compact JSON (`JSON.stringify(value)`) and `entryBytes`. |
 | `SESSION_STORAGE_LIMITS.entryBytes` | 128 | What each key costs on top of its text and value (128): the player's own bookkeeping, so that many tiny entries stay within `bytes` of memory. |
 
+#### Subtitle files
+
+Subtitles.load uploads a file as a track of the current source. A file over `fileBytes` fails with `invalid`; every other limit fails with `busy` and nothing is loaded. The counts are per source, so another file starts from zero. Removing a track frees its place among the tracks and their bytes, but a load stays counted until the source changes.
+
+| Limit | Value | Meaning |
+| --- | --- | --- |
+| `SUBTITLE_LIMITS.fileBytes` | 2097152 (2 MiB) | UTF-8 bytes of one file; a larger one fails with `invalid`. |
+| `SUBTITLE_LIMITS.tracksPerPlugin` | 4 | Tracks one plugin has loaded into the current source at the same time. |
+| `SUBTITLE_LIMITS.tracks` | 16 | Loaded tracks of every plugin in the current source at the same time. |
+| `SUBTITLE_LIMITS.totalBytes` | 16777216 (16 MiB) | Bytes of the loaded tracks of every plugin in the current source together. |
+| `SUBTITLE_LIMITS.loadsPerPlugin` | 16 | Loads by one plugin into the current source, removed tracks included. |
+| `SUBTITLE_LIMITS.loads` | 128 | Loads by every plugin into the current source, removed tracks included. |
+| `SUBTITLE_LIMITS.uploadsPerPlugin` | 2 | Loads of one plugin in progress at the same time. |
+| `SUBTITLE_LIMITS.uploads` | 8 | Loads of every plugin in progress at the same time. |
+
 #### Messages
 
 Every request a plugin sends travels as one protocol line. The plugin's side refuses a longer one with code `limit` before sending it; property values meet their own limits first.
@@ -3244,7 +3260,7 @@ A plugin uses the same API on macOS and Windows; the player does the system-spec
 | DropModifiers | The pointer and ⌥ ⇧ ⌘ (`cmd` is ⌘). | The pointer and Alt, Shift, Ctrl (`cmd` is Ctrl). |
 | plugin.system (open, reveal) | Opened by the system; revealing several files selects all of them in one Finder window. | Opened by the shell; one Explorer window per folder. |
 | plugin.secrets | The login keychain. | The Credential Manager. |
-| App.system() | Version, build, model and displays. | Version, build, model and displays. |
+| App.system() | Version, build, model and displays; `rendering` is `"gpu"`, or `"software"` after a fallback (a window that cannot show GPU frames). | Version, build, model and displays; `rendering` is `"software"`. |
 | Snapshots and exports (MediaCapture) | Available. | Available; needs FFmpeg 6.1 or newer. |
 | Generated streams (Player.openStream) | A Unix socket. | Loopback TCP with a token. |
 | Rendering | On the GPU (OpenGL), with hardware decoding. | In software, with hardware decoding copied back (`d3d11va-copy` and similar). |
@@ -7227,7 +7243,7 @@ worked out once, at the first call, and reused.
 ```ts
 interface App extends AppInfo {
   /**
-   * The operating system and the displays, read when called (displays come and go). No capability. CPU and memory: Node's `os` module.
+   * The operating system, the displays and the renderer, read when called (displays come and go; the renderer can fall back from GPU to software once). No capability. CPU and memory: Node's `os` module.
    * @capability None.
    * @throws busy (rejects) The player could not start the request (no thread available).
    * @example Choose a size for the primary display
@@ -7276,6 +7292,42 @@ interface SystemInfo {
   readonly arch: string;
   /** Primary display first; empty without a user interface. */
   readonly displays: readonly DisplayInfo[];
+  /**
+   * Which renderer draws the video now: `"gpu"` (the GPU renderer, so
+   * render options apply) or `"software"` (they
+   * fail with `unsupported`). Read at each call. It changes at most once
+   * while the player runs, from `"gpu"` to `"software"` when a window
+   * cannot show GPU frames; the owner of the render options hears that
+   * switch through RenderOptions.onStatus.
+   *
+   * Absent (`undefined`) on players before 0.5.12, which do not report it:
+   * the renderer is then unknown, not software.
+   *
+   * Today the player renders on the GPU on macOS and in software on
+   * Windows, Linux and without a user interface (see
+   * Platforms); test this field
+   * rather than SystemInfo.os.
+   * @player 0.5.12; older players leave it out (declare `"minPlayerVersion": "0.5.12"` when the plugin relies on it).
+   * @example Offer the HDR menu only where render options work
+   * The plugin adds its HDR command only when the player renders on the
+   * GPU, instead of creating the render options just to find out from a
+   * failed status. `system()` asks the player, which reports the renderer
+   * drawing at that moment; no capability is needed to ask. A player before
+   * 0.5.12 leaves the field out, so the test is for `"gpu"` exactly (an
+   * older player gets no HDR command).
+   * ```ts
+   * const { rendering } = await plugin.app.system();
+   * if (rendering === "gpu") {
+   *   const render = plugin.video.render(); // one handle, kept
+   *   plugin.commands.add({
+   *     id: "hdr",
+   *     path: ["@video", "HDR Tone Mapping"],
+   *     run: () => render.set({ toneMapping: "bt.2390", targetPeak: 250 }),
+   *   });
+   * }
+   * ```
+   */
+  readonly rendering?: "gpu" | "software";
 }
 ```
 
@@ -9142,8 +9194,10 @@ independent handles.
 
 Platforms: only macOS renders on the GPU. Under software rendering
 (Windows, Linux, headless, fallback) every `set` fails with
-`unsupported`. macOS OpenGL 4.1 has no compute shaders, so `peakDetect`
-is accepted but has no effect; output is always SDR.
+`unsupported`; SystemInfo.rendering tells which renderer draws
+without creating the handle. macOS OpenGL 4.1 has no
+compute shaders, so `peakDetect` is accepted but has no effect; output
+is always SDR.
 
 GPU renderer options (tone mapping, peak detection, shaders,
 interpolation). Only the GPU renderer has them, which today means macOS;
@@ -9373,13 +9427,16 @@ interface Subtitles {
    *
    * Limits: SRT ≤ 2 MiB and ≤ 10,000 cues; ASS ≤ 2 MiB with `[Script Info]`
    * and `[Events]` and 1–20,000 `Dialogue:` lines. Convert other formats
-   * (VTT, SAMI) to SRT first.
+   * (VTT, SAMI) to SRT first. Per source, a plugin has at most 4 loaded
+   * tracks at once and loads at most 16 files (removed ones count), and
+   * every plugin together at most 16 tracks; see `SUBTITLE_LIMITS` in
+   * `@vestra-player/sdk/testing`.
    * @capability subtitles.control and subtitles.read
    * @throws invalid (rejects) A bad `format` or `title`, or a file over the limits.
    * @throws stale (rejects) With `ifCurrent`: the source changed since that state.
    * @throws unavailable (rejects) Nothing loaded, or the source is still loading.
    * @throws aborted (rejects) `signal` aborted before the commit (an `AbortError`); the upload is discarded.
-   * @throws busy (rejects) Too many subtitle operations at once.
+   * @throws busy (rejects) Too many subtitle operations at once, or a limit of `SUBTITLE_LIMITS` is reached (4 tracks of this plugin, 16 loads of this plugin or 16 tracks in the source, or another of its limits); nothing is loaded.
    * @throws capability (rejects) The manifest does not declare `subtitles.control` and `subtitles.read`.
    * @example Load a downloaded SRT and select it
    * A subtitle file the plugin downloaded becomes a track of the current file
@@ -12582,7 +12639,7 @@ class TestHost implements Transport {
     owner: string | null;
     /** The values the player holds. */
     values: RenderSettings;
-    /** `true`: GPU rendering; `false`: software rendering (`unsupported`). */
+    /** `true`: GPU rendering; `false`: software rendering (`unsupported`). `plugin.app.system()` reports it as `rendering`. */
     gpu: boolean;
   };
   /**
@@ -12671,6 +12728,8 @@ class TestHost implements Transport {
     bytes: Buffer[];
     /** The announced total size in bytes. */
     expected: number;
+    /** The source generation it was begun for; like the player, a new source drops the uploads of the old one. */
+    generation?: number;
   }>;
   /** Snapshots taken with `media.capture`, by snapshot id. Wire-level. */
   readonly snapshots: Map<number, Json>;
@@ -12824,8 +12883,10 @@ class TestHost implements Transport {
    * `plugin.storage.session`: key → value, as the player keeps them. Preset entries to simulate values an earlier run of the plugin stored in the same player session, or pass `startPlugin(..., { sessionStorage })`. Like the player, a key is 1–1024 bytes, a `set` that would make the entries larger than 1 MiB (keys, values as compact JSON and `SESSION_STORAGE_LIMITS.entryBytes` per key) fails `limit`, and an object's properties are stored sorted, as the player hands them back.
    */
   readonly sessionStorage: Map<string, Json>;
-  /** What `plugin.app.system()` reports. */
-  systemInfo: WireSystemInfo;
+  /**
+   * What `plugin.app.system()` reports. Its `rendering` follows videoRender.gpu (`"gpu"` or `"software"`), so one switch covers the render options and the fact.
+   */
+  systemInfo: Omit<WireSystemInfo, "rendering">;
   /** What `plugin.app` reports. Set it before startPlugin: the plugin receives it once at start-up. */
   app: {
     /** The player version. */
@@ -14061,6 +14122,61 @@ if (!token || Buffer.byteLength(token) > SECRET_LIMITS.valueBytes) {
 }
 ```
 
+### SUBTITLE_LIMITS
+
+The player's limits on subtitle files a plugin loads with
+Subtitles.load, which `TestHost` enforces with the player's codes.
+The track counts are per source: opening another file starts from zero.
+A file over `fileBytes` fails with `invalid`; every other limit fails with
+`busy`, and nothing is loaded.
+
+Each `load` uses a new resource on the source, and removing the track
+frees its place among the live tracks (`tracksPerPlugin`, `tracks`,
+`totalBytes`) but not among the loads (`loadsPerPlugin`, `loads`). So one
+plugin loads at most 16 files into one source, with at most 4 of them
+present at once.
+
+```ts
+const SUBTITLE_LIMITS: Readonly<{
+  /** UTF-8 bytes of one file; a larger one fails with `invalid` (2 MiB). */
+  readonly fileBytes: number;
+  /** Tracks one plugin has loaded into the current source at the same time (4). */
+  readonly tracksPerPlugin: 4;
+  /** Loaded tracks of every plugin in the current source at the same time (16). */
+  readonly tracks: 16;
+  /** Bytes of the loaded tracks of every plugin in the current source together (16 MiB). */
+  readonly totalBytes: number;
+  /** Loads by one plugin into the current source, removed tracks included (16). */
+  readonly loadsPerPlugin: 16;
+  /** Loads by every plugin into the current source, removed tracks included (128). */
+  readonly loads: 128;
+  /** Loads of one plugin in progress at the same time (2). */
+  readonly uploadsPerPlugin: 2;
+  /** Loads of every plugin in progress at the same time (8). */
+  readonly uploads: 8;
+}>;
+```
+
+Example: Replace the plugin's oldest subtitle when it has four
+
+The plugin keeps the files it loaded, newest last, and removes the oldest
+before a fifth would be refused with `busy`. A load the player still
+refuses (the source holds 16 tracks of every plugin, or this plugin
+already loaded 16 files into it) is reported on the OSD.
+```ts
+import { SUBTITLE_LIMITS } from "@vestra-player/sdk/testing";
+
+const loaded: SubtitleTrack[] = []; // this source's, newest last
+if (loaded.length >= SUBTITLE_LIMITS.tracksPerPlugin)
+  await plugin.subtitles.remove(loaded.shift()!);
+try {
+  loaded.push(await plugin.subtitles.load(bytes));
+} catch (error) {
+  if ((error as PluginError).code !== "busy") throw error;
+  await plugin.osd.show("No room for another subtitle on this file.");
+}
+```
+
 ### UI_VALUE_LIMITS
 
 The player's limits on one property value (a `PropValue` as written
@@ -14549,7 +14665,7 @@ interface SubtitleState {
 
 ### WireSystemInfo
 
-`app.system`: the operating system and the displays.
+`app.system`: the operating system, the displays and the renderer.
 
 ```ts
 interface WireSystemInfo {
@@ -14567,6 +14683,8 @@ interface WireSystemInfo {
     refreshRate: number | null;
     primary: boolean;
   }[];
+  /** Player 0.5.12; older players leave it out. */
+  rendering?: "gpu" | "software";
 }
 ```
 

package/llms.txt

@@ -1,6 +1,6 @@
 # Vestra Player SDK
 
-> @vestra-player/sdk 1.5.33: write plugins for Vestra Player in TypeScript (plugin API `vestra/1`). A plugin is a folder with `manifest.json` and an entry module whose default export `activate(plugin)` the player calls; it runs in its own Node.js process. Everything a plugin creates (commands, windows, panels, filters, listeners…) is a handle that is released automatically when the plugin stops. L<n>: a line of llms-full.txt (next to this file), which has every page, declaration and example.
+> @vestra-player/sdk 1.5.34: write plugins for Vestra Player in TypeScript (plugin API `vestra/1`). A plugin is a folder with `manifest.json` and an entry module whose default export `activate(plugin)` the player calls; it runs in its own Node.js process. Everything a plugin creates (commands, windows, panels, filters, listeners…) is a handle that is released automatically when the plugin stops. L<n>: a line of llms-full.txt (next to this file), which has every page, declaration and example.
 
 **Rules**
 
@@ -33,7 +33,7 @@ my-plugin/
 }
 ```
 
-Fields: `id`, `version`, `apiVersion`, `entry`, `capabilities`, `name`, `author`, `punchline`, `description`, `tags`, `icon`, `readme`, `changelog`, `sourceUrl`, `license`, `minPlayerVersion`; unknown fields and capabilities are rejected. Rules and limits: L2507–2574.
+Fields: `id`, `version`, `apiVersion`, `entry`, `capabilities`, `name`, `author`, `punchline`, `description`, `tags`, `icon`, `readme`, `changelog`, `sourceUrl`, `license`, `minPlayerVersion`; unknown fields and capabilities are rejected. Rules and limits: L2507–2575.
 
 **main.ts**
 
@@ -76,9 +76,9 @@ export default async function activate(plugin: Plugin) {
 - `ui.settings`: Settings.page/show
 - `ui.theme`: Appearance.set/setLanguage
 - `secrets`: Secrets.get/set/delete
-- No capability: `tools`, `storage`, `system`, `app`, `ui` (images and Markdown), `i18n`, reading window.state, appearance.theme and packages.list. Details: L2575–2633.
+- No capability: `tools`, `storage`, `system`, `app`, `ui` (images and Markdown), `i18n`, reading window.state, appearance.theme and packages.list. Details: L2576–2634.
 
-**Test**: `tests/*.test.ts` with `node:test`, run by `vestra-plugin test`. `startPlugin(activate, { directory: new URL("..", import.meta.url) })` from `@vestra-player/sdk/testing` returns `{ host, stop }`, `host` an in-memory player (TestHost): act (`host.command(id).run()`, `host.press(key)`), `await host.settle()`, assert on `host.osd`, `host.window(id).props`… Guide: L1948–2136; TestHost: L11987.
+**Test**: `tests/*.test.ts` with `node:test`, run by `vestra-plugin test`. `startPlugin(activate, { directory: new URL("..", import.meta.url) })` from `@vestra-player/sdk/testing` returns `{ host, stop }`, `host` an in-memory player (TestHost): act (`host.command(id).run()`, `host.press(key)`), `await host.settle()`, assert on `host.osd`, `host.window(id).props`… Guide: L1948–2136; TestHost: L12044.
 
 **Command line**
 
@@ -106,7 +106,7 @@ export default async function activate(plugin: Plugin) {
 - `limit`: A player-wide limit was reached, a property value is over the limits of PropValue
 - `reserved`: The id is `vestra` or starts with `vestra.`
 - `versionMismatch`: The package needs a newer player
-- Others: PluginError, llms-full.txt L3618.
+- Others: PluginError, llms-full.txt L3634.
 
 ## Reference
 
@@ -115,30 +115,30 @@ export default async function activate(plugin: Plugin) {
 - Concepts: How a plugin runs L238–408; Commands, menus and key bindings L409–520; Playback state, controls and sources L521–666; Video and audio processing L667–745; Windows, panels, settings pages, dialogs and the OSD L746–1034
 - How-to: Control playback L1035–1163; Store a plugin's data L1164–1231; Load subtitles from a plugin L1232–1310; Keep a slider responsive while dragging L1311–1485; Remember a window's state between runs L1486–1615; Translate a plugin L1616–1799; Migrate a plugin to English source text L1800–1947; Test a plugin L1948–2136; Publish a plugin L2137–2225; Migrating off package rollback (1.5.16, removed in 1.5.17) L2226–2301
 - Guidelines: Interface guidelines L2302–2409; Menu guidelines L2410–2506
-- Reference: Manifest L2507–2574; Capabilities L2575–2633; Limits L2634–2748; Commands, menus and bindings L2749–3231; Platforms L3232–3260; Theme L3261–3482; Command line L3483–3540
-- [API: @vestra-player/sdk](https://vestrasys.github.io/vestra-player-sdk/modules/_vestra-player_sdk.html): L3541–11671
-- [API: @vestra-player/sdk/testing](https://vestrasys.github.io/vestra-player-sdk/modules/_vestra-player_sdk_testing.html): L11672–14204
+- Reference: Manifest L2507–2575; Capabilities L2576–2634; Limits L2635–2764; Commands, menus and bindings L2765–3247; Platforms L3248–3276; Theme L3277–3498; Command line L3499–3556
+- [API: @vestra-player/sdk](https://vestrasys.github.io/vestra-player-sdk/modules/_vestra-player_sdk.html): L3557–11728
+- [API: @vestra-player/sdk/testing](https://vestrasys.github.io/vestra-player-sdk/modules/_vestra-player_sdk_testing.html): L11729–14320
 
 ## API
 
 Where each `plugin.<module>` is declared:
 
-- Plugin L3938, Scope L3693, PluginError L3618, Disposable L3556
-- Commands L4335; Windows L5272; Panels L6718; Dialogs L7329; Player L8070; video: VideoFilter L8950, VideoView L9050, RenderOptions L9137; audio: AudioFilter L8995; Subtitles L9282; media: MediaCapture L9683; Resolvers L9913; Packages L10311; Osd L8815; Host L8657; Clipboard L10639; Power L10726; Tools L10785; Storage L10937; System L11136; Secrets L11216; window: MainWindow L7035; App L7215; Bindings L10539; Ui L4624; Timeline L6947; Drops L5965; Appearance L6046; I18n L6279; Settings L6562.
+- Plugin L3954, Scope L3709, PluginError L3634, Disposable L3572
+- Commands L4351; Windows L5288; Panels L6734; Dialogs L7381; Player L8122; video: VideoFilter L9002, VideoView L9102, RenderOptions L9189; audio: AudioFilter L9047; Subtitles L9336; media: MediaCapture L9740; Resolvers L9970; Packages L10368; Osd L8867; Host L8709; Clipboard L10696; Power L10783; Tools L10842; Storage L10994; System L11193; Secrets L11273; window: MainWindow L7051; App L7231; Bindings L10596; Ui L4640; Timeline L6963; Drops L5981; Appearance L6062; I18n L6295; Settings L6578.
 
 ## Examples
 
 Tested plugins in [examples/](https://github.com/vestrasys/vestra-player-sdk/tree/main/examples):
 
-- hello: The README Quick start: one menu command and an on-screen message. L14635–14724
-- blur: A tool window with one slider that blurs the playing video. L14725–14986
-- signal-generator: Generates its own video and audio: colour bars and a 1 kHz tone. L14987–15319
-- bookmark: A tool window bound to the playback state: remember the position and jump back to it. L15320–15506
-- panel-menu: A sidebar panel with its own right-click menu. L15507–15715
-- menus: Radio menu items, separator groups and a menu item whose title changes. L15716–15875
-- theme-widgets: A tool window drawn with the player's theme and widgets. L15876–16039
-- markdown: A window that shows a Markdown document. L16040–16236
-- i18n: A plugin in the player's language: English source text, a Chinese translation. L16237–16404
+- hello: The README Quick start: one menu command and an on-screen message. L14753–14842
+- blur: A tool window with one slider that blurs the playing video. L14843–15104
+- signal-generator: Generates its own video and audio: colour bars and a 1 kHz tone. L15105–15437
+- bookmark: A tool window bound to the playback state: remember the position and jump back to it. L15438–15624
+- panel-menu: A sidebar panel with its own right-click menu. L15625–15833
+- menus: Radio menu items, separator groups and a menu item whose title changes. L15834–15993
+- theme-widgets: A tool window drawn with the player's theme and widgets. L15994–16157
+- markdown: A window that shows a Markdown document. L16158–16354
+- i18n: A plugin in the player's language: English source text, a Chinese translation. L16355–16522
 
 ## Optional
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vestra-player/sdk",
-  "version": "1.5.33",
+  "version": "1.5.34",
   "description": "Plugin API types, test host and plugin CLI for Vestra Player (apiVersion vestra/1)",
   "license": "Apache-2.0",
   "repository": {