gloomberb 0.9.7 → 0.9.9

package/src/renderers/opentui/input-host.tsx

@@ -1,4 +1,5 @@
 import { useLayoutEffect, useMemo, useRef, type ReactNode } from "react";
+import { useNativeRenderer } from "../../ui";
 import {
   InputHostProvider,
   shouldDeliverShortcut,
@@ -19,6 +20,7 @@ interface ShortcutEntry {
 let nextShortcutOrder = 1;
 
 export function OpenTuiInputHostProvider({ children }: { children: ReactNode }) {
+  const renderer = useNativeRenderer();
   const shortcutsRef = useRef<ShortcutEntry[]>([]);
   const dispatchShortcut = (event: KeyEventLike) => {
     const shortcuts = shortcutsRef.current;
@@ -34,7 +36,9 @@ export function OpenTuiInputHostProvider({ children }: { children: ReactNode })
   };
 
   useKeyboard((event) => {
-    dispatchShortcut(toKeyEventLike(event));
+    const shortcutEvent = toKeyEventLike(event);
+    shortcutEvent.targetEditable = renderer.currentFocusedEditor != null;
+    dispatchShortcut(shortcutEvent);
   });
 
   const host = useMemo<InputHost>(() => ({

package/src/sources/gloomberb-cloud/index.test.ts

@@ -450,78 +450,6 @@ describe("GloomberbCloudProvider", () => {
     expect(unsubscribeCalled).toBe(true);
   });
 
-  test("maps backend news stories without requiring verified market-data access", async () => {
-    type CloudNewsRequest = NonNullable<Parameters<typeof apiClient.getCloudNews>[0]>;
-    let verifyCalled = false;
-    const requestArgs: { current: CloudNewsRequest | null } = { current: null };
-    apiClient.ensureVerifiedSession = async () => {
-      verifyCalled = true;
-      return verifiedUser;
-    };
-    apiClient.getCloudNews = async (params = {}) => {
-      requestArgs.current = params;
-      return {
-        items: [{
-          id: "story-1",
-          headline: "Apple raises guidance",
-          summary: "Apple lifted its outlook after stronger iPhone demand.",
-          topic: "guidance",
-          topics: ["guidance"],
-          category: "guidance",
-          sentiment: "positive",
-          sectors: ["information_technology"],
-          firstPublishedAt: "2026-04-01T10:00:00.000Z",
-          lastPublishedAt: "2026-04-01T10:05:00.000Z",
-          firstSeenAt: "2026-04-01T10:00:10.000Z",
-          lastSeenAt: "2026-04-01T10:05:10.000Z",
-          primaryUrl: "https://example.com/aapl-guidance",
-          primarySource: "example-wire",
-          scores: {
-            importance: 91,
-            urgency: 74,
-            marketImpact: 88,
-            novelty: 86,
-            confidence: 95,
-          },
-          flags: {
-            breaking: true,
-            developing: false,
-            stale: false,
-          },
-          variantCount: 1,
-          sourceCount: 1,
-          sources: ["example-wire"],
-          entities: [],
-          tickerLinks: [{
-            symbol: "AAPL",
-            exchange: "XNAS",
-            canonicalTicker: "AAPL:XNAS",
-            relationType: "direct",
-            displayTier: "primary",
-            confidence: 0.98,
-            relevanceScore: 95,
-            impactScore: 93,
-            sentiment: "positive",
-          }],
-        }],
-        nextCursor: null,
-      };
-    };
-
-    const provider = new GloomberbCloudProvider();
-    const news = await provider.getNews("AAPL", 10, "NASDAQ");
-
-    expect(verifyCalled).toBe(false);
-    expect(requestArgs.current).toEqual({ feed: "ticker", ticker: "AAPL", exchange: "XNAS", tickerTier: "primary", limit: 10 });
-    expect(news).toEqual([{
-      title: "Apple raises guidance",
-      url: "https://example.com/aapl-guidance",
-      source: "example-wire",
-      publishedAt: new Date("2026-04-01T10:05:00.000Z"),
-      summary: "Apple lifted its outlook after stronger iPhone demand.",
-    }]);
-  });
-
   test("maps news ticker labels from validated story links only", async () => {
     apiClient.getCloudNews = async () => ({
       items: [{

package/src/sources/gloomberb-cloud/index.ts

@@ -9,11 +9,9 @@ import type {
   AssetDataProvider,
   CachedFinancialsTarget,
   MarketDataRequestContext,
-  NewsItem,
   QuoteBatchResult,
   QuoteSubscriptionTarget,
   SearchRequestContext,
-  SecFilingItem,
   TickerFinancialsBatchResult,
 } from "../../types/data-provider";
 import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
@@ -27,12 +25,11 @@ import {
 } from "../../api-client";
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
-import { canonicalTickerKey, publicExchange } from "../../utils/exchanges";
+import { canonicalTickerKey } from "../../utils/exchanges";
 import { createProviderMiss } from "../provider-errors";
 import {
   cloudNewsParams,
   mapCloudNewsArticle,
-  mapCloudNewsItem,
 } from "./news";
 import {
   GLOOMBERB_CLOUD_PROVIDER_ID,
@@ -237,20 +234,6 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
-  async getNews(ticker: string, count?: number, exchange?: string, _context?: MarketDataRequestContext): Promise<NewsItem[]> {
-    const response = await withCloudFallback(
-      () => apiClient.getCloudNews({
-        feed: "ticker",
-        ticker,
-        exchange: exchange ? publicExchange(exchange) : undefined,
-        tickerTier: "primary",
-        limit: count,
-      }),
-      `Cloud news is unavailable for ${ticker}`,
-    );
-    return response.items.map(mapCloudNewsItem);
-  }
-
   async getHolders(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<HolderData> {
     await requireVerifiedSession();
     return withCloudFallback(async () => {
@@ -275,18 +258,6 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     }, `Cloud corporate actions are unavailable for ${ticker}`);
   }
 
-  async getSecFilings(_ticker: string, _count?: number, _exchange?: string, _context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
-    throw createProviderMiss("Cloud SEC filings are not available");
-  }
-
-  async getSecFilingDocuments(_filing: SecFilingItem) {
-    throw createProviderMiss("Cloud filing documents are not available");
-  }
-
-  async getSecFilingContent(_filing: SecFilingItem): Promise<string | null> {
-    throw createProviderMiss("Cloud filing content is not available");
-  }
-
   async getArticleSummary(_url: string): Promise<string | null> {
     throw createProviderMiss("Cloud article summaries are not available");
   }

package/src/sources/gloomberb-cloud/news.ts

@@ -1,5 +1,4 @@
 import { collectNewsDisplayTickers } from "../../news/ticker-symbols";
-import type { NewsItem } from "../../types/data-provider";
 import type { NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
 import type {
   CloudNewsPayload,
@@ -90,17 +89,6 @@ export function mapCloudNewsArticle(
   };
 }
 
-export function mapCloudNewsItem(item: CloudNewsPayload): NewsItem {
-  const article = mapCloudNewsArticle(item);
-  return {
-    title: article.title,
-    url: article.url,
-    source: article.source,
-    publishedAt: article.publishedAt,
-    summary: article.summary,
-  };
-}
-
 export function cloudNewsParams(query: NewsQuery): CloudNewsParams {
   const feed = query.feed ?? (query.scope === "ticker" ? "ticker" : "latest");
   return {

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

@@ -12,8 +12,10 @@ import { isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshnes
 import { resolveTickerFinancialsQuoteState } from "../../market-data/quotes/resolution";
 import { selectCachedResource } from "./cache";
 import {
+  dropUnusableProviderQuote,
   hasDeepStatementHistory,
   hasDetailedStatementRows,
+  isProviderQuoteUsableForCurrentSession,
   quoteWithFreshnessExchange,
   type CachedFinancialsSelection,
 } from "./financials";
@@ -52,8 +54,9 @@ export class ProviderRouterBatchRoutes {
       const context = target.context;
       const entityKey = this.deps.getEntityKey(target.symbol, context?.instrument);
       const variantKeys = this.deps.getTickerVariantCandidates(target.exchange);
+      const brokerSourceKeys = this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate));
       const sourceKeys = [
-        ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
+        ...brokerSourceKeys,
         ...this.deps.getProviderSourceKeys(),
       ];
       const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
@@ -61,6 +64,10 @@ export class ProviderRouterBatchRoutes {
         ? rawCached
         : null;
       if (cached && !forceRefresh && !cached.stale) {
+        if (brokerSourceKeys.includes(cached.sourceKey)) {
+          misses.push({ index, target });
+          return;
+        }
         results[index] = { target, quote: cached.value };
         return;
       }
@@ -80,7 +87,7 @@ export class ProviderRouterBatchRoutes {
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
       const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, options).catch(() => []);
       for (const item of batchResults) {
-        if (!item.quote || isQuoteStaleForCurrentSession(item.quote)) continue;
+        if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange)) continue;
         const key = this.quoteBatchKey(item.target);
         const sourceKey = this.deps.providerSourceKey(batchProvider);
         for (const entry of providerIndexes.get(key) ?? []) {
@@ -142,7 +149,8 @@ export class ProviderRouterBatchRoutes {
       for (const item of batchResults) {
         if (!item.financials) continue;
         const key = this.cachedFinancialsBatchKey(item.target);
-        const value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(item.financials));
+        let value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(item.financials));
+        if (value) value = dropUnusableProviderQuote(value, item.target.exchange);
         if (!value) continue;
         const sourceKey = this.deps.providerSourceKey(batchProvider);
         for (const entry of providerIndexes.get(key) ?? []) {

package/src/sources/provider-router/cached-financials.test.ts

@@ -405,6 +405,129 @@ describe("AssetDataRouter cached financials", () => {
     persistence.close();
   });
 
+  test("uses symbol provider quote reference for broker-linked snapshot reads", async () => {
+    const dbPath = createTempDbPath("cached-symbol-reference-for-contract-snapshot");
+    const persistence = new AppPersistence(dbPath);
+    const now = Date.now();
+
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "contract:275759",
+        variantKey: "exchange=NASDAQ",
+        sourceKey: "provider:gloomberb-cloud",
+      },
+      makeFinancials({
+        quote: makeQuote({
+          symbol: "VICR",
+          providerId: "gloomberb-cloud",
+          price: 292.83,
+          currency: "USD",
+          previousClose: 380.07,
+          change: -87.24,
+          changePercent: -22.95,
+          lastUpdated: now,
+          marketState: "REGULAR",
+          exchangeName: "NASDAQ",
+          listingExchangeName: "NASDAQ",
+          dataSource: "live",
+        }),
+        profile: {
+          description: "Cloud profile",
+        },
+        fundamentals: {
+          trailingPE: 94.3,
+        },
+      }),
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 7 * 24 * 60 * 60_000 },
+        fetchedAt: now,
+      },
+    );
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "contract:275759",
+        variantKey: "exchange=NASDAQ",
+        sourceKey: "provider:yahoo",
+      },
+      makeFinancials({
+        annualStatements: [{ date: "2025-12-31", totalRevenue: 100 }],
+      }),
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 7 * 24 * 60 * 60_000 },
+        fetchedAt: now + 1_000,
+      },
+    );
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "financials",
+        entityKey: "VICR",
+        variantKey: "exchange=NASDAQ",
+        sourceKey: "provider:yahoo",
+      },
+      makeFinancials({
+        quote: makeQuote({
+          symbol: "VICR",
+          providerId: "yahoo",
+          price: 294.39,
+          currency: "USD",
+          previousClose: 282.95,
+          change: 11.44,
+          changePercent: 4.04,
+          lastUpdated: now - 1_000,
+          marketState: "REGULAR",
+          exchangeName: "NASDAQ",
+          listingExchangeName: "NASDAQ",
+          dataSource: "delayed",
+        }),
+      }),
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 7 * 24 * 60 * 60_000 },
+        fetchedAt: now - 1_000,
+      },
+    );
+
+    const router = new AssetDataRouter({
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      async getTickerFinancials() {
+        throw new Error("should not fetch financials");
+      },
+    }, [{
+      ...fallbackProvider,
+      id: "gloomberb-cloud",
+      name: "Cloud",
+      priority: 100,
+      async getTickerFinancials() {
+        throw new Error("should not fetch financials");
+      },
+    }], persistence.resources);
+
+    const financials = await router.getTickerFinancials("VICR", "NASDAQ", {
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-work",
+      instrument: {
+        brokerId: "ibkr",
+        brokerInstanceId: "ibkr-work",
+        conId: 275759,
+        symbol: "VICR",
+      },
+    });
+
+    expect(financials.quote?.providerId).toBe("gloomberb-cloud");
+    expect(financials.quote?.price).toBe(292.83);
+    expect(financials.quote?.previousClose).toBe(282.95);
+    expect(financials.quote?.changePercent).toBeCloseTo(((292.83 - 282.95) / 282.95) * 100, 10);
+    expect(financials.quote?.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+
+    persistence.close();
+  });
+
   test("overlays standalone quote cache on stale financial snapshots during startup priming", () => {
     const dbPath = createTempDbPath("cached-quote-over-financial-snapshot");
     const persistence = new AppPersistence(dbPath);

package/src/sources/provider-router/financial-routes.ts

@@ -43,6 +43,19 @@ export interface ProviderRouterFinancialRouteDeps extends Pick<
   primaryRoutes: ProviderRouterPrimaryRoutes;
 }
 
+function withoutSessionState(quote: Quote): Quote {
+  const fallback = { ...quote };
+  delete fallback.marketState;
+  delete fallback.sessionConfidence;
+  delete fallback.preMarketPrice;
+  delete fallback.preMarketChange;
+  delete fallback.preMarketChangePercent;
+  delete fallback.postMarketPrice;
+  delete fallback.postMarketChange;
+  delete fallback.postMarketChangePercent;
+  return fallback;
+}
+
 export class ProviderRouterFinancialRoutes {
   constructor(private readonly deps: ProviderRouterFinancialRouteDeps) {}
 
@@ -81,7 +94,9 @@ export class ProviderRouterFinancialRoutes {
       quarterlyStatements: base?.quarterlyStatements ?? [],
       priceHistory: base?.priceHistory ?? [],
     });
-    const cached = this.readCachedMergedFinancialsSelection(ticker, exchange, context, false);
+    const cached = this.readCachedMergedFinancialsSelection(ticker, exchange, context, false, {
+      includeSymbolProviderFallback: true,
+    });
     const forceRefresh = context?.cacheMode === "refresh";
     if (cached.value && !forceRefresh) {
       if (isOptionTicker && !cached.value.quote) {
@@ -128,8 +143,9 @@ export class ProviderRouterFinancialRoutes {
   async getQuote(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<Quote> {
     const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
     const variantKeys = this.deps.getTickerVariantCandidates(exchange);
+    const brokerSourceKeys = this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate));
     const sourceKeys = [
-      ...this.deps.getBrokerCandidatesForContext(context, false).map((candidate) => this.deps.brokerSourceKey(candidate)),
+      ...brokerSourceKeys,
       ...this.deps.getProviderSourceKeys(),
     ];
     const rawCached = selectCachedResource<Quote>(this.deps.resources, "quote", entityKey, variantKeys, sourceKeys, false);
@@ -138,12 +154,19 @@ export class ProviderRouterFinancialRoutes {
       : null;
     const forceRefresh = context?.cacheMode === "refresh";
     if (cached && !forceRefresh && !cached.stale) {
-      return cached.value;
+      if (!brokerSourceKeys.includes(cached.sourceKey)) return cached.value;
+      return this.mergeBrokerQuoteWithProviderReference(
+        cached.value,
+        await this.getProviderReferenceQuote(ticker, exchange, context),
+      );
     }
 
     const brokerQuote = await withBrokerTimeout(this.deps.primaryRoutes.fetchBrokerQuote(ticker, exchange, context));
     if (brokerQuote && !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(brokerQuote.value, exchange))) {
-      return brokerQuote.value;
+      return this.mergeBrokerQuoteWithProviderReference(
+        brokerQuote.value,
+        await this.getProviderReferenceQuote(ticker, exchange, context),
+      );
     }
 
     const providerQuote = await this.deps.primaryRoutes.fetchProviderQuote(ticker, exchange, context);
@@ -154,6 +177,54 @@ export class ProviderRouterFinancialRoutes {
     throw new Error(`No quote provider available for ${ticker}`);
   }
 
+  private async getProviderReferenceQuote(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Promise<Quote | null> {
+    const cached = context?.cacheMode === "refresh"
+      ? null
+      : this.readCachedProviderQuote(ticker, exchange, context);
+    if (cached) return cached;
+    const staleFallback = this.readCachedProviderQuote(ticker, exchange, context, true);
+    const providerQuote = await this.deps.primaryRoutes.fetchProviderQuote(ticker, exchange, context);
+    if (providerQuote) return providerQuote.value;
+    return staleFallback ? withoutSessionState(staleFallback) : null;
+  }
+
+  private readCachedProviderQuote(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+    includeStale = false,
+  ): Quote | null {
+    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
+    const entityKeys = [...new Set([entityKey, normalizeTicker(ticker)])];
+    const variantKeys = this.deps.getTickerVariantCandidates(exchange);
+    const sourceKeys = this.deps.getProviderSourceKeys();
+    for (const candidateEntityKey of entityKeys) {
+      const record = selectCachedResource<Quote>(this.deps.resources, "quote", candidateEntityKey, variantKeys, sourceKeys, false);
+      if (
+        record
+        && (includeStale || !record.stale)
+        && !isQuoteStaleForCurrentSession(quoteWithFreshnessExchange(record.value, exchange))
+      ) {
+        return record.value;
+      }
+    }
+    return null;
+  }
+
+  private mergeBrokerQuoteWithProviderReference(brokerQuote: Quote, providerQuote: Quote | null): Quote {
+    if (!providerQuote) return brokerQuote;
+    return resolveTickerFinancialsQuoteState({
+      quote: providerQuote,
+      annualStatements: [],
+      quarterlyStatements: [],
+      priceHistory: [],
+    }, brokerQuote)?.quote ?? brokerQuote;
+  }
+
   readCachedMergedFinancialsSelection(
     ticker: string,
     exchange?: string,
@@ -171,7 +242,8 @@ export class ProviderRouterFinancialRoutes {
       ? { ...brokerRecord, value: sanitizeCachedFinancials(brokerRecord.value, options) }
       : null;
     const providerSourceKeys = this.deps.getProviderSourceKeys();
-    const providerEntityKeys = options.includeSymbolProviderFallback
+    const includeSymbolProviderFallback = options.includeSymbolProviderFallback !== false;
+    const providerEntityKeys = includeSymbolProviderFallback
       ? [...new Set([entityKey, normalizeTicker(ticker)])]
       : [entityKey];
     const providerRecords = sortCachedRecords(

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

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import {
+  dropUnusableProviderQuote,
+  isProviderQuoteUsableForCurrentSession,
+} from "./financials";
+import { makeFinancials, makeQuote } from "./test-support";
+
+describe("provider-router financial quote usability", () => {
+  test("rejects active-session labels without active-session prices", () => {
+    expect(isProviderQuoteUsableForCurrentSession(makeQuote({
+      listingExchangeName: "NASDAQ",
+      marketState: "PRE",
+      lastUpdated: Date.now(),
+    }), "NASDAQ")).toBe(false);
+  });
+
+  test("rejects old active-session provider quotes", () => {
+    expect(isProviderQuoteUsableForCurrentSession(makeQuote({
+      listingExchangeName: "FWB2",
+      marketState: "REGULAR",
+      lastUpdated: Date.now() - 20 * 60_000,
+    }), "FWB2")).toBe(false);
+  });
+
+  test("rejects empty zero provider quotes", () => {
+    expect(isProviderQuoteUsableForCurrentSession(makeQuote({
+      price: 0,
+      change: 0,
+      changePercent: 0,
+      listingExchangeName: "SFB",
+      lastUpdated: Date.now(),
+    }), "SFB")).toBe(false);
+  });
+
+  test("strips unusable quotes while preserving non-quote financials", () => {
+    const value = dropUnusableProviderQuote(makeFinancials({
+      profile: { sector: "Industrials" },
+      quote: makeQuote({
+        price: 0,
+        change: 0,
+        changePercent: 0,
+        listingExchangeName: "SFB",
+      }),
+    }), "SFB");
+
+    expect(value.profile?.sector).toBe("Industrials");
+    expect(value.quote).toBeUndefined();
+  });
+});

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

@@ -77,6 +77,46 @@ export function quoteWithFreshnessExchange(quote: Quote, exchange?: string): Quo
   };
 }
 
+function finitePositiveNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+const ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS = 10 * 60_000;
+const ACTIVE_QUOTE_MARKET_STATES = new Set(["PRE", "REGULAR", "POST"]);
+
+function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
+  if (!ACTIVE_QUOTE_MARKET_STATES.has(quote.marketState ?? "")) return false;
+  if (!Number.isFinite(quote.lastUpdated)) return false;
+  return now - quote.lastUpdated > ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
+}
+
+export function isProviderQuoteUsableForCurrentSession(quote: Quote | null | undefined, exchange?: string): quote is Quote {
+  if (!quote) return false;
+  const normalized = quoteWithFreshnessExchange(quote, exchange);
+  if (isQuoteStaleForCurrentSession(normalized)) return false;
+  if (isActiveProviderQuoteTooOld(normalized)) return false;
+  return [
+    normalized.price,
+    normalized.preMarketPrice,
+    normalized.postMarketPrice,
+    normalized.bid,
+    normalized.ask,
+    normalized.mark,
+  ].some(finitePositiveNumber);
+}
+
+export function dropUnusableProviderQuote(value: TickerFinancials, exchange?: string): TickerFinancials {
+  if (!value.quote || isProviderQuoteUsableForCurrentSession(value.quote, exchange)) {
+    return value;
+  }
+
+  return {
+    ...value,
+    quote: undefined,
+    quoteContributions: undefined,
+  };
+}
+
 function sanitizeCachedQuote(
   quote: Quote,
   exchange: string | undefined,
@@ -216,13 +256,10 @@ export function mergeCachedFinancialRecords(
   value: TickerFinancials | null;
   stale: boolean;
 } {
-  const seenSources = new Set<string>();
   let merged: TickerFinancials | null = null;
   let stale = false;
 
   for (const record of records) {
-    if (seenSources.has(record.sourceKey)) continue;
-    seenSources.add(record.sourceKey);
     merged = mergeFinancials(merged, sanitizeCachedFinancials(record.value, options));
     stale = stale || record.stale === true;
   }