gloomberb 0.16.2 → 0.16.4

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 () => {},

package/src/plugins/registry/index.ts

@@ -54,7 +54,13 @@ import {
   type ResolvedRegistryPaneQuickSetting,
   type ResolvedRegistryPaneSettings,
 } from "./pane-settings";
-import { RegistryResumeStateListeners, createPluginPaneSettingsState, createPluginResumeState } from "./plugin-state";
+import {
+  RegistryResumeStateListeners,
+  bindPluginContextNamespaces,
+  createPluginPaneSettingsState,
+  createPluginResumeState,
+  type NamespacedPluginContext,
+} from "./plugin-state";
 import { createPluginSetupCommand, isPluginConfigured } from "./setup-command";
 import {
   bindSharedRegistry,
@@ -76,6 +82,12 @@ interface PluginRegistryOptions {
 }
 
 export type { WindowEditMode } from "./host-actions";
+
+/** A switched-off plugin, named for a "Turn on" offer. */
+export interface DisabledPluginOwner {
+  id: string;
+  name: string;
+}
 export {
   getSharedMarketData,
   getSharedRegistry,
@@ -167,6 +179,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
     bindSharedRegistry(this, marketData);
     this.capabilities = new CapabilityRegistry({
       isPluginEnabled: (pluginId) => !this.getConfig().disabledPlugins.includes(pluginId),
+      pluginName: (pluginId) => this.plugins.get(pluginId)?.name,
       isCapabilityEnabled: (capability, pluginId) => {
         const disabledSources = this.getConfig().disabledSources ?? [];
         return !disabledSources.includes(capability.sourceId ?? capability.id) && !this.getConfig().disabledPlugins.includes(pluginId);
@@ -407,6 +420,41 @@ export class PluginRegistry implements PluginRuntimeAccess {
     return this.contributions.paneTemplatesMap.owners.get(templateId);
   }
 
+  /**
+   * The plugin that owns this pane type when it is switched off. A pane of a
+   * switched-off plugin stays hidden, so callers offer to turn it on instead
+   * of adding one.
+   */
+  getDisabledPaneOwner(
+    paneType: string,
+    disabledPlugins: readonly string[] = this.getConfig().disabledPlugins,
+  ): DisabledPluginOwner | null {
+    return this.disabledOwner(this.getPanePluginId(paneType), disabledPlugins);
+  }
+
+  /** The same for a template: its own plugin, or the one owning the pane it opens. */
+  getDisabledPaneTemplateOwner(
+    templateId: string,
+    disabledPlugins: readonly string[] = this.getConfig().disabledPlugins,
+  ): DisabledPluginOwner | null {
+    const paneType = this.paneTemplates.get(templateId)?.paneId;
+    return this.disabledOwner(this.getPaneTemplatePluginId(templateId), disabledPlugins)
+      ?? (paneType ? this.getDisabledPaneOwner(paneType, disabledPlugins) : null);
+  }
+
+  /** The plugin behind a research tab when it is switched off, which hides the tab. */
+  getDisabledTickerResearchTabOwner(
+    tabId: string,
+    disabledPlugins: readonly string[] = this.getConfig().disabledPlugins,
+  ): DisabledPluginOwner | null {
+    return this.disabledOwner(this.getTickerResearchTabPluginId(tabId), disabledPlugins);
+  }
+
+  private disabledOwner(pluginId: string | undefined, disabledPlugins: readonly string[]): DisabledPluginOwner | null {
+    if (!pluginId || !disabledPlugins.includes(pluginId)) return null;
+    return { id: pluginId, name: this.plugins.get(pluginId)?.name ?? pluginId };
+  }
+
   getBrokerPluginId(brokerType: string): string | undefined {
     return this.contributions.brokersMap.owners.get(brokerType);
   }
@@ -429,10 +477,42 @@ export class PluginRegistry implements PluginRuntimeAccess {
     }
   }
 
+  /**
+   * The state parts of a plugin's context. `namespaceKey` is the plugin's id,
+   * or the namespace a composed module keeps; both resolve the way a render
+   * context's id does.
+   */
+  private createNamespacedContext(namespaceKey: string): NamespacedPluginContext {
+    const stateId = this.stateNamespace(namespaceKey);
+    return {
+      persistence: createPluginPersistence(
+        this.persistence.pluginState,
+        this.persistence.resources,
+        `plugin:${stateId}`,
+        stateId,
+      ),
+      resume: createPluginResumeState({
+        pluginId: stateId,
+        getResumeState: (key, version) => this.getResumeState(namespaceKey, key, version),
+        setResumeState: (key, value, version) => this.setResumeState(namespaceKey, key, value, version),
+        deleteResumeState: (key) => this.deleteResumeState(namespaceKey, key),
+        getPaneRuntimeState: (paneId) => this.getPaneRuntimeState(paneId),
+        updatePaneRuntimeState: (paneId, patch) => this.updatePaneRuntimeState(paneId, patch),
+      }),
+      teamState: createPluginTeamState(stateId),
+      configState: {
+        get: (key) => this.getConfigState(namespaceKey, key),
+        set: (key, value) => this.setConfigState(namespaceKey, key, value),
+        delete: (key) => this.deleteConfigState(namespaceKey, key),
+        keys: () => this.getConfigStateKeys(namespaceKey),
+      },
+    };
+  }
+
   private createContext(pluginId: string): GloomPluginContext {
     const contributions = this.contributions;
     const items = contributions.getOrCreatePluginItems(pluginId);
-    return {
+    return bindPluginContextNamespaces({
       registerPane: (pane) => contributions.registerPane(pluginId, pane),
       registerPaneTemplate: (template) => contributions.registerPaneTemplate(pluginId, template, true),
       registerCommand: (command) => contributions.registerCommand(pluginId, command),
@@ -468,33 +548,13 @@ export class PluginRegistry implements PluginRuntimeAccess {
       marketData: this.marketData,
       connectionHealth: this.connectionHealth,
       tickerRepository: this.tickerRepository,
-      persistence: createPluginPersistence(
-        this.persistence.pluginState,
-        this.persistence.resources,
-        `plugin:${this.stateNamespace(pluginId)}`,
-        this.stateNamespace(pluginId),
-      ),
+      ...this.createNamespacedContext(pluginId),
       log: debugLog.createLogger(pluginId),
-      resume: createPluginResumeState({
-        pluginId: this.stateNamespace(pluginId),
-        getResumeState: (key, version) => this.getResumeState(pluginId, key, version),
-        setResumeState: (key, value, version) => this.setResumeState(pluginId, key, value, version),
-        deleteResumeState: (key) => this.deleteResumeState(pluginId, key),
-        getPaneRuntimeState: (paneId) => this.getPaneRuntimeState(paneId),
-        updatePaneRuntimeState: (paneId, patch) => this.updatePaneRuntimeState(paneId, patch),
-      }),
-      teamState: createPluginTeamState(this.stateNamespace(pluginId)),
       paneSettings: createPluginPaneSettingsState({
         getLayout: () => this.getLayout(),
         updateLayout: (layout) => this.updateLayout(layout),
         resolvePaneTarget: (paneId) => this.resolvePaneTarget(paneId),
       }),
-      configState: {
-        get: (key) => this.getConfigState(pluginId, key),
-        set: (key, value) => this.setConfigState(pluginId, key, value),
-        delete: (key) => this.deleteConfigState(pluginId, key),
-        keys: () => this.getConfigStateKeys(pluginId),
-      },
       createBrokerInstance: (brokerType, label, values) => this.createBrokerInstance(brokerType, label, values),
       updateBrokerInstance: this.updateBrokerInstance,
       syncBrokerInstance: this.syncBrokerInstance,
@@ -519,7 +579,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
       // Every plugin event is also a host event; TypeScript cannot see that through the generic key.
       emit: (event, payload) => this.events.emit(event, payload as HostEvents[typeof event]),
       notify: (notification) => this.notify(notification),
-    };
+    }, (stateId) => this.createNamespacedContext(stateId));
   }
 
   private registryLog = debugLog.createLogger("registry");

package/src/plugins/registry/plugin-state.ts

@@ -1,7 +1,7 @@
 import type { PaneRuntimeState } from "../../core/state/app/state";
 import { deletePaneSetting, setPaneSetting } from "../../pane-settings";
 import type { LayoutConfig } from "../../types/config";
-import type { PluginPaneSettingsState, PluginResumeState } from "../../types/plugin";
+import type { GloomPluginContext, PluginPaneSettingsState, PluginResumeState } from "../../types/plugin";
 import { deletePluginPaneStateValue, setPluginPaneStateValue } from "../../layout/pane-state";
 
 export class RegistryResumeStateListeners {
@@ -35,6 +35,30 @@ export class RegistryResumeStateListeners {
   }
 }
 
+/** The parts of a plugin context that read and write under its state namespace. */
+export type NamespacedPluginContext = Pick<GloomPluginContext, "persistence" | "resume" | "configState" | "teamState">;
+
+const namespacedContexts = new WeakMap<GloomPluginContext, (stateId: string) => NamespacedPluginContext>();
+
+/** Lets `pluginContextInNamespace` rebuild this context's state parts for another namespace. */
+export function bindPluginContextNamespaces(
+  context: GloomPluginContext,
+  createNamespaced: (stateId: string) => NamespacedPluginContext,
+): GloomPluginContext {
+  namespacedContexts.set(context, createNamespaced);
+  return context;
+}
+
+/**
+ * The same plugin context with its persistence, resume, config and team state
+ * under another namespace. Contributions still register to the plugin that
+ * owns the context. A context the registry did not create comes back as is.
+ */
+export function pluginContextInNamespace(context: GloomPluginContext, stateId: string): GloomPluginContext {
+  const createNamespaced = namespacedContexts.get(context);
+  return createNamespaced ? { ...context, ...createNamespaced(stateId) } : context;
+}
+
 interface PluginResumeStateOptions {
   pluginId: string;
   getResumeState: <T = unknown>(key: string, schemaVersion?: number) => T | null;

package/src/plugins/runtime/context.tsx

@@ -2,6 +2,7 @@ import {
   createContext,
   createElement,
   useContext,
+  useMemo,
   type ReactNode,
 } from "react";
 import type { BrokerAdapter } from "../../types/broker";
@@ -67,6 +68,34 @@ export function withPluginRender<P>(
   );
 }
 
+function PluginStateNamespace({ stateId, children }: { stateId: string; children: ReactNode }) {
+  const outer = useContext(PluginRenderContext);
+  const runtime = outer?.runtime;
+  const value = useMemo(() => (runtime ? { pluginId: stateId, runtime } : null), [runtime, stateId]);
+  if (!value) return children;
+  return <PluginRenderContext value={value}>{children}</PluginRenderContext>;
+}
+
+/**
+ * Renders a component under another state namespace of the plugin render
+ * context it is already in. A built-in module that moved to another plugin
+ * keeps reading and writing the pane and plugin state it already has.
+ */
+export function withPluginStateNamespace<P>(
+  stateId: string,
+  component: (props: P) => ReactNode,
+): (props: P) => ReactNode {
+  const scoped = (props: P) => (
+    <PluginStateNamespace stateId={stateId}>
+      {createElement(component as (props: any) => ReactNode, props)}
+    </PluginStateNamespace>
+  );
+  // Names the namespace in React's tools, and to tests that check a moved
+  // module still reads the state it had.
+  scoped.displayName = `PluginStateNamespace(${stateId})`;
+  return scoped;
+}
+
 export function usePluginRenderContext(): PluginRenderContextValue {
   const context = useContext(PluginRenderContext);
   if (!context) {

package/src/react/input.ts

@@ -57,9 +57,20 @@ interface ShortcutEntry extends ShortcutRegistration {
 
 export interface ShortcutRegistry {
   register(registration: ShortcutRegistration): () => void;
+  /**
+   * Runs `listener` for every key, before any handler is picked for it. State
+   * it sets has rendered by the time the handlers run (when the host can
+   * flush), so they read it instead of what the last frame held.
+   */
+  beforeDispatch(listener: (event: KeyEventLike) => void): () => void;
   dispatch(event: KeyEventLike): void;
 }
 
+export interface ShortcutRegistryOptions {
+  /** The renderer's synchronous render flush, which `beforeDispatch` listeners run inside. */
+  flushSync?: (run: () => void) => void;
+}
+
 const SHORTCUT_PHASES: ReadonlyArray<ShortcutEntry["phase"]> = [
   "capture",
   "before",
@@ -88,9 +99,10 @@ function orderShortcutEntries(entries: ShortcutEntry[]): ShortcutEntry[] {
   });
 }
 
-export function createShortcutRegistry(): ShortcutRegistry {
+export function createShortcutRegistry({ flushSync }: ShortcutRegistryOptions = {}): ShortcutRegistry {
   let nextOrder = 1;
   const entries = new Map<number, ShortcutEntry>();
+  const beforeListeners = new Set<(event: KeyEventLike) => void>();
 
   return {
     register(registration) {
@@ -104,7 +116,20 @@ export function createShortcutRegistry(): ShortcutRegistry {
         entries.delete(order);
       };
     },
+    beforeDispatch(listener) {
+      beforeListeners.add(listener);
+      return () => {
+        beforeListeners.delete(listener);
+      };
+    },
     dispatch(event) {
+      if (beforeListeners.size > 0) {
+        const run = () => {
+          for (const listener of [...beforeListeners]) listener(event);
+        };
+        if (flushSync) flushSync(run);
+        else run();
+      }
       const eligible = orderShortcutEntries(
         [...entries.values()].filter((entry) => (
           entry.isEnabled() && shouldDeliverShortcut(event, entry.allowsEditable())
@@ -151,11 +176,24 @@ export function useRegisteredShortcut(
   }), [options?.phase, options?.scope, registry]);
 }
 
+export function useRegisteredBeforeShortcut(
+  registry: ShortcutRegistry,
+  listener: (event: KeyEventLike) => void,
+): void {
+  const listenerRef = useRef(listener);
+  listenerRef.current = listener;
+  useLayoutEffect(
+    () => registry.beforeDispatch((event) => listenerRef.current(event)),
+    [registry],
+  );
+}
+
 export interface InputHost {
   useShortcut(
     handler: (event: KeyEventLike) => void,
     options?: ShortcutOptions,
   ): void;
+  useBeforeShortcut(listener: (event: KeyEventLike) => void): void;
   useViewport(): { width: number; height: number };
 }
 
@@ -186,6 +224,15 @@ export function useShortcut(
   useInputHost().useShortcut(handler, options);
 }
 
+/**
+ * Runs before every key reaches any shortcut handler, whatever its phase or
+ * scope, for state the handlers read: set it here and it has rendered by the
+ * time they run. Not for acting on the key.
+ */
+export function useBeforeShortcut(listener: (event: KeyEventLike) => void): void {
+  useInputHost().useBeforeShortcut(listener);
+}
+
 export function shouldDeliverShortcut(
   event: KeyEventLike,
   allowEditable: boolean,

package/src/remote/app-host.tsx

@@ -23,6 +23,11 @@ export function useRemoteControlHandler(): RemoteControlHandler | null {
 export interface RemoteControlAdapter {
   startServer?(options: { dataDir: string; handle: RemoteControlHandler }): void | (() => void | Promise<void>);
   registerHandler?(handler: RemoteControlHandler | null): void | (() => void);
+  /**
+   * Set where a remote assistant may drive this app through Gloom Cloud: what
+   * kind of app it is and the machine name it shows under.
+   */
+  terminalDevice?: { kind: "desktop" | "tui"; name: string };
 }
 
 interface RemoteControlHostProps {