gloomberb 0.13.2 → 0.14.0

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

@@ -5,6 +5,8 @@ import type { BrokerAdapter } from "../../types/broker";
 import type { AppConfig } from "../../types/config";
 import { createDefaultConfig } from "../../types/config";
 import type {
+  CachedAssetArgs,
+  CachedAssetMethod,
   CachedFinancialsTarget,
   DataProvider,
   MarketDataRequestContext,
@@ -16,14 +18,16 @@ import type {
 } from "../../types/data-provider";
 import type { CapabilityRouteSource } from "../../types/capability-route-source";
 import { routeSourcePriority } from "../../types/capability-route-source";
-import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
+import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, QuoteMetadata, TickerFinancials } from "../../types/financials";
+import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import type { NewsArticle, NewsQuery } from "../../news/types";
 import type { BrokerContractRef, InstrumentSearchResult } from "../../types/instrument";
 import type { TimeRange } from "../../time-series/range";
 import type { ChartResolutionSupport, ManualChartResolution } from "../../time-series/resolution";
 import { debugLog } from "../../utils/debug-log";
 import { ProviderRouterBatchRoutes } from "./batches";
-import { ProviderRouterDocumentRoutes } from "./document-routes";
+import { mapListingTargets, publicListingExchange } from "../listing-target";
+import { ProviderRouterCachedRoutes } from "./cached-routes";
 import { ProviderRouterFinancialRoutes } from "./financial-routes";
 import { ProviderRouterHistoryRoutes } from "./history";
 import { ProviderRouterNewsRoutes } from "./news";
@@ -70,7 +74,7 @@ export class AssetDataRouter implements DataProvider {
   private readonly streamingRoutes: ProviderRouterStreamingRoutes;
   private readonly supplementalRoutes: ProviderRouterSupplementalRoutes;
   private readonly financialRoutes: ProviderRouterFinancialRoutes;
-  private readonly documentRoutes: ProviderRouterDocumentRoutes;
+  private readonly cachedRoutes: ProviderRouterCachedRoutes;
   private readonly healthyProviders = new WeakMap<DataProvider, DataProvider>();
 
   constructor(
@@ -87,7 +91,7 @@ export class AssetDataRouter implements DataProvider {
       ...routeDeps,
       primaryRoutes: this.primaryRoutes,
     });
-    this.documentRoutes = new ProviderRouterDocumentRoutes(routeDeps);
+    this.cachedRoutes = new ProviderRouterCachedRoutes(routeDeps);
     this.batchRoutes = new ProviderRouterBatchRoutes({
       ...routeDeps,
       readCachedMergedFinancialsSelection: (ticker, exchange, context, allowExpired) => (
@@ -166,37 +170,75 @@ export class AssetDataRouter implements DataProvider {
     targets: CachedFinancialsTarget[],
     options: { allowExpired?: boolean; includeStaleQuotes?: boolean } = {},
   ): Map<string, TickerFinancials> {
-    return this.financialRoutes.getCachedFinancialsForTargets(targets, options);
+    const { valid } = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, contextFromCachedTarget(target)));
+    return this.financialRoutes.getCachedFinancialsForTargets(valid, options);
   }
 
   getCachedExchangeRates(currencies: string[], options: { allowExpired?: boolean } = {}): Map<string, number> {
-    return this.supplementalRoutes.getCachedExchangeRates(currencies, options);
+    return this.cachedRoutes.getCachedExchangeRates(currencies, options);
   }
 
   async getQuotesBatch(
     targets: QuoteSubscriptionTarget[],
     options: { forceRefresh?: boolean } = {},
   ): Promise<QuoteBatchResult[]> {
-    return this.batchRoutes.getQuotesBatch(targets, options);
+    const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, target.context));
+    const results = await this.batchRoutes.getQuotesBatch(mapped.valid, options);
+    const restored = new Map(results.map((result) => {
+      const target = mapped.original(result.target);
+      return [target, { ...result, target }] as const;
+    }));
+    for (const failure of mapped.invalid) restored.set(failure.target, { ...failure, quote: null });
+    return targets.map((target) => restored.get(target) ?? { target, quote: null });
   }
 
   async getTickerFinancialsBatch(
     targets: CachedFinancialsTarget[],
     options: { forceRefresh?: boolean } = {},
   ): Promise<TickerFinancialsBatchResult[]> {
-    return this.batchRoutes.getTickerFinancialsBatch(targets, options);
+    const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, contextFromCachedTarget(target)));
+    const results = await this.batchRoutes.getTickerFinancialsBatch(mapped.valid, options);
+    const restored = new Map(results.map((result) => {
+      const target = mapped.original(result.target);
+      return [target, { ...result, target }] as const;
+    }));
+    for (const failure of mapped.invalid) restored.set(failure.target, { ...failure, financials: null });
+    return targets.map((target) => restored.get(target) ?? { target, financials: null });
   }
 
   async getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context);
     return this.financialRoutes.getTickerFinancials(ticker, exchange, context);
   }
 
   async getQuote(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<Quote> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context);
     return this.financialRoutes.getQuote(ticker, exchange, context);
   }
 
