gloomberb 0.6.1 → 0.7.1

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`);
+  });
 });

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

@@ -111,6 +111,38 @@ describe("resolveTickerForPane", () => {
     )?.zIndex).toBe(21);
   });
 
+  test("raises the session-focused floating pane above tied saved z-order", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    config.layout = {
+      ...config.layout,
+      dockRoot: null,
+      floating: [
+        { instanceId: "ticker-detail:main", x: 4, y: 2, width: 60, height: 22, zIndex: 50 },
+        { instanceId: "chat:main", x: 8, y: 4, width: 48, height: 18, zIndex: 50 },
+      ],
+    };
+    config.layouts = config.layouts.map((entry, index) => (
+      index === config.activeLayoutIndex ? { ...entry, layout: cloneLayout(config.layout) } : entry
+    ));
+    const sessionSnapshot: AppSessionSnapshot = {
+      paneState: {},
+      focusedPaneId: "ticker-detail:main",
+      activePanel: "right",
+      statusBarVisible: true,
+      openPaneIds: ["ticker-detail:main", "chat:main"],
+      hydrationTargets: [],
+      exchangeCurrencies: ["USD"],
+      savedAt: Date.now(),
+    };
+
+    const state = createInitialState(config, sessionSnapshot);
+    const tickerEntry = state.config.layout.floating.find((entry) => entry.instanceId === "ticker-detail:main");
+    const chatEntry = state.config.layout.floating.find((entry) => entry.instanceId === "chat:main");
+
+    expect(tickerEntry?.zIndex).toBe(51);
+    expect((tickerEntry?.zIndex ?? 0) > (chatEntry?.zIndex ?? 0)).toBe(true);
+  });
+
   test("raises the desktop-snapshot focused floating pane during hydration", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     config.layout = {
@@ -455,6 +487,39 @@ describe("quote merging", () => {
 });
 
 describe("layout focus fallback", () => {
+  test("starts with the top floating pane focused when no session pane is active", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const layout = {
+      ...cloneLayout(config.layout),
+      dockRoot: { kind: "pane" as const, instanceId: "portfolio-list:main" },
+      floating: [
+        { instanceId: "chat:main", x: 4, y: 2, width: 36, height: 10, zIndex: 70 },
+        { instanceId: "ticker-detail:main", x: 12, y: 4, width: 36, height: 10, zIndex: 95 },
+      ],
+    };
+
+    const state = createInitialState({
+      ...config,
+      layout,
+      layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+    });
+
+    expect(state.focusedPaneId).toBe("ticker-detail:main");
+  });
+
+  test("cycles backward from a stale focused pane to the last visible pane", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const state = createInitialState(config);
+    state.focusedPaneId = "hidden:stale";
+
+    const next = appReducer(state, {
+      type: "FOCUS_PREV",
+      paneOrder: ["portfolio-list:main", "ticker-detail:main", "ticker-detail:nvda"],
+    });
+
+    expect(next.focusedPaneId).toBe("ticker-detail:nvda");
+  });
+
   test("focuses the highest remaining floating pane when the focused floating pane closes", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const backgroundPane = createPaneInstance("chat", {

package/src/state/app-context.tsx

@@ -13,14 +13,14 @@ import {
   type ReactNode,
 } from "react";
 import type { SessionStore } from "../data/session-store";
-import { syncTheme } from "../theme/colors";
+import { ThemeProvider } from "../theme/theme-context";
 import {
   findPaneInstance,
   materializeDetachedPanesAsFloating,
   type AppConfig,
   type PaneInstanceConfig,
 } from "../types/config";
-import type { DesktopSharedStateSnapshot, DesktopWindowBridge } from "../types/desktop-window";
+import type { DesktopSharedStateSnapshot, DesktopThemePreviewState, DesktopWindowBridge } from "../types/desktop-window";
 import { setPaneSetting } from "../pane-settings";
 import { useTickerFinancials } from "../market-data/hooks";
 import {
@@ -142,7 +142,7 @@ export function useAppSelector<T>(selector: (state: AppState) => T): T {
   const context = useRequiredAppContext();
   const selectorRef = useRef(selector);
   selectorRef.current = selector;
-  const lastSnapshotRef = useRef<{ selection: T; themeId: string } | undefined>(undefined);
+  const lastSnapshotRef = useRef<{ selection: T } | undefined>(undefined);
 
   if (!isAppStoreContextValue(context)) {
     return selector(context.state);
@@ -153,12 +153,11 @@ export function useAppSelector<T>(selector: (state: AppState) => T): T {
     () => {
       const state = context.getState();
       const selection = selectorRef.current(state);
-      const themeId = getEffectiveThemeId(state);
       const previous = lastSnapshotRef.current;
-      if (previous && Object.is(previous.selection, selection) && previous.themeId === themeId) {
+      if (previous && Object.is(previous.selection, selection)) {
         return previous;
       }
-      const nextSnapshot = { selection, themeId };
+      const nextSnapshot = { selection };
       lastSnapshotRef.current = nextSnapshot;
       return nextSnapshot;
     },
@@ -166,7 +165,6 @@ export function useAppSelector<T>(selector: (state: AppState) => T): T {
       const state = context.getState();
       return {
         selection: selectorRef.current(state),
-        themeId: getEffectiveThemeId(state),
       };
     },
   );
@@ -303,6 +301,7 @@ export function AppProvider({
   sessionSnapshot = null,
   desktopBridge,
   desktopSnapshot = null,
+  initialThemePreview = null,
 }: {
   config: AppConfig;
   children: ReactNode;
@@ -310,34 +309,40 @@ export function AppProvider({
   sessionSnapshot?: AppSessionSnapshot | null;
   desktopBridge?: DesktopWindowBridge;
   desktopSnapshot?: DesktopSharedStateSnapshot | null;
+  initialThemePreview?: DesktopThemePreviewState | null;
 }) {
   const [state, rawDispatch] = useReducer(
     appReducer,
-    { config, sessionSnapshot, desktopSnapshot },
+    { config, sessionSnapshot, desktopSnapshot, initialThemePreview },
     (initialState: {
       config: AppConfig;
       sessionSnapshot?: AppSessionSnapshot | null;
       desktopSnapshot?: DesktopSharedStateSnapshot | null;
+      initialThemePreview?: DesktopThemePreviewState | null;
     }) => {
       const {
         config: initialConfig,
         sessionSnapshot: initialSessionSnapshot,
         desktopSnapshot: initialDesktopSnapshot,
+        initialThemePreview: initialDesktopThemePreview,
       } = initialState;
-      const nextState = createInitialState(initialConfig, initialSessionSnapshot);
-      return initialDesktopSnapshot
-        ? appReducer(nextState, { type: "HYDRATE_DESKTOP_SNAPSHOT", snapshot: initialDesktopSnapshot })
+      const baseState = createInitialState(initialConfig, initialSessionSnapshot);
+      const nextState = initialDesktopSnapshot
+        ? appReducer(baseState, { type: "HYDRATE_DESKTOP_SNAPSHOT", snapshot: initialDesktopSnapshot })
+        : baseState;
+      return initialDesktopThemePreview
+        ? appReducer(nextState, { type: "PREVIEW_THEME", theme: initialDesktopThemePreview.theme })
         : nextState;
     },
   );
-  // Sync the current theme before descendants read the shared palette during this render.
-  syncTheme(getEffectiveThemeId(state));
+  const effectiveThemeId = getEffectiveThemeId(state);
   const previousRecentTickers = useRef(state.recentTickers);
   const stateRef = useRef(state);
   const listenersRef = useRef(new Set<() => void>());
   const storeRef = useRef<AppContextStoreValue | null>(null);
   const lastMainSyncRef = useRef<string | null>(null);
   const lastDetachedPaneSyncRef = useRef<string | null>(null);
+  const lastThemePreviewSyncRef = useRef<string | null | undefined>(undefined);
 
   stateRef.current = state;
 
@@ -421,12 +426,35 @@ export function AppProvider({
 
   useEffect(() => {
     if (desktopBridge?.kind !== "main" || !desktopBridge.syncMainState) return;
-    const snapshot = buildDesktopSnapshot(state);
+    const snapshot = buildDesktopSnapshot(stateRef.current);
     const signature = serializeDesktopSnapshot(snapshot);
     if (signature === lastMainSyncRef.current) return;
     lastMainSyncRef.current = signature;
     void desktopBridge.syncMainState(snapshot);
-  }, [buildDesktopSnapshot, desktopBridge, serializeDesktopSnapshot, state]);
+  }, [
+    buildDesktopSnapshot,
+    desktopBridge,
+    serializeDesktopSnapshot,
+    state.activePanel,
+    state.config,
+    state.focusedPaneId,
+    state.paneState,
+    state.statusBarVisible,
+  ]);
+
+  useEffect(() => {
+    if (desktopBridge?.kind !== "main" || !desktopBridge.syncThemePreview) return;
+    if (lastThemePreviewSyncRef.current === state.themePreview) return;
+    lastThemePreviewSyncRef.current = state.themePreview;
+    void desktopBridge.syncThemePreview({ theme: state.themePreview });
+  }, [desktopBridge, state.themePreview]);
+
+  useEffect(() => {
+    if (desktopBridge?.kind !== "detached" || !desktopBridge.subscribeThemePreview) return;
+    return desktopBridge.subscribeThemePreview((preview) => {
+      dispatch({ type: "PREVIEW_THEME", theme: preview.theme });
+    });
+  }, [desktopBridge, dispatch]);
 
   useEffect(() => {
     if (desktopBridge?.kind !== "detached" || !desktopBridge.replaceDetachedPaneState || !desktopBridge.paneId) return;
@@ -445,5 +473,9 @@ export function AppProvider({
 
   usePersistSessionSnapshot(sessionStore, state, APP_SESSION_ID, APP_SESSION_SCHEMA_VERSION);
 
-  return <AppContext.Provider value={storeRef.current}>{children}</AppContext.Provider>;
+  return (
+    <ThemeProvider themeId={effectiveThemeId}>
+      <AppContext.Provider value={storeRef.current}>{children}</AppContext.Provider>
+    </ThemeProvider>
+  );
 }

package/src/state/use-inline-tickers.test.tsx

@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../renderers/opentui/test-utils";
+import { setSharedMarketDataCoordinator } from "../market-data/coordinator";
+import { setSharedRegistryForTests, type PluginRegistry } from "../plugins/registry";
+import { createDefaultConfig } from "../types/config";
+import { AppContext, createInitialState } from "./app-context";
+import { useInlineTickers } from "./use-inline-tickers";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+function InlineTickerHarness() {
+  const { catalog } = useInlineTickers(["$LGD1L"]);
+  return <text>{catalog.LGD1L?.status ?? "none"}</text>;
+}
+
+afterEach(() => {
+  testSetup?.renderer.destroy();
+  testSetup = undefined;
+  setSharedMarketDataCoordinator(null);
+  setSharedRegistryForTests(undefined);
+});
+
+describe("useInlineTickers", () => {
+  test("does not leak rejected quote lookups for existing inline tickers", async () => {
+    const config = createDefaultConfig("/tmp/gloomberb-inline-tickers-test");
+    const state = createInitialState(config);
+    state.tickers.set("LGD1L", {
+      metadata: {
+        ticker: "LGD1L",
+        exchange: "NASDAQ",
+        currency: "USD",
+        name: "Unsupported quote",
+        portfolios: [],
+        watchlists: [],
+        positions: [],
+        broker_contracts: [],
+        custom: {},
+        tags: [],
+      },
+    });
+    const actions: unknown[] = [];
+    setSharedRegistryForTests({
+      marketData: {
+        getQuote: async () => {
+          throw new Error("No quote provider available for LGD1L");
+        },
+      },
+      pinTicker: () => {},
+    } as unknown as PluginRegistry);
+
+    await act(async () => {
+      testSetup = await testRender(
+        <AppContext value={{ state, dispatch: (action) => actions.push(action) }}>
+          <InlineTickerHarness />
+        </AppContext>,
+        { width: 20, height: 1 },
+      );
+    });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    await act(async () => {
+      await testSetup!.renderOnce();
+    });
+
+    expect(testSetup.captureCharFrame()).toContain("missing");
+    expect(actions).toEqual([]);
+  });
+});

package/src/state/use-inline-tickers.ts

@@ -18,6 +18,7 @@ export interface InlineTickerCatalogEntry {
 const resolutionInFlight = new Map<string, Promise<void>>();
 const quoteInFlight = new Map<string, Promise<void>>();
 const missingSymbols = new Set<string>();
+const quoteMissingSymbols = new Set<string>();
 const initialQuoteRequested = new Set<string>();
 
 function normalizeSymbols(texts: readonly string[]): string[] {
@@ -32,7 +33,7 @@ export function useInlineTickers(texts: readonly string[]): {
   const tickers = useAppSelector((state) => state.tickers);
   const financials = useAppSelector((state) => state.financials);
   const registry = getSharedRegistry();
-  const [, setRefreshVersion] = useState(0);
+  const [refreshVersion, setRefreshVersion] = useState(0);
   const textsKey = texts.join("\u0000");
   const symbols = useMemo(() => normalizeSymbols(texts), [textsKey]);
   const symbolsKey = symbols.join("|");
@@ -54,6 +55,7 @@ export function useInlineTickers(texts: readonly string[]): {
 
       if (currentTicker && currentQuote) {
         missingSymbols.delete(symbol);
+        quoteMissingSymbols.delete(symbol);
         initialQuoteRequested.delete(symbol);
         continue;
       }
@@ -123,8 +125,12 @@ export function useInlineTickers(texts: readonly string[]): {
               }
               : undefined,
           );
+          quoteMissingSymbols.delete(symbol);
           current.dispatch({ type: "MERGE_QUOTE", symbol, quote });
         })()
+          .catch(() => {
+            quoteMissingSymbols.add(symbol);
+          })
           .finally(() => {
             quoteInFlight.delete(symbol);
           });
@@ -162,15 +168,18 @@ export function useInlineTickers(texts: readonly string[]): {
     registry?.pinTicker(symbol, { floating: true, paneType: "ticker-detail" });
   }, [registry]);
 
-  const catalog: Record<string, InlineTickerCatalogEntry> = {};
-  for (const symbol of symbols) {
-    const ticker = tickers.get(symbol) ?? null;
-    const quote = financials.get(symbol)?.quote ?? null;
-    const status: InlineTickerStatus = ticker
-      ? (quote ? "ready" : "loading")
-      : (missingSymbols.has(symbol) ? "missing" : "loading");
-    catalog[symbol] = { status, ticker, quote };
-  }
+  const catalog = useMemo(() => {
+    const entries: Record<string, InlineTickerCatalogEntry> = {};
+    for (const symbol of symbols) {
+      const ticker = tickers.get(symbol) ?? null;
+      const quote = financials.get(symbol)?.quote ?? null;
+      const status: InlineTickerStatus = ticker
+        ? (quote ? "ready" : quoteMissingSymbols.has(symbol) ? "missing" : "loading")
+        : (missingSymbols.has(symbol) ? "missing" : "loading");
+      entries[symbol] = { status, ticker, quote };
+    }
+    return entries;
+  }, [financials, refreshVersion, symbols, tickers]);
 
   return { catalog, openTicker };
 }

package/src/test-support/plugin-runtime.ts

@@ -23,8 +23,9 @@ export function createTestPluginRuntime(
     switchTab() {},
     switchPanel() {},
     openCommandBar() {},
-    showWidget() {},
-    hideWidget() {},
+    showPane() {},
+    hidePane() {},
+    openPaneSettings() {},
     openPluginCommandWorkflow() {},
     notify() {},
     subscribeResumeState: () => () => {},