gloomberb 0.16.3 → 0.16.4

package/src/plugins/catalog-manifest.ts

@@ -1,5 +1,10 @@
+import type { FunctionAccess } from "../cli/pane-functions/function-help";
+import type { GloomPlugin, PluginTarget } from "../types/plugin";
 import { ABSORBED_PLUGINS } from "./absorbed";
+import { highlightedCodes, pluginFunctions } from "./plugin-functions";
+import { BUILTIN_EDITORIAL } from "./builtin-editorial";
 import { getPluginCatalog } from "./catalog";
+import { browserBuiltinPlugins } from "./catalog-browser";
 
 /**
  * The public description of the plugins that ship inside Gloomberb.
@@ -8,71 +13,80 @@ import { getPluginCatalog } from "./catalog";
  * built-in has no repository to read metadata from. Hand-maintaining that half
  * elsewhere meant it silently drifted every time a built-in changed its panes
  * or description, so it is derived from the live catalog here instead and
- * checked against a committed snapshot in CI.
+ * checked against a committed snapshot in CI. Editorial copy the catalog does
+ * not carry lives in `builtin-editorial.ts`.
+ *
+ * Fields added since the first version are optional for the directory, which
+ * keeps reading a manifest without them.
  */
 
+/** A function the plugin adds, as the directory lists it. */
+interface BuiltinShortcutManifestEntry {
+  code: string;
+  name: string;
+  description: string;
+  /** Free gets only the upgrade (`pro`) or a preview (`preview`); absent when Free gets it all. */
+  access?: FunctionAccess;
+  /** Where it runs, when that is narrower than the plugin: a code the web app lacks. */
+  targets?: PluginTarget[];
+}
+
 interface BuiltinPluginManifestEntry {
   id: string;
   name: string;
   description: string;
+  /** Ten words at most, for a card. */
+  tagline?: string;
   /** Curated, since the catalog has no notion of categories. */
   categories: string[];
   toggleable: boolean;
   featured?: true;
   /** Path to artwork in this repo, resolved by the directory against HEAD. */
   icon?: string;
+  /** Everywhere the app runs, and the web when the browser catalog carries it. */
+  targets: PluginTarget[];
   contributes: {
     panes: string[];
     capabilities: string[];
     broker: boolean;
+    shortcuts?: BuiltinShortcutManifestEntry[];
   };
+  /** The codes a card shows. */
+  highlights?: string[];
+  /** Codes whose reviewed capture the directory shows, best first. */
+  screenshots?: string[];
 }
 
