gloomberb 0.13.2 → 0.14.0

package/src/market-data/coordinator/fx-refresh.test.ts

@@ -0,0 +1,61 @@
+import { expect, test } from "bun:test";
+import { AssetDataRouter } from "../../sources/provider-router";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import type { ExchangeRateSnapshot } from "../../types/exchange-rate";
+import { MarketDataCoordinator } from "./index";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>(done => { resolve = done; });
+  return { promise, resolve };
+}
+
+for (const cachedRouter of [false, true]) {
+  test(`FX refresh bypasses fresh ${cachedRouter ? "router" : "direct"} cache, shares requests and preserves failed-source age`, async () => {
+    const firstTime = Date.now() - 60_000;
+    const snapshot = (rate: number, asOf: number): ExchangeRateSnapshot => ({
+      rate, fromCurrency: "EUR", toCurrency: "USD", source: "controlled-fx",
+      asOf: new Date(asOf).toISOString(), fetchedAt: new Date(asOf).toISOString(),
+      staleAt: new Date(asOf + 3_600_000).toISOString(), stale: false,
+    });
+    const pending = deferred<ExchangeRateSnapshot>();
+    let calls = 0;
+    let fail = false;
+    const provider = createTestDataProvider({
+      id: "controlled-fx",
+      getExchangeRateSnapshot: async currency => {
+        expect(currency).toBe("EUR");
+        calls++;
+        if (fail) throw new Error("source offline");
+        return calls === 1 ? snapshot(1.1, firstTime) : pending.promise;
+      },
+    });
+    const coordinator = new MarketDataCoordinator(cachedRouter ? new AssetDataRouter(provider) : provider);
+    try {
+      expect((await coordinator.loadFxRate("EUR")).data).toBe(1.1);
+      expect((await coordinator.loadFxRate("EUR")).data).toBe(1.1);
+      expect((await coordinator.loadFxRate("USD", { forceRefresh: true })).data).toBe(1);
+      expect(calls).toBe(1);
+
+      const firstRefresh = coordinator.loadFxRate("EUR", { forceRefresh: true });
+      const secondRefresh = coordinator.loadFxRate("EUR", { forceRefresh: true });
+      await new Promise(resolve => setTimeout(resolve, 0));
+      expect(calls).toBe(2);
+      const secondTime = firstTime + 30_000;
+      pending.resolve(snapshot(1.2, secondTime));
+      expect((await firstRefresh).data).toBe(1.2);
+      expect((await secondRefresh).data).toBe(1.2);
+      expect(coordinator.getFxEntry("EUR").asOf).toBe(secondTime);
+
+      fail = true;
+      const failed = await coordinator.loadFxRate("EUR", { forceRefresh: true });
+      expect(failed.data ?? failed.lastGoodData).toBe(1.2);
+      expect(failed.asOf).toBe(secondTime);
+      expect(failed.fetchedAt).toBe(secondTime);
+      expect(failed.error).not.toBeNull();
+      expect(calls).toBe(3);
+    } finally {
+      coordinator.destroy();
+    }
+  });
+}

package/src/market-data/coordinator/index.test.ts

@@ -1,3 +1,4 @@
+import { useRegularMarketSession } from "../../test-support/market-session";
 import { describe, expect, it } from "bun:test";
 import { MarketDataCoordinator } from "./index";
 import type { DataProvider, QuoteSubscriptionTarget } from "../../types/data-provider";
@@ -6,6 +7,8 @@ import type { PricePoint, Quote, TickerFinancials } from "../../types/financials
 import type { NewsArticle } from "../../news/types";
 import { createTestDataProvider } from "../../test-support/data-provider";
 
