gloomberb 0.7.2 → 0.7.4

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

@@ -127,6 +127,23 @@ describe("MarketDataCoordinator", () => {
     expect(calls).toBe(2);
   });
 
+  it("serves USD exchange rates without hitting the provider", async () => {
+    let calls = 0;
+    const provider = createProvider({
+      getExchangeRate: async () => {
+        calls += 1;
+        return 1;
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+
+    const entry = await coordinator.loadFxRate("usd");
+
+    expect(entry.data).toBe(1);
+    expect(entry.source).toBe("static");
+    expect(calls).toBe(0);
+  });
+
   it("reuses fresh empty tab query results instead of refetching on reopen", async () => {
     let newsCalls = 0;
     let optionsCalls = 0;
@@ -553,6 +570,50 @@ describe("MarketDataCoordinator", () => {
     }
   });
 
+  it("drops a stale stream quote when there is no fresh quote to preserve", () => {
+    const fixedNow = Date.parse("2026-05-13T21:00:00Z");
+    const realDateNow = Date.now;
+    Date.now = () => fixedNow;
+    try {
+      let streamed: ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null = null;
+      const provider = createProvider({
+        subscribeQuotes: (_targets, onQuote) => {
+          streamed = onQuote as typeof streamed;
+          return () => {};
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const instrument = { symbol: "2337", exchange: "TWSE" };
+
+      coordinator.subscribeQuotes([{ instrument }]);
+      const onStreamed = streamed as ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null;
+      if (!onStreamed) throw new Error("expected streaming callback");
+      onStreamed(
+        { symbol: "2337", exchange: "TWSE" },
+        {
+          symbol: "2337",
+          providerId: "gloomberb-cloud",
+          dataSource: "delayed",
+          price: 150,
+          currency: "TWD",
+          change: 0,
+          changePercent: 0,
+          lastUpdated: Date.parse("2026-05-08T06:00:00Z"),
+          listingExchangeName: "TWSE",
+          marketState: "CLOSED",
+          sessionConfidence: "explicit",
+        },
+      );
+
+      const entry = coordinator.getQuoteEntry(instrument);
+      expect(entry.data).toBeNull();
+      expect(entry.lastGoodData).toBeNull();
+      expect(coordinator.getTickerFinancialsSync(instrument)?.quote).toBeUndefined();
+    } finally {
+      Date.now = realDateNow;
+    }
+  });
+
   it("hydrates ticker financials synchronously from primed cached data", () => {
     const coordinator = new MarketDataCoordinator(createProvider());
     const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
@@ -642,7 +703,7 @@ describe("MarketDataCoordinator", () => {
         currency: "USD",
         change: 0,
         changePercent: 0,
-        lastUpdated: 1_700_000_000_000,
+        lastUpdated: Date.now(),
       }),
       getQuotesBatch: async (targets) => {
         batchTargets.push(targets);
@@ -654,7 +715,7 @@ describe("MarketDataCoordinator", () => {
             currency: "USD",
             change: 0,
             changePercent: 0,
-            lastUpdated: 1_700_000_000_000,
+            lastUpdated: Date.now(),
           },
         }));
       },
@@ -672,6 +733,65 @@ describe("MarketDataCoordinator", () => {
     expect(coordinator.getQuoteEntry(msft).data?.price).toBe(200);
   });
 
+  it("refreshes primed quote cache when the quote is stale for the current session", async () => {
+    const fixedNow = Date.parse("2026-05-13T21:00:00Z");
+    const realDateNow = Date.now;
+    Date.now = () => fixedNow;
+    try {
+      const batchTargets: QuoteSubscriptionTarget[][] = [];
+      const provider = createProvider({
+        getQuotesBatch: async (targets) => {
+          batchTargets.push(targets);
+          return targets.map((target) => ({
+            target,
+            quote: {
+              symbol: target.symbol,
+              price: 6970,
+              currency: "JPY",
+              change: 370,
+              changePercent: 5.61,
+              lastUpdated: Date.parse("2026-05-13T06:24:00Z"),
+              marketState: "CLOSED",
+              listingExchangeName: "JPX",
+              providerId: "yahoo",
+            },
+          }));
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const instrument = { symbol: "6324.T", exchange: "JPX" };
+
+      coordinator.primeCachedFinancials([{
+        instrument,
+        financials: {
+          quote: {
+            symbol: "6324.T",
+            price: 6230,
+            currency: "JPY",
+            change: 520,
+            changePercent: 9.11,
+            lastUpdated: Date.parse("2026-05-08T06:24:00Z"),
+            marketState: "CLOSED",
+            listingExchangeName: "JPX",
+            providerId: "gloomberb-cloud",
+          },
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+        },
+      }]);
+
+      await coordinator.loadQuotesBatch([instrument]);
+
+      expect(batchTargets).toHaveLength(1);
+      expect(batchTargets[0]?.map((target) => target.symbol)).toEqual(["6324.T"]);
+      expect(coordinator.getQuoteEntry(instrument).data?.price).toBe(6970);
+      expect(coordinator.getQuoteEntry(instrument).data?.changePercent).toBe(5.61);
+    } finally {
+      Date.now = realDateNow;
+    }
+  });
+
   it("batch loads snapshots through provider batch support", async () => {
     const batchSymbols: string[][] = [];
     const provider = createProvider({

package/src/market-data/coordinator.ts

@@ -23,9 +23,9 @@ import {
   toMarketDataContext,
 } from "./selectors";
 import { traceMarketData } from "./trace";
-import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../utils/price-history";
+import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../utils/price-history";
 import { hasFreshQuoteForCurrentSession, isQuoteStaleForCurrentSession } from "../utils/quote-freshness";
-import { TIME_RANGE_ORDER } from "../components/chart/chart-resolution";
+import { isIntradayResolution, TIME_RANGE_ORDER } from "../components/chart/chart-resolution";
 import { measurePerf } from "../utils/perf-marks";
 
 const EMPTY_MESSAGE = "No data available";
@@ -57,6 +57,29 @@ function getTimeRangeIndex(range: ChartRequest["bufferRange"]): number {
   return TIME_RANGE_INDEX.get(range) ?? 0;
 }
 
+function isCurrentHistoryWindow(endDate?: Date): boolean {
+  if (!endDate) return true;
+  const endMs = endDate.getTime();
+  return Number.isFinite(endMs) && Date.now() - endMs < 60 * 60_000;
+}
+
+function isIntradayChartRequest(request: ChartRequest): boolean {
+  const granularity = getChartGranularity(request);
+  if (granularity === "detail") return isCurrentHistoryWindow(request.endDate);
+  if (granularity === "resolution") {
+    return request.resolution ? isIntradayResolution(request.resolution) : false;
+  }
+  return request.bufferRange === "1D" || request.bufferRange === "1W" || request.bufferRange === "1M" || request.bufferRange === "3M";
+}
+
+function normalizeFreshChartData(points: PricePoint[] | null | undefined, request: ChartRequest): PricePoint[] {
+  const normalized = normalizePriceHistory(points ?? []);
+  if (isIntradayChartRequest(request) && isPriceHistoryStaleForCurrentWindow(normalized)) {
+    return [];
+  }
+  return normalized;
+}
+
 function isSeedableChartRequest(
   target: ChartRequest,
   candidate: ChartRequest,
@@ -88,6 +111,20 @@ function hasFreshReadyEntry<T>(entry: QueryEntry<T>, ttlMs: number, now = Date.n
   return entry.phase === "ready" && entry.fetchedAt != null && now - entry.fetchedAt < ttlMs;
 }
 
+function hasFreshQuoteEntry(
+  entry: QueryEntry<Quote>,
+  instrument: InstrumentRef,
+  ttlMs: number,
+  now = Date.now(),
+): boolean {
+  const quote = resolveEntryData(entry);
+  if (!quote || entry.fetchedAt == null || now - entry.fetchedAt >= ttlMs) return false;
+  const quoteForFreshness = instrument.exchange && !quote.listingExchangeName && !quote.exchangeName
+    ? { ...quote, listingExchangeName: instrument.exchange }
+    : quote;
+  return !isQuoteStaleForCurrentSession(quoteForFreshness, now);
+}
+
 function createAttempt(
   providerId: string,
   startedAt: number,
@@ -142,11 +179,9 @@ function readyQuoteEntry(
   source: string,
   attempts: ProviderAttempt[],
 ): QueryEntry<Quote> {
-  if (
-    isQuoteStaleForCurrentSession(quote)
-    && hasFreshQuoteForCurrentSession([current.data, current.lastGoodData])
-  ) {
-    return readyEntry(current, null, current.source ?? source, attempts, { keepLastGoodOnEmpty: true });
+  if (isQuoteStaleForCurrentSession(quote)) {
+    const keepFreshQuote = hasFreshQuoteForCurrentSession([current.data, current.lastGoodData]);
+    return readyEntry(current, null, current.source ?? source, attempts, { keepLastGoodOnEmpty: keepFreshQuote });
   }
   return readyEntry(current, quote, source, attempts, { keepLastGoodOnEmpty: true });
 }
@@ -189,19 +224,69 @@ const STREAM_QUOTE_FIELDS: Array<keyof Quote> = [
   "dataSource",
 ];
 
-function quoteTimestampMinute(quote: Quote): number | null {
-  return Number.isFinite(quote.lastUpdated) ? Math.floor(quote.lastUpdated / 60_000) : null;
-}
-
 function areStreamQuotesEquivalent(current: Quote | null | undefined, next: Quote): boolean {
   if (!current) return false;
   for (const field of STREAM_QUOTE_FIELDS) {
     if (current[field] !== next[field]) return false;
   }
-  return quoteTimestampMinute(current) === quoteTimestampMinute(next)
+  return current.lastUpdated === next.lastUpdated
     && JSON.stringify(current.provenance ?? null) === JSON.stringify(next.provenance ?? null);
 }
 
+function hasCachedSnapshotData(financials: TickerFinancials): boolean {
+  return !!financials.profile
+    || Object.keys(financials.fundamentals ?? {}).length > 0
+    || financials.annualStatements.length > 0
+    || financials.quarterlyStatements.length > 0;
+}
+
+type QuoteSubscriptionPriority = Pick<QuoteSubscriptionTarget, "surface" | "visible" | "selected" | "weight">;
+
+interface QuoteSubscriptionEntry {
+  target: QuoteSubscriptionTarget;
+  targets: Map<number, QuoteSubscriptionTarget>;
+  removeTimer: ReturnType<typeof setTimeout> | null;
+}
+
+function quoteSubscriptionPriorityScore(target: QuoteSubscriptionTarget): number {
+  let score = Number.isFinite(target.weight) ? Math.max(0, target.weight ?? 0) : 0;
+  if (target.selected) score += 10_000;
+  if (target.visible) score += 5_000;
+  if (target.surface === "detail" || target.surface === "monitor") score += 4_000;
+  if (target.surface === "portfolio" || target.surface === "watchlist") score += 1_000;
+  if (target.surface === "screener") score += 700;
+  if (target.surface === "inline") score += 200;
+  return score;
+}
+
+function mergeQuoteSubscriptionTargets(targets: Iterable<QuoteSubscriptionTarget>): QuoteSubscriptionTarget | null {
+  let selectedTarget: QuoteSubscriptionTarget | null = null;
+  let selectedScore = -1;
+  let visible = false;
+  let selected = false;
+  let weight = 0;
+
+  for (const target of targets) {
+    const score = quoteSubscriptionPriorityScore(target);
+    if (!selectedTarget || score > selectedScore) {
+      selectedTarget = target;
+      selectedScore = score;
+    }
+    visible ||= target.visible === true;
+    selected ||= target.selected === true;
+    weight = Math.max(weight, Number.isFinite(target.weight) ? Math.max(0, target.weight ?? 0) : 0);
+  }
+
+  return selectedTarget
+    ? {
+      ...selectedTarget,
+      visible,
+      selected,
+      weight,
+    }
+    : null;
+}
+
 function errorEntry<T>(current: QueryEntry<T>, attempt: ProviderAttempt): QueryEntry<T> {
   return {
     ...current,
@@ -224,12 +309,10 @@ export class MarketDataCoordinator {
   private readonly keyVersions = new Map<string, number>();
   private readonly inFlight = new Map<string, Promise<unknown>>();
   private readonly chartRequests = new Map<string, ChartRequest>();
-  private readonly quoteSubscriptions = new Map<string, {
-    target: QuoteSubscriptionTarget;
-    refCount: number;
-    unsubscribe: (() => void) | null;
-    removeTimer: ReturnType<typeof setTimeout> | null;
-  }>();
+  private readonly quoteSubscriptions = new Map<string, QuoteSubscriptionEntry>();
+  private nextQuoteSubscriptionId = 1;
+  private quoteSubscriptionDispose: (() => void) | null = null;
+  private quoteSubscriptionSignature = "";
   private pendingQuoteSubscriptionKeys = new Set<string>();
 
   private readonly quoteStore = new QueryStore<Quote>((key) => this.bump(key));
@@ -365,7 +448,7 @@ export class MarketDataCoordinator {
       const fundamentalsKey = buildFundamentalsKey(instrument);
       const statementsKey = buildStatementsKey(instrument);
 
-      if (this.snapshotStore.get(snapshotKey).phase === "idle") {
+      if (hasCachedSnapshotData(normalized) && this.snapshotStore.get(snapshotKey).phase === "idle") {
         this.snapshotStore.set(
           snapshotKey,
           readyEntry(this.snapshotStore.get(snapshotKey), normalized, source, [], { keepLastGoodOnEmpty: true }),
@@ -445,11 +528,15 @@ export class MarketDataCoordinator {
     };
   }
 
-  private quoteTargetFromInstrument(instrument: InstrumentRef): QuoteSubscriptionTarget {
+  private quoteTargetFromInstrument(
+    instrument: InstrumentRef,
+    priority: QuoteSubscriptionPriority = {},
+  ): QuoteSubscriptionTarget {
     return {
       symbol: instrument.symbol,
       exchange: instrument.exchange ?? "",
       context: toMarketDataContext(instrument),
+      ...priority,
     };
   }
 
@@ -516,19 +603,37 @@ export class MarketDataCoordinator {
     request: ChartRequest,
     current: QueryEntry<PricePoint[]>,
   ): QueryEntry<PricePoint[]> {
-    if (resolveEntryData(current)?.length) {
-      return loadingEntry(current);
+    const currentData = normalizeFreshChartData(resolveEntryData(current), request);
+    if (currentData.length) {
+      return loadingEntry({
+        ...current,
+        data: currentData,
+        lastGoodData: currentData,
+      });
     }
 
     const seed = this.findChartSeedEntry(key, request);
     if (!seed) {
-      return loadingEntry(current);
+      return loadingEntry({
+        ...current,
+        data: null,
+        lastGoodData: null,
+      });
+    }
+
+    const seedData = normalizeFreshChartData(seed.data, request);
+    if (!seedData.length) {
+      return loadingEntry({
+        ...current,
+        data: null,
+        lastGoodData: null,
+      });
     }
 
     return loadingEntry({
       ...current,
-      data: seed.data,
-      lastGoodData: seed.entry.lastGoodData?.length ? seed.entry.lastGoodData : seed.data,
+      data: seedData,
+      lastGoodData: seedData,
       source: seed.entry.source,
       fetchedAt: seed.entry.fetchedAt,
       staleAt: seed.entry.staleAt,
@@ -661,7 +766,7 @@ export class MarketDataCoordinator {
     for (const instrument of uniqueInstruments) {
       const key = buildQuoteKey(instrument);
       const current = this.quoteStore.get(key);
-      if (!options.forceRefresh && hasFreshEntryData(current, SNAPSHOT_CACHE_TTL_MS)) {
+      if (!options.forceRefresh && hasFreshQuoteEntry(current, instrument, SNAPSHOT_CACHE_TTL_MS)) {
         results.set(key, current);
       } else {
         misses.push(instrument);
@@ -699,7 +804,13 @@ export class MarketDataCoordinator {
     const key = buildChartKey(request);
     this.chartRequests.set(key, request);
     const current = this.chartStore.get(key);
-    if (!options.forceRefresh && hasFreshEntryData(current, CHART_CACHE_TTL_MS)) {
+    const currentData = normalizeFreshChartData(resolveEntryData(current), request);
+    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 })
+        );
+      }
       return current;
     }
     const flightKey = options.forceRefresh ? `${key}|refresh` : key;
@@ -898,16 +1009,22 @@ export class MarketDataCoordinator {
   }
 
   async loadFxRate(currency: string): Promise<QueryEntry<number>> {
-    const key = buildFxKey(currency);
+    const normalizedCurrency = currency.trim().toUpperCase();
+    const key = buildFxKey(normalizedCurrency);
     const current = this.fxStore.get(key);
     if (hasFreshEntryData(current, FX_CACHE_TTL_MS)) {
       return current;
     }
+    if (normalizedCurrency === "USD") {
+      const startedAt = Date.now();
+      const attempts = [createAttempt("static", startedAt, "success")];
+      return this.fxStore.update(key, (current) => readyEntry(current, 1, "static", attempts, { keepLastGoodOnEmpty: true }));
+    }
     return this.runSingleFlight(key, async () => {
       this.fxStore.update(key, loadingEntry);
       const startedAt = Date.now();
       try {
-        const rate = await this.dataProvider.getExchangeRate(currency);
+        const rate = await this.dataProvider.getExchangeRate(normalizedCurrency);
         const attempts = [createAttempt(this.dataProvider.id, startedAt, "success")];
         return this.fxStore.update(key, (current) => readyEntry(current, rate, this.dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
       } catch (error) {
@@ -918,18 +1035,22 @@ export class MarketDataCoordinator {
     });
   }
 
-  subscribeQuotes(targets: Array<{ instrument: InstrumentRef }>): () => void {
+  subscribeQuotes(targets: Array<{ instrument: InstrumentRef; priority?: QuoteSubscriptionPriority }>): () => void {
     if (!this.dataProvider.subscribeQuotes || targets.length === 0) {
       return () => {};
     }
 
+    const subscriptionId = this.nextQuoteSubscriptionId++;
     const subscribedKeys = new Set<string>();
-    for (const { instrument } of targets) {
+    for (const { instrument, priority } of targets) {
       const key = buildQuoteKey(instrument);
       subscribedKeys.add(key);
+      const target = this.quoteTargetFromInstrument(instrument, priority);
       const existing = this.quoteSubscriptions.get(key);
       if (existing) {
-        existing.refCount += 1;
+        existing.targets.set(subscriptionId, target);
+        existing.target = mergeQuoteSubscriptionTargets(existing.targets.values()) ?? target;
+        this.pendingQuoteSubscriptionKeys.add(key);
         if (existing.removeTimer) {
           clearTimeout(existing.removeTimer);
           existing.removeTimer = null;
@@ -937,9 +1058,8 @@ export class MarketDataCoordinator {
         continue;
       }
       this.quoteSubscriptions.set(key, {
-        target: this.quoteTargetFromInstrument(instrument),
-        refCount: 1,
-        unsubscribe: null,
+        target,
+        targets: new Map([[subscriptionId, target]]),
         removeTimer: null,
       });
       this.pendingQuoteSubscriptionKeys.add(key);
@@ -950,44 +1070,68 @@ export class MarketDataCoordinator {
       for (const key of subscribedKeys) {
         const existing = this.quoteSubscriptions.get(key);
         if (!existing) continue;
-        existing.refCount = Math.max(0, existing.refCount - 1);
-        if (existing.refCount > 0 || existing.removeTimer) continue;
+        existing.targets.delete(subscriptionId);
+        const mergedTarget = mergeQuoteSubscriptionTargets(existing.targets.values());
+        if (mergedTarget) {
+          existing.target = mergedTarget;
+          this.pendingQuoteSubscriptionKeys.add(key);
+          this.flushQuoteSubscriptions();
+          continue;
+        }
+        if (existing.removeTimer) continue;
         existing.removeTimer = setTimeout(() => {
           const current = this.quoteSubscriptions.get(key);
-          if (!current || current.refCount > 0) return;
-          current.unsubscribe?.();
+          if (!current || current.targets.size > 0) return;
           this.quoteSubscriptions.delete(key);
           this.pendingQuoteSubscriptionKeys.delete(key);
+          this.flushQuoteSubscriptions();
         }, QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS);
       }
     };
   }
 
   private flushQuoteSubscriptions(): void {
-    const keys = this.pendingQuoteSubscriptionKeys;
+    if (!this.dataProvider.subscribeQuotes) return;
     this.pendingQuoteSubscriptionKeys = new Set();
-    for (const key of keys) {
-      const entry = this.quoteSubscriptions.get(key);
-      if (!entry || entry.refCount === 0 || entry.unsubscribe) continue;
-      entry.unsubscribe = this.dataProvider.subscribeQuotes?.([entry.target], (target, quote) => {
-        const instrument: InstrumentRef = {
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-          brokerId: target.context?.brokerId,
-          brokerInstanceId: target.context?.brokerInstanceId,
-          instrument: target.context?.instrument ?? null,
-        };
-        this.applyStreamQuote(instrument, quote);
-      }) ?? null;
-    }
+
+    const activeEntries = [...this.quoteSubscriptions.entries()]
+      .filter(([, entry]) => entry.targets.size > 0 || entry.removeTimer)
+      .sort(([left], [right]) => left.localeCompare(right));
+    const nextSignature = activeEntries.map(([key, entry]) => [
+      key,
+      entry.target.surface ?? "",
+      entry.target.visible ? "visible" : "",
+      entry.target.selected ? "selected" : "",
+      Number.isFinite(entry.target.weight) ? entry.target.weight : "",
+    ].join(":")).join("|");
+    if (nextSignature === this.quoteSubscriptionSignature) return;
+
+    this.quoteSubscriptionDispose?.();
+    this.quoteSubscriptionDispose = null;
+    this.quoteSubscriptionSignature = nextSignature;
+
+    const targets = activeEntries.map(([, entry]) => entry.target);
+    if (targets.length === 0) return;
+
+    this.quoteSubscriptionDispose = this.dataProvider.subscribeQuotes(targets, (target, quote) => {
+      const instrument: InstrumentRef = {
+        symbol: target.symbol,
+        exchange: target.exchange ?? "",
+        brokerId: target.context?.brokerId,
+        brokerInstanceId: target.context?.brokerInstanceId,
+        instrument: target.context?.instrument ?? null,
+      };
+      this.applyStreamQuote(instrument, quote);
+    });
   }
 
   private applyStreamQuote(instrument: InstrumentRef, quote: Quote): void {
     const key = buildQuoteKey(instrument);
     const current = this.quoteStore.get(key);
     if (areStreamQuotesEquivalent(current.data ?? current.lastGoodData, quote)) return;
-    const attempts = [createAttempt(quote.providerId ?? this.dataProvider.id, Date.now(), "success")];
-    this.quoteStore.set(key, readyQuoteEntry(current, quote, quote.providerId ?? this.dataProvider.id, attempts));
+    const receivedAt = Date.now();
+    const attempts = [createAttempt(quote.providerId ?? this.dataProvider.id, receivedAt, "success")];
+    this.quoteStore.set(key, readyQuoteEntry(current, { ...quote, receivedAt }, quote.providerId ?? this.dataProvider.id, attempts));
   }
 }
 

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

@@ -73,6 +73,12 @@ function HooksHarness() {
   return <text>{String(tick)}</text>;
 }
 
+function FxRatesHarness() {
+  latestFxRates = useFxRatesMap(["usd", "EUR", null]);
+
+  return <text>fx</text>;
+}
+
 function ChartQueriesHarness({
   initialRequests,
   debounceMs,
@@ -147,6 +153,31 @@ describe("market-data hooks", () => {
     expect(latestFinancialsMap).toBe(initialFinancialsMap);
   });
 
+  test("does not load USD exchange rates from providers", async () => {
+    const loadedFxCurrencies: string[] = [];
+    const coordinator = {
+      subscribe: () => () => {},
+      getVersion: () => 1,
+      getFxEntry: (currency: string) => (currency === "EUR" ? readyEurEntry : readyUsdEntry),
+      loadFxRate: async (currency: string) => {
+        loadedFxCurrencies.push(currency);
+      },
+    };
+    setSharedMarketDataCoordinator(coordinator as unknown as MarketDataCoordinator);
+
+    testSetup = await testRender(<FxRatesHarness />, {
+      width: 20,
+      height: 1,
+    });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    expect(latestFxRates?.get("USD")).toBe(1);
+    expect(loadedFxCurrencies).toEqual(["EUR"]);
+  });
+
   test("debounces chart query batches and cancels superseded schedules", async () => {
     const loadedRanges: string[] = [];
     const idleChartEntry = createIdleEntry<PricePoint[]>();

package/src/market-data/hooks.tsx

@@ -283,6 +283,7 @@ export function useFxRatesMap(currencies: Array<string | null | undefined>): Map
     const coordinator = getSharedMarketDataCoordinator();
     if (!coordinator) return;
     for (const currency of normalizedCurrencies) {
+      if (currency === "USD") continue;
       void coordinator.loadFxRate(currency);
     }
   }, [normalizedCurrencyKey]);

package/src/news/aggregator.test.ts

@@ -312,4 +312,45 @@ describe("NewsService", () => {
     expect(detail?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
     expect(state.articles[0]?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
   });
+
+  it("keeps story detail identity when a duplicate feed item wins ranking", async () => {
+    const url = "https://detail.example.com/duplicate-story";
+    const cloudArticle = makeItem({
+      id: "story-1",
+      url,
+      importance: 60,
+      publishedAt: new Date("2026-04-01T10:00:00.000Z"),
+      items: [],
+    });
+    const feedDuplicate = makeItem({
+      id: "rss-1",
+      url,
+      importance: 95,
+      publishedAt: new Date("2026-04-01T10:05:00.000Z"),
+    });
+    const detailArticle = makeItem({
+      ...cloudArticle,
+      items: [{
+        id: "item-1",
+        sourceKey: "wire-a",
+        sourceName: "Wire A",
+        title: "Original",
+        url: "https://detail.example.com/original",
+        publishedAt: new Date("2026-04-01T10:00:00.000Z"),
+      }],
+    });
+
+    agg.register({ ...makeStorySource("cloud", [cloudArticle], detailArticle), priority: 10 });
+    agg.register({ ...makeSource("rss", [feedDuplicate]), priority: 2000 });
+
+    const initial = await agg.load({ feed: "top", limit: 10 });
+
+    expect(initial.articles[0]?.id).toBe("story-1");
+    expect(initial.articles[0]?.importance).toBe(95);
+
+    await agg.loadStory(initial.articles[0]!.id);
+    const state = agg.getQueryState({ feed: "top", limit: 10 });
+
+    expect(state.articles[0]?.items?.map((item) => item.id)).toEqual(["item-1"]);
+  });
 });