gloomberb 0.7.0 → 0.7.1

package/src/sources/provider-router.ts

@@ -8,9 +8,11 @@ import type {
   CachedFinancialsTarget,
   DataProvider,
   MarketDataRequestContext,
+  QuoteBatchResult,
   QuoteSubscriptionTarget,
   SearchRequestContext,
   SecFilingItem,
+  TickerFinancialsBatchResult,
 } from "../types/data-provider";
 import type { CapabilityRouteSource } from "../types/capability-route-source";
 import { routeSourcePriority } from "../types/capability-route-source";
@@ -150,6 +152,16 @@ function hasAnalystResearchValue(data: AnalystResearchData): boolean {
     || data.revenueEstimates.length > 0;
 }
 
+function hasAnalystRatingPriceTargets(data: AnalystResearchData): boolean {
+  return data.ratings.some((rating) => (
+    rating.currentPriceTarget != null || rating.priorPriceTarget != null
+  ));
+}
+
+function isAnalystResearchMissingRatingTargets(data: AnalystResearchData): boolean {
+  return data.ratings.length > 0 && !hasAnalystRatingPriceTargets(data);
+}
+
 function hasCorporateActionsValue(data: CorporateActionsData): boolean {
   return data.dividends.length > 0
     || data.splits.length > 0
@@ -345,6 +357,135 @@ export class AssetDataRouter implements DataProvider {
     return results;
   }
 
+  async getQuotesBatch(
+    targets: QuoteSubscriptionTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QuoteBatchResult[]> {
+    const forceRefresh = options.forceRefresh === true;
+    const results = new Array<QuoteBatchResult | null>(targets.length).fill(null);
+    const misses: Array<{ index: number; target: QuoteSubscriptionTarget }> = [];
+
+    targets.forEach((target, index) => {
+      const context = target.context;
+      const entityKey = this.getEntityKey(target.symbol, target.exchange, context?.instrument);
+      const variantKeys = this.getTickerVariantCandidates(target.exchange);
+      const sourceKeys = [
+        ...this.getBrokerCandidatesForContext(context, false).map((candidate) => this.brokerSourceKey(candidate)),
+        ...this.getProviderSourceKeys(),
+      ];
+      const rawCached = this.selectCachedResource<Quote>("quote", entityKey, variantKeys, sourceKeys, false);
+      const cached = rawCached && !isQuoteStaleForCurrentSession(rawCached.value)
+        ? rawCached
+        : null;
+      if (cached && !forceRefresh && !cached.stale) {
+        results[index] = { target, quote: cached.value };
+        return;
+      }
+      misses.push({ index, target });
+    });
+
+    const batchProvider = this.providersInPriorityOrder().find((provider) => provider.getQuotesBatch);
+    const providerMisses = misses.filter(({ target }) => !this.hasBrokerContext(target.context));
+    const providerIndexes = new Map<string, Array<{ index: number; target: QuoteSubscriptionTarget }>>();
+    if (batchProvider && providerMisses.length > 0) {
+      for (const entry of providerMisses) {
+        const key = this.quoteBatchKey(entry.target);
+        const bucket = providerIndexes.get(key) ?? [];
+        bucket.push(entry);
+        providerIndexes.set(key, bucket);
+      }
+      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) continue;
+        const key = this.quoteBatchKey(item.target);
+        const sourceKey = this.providerSourceKey(batchProvider);
+        for (const entry of providerIndexes.get(key) ?? []) {
+          const entityKey = this.getEntityKey(entry.target.symbol, entry.target.exchange, entry.target.context?.instrument);
+          const variantKey = this.getTickerVariantCandidates(entry.target.exchange)[0] ?? "";
+          this.cacheResource("quote", entityKey, variantKey, sourceKey, item.quote, this.resolveProviderPolicy("quote", batchProvider));
+          results[entry.index] = { target: entry.target, quote: item.quote };
+        }
+      }
+    }
+
+    await Promise.all(misses.map(async ({ index, target }) => {
+      if (results[index]) return;
+      try {
+        const quote = await this.getQuote(target.symbol, target.exchange, {
+          ...target.context,
+          cacheMode: forceRefresh ? "refresh" : "default",
+        });
+        results[index] = { target, quote };
+      } catch (error) {
+        results[index] = { target, quote: null, error };
+      }
+    }));
+
+    return results.map((result, index) => result ?? { target: targets[index]!, quote: null });
+  }
+
+  async getTickerFinancialsBatch(
+    targets: CachedFinancialsTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<TickerFinancialsBatchResult[]> {
+    const forceRefresh = options.forceRefresh === true;
+    const results = new Array<TickerFinancialsBatchResult | null>(targets.length).fill(null);
+    const misses: Array<{ index: number; target: CachedFinancialsTarget }> = [];
+
+    targets.forEach((target, index) => {
+      const context = this.contextFromCachedTarget(target);
+      const cached = this.readCachedMergedFinancialsSelection(target.symbol, target.exchange, context, true);
+      if (cached.value && !forceRefresh) {
+        results[index] = { target, financials: cached.value };
+        return;
+      }
+      misses.push({ index, target });
+    });
+
+    const batchProvider = this.providersInPriorityOrder().find((provider) => provider.getTickerFinancialsBatch);
+    const providerMisses = misses.filter(({ target }) => !this.hasCachedTargetBrokerContext(target));
+    const providerIndexes = new Map<string, Array<{ index: number; target: CachedFinancialsTarget }>>();
+    if (batchProvider && providerMisses.length > 0) {
+      for (const entry of providerMisses) {
+        const key = this.cachedFinancialsBatchKey(entry.target);
+        const bucket = providerIndexes.get(key) ?? [];
+        bucket.push(entry);
+        providerIndexes.set(key, bucket);
+      }
+      const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
+      const batchResults = await batchProvider.getTickerFinancialsBatch!(uniqueTargets, options).catch(() => []);
+      for (const item of batchResults) {
+        if (!item.financials) continue;
+        const key = this.cachedFinancialsBatchKey(item.target);
+        const value = resolveTickerFinancialsQuoteState(normalizeTickerFinancialsPriceHistory(item.financials));
+        if (!value) continue;
+        const sourceKey = this.providerSourceKey(batchProvider);
+        for (const entry of providerIndexes.get(key) ?? []) {
+          const entityKey = this.getEntityKey(entry.target.symbol, entry.target.exchange, entry.target.instrument ?? undefined);
+          const variantKey = this.getTickerVariantCandidates(entry.target.exchange)[0] ?? "";
+          this.cacheResource("financials", entityKey, variantKey, sourceKey, value, this.resolveProviderPolicy("financials", batchProvider));
+          results[entry.index] = { target: entry.target, financials: value };
+        }
+      }
+    }
+
+    await Promise.all(misses.map(async ({ index, target }) => {
+      if (results[index]) return;
+      try {
+        const financials = await this.getTickerFinancials(target.symbol, target.exchange, {
+          ...this.contextFromCachedTarget(target),
+          cacheMode: forceRefresh ? "refresh" : "default",
+        });
+        results[index] = { target, financials };
+      } catch (error) {
+        results[index] = { target, financials: null, error };
+      }
+    }));
+
+    return results.map((result, index) => result ?? { target: targets[index]!, financials: null });
+  }
+
   async getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials> {
     const cached = this.readCachedMergedFinancialsSelection(ticker, exchange, context, false);
     const forceRefresh = context?.cacheMode === "refresh";
@@ -518,9 +659,9 @@ export class AssetDataRouter implements DataProvider {
   async getAnalystResearch(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<AnalystResearchData> {
     const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
     const variantKeys = this.getTickerVariantCandidates(exchange);
-    const cached = this.selectCachedResource<AnalystResearchData>("analystResearch", entityKey, variantKeys, this.getProviderSourceKeys(), false);
+    const cached = this.selectCachedAnalystResearch(entityKey, variantKeys, this.getProviderSourceKeys(), false);
     const forceRefresh = context?.cacheMode === "refresh";
-    if (cached && !forceRefresh) {
+    if (cached && !forceRefresh && !isAnalystResearchMissingRatingTargets(cached.value)) {
       this.scheduleRevalidation(this.makeRevalidationKey("analystResearch", ticker, exchange, context), async () => {
         await this.revalidateAnalystResearch(ticker, exchange, context);
       });
@@ -876,7 +1017,17 @@ export class AssetDataRouter implements DataProvider {
     sourceKeys: string[],
     allowExpired: boolean,
   ): CachedResourceRecord<T> | null {
-    return this.listCachedResources(kind, entityKey, variantKeys, sourceKeys, allowExpired)[0] ?? null;
+    return this.listCachedResources<T>(kind, entityKey, variantKeys, sourceKeys, allowExpired)[0] ?? null;
+  }
+
+  private selectCachedAnalystResearch(
+    entityKey: string,
+    variantKeys: string[],
+    sourceKeys: string[],
+    allowExpired: boolean,
+  ): CachedResourceRecord<AnalystResearchData> | null {
+    const records = this.listCachedResources<AnalystResearchData>("analystResearch", entityKey, variantKeys, sourceKeys, allowExpired);
+    return records.find((record) => !isAnalystResearchMissingRatingTargets(record.value)) ?? records[0] ?? null;
   }
 
   private selectCachedArrayResource<T>(
@@ -1005,14 +1156,42 @@ export class AssetDataRouter implements DataProvider {
     );
   }
 
-  private getStreamingBrokerCandidate(target: QuoteSubscriptionTarget): BrokerCandidate | null {
-    const hasBrokerContext = !!(
-      target.context?.brokerId
-      || target.context?.brokerInstanceId
-      || target.context?.instrument?.brokerId
-      || target.context?.instrument?.brokerInstanceId
+  private hasBrokerContext(context?: MarketDataRequestContext): boolean {
+    return !!(
+      context?.brokerId ||
+      context?.brokerInstanceId ||
+      context?.instrument?.brokerId ||
+      context?.instrument?.brokerInstanceId
     );
-    if (!hasBrokerContext) return null;
+  }
+
+  private hasCachedTargetBrokerContext(target: CachedFinancialsTarget): boolean {
+    return !!(
+      target.brokerId ||
+      target.brokerInstanceId ||
+      target.instrument?.brokerId ||
+      target.instrument?.brokerInstanceId
+    );
+  }
+
+  private contextFromCachedTarget(target: CachedFinancialsTarget): MarketDataRequestContext {
+    return {
+      brokerId: target.brokerId,
+      brokerInstanceId: target.brokerInstanceId,
+      instrument: target.instrument ?? null,
+    };
+  }
+
+  private quoteBatchKey(target: QuoteSubscriptionTarget): string {
+    return `${target.symbol.trim().toUpperCase()}:${canonicalExchange(target.exchange ?? "")}`;
+  }
+
+  private cachedFinancialsBatchKey(target: CachedFinancialsTarget): string {
+    return `${target.symbol.trim().toUpperCase()}:${canonicalExchange(target.exchange ?? "")}`;
+  }
+
+  private getStreamingBrokerCandidate(target: QuoteSubscriptionTarget): BrokerCandidate | null {
+    if (!this.hasBrokerContext(target.context)) return null;
     return this.getBrokerCandidatesForContext(target.context, false)
       .find((candidate) => typeof candidate.broker.subscribeQuotes === "function") ?? null;
   }
@@ -1579,6 +1758,7 @@ export class AssetDataRouter implements DataProvider {
     const entityKey = this.getEntityKey(ticker, exchange, context?.instrument);
     const variantKey = this.getTickerVariantCandidates(exchange)[0] ?? "";
     let firstEmptyResult: SourceResult<AnalystResearchData> | null = null;
+    let firstIncompleteResult: SourceResult<AnalystResearchData> | null = null;
     let lastError: unknown = null;
 
     for (const provider of this.providersInPriorityOrder()) {
@@ -1587,7 +1767,13 @@ export class AssetDataRouter implements DataProvider {
         const value = await provider.getAnalystResearch(ticker, exchange, context);
         const sourceKey = this.providerSourceKey(provider);
         this.cacheResource("analystResearch", entityKey, variantKey, sourceKey, value, this.resolveProviderPolicy("analystResearch", provider));
-        if (hasAnalystResearchValue(value)) return { sourceKey, value };
+        if (hasAnalystResearchValue(value)) {
+          if (isAnalystResearchMissingRatingTargets(value)) {
+            firstIncompleteResult ??= { sourceKey, value };
+            continue;
+          }
+          return { sourceKey, value };
+        }
         firstEmptyResult ??= { sourceKey, value };
       } catch (error) {
         lastError = error;
@@ -1597,6 +1783,7 @@ export class AssetDataRouter implements DataProvider {
       }
     }
 
+    if (firstIncompleteResult) return firstIncompleteResult;
     if (firstEmptyResult) return firstEmptyResult;
     if (lastError) throw lastError;
     return null;

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

@@ -32,4 +32,48 @@ describe("YahooFinanceClient exchange aliases", () => {
     });
     expect(history[0]?.close).toBe(200);
   });
+
+  test("preserves analyst rating price targets from upgrade history", async () => {
+    const provider = new YahooFinanceClient() as any;
+    let requestUrl = "";
+    provider.getSymbolsToTry = () => ["AMD"];
+    provider.fetchJsonWithCrumb = async (_label: string, url: string) => {
+      requestUrl = url;
+      return {
+        quoteSummary: {
+          result: [{
+            price: { symbol: "AMD", currency: "USD", exchangeName: "NasdaqGS" },
+            financialData: {},
+            recommendationTrend: { trend: [] },
+            earningsTrend: { trend: [] },
+            upgradeDowngradeHistory: {
+              history: [{
+                epochGradeDate: 1778188318,
+                firm: "Citigroup",
+                toGrade: "Neutral",
+                fromGrade: "Neutral",
+                action: "main",
+                priceTargetAction: "Raises",
+                currentPriceTarget: 358,
+                priorPriceTarget: 248,
+              }],
+            },
+          }],
+        },
+      };
+    };
+
+    const research = await provider.getAnalystResearch("AMD", "NASDAQ");
+
+    expect(requestUrl).toContain("upgradeDowngradeHistory");
+    expect(research.ratings[0]).toMatchObject({
+      date: "2026-05-07",
+      firm: "Citigroup",
+      action: "Raises",
+      current: "Neutral",
+      prior: "Neutral",
+      currentPriceTarget: 358,
+      priorPriceTarget: 248,
+    });
+  });
 });

package/src/sources/yahoo-finance.ts

@@ -179,6 +179,8 @@ type QuoteSummaryResponse = {
           priceTargetAction?: string;
           toGrade?: string;
           fromGrade?: string;
+          currentPriceTarget?: { raw?: number } | number | null;
+          priorPriceTarget?: { raw?: number } | number | null;
         }>;
       };
       earningsTrend?: {
@@ -412,12 +414,16 @@ function mapYahooAnalystResearchResponse(
         const action = normalizeYahooRatingAction(rating.action, rating.priceTargetAction);
         const current = rating.toGrade?.trim();
         const prior = rating.fromGrade?.trim();
+        const currentPriceTarget = financeRawNumber(rating.currentPriceTarget);
+        const priorPriceTarget = financeRawNumber(rating.priorPriceTarget);
         return {
           date,
           firm,
           ...(action ? { action } : {}),
           ...(current ? { current } : {}),
           ...(prior ? { prior } : {}),
+          ...(currentPriceTarget != null ? { currentPriceTarget } : {}),
+          ...(priorPriceTarget != null ? { priorPriceTarget } : {}),
         };
       })
       .filter((rating): rating is AnalystResearchData["ratings"][number] => rating !== null)

package/src/state/app-bootstrap.ts

@@ -54,6 +54,8 @@ export interface InitializeAppStateArgs {
   primeCachedFinancials?: (entries: Array<{ ticker: TickerRecord; financials: TickerFinancials }>) => void;
   refreshTicker: (symbol: string, exchange?: string, tickerOverride?: TickerRecord | null, priority?: number) => void;
   refreshQuote: (symbol: string, exchange?: string, tickerOverride?: TickerRecord | null, priority?: number) => void;
+  refreshTickersBatch?: (entries: Array<{ ticker: TickerRecord; priority: number }>) => void;
+  refreshQuotesBatch?: (entries: Array<{ ticker: TickerRecord; priority: number }>) => void;
   autoImportBrokerPositions: (tickerMap: Map<string, TickerRecord>) => Promise<void>;
   persistedBrokerAccounts?: Record<string, BrokerAccount[]>;
 }
@@ -211,11 +213,11 @@ function buildCachedFinancialTarget(ticker: TickerRecord): CachedFinancialsTarge
   };
 }
 
-function resolveCachedFinancialPrimeEntries(
+async function resolveCachedFinancialPrimeEntries(
   refreshPlan: RefreshPlanEntry[],
   sessionSnapshot: AppSessionSnapshot | null | undefined,
   dataProvider: DataProvider,
-): Array<{ ticker: TickerRecord; financials: TickerFinancials }> {
+): Promise<Array<{ ticker: TickerRecord; financials: TickerFinancials }>> {
   if (!dataProvider.getCachedFinancialsForTargets) return [];
 
   const sessionTargetsBySymbol = new Map<string, CachedFinancialsTarget>();
@@ -226,7 +228,7 @@ function resolveCachedFinancialPrimeEntries(
   const financialEntries = refreshPlan.filter((entry) => entry.mode === "financials");
   if (financialEntries.length === 0) return [];
 
-  const cachedFinancials = dataProvider.getCachedFinancialsForTargets(
+  const cachedFinancials = await dataProvider.getCachedFinancialsForTargets(
     financialEntries.map(({ ticker }) => (
       sessionTargetsBySymbol.get(ticker.metadata.ticker.trim().toUpperCase()) ?? buildCachedFinancialTarget(ticker)
     )),
@@ -252,6 +254,8 @@ export async function initializeAppState({
   primeCachedFinancials,
   refreshTicker,
   refreshQuote,
+  refreshTickersBatch,
+  refreshQuotesBatch,
   autoImportBrokerPositions,
   persistedBrokerAccounts = {},
 }: InitializeAppStateArgs): Promise<void> {
@@ -341,7 +345,7 @@ export async function initializeAppState({
   });
 
   if (primeCachedFinancials) {
-    const cachedPrimeEntries = measurePerf(
+    const cachedPrimeEntries = await measurePerfAsync(
       "startup.resolve-cached-financial-prime",
       () => resolveCachedFinancialPrimeEntries(refreshPlan, sessionSnapshot, dataProvider),
       { financialRefreshCount: refreshPlan.filter((entry) => entry.mode === "financials").length },
@@ -362,10 +366,19 @@ export async function initializeAppState({
   });
 
   measurePerf("startup.enqueue-refresh-plan", () => {
-    for (const entry of refreshPlan) {
-      if (entry.mode === "financials") {
+    const financialEntries = refreshPlan.filter((entry) => entry.mode === "financials");
+    const quoteEntries = refreshPlan.filter((entry) => entry.mode === "quote");
+    if (refreshTickersBatch) {
+      refreshTickersBatch(financialEntries.map((entry) => ({ ticker: entry.ticker, priority: entry.priority })));
+    } else {
+      for (const entry of financialEntries) {
         refreshTicker(entry.ticker.metadata.ticker, entry.ticker.metadata.exchange, entry.ticker, entry.priority);
-      } else {
+      }
+    }
+    if (refreshQuotesBatch) {
+      refreshQuotesBatch(quoteEntries.map((entry) => ({ ticker: entry.ticker, priority: entry.priority })));
+    } else {
+      for (const entry of quoteEntries) {
         refreshQuote(entry.ticker.metadata.ticker, entry.ticker.metadata.exchange, entry.ticker, entry.priority);
       }
     }

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

@@ -3,7 +3,9 @@ import { act, useRef, type Dispatch } from "react";
 import { testRender } from "../renderers/opentui/test-utils";
 import { AppProvider, PaneInstanceProvider, useAppDispatch, useAppSelector, usePaneTicker, type AppAction } from "./app-context";
 import { cloneLayout, createDefaultConfig, type AppConfig } from "../types/config";
-import { applyTheme, getCurrentThemeId } from "../theme/colors";
+import { applyTheme } from "../theme/colors";
+import { useThemeId } from "../theme/theme-context";
+import type { DesktopSharedStateSnapshot, DesktopThemePreviewState, DesktopWindowBridge } from "../types/desktop-window";
 
 const TEST_PANE_ID = "ticker-detail:test";
 
@@ -20,6 +22,7 @@ function createTickerDetailConfig(symbol: string): AppConfig {
       binding: { kind: "fixed" as const, symbol },
     }],
     floating: [],
+    detached: [],
   };
 
   return {
@@ -43,7 +46,46 @@ function PaneTickerHarness() {
 
 function ThemeSelectorHarness() {
   const focusedPaneId = useAppSelector((state) => state.focusedPaneId);
-  return <text>{`${focusedPaneId ?? "none"}:${getCurrentThemeId()}`}</text>;
+  const themeId = useThemeId();
+  return <text>{`${focusedPaneId ?? "none"}:${themeId}`}</text>;
+}
+
+function FocusSelectorHarness() {
+  const renderCountRef = useRef(0);
+  renderCountRef.current += 1;
+  const focusedPaneId = useAppSelector((state) => state.focusedPaneId);
+  return <text>{`${focusedPaneId ?? "none"}:${renderCountRef.current}`}</text>;
+}
+
+function createDesktopBridge(
+  kind: "main" | "detached",
+  calls: {
+    mainSnapshots?: DesktopSharedStateSnapshot[];
+    themePreviews?: DesktopThemePreviewState[];
+    onThemePreviewSubscribe?: (listener: (preview: DesktopThemePreviewState) => void) => void;
+  } = {},
+): DesktopWindowBridge {
+  return {
+    kind,
+    paneId: kind === "detached" ? TEST_PANE_ID : undefined,
+    syncMainState: kind === "main"
+      ? async (snapshot) => {
+        calls.mainSnapshots?.push(snapshot);
+      }
+      : undefined,
+    syncThemePreview: kind === "main"
+      ? async (preview) => {
+        calls.themePreviews?.push(preview);
+      }
+      : undefined,
+    subscribeState: () => () => {},
+    subscribeThemePreview: kind === "detached"
+      ? (listener) => {
+        calls.onThemePreviewSubscribe?.(listener);
+        return () => {};
+      }
+      : undefined,
+  };
 }
 
 describe("pane selectors", () => {
@@ -100,7 +142,28 @@ describe("pane selectors", () => {
     expect(testSetup.captureCharFrame()).toContain("AAPL:1");
   });
 
-  test("rerenders selector consumers when the theme changes", async () => {
+  test("does not rerender non-theme selector consumers when the theme preview changes", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")}>
+        <DispatchCapture />
+        <FocusSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:1`);
+
+    await act(() => {
+      capturedDispatch?.({ type: "PREVIEW_THEME", theme: "green" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:1`);
+  });
+
+  test("rerenders theme hook consumers when the theme changes", async () => {
     testSetup = await testRender(
       <AppProvider config={createTickerDetailConfig("AAPL")}>
         <DispatchCapture />
@@ -121,7 +184,7 @@ describe("pane selectors", () => {
     expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
   });
 
-  test("rerenders selector consumers when the theme preview changes", async () => {
+  test("rerenders theme hook consumers when the theme preview changes", async () => {
     testSetup = await testRender(
       <AppProvider config={createTickerDetailConfig("AAPL")}>
         <DispatchCapture />
@@ -142,6 +205,33 @@ describe("pane selectors", () => {
     expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
   });
 
+  test("set theme updates the theme hook and clears the active preview", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")}>
+        <DispatchCapture />
+        <ThemeSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    await act(() => {
+      capturedDispatch?.({ type: "PREVIEW_THEME", theme: "green" });
+    });
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
+
+    await act(() => {
+      capturedDispatch?.({ type: "SET_THEME", theme: "red" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain(`${TEST_PANE_ID}:red`);
+    expect(frame).not.toContain(`${TEST_PANE_ID}:green`);
+  });
+
   test("falls back to the committed theme when theme preview clears", async () => {
     testSetup = await testRender(
       <AppProvider config={createTickerDetailConfig("AAPL")}>
@@ -181,4 +271,99 @@ describe("pane selectors", () => {
     await testSetup.renderOnce();
     expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
   });
+
+  test("uses the initial desktop theme preview on the first provider render", async () => {
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")} initialThemePreview={{ theme: "green" }}>
+        <ThemeSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
+  });
+
+  test("desktop main preview sync does not publish the full state snapshot", async () => {
+    const mainSnapshots: DesktopSharedStateSnapshot[] = [];
+    const themePreviews: DesktopThemePreviewState[] = [];
+    const bridge = createDesktopBridge("main", { mainSnapshots, themePreviews });
+
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")} desktopBridge={bridge}>
+        <DispatchCapture />
+        <ThemeSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    mainSnapshots.length = 0;
+    themePreviews.length = 0;
+
+    await act(() => {
+      capturedDispatch?.({ type: "PREVIEW_THEME", theme: "green" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    expect(themePreviews).toEqual([{ theme: "green" }]);
+    expect(mainSnapshots).toHaveLength(0);
+  });
+
+  test("desktop committed theme changes still sync through the config snapshot", async () => {
+    const mainSnapshots: DesktopSharedStateSnapshot[] = [];
+    const themePreviews: DesktopThemePreviewState[] = [];
+    const bridge = createDesktopBridge("main", { mainSnapshots, themePreviews });
+
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")} desktopBridge={bridge}>
+        <DispatchCapture />
+        <ThemeSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    mainSnapshots.length = 0;
+    themePreviews.length = 0;
+
+    await act(() => {
+      capturedDispatch?.({ type: "SET_THEME", theme: "green" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    expect(mainSnapshots).toHaveLength(1);
+    expect(mainSnapshots[0]?.config.theme).toBe("green");
+    expect(themePreviews).toHaveLength(0);
+  });
+
+  test("desktop detached windows apply theme preview messages locally", async () => {
+    let previewListener: ((preview: DesktopThemePreviewState) => void) | null = null;
+    const bridge = createDesktopBridge("detached", {
+      onThemePreviewSubscribe: (listener) => {
+        previewListener = listener;
+      },
+    });
+
+    testSetup = await testRender(
+      <AppProvider config={createTickerDetailConfig("AAPL")} desktopBridge={bridge}>
+        <ThemeSelectorHarness />
+      </AppProvider>,
+      { width: 32, height: 4 },
+    );
+
+    await testSetup.renderOnce();
+    expect(previewListener).not.toBeNull();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:amber`);
+
+    await act(() => {
+      previewListener?.({ theme: "green" });
+    });
+
+    await testSetup.renderOnce();
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain(`${TEST_PANE_ID}:green`);
+  });
 });