+useRegularMarketSession();
+
 type CoordinatorTestProviderOverrides = Partial<DataProvider> & {
   getNews?: (query: {
     feed: "ticker";
@@ -154,6 +157,28 @@ describe("MarketDataCoordinator", () => {
     expect(calls).toBe(0);
   });
 
+  it("retries a recently retrieved stale FX rate without changing its source time on failure", async () => {
+    const now = Date.now();
+    let calls = 0;
+    const provider = createProvider({
+      getExchangeRateSnapshot: async () => {
+        if (++calls > 1) throw new Error("rate provider offline");
+        return { fromCurrency: "EUR", toCurrency: "USD", rate: 1.16, source: "yahoo",
+          asOf: new Date(now - 7_200_000).toISOString(), fetchedAt: new Date(now).toISOString(),
+          staleAt: new Date(now - 3_600_000).toISOString(), stale: true };
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const first = await coordinator.loadFxRate("EUR");
+    const retry = await coordinator.loadFxRate("EUR");
+    expect(calls).toBe(2);
+    expect(first.asOf).toBe(now - 7_200_000);
+    expect(retry.lastGoodData).toBe(1.16);
+    expect(retry.asOf).toBe(first.asOf);
+    expect(retry.fetchedAt).toBe(first.fetchedAt);
+    expect(retry.error?.message).toContain("offline");
+  });
+
   it("reuses fresh empty tab query results instead of refetching on reopen", async () => {
     let optionsCalls = 0;
     const provider = createProvider({

package/src/market-data/coordinator/index.ts

@@ -1,8 +1,9 @@
-import type { DataProvider, SecFilingDocument, SecFilingItem } from "../../types/data-provider";
+import type { CachedAssetArgs, CachedAssetMethod, CachedAssetValue, DataProvider, SecFilingDocument, SecFilingItem } from "../../types/data-provider";
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
 import type { ChartRequest, InstrumentRef, OptionsRequest, SecFilingsRequest } from "../request-types";
 import { QueryStore } from "../query-store";
 import type { QueryEntry } from "../result-types";
+import type { CachedQueryHandle } from "../../data/cached-query";
 import {
   buildArticleSummaryKey,
   buildChartKey,
@@ -19,7 +20,7 @@ import {
 } from "../selectors";
 import { resolveTickerFinancialsQuoteState } from "../quotes/resolution";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
-import { normalizePriceHistory } from "../../utils/price-history";
+import { hasUsablePriceHistory, normalizePriceHistory } from "../../utils/price-history";
 import {
   createBaselineChartRequest,
   createChartLoadingEntry,
@@ -34,6 +35,7 @@ import {
   errorEntry,
   hasFreshEntryData,
   readyEntry,
+  readyChartEntry,
   readyQuoteEntry,
 } from "./entries";
 import {
@@ -59,17 +61,22 @@ import {
   type QuoteSubscriptionRequest,
 } from "./quotes";
 
+// A store hands out a fresh idle entry for every key it has never seen, so
+// two idle reads of the same key must count as the same entry.
+function sameQueryEntry<T>(left: QueryEntry<T>, right: QueryEntry<T>): boolean {
+  return left === right || (left.phase === "idle" && right.phase === "idle" && left.data === null && right.data === null);
+}
+
 export class MarketDataCoordinator {
   private readonly events = new MarketDataCoordinatorEvents();
   private readonly inFlight = new Map<string, Promise<unknown>>();
   private readonly chartRequests = new Map<string, ChartRequest>();
   private readonly quoteSubscriptionManager: QuoteSubscriptionManager;
+  private destroyed = false;
+  private readonly cachedQueries = new Map<string, { query: CachedQueryHandle<unknown>; dispose: () => void }>();
 
   private readonly quoteStore = new QueryStore<Quote>((key) => this.events.bump(key));
   private readonly snapshotStore = new QueryStore<TickerFinancials>((key) => this.events.bump(key));
-  private readonly profileStore = new QueryStore<TickerFinancials["profile"]>((key) => this.events.bump(key));
-  private readonly fundamentalsStore = new QueryStore<TickerFinancials["fundamentals"]>((key) => this.events.bump(key));
-  private readonly statementsStore = new QueryStore<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>((key) => this.events.bump(key));
   private readonly chartStore = new QueryStore<PricePoint[]>((key) => this.events.bump(key));
   private readonly optionsStore = new QueryStore<OptionsChain>((key) => this.events.bump(key));
   private readonly secFilingsStore = new QueryStore<SecFilingItem[]>((key) => this.events.bump(key));
@@ -80,9 +87,6 @@ export class MarketDataCoordinator {
   private readonly financialCacheStores: FinancialCacheStores = {
     quoteStore: this.quoteStore,
     snapshotStore: this.snapshotStore,
-    profileStore: this.profileStore,
-    fundamentalsStore: this.fundamentalsStore,
-    statementsStore: this.statementsStore,
     chartStore: this.chartStore,
   };
 
@@ -145,12 +149,36 @@ export class MarketDataCoordinator {
     return this.fxStore.get(buildFxKey(currency));
   }
 
+  /**
+   * Building the merged view re-normalizes the whole price history, and every
+   * consumer asks for it on every render. The result is kept per instrument
+   * until one of the three store entries is replaced, so callers also get a
+   * stable identity to memoize on.
+   */
+  private readonly financialsSnapshotCache = new Map<string, {
+    snapshotEntry: QueryEntry<TickerFinancials>;
+    quoteEntry: QueryEntry<Quote>;
+    chartEntry: QueryEntry<PricePoint[]>;
+    financials: TickerFinancials | null;
+  }>();
+
   getTickerFinancialsSync(instrument: InstrumentRef): TickerFinancials | null {
-    return buildTickerFinancialsSnapshot(
-      this.getSnapshotEntry(instrument),
-      this.getQuoteEntry(instrument),
-      this.getChartEntry(createBaselineChartRequest(instrument)),
-    );
+    const key = buildSnapshotKey(instrument);
+    const snapshotEntry = this.getSnapshotEntry(instrument);
+    const quoteEntry = this.getQuoteEntry(instrument);
+    const chartEntry = this.getChartEntry(createBaselineChartRequest(instrument));
+    const cached = this.financialsSnapshotCache.get(key);
+    if (
+      cached
+      && sameQueryEntry(cached.snapshotEntry, snapshotEntry)
+      && sameQueryEntry(cached.quoteEntry, quoteEntry)
+      && sameQueryEntry(cached.chartEntry, chartEntry)
+    ) {
+      return cached.financials;
+    }
+    const financials = buildTickerFinancialsSnapshot(snapshotEntry, quoteEntry, chartEntry);
+    this.financialsSnapshotCache.set(key, { snapshotEntry, quoteEntry, chartEntry, financials });
+    return financials;
   }
 
   primeCachedFinancials(entries: Array<{ instrument: InstrumentRef; financials: TickerFinancials }>): void {
@@ -165,6 +193,23 @@ export class MarketDataCoordinator {
     void this.loadChart(createBaselineChartRequest(instrument)).catch(() => {});
   }
 
+  /**
+   * Loads only what the caches lack for an instrument. Rows the user is about
+   * to land on should have something to show; whether that something is
+   * stale is for the pane that shows it to decide, so a warm-up never issues
+   * a refresh of data that is already there.
+   */
+  warmTickerGaps(instrument: InstrumentRef | null | undefined): void {
+    if (!instrument) return;
+    if (resolveEntryData(this.getSnapshotEntry(instrument)) == null) {
+      void this.loadSnapshot(instrument).catch(() => {});
+    }
+    const chartRequest = createBaselineChartRequest(instrument);
+    if (resolveEntryData(this.getChartEntry(chartRequest)) == null) {
+      void this.loadChart(chartRequest).catch(() => {});
+    }
+  }
+
   private runSingleFlight<T>(key: string, task: () => Promise<T>): Promise<T> {
     const existing = this.inFlight.get(key);
     if (existing) {
@@ -242,7 +287,7 @@ export class MarketDataCoordinator {
     if (!options.forceRefresh && currentData.length > 0 && hasFreshEntryData(current, CHART_CACHE_TTL_MS)) {
       if (currentData !== resolveEntryData(current)) {
         return this.chartStore.update(key, (entry) =>
-          readyEntry(entry, currentData, entry.source ?? this.dataProvider.id, entry.attempts, { keepLastGoodOnEmpty: true })
+          readyChartEntry(entry, currentData, entry.source ?? this.dataProvider.id, entry.attempts)
         );
       }
       return current;
@@ -293,9 +338,9 @@ export class MarketDataCoordinator {
               },
             ),
         );
-        const status = data.length > 0 ? "success" : "empty";
-        const attempts = [createAttempt(this.dataProvider.id, startedAt, status, data.length === 0 ? "NO_DATA" : undefined)];
-        return this.chartStore.update(key, (current) => readyEntry(current, data.length > 0 ? data : null, this.dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+        const status = hasUsablePriceHistory(data) ? "success" : "empty";
+        const attempts = [createAttempt(this.dataProvider.id, startedAt, status, status === "empty" ? "NO_DATA" : undefined)];
+        return this.chartStore.update(key, (current) => readyChartEntry(current, data.length > 0 ? data : null, this.dataProvider.id, attempts));
       } catch (error) {
         const classified = classifyError(error);
         const attempt = createAttempt(this.dataProvider.id, startedAt, EXPECTED_EMPTY.test(classified.message) ? "empty" : "fatal_error", classified.reasonCode, classified.message);
@@ -308,7 +353,7 @@ export class MarketDataCoordinator {
     request: OptionsRequest,
     options: { forceRefresh?: boolean } = {},
   ): Promise<QueryEntry<OptionsChain>> {
-    return loadOptionsEntry({
+    return this.loadCachedQuery("getOptionsChain", [request.instrument.symbol, request.instrument.exchange, request.expirationDate, toMarketDataContext(request.instrument)], buildOptionsKey(request), this.optionsStore, options.forceRefresh, (value) => value.expirationDates.length === 0) ?? loadOptionsEntry({
       dataProvider: this.dataProvider,
       forceRefresh: options.forceRefresh,
       request,
@@ -317,8 +362,9 @@ export class MarketDataCoordinator {
     });
   }
 
-  async loadSecFilings(request: SecFilingsRequest): Promise<QueryEntry<SecFilingItem[]>> {
-    return loadSecFilingsEntry({
+  async loadSecFilings(request: SecFilingsRequest, options: { forceRefresh?: boolean } = {}): Promise<QueryEntry<SecFilingItem[]>> {
+    return this.loadCachedQuery("getSecFilings", [request.instrument.symbol, request.count ?? 50, request.instrument.exchange, toMarketDataContext(request.instrument)], buildSecFilingsKey(request), this.secFilingsStore, options.forceRefresh, (value) => value.length === 0) ?? loadSecFilingsEntry({
+      forceRefresh: options.forceRefresh,
       dataProvider: this.dataProvider,
       request,
       store: this.secFilingsStore,
@@ -326,8 +372,9 @@ export class MarketDataCoordinator {
     });
   }
 
-  async loadSecFilingContent(filing: SecFilingItem): Promise<QueryEntry<string | null>> {
-    return loadSecFilingContentEntry({
+  async loadSecFilingContent(filing: SecFilingItem, options: { forceRefresh?: boolean } = {}): Promise<QueryEntry<string | null>> {
+    return this.loadCachedQuery("getSecFilingContent", [filing], buildSecContentKey(filing.accessionNumber), this.secContentStore, options.forceRefresh) ?? loadSecFilingContentEntry({
+      forceRefresh: options.forceRefresh,
       dataProvider: this.dataProvider,
       filing,
       store: this.secContentStore,
@@ -335,8 +382,9 @@ export class MarketDataCoordinator {
     });
   }
 
-  async loadSecFilingDocuments(filing: SecFilingItem): Promise<QueryEntry<SecFilingDocument[]>> {
-    return loadSecFilingDocumentsEntry({
+  async loadSecFilingDocuments(filing: SecFilingItem, options: { forceRefresh?: boolean } = {}): Promise<QueryEntry<SecFilingDocument[]>> {
+    return this.loadCachedQuery("getSecFilingDocuments", [filing], buildSecDocumentsKey(filing.accessionNumber), this.secDocumentsStore, options.forceRefresh, (value) => value.length === 0) ?? loadSecFilingDocumentsEntry({
+      forceRefresh: options.forceRefresh,
       dataProvider: this.dataProvider,
       filing,
       store: this.secDocumentsStore,
@@ -345,7 +393,7 @@ export class MarketDataCoordinator {
   }
 
   async loadArticleSummary(url: string): Promise<QueryEntry<string | null>> {
-    return loadArticleSummaryEntry({
+    return this.loadCachedQuery("getArticleSummary", [url], buildArticleSummaryKey(url), this.articleSummaryStore) ?? loadArticleSummaryEntry({
       dataProvider: this.dataProvider,
       url,
       store: this.articleSummaryStore,
@@ -353,15 +401,69 @@ export class MarketDataCoordinator {
     });
   }
 
-  async loadFxRate(currency: string): Promise<QueryEntry<number>> {
-    return loadFxRateEntry({
+  async loadFxRate(currency: string, options: { forceRefresh?: boolean } = {}): Promise<QueryEntry<number>> {
+    return this.loadCachedQuery("getExchangeRate", [currency], buildFxKey(currency), this.fxStore, options.forceRefresh) ?? loadFxRateEntry({
       dataProvider: this.dataProvider,
       currency,
+      forceRefresh: options.forceRefresh,
       store: this.fxStore,
       runSingleFlight: (key, task) => this.runSingleFlight(key, task),
     });
   }
 
+  /** QueryStore is only a renderer projection here; the provider owns age and refreshes. */
+  private loadCachedQuery<K extends CachedAssetMethod>(
+    method: K,
+    args: CachedAssetArgs<K>,
+    key: string,
+    store: QueryStore<CachedAssetValue<K>>,
+    force = false,
+    isEmpty: (value: CachedAssetValue<K>) => boolean = (value) => value == null,
+  ): Promise<QueryEntry<CachedAssetValue<K>>> | undefined {
+    if (this.destroyed) return Promise.resolve(store.get(key));
+    const query = this.dataProvider.getCachedQuery?.(method, args);
+    if (!query) return undefined;
+    const update = () => {
+      const { result, loading, error } = query.getSnapshot();
+      const current = store.get(key);
+      const empty = result != null && isEmpty(result.value);
+      // An empty options catalogue is itself a successful observation. Retain
+      // it through errors so old expirations cannot return via lastGoodData.
+      const value = result && (!empty || method === "getOptionsChain") ? result.value : null;
+      const classified = error ? classifyError(error) : null;
+      store.set(key, {
+        phase: loading ? (result ? "refreshing" : "loading") : result ? "ready" : "error",
+        data: value,
+        // FX query ownership includes the maximum source age. A null result
+        // means there is no valid conversion fallback left to project.
+        lastGoodData: value ?? (method === "getExchangeRate" ? null : current.lastGoodData),
+        source: result?.source ?? null,
+        fetchedAt: result?.fetchedAt ?? null,
+        responseSequence: result?.responseSequence,
+        asOf: result?.asOf,
+        staleAt: result?.staleAt ?? null,
+        error: classified ?? (!loading && empty ? { reasonCode: "NO_DATA", message: "No data available" } : null),
+        attempts: result ? [createAttempt(result.source, result.fetchedAt, error ? "fatal_error" : empty ? "empty" : "success", classified?.reasonCode, classified?.message)] : [],
+      });
+    };
+    const existing = this.cachedQueries.get(key);
+    if (existing?.query !== query) {
+      existing?.dispose();
+      this.cachedQueries.set(key, { query, dispose: query.subscribe(update) });
+      update();
+    }
+    return query.load({ force, background: true }).then(
+      () => { if (this.cachedQueries.get(key)?.query === query) update(); return store.get(key); },
+      () => store.get(key),
+    );
+  }
+
+  destroy(): void {
+    this.destroyed = true;
+    for (const { dispose } of this.cachedQueries.values()) dispose();
+    this.cachedQueries.clear();
+  }
+
   subscribeQuotes(targets: QuoteSubscriptionRequest[]): QuoteSubscriptionHandle {
     return this.quoteSubscriptionManager.subscribe(targets);
   }

package/src/market-data/coordinator/quotes.ts

@@ -56,6 +56,7 @@ const STREAM_QUOTE_FIELDS: Array<keyof Quote> = [
   "change",
   "changePercent",
   "previousClose",
+  "changeSessionDate",
   "high52w",
   "low52w",
   "marketCap",

package/src/market-data/coordinator/subscriptions.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, jest, test } from "bun:test";
 import { MarketDataCoordinator } from "./index";
+import { MARKET_DATA_NOTIFY_THROTTLE_MS } from "./events";
 import { buildQuoteKey } from "../selectors";
 import { QUOTE_STREAM_UPDATE_THROTTLE_MS } from "../quotes/cadence";
 import { createTestDataProvider } from "../../test-support/data-provider";
@@ -49,6 +50,12 @@ async function flushCoordinator(): Promise<void> {
   await new Promise((resolve) => setTimeout(resolve, 0));
 }
 
+/** Waits out the notify throttle too, so consecutive stream ticks each reach listeners. */
+async function flushCoordinatorNotify(): Promise<void> {
+  await Promise.resolve();
+  await new Promise((resolve) => setTimeout(resolve, MARKET_DATA_NOTIFY_THROTTLE_MS + 10));
+}
+
 describe("MarketDataCoordinator key subscriptions", () => {
   test("subscribes active quote targets as one provider batch", () => {
     const subscriptions: QuoteSubscriptionTarget[][] = [];
@@ -433,11 +440,11 @@ describe("MarketDataCoordinator key subscriptions", () => {
 
       Date.now = () => firstTimestamp;
       emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp }));
-      await flushCoordinator();
+      await flushCoordinatorNotify();
 
       Date.now = () => firstTimestamp + 10_000;
       emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp + 10_000 }));
-      await flushCoordinator();
+      await flushCoordinatorNotify();
 
       expect(calls).toBe(2);
       expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp + 10_000);
@@ -445,7 +452,7 @@ describe("MarketDataCoordinator key subscriptions", () => {
 
       Date.now = () => firstTimestamp + 20_000;
       emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 101, { lastUpdated: firstTimestamp + 10_000 }));
-      await flushCoordinator();
+      await flushCoordinatorNotify();
 
       expect(calls).toBe(3);
       expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(101);
@@ -479,11 +486,11 @@ describe("MarketDataCoordinator key subscriptions", () => {
         stale: false,
       });
       emitQuote(option, heartbeat);
-      await flushCoordinator();
+      await flushCoordinatorNotify();
 
       Date.now = () => firstTimestamp + 60_000;
       emitQuote(option, heartbeat);
-      await flushCoordinator();
+      await flushCoordinatorNotify();
 
       expect(calls).toBe(2);
       expect(coordinator.getQuoteEntry(option).data).toMatchObject({

package/src/market-data/hooks.tsx

@@ -12,6 +12,7 @@ import {
 import type { QueryEntry } from "./result-types";
 import {
   buildArticleSummaryKey,
+  buildInstrumentKey,
   buildChartKey,
   buildFxKey,
   buildOptionsKey,
@@ -82,15 +83,7 @@ function stableCurrencyList(currencies: Array<string | null | undefined>): strin
 function buildTickerFinancialsMapKey(tickers: TickerRecord[], options: TickerInstrumentOptions = {}): string {
   return tickers.map((ticker) => {
     const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, options);
-    return [
-      ticker.metadata.ticker,
-      ticker.metadata.exchange ?? "",
-      instrument?.brokerId ?? "",
-      instrument?.brokerInstanceId ?? "",
-      instrument?.instrument?.conId ?? "",
-      instrument?.instrument?.localSymbol ?? "",
-      instrument?.instrument?.symbol ?? "",
-    ].join("|");
+    return instrument ? buildSnapshotKey(instrument) : `unresolved:${ticker.metadata.ticker}`;
   }).join("::");
 }
 
@@ -100,6 +93,7 @@ function useTickerInstrument(symbol: string | null | undefined, ticker: TickerRe
 
 export function useTickerFinancials(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): TickerFinancials | null {
   const instrument = useTickerInstrument(symbol, ticker);
+  const instrumentKey = instrument ? buildInstrumentKey(instrument) : null;
   const keys = useMemo(() => (
     instrument
       ? [
@@ -108,7 +102,7 @@ export function useTickerFinancials(symbol: string | null | undefined, ticker: T
         buildChartKey(createBaselineChartRequest(instrument)),
       ]
       : []
-  ), [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
+  ), [instrumentKey]);
   useCoordinatorKeysVersion(keys);
   const coordinator = getSharedMarketDataCoordinator();
   const financials = coordinator && instrument
@@ -122,7 +116,7 @@ export function useTickerFinancials(symbol: string | null | undefined, ticker: T
       void coordinator.loadSnapshot(instrument).catch(() => {});
     }, TICKER_FINANCIALS_LOAD_DELAY_MS);
     return () => clearTimeout(timeoutId);
-  }, [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
+  }, [instrumentKey]);
 
   return financials;
 }
@@ -168,9 +162,10 @@ export function useTickerFinancialsMap(
 
 export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): QueryEntry<Quote> | null {
   const instrument = useTickerInstrument(symbol, ticker);
+  const instrumentKey = instrument ? buildInstrumentKey(instrument) : null;
   const keys = useMemo(
     () => (instrument ? [buildQuoteKey(instrument)] : []),
-    [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol],
+    [instrumentKey],
   );
   useCoordinatorKeysVersion(keys);
   const coordinator = getSharedMarketDataCoordinator();
@@ -180,7 +175,7 @@ export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerR
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator || !instrument) return;
     void coordinator.loadQuote(instrument).catch(() => {});
-  }, [instrument?.brokerId, instrument?.brokerInstanceId, instrument?.exchange, instrument?.instrument?.conId, instrument?.symbol]);
+  }, [instrumentKey]);
 
   return entry;
 }

package/src/market-data/legacy-contract-hooks.test.tsx

@@ -0,0 +1,49 @@
+import { afterEach, expect, test } from "bun:test";
+import { act, useState } from "react";
+import { testRender } from "../renderers/opentui/test-utils";
+import { useQuoteStreaming } from "../state/hooks/quote-streaming";
+import { createTestDataProvider } from "../test-support/data-provider";
+import type { TickerRecord } from "../types/ticker";
+import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "./coordinator";
+import { useQuoteEntry, useTickerFinancials, useTickerFinancialsMap } from "./hooks";
+import { quoteSubscriptionTargetFromTicker } from "./request-types";
+
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+let coordinator: MarketDataCoordinator | undefined;
+afterEach(async () => {
+  if (setup) await act(async () => setup!.renderer.destroy());
+  setup = undefined; coordinator?.destroy(); coordinator = undefined; setSharedMarketDataCoordinator(null);
+  await new Promise(resolve => setTimeout(resolve, 260));
+});
+
+test.each([false, true])("hooks reload and resubscribe when a supplied definition changes; localSymbol=%s", async (hasLocalSymbol) => {
+  const ticker = (strike: number): TickerRecord => ({ metadata: {
+    ticker: "ACME", exchange: "NASDAQ", name: "ACME", currency: "USD", portfolios: ["p"], watchlists: [], tags: [], custom: {},
+    positions: [{ portfolio: "p", shares: 1, broker: "fixture", brokerInstanceId: "feed" }],
+    broker_contracts: [{ brokerId: "fixture", brokerInstanceId: "feed", symbol: "ACME", localSymbol: hasLocalSymbol ? "LEGACY" : undefined, secType: "OPT", currency: "USD", lastTradeDateOrContractMonth: "20261016", right: "C", strike, multiplier: "100" }],
+  } });
+  const quote = (strike: number) => ({ symbol: "ACME", currency: "USD", price: strike / 10, change: 0, changePercent: 0, lastUpdated: Date.now() });
+  const snapshots: number[] = []; const subscriptions: number[][] = [];
+  coordinator = new MarketDataCoordinator(createTestDataProvider({
+    getQuote: async (_s, _e, context) => quote(context!.instrument!.strike!),
+    getTickerFinancials: async (_s, _e, context) => { const strike = context!.instrument!.strike!; snapshots.push(strike); return { quote: quote(strike), annualStatements: [], quarterlyStatements: [], priceHistory: [] }; },
+    subscribeQuotes: targets => { subscriptions.push(targets.map(t => t.context!.instrument!.strike!)); return () => {}; },
+  }));
+  setSharedMarketDataCoordinator(coordinator);
+  let replace: (ticker: TickerRecord) => void = () => {}; let observed: unknown;
+  function Harness() {
+    const [current, setCurrent] = useState(ticker(100)); replace = setCurrent;
+    const quoteEntry = useQuoteEntry("ACME", current);
+    const financials = useTickerFinancials("ACME", current);
+    const map = useTickerFinancialsMap([current], { portfolioId: "p" });
+    useQuoteStreaming([quoteSubscriptionTargetFromTicker(current)!]);
+    observed = [quoteEntry?.data?.price, financials?.quote?.price, map.get("ACME")?.quote?.price];
+    return <text>{JSON.stringify(observed)}</text>;
+  }
+  setup = await testRender(<Harness />, { width: 48, height: 2 });
+  const settle = async () => { await act(async () => { await new Promise(resolve => setTimeout(resolve, 280)); }); await act(async () => { await setup!.renderOnce(); }); };
+  await settle(); expect(observed).toEqual([10, 10, 10]);
+  await act(async () => replace(ticker(110))); await settle();
+  expect(observed).toEqual([11, 11, 11]); expect(snapshots).toEqual([100, 110]);
+  expect(subscriptions).toEqual([[100], [110]]);
+});