@vestra-player/sdk 1.6.8 → 1.6.9

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.6.9
+
+**Who must change: nobody.** Additions only: timeline ranges, OSD messages with action buttons, a limits constant, a wire method and `TestHost` support, and documentation of a bottom bar's `content-full-width`. `apiVersion` stays `vestra/1`, no new capability (`timeline.marks`, `playback.read` and `ui.osd` cover them). A plugin that does not use them sends exactly what it sent before; `onChange` of `plugin.timeline` still runs only when the marks change. One that uses them needs player 0.7.6 (`"minPlayerVersion": "0.7.6"`): the player builds `plugin` from its own SDK, so on older players `setRanges` and `ranges` do not exist (a `TypeError`), and `osd.show` there takes no options.
+
+- **Timeline ranges** (player 0.7.6): `TimelineLayer.setRanges(ranges, { ifCurrent? })` puts spans of the media on the seek bar, each `{ start, end, style, title? }` with `style` `"selection"` (a span the user picked to act on, such as a clip to export; drawn in the accent colour) or `"region"` (a part of the media the plugin describes; drawn dimmer). A layer's marks and ranges are replaced on their own (`set` keeps the ranges, `setRanges` keeps the marks); disposing the layer, its scope or stopping the plugin removes both, and a new source clears every layer. At most 100 ranges per layer, `0 ≤ start < end`, `end` within the media, titles ≤ 100 characters (`TIMELINE_LIMITS`, new, with the marks' 1000); failures go to `onError` as for marks. `plugin.timeline.ranges` (new, `playback.read`) is every layer's ranges merged by start, with `TimelineRange` (`start`, `end`, `style`, `title`, `plugin`); read it in a binding to follow it. Wire: `timeline.setRanges` (needs `timeline.marks`), and `ranges` beside `marks` in `timeline.marks` and `timeline.changed`.
+- **OSD messages with actions** (player 0.7.6): `plugin.osd.show(text, args?, { actions })` ends the message in up to two buttons (`OsdAction`: `title`, translated like the text, 1–40 characters; `command`, the local id of one of the plugin's own commands). The message stays about 4 seconds instead of 2 and does not fade while the pointer is on it and moving (it goes 2 seconds after the pointer leaves or rests, and at the latest 30 seconds after it showed); a click runs the command as if picked from a menu and removes the message. It stays one line, and nothing in it is created or removed while the pointer moves. A newer message replaces it with its buttons; the buttons go when the plugin stops, and while they show the plugin is not stopped for being idle. `osd.show` rejects with `invalid` for more than two actions, a bad title or a command the plugin has not declared. `OSD_LIMITS` gains `actions` (2) and `actionChars` (40). Older players ignore `actions`.
+- **`TestHost`**: `timeline.rangeLayers`, `timeline.ranges` and `setTimelineRanges(pluginId, ranges)` (another plugin's ranges); `timeline.setRanges` checked as the player does; `osdActions` (each message's buttons, in step with `osd`) and `pressOsdAction(index)`, which runs the command like a click.
+- **A bottom bar's `content-full-width`** (player 0.7.6, docs only): a bar that drops controls of its own also reports its row with every control shown in `content-full-width`, a public `length` property declared like `content-min-width`. The player then gives plugin buttons only the width beyond it, so every plugin button moves to » before the bar drops a control, and narrowing the window never brings a button back. A bar with only `content-min-width` keeps the earlier rule. [Writing a bottom bar](docs/guidelines/interface.md#writing-a-bottom-bar) and [Reference: theme](docs/reference/theme.md#bar-buttons) say so.
+
 ## 1.6.8
 
 **Who must change: nobody; authors of a bottom bar should move to `content-min-width`.** Documentation, a read-only Slint property and a removed CLI warning: no change to the TypeScript API, the wire or `TestHost`, `apiVersion` stays `vestra/1`, no new capability. A plugin's `button` declarations stay as they are. A bottom bar that still places `BarButtons` keeps working on player 0.7.6 (it shows that strip, and the player draws no second one); it is deprecated and goes in a later patch.

package/dist/api-requests.js

@@ -71,8 +71,12 @@ export const API_REQUESTS = Object.freeze({
     "Subtitles.remove": [{ method: "subtitles.remove" }, readsSubtitles],
     "Subtitles.setStyle": [{ method: "subtitles.style" }, readsSubtitles],
     "Timeline.marks": [{ method: "timeline.marks" }],
+    "Timeline.ranges": [{ method: "timeline.marks" }],
     "Timeline.onChange": [listen("timeline.changed")],
-    "Timeline.layer": [{ method: "timeline.set" }],
+    "Timeline.layer": [
+        { method: "timeline.set" },
+        { method: "timeline.setRanges" },
+    ],
     "MainWindow.onChange": [listen("window.state")],
     "MainWindow.setVideoArea": [{ method: "window.setVideoArea" }],
     "MainWindow.setAlwaysOnTop": [{ method: "window.setAlwaysOnTop" }],

package/dist/host-capabilities.js

@@ -300,7 +300,10 @@ export const HOST_CAPABILITIES = {
         },
         {
             label: "Show marks on the progress bar",
-            methods: [{ name: "timeline.set", needs: "timeline.marks" }],
+            methods: [
+                { name: "timeline.set", needs: "timeline.marks" },
+                { name: "timeline.setRanges", needs: "timeline.marks" },
+            ],
             name: "timeline.marks",
             requires: [],
             residency: "live",

package/dist/player-runtime.d.ts

@@ -16,6 +16,7 @@ export { HOST_CAPABILITIES } from "./host-capabilities.ts";
 export { BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BUILTIN_COMMANDS, BUILTIN_SUBMENUS, COMMAND_LIMITS, MENU_IDS, } from "./commands.ts";
 export { BINDING_INPUTS } from "./plugin/bindings.ts";
 export { OSD_LIMITS } from "./plugin/osd.ts";
+export { TIMELINE_LIMITS } from "./plugin/timeline.ts";
 export { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./plugin/services.ts";
 export { SUBTITLE_LIMITS } from "./plugin/subtitles.ts";
 export { VIDEO_PROCESSING_LIMITS } from "./processing.ts";

package/dist/player-runtime.js

@@ -14,6 +14,7 @@ export { HOST_CAPABILITIES } from "./host-capabilities.js";
 export { BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BUILTIN_COMMANDS, BUILTIN_SUBMENUS, COMMAND_LIMITS, MENU_IDS, } from "./commands.js";
 export { BINDING_INPUTS } from "./plugin/bindings.js";
 export { OSD_LIMITS } from "./plugin/osd.js";
+export { TIMELINE_LIMITS } from "./plugin/timeline.js";
 export { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./plugin/services.js";
 export { SUBTITLE_LIMITS } from "./plugin/subtitles.js";
 export { VIDEO_PROCESSING_LIMITS } from "./processing.js";

package/dist/plugin/osd.d.ts

@@ -46,6 +46,10 @@ export declare const OSD_LIMITS: Readonly<{
     readonly minColumns: 8;
     /** The largest `OsdPanelOptions.maxColumns` (1000). */
     readonly maxColumns: 1000;
+    /** Action buttons of one `osd.show` message (`OsdShowOptions.actions`; player 0.7.6) (2). */
+    readonly actions: 2;
+    /** Characters of an action's title, as shown (40; at least 1 that is not white space). */
+    readonly actionChars: 40;
 }>;
 /**
  * Copy and check template arguments: an array or object of at most 16

package/dist/plugin/osd.js

@@ -47,7 +47,32 @@ export const OSD_LIMITS = Object.freeze({
     minColumns: 8,
     /** The largest `OsdPanelOptions.maxColumns` (1000). */
     maxColumns: 1000,
+    /** Action buttons of one `osd.show` message (`OsdShowOptions.actions`; player 0.7.6) (2). */
+    actions: 2,
+    /** Characters of an action's title, as shown (40; at least 1 that is not white space). */
+    actionChars: 40,
 });
+/** Copy and check `OsdShowOptions.actions`: what the SDK can check before the player does. */
+function osdActions(options) {
+    if (options === undefined || options === null)
+        return undefined;
+    if (typeof options !== "object")
+        throw failure("invalid", "options is an object");
+    const actions = options.actions;
+    if (actions === undefined)
+        return undefined;
+    if (!Array.isArray(actions) || actions.length > OSD_LIMITS.actions)
+        throw failure("invalid", `actions is a list of at most ${OSD_LIMITS.actions}`);
+    return actions.map((action, i) => {
+        const { title, command } = (action ?? {});
+        if (typeof command !== "string" || command === "")
+            throw failure("invalid", `actions[${i}].command is a command id`);
+        return {
+            title: shownText(title, undefined, `actions[${i}].title`),
+            command,
+        };
+    });
+}
 /**
  * Copy and check template arguments: an array or object of at most 16
  * strings, finite numbers, texts and lists (`TEXT_LIMITS`).
@@ -134,6 +159,6 @@ class PanelHandle {
     }
 }
 export const osd = (scope) => ({
-    show: async (text, args) => scope.runtime.host.osd.show(shownText(text, args), templateArgs(args)),
+    show: async (text, args, options) => scope.runtime.host.osd.show(shownText(text, args), templateArgs(args), osdActions(options)),
     panel: () => new PanelHandle(scope),
 });

package/dist/plugin/testing.d.ts

@@ -7,6 +7,7 @@ import type { BuiltinCommand, BuiltinSubmenu } from "../commands.ts";
 import { CAPABILITY_INFO, MESSAGE_LIMIT } from "../capabilities.ts";
 import type { CapabilityInfo } from "../capabilities.ts";
 import { OSD_LIMITS } from "./osd.ts";
+import { TIMELINE_LIMITS } from "./timeline.ts";
 import { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./services.ts";
 import { SUBTITLE_LIMITS } from "./subtitles.ts";
 import { BINDING_INPUTS } from "./bindings.ts";
@@ -36,6 +37,8 @@ export type { CapabilityInfo };
 export { MESSAGE_LIMIT };
 /** The player's limits on the on-screen display. */
 export { OSD_LIMITS };
+/** The player's limits on a timeline layer. */
+export { TIMELINE_LIMITS };
 /** The player's limits on stored secrets. */
 export { SECRET_LIMITS };
 /** The player's limits on `plugin.storage.session`. */
@@ -647,6 +650,43 @@ export declare class TestHost implements Transport {
      * template and args the plugin sent are in `host.sent("osd.show")`.
      */
     readonly osd: string[];
+    /**
+     * The action buttons of each `osd.show` message, in step with `osd`
+     * (index for index): each button's title as shown and its command; `[]`
+     * for a message without actions (SDK 1.6.9).
+     */
+    readonly osdActions: {
+        /** The button title as shown, in the plugin's locale. */
+        title: string;
+        /** The local id of the plugin's command the button runs. */
+        command: string;
+    }[][];
+    /**
+     * Press button `index` of the newest OSD message, as the user does
+     * (player 0.7.6): its command runs as if picked from a menu, and settles.
+     * A disabled or busy command does nothing, as in the player.
+     *
+     * @param index - 0 or 1.
+     *
+     * @throws `Error` (rejects) The newest message has no button `index`.
+     *
+     * @example Press "Show in Folder" on the saved message
+     * The test checks the button the plugin put on its newest message, then
+     * presses it as the user would: the plugin's `reveal` command runs.
+     * ```ts
+     * import assert from "node:assert/strict";
+     * declare const host: TestHost;
+     * // ---cut---
+     * assert.deepEqual(host.osdActions.at(-1), [
+     *   { title: "Show in Folder", command: "reveal" },
+     * ]);
+     * await host.pressOsdAction(0); // runs the plugin's `reveal` command
+     * ```
+     *
+     * @capability None.
+     * @since 1.6.9
+     */
+    pressOsdAction(index: number): Promise<void>;
     /** The text of this plugin's osd panel as shown, `null` when hidden. */
     osdPanel: string | null;
     /**
@@ -948,7 +988,65 @@ export declare class TestHost implements Transport {
             /** The mark's title, `null` without one. */
             title: string | null;
         }[];
+        /**
+         * Each plugin's ranges by plugin id; layers without ranges are absent
+         * (SDK 1.6.9).
+         */
+        rangeLayers: Map<string, {
+            /** Seconds from the start. */
+            start: number;
+            /** Seconds from the start, after `start`. */
+            end: number;
+            /** `"selection"` or `"region"`. */
+            style: string;
+            /** The range's title, `null` without one. */
+            title: string | null;
+        }[]>;
+        /** Every layer's ranges merged, sorted by start, with the plugin's id. */
+        readonly ranges: {
+            /** The manifest id of the plugin that published the range. */
+            plugin: string;
+            /** Seconds from the start. */
+            start: number;
+            /** Seconds from the start, after `start`. */
+            end: number;
+            /** `"selection"` or `"region"`. */
+            style: string;
+            /** The range's title, `null` without one. */
+            title: string | null;
+        }[];
     };
+    /**
+     * Simulate another plugin publishing its timeline ranges (or clearing
+     * them with `[]`); pushes `timeline.changed` when the plugin subscribed.
+     *
+     * @param pluginId - The other plugin's manifest id.
+     * @param ranges - All its ranges.
+     *
+     * @example Let another plugin publish a clip range
+     * The plugin under test sees a range another plugin put on the seek bar:
+     * `setTimelineRanges` stores that plugin's ranges and pushes
+     * `timeline.changed`, and `settle()` lets it arrive.
+     * ```ts
+     * import assert from "node:assert/strict";
+     * declare const host: TestHost;
+     * // ---cut---
+     * host.setTimelineRanges("community.clips", [
+     *   { start: 40, end: 52.5, style: "selection", title: "Clip" },
+     * ]);
+     * await host.settle();
+     * assert.equal(plugin.timeline.ranges[0]?.plugin, "community.clips");
+     * ```
+     *
+     * @capability None.
+     * @since 1.6.9
+     */
+    setTimelineRanges(pluginId: string, ranges: {
+        start: number;
+        end: number;
+        style: string;
+        title?: string | null;
+    }[]): void;
     /**
      * Simulate another plugin publishing its timeline layer (or clearing it
      * with `[]`); pushes `timeline.changed` when the plugin subscribed.

package/dist/plugin/testing.js

@@ -76,6 +76,7 @@ import { localSocketPath } from "./local.js";
 import { BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BUILTIN_COMMANDS, BUILTIN_SUBMENUS, COMMAND_LIMITS, MENU_IDS, } from "../commands.js";
 import { CAPABILITY_INFO, MESSAGE_LIMIT } from "../capabilities.js";
 import { OSD_LIMITS } from "./osd.js";
+import { TIMELINE_LIMITS } from "./timeline.js";
 import { SECRET_LIMITS, SESSION_STORAGE_LIMITS } from "./services.js";
 import { SUBTITLE_LIMITS } from "./subtitles.js";
 import { BINDING_INPUTS, canonical, keyLabel } from "./bindings.js";
@@ -105,6 +106,8 @@ export { CAPABILITY_INFO };
 export { MESSAGE_LIMIT };
 /** The player's limits on the on-screen display. */
 export { OSD_LIMITS };
+/** The player's limits on a timeline layer. */
+export { TIMELINE_LIMITS };
 /** The player's limits on stored secrets. */
 export { SECRET_LIMITS };
 /** The player's limits on `plugin.storage.session`. */
@@ -536,6 +539,46 @@ export class TestHost {
      * template and args the plugin sent are in `host.sent("osd.show")`.
      */
     osd = [];
+    /**
+     * The action buttons of each `osd.show` message, in step with `osd`
+     * (index for index): each button's title as shown and its command; `[]`
+     * for a message without actions (SDK 1.6.9).
+     */
+    osdActions = [];
+    /**
+     * Press button `index` of the newest OSD message, as the user does
+     * (player 0.7.6): its command runs as if picked from a menu, and settles.
+     * A disabled or busy command does nothing, as in the player.
+     *
+     * @param index - 0 or 1.
+     *
+     * @throws `Error` (rejects) The newest message has no button `index`.
+     *
+     * @example Press "Show in Folder" on the saved message
+     * The test checks the button the plugin put on its newest message, then
+     * presses it as the user would: the plugin's `reveal` command runs.
+     * ```ts
+     * import assert from "node:assert/strict";
+     * declare const host: TestHost;
+     * // ---cut---
+     * assert.deepEqual(host.osdActions.at(-1), [
+     *   { title: "Show in Folder", command: "reveal" },
+     * ]);
+     * await host.pressOsdAction(0); // runs the plugin's `reveal` command
+     * ```
+     *
+     * @capability None.
+     * @since 1.6.9
+     */
+    async pressOsdAction(index) {
+        const action = this.osdActions.at(-1)?.[index];
+        if (!action)
+            throw new Error(`the newest OSD message has no button ${index}`);
+        const command = this.commands.get(action.command);
+        if (!command || command.state.busy || !command.state.enabled)
+            return;
+        await command.run();
+    }
     /** The text of this plugin's osd panel as shown, `null` when hidden. */
     osdPanel = null;
     #locale;
@@ -900,7 +943,59 @@ export class TestHost {
             })))
                 .sort((a, b) => a.time - b.time);
         },
