@vestra-player/sdk 1.5.1 → 1.5.3

package/dist/plugin/types.d.ts

@@ -1212,6 +1212,46 @@ export interface SlotState {
     /** The sidebar floats in its own window; always `false` for the bottom bar. */
     detached: boolean;
 }
+/**
+ * One panel of a position ({@link PanelSlot.panels}): a tab of the sidebar.
+ *
+ * @since 1.5.2
+ * @category UI
+ */
+export interface SlotPanel {
+    /** The manifest id of the plugin that mounted it (pass it to {@link PanelSlot.activate}). */
+    plugin: string;
+    /** Its tab label: the `title` of {@link Panels.mount}, else the plugin's name. */
+    title: string;
+    /** Its tab is the current one (the panel the position shows). */
+    active: boolean;
+}
+/**
+ * The state of one panel ({@link Panel.state}): its position's state, seen
+ * from this panel, which may be one of several sidebar tabs.
+ *
+ * @since 1.5.2
+ * @category UI
+ */
+export interface PanelState {
+    /**
+     * Its tab is the current one. Always `true` for the bottom bar, the
+     * backdrop and a sidebar panel without other tabs.
+     */
+    active: boolean;
+    /** The position's preference (the user's choice to show it). */
+    preferred: boolean;
+    /** This panel is on screen now: the position is, and this is its current tab. */
+    effective: boolean;
+    /**
+     * Why this panel is not on screen, `null` while it is: `otherTab` while
+     * another plugin's tab is the current one (whatever the position's state),
+     * else the position's reason ({@link SlotState.reason}).
+     */
+    reason: SlotState["reason"] | "otherTab";
+    /** The sidebar floats in its own window (with all its tabs). */
+    detached: boolean;
+}
 /**
  * The bottom bar or the sidebar position (`plugin.panels.bottom`,
  * `plugin.panels.sidebar`), independent of who mounted the panel there.
@@ -1246,15 +1286,31 @@ export interface SlotState {
  * @category UI
  */
 export interface PanelSlot {
-    /** The current state; `null` while no plugin has a panel there (or without `ui.mount`). */
+    /**
+     * The current state; `null` while no plugin has a panel there (or without
+     * `ui.mount`). With sidebar tabs it is the whole position's: shown,
+     * hidden and floating apply to all tabs, which {@link PanelSlot.panels}
+     * lists.
+     */
     readonly state: SlotState | null;
+    /**
+     * The position's panels in tab order: the sidebar's tabs, the bottom
+     * bar's one panel; `null` while there is none (as `state`), and from
+     * players without sidebar tabs (0.4.0 and older). Refreshed with `state`.
+     *
+     * @throws Never.
+     *
+     * @since 1.5.2
+     */
+    readonly panels: readonly SlotPanel[] | null;
     /**
      * Run code when the position's state changes.
      *
      * @remarks
      * Needs `events`: without it the listener runs only after this plugin's own
-     * changes. Called with `null` when the panel there is unmounted. Errors go
-     * to {@link Scope.onError}.
+     * changes. Called with `null` when the panel there is unmounted, and also
+     * when only the tabs changed ({@link PanelSlot.panels}: a panel added or
+     * removed, another tab current). Errors go to {@link Scope.onError}.
      *
      * @capability ui.mount and events
      *
@@ -1325,6 +1381,41 @@ export interface PanelSlot {
      * @since 1.0.0
      */
     toggle(): Promise<void>;
+    /**
+     * Make a panel's tab the current one, without showing or hiding the
+     * position.
+     *
+     * @remarks
+     * The sidebar holds the panels of several plugins as tabs (see
+     * {@link Panels.mount}); this switches which one it shows, like a click on
+     * its tab. To show this plugin's own panel, use {@link Panel.show}. The
+     * bottom bar has one panel: activating it changes nothing. Players
+     * without sidebar tabs (0.4.0 and older) ignore it.
+     *
+     * @capability ui.mount
+     *
+     * @param plugin - The manifest id of the plugin whose panel to show, one
+     *   of {@link PanelSlot.panels}.
+     * @returns Resolves once the layout has the new current tab, with `state`
+     *   refreshed.
+     *
+     * @throws `missing` (rejects) No panel is mounted at this position, or
+     *   none of `plugin`.
+     * @throws `unavailable` (rejects) The player runs without a user interface.
+     * @throws `capability` (rejects) The manifest does not declare `ui.mount`.
+     *
+     * @example A command that shows the playlist's tab
+     * ```ts
+     * plugin.commands.add({
+     *   id: "to-playlist",
+     *   title: "Show the playlist tab",
+     *   run: () => plugin.panels.sidebar.activate("vestra.playlist"),
+     * });
+     * ```
+     *
+     * @since 1.5.2
+     */
+    activate(plugin: string): Promise<void>;
 }
 /**
  * The sidebar position: a {@link PanelSlot} that can also float in a window
@@ -1418,14 +1509,25 @@ export interface Panel extends View, Disposable {
      *
      * @remarks
      * Mounts made while `activate` runs must succeed before the plugin is
-     * ready: a rejection fails activation. Later failures also go to
-     * {@link Scope.onError}.
+     * ready: a rejection fails activation, except `conflict` for a taken
+     * position (below), which the player (0.4.x after 0.4.0) and `TestHost`
+     * do not count: the plugin runs without its panel, its commands and keys
+     * work, and the player shows the refusal (an OSD message,
+     * {@link PluginInfo.warnings} and the text in {@link PluginInfo.error}).
+     * Later failures also go to {@link Scope.onError}.
+     *
+     * A second sidebar panel is not refused: it resolves as another tab
+     * (see {@link Panel.state}). Built-in plugins mount first at start-up,
+     * so the playlist's tab is first and a built-in panel keeps its position.
      *
      * @throws `ui-prepare` (rejects) The Slint file does not compile, or a
      *   bound property is not declared on the bridge global; `message` has the
-     *   diagnostics. Also when another plugin's panel already occupies the
-     *   bottom bar or the sidebar.
-     * @throws `conflict` (rejects) Another plugin shows the backdrop.
+     *   diagnostics. (Players 0.4.0 and older also answer a taken bottom bar
+     *   or sidebar with it.)
+     * @throws `conflict` (rejects) Another plugin's panel holds the bottom bar
+     *   or the backdrop (shown, or being mounted), or the sidebar has all the
+     *   tabs it takes (8); `message` names the position and the holder
+     *   (「侧栏已被 vestra.playlist 使用」). Not an activation failure.
      * @throws `busy` (rejects) The player is still preparing this plugin's
      *   previous mount, or its queue of mounts is full.
      * @throws `invalid` (rejects) `title` is longer than 128 bytes or has
@@ -1436,6 +1538,107 @@ export interface Panel extends View, Disposable {
      * @throws `capability` (rejects) The manifest does not declare `ui.mount`.
      */
     readonly ready: Promise<void>;
