gloomberb 0.13.2 → 0.14.0

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

@@ -67,12 +67,115 @@ function cloneRuntimeValue<T>(value: T): T {
   return value;
 }
 
+// The saved-layout mirror is rebuilt on every pane-state update, and pane
+// state is replaced, never edited, when it changes: a patch spreads the
+// top-level object and leaves untouched values (a cached article list, say)
+// with their identity. Cloning each object once per identity, at every
+// level, keeps the mirror a real copy while making the rebuild cost
+// proportional to what changed rather than to every pane in every layout.
+const runtimeValueClones = new WeakMap<object, unknown>();
+/** Clone to the object it was copied from, so a saved copy can be traced to live state. */
+const paneStateOrigins = new WeakMap<object, object>();
+
+function cloneRuntimeValueShared<T>(value: T): T {
+  if (!value || typeof value !== "object") return value;
+  const cached = runtimeValueClones.get(value);
+  if (cached !== undefined) return cached as T;
+  const clone = Array.isArray(value)
+    ? value.map((entry) => cloneRuntimeValueShared(entry))
+    : Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).map(([key, entry]) => [key, cloneRuntimeValueShared(entry)]),
+    );
+  runtimeValueClones.set(value, clone);
+  return clone as T;
+}
+
+function clonePaneState(paneState: Record<string, unknown>): PaneRuntimeState {
+  const cached = runtimeValueClones.get(paneState);
+  if (cached !== undefined) return cached as PaneRuntimeState;
+  const clone = cloneRuntimeValueShared(paneState) as PaneRuntimeState;
+  paneStateOrigins.set(clone, paneState);
+  return clone;
+}
+
+function descendsFrom(candidate: object, ancestor: object): boolean {
+  let current: object | undefined = candidate;
+  for (let depth = 0; current && depth < 4; depth += 1) {
+    if (current === ancestor) return true;
+    current = paneStateOrigins.get(current);
+  }
+  return false;
+}
+
+/**
+ * The pane state a config carries for its active layout, ready to merge over
+ * the live map. A saved entry that is a copy of the live entry (the usual case
+ * when a caller spreads the current config to change one field) yields the
+ * live object itself, so the merge does not hand every pane a new identity.
+ */
+export function restoreSavedPaneState(
+  config: AppConfig,
+  livePaneState: Record<string, PaneRuntimeState>,
+): Record<string, PaneRuntimeState> | null {
+  const saved = config.layouts[config.activeLayoutIndex]?.paneState;
+  if (!saved) return null;
+  return Object.fromEntries(Object.entries(saved).map(([paneId, entry]) => {
+    const live = livePaneState[paneId];
+    return [paneId, live && descendsFrom(entry, live) ? live : clonePaneState(entry)];
+  }));
+}
+
 export function clonePaneStateMap(previous: Record<string, Record<string, unknown>>): Record<string, PaneRuntimeState> {
   return Object.fromEntries(
-    Object.entries(previous).map(([paneId, paneState]) => [paneId, cloneRuntimeValue(paneState) as PaneRuntimeState]),
+    Object.entries(previous).map(([paneId, paneState]) => [paneId, clonePaneState(paneState)]),
   );
 }
 