+        /**
+         * Each plugin's ranges by plugin id; layers without ranges are absent
+         * (SDK 1.6.9).
+         */
+        rangeLayers: new Map(),
+        /** Every layer's ranges merged, sorted by start, with the plugin's id. */
+        get ranges() {
+            return [...this.rangeLayers]
+                .flatMap(([plugin, ranges]) => ranges.map((range) => ({
+                ...range,
+                /** The manifest id of the plugin that published the range. */
+                plugin,
+            })))
+                .sort((a, b) => a.start - b.start);
+        },
     };
+    /**
+     * Simulate another plugin publishing its timeline ranges (or clearing
+     * them with `[]`); pushes `timeline.changed` when the plugin subscribed.
+     *
+     * @param pluginId - The other plugin's manifest id.
+     * @param ranges - All its ranges.
+     *
+     * @example Let another plugin publish a clip range
+     * The plugin under test sees a range another plugin put on the seek bar:
+     * `setTimelineRanges` stores that plugin's ranges and pushes
+     * `timeline.changed`, and `settle()` lets it arrive.
+     * ```ts
+     * import assert from "node:assert/strict";
+     * declare const host: TestHost;
+     * // ---cut---
+     * host.setTimelineRanges("community.clips", [
+     *   { start: 40, end: 52.5, style: "selection", title: "Clip" },
+     * ]);
+     * await host.settle();
+     * assert.equal(plugin.timeline.ranges[0]?.plugin, "community.clips");
+     * ```
+     *
+     * @capability None.
+     * @since 1.6.9
+     */
+    setTimelineRanges(pluginId, ranges) {
+        if (ranges.length)
+            this.timeline.rangeLayers.set(pluginId, ranges.map((r) => ({
+                start: r.start,
+                end: r.end,
+                style: r.style,
+                title: r.title ?? null,
+            })));
+        else
+            this.timeline.rangeLayers.delete(pluginId);
+        this.#timelineChanged();
+    }
     /**
      * Simulate another plugin publishing its timeline layer (or clearing it
      * with `[]`); pushes `timeline.changed` when the plugin subscribed.
@@ -941,7 +1036,10 @@ export class TestHost {
         this.#timelineChanged();
     }
     #timelineChanged() {
-        this.emit("timeline.changed", { marks: this.timeline.marks });
+        this.emit("timeline.changed", {
+            marks: this.timeline.marks,
+            ranges: this.timeline.ranges,
+        });
     }
     /**
      * Runtime images written to views (`plugin.ui.image`,
@@ -3663,8 +3761,9 @@ export class TestHost {
             next.terminalReason = null;
             next.capabilities = { ...readyCapabilities };
             next.loop = null; // a new source clears the A-B loop
-            if (this.timeline.layers.size) {
+            if (this.timeline.layers.size || this.timeline.rangeLayers.size) {
                 this.timeline.layers.clear(); // and every timeline layer
+                this.timeline.rangeLayers.clear();
                 queueMicrotask(() => this.#timelineChanged());
             }
         }
@@ -4452,7 +4551,22 @@ export class TestHost {
             const text = this.#shown(p.text, p.args, "text").replace(/[\n\r]/g, " ");
             if (!text.trim() || [...text].length > OSD_LIMITS.messageChars)
                 throw new HostError("invalid", `osd text needs 1..${OSD_LIMITS.messageChars} characters`);
+            // Player 0.7.6: up to 2 buttons, each a command of this plugin.
+            const sent = p.actions;
+            if (sent !== undefined &&
+                (!Array.isArray(sent) || sent.length > OSD_LIMITS.actions))
+                throw new HostError("invalid", `actions is a list of at most ${OSD_LIMITS.actions}`);
+            const actions = (sent ?? []).map((action) => {
+                const title = this.#shown(action.title, undefined, "title").replace(/[\n\r]/g, " ");
+                if (!title.trim() || [...title].length > OSD_LIMITS.actionChars)
+                    throw new HostError("invalid", `an action title needs 1..=${OSD_LIMITS.actionChars} characters`);
+                const command = String(action.command);
+                if (!this.commands.has(command))
+                    throw new HostError("invalid", `${command} is not a command of this plugin`);
+                return { title, command };
+            });
             this.osd.push(text);
+            this.osdActions.push(actions);
         },
         "osd.panel": (p) => {
             if (p.text === null)
@@ -4701,7 +4815,10 @@ export class TestHost {
             if (next !== undefined)
                 panel.props[property] = next;
         },
-        "timeline.marks": () => ({ marks: this.timeline.marks }),
+        "timeline.marks": () => ({
+            marks: this.timeline.marks,
+            ranges: this.timeline.ranges,
+        }),
         "drops.provide": (p) => {
             const id = String(p.id);
             const index = this.dropProviders.findIndex((d) => d.id === id);
@@ -4895,6 +5012,44 @@ export class TestHost {
             })));
             return { applied: true };
         },
+        // Player 0.7.6: the layer's ranges, replaced on their own.
+        "timeline.setRanges": (p) => {
+            if (p.sourceId !== undefined &&
+                p.sourceId !== this.source.stamp.generation)
+                return { applied: false };
+            const sent = p.ranges;
+            const duration = this.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 = this.#declared(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`);
+            }
+            this.setTimelineRanges(this.manifestId, ranges.map((r) => ({
+                start: r.start,
+                end: r.end,
+                style: String(r.style),
+                title: r.title ?? null,
+            })));
+            return { applied: true };
+        },
         "ui.interaction": (p) => void (this.mounted().locks = p),
         "dialogs.confirm": (p) => {
             this.confirms.push(p);

package/dist/plugin/timeline.d.ts

@@ -1,7 +1,43 @@
 import type { Runtime } from "./runtime.ts";
 import type { ScopeImpl } from "./scope.ts";
-import type { WireMark } from "../wire.ts";
-import type { Timeline, TimelineMark } from "./types.ts";
+import type { WireTimeline } from "../wire.ts";
+import type { Timeline, TimelineMark, TimelineRange } from "./types.ts";
+/**
+ * The player's limits on one plugin's timeline layer
+ * ({@link TimelineLayer}). A list over them fails with code `invalid`,
+ * reported to `Scope.onError` (`set` and `setRanges` never throw). The
+ * player's tests check that these agree with the player.
+ *
+ * @example Keep a long list of ranges inside the limit
+ * The plugin publishes the first 100 of its ranges; the player refuses a
+ * longer list whole.
+ * ```ts
+ * import type { Plugin } from "@vestra-player/sdk";
+ * declare const plugin: Plugin;
+ * declare const segments: { start: number; end: number }[];
+ * // ---cut---
+ * import { TIMELINE_LIMITS } from "@vestra-player/sdk/testing";
+ *
+ * // A longer list would be refused whole.
+ * plugin.timeline.layer().setRanges(
+ *   segments
+ *     .slice(0, TIMELINE_LIMITS.ranges)
+ *     .map((s) => ({ ...s, style: "region" as const })),
+ * );
+ * ```
+ *
+ * @since 1.6.9
+ *
+ * @category Testing
+ */
+export declare const TIMELINE_LIMITS: Readonly<{
+    /** Marks in one layer (`TimelineLayer.set`) (1000). */
+    readonly marks: 1000;
+    /** Ranges in one layer (`TimelineLayer.setRanges`; player 0.7.6) (100). */
+    readonly ranges: 100;
+    /** Characters of a mark's or a range's title, as shown (100). */
+    readonly titleChars: 100;
+}>;
 /**
  * One per plugin: read before activation (with `playback.read`), then kept
  * current from `timeline.changed` (with `events`) once the plugin uses it.
@@ -9,11 +45,12 @@ import type { Timeline, TimelineMark } from "./types.ts";
 export declare class TimelineService {
     #private;
     marks: readonly TimelineMark[];
+    ranges: readonly TimelineRange[];
     layer: boolean;
     constructor(runtime: Runtime);
     init(): Promise<void>;
     start(): void;
-    accept(marks: WireMark[]): void;
+    accept(lists: WireTimeline): void;
     read(): Promise<void>;
     watch(listener: (marks: readonly TimelineMark[]) => void): {
         dispose: () => Promise<void>;

package/dist/plugin/timeline.js

@@ -1,11 +1,54 @@
 /** Seek-bar marks (`plugin.timeline`): one layer per plugin, merged by the player. */
 import { failure, Latest, quiet } from "./runtime.js";
