gloomberb 0.16.3 → 0.16.4

package/src/core/state/app/layout-reducer.ts

@@ -1,4 +1,5 @@
-import { cloneLayout, createBlankLayout, type SavedLayout } from "../../../types/config";
+import { cloneLayout, createBlankLayout, getPlacedPaneInstanceIds, type SavedLayout } from "../../../types/config";
+import { movePaneBack, movePaneToOwnLayout, paneMoveBackTarget } from "../../../layout/pane-layout-move";
 import {
   clonePaneStateMap,
   cloneSavedLayout,
@@ -6,11 +7,12 @@ import {
   moveHistoryIndex,
   movedIndex,
   removeHistoryIndex,
+  resolveTickerForPane,
   setHistoryForIndex,
   syncConfigActiveLayoutState,
   withFocusedPane,
 } from "./layout";
-import type { AppAction, AppState } from "./types";
+import type { AppAction, AppState, PaneRuntimeState } from "./types";
 
 const MAX_LAYOUT_HISTORY = 50;
 
@@ -293,7 +295,8 @@ export function reduceLayoutAction(state: AppState, action: AppAction): AppState
         state.paneState,
         state.focusedPaneId,
       );
-      const source = currentConfig.layouts[action.index]!;
+      const { id: _id, ...source } = currentConfig.layouts[action.index]!;
+      // A copy is a layout of its own: sharing the id would send Move Back to either.
       const duplicate: SavedLayout = {
         ...cloneSavedLayout(source),
         name: `${source.name} Copy`,
@@ -313,6 +316,89 @@ export function reduceLayoutAction(state: AppState, action: AppAction): AppState
       });
     }
 
