gloomberb 0.7.0 → 0.7.1

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

@@ -487,6 +487,26 @@ 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);

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.ts

@@ -33,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("|");
@@ -168,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" : quoteMissingSymbols.has(symbol) ? "missing" : "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/theme/colors.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+  applyTheme,
+  clearTransientThemePreview,
+  getCurrentThemeId,
+  previewTheme,
+  syncTheme,
+} from "./colors";
+import { DEFAULT_THEME, getTheme } from "./themes";
+
+const originalDocument = (globalThis as Record<string, unknown>).document;
+
+function setDocument(value: unknown): void {
+  Object.defineProperty(globalThis, "document", {
+    configurable: true,
+    writable: true,
+    value,
+  });
+}
+
+function installDocumentStyleMock() {
+  const values = new Map<string, string>();
+  setDocument({
+    documentElement: {
+      style: {
+        setProperty(name: string, value: string) {
+          values.set(name, value);
+        },
+      },
+    },
+  });
+  return values;
+}
+
+afterEach(() => {
+  if (originalDocument === undefined) {
+    Reflect.deleteProperty(globalThis, "document");
+  } else {
+    setDocument(originalDocument);
+  }
+  clearTransientThemePreview();
+  syncTheme(DEFAULT_THEME);
+});
+
+describe("theme colors", () => {
+  test("syncs CSS variables when a theme is applied", () => {
+    const values = installDocumentStyleMock();
+    const theme = getTheme("midnight");
+
+    applyTheme("midnight");
+
+    expect(values.get("--gloom-bg")).toBe(theme.bg);
+    expect(values.get("--gloom-panel")).toBe(theme.panel);
+    expect(values.get("--gloom-text-dim")).toBe(theme.textDim);
+    expect(values.get("--gloom-selected")).toBe(theme.selected);
+    expect(values.get("--gloom-hover-bg")).toBeString();
+  });
+
+  test("does not let provider sync clobber a pending preview", () => {
+    const values = installDocumentStyleMock();
+    const preview = getTheme("midnight");
+
+    previewTheme("midnight");
+    syncTheme(DEFAULT_THEME);
+
+    expect(getCurrentThemeId()).toBe("midnight");
+    expect(values.get("--gloom-bg")).toBe(preview.bg);
+
+    clearTransientThemePreview();
+    syncTheme(DEFAULT_THEME);
+
+    expect(getCurrentThemeId()).toBe(DEFAULT_THEME);
+    expect(values.get("--gloom-bg")).toBe(getTheme(DEFAULT_THEME).bg);
+  });
+});

package/src/theme/colors.ts

@@ -5,7 +5,33 @@ import { getTheme, DEFAULT_THEME, type Theme } from "./themes";
 // React components re-read these on each render triggered by the SET_THEME action.
 export const colors: Omit<Theme, "name" | "description"> = { ...getTheme(DEFAULT_THEME) };
 
+export type ColorKey = keyof typeof colors;
+
 let currentThemeId = DEFAULT_THEME;