+/**
+ * The player's limits on one plugin's timeline layer
+ * ({@link TimelineLayer}). A list over them fails with code `invalid`,
+ * reported to `Scope.onError` (`set` and `setRanges` never throw). The
+ * player's tests check that these agree with the player.
+ *
+ * @example Keep a long list of ranges inside the limit
+ * The plugin publishes the first 100 of its ranges; the player refuses a
+ * longer list whole.
+ * ```ts
+ * import type { Plugin } from "@vestra-player/sdk";
+ * declare const plugin: Plugin;
+ * declare const segments: { start: number; end: number }[];
+ * // ---cut---
+ * import { TIMELINE_LIMITS } from "@vestra-player/sdk/testing";
+ *
+ * // A longer list would be refused whole.
+ * plugin.timeline.layer().setRanges(
+ *   segments
+ *     .slice(0, TIMELINE_LIMITS.ranges)
+ *     .map((s) => ({ ...s, style: "region" as const })),
+ * );
+ * ```
+ *
+ * @since 1.6.9
+ *
+ * @category Testing
+ */
+export const TIMELINE_LIMITS = Object.freeze({
+    /** Marks in one layer (`TimelineLayer.set`) (1000). */
+    marks: 1000,
+    /** Ranges in one layer (`TimelineLayer.setRanges`; player 0.7.6) (100). */
+    ranges: 100,
+    /** Characters of a mark's or a range's title, as shown (100). */
+    titleChars: 100,
+});
 const view = (marks) => Object.freeze(marks.map((mark) => Object.freeze({
     time: mark.time,
     kind: mark.kind,
     title: mark.title ?? null,
     plugin: mark.plugin,
 })));