+function shallowEqualRecords(left: Record<string, unknown>, right: Record<string, unknown>): boolean {
+  const leftKeys = Object.keys(left);
+  if (leftKeys.length !== Object.keys(right).length) return false;
+  return leftKeys.every((key) => Object.is(left[key], right[key]));
+}
+
+// Reconciling runs on every pane-state update for every pane in the layout.
+// A pane whose state object and defaults are unchanged gets the object it
+// got last time, so the clone behind it is paid once per state change.
+const reconciledPaneStates = new WeakMap<object, { defaults: PaneRuntimeState; result: PaneRuntimeState }>();
+const EMPTY_PANE_STATE: PaneRuntimeState = {};
+
+function reconcilePaneStateEntry(
+  config: AppConfig,
+  instance: LayoutConfig["instances"][number],
+  source: PaneRuntimeState,
+): PaneRuntimeState {
+  const defaults = defaultPaneStateForInstance(config, instance);
+  const cached = reconciledPaneStates.get(source);
+  const collectionId = (source.collectionId ?? defaults.collectionId) as string | undefined;
+  const resolvedCollectionId = instance.paneId === "portfolio-list"
+    && !isKnownCollection(config, collectionId)
+    && !shouldPreserveUnknownCollectionId(collectionId)
+    ? defaults.collectionId
+    : collectionId;
+  if (
+    cached
+    && shallowEqualRecords(cached.defaults, defaults)
+    && Object.is(cached.result.collectionId, resolvedCollectionId)
+  ) {
+    return cached.result;
+  }
+  // Nothing to add or fix: the live object is already the reconciled state.
+  // Handing it back keeps its identity, and with it every memo keyed on it.
+  const unchanged = Object.keys(defaults).every((key) => Object.prototype.hasOwnProperty.call(source, key))
+    && (instance.paneId !== "portfolio-list" || Object.is(source.collectionId, resolvedCollectionId));
+  if (unchanged) return source;
+  const result: PaneRuntimeState = { ...defaults, ...cloneRuntimeValue(source) };
+  if (instance.paneId === "portfolio-list") result.collectionId = resolvedCollectionId;
+  // Panes without state share one empty source; caching it would thrash
+  // between their different defaults for no saving.
+  if (source !== EMPTY_PANE_STATE) reconciledPaneStates.set(source, { defaults, result });
+  return result;
+}
+
 export function reconcilePaneState(
   config: AppConfig,
   previous: Record<string, PaneRuntimeState>,
@@ -80,16 +183,7 @@ export function reconcilePaneState(
 ): Record<string, PaneRuntimeState> {
   const next: Record<string, PaneRuntimeState> = {};
   for (const instance of layout.instances) {
-    const defaults = defaultPaneStateForInstance(config, instance);
-    const paneState = { ...defaults, ...cloneRuntimeValue(previous[instance.instanceId] ?? {}) };
-    if (
-      instance.paneId === "portfolio-list"
-      && !isKnownCollection(config, paneState.collectionId as string | undefined)
-      && !shouldPreserveUnknownCollectionId(paneState.collectionId as string | undefined)
-    ) {
-      paneState.collectionId = defaults.collectionId;
-    }
-    next[instance.instanceId] = paneState;
+    next[instance.instanceId] = reconcilePaneStateEntry(config, instance, previous[instance.instanceId] ?? EMPTY_PANE_STATE);
   }
   return next;
 }
@@ -186,12 +280,27 @@ export function nextRecentTickers(current: string[], symbol: string | null): str
   return next;
 }
 