+  async getQuoteMetadata(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<QuoteMetadata | null> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context);
+    const cached = this.getCachedFinancialsForTargets([{ ...context, symbol: ticker, exchange }], { allowExpired: true, includeStaleQuotes: true })
+      .get(ticker.trim().toUpperCase());
+    const stored = cached?.quote ? quoteMetadataFromQuote(cached.quote) : cached?.quoteMetadata;
+    let known = stored && quoteMetadataMatchesTarget(stored, ticker, exchange) ? stored : undefined;
+    if (known?.currency && known.instrumentType) return known;
+    for (const provider of this.providersInPriorityOrder()) {
+      try {
+        const metadata = provider.getQuoteMetadata
+          ? await provider.getQuoteMetadata(ticker, exchange, context)
+          : quoteMetadataFromQuote(await provider.getQuote(ticker, exchange, context));
+        if (metadata && (metadata.currency || metadata.instrumentType) && quoteMetadataMatchesTarget(metadata, ticker, exchange)) {
+          known = mergeQuoteMetadata(known, metadata);
+          if (known?.currency && known.instrumentType) return known;
+        }
+      } catch { /* Optional listing metadata must not prevent historical research. */ }
+    }
+    return known ?? null;
+  }
+
   async getExchangeRate(fromCurrency: string): Promise<number> {
-    return this.supplementalRoutes.getExchangeRate(fromCurrency);
+    return (await this.getCachedQuery("getExchangeRate", [fromCurrency]).load({ force: false, background: true })).value;
   }
 
   async search(query: string, context?: SearchRequestContext): Promise<InstrumentSearchResult[]> {
@@ -208,15 +250,15 @@ export class AssetDataRouter implements DataProvider {
   }
 
   async getHolders(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<HolderData> {
-    return this.supplementalRoutes.getHolders(ticker, exchange, context);
+    return (await this.getCachedQuery("getHolders", [ticker, exchange, context]).load({ force: context?.cacheMode === "refresh", background: true })).value;
   }
 
   async getAnalystResearch(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<AnalystResearchData> {
-    return this.supplementalRoutes.getAnalystResearch(ticker, exchange, context);
+    return (await this.getCachedQuery("getAnalystResearch", [ticker, exchange, context]).load({ force: context?.cacheMode === "refresh", background: true })).value;
   }
 
   async getCorporateActions(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<CorporateActionsData> {
-    return this.supplementalRoutes.getCorporateActions(ticker, exchange, context);
+    return (await this.getCachedQuery("getCorporateActions", [ticker, exchange, context]).load({ force: context?.cacheMode === "refresh", background: true })).value;
   }
 
   async getEarningsCalendar(symbols: string[], context?: MarketDataRequestContext) {
@@ -224,22 +266,23 @@ export class AssetDataRouter implements DataProvider {
   }
 
   async getSecFilings(ticker: string, count = 15, exchange?: string, context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
-    return this.documentRoutes.getSecFilings(ticker, count, exchange, context);
+    return (await this.getCachedQuery("getSecFilings", [ticker, count, exchange, context]).load({ force: context?.cacheMode === "refresh", background: true })).value;
   }
 
   async getSecFilingDocuments(filing: SecFilingItem) {
-    return this.documentRoutes.getSecFilingDocuments(filing);
+    return (await this.getCachedQuery("getSecFilingDocuments", [filing]).load({ force: false, background: true })).value;
   }
 
   async getSecFilingContent(filing: SecFilingItem): Promise<string | null> {
-    return this.documentRoutes.getSecFilingContent(filing);
+    return (await this.getCachedQuery("getSecFilingContent", [filing]).load({ force: false, background: true })).value;
   }
 
   async getArticleSummary(url: string): Promise<string | null> {
-    return this.documentRoutes.getArticleSummary(url);
+    return (await this.getCachedQuery("getArticleSummary", [url]).load({ force: false, background: true })).value;
   }
 
   async getPriceHistory(ticker: string, exchange: string, range: TimeRange, context?: MarketDataRequestContext): Promise<PricePoint[]> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context) ?? "";
     return this.historyRoutes.getPriceHistory(ticker, exchange, range, context);
   }
 
@@ -250,6 +293,7 @@ export class AssetDataRouter implements DataProvider {
     resolution: ManualChartResolution,
     context?: MarketDataRequestContext,
   ): Promise<PricePoint[]> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context) ?? "";
     return this.historyRoutes.getPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context);
   }
 
@@ -258,6 +302,7 @@ export class AssetDataRouter implements DataProvider {
     exchange?: string,
     context?: MarketDataRequestContext,
   ): Promise<ChartResolutionSupport[]> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context) ?? "";
     return this.historyRoutes.getChartResolutionSupport(ticker, exchange, context);
   }
 
@@ -266,6 +311,7 @@ export class AssetDataRouter implements DataProvider {
     exchange?: string,
     context?: MarketDataRequestContext,
   ): Promise<ManualChartResolution[]> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context) ?? "";
     return this.historyRoutes.getChartResolutionCapabilities(ticker, exchange, context);
   }
 
