gloomberb 0.13.2 → 0.14.0

package/src/sources/provider-router/history.ts

@@ -1,3 +1,4 @@
+import { assertTradingPriceHistory, hasCircleOfferingPriceHistory } from "../listing-history";
 import type { BrokerCandidate } from "./brokers";
 import { withBrokerTimeout } from "./brokers";
 import type { DataProvider, MarketDataRequestContext } from "../../types/data-provider";
@@ -10,19 +11,21 @@ import {
   type ChartResolutionSupport,
   type ManualChartResolution,
 } from "../../time-series/resolution";
+import { subtractTimeRange } from "../../time-series/date-window";
 import { clipPriceHistoryToRange } from "../../time-series/history-window";
 import { repairIsolatedIntradayOhlcOutliers } from "../../time-series/history-quality";
-import { canonicalExchange } from "../../utils/exchanges";
+import { canonicalExchange, parsePublicTickerKey } from "../../utils/exchanges";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
-import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory } from "../../utils/price-history";
+import { getPricePointTimestamp, hasUsablePriceHistory, preservePriceHistoryGaps, isPriceHistoryStaleForCurrentWindow, normalizePriceHistory, priceHistoryIntervalMs } from "../../utils/price-history";
 import { shouldLogProviderError } from "../provider-errors";
+import { hasUnverifiedShellHistory, HistoryCoverageError } from "../history-coverage";
 import {
   buildVariantKey,
   compactDate,
   isCurrentHistoryWindow,
   isIntradayRange,
   isStaleIntradayHistory,
-  selectCachedArrayResource,
+  listCachedResources,
   type ProviderRouterCachePolicyKey,
 } from "./cache";
 import type { ProviderRouterCoreDeps, SourceResult } from "./route-types";
@@ -32,13 +35,15 @@ type PriceHistoryCachePolicyKey = Extract<
   ProviderRouterCachePolicyKey,
   "priceHistoryIntraday" | "priceHistoryDaily"
 >;