+let transientPreviewThemeId: string | null = null;
+let cssThemeId: string | null = null;
+let cssThemeDocument: unknown = null;
+
+const THEME_CSS_VARIABLES: Array<[ColorKey, string]> = [
+  ["bg", "--gloom-bg"],
+  ["panel", "--gloom-panel"],
+  ["border", "--gloom-border"],
+  ["borderFocused", "--gloom-border-focused"],
+  ["text", "--gloom-text"],
+  ["textDim", "--gloom-text-dim"],
+  ["textBright", "--gloom-text-bright"],
+  ["textMuted", "--gloom-text-muted"],
+  ["positive", "--gloom-positive"],
+  ["negative", "--gloom-negative"],
+  ["neutral", "--gloom-neutral"],
+  ["warning", "--gloom-warning"],
+  ["header", "--gloom-header"],
+  ["headerText", "--gloom-header-text"],
+  ["selected", "--gloom-selected"],
+  ["selectedText", "--gloom-selected-text"],
+  ["commandBg", "--gloom-command-bg"],
+  ["commandBorder", "--gloom-command-border"],
+];
 
 export function getCurrentThemeId(): string {
   return currentThemeId;
@@ -16,14 +42,34 @@ export function applyTheme(id: string): void {
   currentThemeId = id;
   // Mutate in-place so every existing import sees the new values
   Object.assign(colors, theme);
+  syncThemeCssVariables();
 }
 
-export function syncTheme(id: string): void {
-  if (currentThemeId === id) return;
+export function previewTheme(id: string): void {
+  transientPreviewThemeId = id;
   applyTheme(id);
 }
 
-export type ColorKey = keyof typeof colors;
+export function clearTransientThemePreview(): void {
+  transientPreviewThemeId = null;
+}
+
+export function syncTheme(id: string): void {
+  if (
+    transientPreviewThemeId
+    && currentThemeId === transientPreviewThemeId
+    && id !== transientPreviewThemeId
+  ) {
+    syncThemeCssVariables();
+    return;
+  }
+  transientPreviewThemeId = null;
+  if (currentThemeId === id) {
+    syncThemeCssVariables();
+    return;
+  }
+  applyTheme(id);
+}
 
 export { blendHex } from "./color-utils";
 
@@ -49,6 +95,21 @@ export function hoverBg(): string {
   return blendHex(colors.bg, colors.selected, 0.5);
 }
 
+function syncThemeCssVariables(): void {
+  const documentLike = (globalThis as {
+    document?: { documentElement?: { style?: { setProperty: (name: string, value: string) => void } } };
+  }).document;
+  const style = documentLike?.documentElement?.style;
+  if (!style) return;
+  if (cssThemeId === currentThemeId && cssThemeDocument === documentLike) return;
+  cssThemeId = currentThemeId;
+  cssThemeDocument = documentLike;
+  for (const [key, name] of THEME_CSS_VARIABLES) {
+    style.setProperty(name, colors[key]);
+  }
+  style.setProperty("--gloom-hover-bg", hoverBg());
+}
+
 export function commandBarBg(): string {
   const base = higherContrast(colors.commandBg, colors.panel, colors.bg);
   const accent = higherContrast(colors.textBright, colors.borderFocused, base);

package/src/theme/theme-context.tsx

@@ -0,0 +1,26 @@
+import { createContext, useContext, useMemo, type ReactNode } from "react";
+import { colors, getCurrentThemeId, syncTheme } from "./colors";
+import type { Theme } from "./themes";
+
+type ThemeColors = Omit<Theme, "name" | "description">;
+
+interface ThemeContextValue {
+  themeId: string;
+  colors: ThemeColors;
+}
+
+const ThemeContext = createContext<ThemeContextValue | null>(null);
+
+export function ThemeProvider({ themeId, children }: { themeId: string; children: ReactNode }) {
+  syncTheme(themeId);
+  const value = useMemo(() => ({ themeId, colors }), [themeId]);
+  return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
+}
+
+export function useThemeId(): string {
+  return useContext(ThemeContext)?.themeId ?? getCurrentThemeId();
+}
+
+export function useThemeColors(): ThemeColors {
+  return useContext(ThemeContext)?.colors ?? colors;
+}

package/src/types/capability-route-source.ts

@@ -6,6 +6,7 @@ export interface NewsDataProvider {
   supports?(query: NewsQuery): boolean;
   getCachedNews?(query: NewsQuery): NewsArticle[];
   fetchNews(query: NewsQuery): Promise<NewsArticle[]>;
+  fetchNewsStory?(storyId: string): Promise<NewsArticle | null>;
 }
 
 export interface CapabilityRouteSource {

package/src/types/data-provider.ts

@@ -92,6 +92,18 @@ export interface QuoteSubscriptionTarget {
   route?: "auto" | "provider" | "broker";
 }
 
+export interface QuoteBatchResult {
+  target: QuoteSubscriptionTarget;
+  quote: Quote | null;
+  error?: unknown;
+}
+
+export interface TickerFinancialsBatchResult {
+  target: CachedFinancialsTarget;
+  financials: TickerFinancials | null;
+  error?: unknown;
+}
+
 export interface AssetDataProvider {
   readonly id: string;
   readonly name: string;
@@ -99,7 +111,9 @@ export interface AssetDataProvider {
   readonly cachePolicy?: CachePolicyMap;
 
   canProvide?(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<boolean> | boolean;
-  getCachedFinancialsForTargets?(targets: CachedFinancialsTarget[], options?: { allowExpired?: boolean }): Map<string, TickerFinancials>;
+  getCachedFinancialsForTargets?(targets: CachedFinancialsTarget[], options?: { allowExpired?: boolean }): Map<string, TickerFinancials> | Promise<Map<string, TickerFinancials>>;
+  getQuotesBatch?(targets: QuoteSubscriptionTarget[], options?: { forceRefresh?: boolean }): Promise<QuoteBatchResult[]>;
+  getTickerFinancialsBatch?(targets: CachedFinancialsTarget[], options?: { forceRefresh?: boolean }): Promise<TickerFinancialsBatchResult[]>;
   getTickerFinancials(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<TickerFinancials>;
   getQuote(ticker: string, exchange?: string, context?: MarketDataRequestContext): Promise<Quote>;
   getExchangeRate(fromCurrency: string): Promise<number>;

package/src/types/desktop-window.ts

@@ -15,10 +15,15 @@ export interface DesktopDockPreviewState {
   edge: "left" | "right" | "top" | "bottom" | null;
 }
 
+export interface DesktopThemePreviewState {
+  theme: string | null;
+}
+
 export interface DesktopWindowBridge {
   kind: "main" | "detached";
   paneId?: string;
   syncMainState?(snapshot: DesktopSharedStateSnapshot): Promise<void>;
+  syncThemePreview?(preview: DesktopThemePreviewState): Promise<void>;
   replaceDetachedPaneState?(paneId: string, paneState: PaneRuntimeState): Promise<void>;
   popOutPane?(paneId: string): Promise<void>;
   dockDetachedPane?(paneId: string): Promise<void>;
@@ -26,4 +31,5 @@ export interface DesktopWindowBridge {
   focusDetachedPane?(paneId: string): Promise<void>;
   subscribeState(listener: (snapshot: DesktopSharedStateSnapshot) => void): () => void;
   subscribeDockPreview?(listener: (preview: DesktopDockPreviewState) => void): () => void;
+  subscribeThemePreview?(listener: (preview: DesktopThemePreviewState) => void): () => void;
 }

package/src/types/financials.ts

@@ -141,6 +141,8 @@ export interface AnalystRatingRecord {
   action?: string;
   current?: string;
   prior?: string;
+  currentPriceTarget?: number;
+  priorPriceTarget?: number;
 }
 
 export interface AnalystEstimateRecord {

package/src/types/plugin.ts

@@ -449,7 +449,7 @@ export interface GloomPluginContext {
   hidePane(paneId: string): void;
   focusPane(paneId: string): void;
   pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
-  navigateTicker(symbol: string): void;
+  navigateTicker(symbol: string, options?: { sourcePaneId?: string | null }): void;
   openPaneSettings(paneId?: string): void;
 
   on<K extends keyof PluginEvents>(event: K, handler: (payload: PluginEvents[K]) => void): () => void;

package/src/ui/host.tsx

@@ -98,13 +98,19 @@ export interface ScrollBoxRenderable {
   scrollTop: number;
   scrollLeft?: number;
   scrollHeight: number;
+  scrollTopPx?: number;
+  scrollLeftPx?: number;
+  scrollHeightPx?: number;
+  scrollWidthPx?: number;
   viewport?: { width: number; height: number };
+  viewportPx?: { width: number; height: number };
   visible?: boolean;
   parent?: unknown;
   getBoundingClientRect?: () => { x: number; y: number; width: number; height: number };
   horizontalScrollBar?: { visible: boolean };
   verticalScrollBar?: { visible: boolean };
   scrollTo(target: number | { x?: number; y?: number }, y?: number): void;
+  scrollToPixels?(target: number | { x?: number; y?: number }, y?: number): void;
 }
 
 export interface InputRenderable {

package/src/utils/api-client.test.ts

@@ -320,4 +320,36 @@ describe("apiClient cloud news", () => {
     expect(url.searchParams.get("cursor")).toBe("cursor-1");
     expect(result).toEqual({ items: [], nextCursor: null });
   });
+
+  test("fetches news story details from the story route", async () => {
+    let seenUrl = "";
+    globalThis.fetch = mockFetch(async (input: Request | string | URL) => {
+      seenUrl = String(input);
+      return createResponse({
+        id: "story-1",
+        headline: "Story headline",
+        summary: "Story summary",
+        category: "general",
+        sentiment: "neutral",
+        sectors: [],
+        firstPublishedAt: "2026-04-01T10:00:00.000Z",
+        lastPublishedAt: "2026-04-01T10:05:00.000Z",
+        firstSeenAt: "2026-04-01T10:00:10.000Z",
+        lastSeenAt: "2026-04-01T10:05:10.000Z",
+        primaryUrl: "https://example.com/story",
+        primarySource: "example-wire",
+        variantCount: 2,
+        sourceCount: 2,
+        sources: ["example-wire"],
+        entities: [],
+        tickerLinks: [],
+        items: [],
+      });
+    });
+
+    const story = await apiClient.getCloudNewsStory("story-1");
+
+    expect(new URL(seenUrl).pathname).toBe("/news/story-1");
+    expect(story.id).toBe("story-1");
+  });
 });