+const viewRanges = (ranges) => Object.freeze(ranges.map((range) => Object.freeze({
+    start: range.start,
+    end: range.end,
+    style: range.style,
+    title: range.title ?? null,
+    plugin: range.plugin,
+})));
 /**
  * One per plugin: read before activation (with `playback.read`), then kept
  * current from `timeline.changed` (with `events`) once the plugin uses it.
@@ -13,6 +56,7 @@ const view = (marks) => Object.freeze(marks.map((mark) => Object.freeze({
 export class TimelineService {
     #runtime;
     marks = Object.freeze([]);
+    ranges = Object.freeze([]);
     #listeners = new Set();
     #started = false;
     layer = false;
@@ -29,26 +73,35 @@ export class TimelineService {
         this.#started = true;
         // A mirror: a plugin listens through `watch` and bindings.
         this.#runtime.on("timeline.changed", (data) => {
-            const marks = data?.marks;
-            if (Array.isArray(marks))
-                this.accept(marks);
+            const lists = data;
+            if (lists && Array.isArray(lists.marks))
+                this.accept(lists);
             else
                 void this.read();
         }, "events", true);
     }
-    accept(marks) {
-        const next = view(marks);
-        if (JSON.stringify(next) === JSON.stringify(this.marks))
+    accept(lists) {
+        const marks = view(lists.marks);
+        // Players before 0.7.6 send no ranges.
+        const ranges = viewRanges(Array.isArray(lists.ranges) ? lists.ranges : []);
+        const marksChanged = JSON.stringify(marks) !== JSON.stringify(this.marks);
+        const rangesChanged = JSON.stringify(ranges) !== JSON.stringify(this.ranges);
+        if (!marksChanged && !rangesChanged)
             return;
-        this.marks = next;
-        for (const listener of [...this.#listeners])
-            listener(next);
+        if (marksChanged)
+            this.marks = marks;
+        if (rangesChanged)
+            this.ranges = ranges;
+        // `onChange` follows the marks only, as before ranges existed.
+        if (marksChanged)
+            for (const listener of [...this.#listeners])
+                listener(marks);
         this.#runtime.invalidate();
     }
     async read() {
         const result = await this.#runtime.host.timeline.marks().catch(() => null);
         if (result)
-            this.accept(result.marks);
+            this.accept(result);
     }
     watch(listener) {
         this.#listeners.add(listener);
@@ -70,6 +123,11 @@ export function timeline(scope) {
             scope.runtime.reading("timeline.changed");
             return service().marks;
         },
+        get ranges() {
+            service().start();
+            scope.runtime.reading("timeline.changed");
+            return service().ranges;
+        },
         onChange(listener) {
             service().start();
             const watch = service().watch((marks) => scope.run(listener, marks));
@@ -93,12 +151,18 @@ export function timeline(scope) {
 class Layer {
     #scope;
     #latest;
+    #latestRanges;
+    /** Ranges were sent: disposing clears them too. */
+    #ranged = false;
     #disposed = false;
     constructor(scope) {
         this.#scope = scope;
         this.#latest = new Latest(async (write) => {
             await scope.runtime.host.timeline.set(write.marks, write.sourceId);
         });
