gloomberb 0.5.1 → 0.6.1

package/src/index.tsx

@@ -1,72 +1,6 @@
-import { createCliRenderer } from "@opentui/core";
-import { createRoot } from "@opentui/react";
-import { App } from "./app";
-import { getDataDir, initDataDir } from "./data/config-store";
-import { join } from "path";
-import { existsSync, mkdirSync } from "fs";
-import { dispatchCli } from "./cli/index";
-import { loadExternalPlugins } from "./plugins/loader";
-import { debugLog } from "./utils/debug-log";
-import { resetTerminalInputState } from "./utils/terminal-input-reset";
+import { startOpenTuiApp } from "./renderers/opentui/start";
 
-async function main() {
-  // Intercept console.log/warn/error to capture in debug log
-  debugLog.interceptConsole();
-
-  const appLog = debugLog.createLogger("app");
-  appLog.info("Gloomberb starting");
-
-  // Handle CLI subcommands (install, remove, update, plugins)
-  const cliArgs = process.argv.slice(2);
-  const externalPlugins = await loadExternalPlugins();
-  let cliLaunchRequest = null;
-  if (cliArgs.length > 0) {
-    const dispatchResult = await dispatchCli(cliArgs, { externalPlugins });
-    if (dispatchResult.kind === "handled") return;
-    if (dispatchResult.kind === "launch-ui") {
-      cliLaunchRequest = dispatchResult.request;
-    }
-  }
-
-  // Determine data directory
-  let dataDir = await getDataDir();
-
-  if (!dataDir) {
-    // First run - use default location
-    dataDir = join(process.env.HOME || "~", ".gloomberb");
-  }
-
-  // Ensure data dir exists
-  if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true });
-  }
-
-  // Load or create config
-  const config = await initDataDir(dataDir);
-
-  // `bun run --watch` does not guarantee the previous run's renderer can cleanly
-  // restore mouse/raw terminal modes before the next run starts.
-  resetTerminalInputState();
-
-  // Create renderer
-  const renderer = await createCliRenderer({
-    exitOnCtrlC: true,
-    backgroundColor: "#000000",
-    enableMouseMovement: true,
-  });
-
-  // Render app
-  createRoot(renderer).render(
-    <App
-      config={config}
-      renderer={renderer}
-      externalPlugins={externalPlugins}
-      cliLaunchRequest={cliLaunchRequest}
-    />
-  );
-}
-
-main().catch((err) => {
+startOpenTuiApp().catch((err) => {
   console.error("Fatal error:", err);
   process.exitCode = 1;
 });

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

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+import { MarketDataCoordinator } from "./coordinator";
+import { buildQuoteKey } from "./selectors";
+import { createTestDataProvider } from "../test-support/data-provider";
+import type { Quote } from "../types/financials";
+import type { DataProvider, QuoteSubscriptionTarget } from "../types/data-provider";
+
+function createProvider(): {
+  provider: DataProvider;
+  emitQuote: (target: QuoteSubscriptionTarget, quote: Quote) => void;
+} {
+  let onQuote: ((target: QuoteSubscriptionTarget, quote: Quote) => void) | null = null;
+  const provider = createTestDataProvider({
+    id: "test-provider",
+    subscribeQuotes: (_targets, handler) => {
+      onQuote = handler;
+      return () => {};
+    },
+  });
+  return {
+    provider,
+    emitQuote(target, quote) {
+      if (!onQuote) throw new Error("subscription was not registered");
+      onQuote(target, quote);
+    },
+  };
+}
+
+function quote(symbol: string, price: number, overrides: Partial<Quote> = {}): Quote {
+  return {
+    symbol,
+    price,
+    currency: "USD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.now(),
+    ...overrides,
+  };
+}
+
+async function flushCoordinator(): Promise<void> {
+  await Promise.resolve();
+}
+
+describe("MarketDataCoordinator key subscriptions", () => {
+  test("notifies listeners for changed keys only", async () => {
+    const { provider, emitQuote } = createProvider();
+    const coordinator = new MarketDataCoordinator(provider);
+    const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
+    const msft = { symbol: "MSFT", exchange: "NASDAQ" };
+    let aaplCalls = 0;
+    let msftCalls = 0;
+
+    coordinator.subscribeKeys([buildQuoteKey(aapl)], () => { aaplCalls += 1; });
+    coordinator.subscribeKeys([buildQuoteKey(msft)], () => { msftCalls += 1; });
+    coordinator.subscribeQuotes([{ instrument: aapl }, { instrument: msft }]);
+
+    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100));
+    await flushCoordinator();
+
+    expect(aaplCalls).toBe(1);
+    expect(msftCalls).toBe(0);
+  });
+
+  test("dedupes listeners subscribed to multiple changed keys", async () => {
+    const { provider, emitQuote } = createProvider();
+    const coordinator = new MarketDataCoordinator(provider);
+    const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
+    const msft = { symbol: "MSFT", exchange: "NASDAQ" };
+    let calls = 0;
+
+    coordinator.subscribeKeys([buildQuoteKey(aapl), buildQuoteKey(msft)], () => { calls += 1; });
+    coordinator.subscribeQuotes([{ instrument: aapl }, { instrument: msft }]);
+
+    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100));
+    emitQuote({ symbol: "MSFT", exchange: "NASDAQ" }, quote("MSFT", 200));
+    await flushCoordinator();
+
+    expect(calls).toBe(1);
+  });
+
+  test("coalesces global notifications per microtask", async () => {
+    const { provider, emitQuote } = createProvider();
+    const coordinator = new MarketDataCoordinator(provider);
+    const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
+    const msft = { symbol: "MSFT", exchange: "NASDAQ" };
+    let calls = 0;
+
+    coordinator.subscribe(() => { calls += 1; });
+    coordinator.subscribeQuotes([{ instrument: aapl }, { instrument: msft }]);
+
+    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100));
+    emitQuote({ symbol: "MSFT", exchange: "NASDAQ" }, quote("MSFT", 200));
+    await flushCoordinator();
+
+    expect(calls).toBe(1);
+    expect(coordinator.getVersion()).toBe(1);
+  });
+
+  test("ignores repeated stream quotes that only refresh timestamp noise", async () => {
+    const { provider, emitQuote } = createProvider();
+    const coordinator = new MarketDataCoordinator(provider);
+    const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
+    let calls = 0;
+
+    coordinator.subscribeKeys([buildQuoteKey(aapl)], () => { calls += 1; });
+    coordinator.subscribeQuotes([{ instrument: aapl }]);
+
+    const firstTimestamp = 1_700_000_000_000;
+    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp }));
+    await flushCoordinator();
+
+    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp + 10_000 }));
+    await flushCoordinator();
+
+    expect(calls).toBe(1);
+    expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp);
+
+    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 101, { lastUpdated: firstTimestamp + 20_000 }));
+    await flushCoordinator();
+
+    expect(calls).toBe(2);
+    expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(101);
+  });
+});

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