-const PRICE_HISTORY_CACHE_VERSION = 4;
-
+// Earlier cache records discarded dated unavailable closes.
+const PRICE_HISTORY_CACHE_VERSION = 5;
 interface HistoryRequestDescriptor {
+  target: { symbol: string; exchange: string };
   identity: RouterRequestIdentity;
   cacheVariantKeys: string[];
   exactCacheVariantKeys: string[];
   requestedRange?: TimeRange;
+  requestedStart: number;
   context?: MarketDataRequestContext;
   cachePolicyKey: PriceHistoryCachePolicyKey;
   missingProviderError?: string;
@@ -51,11 +56,30 @@ interface HistoryRequestDescriptor {
 function priceHistoryVariantParts(
   parts: Array<[string, string | number | undefined | null]>,
   exchange: string,
+  ticker: string,
 ): Array<[string, string | number | undefined | null]> {
   const unit = resolvePriceHistoryCurrencyUnit(null, exchange);
+  const target = parsePublicTickerKey(ticker);
+  const venue = target.exchange || canonicalExchange(exchange);
+  // Old cloud weekly/monthly JEPQ responses contained prices from 2013, before
+  // this fund existed. Refetch this exact US/bare identity after backend repair;
+  // neither broader cached windows nor saved detailed requests may reuse them.
+  const bar = parts.find(([key]) => key === "resolution" || key === "bar")?.[1];
+  const range = parts.find(([key]) => key === "range")?.[1];
+  const intraday = typeof bar === "string" ? /^\d+(m|min|h)$/.test(bar)
+    : typeof range === "string" && isIntradayRange(range as TimeRange);
+  const inceptionVersion = !intraday && target.symbol === "JEPQ" && (!venue || venue === "NASDAQ") ? 1 : undefined;
+  const monthly = bar === "1mo" || bar === "1month"
+    || (bar == null && parts.some(([key, value]) => key === "range" && value === "ALL"));
   const versionedParts: Array<[string, string | number | undefined | null]> = [
     ...parts,
     ["version", PRICE_HISTORY_CACHE_VERSION],
+    ["inception", inceptionVersion],
+    ["calendar", monthly ? 1 : undefined],
+    // Old Yahoo/cloud ALL responses could serve weekly/quarterly bars under
+    // a different requested interval. Exact and broader cache lookups must
+    // refetch these windows instead of relabeling the cached bars.
+    ["granularity", range === "ALL" ? 1 : undefined],
   ];
   return unit.divisor === 1
     ? versionedParts
@@ -72,18 +96,24 @@ function makeHistoryRequestIdentity(
     variantParts: Array<[string, string | number | undefined | null]>;
     fallbackVariantParts: Array<[string, string | number | undefined | null]>;
   },
-): Pick<HistoryRequestDescriptor, "identity" | "cacheVariantKeys" | "exactCacheVariantKeys"> {
+): Pick<HistoryRequestDescriptor, "identity" | "cacheVariantKeys" | "exactCacheVariantKeys" | "target"> {
   const identity = makeRouterRequestIdentity(deps, {
     kind: input.kind,
     ticker: input.ticker,
     context: input.context,
-    variantParts: priceHistoryVariantParts(input.variantParts, input.exchange),
+    variantParts: priceHistoryVariantParts(input.variantParts, input.exchange, input.ticker),
   });
   const cacheVariantKeys = [
     identity.variantKey,
-    buildVariantKey(priceHistoryVariantParts(input.fallbackVariantParts, input.exchange)),
-  ];
+    buildVariantKey(priceHistoryVariantParts(input.fallbackVariantParts, input.exchange, input.ticker)),
+  ].flatMap((key) => {
+    // Broker and independent-provider records did not use the affected Yahoo
+    // request. Keep their old keys readable, then filter by source below.
+    const legacy = key.replace(/;granularity=1(?=;|$)/, "");
+    return legacy === key ? [key] : [key, legacy];
+  });
   return {
+    target: { symbol: input.ticker, exchange: input.exchange },
     identity,
     cacheVariantKeys,
     exactCacheVariantKeys: cacheVariantKeys,
@@ -131,6 +161,28 @@ function normalizeRequestHistory(
     : normalized;
 }
 
+function mergeRequestHistoryGaps(
+  value: PricePoint[], unavailable: readonly PricePoint[][], range?: TimeRange,
+): PricePoint[] {
+  if (!range || range === "ALL") return preservePriceHistoryGaps(value, unavailable);
+  if (!hasUsablePriceHistory(value)) return clipPriceHistoryToRange(preservePriceHistoryGaps(value, unavailable), range);
+  // A broader cache cannot move the selected response's window or add older dates.
+  const end = value.reduce((latest, point) => Math.max(latest, getPricePointTimestamp(point)), Number.NEGATIVE_INFINITY);
+  if (!Number.isFinite(end)) return value;
+  const start = subtractTimeRange(new Date(end), range).getTime();
+  return preservePriceHistoryGaps(value, unavailable.map((points) => points.filter((point) => {
+    const time = getPricePointTimestamp(point);
+    return time >= start && time <= end;
+  })));
+}
+
+function historyCoverage(request: HistoryRequestDescriptor) {
+  return {
+    isUsable: (value: PricePoint[]) => hasUsablePriceHistory(value),
+    merge: (value: PricePoint[], unavailable: PricePoint[][]) => mergeRequestHistoryGaps(value, unavailable, request.requestedRange),
+  };
+}
+
 export class ProviderRouterHistoryRoutes {
   constructor(private readonly deps: ProviderRouterCoreDeps) {}
   private readonly historyRefreshInFlight = new Map<string, Promise<unknown>>();
@@ -154,6 +206,7 @@ export class ProviderRouterHistoryRoutes {
       ...identity,
       cacheVariantKeys: expandedHistoryCacheVariantKeys(this.deps, { ticker, exchange, context, range }),
       requestedRange: range,
+      requestedStart: subtractTimeRange(new Date(), range).getTime(),
       context,
       cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
       missingProviderError: `No history provider available for ${ticker}`,
@@ -192,6 +245,7 @@ export class ProviderRouterHistoryRoutes {
       fallbackVariantParts: [["range", bufferRange], ["resolution", resolution]],
     });
     const intraday = isIntradayResolution(resolution);
+    const intervalMs = priceHistoryIntervalMs(resolution);
     return this.executeHistoryRequest({
       ...identity,
       cacheVariantKeys: expandedHistoryCacheVariantKeys(this.deps, {
@@ -202,11 +256,12 @@ export class ProviderRouterHistoryRoutes {
         resolution,
       }),
       requestedRange: bufferRange,
+      requestedStart: subtractTimeRange(new Date(), bufferRange).getTime(),
       context,
       cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
       missingProviderError: `No resolution-aware history provider available for ${ticker}`,
-      isCachedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange),
-      isFetchedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange),
+      isCachedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange, intervalMs),
+      isFetchedValueStale: (value) => isStaleIntradayHistory(value, intraday, exchange, intervalMs),
       fetchBroker: async (candidate) => candidate.broker.getPriceHistoryForResolution
         ? candidate.broker.getPriceHistoryForResolution(
           ticker,
@@ -302,14 +357,16 @@ export class ProviderRouterHistoryRoutes {
       fallbackVariantParts: fallbackParts,
     });
     const currentWindowAtLookup = isCurrentHistoryWindow(endDate);
+    const intervalMs = priceHistoryIntervalMs(barSize);
     return this.executeHistoryRequest({
       ...identity,
+      requestedStart: startDate.getTime(),
       context,
-      cachePolicyKey: "priceHistoryIntraday",
+      cachePolicyKey: intervalMs != null && intervalMs >= 24 * 60 * 60 * 1000 ? "priceHistoryDaily" : "priceHistoryIntraday",
       isCachedValueStale: (value) => currentWindowAtLookup
-        && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange }),
+        && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange, intervalMs }),
       isFetchedValueStale: (value) => isCurrentHistoryWindow(endDate)
-        && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange }),
+        && isPriceHistoryStaleForCurrentWindow(value, Date.now(), { exchange, intervalMs }),
       fetchBroker: async (candidate) => candidate.broker.getDetailedPriceHistory
         ? candidate.broker.getDetailedPriceHistory(
           ticker,
@@ -333,49 +390,76 @@ export class ProviderRouterHistoryRoutes {
       ...brokerCandidates.map((candidate) => this.deps.brokerSourceKey(candidate)),
       ...this.deps.getProviderSourceKeys(),
     ];
-    const cached = selectCachedArrayResource<PricePoint>(
+    const cachedRecords = listCachedResources<PricePoint[]>(
       this.deps.resources,
       request.identity.kind,
       request.identity.entityKey,
       request.cacheVariantKeys,
       sourceKeys,
       false,
-    );
+    ).filter((record) => {
+      const unverifiedAllInterval = ["provider:yahoo", "provider:gloomberb-cloud"].includes(record.sourceKey)
+        && /(?:^|;)range=ALL(?:;|$)/.test(record.variantKey)
+        && !/(?:^|;)granularity=1(?:;|$)/.test(record.variantKey);
+      if (unverifiedAllInterval || hasCircleOfferingPriceHistory(record.value, request.target, record.sourceKey)) return false;
+      return request.cachePolicyKey === "priceHistoryIntraday"
+        || !hasUnverifiedShellHistory(record.value, request.target, record.sourceKey, request.requestedStart);
+    });
+    const cached = cachedRecords.find((record) => hasUsablePriceHistory(record.value)) ?? cachedRecords[0] ?? null;
     const cachedValue = cached ? normalizeRequestHistory(cached.value, request) : [];
+    const reportedGaps = cachedRecords.map((record) => normalizeRequestHistory(record.value, request))
+      .filter((value) => !hasUsablePriceHistory(value));
+    const withReportedGaps = (value: PricePoint[]) => mergeRequestHistoryGaps(value, reportedGaps, request.requestedRange);
     const cachedHistoryStale = request.isCachedValueStale(cachedValue);
     const forceRefresh = request.context?.cacheMode === "refresh";
-    const usableCached = cachedValue.length > 0 && cached && !cached.expired && !cachedHistoryStale;
+    const usableCached = hasUsablePriceHistory(cachedValue) && cached && !cached.expired && !cachedHistoryStale;
     if (usableCached && !forceRefresh) {
       const exactHit = request.exactCacheVariantKeys.includes(cached.variantKey);
-      if (cached.stale && exactHit) {
+      if (cached.stale) {
         scheduleRouterRevalidation(this.historyRefreshInFlight, request.identity.revalidationKey, () => this.refreshHistory(request));
       }
       return exactHit || !request.requestedRange
-        ? cachedValue
-        : clipPriceHistoryToRange(cachedValue, request.requestedRange);
+        ? withReportedGaps(cachedValue)
+        : clipPriceHistoryToRange(withReportedGaps(cachedValue), request.requestedRange);
     }
 
-    const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates));
-    if (brokerResult && brokerResult.value.length > 0) return brokerResult.value;
+    const supersededCacheSources = new Set<string>();
+    const onUnavailable = (sourceKey: string, value: PricePoint[]) => {
+      if (value.length && !hasUsablePriceHistory(value)) supersededCacheSources.add(sourceKey);
+    };
+    const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates, onUnavailable));
+    if (brokerResult && hasUsablePriceHistory(brokerResult.value)) return withReportedGaps(brokerResult.value);
+    if (brokerResult) reportedGaps.push(brokerResult.value);
 