+        this.#latestRanges = new Latest(async (write) => {
+            await scope.runtime.host.timeline.setRanges(write.ranges, write.sourceId);
+        });
         scope.add(this);
     }
     set = (marks, options = {}) => {
@@ -121,13 +185,41 @@ class Layer {
             write.sourceId = options.ifCurrent.sourceId;
         quiet(this.#latest.push(write).catch((error) => this.#scope.report(error)));
     };
+    setRanges = (ranges, options = {}) => {
+        if (this.#disposed)
+            return;
+        if (!Array.isArray(ranges)) {
+            this.#scope.report(failure("invalid", "ranges must be a list"));
+            return;
+        }
+        const write = {
+            ranges: ranges.map((range) => ({
+                start: range?.start,
+                end: range?.end,
+                style: range?.style,
+                ...(range?.title === undefined
+                    ? {}
+                    : { title: range.title }),
+            })),
+        };
+        if (options.ifCurrent)
+            write.sourceId = options.ifCurrent.sourceId;
+        this.#ranged = true;
+        quiet(this.#latestRanges
+            .push(write)
+            .catch((error) => this.#scope.report(error)));
+    };
     async dispose() {
         if (this.#disposed)
             return;
         this.#disposed = true;
         this.#scope.forget(this);
         this.#latest.stop();
+        this.#latestRanges.stop();
         timelineOf(this.#scope.runtime).layer = false;
         await this.#scope.runtime.host.timeline.set([]).catch(() => { });
+        // Only a layer that sent ranges: an older player refuses the method.
+        if (this.#ranged)
+            await this.#scope.runtime.host.timeline.setRanges([]).catch(() => { });
     }
 }

package/dist/plugin/types.d.ts

@@ -4216,6 +4216,36 @@ export interface TimelineMark {
     /** The manifest id of the plugin that published it. */
     readonly plugin: string;
 }
+/**
+ * How a timeline range is drawn; readers choose colours by it.
+ *
+ * - `"selection"`: a span the user picked to act on, such as a clip to
+ *   export. The player's seek bar draws it in the accent colour.
+ * - `"region"`: a part of the media the plugin describes, such as an intro
+ *   or a chapter's span. Drawn dimmer, under selections.
+ *
+ * @since 1.6.9
+ * @category Playback
+ */
+export type RangeStyle = "selection" | "region";
+/**
+ * One range on the seek bar (player 0.7.6).
+ *
+ * @since 1.6.9
+ * @category Playback
+ */
+export interface TimelineRange {
+    /** Seconds from the start. */
+    readonly start: number;
+    /** Seconds from the start, after `start`. */
+    readonly end: number;
+    /** How it is drawn. */
+    readonly style: RangeStyle;
+    /** Label, `null` without one. */
+    readonly title: string | null;
+    /** The manifest id of the plugin that published it. */
+    readonly plugin: string;
+}
 /**
  * This plugin's own marks; disposing it removes them.
  *
@@ -4273,6 +4303,54 @@ export interface TimelineLayer extends Disposable {
     }[], options?: {
         ifCurrent?: PlayerState;
     }): void;
+    /**
+     * Replace the layer's ranges (last write wins; `[]` clears them), spans of
+     * the media drawn on the seek bar (player 0.7.6). The marks and the ranges
+     * of a layer are replaced on their own: `set` keeps the ranges and
+     * `setRanges` keeps the marks. Disposing the layer, its scope or stopping
+     * the plugin removes both, and a new source clears every layer.
+     *
+     * At most 100 ranges (`TIMELINE_LIMITS.ranges`), `0 ≤ start < end`, `end`
+     * within the media while its duration is known, titles ≤ 100 characters.
+     * Ranges may overlap. Failures go to `onError`; with `ifCurrent`, a
+     * write for another source is dropped silently. A title is data or a
+     * {@link Text} the player translates, as in `set`.
+     *
+     * Players before 0.7.6 build `plugin` from an SDK without `setRanges`, so
+     * the call throws a `TypeError` there: declare
+     * `"minPlayerVersion": "0.7.6"`.
+     *
+     * @example Show the clip range on the seek bar while a panel is open
+     * The span the user picked shows on the seek bar in the accent colour
+     * while the plugin's tab is showing, and goes when it is not. Two point
+     * marks would show the ends but not the span between them.
+     * ```ts
+     * declare const panel: Panel;
+     * declare const clip: { start: number; end: number };
+     * // ---cut---
+     * const layer = plugin.timeline.layer();
+     * // Only while the tab is on screen; [] takes the range away.
+     * const show = () =>
+     *   layer.setRanges(
+     *     panel.state?.effective
+     *       ? [{ start: clip.start, end: clip.end, style: "selection", title: "Clip" }]
+     *       : [],
+     *     { ifCurrent: plugin.player.state },
+     *   );
+     * panel.onChange(show);
+     * ```
+     *
+     * @capability timeline.marks
+     * @since 1.6.9
+     */
+    setRanges(ranges: {
+        start: number;
+        end: number;
+        style: RangeStyle;
+        title?: string | Text;
+    }[], options?: {
+        ifCurrent?: PlayerState;
+    }): void;
 }
 /**
  * `plugin.timeline`: marks on the seek bar. Every plugin publishes one
@@ -4303,6 +4381,38 @@ export interface TimelineLayer extends Disposable {
 export interface Timeline {
     /** Every layer merged, by time (`playback.read`). Empty on a new source. */
     readonly marks: readonly TimelineMark[];
+    /**
+     * Every layer's ranges merged, by start (`playback.read`; player 0.7.6:
+     * on older players `ranges` does not exist and reads `undefined`). Empty
+     * on a new source. Kept current like `marks` (with `events`): read it in
+     * a {@link View.bind} function and the view follows it. `onChange` runs
+     * only when the marks change.
+     *
+     * @example Draw the published ranges in a seek bar of your own
+     * A bottom bar draws a band for every range on the seek bar, whoever
+     * published it, as fractions of the duration.
+     * ```ts
+     * declare const bar: View;
+     * // ---cut---
+     * bar.bind(() => {
+     *   // Reading `ranges` here runs the binding again when they change.
+     *   const duration = plugin.player.state.duration ?? 0;
+     *   return {
+     *     ranges: duration
+     *       ? plugin.timeline.ranges.map((range) => ({
+     *           from: range.start / duration,
+     *           to: range.end / duration,
+     *           selection: range.style === "selection",
+     *         }))
+     *       : [],
+     *   };
+     * });
+     * ```
+     *
+     * @capability playback.read
+     * @since 1.6.9
+     */
+    readonly ranges: readonly TimelineRange[];
     /**
      * The merged list changed (needs `events`; at most every 100 ms).
      *
@@ -6700,12 +6810,19 @@ export interface Osd {
      *
      * @param text - The template, 1–200 characters once translated and
      *   formatted; line breaks become spaces.
+     * With `options.actions` (player 0.7.6) the message ends in up to two
+     * buttons, each running one of the plugin's own commands
+     * ({@link OsdShowOptions}). Older players show the message without them.
+     *
      * @param args - Values for its placeholders (player 0.4.3; older players
-     *   show the template as it is).
+     *   show the template as it is). Pass `null` with a `Text` and options.
+     * @param options - Action buttons after the text (SDK 1.6.9).
      * @returns Resolves once the message is on screen.
      *
      * @throws `invalid` (rejects) The shown text is empty, only white space,
-     *   or longer than 200 characters, or `args` is not a {@link TemplateArgs}.
+     *   or longer than 200 characters, or `args` is not a {@link TemplateArgs};
+     *   or there are more than 2 actions, a title is empty or longer than 40
+     *   characters once translated, or a command is not one of the plugin's.
      * @throws `unavailable` (rejects) The player runs without a user interface.
      * @throws `capability` (rejects) The manifest does not declare `ui.osd`.
      *
@@ -6719,9 +6836,28 @@ export interface Osd {
      * await plugin.osd.show("Speed {}×", [plugin.player.state.rate]);
      * ```
      *
+     * @example Offer "Show in Folder" after saving a file
+     * The OSD reads "Saved clip.mp4 [Show in Folder]" for about 4 seconds,
+     * longer while the pointer is on it. A click runs the plugin's own
+     * `reveal` command, which knows the last saved file; the message goes.
+     * ```ts
+     * declare const path: string;
+     * // ---cut---
+     * let saved = path; // the command acts on the last saved file
+     * plugin.commands.add({
+     *   id: "reveal",
+     *   title: "Show Last Saved File in Folder",
+     *   enabled: () => saved !== "",
+     *   run: () => plugin.system.reveal(saved),
+     * });
+     * await plugin.osd.show("Saved {}", [saved.split(/[\\/]/).pop() ?? saved], {
+     *   actions: [{ title: "Show in Folder", command: "reveal" }], // one button
+     * });
+     * ```
+     *
      * @since 1.0.0
      */
-    show(text: TextValue, args?: TemplateArgs): Promise<void>;
+    show(text: TextValue, args?: TemplateArgs | null, options?: OsdShowOptions): Promise<void>;
     /**
      * Create this plugin's information block.
      *
@@ -6748,6 +6884,54 @@ export interface Osd {
      */
     panel(): OsdPanel;
 }
+/**
+ * One button at the end of an OSD message ({@link Osd.show}, player 0.7.6).
+ *
+ * @since 1.6.9
+ * @category UI
+ */
+export interface OsdAction {
+    /**
+     * The button's label: English source text the player translates with the
+     * plugin's catalog, or a {@link Text}; 1–40 characters once translated
+     * (`OSD_LIMITS.actionChars`). A verb, as on a menu item: "Show in
+     * Folder", "Copy", "Undo".
+     */
+    title: TextValue;
+    /**
+     * The local id of one of this plugin's own commands
+     * ({@link CommandOptions.id}), declared when the message is shown. A
+     * click runs it as if the user picked it from a menu: a disabled command
+     * does nothing. The command takes no arguments, so it acts on what the
+     * plugin remembers (the file it just saved).
+     */
+    command: string;
+}
+/**
+ * Options of {@link Osd.show} (SDK 1.6.9).
+ *
+ * @remarks
+ * A message with actions stays about 4 seconds instead of 2, and does not
+ * fade while the pointer is on it and moving: it goes 2 seconds after the
+ * pointer leaves or rests (the player's idle time), and at the latest 30
+ * seconds after it showed, hovered or not. A click on a button runs its
+ * command and removes the message.
+ * It is still one line: the buttons follow the text. Buttons take no
+ * keyboard focus; screen readers can press them. A newer message, from any
+ * plugin or the player, replaces the message with its buttons, and the
+ * buttons go when the plugin stops. While its buttons show, the plugin is
+ * not stopped for being idle.
+ *
+ * Players before 0.7.6 ignore `actions` and show the text alone for 2
+ * seconds, so do not make an action the only way to reach something.
+ *
+ * @since 1.6.9
+ * @category UI
+ */
+export interface OsdShowOptions {
+    /** At most 2 buttons (`OSD_LIMITS.actions`), in order after the text. */
+    actions?: readonly OsdAction[];
+}
 /**
  * The state of a filter, display layer or render options handle.
  * After `failed` nothing retries automatically until the next `set()`,

package/dist/wire.d.ts

@@ -262,6 +262,19 @@ export interface WireMark {
     title: string | null;
     plugin: string;
 }
+/** One timeline range as the player merges them (player 0.7.6). */
+export interface WireRange {
+    start: number;
+    end: number;
+    style: "selection" | "region";
+    title: string | null;
+    plugin: string;
+}
+/** `timeline.marks` and `timeline.changed`; `ranges` from player 0.7.6. */
+export interface WireTimeline {
+    marks: WireMark[];
+    ranges?: WireRange[];
+}
 /** The backdrop as `layout.state` reports it; `null` without one. */
 export interface LayoutBackdrop {
     owner: number;
@@ -568,9 +581,7 @@ export declare function createWire(transport: Transport): {
     };
     /** Mark layers on the seek bar (`plugin.timeline`). */
     timeline: {
-        marks: () => Promise<{
-            marks: WireMark[];
-        }>;
+        marks: () => Promise<WireTimeline>;
         set: (marks: {
             time: number;
             kind: string;
@@ -578,6 +589,15 @@ export declare function createWire(transport: Transport): {
         }[], sourceId?: number) => Promise<{
             applied: boolean;
         }>;
+        /** Player 0.7.6. */
+        setRanges: (ranges: {
+            start: number;
+            end: number;
+            style: string;
+            title?: string | TextJson;
+        }[], sourceId?: number) => Promise<{
+            applied: boolean;
+        }>;
     };
     /** Chapters and the A-B loop of the current media. */
     marks: {
@@ -666,7 +686,10 @@ export declare function createWire(transport: Transport): {
     };
     /** `text` is a template in the plugin's catalog, formatted with `args` (player 0.4.3). */
     osd: {
-        show: (text: TextValueJson, args?: TemplateArgsJson) => Promise<void>;
+        show: (text: TextValueJson, args?: TemplateArgsJson, actions?: {
+            title: TextValueJson;
+            command: string;
+        }[]) => Promise<void>;
         panel: (text: TextValueJson | null, args?: TemplateArgsJson, maxColumns?: number) => Promise<void>;
     };
     layout: {

package/dist/wire.js

@@ -156,6 +156,11 @@ export function createWire(transport) {
                 marks,
                 ...(sourceId === undefined ? {} : { sourceId }),
             }),
+            /** Player 0.7.6. */
+            setRanges: (ranges, sourceId) => transport.request("timeline.setRanges", {
+                ranges,
+                ...(sourceId === undefined ? {} : { sourceId }),
+            }),
         },
         /** Chapters and the A-B loop of the current media. */
         marks: {
@@ -245,9 +250,11 @@ export function createWire(transport) {
         },
         /** `text` is a template in the plugin's catalog, formatted with `args` (player 0.4.3). */
         osd: {
-            show: (text, args) => transport.request("osd.show", {
+            show: (text, args, actions) => transport.request("osd.show", {
                 text,
                 ...(args === undefined ? {} : { args }),
+                // Player 0.7.6; older players ignore it.
+                ...(actions === undefined ? {} : { actions }),
             }),
             panel: (text, args, maxColumns) => transport.request("osd.panel", {
                 text,

package/llms.txt

@@ -1,6 +1,6 @@
 # Vestra Player SDK
 
-> @vestra-player/sdk 1.6.8: 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. The documentation is a tree of short pages read by path, like `go doc`: the same pages and API as https://vestrasys.github.io/vestra-player-sdk/.
+> @vestra-player/sdk 1.6.9: 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. The documentation is a tree of short pages read by path, like `go doc`: the same pages and API as https://vestrasys.github.io/vestra-player-sdk/.
 
 ## Read the documentation
 
@@ -31,12 +31,12 @@
 - `/API/Commands`: 15 entries: CommandState, Bindable, Condition, When, MenuId, BarButtonIcon, CommandButton, CommandOptions, Command, Commands, HostAction, Host, BindingRef, BindingInfo, Bindings
 - `/API/Media`: 6 entries: CaptureOptions, Snapshot, ExportOptions, JobState, ExportJob, MediaCapture
 - `/API/Packages`: 10 entries: PackageManifest, PackageSource, InstallOptions, PackageCandidate, PackageChangeStatus, PackageChange, PluginInfo, PluginDisplay, PluginWarning, Packages
-- `/API/Playback`: 18 entries: MarkKind, TimelineMark, TimelineLayer, Timeline, AudioTrack, PlayerState, AudioDevice, Chapter, Conditional, Media, Scrub, StreamFrame, StreamOptions, StreamStartError, Stream,…
+- `/API/Playback`: 20 entries: MarkKind, TimelineMark, RangeStyle, TimelineRange, TimelineLayer, Timeline, AudioTrack, PlayerState, AudioDevice, Chapter, Conditional, Media, Scrub, StreamFrame, StreamOptions,…
 - `/API/Plugin`: 13 entries: Disposable, PluginError, Scope, Plugin, StopReason, DisposeInfo, WindowState, MainWindow, AppInfo, App, SystemInfo, DisplayInfo, Json
 - `/API/Processing`: 18 entries: FilterStatus, VideoFilter, AudioFilter, ViewSettings, VideoView, RenderSettings, RenderOptions, VideoShaders, UpscalingReasonCode, UpscalingReason, UpscalingDecodingCause,…
 - `/API/Services`: 15 entries: Clipboard, Power, ToolResult, Tools, JsonStore, Storage, SessionStorage, System, Secrets, RenderingMode, RenderingPreference, RenderingReasonCode, RenderingReason, RenderingState,…
 - `/API/Sources`: 7 entries: ResolverOptions, WebResolverOptions, FileResolverOptions, ResolvedStream, Resolver, Resolvers, ResolvedMedia
 - `/API/Subtitles`: 5 entries: SubtitleTrack, SubtitlesState, SubtitleConditional, Subtitles, SubtitleStyle
-- `/API/UI`: 42 entries: ImageRef, ImageOptions, MarkdownRef, MarkdownOptions, PropValue, PropData, Props, Ui, View, Window, Windows, SlotState, SlotPanel, PanelState, PanelSlot, SidebarSlot, Panel,…
-- `/API/Testing`: 32 entries: CapabilityInfo, CAPABILITY_INFO, MESSAGE_LIMIT, COMMAND_LIMITS, MENU_IDS, BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BuiltinSubmenu, BUILTIN_SUBMENUS, BuiltinCommand, BUILTIN_COMMANDS, LOCALES,…
+- `/API/UI`: 44 entries: ImageRef, ImageOptions, MarkdownRef, MarkdownOptions, PropValue, PropData, Props, Ui, View, Window, Windows, SlotState, SlotPanel, PanelState, PanelSlot, SidebarSlot, Panel,…
+- `/API/Testing`: 33 entries: CapabilityInfo, CAPABILITY_INFO, MESSAGE_LIMIT, COMMAND_LIMITS, MENU_IDS, BAR_BUTTON_ICONS, BAR_BUTTON_LIMITS, BuiltinSubmenu, BUILTIN_SUBMENUS, BuiltinCommand, BUILTIN_COMMANDS, LOCALES,…
 - `/API/Docs`: 4 entries: DOCS_PAGE_BYTES, DocsOptions, docs, searchDocs

package/package.json

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