+    /**
+     * This panel's state: its position's, and whether its tab is the current
+     * one; `null` until {@link Panel.ready} resolved (and after `dispose`).
+     *
+     * @remarks
+     * Read when first used; with `events` it then follows every change (the
+     * user switching tabs, other plugins, the window size), without `events`
+     * only this plugin's own changes. A sidebar panel in a background tab
+     * has `active: false`, `effective: false` and `reason: "otherTab"`.
+     *
+     * @throws Never; `null` stands for "not mounted".
+     *
+     * @since 1.5.2
+     */
+    readonly state: PanelState | null;
+    /**
+     * Run code when this panel's state changes.
+     *
+     * @remarks
+     * Needs `events`: without it the listener runs only after this plugin's
+     * own changes. Called with `null` when the panel is unmounted. Errors go
+     * to {@link Scope.onError}.
+     *
+     * @capability ui.mount and events
+     *
+     * @param listener - Receives the new state.
+     * @returns A handle that removes the listener.
+     *
+     * @example Say when the user switched to another tab
+     * ```ts
+     * const panel = plugin.panels.mount("sidebar", "ui/list.slint", { title: "List" });
+     * panel.onChange((state) => {
+     *   if (state?.reason === "otherTab") console.error("list in a background tab");
+     * });
+     * ```
+     *
+     * @since 1.5.2
+     */
+    onChange(listener: (state: PanelState | null) => void): Disposable;
+    /**
+     * Show this panel: make its tab the current one and show its position.
+     *
+     * @remarks
+     * Sets the position's preference like {@link PanelSlot.setVisible}`(true)`
+     * (remembered; in fullscreen the sidebar overlay pops out). On players
+     * without sidebar tabs (0.4.0 and older) it is just that. Waits for
+     * {@link Panel.ready} first.
+     *
+     * @capability ui.mount
+     *
+     * @returns Resolves once the layout shows the panel's tab, with `state`
+     *   refreshed.
+     *
+     * @throws `invalid` (rejects) The panel is the backdrop, which the player
+     *   shows by itself.
+     * @throws `unavailable` (rejects) The player runs without a user interface.
+     * @throws The errors of {@link Panel.ready} (rejects) The mount failed.
+     *
+     * @example
+     * ```ts
+     * const list = plugin.panels.mount("sidebar", "ui/list.slint", { title: "List" });
+     * plugin.commands.add({ id: "show", title: "Show the list", run: () => list.show() });
+     * ```
+     *
+     * @since 1.5.2
+     */
+    show(): Promise<void>;
+    /**
+     * Show this panel, or hide its position when it is shown.
+     *
+     * @remarks
+     * Reads the state from the player first. When the position is shown
+     * (`preferred`) and this panel's tab is the current one, it hides the
+     * position; otherwise it does {@link Panel.show}: a panel in a background
+     * tab comes to the front instead of the sidebar closing. A "Show list"
+     * command checked by `state.preferred && state.active` matches it. Waits
+     * for {@link Panel.ready} first.
+     *
+     * @capability ui.mount
+     *
+     * @returns Resolves once the layout has changed, with `state` refreshed.
+     *
+     * @throws `invalid` (rejects) The panel is the backdrop.
+     * @throws `unavailable` (rejects) The player runs without a user interface.
+     * @throws The errors of {@link Panel.ready} (rejects) The mount failed.
+     *
+     * @example A toggle command for a sidebar panel (the playlist's F6)
+     * ```ts
+     * const list = plugin.panels.mount("sidebar", "ui/list.slint", { title: "List" });
+     * plugin.commands.add({
+     *   id: "list",
+     *   path: ["@screen", "List"],
+     *   bindings: ["F6"],
+     *   checked: () => (list.state?.preferred ?? false) && (list.state?.active ?? false),
+     *   run: () => list.toggle(),
+     * });
+     * ```
+     *
+     * @since 1.5.2
+     */
+    toggle(): Promise<void>;
     /**
      * Keep the panel on screen while the user works in it.
      *
@@ -1489,8 +1692,8 @@ export interface Panel extends View, Disposable {
      * @returns Resolves once the menu is open (not when the user picks).
      *
      * @throws `missing` (rejects) An item is not a command of this plugin.
-     * @throws `unavailable` (rejects) The panel is not on screen, or it is the
-     *   backdrop.
+     * @throws `unavailable` (rejects) The panel is not on screen (also: its
+     *   sidebar tab is not the current one), or it is the backdrop.
      * @throws `invalid` (rejects) No items, more than 32, or `at` is not
      *   finite.
      * @throws The errors of {@link Panel.ready} (rejects) The mount failed.
@@ -2032,9 +2235,17 @@ export interface Panels {
      *   floats over the video and hides after 3 seconds without activity.
      * - `"sidebar"`: right of the video, the window's full height, as wide as the
      *   user drags it (at least 317). The user can detach it into a floating
-     *   window titled `title`.
+     *   window titled `title`. Several plugins may mount here (player 0.4.x
+     *   after 0.4.0): each panel is a tab, labelled `title` (else the plugin's
+     *   name), and the player draws a 31px tab strip above the current one
+     *   while there are two or more (with one panel, nothing changes).
+     *   Showing, hiding and detaching apply to the whole sidebar. If the
+     *   bridge global declares `in property <bool> tabbed`, the player sets
+     *   it to `true` while it draws the strip, so a panel with a tab strip of
+     *   its own can hide it. Panel coordinates (drops) start below the strip.
      * - `"backdrop"`: the whole video area, under the OSD, while there is no
-     *   video picture (see {@link Panels.backdrop}). One plugin at a time; it
+     *   video picture (see {@link Panels.backdrop}). One plugin at a time (as
+     *   for the bottom bar, another one's mount rejects with `conflict`); it
      *   takes no pointer or keyboard input. While it is mounted, the player does
      *   not show the cover art of audio files itself (from the next file
      *   opened on), so the plugin can draw it.
@@ -2560,7 +2771,12 @@ export interface PlayerState {
     readonly kind: "media" | "stream";
     /** The source's life cycle. */
     readonly phase: "empty" | "loading" | "ready" | "ended" | "error";