+const savedLayoutClones = new WeakMap<SavedLayout, SavedLayout>();
+const layoutClones = new WeakMap<LayoutConfig, LayoutConfig>();
+
+function cloneLayoutOnce(layout: LayoutConfig): LayoutConfig {
+  const cached = layoutClones.get(layout);
+  if (cached) return cached;
+  const clone = cloneLayout(layout);
+  layoutClones.set(layout, clone);
+  return clone;
+}
+
 export function cloneSavedLayout(entry: SavedLayout): SavedLayout {
-  return {
+  const cached = savedLayoutClones.get(entry);
+  if (cached) return cached;
+  const clone = {
     ...entry,
-    layout: cloneLayout(entry.layout),
+    layout: cloneLayoutOnce(entry.layout),
     paneState: entry.paneState ? clonePaneStateMap(entry.paneState) : entry.paneState,
   };
+  savedLayoutClones.set(entry, clone);
+  return clone;
 }
 
 function buildSavedLayoutSnapshot(
@@ -203,13 +312,39 @@ function buildSavedLayoutSnapshot(
 ): SavedLayout {
   return {
     ...(entry ?? { name: "Default" }),
-    layout: cloneLayout(layout),
+    layout: cloneLayoutOnce(layout),
     paneState: clonePaneStateMap(paneState),
     focusedPaneId,
     activePanel,
   };
 }
 
+const SAVED_LAYOUT_MIRROR_KEYS = new Set<keyof SavedLayout>(["paneState", "focusedPaneId", "activePanel"]);
+
+/**
+ * True when two saved-layout lists differ only in what the active layout
+ * mirrors from live state (pane state, focus). Structural edits, renames, or
+ * reordering make this false.
+ */
+export function savedLayoutsDifferOnlyInMirror(
+  previous: readonly SavedLayout[],
+  next: readonly SavedLayout[],
+): boolean {
+  if (previous.length !== next.length) return false;
+  for (let index = 0; index < next.length; index += 1) {
+    const before = previous[index]!;
+    const after = next[index]!;
+    if (before === after) continue;
+    const beforeKeys = Object.keys(before) as Array<keyof SavedLayout>;
+    if (beforeKeys.length !== Object.keys(after).length) return false;
+    for (const key of beforeKeys) {
+      if (SAVED_LAYOUT_MIRROR_KEYS.has(key)) continue;
+      if (!Object.is(before[key], after[key])) return false;
+    }
+  }
+  return true;
+}
+
 export function syncConfigActiveLayoutState(
   config: AppConfig,
   paneState: Record<string, PaneRuntimeState>,
@@ -233,11 +368,6 @@ export function syncConfigActiveLayoutState(
   };
 }
 
-export function getActiveSavedPaneState(config: AppConfig): Record<string, PaneRuntimeState> | null {
-  const paneState = config.layouts[config.activeLayoutIndex]?.paneState;
-  return paneState ? clonePaneStateMap(paneState) : null;
-}
-
 const PANEL_RESOLUTION_BOUNDS = { x: 0, y: 0, width: 120, height: 40 };
 
 export function getPaneOrder(layout: LayoutConfig): string[] {

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

@@ -5,7 +5,7 @@ import {
   clearTickerBindings,
   clonePaneStateMap,
   focusPaneState,
-  getActiveSavedPaneState,
+  restoreSavedPaneState,
   getEffectiveThemeId,
   getFocusedCollectionId,
   getFocusedTickerSymbol,
@@ -47,7 +47,7 @@ export function appReducer(state: AppState, action: AppAction): AppState {
         {
           paneState: {
             ...state.paneState,
-            ...(getActiveSavedPaneState(action.config) ?? {}),
+            ...(restoreSavedPaneState(action.config, state.paneState) ?? {}),
           },
         },
       );

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

@@ -1,5 +1,5 @@
 import type { BrokerAccount } from "../../../types/trading";
-import type { AppConfig, LayoutConfig, OnboardingProgress } from "../../../types/config";
+import type { AppConfig, LayoutConfig, LayoutOrigin, OnboardingProgress } from "../../../types/config";
 import type { DesktopSharedStateSnapshot } from "../../../types/desktop-window";
 import type { Quote, TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
@@ -115,6 +115,19 @@ export type AppAction =
       name: string;
       layout: LayoutConfig;
       paneState: Record<string, PaneRuntimeState>;
+      /** Set when the tab is linked to a team layout. */
+      origin?: LayoutOrigin;
+    }
+  /** Links, relinks, or unlinks a saved tab. Null drops the link and keeps the content. */
+  | { type: "SET_LAYOUT_ORIGIN"; index: number; origin: LayoutOrigin | null }
+  /** Replaces a saved tab's content with a pulled revision. */
+  | {
+      type: "REPLACE_LAYOUT_CONTENT";
+      index: number;
+      layout: LayoutConfig;
+      paneState: Record<string, PaneRuntimeState>;
+      origin: LayoutOrigin;
+      name?: string;
     }
   | { type: "DELETE_LAYOUT"; index: number }
   | { type: "RENAME_LAYOUT"; index: number; name: string }

package/src/core/state/session-persistence.ts

@@ -4,6 +4,11 @@ import type { TickerRecord } from "../../types/ticker";
 import { getDockedPaneIds } from "../../plugins/pane-manager";
 import { normalizeBuiltinPaneStatePluginOwners } from "../../plugins/ownership";
 import { canonicalExchange, normalizeSymbol } from "../../utils/exchanges";
+import { instrumentFromTicker } from "../../market-data/request-types";
+import { buildInstrumentKey } from "../../market-data/selectors";
+import { hasAmbiguousTickerContracts, resolveInstrumentForPane } from "./app/instrument";
+import { resolveCollectionForPane } from "./app/layout";
+import type { AppState } from "./app/types";
 
 export const APP_SESSION_SCHEMA_VERSION = 1;
 export const APP_SESSION_ID = "app";
@@ -49,40 +54,7 @@ function normalizeHydrationTarget(target: HydrationTarget): HydrationTarget {
 }
 
 function hydrationTargetKey(target: HydrationTarget): string {
-  const normalized = normalizeHydrationTarget(target);
-  const contractKey = normalized.instrument?.conId
-    ?? normalized.instrument?.localSymbol
-    ?? normalized.instrument?.symbol
-    ?? "";
-  return [
-    normalized.symbol,
-    normalized.exchange ?? "",
-    normalized.brokerId ?? "",
-    normalized.brokerInstanceId ?? "",
-    contractKey,
-  ].join("|");
-}
-
-function targetFromTicker(ticker: TickerRecord): HydrationTarget {
-  const instrument = ticker.metadata.broker_contracts?.[0] ?? null;
-  return normalizeHydrationTarget({
-    symbol: ticker.metadata.ticker,
-    exchange: ticker.metadata.exchange,
-    brokerId: instrument?.brokerId,
-    brokerInstanceId: instrument?.brokerInstanceId,
-    instrument,
-  });
-}
-
-function resolvePortfolioPaneCollectionId(
-  config: AppConfig,
-  paneState: Record<string, unknown> | undefined,
-  instance: AppConfig["layout"]["instances"][number],
-): string | null {
-  const stateCollectionId = typeof paneState?.collectionId === "string" ? paneState.collectionId : null;
-  if (stateCollectionId) return stateCollectionId;
-  if (typeof instance.params?.collectionId === "string") return instance.params.collectionId;
-  return config.portfolios[0]?.id ?? config.watchlists[0]?.id ?? null;
+  return buildInstrumentKey(normalizeHydrationTarget(target));
 }
 
 function tickerInCollection(ticker: TickerRecord, collectionId: string | null): boolean {
@@ -100,9 +72,10 @@ export function buildAppSessionSnapshot(state: SessionStateInput): AppSessionSna
       .filter(Boolean),
   )];
 
-  const pushTarget = (ticker: TickerRecord | null | undefined) => {
-    if (!ticker) return;
-    const target = targetFromTicker(ticker);
+  const pushTarget = (input: HydrationTarget | null | undefined) => {
+    if (!input) return;
+    const target = normalizeHydrationTarget(input);
+    if (!state.tickers.has(target.symbol)) return;
     const key = hydrationTargetKey(target);
     if (seen.has(key)) return;
     seen.add(key);
@@ -110,23 +83,20 @@ export function buildAppSessionSnapshot(state: SessionStateInput): AppSessionSna
   };
 
   for (const symbol of state.recentTickers) {
-    pushTarget(state.tickers.get(symbol));
+    const ticker = state.tickers.get(symbol);
+    if (ticker && !hasAmbiguousTickerContracts(ticker)) pushTarget(instrumentFromTicker(ticker));
   }
 
   for (const instance of state.config.layout.instances) {
-    const paneState = state.paneState[instance.instanceId];
-    const cursorSymbol = typeof paneState?.cursorSymbol === "string" ? paneState.cursorSymbol : null;
-    if (cursorSymbol) {
-      pushTarget(state.tickers.get(cursorSymbol));
-    }
-    if (instance.binding?.kind === "fixed") {
-      pushTarget(state.tickers.get(instance.binding.symbol));
-    }
+    pushTarget(resolveInstrumentForPane(state, instance.instanceId));
     if (instance.paneId === "portfolio-list") {
-      const collectionId = resolvePortfolioPaneCollectionId(state.config, paneState, instance);
+      const collectionId = resolveCollectionForPane(state as AppState, instance.instanceId);
       for (const ticker of state.tickers.values()) {
         if (tickerInCollection(ticker, collectionId)) {
-          pushTarget(ticker);
+          pushTarget(resolveInstrumentForPane({ ...state, paneState: {
+            ...state.paneState,
+            [instance.instanceId]: { ...state.paneState[instance.instanceId], cursorSymbol: ticker.metadata.ticker },
+          } }, instance.instanceId));
         }
       }
     }

package/src/data/cached-query.test.ts

@@ -0,0 +1,95 @@
+import { expect, test } from "bun:test";
+import { CachedQuery, type CachedValue } from "./cached-query";
+
+const value = (name: string, time = Date.now()): CachedValue<string> => ({
+  value: name, fetchedAt: time, staleAt: time + 600_000, expiresAt: time + 3_600_000, source: "test",
+});
+
+test("hydration, cache reads and failed refreshes retain successful response identity", async () => {
+  const seeded = value("hydrated");
+  let calls = 0;
+  let fail = false;
+  const query = new CachedQuery({ read: () => seeded, fetch: async () => {
+    calls++;
+    if (fail) throw new Error("offline");
+    return value(`response-${calls}`, seeded.fetchedAt);
+  } });
+  expect(await query.load()).toBe(seeded);
+  expect(calls).toBe(0);
+  expect(seeded.responseSequence).toBeUndefined();
+  const first = await query.load({ force: true });
+  expect(first.responseSequence).toBeGreaterThan(0);
+  expect(await query.load()).toBe(first);
+  fail = true;
+  const refresh = query.load({ force: true });
+  expect(query.getSnapshot().result).toBe(first);
+  expect(query.getSnapshot().loading).toBe(true);
+  const retained = await refresh;
+  expect(retained.responseSequence).toBe(first.responseSequence);
+  expect(query.getSnapshot().result).toBe(retained);
+  expect(retained).toMatchObject({ ...first, refreshError: expect.any(Error) });
+  expect(await query.load()).toBe(retained);
+  expect(query.getSnapshot().error).toBeInstanceOf(Error);
+  fail = false;
+  const recovered = await query.load({ force: true });
+  expect(recovered.fetchedAt).toBe(first.fetchedAt);
+  expect(recovered.responseSequence).toBeGreaterThan(first.responseSequence!);
+  expect(query.getSnapshot().error).toBeNull();
+  expect(recovered.refreshError).toBeUndefined();
+  expect(await query.load()).toBe(recovered);
+});
+
+test("failed cache reads keep their error without mutating hydrated or independent query data", async () => {
+  const seeded = value("hydrated");
+  const query = new CachedQuery({ read: () => seeded, fetch: async () => { throw new Error("offline"); } });
+  const independent = new CachedQuery({ read: () => seeded });
+  await query.load({ force: true });
+  expect((await query.load()).refreshError).toBeInstanceOf(Error);
+  expect((await independent.load()).refreshError).toBeUndefined();
+  expect(seeded.refreshError).toBeUndefined();
+  const reopened = new CachedQuery({ read: () => seeded });
+  expect(await reopened.load()).toBe(seeded);
+});
+
+test("expired fallbacks retain source age and a superseded failure cannot restore an old error", async () => {
+  const expired = value("expired", Date.now() - 10_000_000);
+  let calls = 0;
+  const query = new CachedQuery({ read: (allowExpired) => allowExpired ? expired : null, fetch: async () => {
+    calls++;
+    throw new Error("offline");
+  } });
+  const fallback = await query.load();
+  expect(fallback).toMatchObject({ fetchedAt: expired.fetchedAt, expiresAt: expired.expiresAt, refreshError: expect.any(Error) });
+  await query.load();
+  expect(calls).toBe(2);
+  let rejectOld!: (error: Error) => void;
+  const old = query.load({ force: true, fetch: () => new Promise((_, reject) => { rejectOld = reject; }) });
+  await Promise.resolve();
+  const current = await query.load({ force: true, replace: true, fetch: async () => value("recovered") });
+  rejectOld(new Error("late obsolete failure"));
+  await old;
+  expect(await query.load()).toBe(current);
+  expect(query.getSnapshot().error).toBeNull();
+  expect(current.refreshError).toBeUndefined();
+});
+
+test("cross-query order follows accepted completion, excluding superseded and disposed results", async () => {
+  const pending: Array<(result: CachedValue<string>) => void> = [];
+  const query = new CachedQuery({ read: () => null, fetch: () => new Promise<CachedValue<string>>((resolve) => pending.push(resolve)) });
+  const first = query.load(); await Promise.resolve();
+  const replacement = query.load({ force: true, replace: true }); await Promise.resolve();
+  const time = Date.now();
+  pending[1]!(value("accepted", time));
+  const accepted = await replacement;
+  pending[0]!(value("superseded", time));
+  expect((await first).responseSequence).toBeUndefined();
+  expect(query.getSnapshot().result).toBe(accepted);
+  const disposedRequest = query.load({ force: true }); await Promise.resolve();
+  query.dispose(); pending[2]!(value("disposed", time));
+  expect((await disposedRequest).responseSequence).toBeUndefined();
+  expect(query.getSnapshot().result).toBe(accepted);
+  const peer = new CachedQuery({ read: () => null, fetch: async () => value("peer", time) });
+  const later = await peer.load();
+  expect(later.fetchedAt).toBe(accepted.fetchedAt);
+  expect(later.responseSequence).toBe(accepted.responseSequence! + 1);
+});

package/src/data/cached-query.ts

@@ -0,0 +1,106 @@
+import { nextResponseSequence } from "./response-sequence";
+
+/** A value's age belongs to its source, not to the consumer that last read it. */
+export interface CachedValue<T> {
+  value: T;
+  fetchedAt: number;
+  /** Process-local successful response order; absent on unsequenced hydrated cache. */
+  responseSequence?: number;
+  staleAt: number;
+  expiresAt: number;
+  source: string;
+  /** Source observation time, when supplied; fetchedAt remains retrieval time. */
+  asOf?: number;
+  refreshError?: unknown;
+}
+
+export interface CachedQueryState<T> {
+  result: CachedValue<T> | null;
+  loading: boolean;
+  error: unknown;
+}
+
+export interface CachedQueryHandle<T> {
+  getSnapshot(): CachedQueryState<T>;
+  subscribe(listener: () => void): () => void;
+  load(options?: { force?: boolean; background?: boolean; replace?: boolean }): Promise<CachedValue<T>>;
+}
+
+/** Owns freshness, concurrent requests, stale fallback, and refresh notification. */
+export class CachedQuery<T> implements CachedQueryHandle<T> {
+  private state: CachedQueryState<T>;
+  private readonly listeners = new Set<() => void>();
+  private active: Promise<CachedValue<T>> | null = null;
+  private generation = 0;
+
+  constructor(private readonly options: {
+    read: (allowExpired: boolean) => CachedValue<T> | null;
+    fetch?: (force: boolean) => Promise<CachedValue<T>>;
+    acceptCached?: (value: T) => boolean;
+    /** Optional source-age/identity limit that also applies to stale fallback. */
+    acceptResult?: (result: CachedValue<T>) => boolean;
+  }) {
+    this.state = { result: options.read(false), loading: false, error: null };
+  }
+
+  getSnapshot = (): CachedQueryState<T> => {
+    if (this.state.result && !this.usable(this.state.result)) this.state = { ...this.state, result: null };
+    return this.state;
+  };
+
+  private usable(result: CachedValue<T> | null): CachedValue<T> | null {
+    return result && (this.options.acceptResult?.(result) ?? true) ? result : null;
+  }
+
+  subscribe = (listener: () => void): (() => void) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+
+  private publish(state: CachedQueryState<T>): void {
+    this.state = state;
+    for (const listener of this.listeners) listener();
+  }
+
+  dispose(): void {
+    this.generation += 1;
+    this.active = null;
+    this.listeners.clear();
+  }
+
+  load({ force = false, background = false, replace = false, fetch = this.options.fetch }: {
+    force?: boolean;
+    background?: boolean;
+    replace?: boolean;
+    fetch?: (force: boolean) => Promise<CachedValue<T>>;
+  } = {}): Promise<CachedValue<T>> {
+    const cached = this.usable(this.state.result) ?? this.usable(this.options.read(false));
+    const acceptable = cached && (this.options.acceptCached?.(cached.value) ?? true);
+    if (!force && acceptable && cached.staleAt > Date.now()) return Promise.resolve(cached);
+    if (!this.active || replace) {
+      if (!fetch) return Promise.reject(new Error("A cache miss requires a loader"));
+      const generation = ++this.generation;
+      this.publish({ result: cached, loading: true, error: null });
+      const request = Promise.resolve().then(() => fetch(force)).then((result) => {
+        if (generation !== this.generation) return result;
+        const accepted = { ...result, responseSequence: nextResponseSequence() };
+        this.publish({ result: accepted, loading: false, error: null });
+        return accepted;
+      }, (error: unknown) => {
+        const fallback = this.usable(cached) ?? this.usable(this.options.read(true));
+        const retained = fallback ? { ...fallback, refreshError: error } : null;
+        if (generation === this.generation) this.publish({ result: retained, loading: false, error });
+        if (retained) return retained;
+        throw error;
+      }).finally(() => {
+        if (this.active === request) this.active = null;
+      });
+      this.active = request;
+    }
+    if (!force && acceptable && cached.expiresAt > Date.now() && background) {
+      void this.active.catch(() => {});
+      return Promise.resolve(cached);
+    }
+    return this.active;
+  }
+}

package/src/data/config/layout.ts

@@ -6,6 +6,7 @@ import type {
   PaneInstanceConfig,
   PanePlacementMemory,
 } from "../../types/config";
+import type { BrokerContractRef, TickerListingRef } from "../../types/instrument";
 import {
   cloneLayout,
   clonePaneSettings,
@@ -31,7 +32,13 @@ export function isLayoutConfig(value: unknown): value is LayoutConfig {
 function sanitizePaneBinding(value: unknown, fallback: PaneBinding = { kind: "none" }): PaneBinding {
   if (!value || typeof value !== "object") return fallback;
   if ((value as PaneBinding).kind === "fixed" && typeof (value as Extract<PaneBinding, { kind: "fixed" }>).symbol === "string") {
-    return { kind: "fixed", symbol: (value as Extract<PaneBinding, { kind: "fixed" }>).symbol };
+    const binding = value as Extract<PaneBinding, { kind: "fixed" }>;
+    const instrument = sanitizeBoundInstrument(binding.instrument);
+    const listing = sanitizeBoundListing(binding.listing);
+    return { kind: "fixed", symbol: binding.symbol,
+      ...(instrument !== undefined ? { instrument } : {}),
+      ...(listing ? { listing } : {}),
+    };
   }
   if ((value as PaneBinding).kind === "follow" && typeof (value as Extract<PaneBinding, { kind: "follow" }>).sourceInstanceId === "string") {
     return { kind: "follow", sourceInstanceId: (value as Extract<PaneBinding, { kind: "follow" }>).sourceInstanceId };
@@ -40,6 +47,32 @@ function sanitizePaneBinding(value: unknown, fallback: PaneBinding = { kind: "no
   return fallback;
 }
 
+function sanitizeBoundInstrument(value: unknown): BrokerContractRef | null | undefined {
+  if (value === null) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const raw = value as Record<string, unknown>;
+  if (typeof raw.brokerId !== "string" || !raw.brokerId.trim()
+    || typeof raw.symbol !== "string" || !raw.symbol.trim()) return undefined;
+  const result: BrokerContractRef = { brokerId: raw.brokerId, symbol: raw.symbol };
+  for (const key of ["brokerInstanceId", "localSymbol", "secType", "exchange", "primaryExchange", "currency",
+    "lastTradeDateOrContractMonth", "multiplier", "tradingClass"] as const) {
+    if (typeof raw[key] === "string") result[key] = raw[key];
+  }
+  if (typeof raw.conId === "number" && Number.isSafeInteger(raw.conId) && raw.conId > 0) result.conId = raw.conId;
+  if (typeof raw.strike === "number" && Number.isFinite(raw.strike)) result.strike = raw.strike;
+  if (raw.right === "C" || raw.right === "P") result.right = raw.right;
+  return result;
+}
+
+function sanitizeBoundListing(value: unknown): TickerListingRef | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const raw = value as Record<string, unknown>;
+  if (typeof raw.name !== "string" || typeof raw.exchange !== "string" || typeof raw.type !== "string") return undefined;
+  return { name: raw.name, exchange: raw.exchange, type: raw.type,
+    ...(typeof raw.currency === "string" ? { currency: raw.currency } : {}),
+  };
+}
+
 function sanitizeFloatingPlacementMemory(value: unknown): FloatingPlacementMemory | undefined {
   if (!value || typeof value !== "object") return undefined;
   const x = typeof (value as FloatingPlacementMemory).x === "number" ? Math.max(0, Math.round((value as FloatingPlacementMemory).x)) : null;
@@ -155,6 +188,7 @@ function sanitizePaneInstances(
           : undefined,
         settings: migrateChartPaneSettings(originalPaneId, binding, settings, chartMigration),
         placementMemory: sanitizePlacementMemory(entry.placementMemory),
+        locked: entry.locked === true ? true : undefined,
       };
     });
   return instances;