+    case "MOVE_PANE_TO_NEW_LAYOUT": {
+      const resolveSymbol = (instanceId: string) => resolveTickerForPane(state, instanceId);
+      const currentConfig = syncConfigActiveLayoutState(state.config, state.paneState, state.focusedPaneId);
+      const sourceIndex = currentConfig.activeLayoutIndex;
+      const sourceEntry = currentConfig.layouts[sourceIndex]!;
+      const sourceLayoutId = sourceEntry.id ?? action.sourceLayoutId;
+      const move = movePaneToOwnLayout(state.config.layout, action.paneId, sourceLayoutId, resolveSymbol);
+      if (!move) return state;
+
+      const { [action.paneId]: savedPaneState, ...sourcePaneState } = sourceEntry.paneState ?? {};
+      // The live object, so the pane's state keeps its identity across the move.
+      const livePaneState = (state.paneState[action.paneId] ?? savedPaneState) as PaneRuntimeState | undefined;
+      const movedPaneState: Record<string, PaneRuntimeState> = livePaneState ? { [action.paneId]: livePaneState } : {};
+      const previous = state.previousFocusedPaneId;
+      const sourceFocus = previous && getPlacedPaneInstanceIds(move.source).includes(previous) ? previous : null;
+      const layouts: SavedLayout[] = currentConfig.layouts.map((entry, index) => (
+        index === sourceIndex
+          ? { ...entry, id: sourceLayoutId, layout: move.source, paneState: sourcePaneState, focusedPaneId: sourceFocus }
+          : entry
+      ));
+      layouts.push({
+        name: availableLayoutName(action.name, layouts),
+        layout: move.target,
+        paneState: movedPaneState,
+        focusedPaneId: action.paneId,
+      });
+      return withFocusedPane({
+        ...state,
+        layoutHistory: setHistoryForIndex(state.layoutHistory, layouts.length - 1, { past: [], future: [] }),
+      }, {
+        ...currentConfig,
+        layout: cloneLayout(move.target),
+        layouts,
+        activeLayoutIndex: layouts.length - 1,
+      }, {
+        paneState: movedPaneState,
+        focusedPaneId: action.paneId,
+      });
+    }
+
+    case "MOVE_PANE_BACK": {
+      const target = paneMoveBackTarget(state.config, action.paneId);
+      if (!target) return state;
+      const resolveSymbol = (instanceId: string) => resolveTickerForPane(state, instanceId);
+      const currentConfig = syncConfigActiveLayoutState(state.config, state.paneState, state.focusedPaneId);
+      const activeIndex = currentConfig.activeLayoutIndex;
+      const activeEntry = currentConfig.layouts[activeIndex]!;
+      const targetEntry = currentConfig.layouts[target.index]!;
+      const move = movePaneBack(state.config.layout, targetEntry.layout, action.paneId, target.original, resolveSymbol);
+      if (!move) return state;
+
+      const { [action.paneId]: savedPaneState, ...activePaneState } = activeEntry.paneState ?? {};
+      const livePaneState = (state.paneState[action.paneId] ?? savedPaneState) as PaneRuntimeState | undefined;
+      const { [action.paneId]: _stale, ...targetPaneState } = targetEntry.paneState ?? {};
+      if (livePaneState) targetPaneState[action.paneId] = livePaneState;
+      let layouts: SavedLayout[] = currentConfig.layouts.map((entry, index) => {
+        if (index === target.index) return { ...entry, layout: move.target, paneState: targetPaneState, focusedPaneId: action.paneId };
+        if (index === activeIndex) return { ...entry, layout: move.source, paneState: activePaneState, focusedPaneId: null };
+        return entry;
+      });
+      // A layout the pane leaves empty was only there for it, unless a team layout is linked to it.
+      let layoutHistory = state.layoutHistory;
+      let nextIndex = target.index;
+      if (getPlacedPaneInstanceIds(move.source).length === 0 && !activeEntry.origin) {
+        layouts = layouts.filter((_, index) => index !== activeIndex);
+        layoutHistory = removeHistoryIndex(layoutHistory, activeIndex);
+        if (activeIndex < target.index) nextIndex -= 1;
+      }
+      const next = layouts[nextIndex]!;
+      return withFocusedPane({ ...state, layoutHistory }, {
+        ...currentConfig,
+        layout: cloneLayout(next.layout),
+        layouts,
+        activeLayoutIndex: nextIndex,
+      }, {
+        paneState: {
+          ...clonePaneStateMap(targetPaneState),
+          ...(livePaneState ? { [action.paneId]: livePaneState } : {}),
+        },
+        focusedPaneId: action.paneId,
+      });
+    }
+
     default:
       return undefined;
   }

package/src/core/state/app/state.ts

