gloomberb 0.3.7 → 0.4.0

package/src/sources/provider-router.ts

@@ -16,9 +16,22 @@ import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types
 import type { BrokerContractRef, InstrumentSearchResult } from "../types/instrument";
 import type { CachePolicy, CachePolicyMap } from "../types/persistence";
 import type { TimeRange } from "../components/chart/chart-types";
+import {
+  isIntradayResolution,
+  normalizeChartResolutionSupport,
+  type ChartResolutionSupport,
+  type ManualChartResolution,
+} from "../components/chart/chart-resolution";
 import { hasLikelyQuoteUnitMismatch } from "../utils/currency-units";
 import { debugLog } from "../utils/debug-log";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../utils/price-history";
+import { isQuoteStaleForCurrentSession } from "../utils/quote-freshness";
+import {
+  mergeQuoteContributionMaps,
+  resolveCanonicalQuote,
+  resolveTickerFinancialsQuoteState,
+  seedQuoteContributions,
+} from "../utils/quote-resolution";
 import { isProviderMiss } from "./provider-errors";
 
 const providerLog = debugLog.createLogger("provider-router");
@@ -65,6 +78,15 @@ function normalizeExchange(exchange?: string): string {
   return (exchange ?? "").trim().toUpperCase();
 }
 
+function sanitizeCachedFinancials(financials: TickerFinancials): TickerFinancials {
+  if (!isQuoteStaleForCurrentSession(financials.quote)) return financials;
+  return {
+    ...financials,
+    quote: undefined,
+    quoteContributions: undefined,
+  };
+}
+
 function compactUrl(url: string): string {
   return url.trim();
 }
