gloomberb 0.16.3 → 0.16.5

package/src/components/ui/icon.tsx

@@ -6,6 +6,7 @@ import { t } from "../../i18n";
 
 export type IconName =
   | "more"
+  | "help"
   | "close"
   | "zap"
   | "sqrt"
@@ -27,11 +28,14 @@ export type IconName =
   | "sort-up"
   | "sort-down"
   | "grip"
-  | "image";
+  | "image"
+  | "thumbs-up"
+  | "thumbs-down";
 
 /** Terminal glyph for each icon; the desktop host draws SVG. */
 export const ICON_GLYPHS: Record<IconName, string> = {
   more: "...",
+  help: "?",
   close: "x",
   zap: "⚡",
   sqrt: "√",
@@ -54,6 +58,10 @@ export const ICON_GLYPHS: Record<IconName, string> = {
   "sort-down": "▼",
   grip: "::",
   image: "▣",
+  // Votes rather than emoji: an emoji keeps its own colours, so it could not
+  // show which thumb is chosen.
+  "thumbs-up": "+1",
+  "thumbs-down": "-1",
 };
 
 export interface IconProps {
@@ -160,7 +168,10 @@ export function IconButton({
         if (!disabled) onPress?.(event);
       }}
     >
-      <Text fg={disabled ? colors.textMuted : color ?? colors.textDim} selectable={false}>{` ${ICON_GLYPHS[icon]} `}</Text>
+      {/* Pressed takes the colour the desktop and the terminal pane header give an active toggle. */}
+      <Text fg={disabled ? colors.textMuted : color ?? (pressed ? colors.warning : colors.textDim)} selectable={false}>
+        {` ${ICON_GLYPHS[icon]} `}
+      </Text>
     </Box>
   );
 }

package/src/components/ui/index.ts

@@ -5,7 +5,7 @@ export type { ListViewItem, ListViewProps, ListRowState } from "./list-view";
 export { DataTable } from "./data-table";
 export type { DataTableCell, DataTableColumn, DataTableProps, DataTableVisibleRange } from "./data-table";
 
-export { Button } from "./button";
+export { Button, terminalButtonColumns } from "./button";
 export { Icon, IconButton, ICON_GLYPHS } from "./icon";
 export type { IconButtonPressEvent, IconButtonProps, IconName, IconProps } from "./icon";
 export { ActionRow } from "./action-row";

package/src/components/ui/text-prompt-dialog.tsx

@@ -4,8 +4,9 @@ import { t } from "../../i18n";
 import { useDialogKeyboard, type PromptContext } from "../../ui/dialog";
 import { useThemeColors } from "../../theme/theme-context";
 import { Button } from "./button";
+import { DialogActions } from "./dialog-actions";
 import { FRAMED_TEXTAREA_DESKTOP_STYLE, TextField } from "./fields";
-import { DialogFrame } from "./frame";
+import { DialogFrame, fitDialogWidth } from "./frame";
 
 export interface TextPromptDialogProps extends PromptContext<string> {
   title: string;
@@ -24,6 +25,7 @@ export interface TextPromptDialogProps extends PromptContext<string> {
   /** Empty is an answer (clearing a value) rather than nothing to save. */
   allowEmpty?: boolean;
   width?: number;
+  /** The terminal's key line; the desktop shows the keys on the buttons. */
   footer?: string;
 }
 
@@ -80,10 +82,10 @@ export function TextPromptDialog({
 
   const shownPlaceholder = placeholder ? t(placeholder) : "";
   return (
-    <DialogFrame title={title} footer={footer}>
-      <Box flexDirection="column" width={width}>
+    <DialogFrame title={title} footer={footer} desktopFooter={null}>
+      <Box flexDirection="column" {...(nativePaneChrome ? { style: { width: fitDialogWidth(width) } } : { width })}>
         {body?.map((line, index) => (
-          <Text key={index} fg={colors.textDim} wrapText width={width}>{line ? t(line) : " "}</Text>
+          <Text key={index} fg={colors.textDim} wrapText width={nativePaneChrome ? undefined : width}>{line ? t(line) : " "}</Text>
         ))}
         {body && body.length > 0 && <Box height={1} />}
         {multiline ? (
@@ -116,17 +118,17 @@ export function TextPromptDialog({
             value={value}
             placeholder={shownPlaceholder}
             focused
-            width={width}
+            width={nativePaneChrome ? undefined : width}
             onChange={setValue}
             onSubmit={submit}
           />
         )}
         <Box height={1} />
-        <Box flexDirection="row" gap={1}>
+        <DialogActions hints={multiline ? { keys: [{ key: "Shift+Enter", label: "newline" }] } : undefined}>
           {/* A textarea is read when it submits, so its button stays live. */}
-          <Button label={confirmLabel} variant="primary" disabled={!multiline && !allowEmpty && !value.trim()} onPress={() => submit(current())} />
-          <Button label="Cancel" variant="secondary" onPress={dismiss} />
-        </Box>
+          <Button label={confirmLabel} variant="primary" desktopShortcut="Enter" disabled={!multiline && !allowEmpty && !value.trim()} onPress={() => submit(current())} />
+          <Button label="Cancel" variant="secondary" desktopShortcut="Esc" onPress={dismiss} />
+        </DialogActions>
       </Box>
     </DialogFrame>
   );

package/src/core/connection-health.ts

@@ -280,7 +280,7 @@ export function registerGloomCloudConnectionSources(health: ConnectionHealthRegi
       id: GLOOM_CLOUD_FRED_CONNECTION_ID,
       name: "Gloom / FRED",
       kind: "api",
-      ownerId: "macro",
+      ownerId: "rates-macro",
       priority: 2,
       detail: "api.gloom.sh/cloud/econ/series",
     }),

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/cached-query.ts

@@ -11,6 +11,8 @@ export interface CachedValue<T> {
   source: string;
   /** Source observation time, when supplied; fetchedAt remains retrieval time. */
   asOf?: number;
+  /** How far a delayed source runs behind the market, in minutes; 0 for a real-time one. */
+  delayMinutes?: number;
   refreshError?: unknown;
 }
 

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 });