-    /** Path or URL. */
+    /**
+     * Path or URL; `null` when empty. A generated stream started with
+     * {@link Player.openStream} has the opaque `producer://<n>` (do not parse
+     * it); one a file resolver generates ({@link FileResolverOptions}) keeps
+     * the path that was opened. Tell streams apart by `kind`, not by `source`.
+     */
     readonly source: string | null;
     /** Playback is paused. */
     readonly paused: boolean;
@@ -2876,7 +3092,9 @@ export interface Player {
      *
      * It does not wait for playback: use {@link Media.ready}. `paused` opens
      * it paused; aborting `signal` closes it. URLs matching a registered
-     * {@link Resolver} are resolved first.
+     * {@link Resolver} are resolved first, and so are local files of an
+     * extension a file resolver claims (the source is then a stream that
+     * plugin generates; `paused` reaches it).
      */
     open(source: string, options?: {
         paused?: boolean;
@@ -3600,8 +3818,13 @@ export interface MediaCapture {
      */
     capture(options?: CaptureOptions): Promise<Snapshot>;
 }
-/** Declaration of {@link Resolvers.add}. */
-export interface ResolverOptions {
+/**
+ * Declaration of {@link Resolvers.add}: a web resolver
+ * ({@link WebResolverOptions}) or a file resolver ({@link FileResolverOptions}).
+ */
+export type ResolverOptions = WebResolverOptions | FileResolverOptions;
+/** A resolver for web pages: `https://host/…` to playable stream URLs. */
+export interface WebResolverOptions {
     /** Local id, unique within the plugin. */
     id: string;
     /** URL schemes handled. */
@@ -3611,14 +3834,104 @@ export interface ResolverOptions {
     /** Turn a page URL into playable stream URLs. */
     resolve(url: string, signal: AbortSignal): Promise<ResolvedMedia>;
 }
+/**
+ * A resolver for local files by extension (SDK 1.5.3, player 0.4.1): when
+ * anyone opens such a file with {@link Player.open} (the Open dialog, the
+ * playlist, next / previous, the recent list, a drop that calls `open`),
+ * the player asks this plugin for a stream it generates instead of
+ * playing the file. Needs `source.resolve` and `producer.av`.
+ *
+ * @remarks
+ * The open keeps everything of the original call: its `ifCurrent`, its
+ * operation (the opener's `open` and `media.ready()` settle as for any
+ * file), `paused` (the stream starts paused), and its path as
+ * `state.source`, with `state.kind` `"stream"`. A thrown error fails that
+ * open: `phase` `"error"` with the error's message as `state.error`,
+ * word for word. The stream belongs to this plugin, as with
+ * {@link Player.openStream}.
+ *
+ * Cancellation: `signal` aborts when the open is replaced, closed
+ * (`player.close()`, F4) or times out (30 seconds), or this resolver is
+ * disposed. Cancelled after `resolve` returned but before the stream ran,
+ * the SDK releases the stream and never calls `started`.
+ *
+ * One extension has one resolver: another plugin's resolver for it makes
+ * {@link Resolver.ready} reject with `conflict` without failing activation
+ * (the player shows a warning). When this plugin stops, its extensions are
+ * free again and such files go to the player as before.
+ *
+ * @example
+ * ```ts
+ * const { readFile } = await import("node:fs/promises");
+ * // The plugin's own emulator: one frame per call.
+ * const emulator = (rom: Uint8Array): (() => StreamFrame) => {
+ *   const video = new Uint8Array(256 * 240 * 4).fill(rom[0] ?? 0);
+ *   return () => ({ video, audio: new Float32Array(1600) });
+ * };
+ * plugin.resolvers.add({
+ *   id: "nes",
+ *   extensions: ["nes"],
+ *   async resolve(path, signal) {
+ *     const frame = emulator(await readFile(path, { signal }));
+ *     return {
+ *       kind: "stream",
+ *       width: 256,
+ *       height: 240,
+ *       frame,
+ *       started: (stream) => stream.onStop((error) => error && plugin.osd.show(error.message)),
+ *     };
+ *   },
+ * });
+ * ```
+ */
+export interface FileResolverOptions {
+    /** Local id, unique within the plugin. */
+    id: string;
+    /**
+     * Lower case, without the dot: 1–16 entries of 1–16 lower-case letters or
+     * digits (not `"folder"`). Only absolute local paths match, by their
+     * extension in any case (`/roms/Game.NES`); URLs never do.
+     */
+    extensions: string[];
+    /** Read the file and describe the stream to generate for it. */
+    resolve(path: string, signal: AbortSignal): Promise<ResolvedStream>;
+}
+/**
+ * What a file resolver returns: a stream, with the same frame contract as
+ * {@link StreamOptions} (size limits, `frame()` on the audio clock).
+ */
+export interface ResolvedStream {
+    /** Always `"stream"`. */
+    kind: "stream";
+    /** Frame width in pixels. */
+    width: number;
+    /** Frame height in pixels. */
+    height: number;
+    /** Produce the next frame. Never called concurrently or while paused. */
+    frame(): StreamFrame;
+    /**
+     * Called with the running stream once the player plays it, synchronously
+     * after activation and before any {@link Stream.onStop}. Not called when
+     * the open was cancelled first. `stream.stop()` closes the source (if
+     * still current); the plugin stopping stops it too.
+     */
+    started?(stream: Stream): void;
+}
 /** A registered resolver. Disposing it unregisters it and aborts resolutions in flight. */
 export interface Resolver extends Disposable {
-    /** Resolves when the player registered it; rejects (e.g. `conflict`) otherwise. */
+    /**
+     * Resolves when the player registered it; rejects otherwise: `conflict`
+     * when another resolver has the extension or the scheme + host (another
+     * plugin's: activation goes on; this plugin's own: activation fails),
+     * `invalid` for a malformed declaration (a player before 0.4.1 also for
+     * `extensions`).
+     */
     readonly ready: Promise<void>;
 }
 /**
- * `plugin.resolvers`: turn web page URLs into playable streams. Needs
- * `source.resolve`.
+ * `plugin.resolvers`: turn web page URLs into playable streams, or local
+ * files into streams this plugin generates. Needs `source.resolve` (file
+ * resolvers also `producer.av`).
  *
  * @example
  * ```ts
@@ -3635,9 +3948,11 @@ export interface Resolver extends Disposable {
  */
 export interface Resolvers {
     /**
-     * Register a resolver. When anyone opens a matching URL the player calls
-     * `resolve`; `signal` aborts when the open is cancelled or replaced. One
-     * scheme + host pair has one resolver (`conflict` otherwise).
+     * Register a resolver. When anyone opens a matching URL or file the
+     * player calls `resolve`; `signal` aborts when the open is cancelled or
+     * replaced. One scheme + host pair, and one extension, has one resolver
+     * (`conflict` otherwise). A rejected `resolve` fails the open with the
+     * error's message.
      */
     add(options: ResolverOptions): Resolver;
 }
@@ -3800,6 +4115,38 @@ export interface PluginInfo {
      * the player has none. The path's layout is not part of the API.
      */
     dataDirectory: string | null;
+    /**
+     * What a running plugin was refused because another plugin holds it: a
+     * panel position (`slot-occupied`, with `slot`) or the next/previous
+     * sequence (`sequence-taken`). Neither fails activation; `error` has the
+     * same as text. Empty from players before 0.4.x (after 0.4.0).
+     * Always set by the SDK; optional so that code building `PluginInfo`
+     * values itself (tests) keeps compiling.
+     *
+     * @since 1.5.2
+     */
+    warnings?: readonly PluginWarning[];
+}
+/**
+ * One refusal in {@link PluginInfo.warnings}.
+ *
+ * @since 1.5.2
+ */
+export interface PluginWarning {
+    /**
+     * `"slot-occupied"`, `"sequence-taken"` or `"resolver-taken"` (player
+     * 0.4.1); a newer player may add codes.
+     */
+    code: string;
+    /** The panel position (`"bottom"`, `"sidebar"`, `"backdrop"`) for `slot-occupied`. */
+    slot?: string;
+    /**
+     * What was taken, for `resolver-taken`: 「文件类型 .nes」 or the
+     * `scheme://host` of a web resolver.
+     */
+    target?: string;
+    /** The manifest id of the plugin holding it (absent for a full sidebar). */
+    owner?: string;
 }
 /**
  * `plugin.packages`: the plugins the player knows. `list` and `onChange`

package/dist/plugin/ui.js

@@ -323,6 +323,7 @@ export function exported(directory, file, kind) {
 }
 class PanelHandle extends ViewBase {
     ready;
+    #slot;
     #mounted = false;
     #locks = { focused: false, dragging: false, popupOpen: false };
     #interaction;
@@ -330,6 +331,7 @@ class PanelHandle extends ViewBase {
         if (scope.runtime.views.has("$mount"))
             throw new Error("a plugin can mount only one panel");
         super(scope);
+        this.#slot = slot;
         const runtime = scope.runtime;
         runtime.views.set("$mount", (callback, args) => this.dispatch(callback, args));
         this.#interaction = new Latest((locks) => runtime.host.ui.interaction(locks));
@@ -364,6 +366,51 @@ class PanelHandle extends ViewBase {
     write(property, value) {
         return this.scope.runtime.host.ui.setMount(property, value);
     }
+    get state() {
+        const service = layoutOf(this.scope.runtime);
+        service.start();
+        return this.live()
+            ? panelState(service.state, this.#slot, this.scope.runtime.manifest.id)
+            : null;
+    }
+    onChange(listener) {
+        const scope = this.scope;
+        let last = JSON.stringify(this.state);
+        const watch = layoutOf(scope.runtime).watch(() => {
+            const state = this.state;
+            const next = JSON.stringify(state);
+            if (next === last)
+                return;
+            last = next;
+            scope.run(listener, state);
+        });
+        return scope.add({
+            dispose: async () => {
+                scope.forget(watch);
+                await watch.dispose();
+            },
+        });
+    }
+    async show() {
+        await this.ready;
+        if (this.#slot === "backdrop")
+            throw failure("invalid", "the player shows the backdrop by itself");
+        await layoutOf(this.scope.runtime).set(this.#slot, {
+            active: this.scope.runtime.manifest.id,
+            visible: true,
+        });
+    }
+    async toggle() {
+        await this.ready;
+        if (this.#slot === "backdrop")
+            throw failure("invalid", "the player shows the backdrop by itself");
+        await layoutOf(this.scope.runtime).read();
+        const state = this.state;
+        if (state?.preferred && state.active)
+            await layoutOf(this.scope.runtime).set(this.#slot, { visible: false });
+        else
+            await this.show();
+    }
     async showMenu(items, at) {
         await this.ready;
         await this.scope.runtime.host.ui.menu(items.map((item) => item?.id ?? null), at.x, at.y);
@@ -388,8 +435,38 @@ class PanelHandle extends ViewBase {
         this.#mounted = false;
         await this.release();
         this.scope.runtime.views.delete("$mount");
+        // Listeners of `onChange` hear `null`.
+        this.scope.runtime.invalidate();
+        await layoutOf(this.scope.runtime).refresh();
     }
 }
+/** One panel's view of its position (`Panel.state`). */
+function panelState(layout, slot, plugin) {
+    if (slot === "backdrop")
+        return (layout.backdrop && {
+            active: true,
+            preferred: true,
+            effective: layout.backdrop.effective,
+            reason: null,
+            detached: false,
+        });
+    const state = layout[slot];
+    if (!state)
+        return null;
+    // Players without tabs (no `panels`): the position holds this panel only.
+    const panels = layout.tabs[slot];
+    const own = panels?.find((panel) => panel.plugin === plugin);
+    if (panels && !own)
+        return null;
+    const active = own?.active ?? true;
+    return {
+        active,
+        preferred: state.preferred,
+        effective: state.effective && active,
+        reason: active ? state.reason : "otherTab",
+        detached: state.detached,
+    };
+}
 export const windows = (scope) => ({
     create: (file, options) => new WindowHandle(scope, file, options?.id ?? basename(file, extname(file))),
 });
@@ -400,7 +477,12 @@ export const windows = (scope) => ({
  */
 class LayoutService {
     #runtime;
-    state = { bottom: null, sidebar: null, backdrop: null };
+    state = {
+        bottom: null,
+        sidebar: null,
+        tabs: { bottom: null, sidebar: null },
+        backdrop: null,
+    };
     #listeners = new Set();
     #started = false;
     #reading = false;
@@ -444,9 +526,17 @@ class LayoutService {
                     reason: slot.reason,
                     detached: slot.detached,
                 };
+                const tabs = (slot) => slot?.panels
+                    ? Object.freeze(slot.panels.map((panel) => Object.freeze({
+                        plugin: panel.plugin,
+                        title: panel.title,
+                        active: panel.owner === slot.owner,
+                    })))
+                    : null;
                 const next = {
                     bottom: view(raw.bottom),
                     sidebar: view(raw.sidebar),
+                    tabs: { bottom: tabs(raw.bottom), sidebar: tabs(raw.sidebar) },
                     backdrop: raw.backdrop
                         ? Object.freeze({ effective: raw.backdrop.effective === true })
                         : null,
@@ -477,10 +567,15 @@ function slot(scope, name) {
             service().start();
             return service().state[name];
         },
+        get panels() {
+            service().start();
+            return service().state.tabs[name];
+        },
         onChange(listener) {
-            let last = JSON.stringify(service().state[name]);
+            const seen = (layout) => JSON.stringify([layout[name], layout.tabs[name]]);
+            let last = seen(service().state);
             const watch = service().watch((layout) => {
-                const next = JSON.stringify(layout[name]);
+                const next = seen(layout);
                 if (next === last)
                     return;
                 last = next;
@@ -500,6 +595,7 @@ function slot(scope, name) {
             await service().set(name, { visible: !(current?.preferred ?? true) });
         },
         setDetached: (detached) => service().set(name, { detached }),
+        activate: (plugin) => service().set(name, { active: plugin }),
     };
 }
 function backdrop(scope) {