@@ -106,7 +128,7 @@ function buildVariantKey(parts: Array<[string, string | number | undefined | nul
 }
 
 function isIntradayRange(range: TimeRange): boolean {
-  return range === "1W" || range === "1M" || range === "3M";
+  return range === "1D" || range === "1W" || range === "1M" || range === "3M";
 }
 
 function hasMeaningfulFundamentals(data: TickerFinancials | null | undefined): boolean {
@@ -144,17 +166,23 @@ function mergeDefinedObject<T extends object>(preferred: T | null | undefined, f
 function mergeFinancials(primary: TickerFinancials | null, fallback: TickerFinancials | null): TickerFinancials | null {
   if (!primary || !fallback) {
     const single = primary ?? fallback;
-    return single ? normalizeTickerFinancialsPriceHistory(single) : null;
+    return single ? resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(single)) : null;
   }
 
   const preferFallbackPriceData = hasLikelyPriceUnitMismatch(primary, fallback);
   const dominant = preferFallbackPriceData ? fallback : primary;
   const secondary = preferFallbackPriceData ? primary : fallback;
+  const quoteContributions = mergeQuoteContributionMaps(
+    seedQuoteContributions(primary),
+    seedQuoteContributions(fallback),
+  );
+  const resolvedQuote = resolveCanonicalQuote(quoteContributions).quote;
 
   return {
     ...fallback,
     ...primary,
-    quote: mergeDefinedObject(dominant.quote, secondary.quote),
+    quote: resolvedQuote,
+    quoteContributions,
     profile: mergeDefinedObject(primary.profile, fallback.profile),
     fundamentals: mergeDefinedObject(primary.fundamentals, fallback.fundamentals),
     priceHistory: normalizePriceHistory(dominant.priceHistory.length > 0 ? dominant.priceHistory : secondary.priceHistory),
@@ -174,7 +202,7 @@ function mergeCachedFinancialRecords(records: CachedResourceRecord<TickerFinanci
   for (const record of records) {
     if (seenSources.has(record.sourceKey)) continue;
     seenSources.add(record.sourceKey);
-    merged = mergeFinancials(merged, record.value);
+    merged = mergeFinancials(merged, sanitizeCachedFinancials(record.value));
     stale = stale || record.stale;
   }
 
@@ -299,7 +327,10 @@ export class ProviderRouter implements DataProvider {
       ...this.getBrokerCandidatesForContext(context, false).map((candidate) => this.brokerSourceKey(candidate)),
       ...this.getProviderSourceKeys(),
     ];
-    const cached = this.selectCachedResource<Quote>("quote", entityKey, variantKeys, sourceKeys, false);
+    const rawCached = this.selectCachedResource<Quote>("quote", entityKey, variantKeys, sourceKeys, false);
+    const cached = rawCached && !isQuoteStaleForCurrentSession(rawCached.value)
+      ? rawCached
+      : null;
     const forceRefresh = context?.cacheMode === "refresh";
     if (cached && !forceRefresh && !cached.stale) {
       return cached.value;
@@ -503,6 +534,65 @@ export class ProviderRouter implements DataProvider {
     return providerHistory.value;
   }
 
+  async getPriceHistoryForResolution(
+    ticker: string,
+    exchange: string,
+    bufferRange: TimeRange,
+    resolution: ManualChartResolution,
+    context?: MarketDataRequestContext,
+  ): Promise<PricePoint[]> {
+    const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
+    const variantKeys = [
+      buildVariantKey([["exchange", normalizeExchange(exchange)], ["range", bufferRange], ["resolution", resolution]]),
+      buildVariantKey([["range", bufferRange], ["resolution", resolution]]),
+    ];
+    const sourceKeys = [
+      ...this.getBrokerCandidatesForContext(context, false).map((candidate) => this.brokerSourceKey(candidate)),
+      ...this.getProviderSourceKeys(),
+    ];
+    const cached = this.selectCachedArrayResource<PricePoint>("price-history", entityKey, variantKeys, sourceKeys, false);
+    const cachedValue = cached ? normalizePriceHistory(cached.value) : [];
+    const forceRefresh = context?.cacheMode === "refresh";
+    if (cachedValue.length > 0 && !forceRefresh && cached && !cached.stale) {
+      return cachedValue;
+    }
+
+    const brokerHistory = await withBrokerTimeout(this.fetchBrokerPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context));
+    if (brokerHistory && brokerHistory.value.length > 0) return brokerHistory.value;
+
+    const providerHistory = await this.fetchProviderPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context);
+    if (providerHistory && providerHistory.value.length > 0) {
+      return providerHistory.value;
+    }
+    if (cachedValue.length > 0) return cachedValue;
+    if (!providerHistory) {
+      throw new Error(`No resolution-aware history provider available for ${ticker}`);
+    }
+    return providerHistory.value;
+  }
+
+  async getChartResolutionSupport(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Promise<ChartResolutionSupport[]> {
+    const brokerSupport = await withBrokerTimeout(this.fetchBrokerChartResolutionSupport(ticker, exchange, context));
+    if (brokerSupport && brokerSupport.value.length > 0) {
+      return brokerSupport.value;
+    }
+    const providerSupport = await this.fetchProviderChartResolutionSupport(ticker, exchange, context);
+    return providerSupport?.value ?? [];
+  }
+
+  async getChartResolutionCapabilities(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Promise<ManualChartResolution[]> {
+    const support = await this.getChartResolutionSupport(ticker, exchange, context);
+    return support.map((entry) => entry.resolution);
+  }
+
   async getDetailedPriceHistory(
     ticker: string,
     exchange: string,
@@ -717,6 +807,9 @@ export class ProviderRouter implements DataProvider {
     const brokerRecord = brokerSourceKeys.length > 0
       ? this.selectCachedResource<TickerFinancials>("financials", entityKey, variantKeys, brokerSourceKeys, allowExpired)
       : null;
+    const sanitizedBrokerRecord = brokerRecord
+      ? { ...brokerRecord, value: sanitizeCachedFinancials(brokerRecord.value) }
+      : null;
     const providerSelection = mergeCachedFinancialRecords(
       this.listCachedResources<TickerFinancials>(
         "financials",
@@ -727,10 +820,10 @@ export class ProviderRouter implements DataProvider {
       ),
     );
     return {
-      brokerRecord,
+      brokerRecord: sanitizedBrokerRecord,
       providerValue: providerSelection.value,
-      value: mergeFinancials(brokerRecord?.value ?? null, providerSelection.value),
-      stale: (brokerRecord?.stale ?? false) || providerSelection.stale,
+      value: mergeFinancials(sanitizedBrokerRecord?.value ?? null, providerSelection.value),
+      stale: (sanitizedBrokerRecord?.stale ?? false) || providerSelection.stale,
     };
   }
 
@@ -880,12 +973,14 @@ export class ProviderRouter implements DataProvider {
     for (const candidate of this.getBrokerCandidatesForContext(context, false)) {
       if (!candidate.broker.getTickerFinancials) continue;
       try {
-        const result = normalizeTickerFinancialsPriceHistory(await candidate.broker.getTickerFinancials(
+        const rawResult = await candidate.broker.getTickerFinancials(
           ticker,
           candidate.instance,
           exchange,
           context?.instrument ?? null,
-        ));
+        );
+        const result = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawResult));
+        if (!result) continue;
         this.cacheResource(
           "financials",
           entityKey,
@@ -914,7 +1009,9 @@ export class ProviderRouter implements DataProvider {
 
     for (const provider of this.providersInPriorityOrder()) {
       try {
-        const value = normalizeTickerFinancialsPriceHistory(await provider.getTickerFinancials(ticker, exchange, context));
+        const rawValue = await provider.getTickerFinancials(ticker, exchange, context);
+        const value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(rawValue));
+        if (!value) continue;
         const sourceKey = this.providerSourceKey(provider);
         this.cacheResource(
           "financials",
@@ -1020,6 +1117,42 @@ export class ProviderRouter implements DataProvider {
     return null;
   }
 
+  private async fetchBrokerPriceHistoryForResolution(
+    ticker: string,
+    exchange: string,
+    bufferRange: TimeRange,
+    resolution: ManualChartResolution,
+    context?: MarketDataRequestContext,
+  ): Promise<SourceResult<PricePoint[]> | null> {
+    const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
+    const variantKey = buildVariantKey([["exchange", normalizeExchange(exchange)], ["range", bufferRange], ["resolution", resolution]]);
+    for (const candidate of this.getBrokerCandidatesForContext(context, false)) {
+      if (!candidate.broker.getPriceHistoryForResolution) continue;
+      try {
+        const result = normalizePriceHistory(await candidate.broker.getPriceHistoryForResolution(
+          ticker,
+          candidate.instance,
+          exchange,
+          bufferRange,
+          resolution,
+          context?.instrument ?? null,
+        ));
+        this.cacheResource(
+          "price-history",
+          entityKey,
+          variantKey,
+          this.brokerSourceKey(candidate),
+          result,
+          this.resolveBrokerPolicy(isIntradayResolution(resolution) ? "priceHistoryIntraday" : "priceHistoryDaily", candidate.broker),
+        );
+        return { sourceKey: this.brokerSourceKey(candidate), value: result };
+      } catch {
+        // continue
+      }
+    }
+    return null;
+  }
+
   private async fetchProviderPriceHistory(
     ticker: string,
     exchange: string,
@@ -1056,6 +1189,101 @@ export class ProviderRouter implements DataProvider {
     return firstEmptyResult;
   }
 
+  private async fetchProviderPriceHistoryForResolution(
+    ticker: string,
+    exchange: string,
+    bufferRange: TimeRange,
+    resolution: ManualChartResolution,
+    context?: MarketDataRequestContext,
+  ): Promise<SourceResult<PricePoint[]> | null> {
+    const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
+    const variantKey = buildVariantKey([["exchange", normalizeExchange(exchange)], ["range", bufferRange], ["resolution", resolution]]);
+    let firstEmptyResult: SourceResult<PricePoint[]> | null = null;
+
+    for (const provider of this.providersInPriorityOrder()) {
+      if (!provider.getPriceHistoryForResolution) continue;
+      try {
+        const value = normalizePriceHistory(await provider.getPriceHistoryForResolution(ticker, exchange, bufferRange, resolution, context));
+        const sourceKey = this.providerSourceKey(provider);
+        this.cacheResource(
+          "price-history",
+          entityKey,
+          variantKey,
+          sourceKey,
+          value,
+          this.resolveProviderPolicy(isIntradayResolution(resolution) ? "priceHistoryIntraday" : "priceHistoryDaily", provider),
+        );
+        if (value.length > 0) {
+          return { sourceKey, value };
+        }
+        firstEmptyResult ??= { sourceKey, value };
+      } catch (error) {
+        if (shouldLogProviderError(error)) {
+          providerLog.error(`${provider.id} failed: ${error}`);
+        }
+      }
+    }
+
+    return firstEmptyResult;
+  }
+
+  private async fetchBrokerChartResolutionSupport(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Promise<SourceResult<ChartResolutionSupport[]> | null> {
+    for (const candidate of this.getBrokerCandidatesForContext(context, false)) {
+      if (!candidate.broker.getChartResolutionSupport && !candidate.broker.getChartResolutionCapabilities) continue;
+      try {
+        const result = candidate.broker.getChartResolutionSupport
+          ? normalizeChartResolutionSupport(await candidate.broker.getChartResolutionSupport(
+            ticker,
+            candidate.instance,
+            exchange,
+            context?.instrument ?? null,
+          ))
+          : normalizeChartResolutionSupport(
+            (await candidate.broker.getChartResolutionCapabilities!(
+              ticker,
+              candidate.instance,
+              exchange,
+              context?.instrument ?? null,
+            )).map((resolution) => ({ resolution, maxRange: "ALL" })),
+          );
+        if (result.length === 0) continue;
+        return { sourceKey: this.brokerSourceKey(candidate), value: result };
+      } catch {
+        // continue
+      }
+    }
+    return null;
+  }
+
+  private async fetchProviderChartResolutionSupport(
+    ticker: string,
+    exchange?: string,
+    context?: MarketDataRequestContext,
+  ): Promise<SourceResult<ChartResolutionSupport[]> | null> {
+    for (const provider of this.providersInPriorityOrder()) {
+      if (!provider.getChartResolutionSupport && !provider.getChartResolutionCapabilities) continue;
+      try {
+        const result = provider.getChartResolutionSupport
+          ? normalizeChartResolutionSupport(await provider.getChartResolutionSupport(ticker, exchange, context))
+          : normalizeChartResolutionSupport(
+            (await provider.getChartResolutionCapabilities!(ticker, exchange, context)).map((resolution) => ({ resolution, maxRange: "ALL" })),
+          );
+        if (result.length === 0) continue;
+        return { sourceKey: this.providerSourceKey(provider), value: result };
+      } catch (error) {
+        if (shouldLogProviderError(error)) {
+          providerLog.error(`${provider.id} failed: ${error}`);
+        }
+      }
+    }
+
+    return null;
+  }
+
   private async fetchBrokerDetailedPriceHistory(
     ticker: string,
     exchange: string,

package/src/sources/yahoo-finance.test.ts

@@ -11,4 +11,30 @@ describe("YahooFinanceClient exchange aliases", () => {
     const provider = new YahooFinanceClient() as any;
     expect(provider.getSymbolsToTry("HY9H", "FWB2")).toEqual(["HY9H.F", "HY9H.DE"]);
   });
+
+  test("reports its manual chart resolution capabilities", () => {
+    const provider = new YahooFinanceClient();
+    expect(provider.getChartResolutionCapabilities()).toEqual(["5m", "15m", "1h", "1d", "1wk", "1mo"]);
+  });
+
+  test("maps manual resolution requests to yahoo chart range plus interval", async () => {
+    const provider = new YahooFinanceClient() as any;
+    let request: { symbol: string; range: string; interval: string } | null = null;
+    provider.fetchChart = async (symbol: string, range: string, interval: string) => {
+      request = { symbol, range, interval };
+      return {
+        meta: { currency: "USD" },
+        history: [{ date: new Date("2026-03-30T00:00:00Z"), close: 200 }],
+      };
+    };
+
+    const history = await provider.getPriceHistoryForResolution("AAPL", "NASDAQ", "1Y", "1wk");
+
+    expect(request).toEqual({
+      symbol: "AAPL",
+      range: "1y",
+      interval: "1wk",
+    });
+    expect(history[0]?.close).toBe(200);
+  });
 });

package/src/sources/yahoo-finance.ts

@@ -1,6 +1,11 @@
 import type { Quote, Fundamentals, FinancialStatement, PricePoint, TickerFinancials, MarketState, OptionContract, OptionsChain, CompanyProfile } from "../types/financials";
 import type { DataProvider, MarketDataRequestContext, NewsItem, SecFilingItem } from "../types/data-provider";
 import type { TimeRange } from "../components/chart/chart-types";
+import {
+  normalizeChartResolutionSupport,
+  type ChartResolutionSupport,
+  type ManualChartResolution,
+} from "../components/chart/chart-resolution";
 import type { InstrumentSearchResult } from "../types/instrument";
 import { SecEdgarClient } from "./sec-edgar";
 
@@ -272,6 +277,7 @@ const INTRADAY_HISTORY_TTL = 5 * 60_000; // 5 min for intraday ranges
 
 // Maps TimeRange → Yahoo API { range, interval } for optimal granularity
 const RANGE_PARAMS: Record<TimeRange, { range: string; interval: string; ttl: number }> = {
+  "1D": { range: "1d", interval: "5m", ttl: INTRADAY_HISTORY_TTL },
   "1W": { range: "5d", interval: "5m", ttl: INTRADAY_HISTORY_TTL },
   "1M": { range: "1mo", interval: "15m", ttl: INTRADAY_HISTORY_TTL },
   "3M": { range: "3mo", interval: "1h", ttl: QUOTE_TTL },
@@ -281,6 +287,15 @@ const RANGE_PARAMS: Record<TimeRange, { range: string; interval: string; ttl: nu
   "ALL": { range: "max", interval: "1wk", ttl: HISTORY_TTL },
 };
 
+const YAHOO_RESOLUTION_SUPPORT = normalizeChartResolutionSupport([
+  { resolution: "5m", maxRange: "1W" },
+  { resolution: "15m", maxRange: "1M" },
+  { resolution: "1h", maxRange: "3M" },
+  { resolution: "1d", maxRange: "5Y" },
+  { resolution: "1wk", maxRange: "ALL" },
+  { resolution: "1mo", maxRange: "ALL" },
+]);
+
 export class YahooFinanceClient implements DataProvider {
   readonly id = "yahoo";
   readonly name = "Yahoo Finance";
@@ -660,6 +675,7 @@ export class YahooFinanceClient implements DataProvider {
 
     const quote: Quote = {
       symbol,
+      providerId: this.id,
       price: currentPrice,
       currency: normalizedCurrency,
       change,
@@ -671,7 +687,10 @@ export class YahooFinanceClient implements DataProvider {
       lastUpdated: Date.now(),
       exchangeName: meta.exchangeName,
       fullExchangeName: meta.fullExchangeName,
+      listingExchangeName: meta.exchangeName,
+      listingExchangeFullName: meta.fullExchangeName,
       marketState,
+      sessionConfidence: "derived",
       dataSource: "yahoo",
       ...quoteSupplement,
       ...extHours,
@@ -799,6 +818,7 @@ export class YahooFinanceClient implements DataProvider {
 
         const quote: Quote = {
           symbol,
+          providerId: this.id,
           price,
           currency: normalizedCurrency,
           change,
@@ -809,7 +829,10 @@ export class YahooFinanceClient implements DataProvider {
           lastUpdated: Date.now(),
           exchangeName: meta.exchangeName,
           fullExchangeName: meta.fullExchangeName,
+          listingExchangeName: meta.exchangeName,
+          listingExchangeFullName: meta.fullExchangeName,
           marketState,
+          sessionConfidence: "derived",
           dataSource: "yahoo",
           ...quoteSupplement,
           ...extHours,
@@ -925,14 +948,26 @@ export class YahooFinanceClient implements DataProvider {
   }
 
   /** Fetch price history with appropriate granularity for the given time range */
-  async getPriceHistory(ticker: string, exchange = "", range: TimeRange, _context?: MarketDataRequestContext): Promise<PricePoint[]> {
-    const params = RANGE_PARAMS[range];
+  getChartResolutionSupport(): ChartResolutionSupport[] {
+    return YAHOO_RESOLUTION_SUPPORT;
+  }
+
+  getChartResolutionCapabilities(): ManualChartResolution[] {
+    return YAHOO_RESOLUTION_SUPPORT.map((entry) => entry.resolution);
+  }
+
+  private async loadPriceHistory(
+    ticker: string,
+    exchange: string,
+    range: string,
+    interval: ManualChartResolution,
+  ): Promise<PricePoint[]> {
     const symbolsToTry = this.getSymbolsToTry(ticker, exchange);
     let lastError: any;
 
     for (const symbol of symbolsToTry) {
       try {
-        const { meta, history } = await this.fetchChart(symbol, params.range, params.interval);
+        const { meta, history } = await this.fetchChart(symbol, range, interval);
 
         // Normalize sub-unit currencies in price history
         const { divisor } = normalizeSubUnitCurrency(meta.currency || "USD");
@@ -953,6 +988,22 @@ export class YahooFinanceClient implements DataProvider {
     throw lastError || new Error(`No history for ${ticker}`);
   }
 
+  async getPriceHistory(ticker: string, exchange = "", range: TimeRange, _context?: MarketDataRequestContext): Promise<PricePoint[]> {
+    const params = RANGE_PARAMS[range];
+    return this.loadPriceHistory(ticker, exchange, params.range, params.interval as ManualChartResolution);
+  }
+
+  async getPriceHistoryForResolution(
+    ticker: string,
+    exchange = "",
+    bufferRange: TimeRange,
+    resolution: ManualChartResolution,
+    _context?: MarketDataRequestContext,
+  ): Promise<PricePoint[]> {
+    const params = RANGE_PARAMS[bufferRange];
+    return this.loadPriceHistory(ticker, exchange, params.range, resolution);
+  }
+
   // ── Options Chain ──────────────────────────────────────────────────
 
   private mapContract(raw: Record<string, any>): OptionContract {

package/src/state/app-context-selector.test.tsx

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useRef, type Dispatch } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneTicker, type AppAction } from "./app-context";
+import { cloneLayout, createDefaultConfig, type AppConfig } from "../types/config";
+import { getCurrentThemeId } from "../theme/colors";
+
+const TEST_PANE_ID = "ticker-detail:test";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let capturedDispatch: Dispatch<AppAction> | null = null;
+
+function createTickerDetailConfig(symbol: string): AppConfig {
+  const config = createDefaultConfig("/tmp/gloomberb-test");
+  const layout = {
+    dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
+    instances: [{
+      instanceId: TEST_PANE_ID,
+      paneId: "ticker-detail",
+      binding: { kind: "fixed" as const, symbol },
+    }],
+    floating: [],
+  };
+
+  return {
+    ...config,
+    layout,
+    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+  };
+}
+
+function DispatchCapture() {
+  capturedDispatch = useAppDispatch();
+  return null;
+}
+
+function PaneTickerHarness() {
+  const renderCountRef = useRef(0);
+  renderCountRef.current += 1;
+  const { symbol } = usePaneTicker();
+  return <text>{`${symbol ?? "none"}:${renderCountRef.current}`}</text>;
+}
+
+function ThemeSelectorHarness() {
+  const focusedPaneId = useAppSelector((state) => state.focusedPaneId);
+  return <text>{`${focusedPaneId ?? "none"}:${getCurrentThemeId()}`}</text>;
+}
+
+describe("pane selectors", () => {
+  afterEach(() => {
+    testSetup?.renderer.destroy();
+    testSetup = undefined;
+    capturedDispatch = null;
+  });
+
+  test("does not rerender usePaneTicker consumers for unrelated app state updates", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")}>
+        <PaneInstanceProvider paneId={TEST_PANE_ID}>
+          <DispatchCapture />
+          <PaneTickerHarness />
+        </PaneInstanceProvider>
+      </AppProvider>,
+      { width: 24, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("AAPL:1");
+
+    await act(() => {
+      capturedDispatch?.({ type: "SET_COMMAND_BAR", open: true, query: "ticker" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("AAPL:1");
+  });
+
+  test("rerenders selector consumers when the theme changes", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")}>
+        <DispatchCapture />
+        <ThemeSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:amber`);
+
+    await act(() => {
+      capturedDispatch?.({ type: "SET_THEME", theme: "green" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
+  });
+});

package/src/state/app-context.test.ts

@@ -214,6 +214,24 @@ describe("broker account cache", () => {
   });
 });
 
+describe("pane state updates", () => {
+  test("returns the existing state object when a pane patch is a no-op", () => {
+    const initial = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
+    initial.paneState["portfolio-list:main"] = {
+      collectionId: "main",
+      cursorSymbol: "AAPL",
+    };
+
+    const next = appReducer(initial, {
+      type: "UPDATE_PANE_STATE",
+      paneId: "portfolio-list:main",
+      patch: { cursorSymbol: "AAPL" },
+    });
+
+    expect(next).toBe(initial);
+  });
+});
+
 describe("quote merging", () => {
   test("does not overwrite live broker quotes with cloud updates", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");