-    const providerResult = await this.fetchProviderHistory(request);
-    if (providerResult && providerResult.value.length > 0) return providerResult.value;
-    if (cachedValue.length > 0 && !cachedHistoryStale) {
+    let coverageError: HistoryCoverageError | null = null;
+    const providerResult = await this.fetchProviderHistory(request, onUnavailable).catch((error: unknown) => {
+      if (!(error instanceof HistoryCoverageError)) throw error;
+      coverageError = error;
+      return null;
+    });
+    if (providerResult && hasUsablePriceHistory(providerResult.value)) return withReportedGaps(providerResult.value);
+    if (providerResult) reportedGaps.push(providerResult.value);
+    const fallbackValue = cachedRecords
+      .filter((record) => !supersededCacheSources.has(record.sourceKey))
+      .map((record) => normalizeRequestHistory(record.value, request))
+      .find((value) => hasUsablePriceHistory(value) && !request.isCachedValueStale(value));
+    if (fallbackValue) {
       return request.requestedRange
-        ? clipPriceHistoryToRange(cachedValue, request.requestedRange)
-        : cachedValue;
+        ? clipPriceHistoryToRange(withReportedGaps(fallbackValue), request.requestedRange)
+        : withReportedGaps(fallbackValue);
     }
-    if (!providerResult && request.missingProviderError) {
+    if (coverageError) throw coverageError;
+    if (!providerResult && request.missingProviderError && !reportedGaps.some((value) => value.length > 0)) {
       throw new Error(request.missingProviderError);
     }
-    return providerResult?.value ?? [];
+    return withReportedGaps(providerResult?.value ?? []);
   }
 
   private async refreshHistory(request: HistoryRequestDescriptor): Promise<void> {
     const brokerCandidates = this.deps.getBrokerCandidatesForContext(request.context, false);
     try {
       const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates));
-      if (brokerResult && brokerResult.value.length > 0) return;
+      if (brokerResult && hasUsablePriceHistory(brokerResult.value)) return;
       await this.fetchProviderHistory(request);
     } catch {
       // Background refresh is best-effort; callers already have cached points.
@@ -385,12 +469,14 @@ export class ProviderRouterHistoryRoutes {
   private fetchBrokerHistory(
     request: HistoryRequestDescriptor,
     candidates: BrokerCandidate[],
+    onUnavailable?: (sourceKey: string, value: PricePoint[]) => void,
   ): Promise<SourceResult<PricePoint[]> | null> {
     return this.firstBrokerResult(candidates, async (candidate) => {
       const fetched = await request.fetchBroker(candidate);
       if (fetched === null) return null;
       const value = normalizeRequestHistory(fetched, request);
-      if (request.isFetchedValueStale(value)) return null;
+      if (hasUsablePriceHistory(value) && request.isFetchedValueStale(value)) return null;
+      onUnavailable?.(this.deps.brokerSourceKey(candidate), value);
       this.deps.cacheResource(
         request.identity.kind,
         request.identity.entityKey,
@@ -400,15 +486,22 @@ export class ProviderRouterHistoryRoutes {
         this.deps.resolveBrokerPolicy(request.cachePolicyKey, candidate.broker),
       );
       return value;
-    });
+    }, historyCoverage(request));
   }
 
-  private fetchProviderHistory(request: HistoryRequestDescriptor): Promise<SourceResult<PricePoint[]> | null> {
+  private fetchProviderHistory(
+    request: HistoryRequestDescriptor,
+    onUnavailable?: (sourceKey: string, value: PricePoint[]) => void,
+  ): Promise<SourceResult<PricePoint[]> | null> {
     return this.firstProviderArrayResult(async (provider) => {
       const fetched = await request.fetchProvider(provider);
       if (fetched === null) return null;
+      assertTradingPriceHistory(fetched, request.target, this.deps.providerSourceKey(provider));
+      if (request.cachePolicyKey !== "priceHistoryIntraday"
+        && hasUnverifiedShellHistory(fetched, request.target, this.deps.providerSourceKey(provider))) return null;
       const value = normalizeRequestHistory(fetched, request);
-      if (request.isFetchedValueStale(value)) return null;
+      if (hasUsablePriceHistory(value) && request.isFetchedValueStale(value)) return null;
+      onUnavailable?.(this.deps.providerSourceKey(provider), value);
       this.deps.cacheResource(
         request.identity.kind,
         request.identity.entityKey,
@@ -418,39 +511,52 @@ export class ProviderRouterHistoryRoutes {
         this.deps.resolveProviderPolicy(request.cachePolicyKey, provider),
       );
       return value;
-    });
+    }, historyCoverage(request));
   }
 
   private async firstBrokerResult<T>(
     candidates: BrokerCandidate[],
     fetch: (candidate: BrokerCandidate) => Promise<T | null>,
+    coverage?: { isUsable(value: T): boolean; merge(value: T, unavailable: T[]): T },
   ): Promise<SourceResult<T> | null> {
+    const unavailable: T[] = [];
+    let firstUnavailable: SourceResult<T> | null = null;
     for (const candidate of candidates) {
       try {
         const value = await fetch(candidate);
         if (value !== null) {
-          return { sourceKey: this.deps.brokerSourceKey(candidate), value };
+          const result = { sourceKey: this.deps.brokerSourceKey(candidate), value };
+          if (coverage && !coverage.isUsable(value)) { unavailable.push(value); firstUnavailable ??= result; continue; }
+          return coverage ? { ...result, value: coverage.merge(value, unavailable) } : result;
         }
       } catch {
         // Continue through the broker candidates.
       }
     }
-    return null;
+    return firstUnavailable && coverage
+      ? { ...firstUnavailable, value: coverage.merge(firstUnavailable.value, unavailable) } : firstUnavailable;
   }
 
   private async firstProviderArrayResult<T>(
     fetch: (provider: DataProvider) => Promise<T[] | null>,
+    coverage?: { isUsable(value: T[]): boolean; merge(value: T[], unavailable: T[][]): T[] },
   ): Promise<SourceResult<T[]> | null> {
+    const unavailable: T[][] = [];
+    const usable = coverage?.isUsable ?? ((value: T[]) => value.length > 0);
+    const withUnavailable = (result: SourceResult<T[]> | null) => result && coverage
+      ? { ...result, value: coverage.merge(result.value, unavailable) } : result;
     const providers = this.deps.providersInPriorityOrder();
     let firstEmptyResult: SourceResult<T[]> | null = null;
+    let coverageError: HistoryCoverageError | null = null;
     const tryProvider = async (provider: DataProvider): Promise<SourceResult<T[]> | null> => {
       try {
         const value = await fetch(provider);
         if (value === null) return null;
         const result = { sourceKey: this.deps.providerSourceKey(provider), value };
-        if (value.length === 0) firstEmptyResult ??= result;
+        if (!usable(value)) { unavailable.push(value); firstEmptyResult ??= result; }
         return result;
       } catch (error) {
+        if (error instanceof HistoryCoverageError) coverageError ??= error;
         if (shouldLogProviderError(error)) {
           this.deps.logProviderError(`${provider.id} failed: ${error}`);
         }
@@ -461,9 +567,10 @@ export class ProviderRouterHistoryRoutes {
     if (providers.length <= 1) {
       for (const provider of providers) {
         const result = await tryProvider(provider);
-        if (result && result.value.length > 0) return result;
+        if (result && usable(result.value)) return withUnavailable(result);
       }
-      return firstEmptyResult;
+      if (coverageError) throw coverageError;
+      return withUnavailable(firstEmptyResult);
     }
 
     const preferred = tryProvider(providers[0]!);
@@ -471,24 +578,27 @@ export class ProviderRouterHistoryRoutes {
       setTimeout(() => resolve("timeout"), 200);
     });
     const first = await Promise.race([preferred, speculativeDelay]);
-    if (first !== "timeout" && first && first.value.length > 0) return first;
+    if (first !== "timeout" && first && usable(first.value)) return withUnavailable(first);
 
     const remaining = providers.slice(1).map((provider) => tryProvider(provider));
-    return await new Promise((resolve) => {
+    return await new Promise((resolve, reject) => {
       let settled = false;
       const finish = (result: SourceResult<T[]> | null) => {
-        if (settled || !result || result.value.length === 0) return;
+        if (settled || !result || !usable(result.value)) return;
         settled = true;
-        resolve(result);
+        resolve(withUnavailable(result));
       };
       void preferred.then((result) => {
-        if (result && result.value.length > 0) finish(result);
+        if (result && usable(result.value)) finish(result);
       });
       for (const pending of remaining) {
         void pending.then(finish);
       }
       void Promise.all([preferred, ...remaining]).then(() => {
-        if (!settled) resolve(firstEmptyResult);
+        if (!settled) {
+          if (coverageError) reject(coverageError);
+          else resolve(withUnavailable(firstEmptyResult));
+        }
       });
     });
   }

package/src/sources/provider-router/index.test.ts

@@ -1,7 +1,9 @@
+import { useRegularMarketSession } from "../../test-support/market-session";
 import { afterEach, describe, expect, test } from "bun:test";
 import { CloudApiRequestTransport } from "../../api-client/request";
 import { AppPersistence } from "../../data/app-persistence";
 import { AssetDataRouter } from "./index";
+import { getRouterEntityKey } from "./cache";
 import { assetDataProvider } from "../../capabilities";
 import type { BrokerAdapter } from "../../types/broker";
 import type { DataProvider, QuoteSubscriptionTarget } from "../../types/data-provider";
@@ -19,6 +21,8 @@ import {
   setBrokerInstances,
 } from "./test-support";
 
+useRegularMarketSession();
+
 const originalConsoleError = console.error;
 
 afterEach(() => {
@@ -468,7 +472,18 @@ describe("AssetDataRouter", () => {
     const dbPath = createTempDbPath("option-session-transition");
     const persistence = new AppPersistence(dbPath);
     const optionSymbol = "IBIT  281215C00030000";
-    const entityKey = `contract:${optionSymbol}`;
+    const context = {
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-work",
+      instrument: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        symbol: "IBIT",
+        localSymbol: optionSymbol,
+        secType: "OPT",
+      },
+    } as const;
+    const entityKey = getRouterEntityKey(optionSymbol, context.instrument);
     const providerSourceKey = "provider:yahoo";
     const cacheKey = {
       namespace: "market",
@@ -535,17 +550,6 @@ describe("AssetDataRouter", () => {
       const router = new AssetDataRouter(provider, [], persistence.resources);
       attachTestRegistry(router, { brokers: [["ibkr", broker]] });
       setBrokerInstances(router, [brokerInstance()]);
-      const context = {
-        brokerId: "ibkr",
-        brokerInstanceId: "ibkr-work",
-        instrument: {
-          brokerId: "ibkr",
-          brokerInstanceId: "ibkr-work",
-          symbol: "IBIT",
-          localSymbol: optionSymbol,
-          secType: "OPT",
-        },
-      } as const;
 
       const staleTransition = await router.getQuote(optionSymbol, "", context);
       expect(staleTransition.marketState).toBe("CLOSED");
@@ -971,7 +975,7 @@ describe("AssetDataRouter", () => {
       subscribeQuotes(targets, onQuote) {
         providerTargets.push(...targets);
         onQuote(targets[0]!, {
-          symbol: "MSFT",
+          symbol: targets[0]!.symbol,
           price: 456.78,
           currency: "USD",
           change: 2,
@@ -1225,6 +1229,7 @@ describe("AssetDataRouter", () => {
           priceHistory: [{ date: new Date("2026-03-28T00:00:00Z"), close: 0.245 }],
           quote: makeQuote({
             symbol: "IQE.L",
+            listingExchangeName: "LSE",
             providerId: "yahoo",
             price: 0.245,
             currency: "GBP",
@@ -1818,6 +1823,7 @@ describe("AssetDataRouter", () => {
         return makeFinancials({
           quote: makeQuote({
             symbol: "IQE.L",
+            listingExchangeName: "LSE",
             providerId: "yahoo",
             price: 0.245,
             currency: "GBP",