@@ -73,6 +73,9 @@ export function appReducer(state: AppState, action: AppAction): AppState {
     case "SET_KEYBINDINGS":
       return { ...state, config: updateKeybindingsConfig(state.config, action.keybindings) };
 
+    case "SET_STAR_PROMPT":
+      return { ...state, config: { ...state.config, starPrompt: action.starPrompt } };
+
     case "SET_TICKERS":
       return { ...state, tickers: action.tickers };
 
@@ -214,11 +217,11 @@ export function appReducer(state: AppState, action: AppAction): AppState {
     case "SET_UPDATE_NOTICE":
       return { ...state, updateNotice: action.notice };
 
-    case "TOGGLE_PLUGIN": {
-      const disabledPlugins = state.config.disabledPlugins.includes(action.pluginId)
-        ? state.config.disabledPlugins.filter((pluginId) => pluginId !== action.pluginId)
-        : [...state.config.disabledPlugins, action.pluginId];
-      return { ...state, config: { ...state.config, disabledPlugins } };
+    case "SET_DISABLED_PLUGINS": {
+      const config = { ...state.config, disabledPlugins: action.disabledPlugins };
+      return Object.prototype.hasOwnProperty.call(action, "focusedPaneId")
+        ? withFocusedPane(state, config, { focusedPaneId: action.focusedPaneId ?? null })
+        : { ...state, config };
     }
 
     case "SET_INPUT_CAPTURED":

package/src/core/state/app/types.ts

@@ -1,5 +1,5 @@
 import type { BrokerAccount } from "../../../types/trading";
-import type { AppConfig, KeybindingsConfig, LayoutConfig, LayoutOrigin, OnboardingProgress } from "../../../types/config";
+import type { AppConfig, KeybindingsConfig, LayoutConfig, LayoutOrigin, OnboardingProgress, StarPromptConfig } from "../../../types/config";
 import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
 import type { Quote, TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
@@ -99,6 +99,8 @@ export interface AppState {
 export type AppAction =
   | { type: "SET_CONFIG"; config: AppConfig }
   | { type: "SET_KEYBINDINGS"; keybindings: KeybindingsConfig | undefined }
+  /** Only the star prompt's own record, so a background write never touches layouts or a theme preview. */
+  | { type: "SET_STAR_PROMPT"; starPrompt: StarPromptConfig | undefined }
   | {
       type: "SET_ONBOARDING_STATE";
       complete: boolean;
@@ -137,7 +139,8 @@ export type AppAction =
   | { type: "SET_UPDATE_PROGRESS"; progress: UpdateProgress | null }
   | { type: "SET_UPDATE_CHECK_IN_PROGRESS"; checking: boolean }
   | { type: "SET_UPDATE_NOTICE"; notice: string | null }
-  | { type: "TOGGLE_PLUGIN"; pluginId: string }
+  /** Plugins switched on or off; `focusedPaneId` moves focus off a pane that just went hidden. */
+  | { type: "SET_DISABLED_PLUGINS"; disabledPlugins: string[]; focusedPaneId?: string | null }
   | { type: "SET_INPUT_CAPTURED"; captured: boolean }
   /** @deprecated Only writes the unused `AppState.exchangeRates`. Use `useFxRatesMap`. */
   | { type: "SET_EXCHANGE_RATE"; currency: string; rate: number }
@@ -172,6 +175,14 @@ export type AppAction =
   | { type: "DELETE_LAYOUT"; index: number }
   | { type: "RENAME_LAYOUT"; index: number; name: string }
   | { type: "DUPLICATE_LAYOUT"; index: number }
+  /**
+   * Moves a pane out of the active layout into a new layout of its own, named
+   * `name` (made unique), which becomes active. `sourceLayoutId` names the
+   * layout it left when that one has no id yet, so Move Back can find it.
+   */
+  | { type: "MOVE_PANE_TO_NEW_LAYOUT"; paneId: string; name: string; sourceLayoutId: string }
+  /** Returns a pane Move to New Layout moved to the layout it came from, which becomes active. */
+  | { type: "MOVE_PANE_BACK"; paneId: string }
   | { type: "FOCUS_PANE"; paneId: string }
   | { type: "FOCUS_NEXT"; paneOrder: string[] }
   | { type: "FOCUS_PREV"; paneOrder: string[] }

package/src/data/config/layout.ts

@@ -1,9 +1,12 @@
 import type {
   DetachedPlacementMemory,
+  DockedPlacementMemory,
   FloatingPlacementMemory,
   LayoutConfig,
   PaneBinding,
   PaneInstanceConfig,
+  PaneMovedFrom,
+  PaneMovedLink,
   PanePlacementMemory,
 } from "../../types/config";
 import type { BrokerContractRef, TickerListingRef } from "../../types/instrument";
@@ -93,30 +96,59 @@ function sanitizeDetachedPlacementMemory(value: unknown): DetachedPlacementMemor
   return { x, y, width, height };
 }
 
+function sanitizeDockedPlacementMemory(raw: unknown): DockedPlacementMemory | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const rawPath = (raw as { path?: unknown }).path;
+  const path = Array.isArray(rawPath)
+    ? rawPath.filter((segment): segment is 0 | 1 => segment === 0 || segment === 1)
+    : undefined;
+  const anchorInstanceId = typeof (raw as { anchorInstanceId?: unknown }).anchorInstanceId === "string"
+    ? (raw as { anchorInstanceId: string }).anchorInstanceId
+    : undefined;
+  const position = ["left", "right", "above", "below"].includes(String((raw as { position?: unknown }).position))
+    ? (raw as { position: "left" | "right" | "above" | "below" }).position
+    : undefined;
+  if (!path && !anchorInstanceId && !position) return undefined;
+  return {
+    path,
+    anchorInstanceId,
+    position,
+  };
+}
+
+function sanitizePaneMovedFrom(value: unknown): PaneMovedFrom | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const raw = value as Record<string, unknown>;
+  if (typeof raw.layoutId !== "string" || !raw.layoutId) return undefined;
+  const docked = sanitizeDockedPlacementMemory(raw.docked);
+  const rawRatio = (raw.docked as { ratio?: unknown } | undefined)?.ratio;
+  const ratio = typeof rawRatio === "number" && rawRatio > 0 && rawRatio < 1 ? rawRatio : undefined;
+  const floating = docked ? undefined : sanitizeFloatingPlacementMemory(raw.floating);
+  const links = Array.isArray(raw.links)
+    ? raw.links.flatMap((entry): PaneMovedLink[] => {
+      if (!entry || typeof entry !== "object") return [];
+      const link = entry as Record<string, unknown>;
+      if (typeof link.instanceId !== "string" || typeof link.sourceInstanceId !== "string" || typeof link.symbol !== "string") return [];
+      return [{
+        instanceId: link.instanceId,
+        sourceInstanceId: link.sourceInstanceId,
+        symbol: link.symbol,
+        ...(typeof link.title === "string" ? { title: link.title } : {}),
+      }];
+    })
+    : [];
+  return {
+    layoutId: raw.layoutId,
+    ...(docked ? { docked: ratio === undefined ? docked : { ...docked, ratio } } : {}),
+    ...(floating ? { floating } : {}),
+    ...(links.length > 0 ? { links } : {}),
+  };
+}
+
 function sanitizePlacementMemory(value: unknown): PanePlacementMemory | undefined {
   if (!value || typeof value !== "object") return undefined;
 
-  const docked = (() => {
-    const raw = (value as PanePlacementMemory).docked;
-    if (!raw || typeof raw !== "object") return undefined;
-    const rawPath = (raw as { path?: unknown }).path;
-    const path = Array.isArray(rawPath)
-      ? rawPath.filter((segment): segment is 0 | 1 => segment === 0 || segment === 1)
-      : undefined;
-    const anchorInstanceId = typeof (raw as { anchorInstanceId?: unknown }).anchorInstanceId === "string"
-      ? (raw as { anchorInstanceId: string }).anchorInstanceId
-      : undefined;
-    const position = ["left", "right", "above", "below"].includes(String((raw as { position?: unknown }).position))
-      ? (raw as { position: "left" | "right" | "above" | "below" }).position
-      : undefined;
-    if (!path && !anchorInstanceId && !position) return undefined;
-    return {
-      path,
-      anchorInstanceId,
-      position,
-    };
-  })();
-
+  const docked = sanitizeDockedPlacementMemory((value as PanePlacementMemory).docked);
   const floating = sanitizeFloatingPlacementMemory((value as PanePlacementMemory).floating);
   const detached = sanitizeDetachedPlacementMemory((value as PanePlacementMemory).detached);
   if (!docked && !floating && !detached) return undefined;
@@ -176,6 +208,7 @@ function sanitizePaneInstances(
       seen.add(instanceId);
       const binding = sanitizePaneBinding(entry.binding);
       const settings = sanitizePaneSettings(entry.settings);
+      const movedFrom = sanitizePaneMovedFrom(entry.movedFrom);
       return {
         instanceId,
         paneId,
@@ -189,6 +222,7 @@ function sanitizePaneInstances(
         settings: migrateChartPaneSettings(originalPaneId, binding, settings, chartMigration),
         placementMemory: sanitizePlacementMemory(entry.placementMemory),
         locked: entry.locked === true ? true : undefined,
+        ...(movedFrom ? { movedFrom } : {}),
       };
     });
   return instances;

package/src/data/config/store/fold-panes.ts

@@ -0,0 +1,149 @@
+import {
+  removePaneInstances,
+  type DockLayoutNode,
+  type LayoutConfig,
+  type PaneInstanceConfig,
+} from "../../../types/config";
+import { isRecord } from "../../../utils/guards";
+
+const SHORT_VOLUME_PANE_ID = "short-volume";
+const SHORT_INTEREST_PANE_ID = "short-interest";
+const SOVR_PANE_ID = "sovr-board";
+const CDX_PANE_ID = "cdx-board";
+
+interface FoldedLayout {
+  layout: LayoutConfig;
+  idMap: Map<string, string>;
+  removed: Set<string>;
+}
+
+function asLayout(value: unknown): LayoutConfig | null {
+  if (!isRecord(value) || !Array.isArray(value.instances)) return null;
+  return {
+    dockRoot: (value.dockRoot ?? null) as DockLayoutNode | null,
+    instances: value.instances as PaneInstanceConfig[],
+    floating: Array.isArray(value.floating) ? value.floating as LayoutConfig["floating"] : [],
+    detached: Array.isArray(value.detached) ? value.detached as LayoutConfig["detached"] : [],
+  };
+}
+
+function interestInstanceId(instanceId: string): string {
+  if (instanceId === SHORT_VOLUME_PANE_ID || instanceId.startsWith(`${SHORT_VOLUME_PANE_ID}:`)) {
+    return `${SHORT_INTEREST_PANE_ID}${instanceId.slice(SHORT_VOLUME_PANE_ID.length)}`;
+  }
+  return instanceId;
+}
+
+function mapNode(node: DockLayoutNode | null, idMap: Map<string, string>): DockLayoutNode | null {
+  if (!node) return null;
+  if (node.kind === "pane") return { ...node, instanceId: idMap.get(node.instanceId) ?? node.instanceId };
+  return { ...node, first: mapNode(node.first, idMap)!, second: mapNode(node.second, idMap)! };
+}
+
+/** Daily short volume becomes the short interest pane's volume tab, and sovereign CDS the index board's Sovereign tab. */
+export function foldPaneLayout(layout: LayoutConfig): FoldedLayout {
+  const removed = new Set<string>();
+  const idMap = new Map<string, string>();
+  const claimed = new Set(layout.instances.map((instance) => instance.instanceId));
+  let hasIndexBoard = layout.instances.some((instance) => instance.paneId === CDX_PANE_ID);
+
+  const instances = layout.instances.flatMap((instance) => {
+    if (instance.paneId === SOVR_PANE_ID) {
+      if (hasIndexBoard) {
+        removed.add(instance.instanceId);
+        return [];
+      }
+      hasIndexBoard = true;
+      return [{
+        ...instance,
+        paneId: CDX_PANE_ID,
+        params: { ...(instance.params ?? {}), tab: "sovereign" },
+      }];
+    }
+    if (instance.paneId !== SHORT_VOLUME_PANE_ID) return [instance];
+    const targetId = interestInstanceId(instance.instanceId);
+    const taken = targetId !== instance.instanceId && claimed.has(targetId);
+    if (taken) {
+      removed.add(instance.instanceId);
+      return [];
+    }
+    if (targetId !== instance.instanceId) {
+      claimed.add(targetId);
+      idMap.set(instance.instanceId, targetId);
+    }
+    return [{
+      ...instance,
+      instanceId: targetId,
+      paneId: SHORT_INTEREST_PANE_ID,
+      params: { ...(instance.params ?? {}), tab: "volume" },
+    }];
+  });
+
+  const mapped: LayoutConfig = {
+    dockRoot: mapNode(layout.dockRoot, idMap),
+    instances: instances.map((instance) => {
+      const binding = instance.binding?.kind === "follow"
+        ? { ...instance.binding, sourceInstanceId: idMap.get(instance.binding.sourceInstanceId) ?? instance.binding.sourceInstanceId }
+        : instance.binding;
+      const anchor = instance.placementMemory?.docked?.anchorInstanceId;
+      const placementMemory = anchor
+        ? {
+          ...instance.placementMemory,
+          docked: { ...instance.placementMemory?.docked, anchorInstanceId: idMap.get(anchor) ?? anchor },
+        }
+        : instance.placementMemory;
+      return { ...instance, binding, placementMemory };
+    }),
+    floating: layout.floating.map((entry) => ({ ...entry, instanceId: idMap.get(entry.instanceId) ?? entry.instanceId })),
+    detached: (layout.detached ?? []).map((entry) => ({ ...entry, instanceId: idMap.get(entry.instanceId) ?? entry.instanceId })),
+  };
+  return { layout: removePaneInstances(mapped, removed), idMap, removed };
+}
+
+function foldPaneState(
+  value: unknown,
+  idMap: Map<string, string>,
+  removed: Set<string>,
+): unknown {
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([instanceId]) => !removed.has(instanceId))
+      .map(([instanceId, entry]) => [idMap.get(instanceId) ?? instanceId, entry]),
+  );
+}
+
+function foldFocus(value: unknown, idMap: Map<string, string>, removed: Set<string>): unknown {
+  if (typeof value !== "string") return value;
+  if (removed.has(value)) return null;
+  return idMap.get(value) ?? value;
+}
+
+function foldLayoutField(value: unknown): FoldedLayout | null {
+  const layout = asLayout(value);
+  if (!layout) return null;
+  return foldPaneLayout(layout);
+}
+
+/** Rewrite the open layout and every saved tab. */
+export function foldSavedPanes(saved: Record<string, unknown>): Record<string, unknown> {
+  const open = foldLayoutField(saved.layout);
+  const layouts = Array.isArray(saved.layouts)
+    ? saved.layouts.map((entry) => {
+      if (!isRecord(entry)) return entry;
+      const folded = foldLayoutField(entry.layout);
+      if (!folded) return entry;
+      return {
+        ...entry,
+        layout: folded.layout,
+        paneState: foldPaneState(entry.paneState, folded.idMap, folded.removed),
+        focusedPaneId: foldFocus(entry.focusedPaneId, folded.idMap, folded.removed),
+      };
+    })
+    : saved.layouts;
+  return {
+    ...saved,
+    ...(open ? { layout: open.layout } : {}),
+    layouts,
+  };
+}

package/src/data/config/store/migrations.ts

@@ -17,6 +17,7 @@ import {
   type LegacyChartMigrationContext,
 } from "../chart-settings";
 import { sanitizeLayout } from "../layout";
+import { foldSavedPanes } from "./fold-panes";
 import { sanitizeSavedPaneState } from "./pane-state";
 import { isRecord } from "../../../utils/guards";
 
@@ -26,6 +27,7 @@ const ONBOARDING_BACKFILL_CONFIG_VERSION = 21;
 const UNREACHABLE_PANE_CLEANUP_CONFIG_VERSION = 22;
 const MARKET_OVERVIEW_ABSORBED_CONFIG_VERSION = 23;
 const IPO_CALENDAR_ABSORBED_CONFIG_VERSION = 24;
+const FOLDED_PANES_CONFIG_VERSION = 25;
 
 /** What a migration may ask of the machine the config is loaded on. */
 export interface ConfigMigrationHost {
@@ -80,6 +82,11 @@ const CONFIG_MIGRATIONS: readonly ConfigMigration[] = [
     toVersion: IPO_CALENDAR_ABSORBED_CONFIG_VERSION,
     migrate: keepAbsorbedPluginsOff("macro", ["ipo-calendar"]),
   },
+  {
+    name: "fold-short-volume-and-sovereign-cds",
+    toVersion: FOLDED_PANES_CONFIG_VERSION,
+    migrate: foldSavedPanes,
+  },
 ];
 
 export function migrateSavedConfig(

package/src/data/config/store/node.ts

@@ -102,14 +102,16 @@ async function loadConfigState(dataDir: string): Promise<{ config: AppConfig; ne
   }
 }
 
-export async function saveConfig(config: AppConfig): Promise<void> {
-  const configPath = configFileFor(config.dataDir);
-  await mkdir(dirname(configPath), { recursive: true });
+/** The save in flight or queued last for each config file; it never rejects. */
+const saveQueues = new Map<string, Promise<void>>();
+let tempFileCounter = 0;
 
-  const persisted = normalizeConfigForSave(config);
-  const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+async function writeConfigFile(configPath: string, contents: string): Promise<void> {
+  await mkdir(dirname(configPath), { recursive: true });
+  // Unique per call: a clock tick is not, and two saves can land in one.
+  const tempPath = `${configPath}.${process.pid}.${Date.now()}.${tempFileCounter++}.tmp`;
   try {
-    await writeFile(tempPath, JSON.stringify(persisted, null, 2), "utf-8");
+    await writeFile(tempPath, contents, "utf-8");
     await rename(tempPath, configPath);
   } catch (error) {
     await rm(tempPath, { force: true }).catch(() => {});
@@ -117,6 +119,25 @@ export async function saveConfig(config: AppConfig): Promise<void> {
   }
 }
 
+/**
+ * Saves to one file run one after another in call order, so the last call is
+ * the one on disk and none is lost. A failed save rejects only its own caller
+ * and the next one still runs.
+ */
+export async function saveConfig(config: AppConfig): Promise<void> {
+  const configPath = configFileFor(config.dataDir);
+  // Written as it was when called, however the caller's object changes while
+  // earlier saves are still running.
+  const contents = JSON.stringify(normalizeConfigForSave(config), null, 2);
+  const result = (saveQueues.get(configPath) ?? Promise.resolve()).then(() => writeConfigFile(configPath, contents));
+  const settled = result.catch(() => {});
+  saveQueues.set(configPath, settled);
+  void settled.then(() => {
+    if (saveQueues.get(configPath) === settled) saveQueues.delete(configPath);
+  });
+  return result;
+}
+
 export async function initDataDir(dataDir: string): Promise<AppConfig> {
   configLog.info(`Initializing data directory: ${dataDir}`);
   await mkdir(dataDir, { recursive: true });

package/src/data/config/store/normalize.ts

@@ -21,8 +21,30 @@ import { isLanguagePreference } from "../../../i18n/languages";
 import { clampFontSize } from "../../../theme/font-scale";
 import { isLayoutConfig, sanitizeLayout } from "../layout";
 import { migrateSavedConfig, type ConfigMigrationHost } from "./migrations";
+import { encodeBuiltinDisabledPluginIds, expandBuiltinPluginGroups } from "../../../plugins/ownership";
 import { sanitizeSavedPaneState } from "./pane-state";
 import { isRecord } from "../../../utils/guards";
+import { debugLog } from "../../../utils/debug-log";
+import { DEFAULT_THEME, themes } from "../../../theme/themes";
+import { sanitizeStarPrompt } from "../../../app/star-prompt/model";
+
+const configLog = debugLog.createLogger("config");
+const reportedUnknownThemes = new Set<string>();
+
+/**
+ * A theme id this build does not know is kept, not replaced: a newer build on
+ * another device may have saved it, and writing the default back would undo
+ * that choice everywhere through sync. The app draws the default meanwhile,
+ * and says so once.
+ */
+function sanitizeTheme(value: unknown, fallback: string): string {
+  if (typeof value !== "string") return fallback;
+  if (!themes[value] && !reportedUnknownThemes.has(value)) {
+    reportedUnknownThemes.add(value);
+    configLog.warn(`Unknown theme "${value}" in config; showing ${DEFAULT_THEME}. gloomberb config themes lists the ids.`);
+  }
+  return value;
+}
 
 export function normalizeLoadedConfig(
   saved: Record<string, unknown>,
@@ -42,7 +64,10 @@ export function normalizeLoadedConfig(
       : entry
   ));
 
-  const disabledPlugins = sanitizeUniqueStringList(candidate.disabledPlugins ?? defaults.disabledPlugins);
+  // After the migrations, which read retired group ids as they were saved.
+  const disabledPlugins = expandBuiltinPluginGroups(
+    sanitizeUniqueStringList(candidate.disabledPlugins ?? defaults.disabledPlugins),
+  );
   const onboardingProgress = sanitizeOnboardingProgress(candidate.onboardingProgress);
   const onboardingComplete = onboardingProgress
     ? false
@@ -64,9 +89,10 @@ export function normalizeLoadedConfig(
     disabledPlugins,
     seededPlugins: sanitizeUniqueStringList(candidate.seededPlugins),
     ...(candidate.portfolioCurrenciesAdopted === true ? { portfolioCurrenciesAdopted: true } : {}),
+    ...(candidate.presentationMode === true ? { presentationMode: true } : {}),
     disabledSources: sanitizeUniqueStringList(candidate.disabledSources ?? defaults.disabledSources),
     pluginConfig: sanitizePluginConfig(candidate.pluginConfig),
-    theme: typeof candidate.theme === "string" ? candidate.theme : defaults.theme,
+    theme: sanitizeTheme(candidate.theme, defaults.theme),
     chartPreferences: sanitizeChartPreferences(candidate.chartPreferences, defaults.chartPreferences),
     valueFlashingEnabled: typeof candidate.valueFlashingEnabled === "boolean" ? candidate.valueFlashingEnabled : defaults.valueFlashingEnabled,
     fontSize: sanitizeFontSize(candidate.fontSize, defaults.fontSize),
@@ -78,6 +104,7 @@ export function normalizeLoadedConfig(
     lastLaunchedVersion: typeof candidate.lastLaunchedVersion === "string" ? candidate.lastLaunchedVersion : undefined,
     ...withKeybindings(sanitizeKeybindings(candidate.keybindings)),
     ...withTelemetry(sanitizeTelemetry(candidate.telemetry)),
+    ...withStarPrompt(sanitizeStarPrompt(candidate.starPrompt)),
   };
 
   const needsSave =
@@ -122,7 +149,8 @@ export function normalizeConfigForSave(config: AppConfig): AppConfig {
     layouts,
     activeLayoutIndex,
     brokerInstances: sanitizeBrokerInstances(config.brokerInstances),
-    disabledPlugins: sanitizeUniqueStringList(config.disabledPlugins),
+    // Older apps read the retired group ids, so a group that is all off is saved as one.
+    disabledPlugins: encodeBuiltinDisabledPluginIds(sanitizeUniqueStringList(config.disabledPlugins)),
     seededPlugins: sanitizeUniqueStringList(config.seededPlugins),
     disabledSources: sanitizeUniqueStringList(config.disabledSources),
     pluginConfig: sanitizePluginConfig(config.pluginConfig),
@@ -138,6 +166,8 @@ export function normalizeConfigForSave(config: AppConfig): AppConfig {
   Object.assign(persisted, withKeybindings(sanitizeKeybindings(config.keybindings)));
   delete persisted.telemetry;
   Object.assign(persisted, withTelemetry(sanitizeTelemetry(config.telemetry)));
+  delete persisted.starPrompt;
+  Object.assign(persisted, withStarPrompt(sanitizeStarPrompt(config.starPrompt)));
 
   return persisted;
 }
@@ -150,6 +180,10 @@ function withTelemetry(telemetry: TelemetryConfig | undefined): Pick<AppConfig,
   return telemetry ? { telemetry } : {};
 }
 
+function withStarPrompt(starPrompt: AppConfig["starPrompt"]): Pick<AppConfig, "starPrompt"> {
+  return starPrompt ? { starPrompt } : {};
+}
+
 /** Only the switches that are set survive; an empty object is the same as none. */
 function sanitizeTelemetry(value: unknown): TelemetryConfig | undefined {
   if (!isRecord(value)) return undefined;