@@ -277,11 +323,20 @@ export class AssetDataRouter implements DataProvider {
     barSize: string,
     context?: MarketDataRequestContext,
   ): Promise<PricePoint[]> {
+    exchange = this.resolvePublicExchange(ticker, exchange, context) ?? "";
     return this.historyRoutes.getDetailedPriceHistory(ticker, exchange, startDate, endDate, barSize, context);
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, context?: MarketDataRequestContext): Promise<OptionsChain> {
-    return this.supplementalRoutes.getOptionsChain(ticker, exchange, expirationDate, context);
+    return (await this.getCachedQuery("getOptionsChain", [ticker, exchange, expirationDate, context]).load({ force: context?.cacheMode === "refresh", background: true })).value;
+  }
+
+  getCachedQuery<K extends CachedAssetMethod>(method: K, args: CachedAssetArgs<K>) {
+    return this.cachedRoutes.get(method, args);
+  }
+
+  private resolvePublicExchange(ticker: string, exchange?: string, context?: MarketDataRequestContext): string | undefined {
+    return hasBrokerContext(context) || context?.instrument ? exchange : publicListingExchange(ticker, exchange);
   }
 
   private getEntityKey(ticker: string, instrument?: BrokerContractRef | null): string {
@@ -375,6 +430,15 @@ export class AssetDataRouter implements DataProvider {
       .filter((provider): provider is DataProvider => !!provider);
   }
 
+  /**
+   * Name of the provider a plain market request reaches first: the enabled
+   * capability with the best priority, or the fallback when nothing else is
+   * registered. Broker-scoped requests can still route elsewhere.
+   */
+  primaryMarketSourceName(): string | null {
+    return this.providersInPriorityOrder()[0]?.name ?? null;
+  }
+
   private providersInPriorityOrder(): DataProvider[] {
     const providers = [...this.sortedProviders()];
     const fallbackProvider = this.fallbackSource?.market ?? null;
@@ -403,6 +467,7 @@ export class AssetDataRouter implements DataProvider {
     targets: QuoteSubscriptionTarget[],
     onQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void,
   ): () => void {
-    return this.streamingRoutes.subscribeQuotes(targets, onQuote);
+    const mapped = mapListingTargets(targets, (target) => this.resolvePublicExchange(target.symbol, target.exchange, target.context));
+    return this.streamingRoutes.subscribeQuotes(mapped.valid, (target, quote) => onQuote(mapped.original(target), quote));
   }
 }

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

@@ -0,0 +1,139 @@
+import { afterEach, expect, setSystemTime, test } from "bun:test";
+import { apiClient } from "../../api-client";
+import { AppPersistence } from "../../data/app-persistence";
+import { buildComparisonChartPreset } from "../../plugins/builtin/chart-composer/presets";
+import { loadChartPaneModel } from "../../plugins/builtin/chart-composer/headless";
+import { createDefaultConfig } from "../../types/config";
+import type { CachedFinancialsTarget } from "../../types/data-provider";
+import type { PricePoint } from "../../types/financials";
+import { GloomberbCloudProvider } from "../gloomberb-cloud";
+import { hasCircleOfferingPriceHistory } from "../listing-history";
+import { AssetDataRouter } from "./index";
+import { cacheRouterResource } from "./cache";
+import { fallbackProvider, makeFinancials, makeQuote } from "./test-support";
+
+const originalHistory = apiClient.getCloudHistory;
+const originalQuote = apiClient.getCloudQuote;
+afterEach(() => { apiClient.getCloudHistory = originalHistory; apiClient.getCloudQuote = originalQuote; setSystemTime(); });
+// Captured 2026-09-16: June 4 is the issuer's $31 offering, not a traded session.
+const offer: PricePoint = { date: new Date("2025-06-04"), open: 31, high: 31, low: 31, close: 31, volume: 0 };
+const first: PricePoint = { date: new Date("2025-06-05"), open: 69, high: 103.75, low: 64, close: 83.23, volume: 47192000 };
+const next: PricePoint = { date: new Date("2025-06-06"), open: 96.39, high: 123.515, low: 92.95, close: 107.7, volume: 60706300 };
+const month: PricePoint = { date: new Date("2025-06-01"), open: 31, high: 298.98999, low: 31, close: 181.28999, volume: 828616800 };
+const correctMonth: PricePoint = { ...month, open: 69, low: 64 };
+const policy = { staleMs: 60_000, expireMs: 600_000 };
+const equal = (a: unknown, b: unknown) => expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+
+function cloudHistory(points: PricePoint[]) {
+  apiClient.getCloudHistory = async () => ({ status: "success", data: points.map(point => ({ ...point, date: point.date.toISOString() })) });
+  return new GloomberbCloudProvider();
+}
+
+test("Cloud rejects the attested daily offer and contaminated inception aggregate as whole windows, accepting corrected bars", async () => {
+  for (const points of [[offer, first, next], [{ ...offer, date: new Date("2025-06-05T13:40:00Z") }, first, next], [month, { ...month, date: new Date("2025-07-01"), open: 184.67, low: 171.5 }]]) {
+    const cloud = cloudHistory(points);
+    await expect(cloud.getPriceHistory("CRCL:XNYS", "", "ALL")).rejects.toThrow("IPO offer price");
+    await expect(cloud.getPriceHistory("CRCL", "", "ALL")).rejects.toThrow("IPO offer price");
+    await expect(cloud.getPriceHistoryForResolution("CRCL", "NYSE", "5Y", "1mo")).rejects.toThrow("IPO offer price");
+    await expect(cloud.getDetailedPriceHistory("CRCL", "NYSE", new Date("2025-06-01"), new Date("2025-07-01"), "1d")).rejects.toThrow("IPO offer price");
+  }
+  for (const points of [[first, next], [correctMonth], [{ ...first, volume: 0 }], [{ ...offer, date: new Date("2025-06-06") }]]) {
+    equal(await cloudHistory(points).getPriceHistory("CRCL", "NYSE", "ALL"), points);
+  }
+  for (const target of [{ symbol: "OTHER", exchange: "NYSE" }, { symbol: "CRCL", exchange: "LSE" }]) {
+    expect(hasCircleOfferingPriceHistory([offer], target, "provider:gloomberb-cloud")).toBe(false);
+  }
+  for (const source of ["provider:yahoo", "provider:independent", "broker:fixture:account"]) {
+    expect(hasCircleOfferingPriceHistory([offer], { symbol: "CRCL", exchange: "NYSE" }, source)).toBe(false);
+  }
+});
+
+test("poisoned exact and broader Cloud caches recover from a valid alternate, then survive a new router", async () => {
+  for (const mode of ["range", "resolution", "detail", "intraday"] as const) {
+    const store = new AppPersistence(":memory:");
+    try {
+      const detailed = mode === "detail" || mode === "intraday";
+      const bar = mode === "intraday" ? "5m" : "1d";
+      const valid = mode === "intraday" ? [
+        { ...first, date: new Date("2025-06-05T16:35:00Z"), high: 75.9, close: 75.9, volume: 6067069 },
+        { date: new Date("2025-06-05T16:40:00Z"), open: 75.9, high: 88.88, low: 75.9, close: 88.88, volume: 2370973 },
+      ] : [first, next];
+      const bad = [mode === "intraday" ? { ...offer, date: new Date("2025-06-05T13:40:00Z") } : offer, ...valid];
+      const kind = detailed ? "detailed-price-history" : "price-history";
+      const variant = detailed ? `exchange=NYSE;start=2025-06-01;end=2025-06-10;bar=${bar};version=5`
+        : mode === "resolution" ? "exchange=NYSE;range=ALL;resolution=1d;version=5;granularity=1"
+          : "exchange=NYSE;range=ALL;version=5;calendar=1;granularity=1";
+      store.resources.set({ namespace: "market", kind, entityKey: "CRCL", variantKey: variant, sourceKey: "provider:gloomberb-cloud" }, bad, { cachePolicy: policy });
+      let calls = 0;
+      const load = async () => { calls++; return valid; };
+      const alternate = { ...fallbackProvider, id: "yahoo", getPriceHistory: load, getPriceHistoryForResolution: load, getDetailedPriceHistory: load };
+      const cloud = cloudHistory(bad);
+      const read = (router: AssetDataRouter) => mode === "range" ? router.getPriceHistory("CRCL", "NYSE", "ALL")
+        : mode === "resolution" ? router.getPriceHistoryForResolution("CRCL", "NYSE", "5Y", "1d")
+          : router.getDetailedPriceHistory("CRCL", "NYSE", new Date("2025-06-01"), new Date("2025-06-10"), bar);
+      equal(await read(new AssetDataRouter(cloud, [alternate], store.resources)), valid);
+      expect(calls).toBe(1);
+      equal(await read(new AssetDataRouter(cloud, [alternate], store.resources)), valid);
+      expect(calls).toBe(1);
+    } finally { store.close(); }
+  }
+});
+
+test("unavailable fallback cannot turn a mixed inception window into a later comparison baseline", async () => {
+  const cloud = cloudHistory([offer, first, next]);
+  apiClient.getCloudQuote = async symbol => ({ status: "success", data: makeQuote({ symbol, listingExchangeName: symbol === "CRCL" ? "NYSE" : "ARCA" }) });
+  const router = new AssetDataRouter(cloud);
+  const spec = buildComparisonChartPreset(["CRCL:XNYS", "SPY:ARCX"]);
+  spec.viewport = { range: "5Y", resolution: "1d", dateWindow: { start: "2025-06-01", end: "2025-06-10" } };
+  const result = await loadChartPaneModel(spec, { marketData: router, apiClient, config: createDefaultConfig("/tmp/listing-history-unused"), signal: new AbortController().signal });
+  expect(result.errors?.join(" ")).toContain("IPO offer price");
+  expect(result.unavailableSymbols).toContain("CRCL:XNYS");
+  expect(result.metadata?.priceComparison).toMatchObject({ start: null, end: null });
+  expect(result.series.every(series => series.points.length === 0)).toBe(true);
+});
+
+test("cached and refreshed financial histories exclude affected offers while preserving statements and corrected history", async () => {
+  const store = new AppPersistence(":memory:");
+  try {
+    let points = [offer, first, next];
+    const financials = () => makeFinancials({ quote: makeQuote({ symbol: "CRCL", listingExchangeName: "NYSE", providerId: "gloomberb-cloud" }), annualStatements: [{ date: "2024-12-31", totalRevenue: 100 }], profile: { description: "Issuer" }, priceHistory: points });
+    cacheRouterResource(store.resources, "financials", "CRCL", "exchange=NYSE", "provider:gloomberb-cloud", financials(), policy);
+    const provider = { ...fallbackProvider, id: "gloomberb-cloud", getTickerFinancials: async () => financials() };
+    const router = new AssetDataRouter(provider, [], store.resources);
+    const cached = router.getCachedFinancialsForTargets([{ symbol: "CRCL", exchange: "NYSE" }]).get("CRCL");
+    expect(cached?.priceHistory).toEqual([]);
+    expect(cached?.annualStatements).toEqual(financials().annualStatements);
+    const refreshed = await router.getTickerFinancials("CRCL", "NYSE", { statementHistory: "extended", cacheMode: "refresh" });
+    expect(refreshed.priceHistory).toEqual([]);
+    expect(refreshed.profile).toEqual({ description: "Issuer" });
+    points = [first, next];
+    equal((await router.getTickerFinancials("CRCL", "NYSE", { cacheMode: "refresh" })).priceHistory, points);
+  } finally { store.close(); }
+});
+
+
+test("fresh financial batches sanitize both immediate deep results and retained fallbacks after a failed single fetch", async () => {
+  // This exercises batch history routing, independently of extended-hours quote requirements.
+  setSystemTime(new Date("2026-09-16T14:00:00Z"));
+  for (const deep of [true, false]) {
+    const store = new AppPersistence(":memory:");
+    try {
+      let singleCalls = 0;
+      const financials = makeFinancials({ quote: makeQuote({ symbol: "CRCL", listingExchangeName: "NYSE", providerId: "gloomberb-cloud" }),
+        profile: { description: "Issuer" },
+        annualStatements: deep ? Array.from({ length: 5 }, (_, index) => ({ date: `${2020 + index}-12-31`, inventory: 100 })) : [],
+        priceHistory: [offer, first, next] });
+      const provider = { ...fallbackProvider, id: "gloomberb-cloud",
+        getTickerFinancialsBatch: async (targets: CachedFinancialsTarget[]) => targets.map(target => ({ target, financials })),
+        getTickerFinancials: async () => { singleCalls++; throw Error("controlled single-request failure"); },
+      };
+      const router = new AssetDataRouter(provider, [], store.resources);
+      const result = await router.getTickerFinancialsBatch([{ symbol: "CRCL", exchange: "NYSE" }], { forceRefresh: true });
+      expect(result[0]?.financials?.priceHistory).toEqual([]);
+      expect(result[0]?.financials?.annualStatements).toEqual(financials.annualStatements);
+      expect(singleCalls).toBe(deep ? 0 : 1);
+      expect(router.getCachedFinancialsForTargets([{ symbol: "CRCL", exchange: "NYSE" }]).get("CRCL")?.priceHistory).toEqual([]);
+      expect(financials.priceHistory).toEqual([offer, first, next]);
+    } finally { store.close(); }
+  }
+});

package/src/sources/provider-router/listing-identity.test.ts

@@ -0,0 +1,128 @@
+import { useRegularMarketSession } from "../../test-support/market-session";
+import { afterEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { apiClient } from "../../api-client";
+import { GloomberbCloudProvider } from "../gloomberb-cloud";
+import { AssetDataRouter } from "./index";
+import { AppPersistence } from "../../data/app-persistence";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import type { QuoteSubscriptionTarget } from "../../types/data-provider";
+
+useRegularMarketSession();
+
+const originals = { getCloudQuote: apiClient.getCloudQuote, getCloudFinancials: apiClient.getCloudFinancials, getCloudHistory: apiClient.getCloudHistory, getCloudQuotesBatch: apiClient.getCloudQuotesBatch, subscribeQuotes: apiClient.subscribeQuotes, ensureVerifiedSession: apiClient.ensureVerifiedSession };
+afterEach(() => Object.assign(apiClient, originals));
+const quote = (price = 3025) => ({ symbol: "7203", currency: "JPY", exchangeName: "JPX", listingExchangeName: "JPX", price, lastUpdated: Date.now(), marketState: "CLOSED", instrumentType: "EQUITY" });
+const financials = (price = 3025) => ({ quote: quote(price), profile: { description: "Fixture issuer" }, annualStatements: [{ date: "2026-03-31", currency: "JPY", totalRevenue: 10 }], quarterlyStatements: [], priceHistory: [] });
+
+function installCloud() {
+  const calls: Array<[string, string, string | undefined]> = [];
+  apiClient.getCloudQuote = (async (symbol: string, exchange: string) => { calls.push(["quote", symbol, exchange]); return { status: "success", data: quote() }; }) as any;
+  apiClient.getCloudFinancials = (async (symbol: string, exchange: string) => { calls.push(["financials", symbol, exchange]); return { status: "success", data: financials() }; }) as any;
+  apiClient.getCloudHistory = (async (symbol: string, exchange: string) => { calls.push(["history", symbol, exchange]); return { status: "success", providerMeta: { provider: "yahoo" }, currency: "JPY", data: [{ date: "2026-09-10 10:00:00", close: 3025 }] }; }) as any;
+  return calls;
+}
+
+test("bare suffix controls request, returned identity and naive timestamps across actual cloud and router", async () => {
+  const calls = installCloud();
+  const provider = new GloomberbCloudProvider();
+  const store = new AppPersistence(":memory:");
+  try {
+    const router = new AssetDataRouter(provider, [], store.resources);
+    for (const source of [provider, router]) {
+      expect(await source.getQuote("7203.T", "TSE")).toMatchObject({ symbol: "7203.T", currency: "JPY", listingExchangeName: "JPX" });
+      expect(await source.getQuoteMetadata("7203.T", "TSE")).toMatchObject({ currency: "JPY", listingExchangeName: "JPX" });
+      expect((await source.getTickerFinancials("7203.T", "TSE")).quote?.currency).toBe("JPY");
+      const points = await source.getDetailedPriceHistory("7203.T", "TSE", new Date("2026-09-01"), new Date("2026-09-11"), "1h");
+      expect(points[0]?.date.toISOString()).toBe("2026-09-10T01:00:00.000Z");
+    }
+    expect(calls.length).toBeGreaterThan(3);
+    expect(calls.every(([, symbol, exchange]) => symbol === "7203.T" && exchange === "JPX")).toBe(true);
+  } finally { store.close(); }
+});
+
+test("old wrong-venue and unqualified caches cannot reintroduce Tokyo prices or timestamps under stale metadata", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gloom-alias-review-"));
+  const path = join(dir, "cache.sqlite");
+  const calls = installCloud();
+  const policy = { staleMs: 60_000, expireMs: 600_000 };
+  let store = new AppPersistence(path);
+  try {
+    for (const variantKey of ["exchange=TSX", ""]) store.resources.set({ namespace: "market", kind: "financials", entityKey: "7203.T", variantKey, sourceKey: "provider:gloomberb-cloud" }, financials(999), { schemaVersion: 7, cachePolicy: policy });
+    for (const variantKey of ["exchange=TSX;start=2026-09-01;end=2026-09-11;bar=1h;version=5", "start=2026-09-01;end=2026-09-11;bar=1h;version=5"]) store.resources.set({ namespace: "market", kind: "detailed-price-history", entityKey: "7203.T", variantKey, sourceKey: "provider:gloomberb-cloud" }, [{ date: new Date("2026-09-10T14:00:00Z"), close: 999 }], { cachePolicy: policy });
+    // Unrelated records must survive any targeted repair.
+    store.resources.set({ namespace: "market", kind: "financials", entityKey: "UNRELATED", variantKey: "exchange=NYSE", sourceKey: "provider:gloomberb-cloud" }, { ...financials(777), quote: { ...quote(777), symbol: "UNRELATED", currency: "USD", exchangeName: "NYSE", listingExchangeName: "NYSE" } }, { schemaVersion: 7, cachePolicy: policy });
+    store.close(); store = new AppPersistence(path);
+    const first = new AssetDataRouter(new GloomberbCloudProvider(), [], store.resources);
+    expect(first.getCachedFinancialsForTargets([{ symbol: "7203.T", exchange: "TSE" }]).get("7203.T")?.quote?.price).not.toBe(999);
+    expect((await first.getTickerFinancials("7203.T", "TSE")).quote?.price).toBe(3025);
+    const loadHistory = (router: AssetDataRouter) => router.getDetailedPriceHistory("7203.T", "TSE", new Date("2026-09-01"), new Date("2026-09-11"), "1h");
+    expect((await loadHistory(first))[0]?.date.toISOString()).toBe("2026-09-10T01:00:00.000Z");
+    expect(first.getCachedFinancialsForTargets([{ symbol: "UNRELATED", exchange: "NYSE" }]).get("UNRELATED")?.quote?.price).toBe(777);
+    const beforeRestart = calls.length;
+    store.close(); store = new AppPersistence(path);
+    const reopened = new AssetDataRouter(new GloomberbCloudProvider(), [], store.resources);
+    expect(reopened.getCachedFinancialsForTargets([{ symbol: "7203.T", exchange: "TSE" }]).get("7203.T")?.quote?.price).toBe(3025);
+    expect(new Date((await loadHistory(reopened))[0]!.date).toISOString()).toBe("2026-09-10T01:00:00.000Z");
+    expect(calls.length).toBe(beforeRestart);
+    expect(calls.every(([, symbol, exchange]) => symbol === "7203.T" && exchange === "JPX")).toBe(true);
+  } finally { store.close(); rmSync(dir, { recursive: true, force: true }); }
+});
+
+test("declared contract contexts retain exact venue, contract and independent cache identity", async () => {
+  const calls: unknown[] = [];
+  const provider = createTestDataProvider({ getQuote: async (symbol, exchange, context) => {
+    calls.push({ symbol, exchange, context });
+    return { ...quote(context!.instrument!.conId!), symbol, exchangeName: "TSX", listingExchangeName: "TSX" };
+  } });
+  const store = new AppPersistence(":memory:");
+  try {
+    const router = new AssetDataRouter(provider, [], store.resources);
+    const contexts = [100, 200].map(conId => ({ brokerId: "fixture", brokerInstanceId: "exact", instrument: { conId, symbol: "7203.T", brokerId: "fixture", brokerInstanceId: "exact", secType: "STK", exchange: "TSE", currency: "CAD" } }));
+    for (const context of contexts) expect((await router.getQuote("7203.T", "TSE", context)).price).toBe(context.instrument.conId);
+    expect(calls).toHaveLength(2);
+    for (let i = 0; i < calls.length; i++) {
+      expect((calls[i] as any).exchange).toBe("TSE");
+      expect((calls[i] as any).context).toBe(contexts[i]);
+      expect((calls[i] as any).context.instrument).toBe(contexts[i]!.instrument);
+    }
+  } finally { store.close(); }
+});
+
+test("bare suffix aliases keep caller identity through reordered cloud batches and routed streams", async () => {
+  const targets: QuoteSubscriptionTarget[] = [
+    { symbol: "7203.T", exchange: "TSE", surface: "detail", selected: true },
+    { symbol: "RY", exchange: "TSE", surface: "portfolio", visible: true },
+    { symbol: "7203.T:TSE", exchange: "JPX" },
+  ];
+  const items = [
+    { symbol: "UNREQUESTED", exchange: "JPX", status: "success" as const, data: { ...quote(), symbol: "UNREQUESTED" } },
+    { symbol: "RY", exchange: "TSX", status: "success" as const, data: { ...quote(), symbol: "RY", currency: "CAD", exchangeName: "TSX", listingExchangeName: "TSX" } },
+    { symbol: "7203", exchange: "JPX", status: "success" as const, data: quote() },
+  ];
+  apiClient.getCloudQuotesBatch = async (requests) => {
+    expect(requests).toEqual([{ symbol: "7203.T", exchange: "JPX" }, { symbol: "RY", exchange: "TSX" }]);
+    return { status: "success", data: { items } };
+  };
+  apiClient.ensureVerifiedSession = async () => null;
+  apiClient.subscribeQuotes = (requests, onQuote) => {
+    expect(requests.map(({ symbol, exchange }) => ({ symbol, exchange })))
+      .toEqual([{ symbol: "7203.T", exchange: "JPX" }, { symbol: "RY", exchange: "TSX" }]);
+    for (const item of items) onQuote(item, item.data);
+    return () => {};
+  };
+  const cloud = new GloomberbCloudProvider();
+  for (const source of [cloud, new AssetDataRouter(cloud)]) {
+    const batch = await source.getQuotesBatch(targets);
+    expect(batch).toHaveLength(3);
+    expect(batch.find((item) => item.target === targets[0])?.quote).toMatchObject({ symbol: "7203.T", currency: "JPY" });
+    expect(batch.find((item) => item.target === targets[1])?.quote).toMatchObject({ symbol: "RY", currency: "CAD" });
+    expect(batch.find((item) => item.target === targets[2])?.quote).toBeNull();
+    const seen: QuoteSubscriptionTarget[] = [];
+    source.subscribeQuotes(targets, (target, value) => { seen.push(target); expect(value.symbol).toBe(target.symbol); })();
+    expect(seen[0]).toBe(targets[1]!);
+    expect(seen[1]).toBe(targets[0]!);
+  }
+});

package/src/sources/provider-router/non-company-metadata.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { AppPersistence } from "../../data/app-persistence";
+import { apiClient } from "../../api-client";
+import { GloomberbCloudProvider } from "../gloomberb-cloud";
+import { quoteMetadataFromQuote } from "../../market-data/quotes/metadata";
+import { createTestDataProvider } from "../../test-support/data-provider";
+import type { Quote, TickerFinancials } from "../../types/financials";
+import { AssetDataRouter } from "./index";
+import { mergeFinancials, mergeRefreshedFinancials, sanitizeCachedFinancials } from "./financials";
+
+let clock: ReturnType<typeof spyOn>;
+beforeEach(() => { clock = spyOn(Date, "now").mockReturnValue(Date.parse("2026-09-14T18:00:00Z")); });
+afterEach(() => clock.mockRestore());
+const issuerFields = { marketCap: 200, trailingPE: 12, revenue: 0, netIncome: 0, operatingCashFlow: 0, freeCashFlow: 0 };
+function snapshot(quote?: Quote): TickerFinancials {
+  return { quote, fundamentals: issuerFields, annualStatements: [], quarterlyStatements: [], priceHistory: [] };
+}
+function quote(instrumentType?: string, listingExchangeName?: string): Quote {
+  return { symbol: "FUND", currency: "USD", instrumentType, listingExchangeName, price: 105,
+    change: 0, changePercent: 0, lastUpdated: Date.now(), marketState: "REGULAR" };
+}
+
+for (const venue of ["ARCA", undefined]) for (const state of ["fresh", "stale", "metadata-only"] as const) {
+  test(`${state} fund classification with ${venue ?? "unknown venue"} prevents cached issuer enrichment`, async () => {
+    const dir = mkdtempSync(join(tmpdir(), "gloom-fund-metadata-"));
+    const db = join(dir, "cache.sqlite");
+    let store = new AppPersistence(db);
+    const q = { ...quote("ETF", venue), stale: state !== "fresh" };
+    const fresh: TickerFinancials = { ...snapshot(q),
+      fundamentals: { dividendYield: 0.03, dividendYieldBasis: "trailing", dividendYieldSource: "twelvedata" },
+      profile: { description: "Verified fund" },
+    };
+    let loads = 0;
+    const transport = spyOn(apiClient, "getCloudFinancials").mockImplementation(async () => {
+      loads++; return { status: "success", data: fresh };
+    });
+    const price = spyOn(apiClient, "getCloudQuote").mockRejectedValue(new Error("No independent current quote"));
+    const provider = state === "metadata-only" ? createTestDataProvider({
+      getTickerFinancials: async () => { loads++; return { ...fresh, quote: undefined, quoteMetadata: quoteMetadataFromQuote(q) }; },
+      getQuote: async () => { throw new Error("No independent current quote"); },
+    }) : new GloomberbCloudProvider();
+    try {
+      store.resources.set({ namespace: "market", kind: "financials", entityKey: "FUND", variantKey: "", sourceKey: `provider:${provider.id}` },
+        snapshot({ ...quote(), stale: true }), { schemaVersion: 8, cachePolicy: { staleMs: 60_000, expireMs: 300_000 } });
+      store.close(); store = new AppPersistence(db);
+      const result = await new AssetDataRouter(provider, [], store.resources).getTickerFinancials("FUND");
+      expect(loads).toBe(1);
+      store.close(); store = new AppPersistence(db);
+      const reopened = new AssetDataRouter(provider, [], store.resources).getCachedFinancialsForTargets([{ symbol: "FUND" }]).get("FUND");
+      for (const value of [result, reopened]) {
+        expect(value?.quoteMetadata?.instrumentType).toBe("ETF");
+        expect(value?.fundamentals).toMatchObject({ dividendYield: 0.03, dividendYieldBasis: "trailing", dividendYieldSource: "twelvedata" });
+        for (const field of Object.keys(issuerFields) as Array<keyof typeof issuerFields>) expect(value?.fundamentals?.[field]).toBeUndefined();
+        expect(value?.annualStatements).toEqual([]);
+        if (!venue) expect(value?.quoteMetadata?.listingExchangeName).toBeUndefined();
+        if (state !== "fresh") {
+          expect(value?.quote).toBeUndefined();
+          expect(value?.quoteMetadata?.source?.stale).toBe(true);
+          expect(value?.quoteMetadata?.source?.lastUpdated).toBe(q.lastUpdated);
+        }
+      }
+    } finally { transport.mockRestore(); price.mockRestore(); store.close(); rmSync(dir, { recursive: true, force: true }); }
+  });
+}
+
+test("price freshness cannot change the research type or lend a fund an untyped yield", () => {
+  const legacy = { ...snapshot(), profile: { description: "Unverified issuer" }, fundamentals: { ...issuerFields, dividendYield: 0.9 },
+    annualStatements: [{ date: "2025-12-31", totalRevenue: 200 }] };
+  const metadataOnly = (type?: string): TickerFinancials => ({ ...snapshot(), fundamentals: undefined,
+    quoteMetadata: quoteMetadataFromQuote({ ...quote(type), stale: true }) });
+  for (const type of ["ETF", "INDEX", "CURRENCY", "FUTURE", "CRYPTOCURRENCY"]) {
+    const merged = mergeFinancials(legacy, metadataOnly(type))!;
+    expect(merged.fundamentals).toBeUndefined();
+    expect(merged.profile).toBeUndefined();
+    expect(merged.annualStatements).toEqual([]);
+  }
+  for (const type of ["EQUITY", undefined]) {
+    const merged = mergeFinancials(legacy, metadataOnly(type))!;
+    expect(merged.fundamentals?.revenue).toBe(0);
+    expect(merged.annualStatements[0]?.totalRevenue).toBe(200);
+  }
+  // A later untyped valuation overlay cannot undo the known instrument policy.
+  const freshValuation = { ...snapshot(), fundamentals: { enterpriseValue: 100 } };
+  expect(mergeRefreshedFinancials(metadataOnly("ETF"), freshValuation).fundamentals).toBeUndefined();
+  expect(mergeRefreshedFinancials(metadataOnly("EQUITY"), freshValuation).fundamentals?.enterpriseValue).toBe(100);
+  const company = { ...legacy, quote: quote("EQUITY"), quoteMetadata: metadataOnly("ETF").quoteMetadata };
+  expect(sanitizeCachedFinancials(company).annualStatements[0]?.totalRevenue).toBe(200);
+  const staleCompany = { ...company, quote: { ...company.quote, stale: true } };
+  expect(sanitizeCachedFinancials(staleCompany).quote).toBeUndefined();
+  expect(sanitizeCachedFinancials(staleCompany).quoteMetadata?.instrumentType).toBe("EQUITY");
+  expect(sanitizeCachedFinancials(staleCompany).annualStatements[0]?.totalRevenue).toBe(200);
+});