-/**
- * Editorial metadata the runtime catalog does not carry. Anything missing here
- * is reported by `generate-plugin-manifest.ts` rather than silently defaulted,
- * so a new built-in cannot slip into the directory uncategorised.
- */
-const EDITORIAL: Record<
-  string,
-  { categories: string[]; featured?: true; icon?: string }
-> = {
-  "gloomberb-cloud": {
-    categories: ["data", "cloud"],
-    featured: true,
-    icon: "plugin-icons/gloomberb-cloud.webp",
-  },
-  alerts: { categories: ["alerts"] },
-  application: { categories: ["core"] },
-  broker: { categories: ["broker"] },
-  "clinical-trials": { categories: ["research"] },
-  "comment-letters": { categories: ["research"] },
-  "custom-view": { categories: ["data", "productivity"] },
-  debug: { categories: ["developer"] },
-  "fear-greed": { categories: ["markets", "sentiment"], icon: "plugin-icons/fear-greed.webp" },
-  members: { categories: ["markets", "research"] },
-  "ipo-calendar": { categories: ["macro", "markets"], icon: "plugin-icons/ipo-calendar.webp" },
-  macro: { categories: ["macro"] },
-  "market-halts": { categories: ["markets"], icon: "plugin-icons/market-halts.webp" },
-  "market-heatmap": { categories: ["markets"], icon: "plugin-icons/market-heatmap.webp" },
-  "market-overview": { categories: ["markets"] },
-  news: { categories: ["news"] },
-  notes: { categories: ["productivity"] },
-  openfda: { categories: ["research"] },
-  portfolio: { categories: ["portfolio"] },
-  "research-search": { categories: ["research", "news"] },
-  "ticker-research": { categories: ["research"] },
-};
-
 export interface BuiltinManifest {
   version: 1;
   plugins: BuiltinPluginManifestEntry[];
   /** Built-in ids with no editorial entry; a non-empty list fails generation. */
   uncategorised: string[];
+  /** Editorial highlights or screenshots naming a code the plugin lacks, as `id:CODE`; these fail generation too. */
+  unknownCodes: string[];
+}
+
+const NATIVE_TARGETS: PluginTarget[] = ["cli", "tui", "desktop"];
+
+/**
+ * The codes a plugin's pane templates answer to. Commands a plugin registers
+ * while it sets up (ALRT, NOTE) are not known until it runs, so they are not
+ * listed; the Plugins pane reads them from the running app.
+ */
+function functionsOf(plugin: GloomPlugin) {
+  return pluginFunctions({
+    templates: (plugin.paneTemplates ?? []).map((template) => ({
+      label: template.label,
+      prefix: template.shortcut?.prefix,
+      description: template.description,
+    })),
+  });
 }
 
 export function buildBuiltinManifest(): BuiltinManifest {
   const uncategorised: string[] = [];
+  const unknownCodes: string[] = [];
+  const web = new Map(browserBuiltinPlugins.map((plugin) => [plugin.id, plugin]));
 
   const plugins = getPluginCatalog()
     // Built in again, but released apps from before that still install these
@@ -80,18 +94,34 @@ export function buildBuiltinManifest(): BuiltinManifest {
     // id a built-in claims. This build shows that row as its built-in, so they
     // join the manifest once those releases have updated.
     .filter(({ plugin }) => !ABSORBED_PLUGINS.some((absorbed) => absorbed.id === plugin.id))
-    .map(({ plugin }) => {
-      const editorial = EDITORIAL[plugin.id];
+    .map(({ plugin }): BuiltinPluginManifestEntry => {
+      const editorial = BUILTIN_EDITORIAL[plugin.id];
       if (!editorial) uncategorised.push(plugin.id);
 
+      // Some built-ins carry fewer functions in the web app.
+      const webPlugin = web.get(plugin.id);
+      const webCodes = new Set(webPlugin ? functionsOf(webPlugin).map((fn) => fn.code) : []);
+      const functions = functionsOf(plugin);
+      const shortcuts = functions.map((fn): BuiltinShortcutManifestEntry => ({
+        ...fn,
+        ...(webPlugin && !webCodes.has(fn.code) ? { targets: [...NATIVE_TARGETS] } : {}),
+      }));
+      const codes = new Set(functions.map((fn) => fn.code));
+      for (const code of [...editorial?.highlights ?? [], ...editorial?.screenshots ?? []]) {
+        if (!codes.has(code)) unknownCodes.push(`${plugin.id}:${code}`);
+      }
+      const screenshots = (editorial?.screenshots ?? []).filter((code) => codes.has(code));
+
       return {
         id: plugin.id,
         name: plugin.name,
         description: plugin.description ?? "",
+        ...(editorial?.tagline ? { tagline: editorial.tagline } : {}),
         categories: editorial?.categories ?? [],
         toggleable: plugin.toggleable === true,
         ...(editorial?.featured ? { featured: true as const } : {}),
         ...(editorial?.icon ? { icon: editorial.icon } : {}),
+        targets: webPlugin ? [...NATIVE_TARGETS, "web"] : [...NATIVE_TARGETS],
         contributes: {
           panes: (plugin.panes ?? []).map((pane) => pane.id).sort(),
           capabilities: (plugin.capabilities ?? [])
@@ -101,10 +131,13 @@ export function buildBuiltinManifest(): BuiltinManifest {
             })
             .sort(),
           broker: !!plugin.broker,
+          ...(shortcuts.length > 0 ? { shortcuts } : {}),
         },
+        ...(functions.length > 0 ? { highlights: highlightedCodes(plugin.id, functions) } : {}),
+        ...(screenshots.length > 0 ? { screenshots } : {}),
       };
     })
     .sort((left, right) => left.id.localeCompare(right.id));
 
-  return { version: 1, plugins, uncategorised: uncategorised.sort() };
+  return { version: 1, plugins, uncategorised: uncategorised.sort(), unknownCodes };
 }

package/src/plugins/catalog-ui.ts

@@ -15,24 +15,42 @@ import { clinicalTrialsPlugin } from "./builtin/clinical-trials";
 import { commentLettersPlugin } from "./builtin/comment-letters";
 import { openFdaPlugin } from "./builtin/openfda";
 import {
+  altDataPlugin,
   applicationPlugin,
   brokerPlugin,
-  macroPlugin,
-  marketOverviewPlugin,
+  creditPlugin,
+  cryptoPlugin,
+  earningsPlugin,
+  filingsPlugin,
+  futuresCommoditiesPlugin,
+  globalMarketsPlugin,
+  optionsVolatilityPlugin,
+  ownershipPlugin,
   portfolioPlugin,
-  tickerResearchPlugin,
+  quantPlugin,
+  ratesMacroPlugin,
+  screenersPlugin,
+  tickerCorePlugin,
 } from "./builtin/composite-plugins";
 
 export const uiBuiltinPlugins: GloomPlugin[] = [
   gloomberbCloudPlugin,
   portfolioPlugin,
-  tickerResearchPlugin,
+  tickerCorePlugin,
+  optionsVolatilityPlugin,
+  ownershipPlugin,
+  filingsPlugin,
   brokerPlugin,
   applicationPlugin,
   newsPlugin,
   notesPlugin,
   customViewPlugin,
-  marketOverviewPlugin,
+  globalMarketsPlugin,
+  screenersPlugin,
+  futuresCommoditiesPlugin,
+  cryptoPlugin,
+  altDataPlugin,
+  quantPlugin,
   marketHeatmapPlugin,
   marketHaltsPlugin,
   fearGreedPlugin,
@@ -41,7 +59,9 @@ export const uiBuiltinPlugins: GloomPlugin[] = [
   clinicalTrialsPlugin,
   commentLettersPlugin,
   openFdaPlugin,
-  macroPlugin,
+  ratesMacroPlugin,
+  creditPlugin,
+  earningsPlugin,
   alertsPlugin,
   researchSearchPlugin,
 ];

package/src/plugins/extracted-plugins.ts

@@ -4,6 +4,7 @@ import { join } from "path";
 import type { AppConfig } from "../types/config";
 import { debugLog } from "../utils/debug-log";
 import { getPluginsDir } from "./loader";
+import { encodeBuiltinDisabledPluginIds } from "./ownership";
 import { pluginDirectoryNames } from "./plugin-names";
 
 const log = debugLog.createLogger("plugin-seed");
@@ -63,7 +64,12 @@ export async function seedExtractedPlugins(
   pluginsDir: string = getPluginsDir(),
 ): Promise<SeedResult> {
   const alreadySeeded = new Set(config.seededPlugins ?? []);
-  const disabled = new Set(config.disabledPlugins ?? []);
+  // A previous owner that is now a group of built-ins counts as off only while
+  // all of them are, which is when its id is saved.
+  const disabled = new Set([
+    ...config.disabledPlugins ?? [],
+    ...encodeBuiltinDisabledPluginIds(config.disabledPlugins ?? []),
+  ]);
 
   const result: SeedResult = { installed: [], failed: [], seeded: [...alreadySeeded] };
 

package/src/plugins/ownership.ts

@@ -1,9 +1,12 @@
 /**
- * Built-in module ids and the built-in plugin that owns each one. Every key
- * does two jobs: config, sync and session state saved under it is rewritten to
- * the owner, and it is reserved, because an external plugin using it would
- * have its state merged into the owner the same way. A module that moves out
- * to an external plugin leaves this map so that plugin can claim its id.
+ * Built-in module ids and the state namespace each one's state lives in now.
+ * Every key does two jobs: config, sync and session state saved under it is
+ * rewritten to that namespace, and it is reserved, because an external plugin
+ * using it would have its state merged in the same way. A module that moves
+ * out to an external plugin leaves this map so that plugin can claim its id.
+ *
+ * A switched-off module id in `disabledPlugins` follows this map too, unless
+ * BUILTIN_DISABLED_PLUGIN_ALIASES sends it somewhere else.
  */
 const BUILTIN_PLUGIN_OWNER_ALIASES: Record<string, string> = {
   analytics: "portfolio",
@@ -42,6 +45,90 @@ const BUILTIN_PLUGIN_OWNER_ALIASES: Record<string, string> = {
   "world-indices": "market-overview",
 };
 
+/**
+ * Retired ids in `disabledPlugins` whose plugin is not the namespace their
+ * state moved to: once a plugin is split, a module's state stays where it was
+ * while its switch belongs to the successor that holds the module now.
+ */
+const BUILTIN_DISABLED_PLUGIN_ALIASES: Record<string, string> = {
+  "chart-composer": "ticker-core",
+  "company-research": "ticker-core",
+  "comparison-chart": "ticker-core",
+  correlation: "quant",
+  "crypto-board": "crypto",
+  "dividend-yield": "ticker-core",
+  "earnings-calendar": "earnings",
+  "earnings-calls": "earnings",
+  executives: "ticker-core",
+  "filing-events": "filings",
+  "fx-matrix": "global-markets",
+  holders: "ownership",
+  insider: "ownership",
+  jobs: "alt-data",
+  "market-movers": "screeners",
+  options: "options-volatility",
+  research: "ticker-core",
+  "risk-factors": "filings",
+  sec: "filings",
+  sectors: "global-markets",
+  "short-interest": "ownership",
+  "short-volume": "ownership",
+  "social-mentions": "alt-data",
+  thirteenf: "ownership",
+  "ticker-detail": "ticker-core",
+  "world-indices": "global-markets",
+  // `macro-tv` keeps meaning all of Macro: TV left for its own repository, so
+  // no successor holds it, and turning it off was turning Macro off.
+};
+
+/**
+ * Retired built-in plugin ids that now stand for a group of built-ins in
+ * `disabledPlugins`, reserved for good. Turning the old plugin off, here or in
+ * an older app through sync, turns off every successor holding one of its
+ * modules; the old id is written back only while all of them are off, so an
+ * older app shows it off exactly then, and turning it back on there brings
+ * them all back.
+ */
+const BUILTIN_PLUGIN_GROUPS: Readonly<Record<string, readonly string[]>> = {
+  macro: ["rates-macro", "credit", "earnings"],
+  "market-overview": ["global-markets", "screeners", "futures-commodities", "crypto", "alt-data", "quant"],
+  // Shares Credit & Bonds and Earnings with Macro, and Alt Data and Quant with
+  // Market Overview: each holds modules from both.
+  "ticker-research": ["ticker-core", "options-volatility", "ownership", "filings", "alt-data", "quant", "credit", "earnings"],
+};
+
+/** Every built-in that came out of a retired group: the plugins starter packs switch. */
+export function regroupedBuiltinPluginIds(): string[] {
+  return [...new Set(Object.values(BUILTIN_PLUGIN_GROUPS).flat())];
+}
+
+/** The built-ins a retired group id stands for, or null when the id is not a group. */
+export function builtinPluginGroupMembers(pluginId: string): readonly string[] | null {
+  return Object.prototype.hasOwnProperty.call(BUILTIN_PLUGIN_GROUPS, pluginId) ? BUILTIN_PLUGIN_GROUPS[pluginId]! : null;
+}
+
+/**
+ * `disabledPlugins` after switching plugins on or off in one go, or null when
+ * nothing changes. A retired group id switches every member, the way
+ * `gloomberb plugin enable|disable` does. Changes apply in order, so a later
+ * one wins for a plugin two groups share.
+ */
+export function applyPluginToggles(
+  disabledPlugins: readonly string[],
+  changes: Readonly<Record<string, boolean>>,
+): string[] | null {
+  let next = [...disabledPlugins];
+  for (const [pluginId, enabled] of Object.entries(changes)) {
+    for (const memberId of builtinPluginGroupMembers(pluginId) ?? [pluginId]) {
+      if (enabled) next = next.filter((entry) => entry !== memberId);
+      else if (!next.includes(memberId)) next.push(memberId);
+    }
+  }
+  const unchanged = next.length === disabledPlugins.length
+    && next.every((pluginId, index) => pluginId === disabledPlugins[index]);
+  return unchanged ? null : next;
+}
+
 /** The one built-in that cannot be disabled; its legacy module ids normalize to it. */
 const NON_TOGGLEABLE_BUILTIN_PLUGIN_ID = "application";
 
@@ -54,18 +141,74 @@ function normalizeBuiltinPluginOwnerId(pluginId: string): string {
   return BUILTIN_PLUGIN_OWNER_ALIASES[pluginId] ?? pluginId;
 }
 
+/** Every retired built-in module id, for checks that each still lands on the right plugin. */
+export function retiredBuiltinModuleIds(): string[] {
+  return Object.keys(BUILTIN_PLUGIN_OWNER_ALIASES);
+}
+
 export function isReservedBuiltinPluginId(pluginId: string): boolean {
-  return Object.prototype.hasOwnProperty.call(BUILTIN_PLUGIN_OWNER_ALIASES, pluginId);
+  return Object.prototype.hasOwnProperty.call(BUILTIN_PLUGIN_OWNER_ALIASES, pluginId)
+    || builtinPluginGroupMembers(pluginId) !== null;
+}
+
+function normalizeBuiltinDisabledPluginId(pluginId: string): string {
+  return BUILTIN_DISABLED_PLUGIN_ALIASES[pluginId] ?? normalizeBuiltinPluginOwnerId(pluginId);
 }
 
+/**
+ * Rewrites retired module ids to the plugin that holds the module now. Group
+ * ids are left as they are: the configuration migrations after this one read
+ * them before `expandBuiltinPluginGroups` runs.
+ */
 export function normalizeBuiltinDisabledPluginIds(pluginIds: readonly string[]): string[] {
   return [...new Set(
     pluginIds
-      .map(normalizeBuiltinPluginOwnerId)
+      .map(normalizeBuiltinDisabledPluginId)
       .filter((pluginId) => pluginId !== NON_TOGGLEABLE_BUILTIN_PLUGIN_ID),
   )];
 }
 
+/**
+ * `disabledPlugins` as saved, in the ids the registry knows: a retired group
+ * id becomes every member. Applied on every load, after the migrations; it
+ * only ever adds switched-off plugins, and running it twice changes nothing.
+ */
+export function expandBuiltinPluginGroups(pluginIds: readonly string[]): string[] {
+  return [...new Set(pluginIds.flatMap((pluginId) => builtinPluginGroupMembers(pluginId) ?? [pluginId]))];
+}
+
+/**
+ * `disabledPlugins` as pulled. Another device may run an app from before
+ * modules were merged or plugins split, so retired module ids are rewritten
+ * as the migrations would, then groups expanded.
+ */
+export function decodeBuiltinDisabledPluginIds(pluginIds: readonly string[]): string[] {
+  return expandBuiltinPluginGroups(normalizeBuiltinDisabledPluginIds(pluginIds));
+}
+
+/**
+ * `disabledPlugins` as written to disk and pushed: a group whose members are
+ * all off is written as its retired id alone, where its first member stood,
+ * and a group partly off as the members that are. Expanding the result gives
+ * the list back.
+ */
+export function encodeBuiltinDisabledPluginIds(pluginIds: readonly string[]): string[] {
+  const disabled = new Set(pluginIds);
+  const fullyOff = Object.entries(BUILTIN_PLUGIN_GROUPS)
+    .filter(([, members]) => members.length > 0 && members.every((member) => disabled.has(member)));
+  if (fullyOff.length === 0) return [...disabled];
+  const groupAt = new Map<string, string[]>();
+  for (const [groupId, members] of fullyOff) {
+    const first = pluginIds.find((pluginId) => members.includes(pluginId))!;
+    groupAt.set(first, [...(groupAt.get(first) ?? []), groupId]);
+  }
+  const covered = new Set(fullyOff.flatMap(([, members]) => members));
+  return [...new Set(pluginIds.flatMap((pluginId) => [
+    ...(groupAt.get(pluginId) ?? []),
+    ...(covered.has(pluginId) ? [] : [pluginId]),
+  ]))];
+}
+
 export function normalizeBuiltinPluginStateMap(
   value: Record<string, Record<string, unknown>>,
 ): Record<string, Record<string, unknown>> {

package/src/plugins/plugin-functions.ts

@@ -0,0 +1,54 @@
+import { FUNCTION_HELP, type FunctionAccess } from "../cli/pane-functions/function-help";
+import { commands as coreCommands, getCommandPrefixes } from "../components/command-bar/commands/registry";
+import { BUILTIN_EDITORIAL } from "./builtin-editorial";
+
+/** A command-bar function a plugin adds, as the Plugins pane and gloom.sh list it. */
+export interface PluginFunction {
+  code: string;
+  name: string;
+  description: string;
+  access?: FunctionAccess;
+}
+
+interface FunctionSources {
+  templates: ReadonlyArray<{ label: string; prefix?: string; description?: string }>;
+  commands?: ReadonlyArray<{ label: string; shortcut?: string; description?: string }>;
+}
+
+/** The core command an alias belongs to: the research pane's T is DES. */
+const CORE_PRIMARY = new Map(coreCommands.flatMap((command) => {
+  const [primary, ...aliases] = getCommandPrefixes(command);
+  return primary ? aliases.map((alias) => [alias, primary] as const) : [];
+}));
+
+/**
+ * The functions a plugin answers to, once each, in the order it registered
+ * them: its pane templates, then its commands. A code that is an alias of a
+ * core command is listed under the code people type.
+ */
+export function pluginFunctions({ templates, commands = [] }: FunctionSources): PluginFunction[] {
+  const byCode = new Map<string, PluginFunction>();
+  const add = (rawCode: string | undefined, name: string, description = "") => {
+    const typed = rawCode?.trim().toUpperCase();
+    if (!typed) return;
+    const code = CORE_PRIMARY.get(typed) ?? typed;
+    if (byCode.has(code)) return;
+    const access = FUNCTION_HELP[code]?.access;
+    byCode.set(code, { code, name, description, ...(access ? { access } : {}) });
+  };
+  for (const template of templates) add(template.prefix, template.label, template.description);
+  for (const command of commands) add(command.shortcut, command.label, command.description);
+  return [...byCode.values()];
+}
+
+/** Functions Free cannot fully open: Pro only, or a preview on Free. */
+export function proFunctionCount(functions: readonly PluginFunction[]): number {
+  return functions.filter((fn) => fn.access).length;
+}
+
+/** The codes a row shows: the editorial pick when it names real codes, else the first three. */
+export function highlightedCodes(pluginId: string, functions: readonly PluginFunction[]): string[] {
+  const codes = functions.map((fn) => fn.code);
+  const picked = (BUILTIN_EDITORIAL[pluginId]?.highlights ?? []).filter((code) => codes.includes(code));
+  return (picked.length > 0 ? picked : codes).slice(0, 3);
+}

package/src/plugins/plugin-off.ts

@@ -0,0 +1,36 @@
+import type { AppNotificationRequest } from "../types/plugin";
+import type { DisabledPluginOwner } from "./registry";
+
+/**
+ * Opening something whose plugin is switched off. A pane added for it would
+ * stay hidden, so the open is refused and the user is offered the switch.
+ */
+export class PluginOffError extends Error {
+  constructor(readonly plugin: DisabledPluginOwner, what: string) {
+    super(`Turn on ${plugin.name} to open ${what}.`);
+    this.name = "PluginOffError";
+  }
+}
+
+interface PluginOffNotifier {
+  notify(notification: AppNotificationRequest): unknown;
+  setPluginEnabled(pluginId: string, enabled: boolean): void;
+}
+
+/**
+ * Says which plugin to turn on, with a button that turns it on and, when
+ * given, opens what was asked for.
+ */
+export function notifyPluginOff(host: PluginOffNotifier, error: PluginOffError, reopen?: () => void): void {
+  host.notify({
+    body: error.message,
+    type: "info",
+    action: {
+      label: "Turn on",
+      onClick: () => {
+        host.setPluginEnabled(error.plugin.id, true);
+        reopen?.();
+      },
+    },
+  });
+}

package/src/plugins/registry/host-actions.ts

@@ -45,6 +45,10 @@ export interface PluginHostActions {
   openWindowMode(paneId?: string, mode?: WindowEditMode): void;
   /** The shell's fullscreen toggle for a pane; false when there is nothing to fill the window with. */
   togglePaneFullscreen(paneId: string): boolean;
+  /** The shell's Move to New Layout for a pane; false when it did nothing. Not on the plugin API. */
+  movePaneToNewLayout(paneId: string): boolean;
+  /** Returns a pane Move to New Layout moved to where it came from; false when it did nothing. Not on the plugin API. */
+  movePaneBack(paneId: string): boolean;
   showPane(paneId: string): void;
   createPaneFromTemplate(templateId: string, options?: PaneTemplateCreateOptions): void;
   createPaneFromTemplateAsync(templateId: string, options?: PaneTemplateCreateOptions): Promise<void>;
@@ -62,6 +66,14 @@ export interface PluginHostActions {
   watchNewsQuery(query: NewsQuery, listener: (state: NewsQueryState) => void): () => void;
 
   notify(notification: AppNotificationRequest): AppNotificationDelivery | void;
+  /** Switches a plugin on or off the way the Plugins pane does. Not on the plugin API. */
+  setPluginEnabled(pluginId: string, enabled: boolean): void;
+  /**
+   * Switches several plugins on or off as one change: one config write and
+   * one save. A switched-off plugin's panes are hidden, never removed, so
+   * switching it back on shows them where they were. Not on the plugin API.
+   */
+  setPluginsEnabled(changes: Readonly<Record<string, boolean>>): void;
   getPaneRuntimeState(paneId: string): PaneRuntimeState | null;
   updatePaneRuntimeState(paneId: string, patch: Partial<PaneRuntimeState>): void;
   applyPaneSettingValue(paneId: string, field: PaneSettingField, value: unknown): Promise<void>;
@@ -95,6 +107,8 @@ export function createDefaultHostActions(current?: () => Pick<PluginHostActions,
     sharePane: () => {},
     openWindowMode: () => {},
     togglePaneFullscreen: () => false,
+    movePaneToNewLayout: () => false,
+    movePaneBack: () => false,
     showPane: () => {},
     createPaneFromTemplate: () => {},
     createPaneFromTemplateAsync: async () => {},
@@ -109,6 +123,8 @@ export function createDefaultHostActions(current?: () => Pick<PluginHostActions,
     registerNewsCapability: () => () => {},
     watchNewsQuery: () => () => {},
     notify: () => {},
+    setPluginEnabled: () => {},
+    setPluginsEnabled: () => {},
     getPaneRuntimeState: () => null,
     updatePaneRuntimeState: () => {},
     applyPaneSettingValue: async () => {},