@@ -87,11 +87,80 @@ describe("MarketDataCoordinator", () => {
     const first = await coordinator.loadChart(request);
     expect(first.data?.length).toBe(2);
 
-    const second = await coordinator.loadChart(request);
+    const second = await coordinator.loadChart(request, { forceRefresh: true });
     expect(second.data).toBeNull();
     expect(second.lastGoodData?.length).toBe(2);
   });
 
+  it("reuses fresh snapshots instead of refetching on every pane rerender", async () => {
+    let calls = 0;
+    const provider = createProvider({
+      getTickerFinancials: async () => {
+        calls += 1;
+        return {
+          quote: {
+            symbol: "AAPL",
+            price: 100 + calls,
+            currency: "USD",
+            change: 1,
+            changePercent: 1,
+            lastUpdated: Date.now(),
+          },
+          fundamentals: { marketCap: calls },
+          profile: null,
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+        };
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+    const first = await coordinator.loadSnapshot(instrument);
+    const second = await coordinator.loadSnapshot(instrument);
+    const refreshed = await coordinator.loadSnapshot(instrument, { forceRefresh: true });
+
+    expect(first.data?.quote?.price).toBe(101);
+    expect(second.data?.quote?.price).toBe(101);
+    expect(refreshed.data?.quote?.price).toBe(102);
+    expect(calls).toBe(2);
+  });
+
+  it("reuses fresh empty tab query results instead of refetching on reopen", async () => {
+    let newsCalls = 0;
+    let optionsCalls = 0;
+    const provider = createProvider({
+      getNews: async () => {
+        newsCalls += 1;
+        return [];
+      },
+      getOptionsChain: async () => {
+        optionsCalls += 1;
+        return {
+          underlyingSymbol: "AAPL",
+          expirationDates: [],
+          calls: [],
+          puts: [],
+        };
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+    const firstNews = await coordinator.loadNews({ instrument, count: 20 });
+    const secondNews = await coordinator.loadNews({ instrument, count: 20 });
+    const firstOptions = await coordinator.loadOptions({ instrument });
+    const secondOptions = await coordinator.loadOptions({ instrument });
+
+    expect(firstNews.error?.reasonCode).toBe("NO_DATA");
+    expect(secondNews.error?.reasonCode).toBe("NO_DATA");
+    expect(firstOptions.error?.reasonCode).toBe("NO_DATA");
+    expect(secondOptions.error?.reasonCode).toBe("NO_DATA");
+    expect(newsCalls).toBe(1);
+    expect(optionsCalls).toBe(1);
+  });
+
   it("uses cached chart data while a wider range request is loading", async () => {
     const oneYearHistory = [
       { date: new Date("2024-01-01"), close: 100 },
@@ -346,7 +415,7 @@ describe("MarketDataCoordinator", () => {
           change: -0.021,
           changePercent: -7.89,
           lastUpdated: Date.now() - 1000,
-          dataSource: "yahoo",
+          dataSource: "delayed",
         },
         annualStatements: [],
         quarterlyStatements: [],
@@ -385,7 +454,7 @@ describe("MarketDataCoordinator", () => {
           change: -0.021,
           changePercent: -7.89,
           lastUpdated: Date.now() - 1000,
-          dataSource: "yahoo",
+          dataSource: "delayed",
         },
         annualStatements: [],
         quarterlyStatements: [],
@@ -432,7 +501,7 @@ describe("MarketDataCoordinator", () => {
           quote: {
             symbol: "HY9H",
             providerId: "yahoo",
-            dataSource: "yahoo",
+            dataSource: "delayed",
             price: 598,
             currency: "EUR",
             change: 6,

package/src/market-data/coordinator.ts

@@ -1,4 +1,5 @@
-import type { DataProvider, NewsItem, SecFilingItem } from "../types/data-provider";
+import type { DataProvider, SecFilingItem } from "../types/data-provider";
+import type { NewsArticle } from "../news/types";
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { ChartRequest, InstrumentRef, NewsRequest, OptionsRequest, SecFilingsRequest } from "./request-types";
 import { QueryStore } from "./query-store";
@@ -26,10 +27,19 @@ import { traceMarketData } from "./trace";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../utils/price-history";
 import { hasFreshQuoteForCurrentSession, isQuoteStaleForCurrentSession } from "../utils/quote-freshness";
 import { TIME_RANGE_ORDER } from "../components/chart/chart-resolution";
+import { measurePerf } from "../utils/perf-marks";
 
 const EMPTY_MESSAGE = "No data available";
 const EXPECTED_EMPTY = /no data|not found|delisted|unavailable|unsupported/i;
 const TIME_RANGE_INDEX = new Map(TIME_RANGE_ORDER.map((range, index) => [range, index]));
+const SNAPSHOT_CACHE_TTL_MS = 5 * 60_000;
+const CHART_CACHE_TTL_MS = 10 * 60_000;
+const NEWS_CACHE_TTL_MS = 2 * 60_000;
+const OPTIONS_CACHE_TTL_MS = 10 * 60_000;
+const SEC_FILINGS_CACHE_TTL_MS = 10 * 60_000;
+const SEC_CONTENT_CACHE_TTL_MS = 24 * 60 * 60_000;
+const ARTICLE_SUMMARY_CACHE_TTL_MS = 24 * 60 * 60_000;
+const FX_CACHE_TTL_MS = 30 * 60_000;
 
 function createBaselineChartRequest(instrument: InstrumentRef): ChartRequest {
   return {
@@ -69,6 +79,15 @@ function classifyError(error: unknown): { reasonCode: ProviderReasonCode; messag
   return { reasonCode: "UPSTREAM_ERROR", message };
 }
 
+function hasFreshEntryData<T>(entry: QueryEntry<T>, ttlMs: number, now = Date.now()): boolean {
+  if (resolveEntryData(entry) == null) return false;
+  return entry.fetchedAt != null && now - entry.fetchedAt < ttlMs;
+}
+
+function hasFreshReadyEntry<T>(entry: QueryEntry<T>, ttlMs: number, now = Date.now()): boolean {
+  return entry.phase === "ready" && entry.fetchedAt != null && now - entry.fetchedAt < ttlMs;
+}
+
 function createAttempt(
   providerId: string,
   startedAt: number,
@@ -132,6 +151,57 @@ function readyQuoteEntry(
   return readyEntry(current, quote, source, attempts, { keepLastGoodOnEmpty: true });
 }
 
+const STREAM_QUOTE_FIELDS: Array<keyof Quote> = [
+  "symbol",
+  "providerId",
+  "price",
+  "currency",
+  "change",
+  "changePercent",
+  "previousClose",
+  "high52w",
+  "low52w",
+  "marketCap",
+  "volume",
+  "name",
+  "exchangeName",
+  "fullExchangeName",
+  "listingExchangeName",
+  "listingExchangeFullName",
+  "routingExchangeName",
+  "routingExchangeFullName",
+  "marketState",
+  "sessionConfidence",
+  "preMarketPrice",
+  "preMarketChange",
+  "preMarketChangePercent",
+  "postMarketPrice",
+  "postMarketChange",
+  "postMarketChangePercent",
+  "bid",
+  "ask",
+  "bidSize",
+  "askSize",
+  "open",
+  "high",
+  "low",
+  "mark",
+  "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)
+    && JSON.stringify(current.provenance ?? null) === JSON.stringify(next.provenance ?? null);
+}
+
 function errorEntry<T>(current: QueryEntry<T>, attempt: ProviderAttempt): QueryEntry<T> {
   return {
     ...current,
@@ -147,28 +217,55 @@ function errorEntry<T>(current: QueryEntry<T>, attempt: ProviderAttempt): QueryE
 
 export class MarketDataCoordinator {
   private version = 0;
+  private pendingVersionBump = false;
+  private pendingChangedKeys = new Set<string>();
   private readonly listeners = new Set<() => void>();
+  private readonly keyListeners = new Map<string, Set<() => void>>();
+  private readonly keyVersions = new Map<string, number>();
   private readonly inFlight = new Map<string, Promise<unknown>>();
   private readonly chartRequests = new Map<string, ChartRequest>();
 
-  private readonly quoteStore = new QueryStore<Quote>(() => this.bump());
-  private readonly snapshotStore = new QueryStore<TickerFinancials>(() => this.bump());
-  private readonly profileStore = new QueryStore<TickerFinancials["profile"]>(() => this.bump());
-  private readonly fundamentalsStore = new QueryStore<TickerFinancials["fundamentals"]>(() => this.bump());
-  private readonly statementsStore = new QueryStore<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>(() => this.bump());
-  private readonly chartStore = new QueryStore<PricePoint[]>(() => this.bump());
-  private readonly newsStore = new QueryStore<NewsItem[]>(() => this.bump());
-  private readonly optionsStore = new QueryStore<OptionsChain>(() => this.bump());
-  private readonly secFilingsStore = new QueryStore<SecFilingItem[]>(() => this.bump());
-  private readonly secContentStore = new QueryStore<string | null>(() => this.bump());
-  private readonly articleSummaryStore = new QueryStore<string | null>(() => this.bump());
-  private readonly fxStore = new QueryStore<number>(() => this.bump());
+  private readonly quoteStore = new QueryStore<Quote>((key) => this.bump(key));
+  private readonly snapshotStore = new QueryStore<TickerFinancials>((key) => this.bump(key));
+  private readonly profileStore = new QueryStore<TickerFinancials["profile"]>((key) => this.bump(key));
+  private readonly fundamentalsStore = new QueryStore<TickerFinancials["fundamentals"]>((key) => this.bump(key));
+  private readonly statementsStore = new QueryStore<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>((key) => this.bump(key));
+  private readonly chartStore = new QueryStore<PricePoint[]>((key) => this.bump(key));
+  private readonly newsStore = new QueryStore<NewsArticle[]>((key) => this.bump(key));
+  private readonly optionsStore = new QueryStore<OptionsChain>((key) => this.bump(key));
+  private readonly secFilingsStore = new QueryStore<SecFilingItem[]>((key) => this.bump(key));
+  private readonly secContentStore = new QueryStore<string | null>((key) => this.bump(key));
+  private readonly articleSummaryStore = new QueryStore<string | null>((key) => this.bump(key));
+  private readonly fxStore = new QueryStore<number>((key) => this.bump(key));
 
   constructor(private readonly dataProvider: DataProvider) {}
 
-  private bump(): void {
-    this.version += 1;
-    for (const listener of this.listeners) listener();
+  private bump(changeKey?: string): void {
+    if (changeKey) this.pendingChangedKeys.add(changeKey);
+    if (this.pendingVersionBump) return;
+    this.pendingVersionBump = true;
+    queueMicrotask(() => this.flushBump());
+  }
+
+  private flushBump(): void {
+    this.pendingVersionBump = false;
+    const changedKeys = this.pendingChangedKeys;
+    this.pendingChangedKeys = new Set();
+    measurePerf("market-data.bump", () => {
+      this.version += 1;
+      for (const key of changedKeys) {
+        this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
+      }
+      const keyListeners = new Set<() => void>();
+      for (const key of changedKeys) {
+        for (const listener of this.keyListeners.get(key) ?? []) {
+          keyListeners.add(listener);
+        }
+      }
+
+      for (const listener of this.listeners) listener();
+      for (const listener of keyListeners) listener();
+    }, { changedKeyCount: changedKeys.size });
   }
 
   subscribe(listener: () => void): () => void {
@@ -178,10 +275,35 @@ export class MarketDataCoordinator {
     };
   }
 
+  subscribeKeys(keys: readonly string[], listener: () => void): () => void {
+    const uniqueKeys = [...new Set(keys)];
+    for (const key of uniqueKeys) {
+      if (!this.keyListeners.has(key)) this.keyListeners.set(key, new Set());
+      this.keyListeners.get(key)!.add(listener);
+    }
+    return () => {
+      for (const key of uniqueKeys) {
+        const listeners = this.keyListeners.get(key);
+        listeners?.delete(listener);
+        if (listeners?.size === 0) {
+          this.keyListeners.delete(key);
+        }
+      }
+    };
+  }
+
   getVersion(): number {
     return this.version;
   }
 
+  getKeysVersion(keys: readonly string[]): number {
+    let version = 0;
+    for (const key of new Set(keys)) {
+      version += this.keyVersions.get(key) ?? 0;
+    }
+    return version;
+  }
+
   getQuoteEntry(instrument: InstrumentRef): QueryEntry<Quote> {
     return this.quoteStore.get(buildQuoteKey(instrument));
   }
@@ -194,7 +316,7 @@ export class MarketDataCoordinator {
     return this.chartStore.get(buildChartKey(request));
   }
 
-  getNewsEntry(request: NewsRequest): QueryEntry<NewsItem[]> {
+  getNewsEntry(request: NewsRequest): QueryEntry<NewsArticle[]> {
     return this.newsStore.get(buildNewsKey(request));
   }
 
@@ -354,6 +476,10 @@ export class MarketDataCoordinator {
     options: { forceRefresh?: boolean } = {},
   ): Promise<QueryEntry<TickerFinancials>> {
     const key = buildSnapshotKey(instrument);
+    const current = this.snapshotStore.get(key);
+    if (!options.forceRefresh && hasFreshEntryData(current, SNAPSHOT_CACHE_TTL_MS)) {
+      return current;
+    }
     const flightKey = options.forceRefresh ? `${key}|refresh` : key;
     return this.runSingleFlight(flightKey, async () => {
       this.snapshotStore.update(key, loadingEntry);
@@ -448,6 +574,10 @@ export class MarketDataCoordinator {
   ): Promise<QueryEntry<PricePoint[]>> {
     const key = buildChartKey(request);
     this.chartRequests.set(key, request);
+    const current = this.chartStore.get(key);
+    if (!options.forceRefresh && hasFreshEntryData(current, CHART_CACHE_TTL_MS)) {
+      return current;
+    }
     const flightKey = options.forceRefresh ? `${key}|refresh` : key;
     return this.runSingleFlight(flightKey, async () => {
       this.chartStore.update(key, (current) => this.createChartLoadingEntry(key, request, current));
@@ -498,18 +628,33 @@ export class MarketDataCoordinator {
     });
   }
 
-  async loadNews(request: NewsRequest): Promise<QueryEntry<NewsItem[]>> {
+  async loadNews(request: NewsRequest): Promise<QueryEntry<NewsArticle[]>> {
     const key = buildNewsKey(request);
+    const current = this.newsStore.get(key);
+    if (hasFreshReadyEntry(current, NEWS_CACHE_TTL_MS)) {
+      return current;
+    }
     return this.runSingleFlight(key, async () => {
       this.newsStore.update(key, loadingEntry);
       const startedAt = Date.now();
       try {
-        const data = await this.dataProvider.getNews(
-          request.instrument.symbol,
-          request.count ?? 50,
-          request.instrument.exchange ?? "",
-          toMarketDataContext(request.instrument),
-        );
+        const newsProvider = this.dataProvider as DataProvider & {
+          getNews?: (query: {
+            feed: "ticker";
+            ticker: string;
+            exchange?: string;
+            tickerTier: "primary";
+            limit?: number;
+          }) => Promise<NewsArticle[]>;
+        };
+        if (!newsProvider.getNews) throw new Error("No news provider available");
+        const data = await newsProvider.getNews({
+          feed: "ticker",
+          ticker: request.instrument.symbol,
+          exchange: request.instrument.exchange ?? "",
+          tickerTier: "primary",
+          limit: request.count ?? 50,
+        });
         const attempts = [createAttempt(this.dataProvider.id, startedAt, data.length > 0 ? "success" : "empty", data.length === 0 ? "NO_DATA" : undefined)];
         return this.newsStore.update(key, (current) => readyEntry(current, data.length > 0 ? data : null, this.dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
       } catch (error) {
@@ -522,6 +667,10 @@ export class MarketDataCoordinator {
 
   async loadOptions(request: OptionsRequest): Promise<QueryEntry<OptionsChain>> {
     const key = buildOptionsKey(request);
+    const current = this.optionsStore.get(key);
+    if (hasFreshReadyEntry(current, OPTIONS_CACHE_TTL_MS)) {
+      return current;
+    }
     return this.runSingleFlight(key, async () => {
       this.optionsStore.update(key, loadingEntry);
       const startedAt = Date.now();
@@ -548,6 +697,10 @@ export class MarketDataCoordinator {
 
   async loadSecFilings(request: SecFilingsRequest): Promise<QueryEntry<SecFilingItem[]>> {
     const key = buildSecFilingsKey(request);
+    const current = this.secFilingsStore.get(key);
+    if (hasFreshReadyEntry(current, SEC_FILINGS_CACHE_TTL_MS)) {
+      return current;
+    }
     return this.runSingleFlight(key, async () => {
       this.secFilingsStore.update(key, loadingEntry);
       const startedAt = Date.now();
@@ -574,6 +727,10 @@ export class MarketDataCoordinator {
 
   async loadSecFilingContent(filing: SecFilingItem): Promise<QueryEntry<string | null>> {
     const key = buildSecContentKey(filing.accessionNumber);
+    const current = this.secContentStore.get(key);
+    if (hasFreshReadyEntry(current, SEC_CONTENT_CACHE_TTL_MS)) {
+      return current;
+    }
     return this.runSingleFlight(key, async () => {
       this.secContentStore.update(key, loadingEntry);
       const startedAt = Date.now();
@@ -596,6 +753,10 @@ export class MarketDataCoordinator {
 
   async loadArticleSummary(url: string): Promise<QueryEntry<string | null>> {
     const key = buildArticleSummaryKey(url);
+    const current = this.articleSummaryStore.get(key);
+    if (hasFreshReadyEntry(current, ARTICLE_SUMMARY_CACHE_TTL_MS)) {
+      return current;
+    }
     return this.runSingleFlight(key, async () => {
       this.articleSummaryStore.update(key, loadingEntry);
       const startedAt = Date.now();
@@ -614,6 +775,10 @@ export class MarketDataCoordinator {
 
   async loadFxRate(currency: string): Promise<QueryEntry<number>> {
     const key = buildFxKey(currency);
+    const current = this.fxStore.get(key);
+    if (hasFreshEntryData(current, FX_CACHE_TTL_MS)) {
+      return current;
+    }
     return this.runSingleFlight(key, async () => {
       this.fxStore.update(key, loadingEntry);
       const startedAt = Date.now();
@@ -650,6 +815,7 @@ export class MarketDataCoordinator {
       };
       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));
     });

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

@@ -1,6 +1,6 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { act, useState } from "react";
-import { testRender } from "@opentui/react/test-utils";
+import { testRender } from "../renderers/opentui/test-utils";
 import type { PricePoint, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "./coordinator";