gloomberb 0.13.2 → 0.14.0

package/src/plugins/registry/index.ts

@@ -1,18 +1,28 @@
 import type { ReactNode } from "react";
-import type { AppPersistencePort, AppTickerRepositoryPort } from "../../core/app-service-ports";
-import type { LayoutMarketplacePayload } from "../../layout-marketplace/payload";
-import {
-  connectionHealth as sharedConnectionHealth,
-  type ConnectionHealthRegistry,
-} from "../../core/connection-health";
-import type { BrokerAdapter } from "../../types/broker";
 import {
   CapabilityRegistry,
   type CapabilityManifest,
   type NewsCapability,
   type PluginCapability,
 } from "../../capabilities";
+import type { AppPersistencePort, AppTickerRepositoryPort } from "../../core/app-service-ports";
+import {
+  connectionHealth as sharedConnectionHealth,
+  type ConnectionHealthRegistry,
+} from "../../core/connection-health";
+import type { PaneRuntimeState } from "../../core/state/app/state";
+import type { LayoutMarketplacePayload } from "../../layout-marketplace/payload";
+import { cloudSyncController } from "../../sync/controller";
+import type {
+  RegisteredSyncContributor,
+  RegisteredSyncTransport,
+  SyncContributor,
+  SyncTransport,
+} from "../../sync/types";
+import type { BrokerAdapter } from "../../types/broker";
 import type { BrokerInstanceConfig, LayoutConfig } from "../../types/config";
