gloomberb 0.15.2 → 0.15.3

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

@@ -2,8 +2,6 @@ import {
   cloneLayout,
   createDefaultConfig,
   CURRENT_CONFIG_VERSION,
-  DEFAULT_COLUMNS,
-  DEFAULT_PORTFOLIO_COLUMN_IDS,
   getPlacedPaneInstanceIds,
   type LayoutConfig,
 } from "../../../types/config";
@@ -19,40 +17,29 @@ import {
   type LegacyChartMigrationContext,
 } from "../chart-settings";
 import { sanitizeLayout } from "../layout";
+import { sanitizeSavedPaneState } from "./pane-state";
+import { isRecord } from "../../../utils/guards";
 
 const CLOUD_DEFAULT_CONFIG_VERSION = 13;
-const CLOUD_MACRO_SPLIT_CONFIG_VERSION = 15;
-const PORTFOLIO_DEFAULT_COLUMNS_CONFIG_VERSION = 17;
 const BUILTIN_OWNERSHIP_AND_CHART_CONFIG_VERSION = 20;
 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 LEGACY_MAIN_PORTFOLIO_COLUMN_IDS = DEFAULT_COLUMNS.map((column) => column.id);
-const PRE_SPARKLINE_PORTFOLIO_COLUMN_IDS = [
-  ...DEFAULT_COLUMNS.map((column) => column.id),
-  "shares",
-  "avg_cost",
-  "cost_basis",
-  "mkt_value",
-  "pnl",
-  "pnl_pct",
-];
-const PRE_DAY_PNL_PORTFOLIO_COLUMN_IDS = [
-  ...DEFAULT_COLUMNS.map((column) => column.id),
-  "sparkline",
-  "shares",
-  "avg_cost",
-  "cost_basis",
-  "mkt_value",
-  "pnl",
-  "pnl_pct",
-];
-const BUILTIN_SOURCE_IDS = new Set(["yahoo", "gloomberb-cloud"]);
+/** What a migration may ask of the machine the config is loaded on. */
+export interface ConfigMigrationHost {
+  /**
+   * Whether the plugins folder holds a separately installed copy of this
+   * plugin. Absent where there is no plugins folder, as on the web.
+   */
+  hasPluginCheckout?(pluginId: string): boolean;
+}
 
 interface ConfigMigration {
   name: string;
   toVersion: number;
-  migrate(saved: Record<string, unknown>, dataDir: string): Record<string, unknown>;
+  migrate(saved: Record<string, unknown>, dataDir: string, host: ConfigMigrationHost): Record<string, unknown>;
 }
 
 export interface ConfigMigrationResult {
@@ -67,16 +54,6 @@ const CONFIG_MIGRATIONS: readonly ConfigMigration[] = [
     toVersion: CLOUD_DEFAULT_CONFIG_VERSION,
     migrate: migrateCloudDefault,
   },
-  {
-    name: "split-cloud-macro-and-data-sources",
-    toVersion: CLOUD_MACRO_SPLIT_CONFIG_VERSION,
-    migrate: migrateCloudMacroAndSources,
-  },
-  {
-    name: "refresh-portfolio-default-columns",
-    toVersion: PORTFOLIO_DEFAULT_COLUMNS_CONFIG_VERSION,
-    migrate: migratePortfolioDefaultColumns,
-  },
   {
     name: "consolidate-builtins-and-chart-state",
     toVersion: BUILTIN_OWNERSHIP_AND_CHART_CONFIG_VERSION,
@@ -92,9 +69,24 @@ const CONFIG_MIGRATIONS: readonly ConfigMigration[] = [
     toVersion: UNREACHABLE_PANE_CLEANUP_CONFIG_VERSION,
     migrate: migrateUnreachablePaneInstances,
   },
+  {
+    name: "keep-market-overview-modules-off",
+    toVersion: MARKET_OVERVIEW_ABSORBED_CONFIG_VERSION,
+    migrate: keepAbsorbedPluginsOff("market-overview", ["market-heatmap", "market-halts", "fear-greed"]),
+  },
+  {
+    // Main builds already wrote version 23, so the IPO Calendar needs its own.
+    name: "keep-ipo-calendar-off",
+    toVersion: IPO_CALENDAR_ABSORBED_CONFIG_VERSION,
+    migrate: keepAbsorbedPluginsOff("macro", ["ipo-calendar"]),
+  },
 ];
 
-export function migrateSavedConfig(saved: Record<string, unknown>, dataDir: string): ConfigMigrationResult {
+export function migrateSavedConfig(
+  saved: Record<string, unknown>,
+  dataDir: string,
+  host: ConfigMigrationHost = {},
+): ConfigMigrationResult {
   let version = savedConfigVersion(saved.configVersion);
   let config = { ...saved };
   const applied: string[] = [];
@@ -102,7 +94,7 @@ export function migrateSavedConfig(saved: Record<string, unknown>, dataDir: stri
   for (const migration of CONFIG_MIGRATIONS) {
     if (migration.toVersion > CURRENT_CONFIG_VERSION || version >= migration.toVersion) continue;
     config = {
-      ...migration.migrate(config, dataDir),
+      ...migration.migrate(config, dataDir, host),
       configVersion: migration.toVersion,
     };
     version = migration.toVersion;
@@ -116,10 +108,6 @@ function savedConfigVersion(value: unknown): number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
 }
 
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
 function stringList(value: unknown): string[] {
   return Array.isArray(value)
     ? [...new Set(value.filter((entry): entry is string => typeof entry === "string"))]
@@ -127,7 +115,7 @@ function stringList(value: unknown): string[] {
 }
 
 function pluginConfigMap(value: unknown): Record<string, Record<string, unknown>> {
-  if (!isPlainRecord(value) || !Object.values(value).every(isPlainRecord)) return {};
+  if (!isRecord(value) || !Object.values(value).every(isRecord)) return {};
   return Object.fromEntries(
     Object.entries(value).map(([pluginId, state]) => [
       pluginId,
@@ -154,11 +142,11 @@ function migrateUnreachablePaneInstances(
   const layout = sanitizeLayout(saved.layout, defaults.layout);
   const layouts = Array.isArray(saved.layouts)
     ? saved.layouts.map((entry) => {
-      if (!isPlainRecord(entry) || typeof entry.name !== "string") return entry;
+      if (!isRecord(entry) || typeof entry.name !== "string") return entry;
       const entryLayout = sanitizeLayout(entry.layout, layout);
       const instanceIds = new Set(entryLayout.instances.map((instance) => instance.instanceId));
       const placedIds = new Set(getPlacedPaneInstanceIds(entryLayout));
-      const paneState = isPlainRecord(entry.paneState)
+      const paneState = isRecord(entry.paneState)
         ? Object.fromEntries(Object.entries(entry.paneState).filter(([instanceId]) => instanceIds.has(instanceId)))
         : entry.paneState;
       const focusedPaneId = typeof entry.focusedPaneId === "string" && !placedIds.has(entry.focusedPaneId)
@@ -180,108 +168,52 @@ function migrateUnreachablePaneInstances(
   };
 }
 
-function migrateCloudDefault(saved: Record<string, unknown>): Record<string, unknown> {
-  return {
-    ...saved,
-    disabledPlugins: stringList(saved.disabledPlugins)
-      .filter((pluginId) => pluginId !== "gloomberb-cloud"),
-  };
-}
-
-function migrateCloudMacroAndSources(saved: Record<string, unknown>): Record<string, unknown> {
-  const disabledPlugins = stringList(saved.disabledPlugins);
-  if (disabledPlugins.includes("gloomberb-cloud") && !disabledPlugins.includes("macro")) {
-    disabledPlugins.push("macro");
-  }
-  const disabledSources = new Set(stringList(saved.disabledSources));
-  for (const pluginId of disabledPlugins) {
-    if (BUILTIN_SOURCE_IDS.has(pluginId)) disabledSources.add(pluginId);
-  }
-  return {
-    ...saved,
-    disabledPlugins,
-    disabledSources: [...disabledSources],
-  };
-}
-
-function hasExactColumnIds(value: unknown, expected: string[]): boolean {
-  return Array.isArray(value)
-    && value.length === expected.length
-    && value.every((entry, index) => entry === expected[index]);
-}
-
-function shouldMigratePortfolioColumnIds(value: unknown): boolean {
-  return hasExactColumnIds(value, LEGACY_MAIN_PORTFOLIO_COLUMN_IDS)
-    || hasExactColumnIds(value, PRE_SPARKLINE_PORTFOLIO_COLUMN_IDS)
-    || hasExactColumnIds(value, PRE_DAY_PNL_PORTFOLIO_COLUMN_IDS);
-}
-
-function migratePortfolioColumnsInLayout(value: unknown): unknown {
-  if (!isPlainRecord(value) || !Array.isArray(value.instances)) return value;
-  let changed = false;
-  const instances = value.instances.map((instance) => {
-    if (!isPlainRecord(instance) || instance.paneId !== "portfolio-list" || !isPlainRecord(instance.settings)) {
-      return instance;
-    }
-    if (!shouldMigratePortfolioColumnIds(instance.settings.columnIds)) return instance;
-    changed = true;
+// Market Heatmap, Market Halts and Fear & Greed were Market Overview modules,
+// and the IPO Calendar a Macro one, so switching the owner off switched them
+// off, and the seeder kept them off when they moved out by not installing
+// them. Built in again under their own ids, they would come back on. A copy
+// installed since means the user wants it. Removing a restored copy is not
+// taken as switching it off: that config looks the same as a fresh install
+// that never had one, which should get the built-in. The web bundled them
+// whatever their owner said and has no plugins folder, so it decides nothing
+// itself, but disabledPlugins syncs, so a signed-in web session follows what
+// was kept off here.
+//
+// An older build saving this config writes its own configVersion back, which
+// would run this again after the user switched one on. So each plugin is
+// decided once, recorded as `absorbed:<id>` in seededPlugins: older builds
+// keep that list as they found it, and it stays on this machine. A plugin
+// absorbed later needs a migration of its own, since a config already past
+// this one's version never runs it again.
+function keepAbsorbedPluginsOff(ownerId: string, pluginIds: readonly string[]): ConfigMigration["migrate"] {
+  return (saved, _dataDir, host) => {
+    const hasCheckout = host.hasPluginCheckout;
+    if (!hasCheckout) return saved;
+    const seededPlugins = stringList(saved.seededPlugins);
+    const undecided = pluginIds.filter((pluginId) => !seededPlugins.includes(`absorbed:${pluginId}`));
+    if (undecided.length === 0) return saved;
+    const disabledPlugins = stringList(saved.disabledPlugins);
+    const keptOff = disabledPlugins.includes(ownerId)
+      ? undecided.filter((pluginId) => !hasCheckout(pluginId))
+      : [];
     return {
-      ...instance,
-      settings: {
-        ...instance.settings,
-        columnIds: [...DEFAULT_PORTFOLIO_COLUMN_IDS],
-      },
+      ...saved,
+      ...(keptOff.length > 0 ? { disabledPlugins: [...new Set([...disabledPlugins, ...keptOff])] } : {}),
+      seededPlugins: [...seededPlugins, ...undecided.map((pluginId) => `absorbed:${pluginId}`)],
     };
-  });
-  return changed ? { ...value, instances } : value;
+  };
 }
 
-function migratePortfolioDefaultColumns(saved: Record<string, unknown>): Record<string, unknown> {
+// v0.5 shipped with Gloom Cloud in disabledPlugins by default, so without this
+// those installs would upgrade onto the delayed fallback with Cloud switched off.
+function migrateCloudDefault(saved: Record<string, unknown>): Record<string, unknown> {
   return {
     ...saved,
-    layout: migratePortfolioColumnsInLayout(saved.layout),
-    layouts: Array.isArray(saved.layouts)
-      ? saved.layouts.map((entry) => isPlainRecord(entry)
-        ? { ...entry, layout: migratePortfolioColumnsInLayout(entry.layout) }
-        : entry)
-      : saved.layouts,
+    disabledPlugins: stringList(saved.disabledPlugins)
+      .filter((pluginId) => pluginId !== "gloomberb-cloud"),
   };
 }
 
-function sanitizeSerializableValue(value: unknown): unknown {
-  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value
-      .map((entry) => sanitizeSerializableValue(entry))
-      .filter((entry) => entry !== undefined);
-  }
-  if (isPlainRecord(value)) {
-    return Object.fromEntries(
-      Object.entries(value)
-        .map(([key, entry]) => [key, sanitizeSerializableValue(entry)])
-        .filter(([, entry]) => entry !== undefined),
-    );
-  }
-  return undefined;
-}
-
-function migrationPaneState(
-  value: unknown,
-  layout: LayoutConfig,
-): Record<string, Record<string, unknown>> | undefined {
-  if (!isPlainRecord(value)) return undefined;
-  const validPaneIds = new Set(layout.instances.map((instance) => instance.instanceId));
-  const paneState = Object.fromEntries(
-    Object.entries(value)
-      .filter(([paneId, entry]) => validPaneIds.has(paneId) && isPlainRecord(entry))
-      .map(([paneId, entry]) => [paneId, sanitizeSerializableValue(entry)])
-      .filter((entry): entry is [string, Record<string, unknown>] => isPlainRecord(entry[1])),
-  );
-  return normalizeBuiltinPaneStatePluginOwners(paneState);
-}
-
 function legacyRenderMode(value: unknown): LegacyChartMigrationContext["defaultRenderMode"] {
   return value === "area"
     || value === "line"
@@ -299,9 +231,10 @@ function migrateSavedLayouts(
 ): unknown {
   if (!Array.isArray(value)) return value;
   return value.map((entry) => {
-    if (!isPlainRecord(entry) || typeof entry.name !== "string") return entry;
+    if (!isRecord(entry) || typeof entry.name !== "string") return entry;
     const layout = sanitizeLayout(entry.layout, fallbackLayout, chartMigration);
-    const paneState = migrationPaneState(entry.paneState, layout);
+    const sanitized = sanitizeSavedPaneState(entry.paneState, layout);
+    const paneState = sanitized && normalizeBuiltinPaneStatePluginOwners(sanitized);
     const migrated = migrateLegacyChartSavedPaneState(layout, paneState, entry.layout);
     return {
       ...entry,
@@ -317,7 +250,7 @@ function migrateBuiltinOwnershipAndChartState(
 ): Record<string, unknown> {
   const defaults = createDefaultConfig(dataDir);
   const normalizedPluginConfig = normalizeBuiltinPluginStateMap(pluginConfigMap(saved.pluginConfig));
-  const chartPreferences = isPlainRecord(saved.chartPreferences) ? saved.chartPreferences : {};
+  const chartPreferences = isRecord(saved.chartPreferences) ? saved.chartPreferences : {};
   const chartMigration: LegacyChartMigrationContext = {
     migrateLegacy: true,
     defaultRenderMode: legacyRenderMode(chartPreferences.defaultRenderMode),

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

@@ -1,11 +1,13 @@
-import { existsSync } from "fs";
+import { existsSync, readdirSync, type Dirent } from "fs";
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
 import { dirname, join } from "path";
 import { expandUserHome, getGloomberbHome, isGloomberbHomeOverridden } from "../home";
 import type { AppConfig } from "../../../types/config";
 import { createDefaultConfig } from "../../../types/config";
 import { debugLog } from "../../../utils/debug-log";
+import { findAbsorbedCheckout, isDirectoryOrLink, isPluginDirectory } from "../../../plugins/loader";
 import { EXTRACTED_PLUGINS } from "../../../plugins/seed";
+import type { ConfigMigrationHost } from "./migrations";
 import {
   normalizeConfigForSave,
   normalizeLoadedConfig,
@@ -39,6 +41,30 @@ export async function getDataDir(): Promise<string | null> {
   }
 }
 
+/**
+ * Whether the plugins folder holds a copy of a plugin that is built in now,
+ * under its own folder name or another whose gloom.json claims the id. Only a
+ * one-time migration asks, so no ordinary load reads the folder. The home is
+ * resolved per call, so a test can point it away from the real plugins.
+ */
+function hasAbsorbedPluginCheckout(pluginId: string): boolean {
+  const pluginsDir = join(getGloomberbHome(), "plugins");
+  let entries: Dirent[];
+  try {
+    entries = readdirSync(pluginsDir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  return entries.some((entry) => {
+    const pluginDir = join(pluginsDir, entry.name);
+    return isPluginDirectory(entry.name)
+      && isDirectoryOrLink(entry, pluginDir)
+      && findAbsorbedCheckout(pluginDir)?.id === pluginId;
+  });
+}
+
+const migrationHost: ConfigMigrationHost = { hasPluginCheckout: hasAbsorbedPluginCheckout };
+
 export async function loadConfig(dataDir: string): Promise<AppConfig> {
   const { config } = await loadConfigState(dataDir);
   return config;
@@ -50,7 +76,7 @@ async function loadConfigState(dataDir: string): Promise<{ config: AppConfig; ne
   try {
     const raw = await readFile(configPath, "utf-8");
     const saved = JSON.parse(raw) as Record<string, unknown>;
-    const state = normalizeLoadedConfig(saved, dataDir);
+    const state = normalizeLoadedConfig(saved, dataDir, migrationHost);
     // A config.json that names a different directory than the one it sits in
     // came along with a moved folder. Record where it lives now, so the next
     // launch reads it directly instead of through the missing-path fallback.
@@ -103,7 +129,7 @@ export async function exportConfig(config: AppConfig, destPath: string): Promise
 export async function importConfig(dataDir: string, srcPath: string): Promise<AppConfig> {
   const raw = await readFile(expandHomePath(srcPath), "utf-8");
   const saved = JSON.parse(raw) as Record<string, unknown>;
-  const { config } = normalizeLoadedConfig(saved, dataDir);
+  const { config } = normalizeLoadedConfig(saved, dataDir, migrationHost);
   await saveConfig(config);
   return config;
 }

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

@@ -7,6 +7,7 @@ import type {
   OnboardingProgress,
   LayoutOrigin,
   SavedLayout,
+  TelemetryConfig,
 } from "../../../types/config";
 import {
   cloneLayout,
@@ -18,11 +19,17 @@ import type { Portfolio, Watchlist } from "../../../types/ticker";
 import { isLanguagePreference } from "../../../i18n/languages";
 import { clampFontSize } from "../../../theme/font-scale";
 import { isLayoutConfig, sanitizeLayout } from "../layout";
-import { migrateSavedConfig } from "./migrations";
-
-export function normalizeLoadedConfig(saved: Record<string, unknown>, dataDir: string): { config: AppConfig; needsSave: boolean } {
+import { migrateSavedConfig, type ConfigMigrationHost } from "./migrations";
+import { sanitizeSavedPaneState } from "./pane-state";
+import { isRecord } from "../../../utils/guards";
+
+export function normalizeLoadedConfig(
+  saved: Record<string, unknown>,
+  dataDir: string,
+  host?: ConfigMigrationHost,
+): { config: AppConfig; needsSave: boolean } {
   const defaults = createDefaultConfig(dataDir);
-  const migration = migrateSavedConfig(saved, dataDir);
+  const migration = migrateSavedConfig(saved, dataDir, host);
   const candidate = migration.config;
   const directLayout = sanitizeLayout(candidate.layout, defaults.layout);
   const layouts = sanitizeSavedLayouts(candidate.layouts, directLayout);
@@ -67,6 +74,7 @@ export function normalizeLoadedConfig(saved: Record<string, unknown>, dataDir: s
     onboardingProgress,
     lastLaunchedVersion: typeof candidate.lastLaunchedVersion === "string" ? candidate.lastLaunchedVersion : undefined,
     ...withKeybindings(sanitizeKeybindings(candidate.keybindings)),
+    ...withTelemetry(sanitizeTelemetry(candidate.telemetry)),
   };
 
   const needsSave =
@@ -81,7 +89,7 @@ export function normalizeLoadedConfig(saved: Record<string, unknown>, dataDir: s
     || !isChartPreferences(candidate.chartPreferences)
     || (candidate.language !== undefined && !isLanguagePreference(candidate.language))
     || (candidate.onboardingProgress !== undefined && !sanitizeOnboardingProgress(candidate.onboardingProgress))
-    || (isPlainRecord(candidate.onboardingProgress) && candidate.onboardingProgress.stage === "open-security")
+    || (isRecord(candidate.onboardingProgress) && candidate.onboardingProgress.stage === "open-security")
     || (!!onboardingProgress && candidate.onboardingComplete !== false)
     || typeof candidate.valueFlashingEnabled !== "boolean"
     || typeof candidate.activeLayoutIndex !== "number";
@@ -124,6 +132,8 @@ export function normalizeConfigForSave(config: AppConfig): AppConfig {
   };
   delete persisted.keybindings;
   Object.assign(persisted, withKeybindings(sanitizeKeybindings(config.keybindings)));
+  delete persisted.telemetry;
+  Object.assign(persisted, withTelemetry(sanitizeTelemetry(config.telemetry)));
 
   return persisted;
 }
@@ -132,15 +142,29 @@ function withKeybindings(keybindings: KeybindingsConfig | undefined): Pick<AppCo
   return keybindings ? { keybindings } : {};
 }
 
+function withTelemetry(telemetry: TelemetryConfig | undefined): Pick<AppConfig, "telemetry"> {
+  return telemetry ? { telemetry } : {};
+}
+
+/** 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;
+  const telemetry: TelemetryConfig = {
+    ...(typeof value.crashReports === "boolean" ? { crashReports: value.crashReports } : {}),
+    ...(typeof value.usage === "boolean" ? { usage: value.usage } : {}),
+  };
+  return Object.keys(telemetry).length > 0 ? telemetry : undefined;
+}
+
 /**
  * Keeps the shape honest without judging the contents: a chord that does not
  * parse stays in the file and is reported when the table resolves, so a typo
  * is something the user can see and fix rather than something that vanishes.
  */
 function sanitizeKeybindings(value: unknown): KeybindingsConfig | undefined {
-  if (!isPlainRecord(value)) return undefined;
+  if (!isRecord(value)) return undefined;
   const actions: Record<string, string | string[] | null> = {};
-  if (isPlainRecord(value.actions)) {
+  if (isRecord(value.actions)) {
     for (const [actionId, binding] of Object.entries(value.actions)) {
       if (!actionId.trim()) continue;
       if (binding === null || typeof binding === "string") {
@@ -151,7 +175,7 @@ function sanitizeKeybindings(value: unknown): KeybindingsConfig | undefined {
     }
   }
   const commands: Record<string, string> = {};
-  if (isPlainRecord(value.commands)) {
+  if (isRecord(value.commands)) {
     for (const [chord, query] of Object.entries(value.commands)) {
       if (chord.trim() && typeof query === "string" && query.trim()) commands[chord] = query;
     }
@@ -182,7 +206,7 @@ const ONBOARDING_STAGES = new Set<OnboardingProgress["stage"]>([
 ]);
 
 function sanitizeOnboardingProgress(value: unknown): OnboardingProgress | undefined {
-  if (!isPlainRecord(value) || value.version !== 1) {
+  if (!isRecord(value) || value.version !== 1) {
     return undefined;
   }
   const stage = value.stage === "open-security" ? "account" : value.stage;
@@ -217,61 +241,9 @@ function sanitizeUniqueStringList(value: unknown): string[] {
   return [...new Set(sanitizeStringArray(value, []))];
 }
 
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-// Pane state is sanitized on every config write, and most of it is the same
-// objects as last time: the store replaces what changed and keeps the rest.
-// The result depends on nothing but the input, so it is kept per identity.
-const sanitizedValues = new WeakMap<object, unknown>();
-
-function sanitizeSerializableValue(value: unknown): unknown {
-  if (value == null) return value;
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value !== "object") return undefined;
-  if (sanitizedValues.has(value)) return sanitizedValues.get(value);
-  let sanitized: unknown;
-  if (Array.isArray(value)) {
-    sanitized = value
-      .map((entry) => sanitizeSerializableValue(entry))
-      .filter((entry) => entry !== undefined);
-  } else if (isPlainRecord(value)) {
-    sanitized = Object.fromEntries(
-      Object.entries(value)
-        .map(([key, entry]) => [key, sanitizeSerializableValue(entry)])
-        .filter(([, entry]) => entry !== undefined),
-    );
-  } else {
-    sanitized = undefined;
-  }
-  sanitizedValues.set(value, sanitized);
-  return sanitized;
-}
-
-function sanitizeSavedPaneState(
-  value: unknown,
-  layout: LayoutConfig,
-): Record<string, Record<string, unknown>> | undefined {
-  if (!isPlainRecord(value)) return undefined;
-  const validPaneIds = new Set(layout.instances.map((instance) => instance.instanceId));
-  const paneState = Object.fromEntries(
-    Object.entries(value)
-      .filter(([paneId, entry]) => validPaneIds.has(paneId) && isPlainRecord(entry))
-      .map(([paneId, entry]) => {
-        const sanitized = sanitizeSerializableValue(entry);
-        return [paneId, sanitized];
-      })
-      .filter((entry): entry is [string, Record<string, unknown>] => isPlainRecord(entry[1])),
-  );
-  return paneState;
-}
-
 function isPluginConfigMap(value: unknown): value is Record<string, Record<string, unknown>> {
-  if (!isPlainRecord(value)) return false;
-  return Object.values(value).every((entry) => isPlainRecord(entry));
+  if (!isRecord(value)) return false;
+  return Object.values(value).every((entry) => isRecord(entry));
 }
 
 function sanitizePluginConfig(value: unknown): Record<string, Record<string, unknown>> {

package/src/data/config/store/pane-state.ts

@@ -0,0 +1,47 @@
+import type { LayoutConfig } from "../../../types/config";
+import { isRecord } from "../../../utils/guards";
+
+// Pane state is sanitized on every config write, and most of it is the same
+// objects as last time: the store replaces what changed and keeps the rest.
+// The result depends on nothing but the input, so it is kept per identity.
+const sanitizedValues = new WeakMap<object, unknown>();
+
+function sanitizeSerializableValue(value: unknown): unknown {
+  if (value == null) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "object") return undefined;
+  if (sanitizedValues.has(value)) return sanitizedValues.get(value);
+  let sanitized: unknown;
+  if (Array.isArray(value)) {
+    sanitized = value
+      .map((entry) => sanitizeSerializableValue(entry))
+      .filter((entry) => entry !== undefined);
+  } else if (isRecord(value)) {
+    sanitized = Object.fromEntries(
+      Object.entries(value)
+        .map(([key, entry]) => [key, sanitizeSerializableValue(entry)])
+        .filter(([, entry]) => entry !== undefined),
+    );
+  } else {
+    sanitized = undefined;
+  }
+  sanitizedValues.set(value, sanitized);
+  return sanitized;
+}
+
+/** The JSON-safe state of the panes the layout still has, dropping everything else. */
+export function sanitizeSavedPaneState(
+  value: unknown,
+  layout: LayoutConfig,
+): Record<string, Record<string, unknown>> | undefined {
+  if (!isRecord(value)) return undefined;
+  const validPaneIds = new Set(layout.instances.map((instance) => instance.instanceId));
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([paneId, entry]) => validPaneIds.has(paneId) && isRecord(entry))
+      .map(([paneId, entry]) => [paneId, sanitizeSerializableValue(entry)])
+      .filter((entry): entry is [string, Record<string, unknown>] => isRecord(entry[1])),
+  );
+}

package/src/data/fred-series.ts

@@ -1,5 +1,6 @@
 import { createPluginCache } from "./plugin-cache";
 import { getPublishedUsEquityCalendarDay } from "../market-data/published-us-sessions";
+import { zonedDateKey } from "../utils/zoned-date-time";
 import type {
   CloudFredObservationPayload,
   CloudFredSeriesInfoPayload,
@@ -16,9 +17,6 @@ const CACHE_POLICY = {
 // Cloud re-reads a daily series this often until the last business day is published.
 const PUBLICATION_PENDING_REFRESH_MS = 30 * 60 * 1000;
 const DAY_MS = 86_400_000;
-const newYorkDate = new Intl.DateTimeFormat("en-CA", {
-  timeZone: "America/New_York", year: "numeric", month: "2-digit", day: "2-digit",
-});
 
 export interface FredSeriesData {
   observations: CloudFredObservationPayload[];
@@ -49,22 +47,15 @@ export interface FredSeriesLoadResult extends FredSeriesCacheEntry {
 const cache = createPluginCache<FredSeriesData>({
   kind: CACHE_KIND, source: CACHE_SOURCE, schemaVersion: CACHE_SCHEMA_VERSION, policy: CACHE_POLICY,
 });
-const hydratedSeries = new Map<string, FredSeriesCacheEntry>();
 export const attachFredSeriesPersistence = cache.attach;
 
-function seriesKey(seriesId: string): string {
-  return seriesId.trim().toUpperCase();
-}
-
-/** Hydrates server-fetched data for renderers that cannot call the cloud API directly. */
-export function hydrateFredSeries(entries: readonly (readonly [string, FredSeriesCacheEntry])[]): void {
-  hydratedSeries.clear();
-  for (const [seriesId, entry] of entries) hydratedSeries.set(seriesKey(seriesId), entry);
-}
-
 export function resetFredSeriesPersistence(): void {
   cache.reset();
-  hydratedSeries.clear();
+}
+
+/** The series' page on the FRED site, where its notes and release schedule live. */
+export function fredSeriesUrl(seriesId: string): string {
+  return `https://fred.stlouisfed.org/series/${seriesId}`;
 }
 
 function cacheKey(request: FredSeriesRequest): string {
@@ -116,7 +107,7 @@ export function isFredPublicationPending(
   const daily = recent.length >= 3 && recent.every((date, index) =>
     index === 0 || Date.parse(date) - Date.parse(recent[index - 1]!) <= 4 * DAY_MS);
   if (!daily) return false;
-  const today = Date.parse(`${newYorkDate.format(now)}T00:00:00Z`);
+  const today = Date.parse(`${zonedDateKey(now, "America/New_York")}T00:00:00Z`);
   if (!isUsBusinessDay(today)) return false;
   for (let offset = 1; offset <= 10; offset++) {
     const day = today - offset * DAY_MS;
@@ -134,8 +125,6 @@ export async function loadCachedFredSeries(
   const pending = !!stored && !stored.stale && isFredPublicationPending(stored.data.observations ?? [], stored.fetchedAt);
   const cached = stored ? withFredSourceFreshness(stored) : null;
   if (!options?.force && !pending && cached && !cached.stale) return { ...cached, source: "cache" };
-  const hydrated = hydratedSeries.get(seriesKey(request.seriesId));
-  if (!options?.force && hydrated) return { ...withFredSourceFreshness(hydrated), source: "cache" };
   const result = await cache.load(cacheKey(request), loader, pending ? { ...options, force: true } : options);
   // An early re-read is opportunistic: a failure keeps the still-fresh copy as it was.
   if (pending && result.refreshError && cached && !cached.stale && !options?.force) return { ...cached, source: "cache" };