@vestra-player/sdk 1.5.18 → 1.5.21

package/dist/plugin/types.d.ts

@@ -578,11 +578,12 @@ export interface Commands {
  * An image file for a Slint `image` property, made by {@link Ui.image}.
  *
  * @remarks
- * Opaque: pass it as the **whole** value of an `image` property with
- * {@link View.set} or {@link View.bind}; it cannot sit inside a struct or an
- * array. Making the reference does not read the file: the player checks and
- * decodes it each time a view uses it ({@link Ui.image} has the rules and
- * limits).
+ * Opaque: pass it where the Slint type is `image`, with {@link View.set} or
+ * {@link View.bind}: the whole value of an `image` property or, from SDK
+ * 1.5.19 (player 0.5.1), an `image` field at any depth, such as the logo of
+ * each row of a list. Making the reference does not read the file: the
+ * player checks and decodes it each time a view uses it ({@link Ui.image}
+ * has the rules and limits).
  *
  * A reference belongs to the {@link Scope} that created it. Once that scope
  * is disposed, writing the reference fails with `invalid` (reported to
@@ -596,6 +597,22 @@ export interface Commands {
  * await cover.show();
  * ```
  *
+ * @example A logo in each row
+ * ```slint
+ * export struct Row { key: string, name: string, icon: image }
+ * ```
+ * ```ts
+ * const items = [{ id: "a", name: "A", iconPath: `${plugin.dataDirectory}/a.png` }];
+ * const list = plugin.windows.create("ui/list.slint");
+ * list.bind(() => ({
+ *   rows: items.map((item) => ({
+ *     key: item.id,
+ *     name: item.name,
+ *     icon: plugin.ui.image(item.iconPath, { maxSide: 64 }),
+ *   })),
+ * }));
+ * ```
+ *
  * @see {@link Ui.image}, [Windows, panels, settings pages, dialogs and the OSD](../../docs/concepts/ui.md)
  * @since 1.0.0
  * @category UI
@@ -606,6 +623,24 @@ export interface ImageRef {
     /** Brand that marks the value as an image reference; never construct one yourself. */
     readonly __vestraImage: true;
 }
+/**
+ * Options of {@link Ui.image} and {@link Ui.remoteImage}.
+ *
+ * @since 1.5.19
+ * @category UI
+ */
+export interface ImageOptions {
+    /**
+     * Decode the image scaled down, aspect kept, so that neither side is over
+     * this many pixels (an integer 1–4096); smaller images stay as they are.
+     * Use about twice the drawn size (64 for a 32 px logo) so that it stays
+     * sharp on high-density screens. It keeps the decoded memory small: a
+     * 1024×1024 icon is 4 MB decoded, 16 KB at `maxSide: 64`.
+     *
+     * @player 0.5.1; older players refuse the reference (`invalid`).
+     */
+    maxSide?: number;
+}
 /**
  * A Markdown document for `MarkdownView` or `MarkdownBlocks`, made by
  * {@link Ui.markdown}.
@@ -665,9 +700,8 @@ export interface MarkdownOptions {
     remoteImages?: boolean;
 }
 /**
- * The value of one Slint property: JSON with Markdown documents at any
- * depth ({@link PropData}), or an image as the whole value of an `image`
- * property.
+ * The value of one Slint property: JSON with Markdown documents and images
+ * at any depth ({@link PropData}).
  *
  * @remarks
  * JSON becomes Slint values as you would expect: booleans for `bool`,
@@ -684,13 +718,20 @@ export interface MarkdownOptions {
  *
  * A {@link MarkdownRef} goes where the Slint type is `[MarkdownBlock]`: the
  * whole value, or a field at any depth (SDK 1.5.4; older players refuse a
- * nested one). An {@link ImageRef} only as the whole value: nested in an
- * array or object it is `invalid`.
+ * nested one). An {@link ImageRef} goes where the Slint type is `image`: the
+ * whole value, or a field at any depth (SDK 1.5.19, player 0.5.1; older
+ * players refuse a nested one with `invalid`). The images nested in the
+ * values of one view (a window, panel or settings page) may show at most
+ * 32 MB of decoded pixels together (`IMAGE_LIMITS.viewBytes` in
+ * `@vestra-player/sdk/runtime`): a write
+ * that would pass it is refused with `limit`; use
+ * {@link ImageOptions.maxSide} for small pictures such as logos and
+ * thumbnails.
  *
  * Limits per value (`UI_VALUE_LIMITS` in `@vestra-player/sdk/testing`,
  * player 0.4.3; older players: 4096 values and 1024 rows): nesting depth 8,
  * 16384 values in total (every array, object, string, number, boolean and
- * null counts, the value itself included; a document is one), 4096 rows
+ * null counts, the value itself included; a document or an image is one), 4096 rows
  * per array, 64 KiB per string or field name and 1 MiB of text in total,
  * field names and the text of its Markdown documents included (256 KB per
  * document). A list of rows with 8 fields is 9 values per row, so about
@@ -708,8 +749,8 @@ export interface MarkdownOptions {
  */
 export type PropValue = PropData | ImageRef;
 /**
- * JSON whose values may also be Markdown documents, at any depth: the part
- * of {@link PropValue} that nests.
+ * JSON whose values may also be Markdown documents and (SDK 1.5.19) images,
+ * at any depth: the part of {@link PropValue} that nests.
  *
  * @example A message list whose rows carry a document
  * ```ts
@@ -721,7 +762,7 @@ export type PropValue = PropData | ImageRef;
  * @since 1.5.4
  * @category UI
  */
-export type PropData = null | boolean | number | string | MarkdownRef | Text | TextList | PropData[] | {
+export type PropData = null | boolean | number | string | MarkdownRef | ImageRef | Text | TextList | PropData[] | {
     [key: string]: PropData;
 };
 /**
@@ -778,10 +819,13 @@ export interface Ui {
      * the main window being rebuilt): it must be inside this plugin's package
      * directory or {@link Plugin.dataDirectory} after following links, at most
      * 16 MB and 4096×4096 pixels, and PNG or JPEG by content (the extension
-     * does not matter). A failed check is a failed property write: `missing`
-     * for a file that does not exist, `invalid` otherwise. It goes to
-     * {@link Scope.onError} and the property keeps its previous image; in the
-     * initial properties of a tool window it makes {@link Window.show} reject.
+     * does not matter). A failed check of a whole-value image is a failed
+     * property write: `missing` for a file that does not exist, `invalid`
+     * otherwise. It goes to {@link Scope.onError} and the property keeps its
+     * previous image; in the initial properties of a tool window it makes
+     * {@link Window.show} reject. A nested image (a field of a row, SDK
+     * 1.5.19) that fails its check is drawn empty instead, and the rest of
+     * the value is shown, as a Markdown image shows its alt text.
      *
      * The player caches decoded images per plugin (up to 64 MB, least recently
      * used first) and does not watch files. Every call returns a new value, so
@@ -792,9 +836,12 @@ export interface Ui {
      *
      * @param path - Absolute path of the image file, inside the package
      *   directory or the data directory.
+     * @param options - `maxSide` (SDK 1.5.19, player 0.5.1): decode the image
+     *   scaled down, aspect kept, so that neither side is over it.
      * @returns A new {@link ImageRef}, owned by this scope.
      *
-     * @throws `invalid` (throws) `path` is not a non-empty string.
+     * @throws `invalid` (throws) `path` is not a non-empty string, or
+     *   `maxSide` is not an integer 1–4096.
      *
      * @example Show a thumbnail the plugin rendered
      * ```ts
@@ -807,7 +854,51 @@ export interface Ui {
      *
      * @since 1.0.0
      */
-    image(path: string): ImageRef;
+    image(path: string, options?: ImageOptions): ImageRef;
+    /**
+     * Download an `https:` PNG or JPEG image (a thumbnail, a repository's
+     * plugin icon) and reference the local copy, as {@link Ui.image} does.
+     *
+     * @remarks
+     * Downloads like {@link Ui.markdown}'s remote images: Node's `fetch` in
+     * this plugin's process, at most 4 MB and 10 s per image, 4 downloads at a
+     * time per plugin, into `<dataDirectory>/.vestra-cache/images/`; the cache
+     * keeps 32 MB and fetches an address again after 24 hours, so a list that
+     * shows the same thumbnails again reads them from disk.
+     *
+     * @capability None (the plugin process has network access).
+     * @player Any (the reference is an ordinary {@link ImageRef}); nested in a
+     *   value, player 0.5.1.
+     *
+     * @param url - The image's `https:` address.
+     * @param options - As for {@link Ui.image}.
+     * @returns The reference, owned by this scope, once the file is in the
+     *   cache.
+     *
+     * @throws `invalid` (rejects) `url` is not an `https:` address, or
+     *   `maxSide` is not an integer 1–4096.
+     * @throws `unavailable` (rejects) the download failed, timed out, was too
+     *   large, or is not a PNG or JPEG image; or the plugin has no data
+     *   directory.
+     *
+     * @example Search results with thumbnails
+     * ```ts
+     * const results = [{ title: "A", thumbnailUrl: "https://example.com/a.jpg" }];
+     * const placeholder = plugin.ui.image(`${plugin.dataDirectory}/blank.png`);
+     * const rows = await Promise.all(
+     *   results.map(async (r) => ({
+     *     title: r.title,
+     *     thumb: await plugin.ui
+     *       .remoteImage(r.thumbnailUrl, { maxSide: 320 })
+     *       .catch(() => placeholder),
+     *   })),
+     * );
+     * plugin.windows.create("ui/results.slint").set({ rows });
+     * ```
+     *
+     * @since 1.5.19
+     */
+    remoteImage(url: string, options?: ImageOptions): Promise<ImageRef>;
     /**
      * Prepare a Markdown document for `MarkdownView` (`@vestra/markdown.slint`).
      *
@@ -3729,9 +3820,25 @@ export interface Player {
      * The core's first-tier relative seek (`seek-backward` / `seek-forward`,
      * ← / →): 0.1–3600 seconds in tenths, default 5. The newest call of any
      * plugin wins; it reverts when that plugin stops.
+     *
+     * `keyframes: true` (player 0.5.1, SDK 1.5.19): the step seeks
+     * (`seek-backward` / `seek-forward`, including {@link Host.run} with
+     * `seconds` and the picture-in-picture skips) land on a keyframe instead
+     * of the exact time: forward on the first keyframe at or after position +
+     * step, backward on the last at or before position − step, and they
+     * always move. Presses during a seek add up and continue from where it
+     * landed; the on-screen text shows the landed time. Sources without moving
+     * video seek exactly. The seek bar, {@link Player.seek}, scrubs, chapters,
+     * loops and {@link Player.step} are unaffected. Omitted or `false`: exact
+     * seeks, as before. `seconds` and `keyframes` are written as a pair: the
+     * newest call sets both.
+     *
+     * Older players ignore `keyframes`: set `"minPlayerVersion": "0.5.1"` in
+     * the manifest when you rely on it.
      */
     setStepSeek(options: {
         seconds: number;
+        keyframes?: boolean;
     }): Promise<void>;
     /**
      * The chapters of the current media (empty without media or chapters),
@@ -3770,22 +3877,28 @@ export interface Player {
     setAudioDevice(id: string | null): Promise<void>;
 }
 /**
- * The core's basic playback actions (menu commands owned by the player).
+ * The core's basic playback actions (menu commands owned by the player),
+ * and the main window's fullscreen toggle.
  *
  * | action | default bindings | behaviour |
  * | --- | --- | --- |
  * | `stop` | F4 | close the source |
- * | `play-pause` | Space | pause / resume, replay after the end |
+ * | `play-pause` | Space, a left click on the video (player 0.5.2) | pause / resume, replay after the end |
  * | `previous` / `next` | PageUp, Mouse:X1 / PageDown, Mouse:X2 | ask the sequence provider |
  * | `frame-back` / `frame-forward` | D / F | `player.step("frame", …)` |
- * | `seek-backward` / `seek-forward` | ← / → | relative seek by `setStepSeek` seconds |
+ * | `seek-backward` / `seek-forward` | ← / → | relative seek by `setStepSeek` seconds (or `host.run`'s `seconds`), exact or to keyframes as `setStepSeek` says |
  * | `rate-normal`, `rate-down`, `rate-up` | Z, X, C | 1×, ±0.1 within 0.25–4 |
  * | `volume-up` / `volume-down` | ↑ / ↓, wheel | ±5 (`volume-up` stops at 100) |
  * | `mute` | M | toggle mute |
+ * | `fullscreen` | Enter, Alt+Enter, F11 | toggle the main window's fullscreen: enter it when windowed, leave it when fullscreen, as the Toggle Fullscreen command does (SDK 1.5.21, player 0.5.2; `unavailable` when the player has no window) |
  *
- * In the binding overlay their keys are `host/<action>`.
+ * In the binding overlay their keys are `host/<action>`. `fullscreen`
+ * changes no playback state: read the result from `window.state.fullscreen`
+ * (`plugin.window.onChange`), which also changes when the user toggles it.
+ * Players before 0.5.2 reject it with `invalid`: set
+ * `"minPlayerVersion": "0.5.2"` when you use it.
  */
-export type HostAction = "play-pause" | "stop" | "previous" | "next" | "frame-back" | "frame-forward" | "seek-backward" | "seek-forward" | "rate-down" | "rate-up" | "rate-normal" | "volume-up" | "volume-down" | "mute";
+export type HostAction = "play-pause" | "stop" | "previous" | "next" | "frame-back" | "frame-forward" | "seek-backward" | "seek-forward" | "rate-down" | "rate-up" | "rate-normal" | "volume-up" | "volume-down" | "mute" | "fullscreen";
 /** `plugin.host`: the player's own core actions. */
 export interface Host {
     /**
@@ -3802,6 +3915,31 @@ export interface Host {
      * ```
      */
     run(action: HostAction): Promise<void>;
+    /**
+     * One step seek of `seconds` (0.1–3600 in tenths) instead of the
+     * {@link Player.setStepSeek} step: the same checks, mode (exact or
+     * keyframes), accumulation and on-screen text as ← / →. Use it for more
+     * seek steps of your own (Ctrl+→ and the like) so that they add up with
+     * the core's and land the same way.
+     *
+     * In keyframe mode it resolves once the seek has landed (so
+     * `player.state.position` is current after the `await`); presses that add
+     * up resolve together, the last with the text. In exact mode it resolves
+     * once the seek is submitted, as before. `invalid` for `seconds` out of
+     * range.
+     *
+     * @player 0.5.1 (set `"minPlayerVersion": "0.5.1"`: older players ignore
+     * `seconds` and seek by the `setStepSeek` step)
+     * @since 1.5.19
+     *
+     * @example
+     * ```ts
+     * bar.on("forward30", () => plugin.host.run("seek-forward", { seconds: 30 }));
+     * ```
+     */
+    run(action: "seek-backward" | "seek-forward", options: {
+        seconds: number;
+    }): Promise<void>;
 }
 /**
  * This plugin's information block on the OSD: multi-line text over the
@@ -4844,6 +4982,26 @@ export interface Packages {
      * (players released with SDK 1.5.18 on; older ones disabled built-ins too).
      */
     setEnabled(id: string, enabled: boolean): Promise<void>;
+    /**
+     * Restart a plugin (`plugins.manage`): stop it and start it again from the
+     * same package with the same data directory, for example to recover one
+     * that misbehaves. Built-ins included. A stopped or failed plugin is just
+     * started. The disabled flag is never written, so a reload never leaves
+     * a plugin disabled.
+     *
+     * Resolves once the plugin is stopped and its start is scheduled; the
+     * player starts it as soon as the old process is gone (at most 20 s).
+     * Follow it with {@link Packages.onChange}: `starting`, then `running`,
+     * or `failed` with the reason.
+     *
+     * `invalid` for oneself or a disabled plugin (enable it instead),
+     * `missing` unknown, `busy` while it is being installed or reloaded.
+     *
+     * @player 0.5.1; older players reject it as an unknown request
+     * (`unsupported`).
+     * @since 1.5.19
+     */
+    reload(id: string): Promise<void>;
     /**
      * Remove an installed plugin (`plugins.manage`); `removeData` also deletes
      * its data directory, otherwise reinstalling it from the same source

package/dist/plugin/ui.d.ts

@@ -1,6 +1,6 @@
 import type { Json } from "../wire.ts";
 import type { ScopeImpl } from "./scope.ts";
-import type { Dialogs, Disposable, ImageRef, Panels, PropValue, Props, Ui, View, Windows } from "./types.ts";
+import type { Dialogs, Disposable, ImageOptions, ImageRef, Panels, PropValue, Props, Ui, View, Windows } from "./types.ts";
 /** Slint names are kebab-case; plugin code may use camelCase. */
 export declare const kebab: (name: string) => string;
 /**
@@ -13,11 +13,13 @@ export declare class ImageHandle implements ImageRef {
     #private;
     readonly path: string;
     readonly __vestraImage: true;
-    constructor(scope: ScopeImpl, path: string);
+    constructor(scope: ScopeImpl, path: string, maxSide?: number);
     /** Released with its scope: writing it is `invalid`. */
     get released(): boolean;
     toJSON(): Json;
 }
+/** `ImageOptions.maxSide`, checked: an integer 1–4096 or absent. */
+export declare function imageSide(options: ImageOptions | undefined): number | undefined;
 export declare const ui: (scope: ScopeImpl) => Ui;
 /** Property and callback plumbing shared by windows, panels and settings pages. */
 export declare abstract class ViewBase implements View {

package/dist/plugin/ui.js

@@ -5,7 +5,7 @@ import { readFileSync } from "node:fs";
 import { basename, extname, resolve } from "node:path";
 import { failure, Latest, quiet } from "./runtime.js";
 import { dropsOf } from "./drops.js";
-import { MarkdownHandle, markdown } from "./markdown.js";
+import { MarkdownHandle, markdown, remoteImageFile } from "./markdown.js";
 /** Slint names are kebab-case; plugin code may use camelCase. */
 export const kebab = (name) => name.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
 const encode = (props) => Object.fromEntries(Object.entries(props).map(([k, v]) => [kebab(k), v]));
@@ -21,51 +21,69 @@ export class ImageHandle {
     __vestraImage = true;
     #scope;
     #ref = ++images;
-    constructor(scope, path) {
+    #maxSide;
+    constructor(scope, path, maxSide) {
         this.#scope = scope;
         this.path = path;
+        this.#maxSide = maxSide;
     }
     /** Released with its scope: writing it is `invalid`. */
     get released() {
         return this.#scope.disposed;
     }
     toJSON() {
-        return { $vestraImage: this.path, ref: this.#ref };
+        // `maxSide` only when given: players before 0.5.1 refuse the field.
+        return this.#maxSide === undefined
+            ? { $vestraImage: this.path, ref: this.#ref }
+            : { $vestraImage: this.path, ref: this.#ref, maxSide: this.#maxSide };
     }
 }
+/** `ImageOptions.maxSide`, checked: an integer 1–4096 or absent. */
+export function imageSide(options) {
+    const side = options?.maxSide;
+    if (side === undefined)
+        return undefined;
+    if (!Number.isInteger(side) || side < 1 || side > 4096)
+        throw failure("invalid", "maxSide must be an integer 1–4096");
+    return side;
+}
 /**
- * A property value as sent: images and documents in wire form, documents at
- * any depth (released ones refused wherever they are); an image only as the
- * whole value, like the player.
+ * A property value as sent: images and documents in wire form, at any depth
+ * (released ones refused wherever they are), like the player.
  */
-function wireValue(value, nested = false) {
+function wireValue(value) {
     if (value instanceof MarkdownHandle) {
         if (value.released)
             throw failure("invalid", "Markdown document was released with the scope that created it");
         return value.toJSON();
     }
     if (value instanceof ImageHandle) {
-        if (nested)
-            throw failure("invalid", `image ${value.path}: an image reference must be the whole value of an image property`);
         if (value.released)
             throw failure("invalid", `image ${value.path} was released with the scope that created it`);
         return value.toJSON();
     }
     if (Array.isArray(value))
-        return value.map((item) => wireValue(item, true));
+        return value.map((item) => wireValue(item));
     if (value !== null && typeof value === "object") {
         const out = {};
         for (const [key, item] of Object.entries(value))
-            out[key] = wireValue(item, true);
+            out[key] = wireValue(item);
         return out;
     }
     return value;
 }
 export const ui = (scope) => ({
-    image(path) {
+    image(path, options) {
         if (typeof path !== "string" || !path)
             throw failure("invalid", "ui.image needs a file path");
-        return new ImageHandle(scope, path);
+        return new ImageHandle(scope, path, imageSide(options));
+    },
+    async remoteImage(url, options) {
+        if (typeof url !== "string" || !url.startsWith("https://"))
+            throw failure("invalid", "ui.remoteImage needs an https: address");
+        const side = imageSide(options);
+        const file = await remoteImageFile(scope.runtime, url);
+        return new ImageHandle(scope, file, side);
     },
     markdown: (text, options) => markdown(scope, text, options),
 });

package/dist/plugin/values.d.ts

@@ -46,6 +46,21 @@ export declare const UI_VALUE_LIMITS: {
      */
     readonly textBytes: number;
 };
+/**
+ * The player's runtime image limits (`host/src/ui_image.rs`): a file's
+ * bytes and sides, the decoded pixels each plugin caches, and (SDK 1.5.19,
+ * player 0.5.1) the decoded pixels the nested images of one view may show.
+ */
+export declare const IMAGE_LIMITS: Readonly<{
+    /** The largest image file the player reads, in bytes. */
+    fileBytes: number;
+    /** The longest side, in pixels, the player accepts for an image file. */
+    side: 4096;
+    /** The decoded pixel bytes the player caches for each plugin's images. */
+    pluginBytes: number;
+    /** The decoded pixel bytes the nested images of one view may show (player 0.5.1). */
+    viewBytes: number;
+}>;
 /**
  * Why the player would refuse `value` (in wire form) as a property value,
  * or `null`. The same checks, order and messages as the player's

package/dist/plugin/values.js

@@ -54,6 +54,21 @@ function documentText(value) {
     const doc = value.$vestraMarkdown;
     return isObject(doc) && typeof doc.text === "string" ? doc.text : null;
 }
+/**
+ * The player's runtime image limits (`host/src/ui_image.rs`): a file's
+ * bytes and sides, the decoded pixels each plugin caches, and (SDK 1.5.19,
+ * player 0.5.1) the decoded pixels the nested images of one view may show.
+ */
+export const IMAGE_LIMITS = Object.freeze({
+    /** The largest image file the player reads, in bytes. */
+    fileBytes: 16 * 1024 * 1024,
+    /** The longest side, in pixels, the player accepts for an image file. */
+    side: 4096,
+    /** The decoded pixel bytes the player caches for each plugin's images. */
+    pluginBytes: 64 * 1024 * 1024,
+    /** The decoded pixel bytes the nested images of one view may show (player 0.5.1). */
+    viewBytes: 32 * 1024 * 1024,
+});
 /**
  * Why the player would refuse `value` (in wire form) as a property value,
  * or `null`. The same checks, order and messages as the player's
@@ -79,6 +94,9 @@ export function valueLimitProblem(value) {
         if (budget.values === L.values)
             return `UI value exceeds ${L.values} total nodes`;
         budget.values += 1;
+        // An image (nested from SDK 1.5.19) is one value, like a document.
+        if (isObject(value) && "$vestraImage" in value)
+            return null;
         const doc = documentText(value);
         if (doc !== null) {
             const n = bytes(doc);

package/dist/wire.d.ts

@@ -465,11 +465,11 @@ export declare function createWire(transport: Transport): {
     };
     /** The core's own playback actions; resolves when the action finished. */
     host: {
-        run: (action: string) => Promise<void>;
+        run: (action: string, seconds?: number) => Promise<void>;
     };
     step: {
         step: (unit: string, direction: string, expected?: SourceStamp) => Promise<void>;
-        setStepSeek: (seconds: number) => Promise<void>;
+        setStepSeek: (seconds: number, keyframes?: boolean) => Promise<void>;
     };
     clipboard: {
         readText: () => Promise<string | null>;
@@ -570,6 +570,7 @@ export declare function createWire(transport: Transport): {
         cancel: (operationId: string) => Promise<PackageOperation>;
         list: () => Promise<PackageInfo[]>;
         setEnabled: (id: string, enabled: boolean) => Promise<void>;
+        reload: (id: string) => Promise<void>;
         uninstall: (id: string, removeData: boolean, expectedRevision: number, requestId: string) => Promise<PackageOperation>;
     };
     snapshot: {

package/dist/wire.js

@@ -155,7 +155,7 @@ export function createWire(transport) {
         },
         /** The core's own playback actions; resolves when the action finished. */
         host: {
-            run: (action) => transport.request("host.run", { action }),
+            run: (action, seconds) => transport.request("host.run", seconds === undefined ? { action } : { action, seconds }),
         },
         step: {
             step: (unit, direction, expected) => transport.request("player.step", {
@@ -163,7 +163,7 @@ export function createWire(transport) {
                 direction,
                 ...(expected ? { expected } : {}),
             }),
-            setStepSeek: (seconds) => transport.request("player.setStepSeek", { seconds }),
+            setStepSeek: (seconds, keyframes) => transport.request("player.setStepSeek", keyframes === undefined ? { seconds } : { seconds, keyframes }),
         },
         clipboard: {
             readText: () => transport.request("clipboard.readText"),
@@ -284,6 +284,7 @@ export function createWire(transport) {
             cancel: (operationId) => transport.request("packages.cancel", { operationId }),
             list: () => transport.request("packages.list"),
             setEnabled: (id, enabled) => transport.request("packages.setEnabled", { id, enabled }),
+            reload: (id) => transport.request("packages.reload", { id }),
             uninstall: (id, removeData, expectedRevision, requestId) => transport.request("packages.uninstall", {
                 id,
                 removeData,