+import { resolvePaneInstance } from "../../types/config";
+import type { ContextMenuContext, ContextMenuItem } from "../../types/context-menu";
 import type { DataProvider } from "../../types/data-provider";
 import type { TickerFinancials } from "../../types/financials";
 import type {
@@ -23,6 +33,7 @@ import type {
   CommandDef,
   CustomColumnDef,
   GloomPlugin,
+  GloomPluginContext,
   GloomSlots,
   KeyboardShortcut,
   PaneDef,
@@ -32,40 +43,32 @@ import type {
   TickerAction,
   TickerResearchTabDef,
 } from "../../types/plugin";
-import type { ContextMenuContext, ContextMenuItem } from "../../types/context-menu";
 import type { TickerRecord } from "../../types/ticker";
-import type {
-  RegisteredSyncContributor,
-  RegisteredSyncTransport,
-  SyncContributor,
-  SyncTransport,
-} from "../../sync/types";
-import { EventBus } from "../event-bus";
-import { resolvePaneInstance } from "../../types/config";
 import { debugLog } from "../../utils/debug-log";
+import { EventBus } from "../event-bus";
+import { isReservedBuiltinPluginId } from "../ownership";
+import { createPluginPersistence } from "../plugin-persistence";
+import { createPluginTeamState } from "../team-state";
 import {
-  wrapTickerResearchTabDefWithRuntime,
   wrapPaneDefWithRuntime,
+  wrapTickerResearchTabDefWithRuntime,
   type PluginRuntimeAccess,
 } from "../runtime";
-import type { PaneRuntimeState } from "../../core/state/app/state";
+import { resolveRegistryContextMenuItems } from "./context-menu";
+import { RegistryContributions, type PluginItems } from "./contributions";
 import {
   resolveRegistryPaneQuickSettings,
   resolveRegistryPaneSettings,
   type ResolvedRegistryPaneQuickSetting,
   type ResolvedRegistryPaneSettings,
 } from "./pane-settings";
-import { RegistrySlots } from "./slots";
-import { RegistryContributions, type PluginItems } from "./contributions";
-import { createRegistryPluginContext } from "./context";
-import { resolveRegistryContextMenuItems } from "./context-menu";
+import { RegistryResumeStateListeners, createPluginPaneSettingsState, createPluginResumeState } from "./plugin-state";
+import { createPluginSetupCommand, isPluginConfigured } from "./setup-command";
 import {
   bindSharedRegistry,
   releaseSharedRegistry,
 } from "./shared";
-import { RegistryResumeStateListeners } from "./plugin-state";
-import { cloudSyncController } from "../../sync/controller";
-import { isReservedBuiltinPluginId } from "../ownership";
+import { RegistrySlots } from "./slots";
 
 interface PluginRegistryOptions {
   enableCapabilityHandlers?: boolean;
@@ -85,7 +88,7 @@ export {
   getSharedMarketData,
   getSharedRegistry,
   setSharedMarketDataForTests,
-  setSharedRegistryForTests,
+  setSharedRegistryForTests
 } from "./shared";
 
 export class PluginRegistry implements PluginRuntimeAccess {
@@ -127,6 +130,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
   openCommandBarFn: ((query?: string) => void) = () => {};
   openPluginCommandWorkflowFn: ((commandId: string) => void) = () => {};
   openPaneSettingsFn: ((paneId?: string) => void) = () => {};
+  sharePaneFn: ((paneId?: string) => void) = () => {};
   openWindowModeFn: ((paneId?: string, mode?: WindowEditMode) => void) = () => {};
   showPaneFn: ((paneId: string) => void) = () => {};
   createPaneFromTemplateFn: ((templateId: string, options?: PaneTemplateCreateOptions) => void) = () => {};
@@ -179,6 +183,9 @@ export class PluginRegistry implements PluginRuntimeAccess {
   openPaneSettings = (paneId?: string) => {
     this.openPaneSettingsFn(paneId);
   };
+  sharePane = (paneId?: string) => {
+    this.sharePaneFn(paneId);
+  };
   openWindowMode = (paneId?: string, mode?: WindowEditMode) => {
     this.openWindowModeFn(paneId, mode);
   };
@@ -219,8 +226,6 @@ export class PluginRegistry implements PluginRuntimeAccess {
   setPluginConfigValuesFn: ((pluginId: string, values: Record<string, unknown>) => Promise<void>) = async () => {};
   deletePluginConfigValueFn: ((pluginId: string, key: string) => Promise<void>) = async () => {};
 
-  readonly Slot;
-
   constructor(
     marketData: DataProvider,
     tickerRepository: AppTickerRepositoryPort,
@@ -237,8 +242,8 @@ export class PluginRegistry implements PluginRuntimeAccess {
     this.remoteCapabilityInvoke = options.remoteCapabilityInvoke;
     this.events = new EventBus();
     this.contributions = new RegistryContributions({
-      wrapPaneDef: (pluginId, pane) => wrapPaneDefWithRuntime(pluginId, pane, this),
-      wrapTickerResearchTabDef: (pluginId, tab) => wrapTickerResearchTabDefWithRuntime(pluginId, tab, this),
+      wrapPaneDef: (pluginId, pane) => wrapPaneDefWithRuntime(this.stateNamespace(pluginId), pane, this),
+      wrapTickerResearchTabDef: (pluginId, tab) => wrapTickerResearchTabDefWithRuntime(this.stateNamespace(pluginId), tab, this),
       wrapBrokerAdapter: this.wrapBrokerAdapter,
     });
 
@@ -251,9 +256,6 @@ export class PluginRegistry implements PluginRuntimeAccess {
       },
       connectionHealth: this.connectionHealth,
     });
-    this.Slot = ({ name, ...props }: { name: keyof GloomSlots } & Record<string, unknown>) => (
-      this.renderSlot(name, props as any)
-    );
   }
 
   get panes(): ReadonlyMap<string, PaneDef> { return this.contributions.panesMap; }
@@ -316,17 +318,22 @@ export class PluginRegistry implements PluginRuntimeAccess {
   }
 
   getPluginPaneIds(pluginId: string): string[] {
-    return this.contributions.pluginItems.get(pluginId)?.panes ?? [];
+    return this.contributions.panesMap.ids(pluginId);
   }
 
   getPluginPaneTemplateIds(pluginId: string): string[] {
-    return this.contributions.pluginItems.get(pluginId)?.paneTemplates ?? [];
+    return this.contributions.paneTemplatesMap.ids(pluginId);
   }
 
-  notify(notification: AppNotificationRequest): AppNotificationDelivery | void {
-    return this.notifyFn(notification);
+  getEnabledTickerActions(): TickerAction[] {
+    const disabled = this.getConfigFn().disabledPlugins;
+    return [...this.contributions.tickerActionsMap].filter(([id]) => (
+      !disabled.includes(this.contributions.tickerActionsMap.owners.get(id)!)
+    )).map(([, action]) => action);
   }
 
+  notify = (notification: AppNotificationRequest): AppNotificationDelivery | void => this.notifyFn(notification);
+
   renderSlot<K extends keyof GloomSlots>(name: K, props: GloomSlots[K]): ReactNode {
     return this.slots.render(name, props);
   }
@@ -342,7 +349,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
       },
     };
     const disposeCapability = this.capabilities.register(pluginId, ownedCapability);
-    this.contributions.registerCapability(pluginId, capability.id, items);
+    this.contributions.registerCapability(pluginId, capability.id);
     items.capabilityDisposers.push(disposeCapability);
     if (ownedCapability.kind === "asset-data" || ownedCapability.kind === "news") {
       items.capabilityDisposers.push(this.connectionHealth.registerSource({
@@ -361,42 +368,61 @@ export class PluginRegistry implements PluginRuntimeAccess {
     }
   }
 
+  /**
+   * Where a plugin's saved state lives, which is its id unless it declares
+   * otherwise. A plugin that was renamed keeps reading and writing the state
+   * the user already has instead of starting again under the new id.
+   */
+  private stateNamespace(pluginId: string): string {
+    return this.plugins.get(pluginId)?.stateId ?? pluginId;
+  }
+
   subscribeResumeState(pluginId: string, key: string, listener: () => void): () => void {
-    return this.resumeStateListeners.subscribe(pluginId, key, listener);
+    return this.resumeStateListeners.subscribe(this.stateNamespace(pluginId), key, listener);
   }
 
   getResumeState<T = unknown>(pluginId: string, key: string, schemaVersion?: number): T | null {
-    return this.persistence.pluginState.get<T>(pluginId, `resume:${key}`, schemaVersion)?.value ?? null;
+    const stateId = this.stateNamespace(pluginId);
+    return this.persistence.pluginState.get<T>(stateId, `resume:${key}`, schemaVersion)?.value ?? null;
   }
 
   setResumeState(pluginId: string, key: string, value: unknown, schemaVersion?: number): void {
-    this.persistence.pluginState.set(pluginId, `resume:${key}`, value, schemaVersion);
-    this.resumeStateListeners.emit(pluginId, key);
+    const stateId = this.stateNamespace(pluginId);
+    this.persistence.pluginState.set(stateId, `resume:${key}`, value, schemaVersion);
+    this.resumeStateListeners.emit(stateId, key);
   }
 
   deleteResumeState(pluginId: string, key: string): void {
-    this.persistence.pluginState.delete(pluginId, `resume:${key}`);
-    this.resumeStateListeners.emit(pluginId, key);
+    const stateId = this.stateNamespace(pluginId);
+    this.persistence.pluginState.delete(stateId, `resume:${key}`);
+    this.resumeStateListeners.emit(stateId, key);
   }
 
   getConfigState<T = unknown>(pluginId: string, key: string): T | null {
-    return this.getPluginConfigValueFn<T>(pluginId, key);
+    return this.getPluginConfigValueFn<T>(this.stateNamespace(pluginId), key);
   }
 
   setConfigState(pluginId: string, key: string, value: unknown): Promise<void> {
-    return this.setPluginConfigValueFn(pluginId, key, value);
+    return this.setPluginConfigValueFn(this.stateNamespace(pluginId), key, value);
   }
 
   setConfigStates(pluginId: string, values: Record<string, unknown>): Promise<void> {
-    return this.setPluginConfigValuesFn(pluginId, values);
+    return this.setPluginConfigValuesFn(this.stateNamespace(pluginId), values);
   }
 
   deleteConfigState(pluginId: string, key: string): Promise<void> {
-    return this.deletePluginConfigValueFn(pluginId, key);
+    return this.deletePluginConfigValueFn(this.stateNamespace(pluginId), key);
   }
 
   getConfigStateKeys(pluginId: string): string[] {
-    return Object.keys(this.getConfigFn().pluginConfig[pluginId] ?? {}).sort();
+    return Object.keys(this.getConfigFn().pluginConfig[this.stateNamespace(pluginId)] ?? {}).sort();
+  }
+
+  /** False while a plugin with a `configSchema` is missing a required value. */
+  isPluginConfigured(pluginId: string): boolean {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) return true;
+    return isPluginConfigured(plugin, this.getConfigFn().pluginConfig[this.stateNamespace(pluginId)] ?? {});
   }
 
   private resolvePaneTarget(paneId: string): string | undefined {
@@ -410,7 +436,7 @@ export class PluginRegistry implements PluginRuntimeAccess {
       getPaneRuntimeState: this.getPaneRuntimeStateFn,
       layout: this.getLayoutFn(),
       paneDefs: this.contributions.panesMap,
-      paneOwners: this.contributions.paneOwners,
+      paneOwners: this.contributions.panesMap.owners,
       resolvePaneTarget: (targetPaneId) => this.resolvePaneTarget(targetPaneId),
       requestedPaneId: paneId,
     });
@@ -431,27 +457,31 @@ export class PluginRegistry implements PluginRuntimeAccess {
   }
 
   getCommandPluginId(commandId: string): string | undefined {
-    return this.contributions.commandOwners.get(commandId);
+    return this.contributions.commandsMap.owners.get(commandId);
   }
 
   getCommandBarSearchProviderPluginId(providerId: string): string | undefined {
-    return this.contributions.commandBarSearchProviderOwners.get(providerId);
+    return this.contributions.commandBarSearchProvidersMap.owners.get(providerId);
   }
 
   getPanePluginId(paneId: string): string | undefined {
-    return this.contributions.paneOwners.get(paneId);
+    return this.contributions.panesMap.owners.get(paneId);
   }
 
   getPaneTemplatePluginId(templateId: string): string | undefined {
-    return this.contributions.paneTemplateOwners.get(templateId);
+    return this.contributions.paneTemplatesMap.owners.get(templateId);
+  }
+
+  getBrokerPluginId(brokerType: string): string | undefined {
+    return this.contributions.brokersMap.owners.get(brokerType);
   }
 
   getShortcutPluginId(shortcutId: string): string | undefined {
-    return this.contributions.shortcutOwners.get(shortcutId);
+    return this.contributions.shortcutsMap.owners.get(shortcutId);
   }
 
   getTickerResearchTabPluginId(tabId: string): string | undefined {
-    return this.contributions.tickerResearchTabOwners.get(tabId);
+    return this.contributions.tickerResearchTabsMap.owners.get(tabId);
   }
 
   isPaneFloating(paneId: string): boolean {
@@ -463,54 +493,96 @@ export class PluginRegistry implements PluginRuntimeAccess {
     }
   }
 
-  private createContext(pluginId: string) {
-    const items = this.contributions.getOrCreatePluginItems(pluginId);
-    return createRegistryPluginContext({
-      pluginId,
-      items,
-      contributions: this.contributions,
-      enableCapabilityHandlers: this.enableCapabilityHandlers,
-      marketData: this.marketData,
-      connectionHealth: this.connectionHealth,
-      tickerRepository: this.tickerRepository,
-      persistence: this.persistence,
-      getLayout: () => this.getLayoutFn(),
-      updateLayout: (layout) => this.updateLayoutFn(layout),
-      resolvePaneTarget: (paneId) => this.resolvePaneTarget(paneId),
-      registerCapabilityForPlugin: (targetPluginId, capability, pluginItems) => this.registerCapabilityForPlugin(targetPluginId, capability, pluginItems),
-      registerSyncContributorForPlugin: (targetPluginId, contributor) => this.registerSyncContributorForPlugin(targetPluginId, contributor),
-      registerSyncTransportForPlugin: (targetPluginId, transport) => this.registerSyncTransportForPlugin(targetPluginId, transport),
-      watchNewsQuery: (query, listener) => this.watchNewsQueryFn(query, listener),
+  private createContext(pluginId: string): GloomPluginContext {
+    const contributions = this.contributions;
+    const items = contributions.getOrCreatePluginItems(pluginId);
+    return {
+      registerPane: (pane) => contributions.registerPane(pluginId, pane),
+      registerPaneTemplate: (template) => contributions.registerPaneTemplate(pluginId, template, true),
+      registerCommand: (command) => contributions.registerCommand(pluginId, command),
+      registerCommandBarSearchProvider: (provider) => contributions.registerCommandBarSearchProvider(pluginId, provider),
+      registerColumn: (column) => contributions.registerColumn(pluginId, column),
+      registerBroker: (broker) => contributions.registerBroker(pluginId, broker),
+      registerCapability: (capability) => {
+        if (this.enableCapabilityHandlers) this.registerCapabilityForPlugin(pluginId, capability, items);
+      },
+      registerTickerResearchTab: (tab) => contributions.registerTickerResearchTab(pluginId, tab),
+      registerShortcut: (shortcut) => contributions.registerShortcut(pluginId, shortcut),
+      registerTickerAction: (action) => contributions.registerTickerAction(pluginId, action),
+      registerContextMenuProvider: (provider) => contributions.registerContextMenuProvider(pluginId, provider),
+      registerSyncContributor: (contributor) => {
+        const dispose = this.registerSyncContributorForPlugin(pluginId, contributor);
+        items.eventDisposers.push(dispose);
+        return dispose;
+      },
+      registerSyncTransport: (transport) => {
+        const dispose = this.registerSyncTransportForPlugin(pluginId, transport);
+        items.eventDisposers.push(dispose);
+        return dispose;
+      },
+      watchNewsQuery: (query, listener) => {
+        const dispose = this.watchNewsQueryFn(query, listener);
+        items.newsQueryWatchDisposers.push(dispose);
+        return dispose;
+      },
       getData: (ticker) => this.getDataFn(ticker),
       getTicker: (symbol) => this.getTickerFn(symbol),
       getConfig: () => this.getConfigFn(),
-      getResumeState: (key, schemaVersion) => this.getResumeState(pluginId, key, schemaVersion),
-      setResumeState: (key, value, schemaVersion) => this.setResumeState(pluginId, key, value, schemaVersion),
-      deleteResumeState: (key) => this.deleteResumeState(pluginId, key),
-      getPaneRuntimeState: (paneId) => this.getPaneRuntimeStateFn(paneId),
-      updatePaneRuntimeState: (paneId, patch) => this.updatePaneRuntimeStateFn(paneId, patch),
-      getConfigState: (key) => this.getConfigState(pluginId, key),
-      setConfigState: (key, value) => this.setConfigState(pluginId, key, value),
-      deleteConfigState: (key) => this.deleteConfigState(pluginId, key),
-      getConfigStateKeys: () => this.getConfigStateKeys(pluginId),
+      getPaneDef: (paneId) => contributions.panesMap.get(paneId),
+      marketData: this.marketData,
+      connectionHealth: this.connectionHealth,
+      tickerRepository: this.tickerRepository,
+      persistence: createPluginPersistence(
+        this.persistence.pluginState,
+        this.persistence.resources,
+        `plugin:${this.stateNamespace(pluginId)}`,
+        this.stateNamespace(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.getPaneRuntimeStateFn(paneId),
+        updatePaneRuntimeState: (paneId, patch) => this.updatePaneRuntimeStateFn(paneId, patch),
+      }),
+      teamState: createPluginTeamState(this.stateNamespace(pluginId)),
+      paneSettings: createPluginPaneSettingsState({
+        getLayout: () => this.getLayoutFn(),
+        updateLayout: (layout) => this.updateLayoutFn(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.createBrokerInstanceFn(brokerType, label, values),
-      updateBrokerInstance: (instanceId, values, options) => this.updateBrokerInstanceFn(instanceId, values, options),
-      syncBrokerInstance: (instanceId) => this.syncBrokerInstanceFn(instanceId),
-      removeBrokerInstance: (instanceId) => this.removeBrokerInstanceFn(instanceId),
-      selectTicker: (symbol, paneId) => this.selectTicker(symbol, paneId),
-      switchPanel: (panel) => this.switchPanel(panel),
-      switchTab: (tabId, paneId) => this.switchTab(tabId, paneId),
-      openCommandBar: (query) => this.openCommandBar(query),
-      showPane: (paneId) => this.showPane(paneId),
-      createPaneFromTemplate: (templateId, options) => this.createPaneFromTemplate(templateId, options),
-      hidePane: (paneId) => this.hidePane(paneId),
-      focusPane: (paneId) => this.focusPaneFn(paneId),
-      pinTicker: (symbol, options) => this.pinTicker(symbol, options),
-      navigateTicker: (symbol, options) => this.navigateTicker(symbol, options),
-      openPaneSettings: (paneId) => this.openPaneSettings(paneId),
-      events: this.events,
+      updateBrokerInstance: this.updateBrokerInstance,
+      syncBrokerInstance: this.syncBrokerInstance,
+      removeBrokerInstance: this.removeBrokerInstance,
+      selectTicker: this.selectTicker,
+      switchPanel: this.switchPanel,
+      switchTab: this.switchTab,
+      openCommandBar: this.openCommandBar,
+      showPane: this.showPane,
+      createPaneFromTemplate: this.createPaneFromTemplate,
+      hidePane: this.hidePane,
+      focusPane: this.focusPane,
+      pinTicker: this.pinTicker,
+      navigateTicker: this.navigateTicker,
+      openPaneSettings: this.openPaneSettings,
+      sharePane: this.sharePane,
+      on: (event, handler) => {
+        const dispose = this.events.on(event, handler);
+        items.eventDisposers.push(dispose);
+        return dispose;
+      },
+      emit: (event, payload) => this.events.emit(event, payload),
       notify: (notification) => this.notifyFn(notification),
-    });
+    };
   }
 
   private registryLog = debugLog.createLogger("registry");
@@ -526,18 +598,18 @@ export class PluginRegistry implements PluginRuntimeAccess {
       const items = this.contributions.getOrCreatePluginItems(plugin.id);
       if (plugin.panes) {
         for (const pane of plugin.panes) {
-          this.contributions.registerPane(plugin.id, pane, items);
+          this.contributions.registerPane(plugin.id, pane);
         }
       }
 
       if (plugin.paneTemplates) {
         for (const template of plugin.paneTemplates) {
-          this.contributions.registerPaneTemplate(plugin.id, template, items);
+          this.contributions.registerPaneTemplate(plugin.id, template);
         }
       }
 
       if (plugin.broker) {
-        this.contributions.registerBroker(plugin.id, plugin.broker, items);
+        this.contributions.registerBroker(plugin.id, plugin.broker);
       }
 
       if (this.enableCapabilityHandlers && plugin.capabilities) {
@@ -548,6 +620,13 @@ export class PluginRegistry implements PluginRuntimeAccess {
 
       this.slots.register(plugin, this);
 
+      const setupCommand = createPluginSetupCommand(plugin, {
+        getValues: () => this.getConfigFn().pluginConfig[this.stateNamespace(plugin.id)] ?? {},
+        setValues: (values) => this.setConfigStates(plugin.id, values),
+        notify: (body, type) => this.notifyFn({ body, type }),
+      });
+      if (setupCommand) this.contributions.registerCommand(plugin.id, setupCommand);
+
       if (plugin.setup) {
         await plugin.setup(this.createContext(plugin.id));
       }

package/src/plugins/registry/pane-settings.ts

@@ -3,7 +3,7 @@ import {
   resolveCollectionForPane,
   resolveTickerForPane,
 } from "../../core/state/app/state";
-import { getPaneSettings } from "../../pane-settings";
+import { getPaneSettings, isPaneLocked, PANE_LOCK_SETTING_KEY } from "../../pane-settings";
 import type { AppConfig, LayoutConfig, PaneInstanceConfig } from "../../types/config";
 import type {
   PaneDef,
@@ -80,7 +80,7 @@ export function resolveRegistryPaneSettings({
   if (!pane) return null;
 
   const paneDef = paneDefs.get(pane.paneId);
-  if (!paneDef || (!paneDef.settings && !paneDef.tableExport)) return null;
+  if (!paneDef) return null;
 
   const pluginId = paneOwners.get(pane.paneId);
   const paneSettings = getPaneSettings(pane);
@@ -106,13 +106,12 @@ export function resolveRegistryPaneSettings({
   const baseSettingsDef = typeof paneDef.settings === "function"
     ? paneDef.settings(context)
     : paneDef.settings;
-  if (!baseSettingsDef && !paneDef.tableExport) return null;
-  const settingsDef: PaneSettingsDef = paneDef.tableExport
-    ? {
-      ...(baseSettingsDef ?? {}),
-      fields: [
-        ...(baseSettingsDef?.fields ?? []),
-        {
+  const settingsDef: PaneSettingsDef = {
+    ...(baseSettingsDef ?? {}),
+    fields: [
+      ...(baseSettingsDef?.fields ?? []),
+      ...(paneDef.tableExport
+        ? [{
           key: "tableExport.csv",
           label: "Export CSV",
           description: "Export the current table as an Excel-compatible CSV file.",
@@ -125,15 +124,22 @@ export function resolveRegistryPaneSettings({
             pane.title ?? paneDef.name,
             actionContext.notify,
           ),
-        },
-      ],
-    }
-    : baseSettingsDef!;
+        } satisfies PaneSettingField]
+        : []),
+      {
+        key: PANE_LOCK_SETTING_KEY,
+        label: "Lock Pane",
+        description: "Keep this pane in the layout when the close shortcut is pressed.",
+        type: "toggle",
+      },
+    ],
+  };
 
   const rawSettings = { ...paneSettings };
-  const resolvedSettings = {
+  const resolvedSettings: Record<string, unknown> = {
     ...paneSettings,
     ...(settingsDef.values ?? {}),
+    [PANE_LOCK_SETTING_KEY]: isPaneLocked(pane),
   };
   if (pluginId) {
     for (const field of settingsDef.fields) {

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

@@ -1,7 +1,8 @@
-import type { LayoutConfig } from "../../types/config";
 import type { PaneRuntimeState } from "../../core/state/app/state";
-import type { PluginPaneSettingsState, PluginResumeState } from "../../types/plugin";
 import { deletePaneSetting, setPaneSetting } from "../../pane-settings";
+import type { LayoutConfig } from "../../types/config";
+import type { PluginPaneSettingsState, PluginResumeState } from "../../types/plugin";
+import { deletePluginPaneStateValue, setPluginPaneStateValue } from "../pane-state";
 
 export class RegistryResumeStateListeners {
   private listeners = new Map<string, Set<() => void>>();
@@ -67,13 +68,7 @@ export function createPluginResumeState({
     },
     setPaneState: (paneId, key, value) => {
       const currentPaneState = getPaneRuntimeState(paneId) ?? {};
-      const pluginState = {
-        ...(currentPaneState.pluginState ?? {}),
-        [pluginId]: {
-          ...(currentPaneState.pluginState?.[pluginId] ?? {}),
-          [key]: value,
-        },
-      };
+      const pluginState = setPluginPaneStateValue(currentPaneState, pluginId, key, value);
       updatePaneRuntimeState(paneId, { pluginState });
     },
     deletePaneState: (paneId, key) => {
@@ -81,18 +76,8 @@ export function createPluginResumeState({
       const currentPluginState = currentPaneState.pluginState?.[pluginId];
       if (!currentPluginState || !(key in currentPluginState)) return;
 
-      const nextPluginState = { ...currentPluginState };
-      delete nextPluginState[key];
-
-      const nextAllPluginState = { ...(currentPaneState.pluginState ?? {}) };
-      if (Object.keys(nextPluginState).length === 0) {
-        delete nextAllPluginState[pluginId];
-      } else {
-        nextAllPluginState[pluginId] = nextPluginState;
-      }
-
       updatePaneRuntimeState(paneId, {
-        pluginState: Object.keys(nextAllPluginState).length > 0 ? nextAllPluginState : undefined,
+        pluginState: deletePluginPaneStateValue(currentPaneState, pluginId, key),
       });
     },
   };

package/src/plugins/registry/setup-command.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+
+import type { GloomPlugin } from "../../types/plugin";
+import { createPluginSetupCommand, isPluginConfigured } from "./setup-command";
+
+const plugin: GloomPlugin = {
+  id: "weather",
+  name: "Weather",
+  version: "1.0.0",
+  configSchema: [
+    { key: "apiKey", label: "API key", type: "password" },
+    { key: "units", label: "Units", type: "select", required: false, options: [{ label: "C", value: "c" }], defaultValue: "c" },
+    { key: "limit", label: "Limit", type: "number", required: false },
+  ],
+};
+
+describe("isPluginConfigured", () => {
+  test("requires every required field, and only those", () => {
+    expect(isPluginConfigured(plugin, {})).toBe(false);
+    expect(isPluginConfigured(plugin, { apiKey: "   " })).toBe(false);
+    expect(isPluginConfigured(plugin, { apiKey: "k" })).toBe(true);
+  });
+
+  test("defers to the plugin's own rule when it has one", () => {
+    const custom: GloomPlugin = { ...plugin, isConfigured: (values) => values.token === "yes" };
+    expect(isPluginConfigured(custom, { apiKey: "k" })).toBe(false);
+    expect(isPluginConfigured(custom, { token: "yes" })).toBe(true);
+  });
+
+  test("a plugin with no schema is always configured", () => {
+    expect(isPluginConfigured({ id: "plain", name: "Plain", version: "1" }, {})).toBe(true);
+  });
+});
+
+describe("createPluginSetupCommand", () => {
+  test("reads current values as defaults each time the form opens", () => {
+    let stored: Record<string, unknown> = {};
+    const command = createPluginSetupCommand(plugin, {
+      getValues: () => stored,
+      setValues: async (values) => { stored = { ...stored, ...values }; },
+      notify: () => {},
+    })!;
+
+    expect(command.wizard!.map((step) => step.defaultValue)).toEqual([undefined, "c", undefined]);
+    stored = { apiKey: "abc" };
+    expect(command.wizard![0]!.defaultValue).toBe("abc");
+  });
+
+  test("writes typed values and drops blanks so a cleared field does not save an empty string", async () => {
+    let stored: Record<string, unknown> = {};
+    const notes: string[] = [];
+    const command = createPluginSetupCommand(plugin, {
+      getValues: () => stored,
+      setValues: async (values) => { stored = values; },
+      notify: (body) => { notes.push(body); },
+    })!;
+
+    await command.execute({ apiKey: "abc", units: "", limit: "12" });
+    expect(stored).toEqual({ apiKey: "abc", limit: 12 });
+    expect(notes).toEqual(["Weather is set up."]);
+  });
+});