gloomberb 0.7.0 → 0.7.2

package/src/components/ticker-list-table.test.tsx

@@ -1,13 +1,17 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { act, useState } from "react";
+import { act, useEffect, useRef, useState } from "react";
 import { testRender } from "../renderers/opentui/test-utils";
 import type { ColumnConfig } from "../types/config";
 import type { TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
+import type { ScrollBoxRenderable } from "../ui";
 import { TickerListTable, type TickerTableCell } from "./ticker-list-table";
+import { TickerListTableView } from "./ticker-list-table-view";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let setHarnessCursorSymbol: ((symbol: string) => void) | null = null;
+let setHarnessTickers: ((tickers: TickerRecord[]) => void) | null = null;
+let tableScrollRef: ScrollBoxRenderable | null = null;
 let resolveCellCallCount = 0;
 
 const columns: ColumnConfig[] = [
@@ -60,6 +64,16 @@ function TickerListTableHarness() {
 
 function LargeTickerListTableHarness() {
   const [cursorSymbol, setCursorSymbol] = useState("T0");
+  const scrollRef = useRef<ScrollBoxRenderable>(null);
+
+  useEffect(() => {
+    tableScrollRef = scrollRef.current;
+    return () => {
+      if (tableScrollRef === scrollRef.current) {
+        tableScrollRef = null;
+      }
+    };
+  });
 
   return (
     <TickerListTable
@@ -71,6 +85,35 @@ function LargeTickerListTableHarness() {
       setCursorSymbol={setCursorSymbol}
       resolveCell={resolveCell}
       financialsMap={financialsMap}
+      scrollRef={scrollRef}
+    />
+  );
+}
+
+function ReorderingTickerListTableViewHarness() {
+  const [rows, setRows] = useState(manyTickers);
+  const scrollRef = useRef<ScrollBoxRenderable>(null);
+  setHarnessTickers = setRows;
+
+  useEffect(() => {
+    tableScrollRef = scrollRef.current;
+    return () => {
+      if (tableScrollRef === scrollRef.current) {
+        tableScrollRef = null;
+      }
+    };
+  });
+
+  return (
+    <TickerListTableView
+      focused
+      columns={columns}
+      tickers={rows}
+      cursorSymbol="T0"
+      setCursorSymbol={() => {}}
+      resolveCell={resolveCell}
+      financialsMap={financialsMap}
+      scrollRef={scrollRef}
     />
   );
 }
@@ -84,6 +127,8 @@ afterEach(async () => {
   }
   resolveCellCallCount = 0;
   setHarnessCursorSymbol = null;
+  setHarnessTickers = null;
+  tableScrollRef = null;
 });
 
 describe("TickerListTable", () => {
@@ -125,5 +170,41 @@ describe("TickerListTable", () => {
     expect(frame).toContain("T0");
     expect(frame).not.toContain("T999");
     expect(resolveCellCallCount).toBeLessThan(40);
+
+    await act(async () => {
+      for (let index = 0; index < 12; index++) {
+        await testSetup!.mockMouse.scroll(2, 2, "down");
+      }
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+
+    const scrollTop = tableScrollRef?.scrollTop ?? 0;
+    expect(scrollTop).toBeGreaterThan(0);
+    expect(testSetup.captureCharFrame()).toContain(`T${scrollTop}`);
+  });
+
+  test("preserves manual scroll when market data reorders rows around the same cursor", async () => {
+    testSetup = await testRender(
+      <ReorderingTickerListTableViewHarness />,
+      { width: 20, height: 8 },
+    );
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    tableScrollRef!.scrollTop = 20;
+    expect(tableScrollRef?.scrollTop).toBe(20);
+
+    await act(async () => {
+      setHarnessTickers?.([...manyTickers.slice(1), manyTickers[0]!]);
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(tableScrollRef?.scrollTop).toBe(20);
   });
 });

package/src/components/ticker-list-table.tsx

@@ -1,8 +1,18 @@
-import { Box, ScrollBox, Text, tickerContextMenuItems, useContextMenu, useRendererHost, useUiCapabilities } from "../ui";
+import {
+  Box,
+  ScrollBox,
+  Text,
+  tickerContextMenuItems,
+  useContextMenu,
+  useNativeRenderer,
+  useRendererHost,
+  useUiCapabilities,
+} from "../ui";
 import { memo, useCallback, useMemo, useRef, useState, type RefObject } from "react";
 import { TextAttributes, type ScrollBoxRenderable } from "../ui";
 import { EmptyState } from "./ui";
 import { colors, hoverBg } from "../theme/colors";
+import { useThemeColors } from "../theme/theme-context";
 import { getSharedRegistry } from "../plugins/registry";
 import type { ColumnConfig } from "../types/config";
 import type { TickerFinancials, PricePoint } from "../types/financials";
@@ -12,8 +22,8 @@ import { renderChart, resolveChartPalette, type StyledContent } from "./chart/ch
 import type { ProjectedChartPoint } from "./chart/chart-data";
 import { tableContentWidthProps, useMeasuredTableContentWidth } from "./ui/table-layout";
 import { useViewport } from "../react/input";
-import { useRafCallback } from "../react/use-raf-callback";
 import { measurePerf } from "../utils/perf-marks";
+import { useScrollBoxScrollActivity } from "./table-view-shared";
 
 export interface TickerTableCell {
   text: string;
@@ -102,6 +112,7 @@ const TickerListHeader = memo(function TickerListHeader({
   onHeaderClick?: (columnId: string) => void;
   onSizeChange?: () => void;
 }) {
+  useThemeColors();
   return (
     <ScrollBox
       ref={headerScrollRef}
@@ -211,6 +222,7 @@ const TickerListRow = memo(function TickerListRow({
   priceHistory?: PricePoint[];
   contentWidth: number;
 }) {
+  useThemeColors();
   const lastActivatedAtRef = useRef<number | null>(null);
   const rowBg = isSelected ? colors.selected : isHovered ? hoverBg() : colors.bg;
 
@@ -328,6 +340,7 @@ export function TickerListTable({
   const hoveredIdxRef = useRef(hoveredIdx);
   const appViewport = useViewport();
   const renderer = useRendererHost();
+  const nativeRenderer = useNativeRenderer();
   const { showContextMenu } = useContextMenu();
   const { nativeContextMenu } = useUiCapabilities();
   const [scrollVersion, setScrollVersion] = useState(0);
@@ -387,12 +400,16 @@ export function TickerListTable({
       setScrollVersion((current) => current + 1);
     }
     onBodyScrollActivity?.();
-  }, [onBodyScrollActivity, virtualize]);
+    nativeRenderer.requestRender();
+  }, [nativeRenderer, onBodyScrollActivity, virtualize]);
   const syncHeader = useCallback(() => {
     syncHeaderScroll?.();
   }, [syncHeaderScroll]);
-  const scheduleBodyScrollActivity = useRafCallback(handleBodyScrollActivity);
-  const scheduleHeaderScrollSync = useRafCallback(syncHeader);
+  useScrollBoxScrollActivity({
+    scrollRef: effectiveScrollRef,
+    onVerticalScroll: handleBodyScrollActivity,
+    onHorizontalScroll: syncHeader,
+  });
   const setHoveredIdxIfChanged = useCallback((index: number | null) => {
     if (hoveredIdxRef.current === index) return;
     setHoveredIdx(index);
@@ -448,10 +465,6 @@ export function TickerListTable({
         scrollX
         scrollY
         focusable={false}
-        onMouseDown={scheduleHeaderScrollSync}
-        onMouseUp={scheduleBodyScrollActivity}
-        onMouseDrag={scheduleBodyScrollActivity}
-        onMouseScroll={scheduleBodyScrollActivity}
         onSizeChange={measureContentWidth}
       >
         {tickers.length === 0 ? (

package/src/components/ui/data-table.tsx

@@ -1,14 +1,15 @@
-import { Box, ScrollBox, Text, useUiHost } from "../../ui";
+import { Box, ScrollBox, Text, useNativeRenderer, useUiHost } from "../../ui";
 import { useCallback, useEffect, useMemo, useState, type ComponentType, type ReactNode, type RefObject } from "react";
 import { TextAttributes, type ScrollBoxRenderable } from "../../ui";
 import { colors, hoverBg } from "../../theme/colors";
+import { useThemeColors } from "../../theme/theme-context";
 import type { ColumnConfig } from "../../types/config";
 import { useAppDispatch, usePaneInstance } from "../../state/app-context";
 import { useViewport } from "../../react/input";
 import { padTo } from "../../utils/format";
-import { useRafCallback } from "../../react/use-raf-callback";
 import { measurePerf } from "../../utils/perf-marks";
 import { useDoubleClickActivation } from "../use-double-click-activation";
+import { useScrollBoxScrollActivity } from "../table-view-shared";
 import { EmptyState } from "./status";
 import {
   expandTableColumns,
@@ -155,9 +156,11 @@ function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>({
   scrollToIndexAlign = "nearest",
   scrollToIndexVersion = 0,
 }: DataTableProps<T, C>) {
+  useThemeColors();
   const dispatch = useAppDispatch();
   const paneInstanceId = usePaneInstance()?.instanceId ?? null;
   const appViewport = useViewport();
+  const nativeRenderer = useNativeRenderer();
   const [scrollVersion, setScrollVersion] = useState(0);
   const scrollTop = virtualize ? (scrollRef.current?.scrollTop ?? 0) : 0;
   const measuredViewportHeight = scrollRef.current?.viewport?.height;
@@ -228,9 +231,13 @@ function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>({
       setScrollVersion((current) => current + 1);
     }
     onBodyScrollActivity();
-  }, [onBodyScrollActivity, virtualize]);
-  const scheduleBodyScrollActivity = useRafCallback(handleBodyScrollActivity);
-  const scheduleHeaderScrollSync = useRafCallback(syncHeaderScroll);
+    nativeRenderer.requestRender();
+  }, [nativeRenderer, onBodyScrollActivity, virtualize]);
+  useScrollBoxScrollActivity({
+    scrollRef,
+    onVerticalScroll: handleBodyScrollActivity,
+    onHorizontalScroll: syncHeaderScroll,
+  });
   const focusPane = useCallback(() => {
     if (!paneInstanceId) return;
     dispatch({ type: "FOCUS_PANE", paneId: paneInstanceId });
@@ -376,11 +383,7 @@ function OpenTuiDataTable<T, C extends DataTableColumn = DataTableColumn>({
         focusable={false}
         onMouseDown={() => {
           focusPane();
-          scheduleHeaderScrollSync();
         }}
-        onMouseUp={scheduleBodyScrollActivity}
-        onMouseDrag={scheduleBodyScrollActivity}
-        onMouseScroll={scheduleBodyScrollActivity}
         onSizeChange={measureContentWidth}
       >
         {items.length === 0 ? (

package/src/components/ui/frame.tsx

@@ -2,6 +2,7 @@ import { Box, Text, useUiHost } from "../../ui";
 import { TextAttributes } from "../../ui";
 import { type ComponentType, type ReactNode } from "react";
 import { colors } from "../../theme/colors";
+import { useThemeColors } from "../../theme/theme-context";
 
 export interface DialogFrameProps {
   title: string;
@@ -11,6 +12,7 @@ export interface DialogFrameProps {
 }
 
 export function DialogFrame({ title, children, footer, showTitleDivider = true }: DialogFrameProps) {
+  useThemeColors();
   const HostDialogFrame = useUiHost().DialogFrame as ComponentType<DialogFrameProps> | undefined;
   if (HostDialogFrame) {
     return (

package/src/components/ui/table-layout.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, test } from "bun:test";
-import { getTableWidth, hasMeaningfulTableHorizontalOverflow } from "./table-layout";
+import {
+  buildTableGridTemplateColumns,
+  getTableWidth,
+  hasMeaningfulTableHorizontalOverflow,
+} from "./table-layout";
 
 describe("table layout", () => {
   test("detects only meaningful horizontal table overflow", () => {
@@ -13,4 +17,26 @@ describe("table layout", () => {
     expect(hasMeaningfulTableHorizontalOverflow(tableWidth, tableWidth - 1)).toBe(false);
     expect(hasMeaningfulTableHorizontalOverflow(tableWidth, tableWidth - 2)).toBe(true);
   });
+
+  test("keeps non-flex web table columns fixed", () => {
+    const template = buildTableGridTemplateColumns([
+      { width: 4, align: "right" },
+      { width: 40, flexGrow: 1 },
+      { width: 24 },
+      { width: 5, align: "right" },
+    ]);
+
+    expect(template).toBe(
+      "minmax(4ch, 4ch) minmax(14ch, 40fr) minmax(8ch, 24ch) minmax(5ch, 5ch)",
+    );
+  });
+
+  test("keeps proportional web table columns when no column is flexible", () => {
+    const template = buildTableGridTemplateColumns([
+      { width: 12 },
+      { width: 8, align: "right" },
+    ]);
+
+    expect(template).toBe("minmax(8ch, 12fr) minmax(8ch, 8fr)");
+  });
 });

package/src/components/ui/table-layout.ts

@@ -1,9 +1,10 @@
 import { useCallback, useEffect, useState, type RefObject } from "react";
 import type { ScrollBoxRenderable } from "../../ui";
 
-interface TableWidthColumn {
+export interface TableWidthColumn {
   width: number;
   flexGrow?: number;
+  align?: string;
 }
 
 const TRAILING_COLUMN_GUTTER_WIDTH = 1;
@@ -32,6 +33,43 @@ export function expandTableColumns<C extends TableWidthColumn>(
   });
 }
 
+function normalizedColumnWidth(column: TableWidthColumn): number {
+  return Math.max(1, Math.floor(column.width));
+}
+
+function columnMinCh(column: TableWidthColumn): number {
+  const width = normalizedColumnWidth(column);
+  if ((column.flexGrow ?? 0) > 0) {
+    return Math.max(8, Math.min(18, Math.floor(width * 0.35)));
+  }
+  if (column.align === "right") {
+    return Math.max(3, Math.min(width, 8));
+  }
+  if (width >= 16) {
+    return Math.max(8, Math.min(16, Math.floor(width * 0.35)));
+  }
+  return Math.max(1, Math.min(width, 8));
+}
+
+function columnFlexWeight(column: TableWidthColumn): number {
+  const flexGrow = column.flexGrow ?? 0;
+  const baseWeight = normalizedColumnWidth(column);
+  return flexGrow > 0 ? baseWeight * Math.max(1, flexGrow) : baseWeight;
+}
+
+export function buildTableGridTemplateColumns(columns: readonly TableWidthColumn[]): string {
+  const hasFlexColumn = columns.some((column) => (column.flexGrow ?? 0) > 0);
+  return columns
+    .map((column) => {
+      const width = normalizedColumnWidth(column);
+      if (!hasFlexColumn || (column.flexGrow ?? 0) > 0) {
+        return `minmax(${columnMinCh(column)}ch, ${columnFlexWeight(column)}fr)`;
+      }
+      return `minmax(${columnMinCh(column)}ch, ${width}ch)`;
+    })
+    .join(" ");
+}
+
 export function useMeasuredTableContentWidth(
   tableWidth: number,
   headerScrollRef: RefObject<ScrollBoxRenderable | null> | undefined,

package/src/components/ui/tabs.tsx

@@ -1,4 +1,5 @@
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useShortcut } from "../../react/input";
 import { Box, ScrollBox, Text, useUiHost } from "../../ui";
 import { TextAttributes, type ScrollBoxRenderable } from "../../ui";
 import { colors, hoverBg } from "../../theme/colors";
@@ -21,6 +22,8 @@ export interface TabsProps {
   closeMode?: "active" | "always";
   addLabel?: string;
   onAdd?: () => void;
+  focused?: boolean;
+  keyboardNavigation?: boolean;
 }
 
 const WHEEL_DELTA_PER_CELL = 8;
@@ -34,6 +37,8 @@ export function Tabs({
   closeMode = "always",
   addLabel = "+",
   onAdd,
+  focused = false,
+  keyboardNavigation = true,
 }: TabsProps) {
   const ui = useUiHost();
   const NativeTabs = ui.Tabs;
@@ -51,6 +56,34 @@ export function Tabs({
     closeFg: colors.textMuted,
     addFg: colors.textMuted,
   };
+  const selectAdjacentTab = useCallback((direction: -1 | 1) => {
+    const enabledTabs = tabs.filter((tab) => !tab.disabled);
+    if (enabledTabs.length === 0) return;
+
+    const activeIndex = enabledTabs.findIndex((tab) => tab.value === activeValue);
+    const nextIndex = activeIndex >= 0
+      ? Math.max(0, Math.min(activeIndex + direction, enabledTabs.length - 1))
+      : direction > 0 ? 0 : enabledTabs.length - 1;
+    const nextTab = enabledTabs[nextIndex];
+    if (!nextTab || nextTab.value === activeValue) return;
+    onSelect(nextTab.value);
+  }, [activeValue, onSelect, tabs]);
+
+  useShortcut((event) => {
+    if (event.ctrl || event.meta || event.alt || event.targetEditable) return;
+
+    if (event.name === "h" || event.name === "left") {
+      event.preventDefault();
+      event.stopPropagation();
+      selectAdjacentTab(-1);
+      return;
+    }
+    if (event.name === "l" || event.name === "right") {
+      event.preventDefault();
+      event.stopPropagation();
+      selectAdjacentTab(1);
+    }
+  }, { enabled: focused && keyboardNavigation });
 
   if (NativeTabs) {
     return (

package/src/components/ui/ui.test.tsx

@@ -179,6 +179,15 @@ function DataTableVirtualizationHarness() {
     name: `Row ${index}`,
   }));
 
+  useEffect(() => {
+    tableScrollBoxForTest = scrollRef.current;
+    return () => {
+      if (tableScrollBoxForTest === scrollRef.current) {
+        tableScrollBoxForTest = null;
+      }
+    };
+  });
+
   return (
     <DataTable
       columns={[{ id: "name", label: "NAME", width: 12, align: "left" }]}
@@ -333,6 +342,46 @@ describe("shared UI kit", () => {
     expect(frame).toContain("Insider");
   });
 
+  test("moves focused tabs with arrow keys and leaves Tab for pane focus", async () => {
+    let lastSelected = "overview";
+
+    function KeyboardTabsHarness() {
+      const [activeValue, setActiveValue] = useState("overview");
+      return (
+        <Tabs
+          tabs={[
+            { label: "Overview", value: "overview" },
+            { label: "News", value: "news" },
+            { label: "Chart", value: "chart" },
+          ]}
+          activeValue={activeValue}
+          onSelect={(value) => {
+            lastSelected = value;
+            setActiveValue(value);
+          }}
+          focused
+        />
+      );
+    }
+
+    testSetup = await testRender(<KeyboardTabsHarness />, { width: 40, height: 4 });
+
+    await act(async () => {
+      await testSetup!.renderOnce();
+      testSetup!.mockInput.pressArrow("right");
+      await testSetup!.renderOnce();
+    });
+
+    expect(lastSelected).toBe("news");
+
+    await act(async () => {
+      testSetup!.mockInput.pressTab();
+      await testSetup!.renderOnce();
+    });
+
+    expect(lastSelected).toBe("news");
+  });
+
   test("renders tab actions for editable tab sets", async () => {
     testSetup = await testRender(
       <Tabs
@@ -747,8 +796,9 @@ describe("shared UI kit", () => {
     expect(tableScrollBoxForTest?.verticalScrollBar.visible).toBe(true);
   });
 
-  test("virtualizes data table rows by default", async () => {
+  test("virtualizes data table rows and refreshes after wheel scrolling", async () => {
     const state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
+    tableScrollBoxForTest = null;
     testSetup = await testRender(
       <AppContext value={{ state, dispatch: () => {} }}>
         <PaneInstanceProvider paneId="portfolio-list:main">
@@ -765,5 +815,22 @@ describe("shared UI kit", () => {
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("Row 0");
     expect(frame).not.toContain("Row 99");
+    expect(tableScrollBoxForTest?.scrollTop).toBe(0);
+
+    await act(async () => {
+      for (let index = 0; index < 12; index++) {
+        await testSetup!.mockMouse.scroll(2, 2, "down");
+      }
+      await Promise.resolve();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      await testSetup!.renderOnce();
+    });
+    await testSetup.renderOnce();
+
+    const scrollTop = tableScrollBoxForTest?.scrollTop ?? 0;
+    expect(scrollTop).toBeGreaterThan(0);
+
+    const scrolledFrame = testSetup.captureCharFrame();
+    expect(scrolledFrame).toContain(`Row ${scrollTop}`);
   });
 });

package/src/core/state/app-state.ts

@@ -318,23 +318,13 @@ function getTopFloatingPaneId(layout: LayoutConfig): string | null {
   return topInstanceId;
 }
 
-function resolveFocusedPaneId(
-  previousLayout: LayoutConfig,
-  nextLayout: LayoutConfig,
-  focusedPaneId: string | null,
-): string | null {
+function resolveFocusedPaneId(nextLayout: LayoutConfig, focusedPaneId: string | null): string | null {
   const paneOrder = getPaneOrder(nextLayout);
   if (paneOrder.length === 0) return null;
   if (focusedPaneId && paneOrder.includes(focusedPaneId)) {
     return focusedPaneId;
   }
-  const previouslyFloating = focusedPaneId
-    ? previousLayout.floating.some((entry) => entry.instanceId === focusedPaneId)
-    : false;
-  if (previouslyFloating) {
-    return getTopFloatingPaneId(nextLayout) ?? paneOrder[0] ?? null;
-  }
-  return paneOrder[0] ?? null;
+  return getTopFloatingPaneId(nextLayout) ?? paneOrder[0] ?? null;
 }
 
 function getPanelFocusTarget(layout: LayoutConfig, panel: "left" | "right"): string | null {
@@ -446,7 +436,7 @@ function withFocusedPane(state: AppState, config: AppConfig): AppState {
       layouts: syncLayouts(config.layouts, config.activeLayoutIndex, normalizedLayout),
     };
   const nextPaneState = reconcilePaneState(nextConfig, state.paneState);
-  const focusedPaneId = resolveFocusedPaneId(state.config.layout, nextConfig.layout, state.focusedPaneId);
+  const focusedPaneId = resolveFocusedPaneId(nextConfig.layout, state.focusedPaneId);
   const focusedConfig = bringFocusedFloatingPaneToFront(nextConfig, focusedPaneId);
   return {
     ...state,
@@ -854,7 +844,7 @@ export function appReducer(state: AppState, action: AppAction): AppState {
 
 export function createInitialState(config: AppConfig, sessionSnapshot: AppSessionSnapshot | null = null): AppState {
   const paneState = reconcilePaneState(config, sessionSnapshot?.paneState ?? {});
-  const defaultFocusedPaneId = getPaneOrder(config.layout)[0] ?? null;
+  const defaultFocusedPaneId = getTopFloatingPaneId(config.layout) ?? getPaneOrder(config.layout)[0] ?? null;
   const focusedPaneId = sessionSnapshot?.focusedPaneId
     && config.layout.instances.some((instance) => instance.instanceId === sessionSnapshot.focusedPaneId)
     ? sessionSnapshot.focusedPaneId

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

@@ -632,4 +632,79 @@ describe("MarketDataCoordinator", () => {
     expect(financials?.quote?.marketCap).toBe(3_640_775_908_600);
     expect(financials?.fundamentals?.trailingPE).toBe(31.4);
   });
+
+  it("batch loads only missing quotes when fresh quote data is already stored", async () => {
+    const batchTargets: QuoteSubscriptionTarget[][] = [];
+    const provider = createProvider({
+      getQuote: async () => ({
+        symbol: "AAPL",
+        price: 100,
+        currency: "USD",
+        change: 0,
+        changePercent: 0,
+        lastUpdated: 1_700_000_000_000,
+      }),
+      getQuotesBatch: async (targets) => {
+        batchTargets.push(targets);
+        return targets.map((target) => ({
+          target,
+          quote: {
+            symbol: target.symbol,
+            price: target.symbol === "MSFT" ? 200 : 300,
+            currency: "USD",
+            change: 0,
+            changePercent: 0,
+            lastUpdated: 1_700_000_000_000,
+          },
+        }));
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
+    const msft = { symbol: "MSFT", exchange: "NASDAQ" };
+
+    await coordinator.loadQuote(aapl);
+    await coordinator.loadQuotesBatch([aapl, msft]);
+
+    expect(batchTargets).toHaveLength(1);
+    expect(batchTargets[0]?.map((target) => target.symbol)).toEqual(["MSFT"]);
+    expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(100);
+    expect(coordinator.getQuoteEntry(msft).data?.price).toBe(200);
+  });
+
+  it("batch loads snapshots through provider batch support", async () => {
+    const batchSymbols: string[][] = [];
+    const provider = createProvider({
+      getTickerFinancialsBatch: async (targets) => {
+        batchSymbols.push(targets.map((target) => target.symbol));
+        return targets.map((target) => ({
+          target,
+          financials: {
+            quote: {
+              symbol: target.symbol,
+              price: target.symbol === "AAPL" ? 150 : 250,
+              currency: "USD",
+              change: 0,
+              changePercent: 0,
+              lastUpdated: 1_700_000_000_000,
+            },
+            fundamentals: { trailingPE: target.symbol === "AAPL" ? 20 : 30 },
+            annualStatements: [],
+            quarterlyStatements: [],
+            priceHistory: [],
+          },
+        }));
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+
+    await coordinator.loadSnapshotsBatch([
+      { symbol: "AAPL", exchange: "NASDAQ" },
+      { symbol: "MSFT", exchange: "NASDAQ" },
+    ]);
+
+    expect(batchSymbols).toEqual([["AAPL", "MSFT"]]);
+    expect(coordinator.getTickerFinancialsSync({ symbol: "AAPL", exchange: "NASDAQ" })?.quote?.price).toBe(150);
+    expect(coordinator.getTickerFinancialsSync({ symbol: "MSFT", exchange: "NASDAQ" })?.fundamentals?.trailingPE).toBe(30);
+  });
 });