gloomberb 0.9.7 → 0.9.9

package/src/plugins/builtin/portfolio-list/pane/index.test.tsx

@@ -279,6 +279,7 @@ function PortfolioHarness({
   stateMutator,
   runtime = createTestPluginRuntime(),
   paneHeight = 24,
+  paneFocused = true,
 }: {
   config: AppConfig;
   collectionId: string;
@@ -290,6 +291,7 @@ function PortfolioHarness({
   stateMutator?: (state: ReturnType<typeof createInitialState>) => void;
   runtime?: PluginRuntimeAccess;
   paneHeight?: number;
+  paneFocused?: boolean;
 }) {
   const initialState = createPortfolioState(config, collectionId, expanded, {
     ticker,
@@ -309,7 +311,7 @@ function PortfolioHarness({
           <PortfolioPane
             paneId={TEST_PANE_ID}
             paneType="portfolio-list"
-            focused
+            focused={paneFocused}
             width={100}
             height={paneHeight}
           />
@@ -323,11 +325,162 @@ async function flushFrame() {
   await act(async () => {
     await Promise.resolve();
     await testSetup!.renderOnce();
+    await new Promise((resolve) => setTimeout(resolve, 0));
     await Promise.resolve();
     await testSetup!.renderOnce();
   });
 }
 
+function makeSortWarmupQuote(symbol: string): Quote {
+  return makeQuote({
+    symbol,
+    price: symbol === "SIVE" ? 46.7 : 100,
+    change: symbol === "SIVE" ? -9.6 : 0,
+    changePercent: symbol === "SIVE" ? -17.05 : 0,
+    previousClose: symbol === "SIVE" ? 56.3 : 100,
+    listingExchangeName: "NASDAQ",
+  });
+}
+
+function makeSortWarmupBrokerTicker(portfolioId: string, symbol: string, index: number): TickerRecord {
+  return makeTicker({
+    ticker: symbol,
+    name: symbol,
+    portfolios: [portfolioId],
+    positions: [{
+      portfolio: portfolioId,
+      shares: 10,
+      avgCost: 100,
+      currency: "USD",
+      broker: "ibkr",
+      brokerInstanceId: "ibkr-live",
+      brokerAccountId: "DU12345",
+      brokerContractId: 10_000 + index,
+      markPrice: 100,
+    }],
+    broker_contracts: [{
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-live",
+      symbol,
+      localSymbol: symbol,
+      exchange: "SMART",
+      primaryExchange: "NASDAQ",
+      conId: 10_000 + index,
+    }],
+  });
+}
+
+async function renderHiddenChangePctSortWarmup(options: { staleCachedSiveSnapshot?: boolean } = {}) {
+  const portfolioId = "broker:ibkr-live:DU12345";
+  const config = createPortfolioConfigWithColumns(
+    portfolioId,
+    ["ticker", "price", "change_pct", "latency"],
+    [createBrokerInstance("gateway", "ibkr-live")],
+  );
+  const requestedSnapshots: string[] = [];
+  const provider: DataProvider = {
+    id: "test-provider",
+    name: "Test Provider",
+    async getTickerFinancials(symbol) {
+      requestedSnapshots.push(symbol);
+      return {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: makeSortWarmupQuote(symbol),
+      };
+    },
+    async getQuote(symbol) {
+      return makeSortWarmupQuote(symbol);
+    },
+    async getExchangeRate() {
+      return 1;
+    },
+    async search() {
+      return [];
+    },
+    async getArticleSummary() {
+      return null;
+    },
+    async getPriceHistory() {
+      return [];
+    },
+    subscribeQuotes() {
+      return () => {};
+    },
+  };
+  sharedCoordinator = new MarketDataCoordinator(provider);
+  setSharedMarketDataCoordinator(sharedCoordinator);
+
+  const tickers = Array.from({ length: 29 }, (_, index) => makeSortWarmupBrokerTicker(portfolioId, `T${String(index).padStart(2, "0")}`, index));
+  const sive = makeSortWarmupBrokerTicker(portfolioId, "SIVE", 29);
+  if (options.staleCachedSiveSnapshot) {
+    const siveInstrument = instrumentFromTicker(sive, "SIVE", { portfolioId });
+    if (!siveInstrument) throw new Error("expected SIVE instrument");
+    sharedCoordinator.primeCachedFinancials([{
+      instrument: siveInstrument,
+      financials: {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: makeQuote({
+          symbol: "SIVE",
+          price: 56.3,
+          change: 56.3,
+          changePercent: 100,
+          previousClose: 0,
+          listingExchangeName: "NASDAQ",
+          lastUpdated: Date.now() - 24 * 60 * 60_000,
+        }),
+      },
+    }]);
+  }
+
+  testSetup = await testRender(
+    <PortfolioHarness
+      config={config}
+      collectionId={portfolioId}
+      stateMutator={(state) => {
+        state.tickers = new Map([...tickers, sive].map((entry) => [entry.metadata.ticker, entry]));
+        state.financials = new Map(tickers.map((entry, index) => [
+          entry.metadata.ticker,
+          {
+            annualStatements: [],
+            quarterlyStatements: [],
+            priceHistory: [],
+            quote: makeQuote({
+              symbol: entry.metadata.ticker,
+              price: 100 + index,
+              change: index,
+              changePercent: index,
+              listingExchangeName: "NASDAQ",
+            }),
+          },
+        ]));
+        state.paneState[TEST_PANE_ID] = {
+          collectionId: portfolioId,
+          cursorSymbol: "T00",
+          cashDrawerExpanded: false,
+          collectionSorts: {
+            [portfolioId]: { columnId: "change_pct", direction: "asc" },
+          },
+        };
+      }}
+      paneHeight={12}
+    />,
+    { width: 100, height: 12 },
+  );
+
+  await flushFrame();
+  const beforeFrame = testSetup.captureCharFrame();
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, 400));
+  });
+  await flushFrame();
+
+  return { beforeFrame, frame: testSetup.captureCharFrame(), requestedSnapshots };
+}
+
 afterEach(async () => {
   if (testSetup) {
     testSetup.renderer.destroy();
@@ -991,18 +1144,20 @@ describe("PortfolioListPane cash and margin UI", () => {
     expect(frame).toContain("22.0");
   });
 
-  test("force-refreshes stale quote data for visible rows", async () => {
+  test("force-refreshes old visible quote data even when the pane is not focused", async () => {
     const config = createPortfolioConfigWithColumns(
       "broker:ibkr-flex:DU12345",
       ["ticker", "price", "day_pnl"],
       [createBrokerInstance("flex")],
     );
-    const staleQuote = makeQuote({
+    const oldQuote = makeQuote({
       price: 120,
-      change: 0,
-      changePercent: 0,
-      marketState: "PRE",
-      lastUpdated: Date.now() - 24 * 60 * 60 * 1000,
+      change: -5,
+      changePercent: -4,
+      currency: "EUR",
+      listingExchangeName: "FWB2",
+      marketState: "REGULAR",
+      lastUpdated: Date.now() - 5 * 60 * 1000,
     });
     const batchOptions: Array<{ forceRefresh?: boolean } | undefined> = [];
     const provider: DataProvider = {
@@ -1013,7 +1168,7 @@ describe("PortfolioListPane cash and margin UI", () => {
           annualStatements: [],
           quarterlyStatements: [],
           priceHistory: [],
-          quote: staleQuote,
+          quote: oldQuote,
         };
       },
       async getQuotesBatch(targets, options) {
@@ -1023,12 +1178,11 @@ describe("PortfolioListPane cash and margin UI", () => {
           quote: makeQuote({
             symbol: target.symbol,
             price: 126,
-            change: 6,
-            changePercent: 5,
-            marketState: "PRE",
-            preMarketPrice: 126,
-            preMarketChange: 6,
-            preMarketChangePercent: 5,
+            change: 1,
+            changePercent: 0.8,
+            currency: "EUR",
+            listingExchangeName: "FWB2",
+            marketState: "REGULAR",
           }),
         }));
       },
@@ -1058,14 +1212,25 @@ describe("PortfolioListPane cash and margin UI", () => {
       <PortfolioHarness
         config={config}
         collectionId="broker:ibkr-flex:DU12345"
-        quote={staleQuote}
+        ticker={makeTicker({ exchange: "FWB2", currency: "EUR" })}
+        quote={oldQuote}
+        paneFocused={false}
+        stateMutator={(state) => {
+          state.focusedPaneId = "portfolio-list:other";
+          state.paneState[TEST_PANE_ID] = {
+            ...(state.paneState[TEST_PANE_ID] ?? {}),
+            collectionSorts: {
+              "broker:ibkr-flex:DU12345": { columnId: "ticker", direction: "asc" },
+            },
+          };
+        }}
       />,
       { width: 100, height: 12 },
     );
 
     await flushFrame();
     await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 380));
+      await Promise.resolve();
     });
     await flushFrame();
 
@@ -1413,4 +1578,137 @@ describe("PortfolioListPane cash and margin UI", () => {
     expect(frame).toContain("+5.41%");
   });
 
+  test("streams portfolio rows with the active collection broker contract", async () => {
+    const config = createPortfolioConfigWithColumns(
+      "broker:ibkr-live:DU12345",
+      ["ticker", "price", "change_pct", "latency"],
+      [createBrokerInstance("gateway", "ibkr-flex"), createBrokerInstance("gateway", "ibkr-live")],
+    );
+    let subscribedTargets: Array<{ symbol: string; context?: { brokerInstanceId?: string; instrument?: unknown } }> = [];
+    const provider: DataProvider = {
+      id: "test-provider",
+      name: "Test Provider",
+      async getTickerFinancials(symbol) {
+        return {
+          annualStatements: [],
+          quarterlyStatements: [],
+          priceHistory: [],
+          quote: makeQuote({ symbol }),
+        };
+      },
+      async getQuote(symbol) {
+        return makeQuote({ symbol });
+      },
+      async getExchangeRate() {
+        return 1;
+      },
+      async search() {
+        return [];
+      },
+      async getArticleSummary() {
+        return null;
+      },
+      async getPriceHistory() {
+        return [];
+      },
+      subscribeQuotes(targets) {
+        subscribedTargets = targets;
+        return () => {};
+      },
+    };
+    sharedCoordinator = new MarketDataCoordinator(provider);
+    setSharedMarketDataCoordinator(sharedCoordinator);
+
+    const flexContract = {
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-flex",
+      symbol: "VICR",
+      localSymbol: "VICR",
+      exchange: "NASDAQ",
+      conId: 275759,
+    };
+    const liveContract = {
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-live",
+      symbol: "VICR",
+      localSymbol: "VICR",
+      exchange: "NASDAQ",
+      primaryExchange: "NASDAQ",
+      conId: 275759,
+    };
+
+    testSetup = await testRender(
+      <PortfolioHarness
+        config={config}
+        collectionId="broker:ibkr-live:DU12345"
+        stateMutator={(state) => {
+          state.tickers = new Map([["VICR", makeTicker({
+            ticker: "VICR",
+            name: "Vicor",
+            portfolios: ["broker:ibkr-flex:DU12345", "broker:ibkr-live:DU12345"],
+            positions: [
+              {
+                portfolio: "broker:ibkr-flex:DU12345",
+                shares: 170,
+                avgCost: 198,
+                currency: "USD",
+                broker: "ibkr",
+                brokerInstanceId: "ibkr-flex",
+                brokerAccountId: "DU12345",
+                brokerContractId: 275759,
+              },
+              {
+                portfolio: "broker:ibkr-live:DU12345",
+                shares: 350,
+                avgCost: 290,
+                currency: "USD",
+                broker: "ibkr",
+                brokerInstanceId: "ibkr-live",
+                brokerAccountId: "DU12345",
+                brokerContractId: 275759,
+              },
+            ],
+            broker_contracts: [flexContract, liveContract],
+          })]]);
+          state.financials = new Map();
+          state.paneState[TEST_PANE_ID] = {
+            collectionId: "broker:ibkr-live:DU12345",
+            cursorSymbol: "VICR",
+            cashDrawerExpanded: false,
+          };
+        }}
+      />,
+      { width: 100, height: 12 },
+    );
+
+    await flushFrame();
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    const vicrTarget = subscribedTargets.find((target) => target.symbol === "VICR");
+    expect(vicrTarget?.context?.brokerInstanceId).toBe("ibkr-live");
+    expect(vicrTarget?.context?.instrument).toEqual(liveContract);
+  });
+
+  test("warms hidden quote-missing rows when sorting by change percent", async () => {
+    const { beforeFrame, frame, requestedSnapshots } = await renderHiddenChangePctSortWarmup();
+    expect(beforeFrame).not.toContain("SIVE");
+    expect(requestedSnapshots).toContain("SIVE");
+    expect(frame).toContain("SIVE");
+    expect(frame).toContain("-17.05%");
+    expect(frame).toContain("46.7");
+  });
+
+  test("force-refreshes hidden stale cached snapshots when sorting by change percent", async () => {
+    const { beforeFrame, frame, requestedSnapshots } = await renderHiddenChangePctSortWarmup({
+      staleCachedSiveSnapshot: true,
+    });
+    expect(beforeFrame).not.toContain("SIVE");
+    expect(requestedSnapshots).toContain("SIVE");
+    expect(frame).toContain("SIVE");
+    expect(frame).toContain("-17.05%");
+    expect(frame).toContain("46.7");
+  });
+
 });

package/src/plugins/builtin/portfolio-list/pane/index.tsx

@@ -107,7 +107,10 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
     () => getCollectionTickersFromConfig(config, tickersBySymbol, activeCollectionId),
     [activeCollectionId, config, tickersBySymbol],
   );
-  const marketFinancialsMap = useTickerFinancialsMap(tickers);
+  const financialsInstrumentOptions = useMemo(() => ({
+    portfolioId: isPortfolioTab ? activeCollectionId : undefined,
+  }), [activeCollectionId, isPortfolioTab]);
+  const marketFinancialsMap = useTickerFinancialsMap(tickers, financialsInstrumentOptions);
   const financialsMap = useMemo(() => {
     const merged = new Map(cachedFinancials);
     for (const [symbol, financials] of marketFinancialsMap) {
@@ -303,16 +306,20 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
   const effectiveStreamWindow = useMemo(() => (
     viewMode === "grid"
       ? { start: 0, end: Math.min(sortedTickers.length, 96) }
-      : streamWindow
-  ), [sortedTickers.length, streamWindow, viewMode]);
+      : {
+        start: streamWindow.start,
+        end: Math.min(sortedTickers.length, Math.max(streamWindow.end, height + 4)),
+      }
+  ), [height, sortedTickers.length, streamWindow, viewMode]);
 
   usePortfolioPaneStreaming({
     appActive,
-    focused,
+    activeCollectionId: isPortfolioTab ? activeCollectionId : undefined,
     sortedTickers,
     cursorSymbol,
     streamWindow: effectiveStreamWindow,
     isPortfolioTab,
+    activeSort,
     financialsMap,
     visibleWarmupRequirements,
   });

package/src/plugins/builtin/portfolio-list/pane/streaming.ts

@@ -4,36 +4,42 @@ import { instrumentFromTicker, quoteSubscriptionTargetFromTicker } from "../../.
 import { useQuoteStreaming } from "../../../../state/hooks/quote-streaming";
 import type { TickerFinancials } from "../../../../types/financials";
 import type { TickerRecord } from "../../../../types/ticker";
+import type { CollectionSortPreference } from "../../../../state/app/context";
 import {
   VISIBLE_FINANCIAL_WARMUP_DELAY_MS,
   VISIBLE_QUOTE_REFRESH_COOLDOWN_MS,
   VISIBLE_QUOTE_STREAM_WATCHDOG_MS,
   VISIBLE_SNAPSHOT_WARMUP_BATCH_LIMIT,
   VISIBLE_SNAPSHOT_REFRESH_COOLDOWN_MS,
+  SORT_QUOTE_WARMUP_BATCH_LIMIT,
   needsVisibleQuoteWarmup,
   needsVisibleQuoteWatchdogRefresh,
   needsVisibleSnapshotWarmup,
+  selectQuoteWarmupTickers,
   selectStreamTickers,
+  sortPreferenceUsesQuote,
   visibleWarmupKey,
   type VisibleWarmupRequirements,
 } from "./data";
 
 export function usePortfolioPaneStreaming({
   appActive,
-  focused,
+  activeCollectionId,
   sortedTickers,
   cursorSymbol,
   streamWindow,
   isPortfolioTab,
+  activeSort,
   financialsMap,
   visibleWarmupRequirements,
 }: {
   appActive: boolean;
-  focused: boolean;
+  activeCollectionId?: string;
   sortedTickers: TickerRecord[];
   cursorSymbol: string | null;
   streamWindow: { start: number; end: number };
   isPortfolioTab: boolean;
+  activeSort: CollectionSortPreference;
   financialsMap: Map<string, TickerFinancials>;
   visibleWarmupRequirements: VisibleWarmupRequirements;
 }) {
@@ -57,10 +63,13 @@ export function usePortfolioPaneStreaming({
     [streamTickers],
   );
   const streamSurface: "portfolio" | "watchlist" = isPortfolioTab ? "portfolio" : "watchlist";
+  const instrumentOptions = useMemo(() => ({
+    portfolioId: isPortfolioTab ? activeCollectionId : undefined,
+  }), [activeCollectionId, isPortfolioTab]);
   const streamTargets = useMemo(() => (
     sortedTickers
       .map((ticker) => {
-        const target = quoteSubscriptionTargetFromTicker(ticker, ticker.metadata.ticker, "provider");
+        const target = quoteSubscriptionTargetFromTicker(ticker, ticker.metadata.ticker, "provider", instrumentOptions);
         if (!target) return null;
         const selected = ticker.metadata.ticker === cursorSymbol;
         const visible = priorityStreamSymbols.has(ticker.metadata.ticker);
@@ -73,32 +82,64 @@ export function usePortfolioPaneStreaming({
         };
       })
       .filter((target): target is NonNullable<typeof target> => target != null)
-  ), [cursorSymbol, priorityStreamSymbols, sortedTickers, streamSurface]);
+  ), [cursorSymbol, instrumentOptions, priorityStreamSymbols, sortedTickers, streamSurface]);
   const visibleFinancialTickers = useMemo(
     () => sortedTickers.slice(streamWindow.start, streamWindow.end),
     [sortedTickers, streamWindow.end, streamWindow.start],
   );
+  const watchdogInputsRef = useRef<{
+    financialsMap: Map<string, TickerFinancials>;
+    instrumentOptions: typeof instrumentOptions;
+    visibleFinancialTickers: TickerRecord[];
+  }>({ financialsMap, instrumentOptions, visibleFinancialTickers });
+
+  useEffect(() => {
+    watchdogInputsRef.current = {
+      financialsMap,
+      instrumentOptions,
+      visibleFinancialTickers,
+    };
+  }, [financialsMap, instrumentOptions, visibleFinancialTickers]);
 
   useEffect(() => {
     if (!appActive) return;
-    if (!focused) return;
     if (!sharedCoordinator) return;
 
     const nowTimestamp = Date.now();
     const quoteQueue: TickerRecord[] = [];
+    const quoteSnapshotQueue: TickerRecord[] = [];
     const snapshotQueue: TickerRecord[] = [];
-    for (const ticker of visibleFinancialTickers) {
+    const snapshotQueueSymbols = new Set<string>();
+    const useSnapshotForQuoteWarmup = sortPreferenceUsesQuote(activeSort);
+    const quoteWarmupTickers = selectQuoteWarmupTickers(
+      sortedTickers,
+      streamWindow,
+      financialsMap,
+      activeSort,
+      nowTimestamp,
+    );
+    for (const ticker of quoteWarmupTickers) {
       const financials = financialsMap.get(ticker.metadata.ticker);
       const quoteKey = visibleWarmupKey("quote", ticker);
+      const warmupWithSnapshot = useSnapshotForQuoteWarmup && ticker.metadata.assetCategory !== "OPT";
+      const warmupKey = warmupWithSnapshot ? visibleWarmupKey("snapshot", ticker) : quoteKey;
       if (
         needsVisibleQuoteWarmup(financials, nowTimestamp)
-        && !warmupInFlightRef.current.has(quoteKey)
-        && nowTimestamp - (warmupAttemptRef.current.get(quoteKey) ?? 0) >= VISIBLE_QUOTE_REFRESH_COOLDOWN_MS
+        && !warmupInFlightRef.current.has(warmupKey)
+        && nowTimestamp - (warmupAttemptRef.current.get(warmupKey) ?? 0) >= VISIBLE_QUOTE_REFRESH_COOLDOWN_MS
       ) {
-        quoteQueue.push(ticker);
-        continue;
+        if (warmupWithSnapshot) {
+          quoteSnapshotQueue.push(ticker);
+          snapshotQueueSymbols.add(ticker.metadata.ticker);
+        } else {
+          quoteQueue.push(ticker);
+        }
       }
+    }
 
+    for (const ticker of visibleFinancialTickers) {
+      const financials = financialsMap.get(ticker.metadata.ticker);
+      if (snapshotQueueSymbols.has(ticker.metadata.ticker)) continue;
       const snapshotKey = visibleWarmupKey("snapshot", ticker);
       if (
         needsVisibleSnapshotWarmup(ticker, financials, visibleWarmupRequirements)
@@ -106,43 +147,56 @@ export function usePortfolioPaneStreaming({
         && nowTimestamp - (warmupAttemptRef.current.get(snapshotKey) ?? 0) >= VISIBLE_SNAPSHOT_REFRESH_COOLDOWN_MS
       ) {
         snapshotQueue.push(ticker);
+        snapshotQueueSymbols.add(ticker.metadata.ticker);
       }
     }
+    const limitedQuoteSnapshotQueue = quoteSnapshotQueue.slice(0, SORT_QUOTE_WARMUP_BATCH_LIMIT);
     const limitedSnapshotQueue = snapshotQueue.slice(0, VISIBLE_SNAPSHOT_WARMUP_BATCH_LIMIT);
-    if (quoteQueue.length === 0 && limitedSnapshotQueue.length === 0) return;
+    if (quoteQueue.length === 0 && limitedQuoteSnapshotQueue.length === 0 && limitedSnapshotQueue.length === 0) return;
 
     let cancelled = false;
     const runBatch = async (): Promise<void> => {
       const quoteEntries = quoteQueue.flatMap((ticker) => {
-        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, instrumentOptions);
         if (!instrument) return [];
         const key = visibleWarmupKey("quote", ticker);
         warmupInFlightRef.current.add(key);
         warmupAttemptRef.current.set(key, nowTimestamp);
         return [{ key, instrument }];
       });
-      const snapshotEntries = limitedSnapshotQueue.flatMap((ticker) => {
-        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+      const forcedSnapshotEntries = limitedQuoteSnapshotQueue.flatMap((ticker) => {
+        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, instrumentOptions);
         if (!instrument) return [];
         const key = visibleWarmupKey("snapshot", ticker);
         warmupInFlightRef.current.add(key);
         warmupAttemptRef.current.set(key, nowTimestamp);
         return [{ key, instrument }];
       });
-      if (quoteEntries.length === 0 && snapshotEntries.length === 0) return;
+      const normalSnapshotEntries = limitedSnapshotQueue.flatMap((ticker) => {
+        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, instrumentOptions);
+        if (!instrument) return [];
+        const key = visibleWarmupKey("snapshot", ticker);
+        warmupInFlightRef.current.add(key);
+        warmupAttemptRef.current.set(key, nowTimestamp);
+        return [{ key, instrument }];
+      });
+      if (quoteEntries.length === 0 && forcedSnapshotEntries.length === 0 && normalSnapshotEntries.length === 0) return;
       try {
         await Promise.allSettled([
           quoteEntries.length > 0
             ? sharedCoordinator.loadQuotesBatch(quoteEntries.map((entry) => entry.instrument), { forceRefresh: true })
             : Promise.resolve(),
-          snapshotEntries.length > 0
-            ? sharedCoordinator.loadSnapshotsBatch(snapshotEntries.map((entry) => entry.instrument))
+          forcedSnapshotEntries.length > 0
+            ? sharedCoordinator.loadSnapshotsBatch(forcedSnapshotEntries.map((entry) => entry.instrument), { forceRefresh: true })
+            : Promise.resolve(),
+          normalSnapshotEntries.length > 0
+            ? sharedCoordinator.loadSnapshotsBatch(normalSnapshotEntries.map((entry) => entry.instrument))
             : Promise.resolve(),
         ]);
       } catch {
         // Best-effort warmup for visible rows only.
       } finally {
-        for (const entry of [...quoteEntries, ...snapshotEntries]) {
+        for (const entry of [...quoteEntries, ...forcedSnapshotEntries, ...normalSnapshotEntries]) {
           warmupInFlightRef.current.delete(entry.key);
         }
       }
@@ -156,18 +210,22 @@ export function usePortfolioPaneStreaming({
       cancelled = true;
       clearTimeout(timeoutId);
     };
-  }, [appActive, financialsMap, focused, sharedCoordinator, visibleFinancialTickers, visibleWarmupRequirements]);
+  }, [activeSort, appActive, financialsMap, instrumentOptions, sharedCoordinator, sortedTickers, streamWindow, visibleFinancialTickers, visibleWarmupRequirements]);
 
   useEffect(() => {
     if (!appActive) return;
-    if (!focused) return;
     if (!sharedCoordinator) return;
 
     let cancelled = false;
     const runWatchdog = async (): Promise<void> => {
       const nowTimestamp = Date.now();
-      const quoteEntries = visibleFinancialTickers.flatMap((ticker) => {
-        const financials = financialsMap.get(ticker.metadata.ticker);
+      const {
+        financialsMap: latestFinancialsMap,
+        instrumentOptions: latestInstrumentOptions,
+        visibleFinancialTickers: latestVisibleFinancialTickers,
+      } = watchdogInputsRef.current;
+      const quoteEntries = latestVisibleFinancialTickers.flatMap((ticker) => {
+        const financials = latestFinancialsMap.get(ticker.metadata.ticker);
         const key = visibleWarmupKey("quote", ticker);
         if (
           !needsVisibleQuoteWatchdogRefresh(financials, nowTimestamp)
@@ -176,7 +234,7 @@ export function usePortfolioPaneStreaming({
         ) {
           return [];
         }
-        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+        const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, latestInstrumentOptions);
         if (!instrument) return [];
         warmupInFlightRef.current.add(key);
         warmupAttemptRef.current.set(key, nowTimestamp);
@@ -195,6 +253,7 @@ export function usePortfolioPaneStreaming({
       }
     };
 
+    void runWatchdog();
     const intervalId = setInterval(() => {
       if (!cancelled && mountedRef.current) void runWatchdog();
     }, VISIBLE_QUOTE_STREAM_WATCHDOG_MS);
@@ -203,7 +262,7 @@ export function usePortfolioPaneStreaming({
       cancelled = true;
       clearInterval(intervalId);
     };
-  }, [appActive, financialsMap, focused, sharedCoordinator, visibleFinancialTickers]);
+  }, [appActive, sharedCoordinator]);
 
   useQuoteStreaming(streamTargets);
 }