gloomberb 0.7.3 → 0.7.4

package/src/components/chart/stock-chart.tsx

@@ -128,6 +128,7 @@ import type { PricePoint, TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import { TimeAxisLabel } from "./time-axis-label";
 import { PriceAxisLabels } from "./price-axis-labels";
+import { getChartMarketSessionKey, resolveChartMarketSession } from "./market-session";
 
 const MODE_CHIPS: Record<ChartRenderMode, string> = {
   area: "A",
@@ -1086,6 +1087,7 @@ function buildNativeBitmapKey(
   showVolume: boolean,
   paletteId: string,
   indicatorKey: string,
+  marketSessionKey: string,
 ): string {
   const fingerprint = points
     .map((point) => {
@@ -1093,7 +1095,7 @@ function buildNativeBitmapKey(
       return `${date}:${point.open}:${point.high}:${point.low}:${point.close}:${point.volume ?? 0}`;
     })
     .join("|");
-  return [pointCount, pixelWidth, pixelHeight, mode, showVolume ? "1" : "0", paletteId, indicatorKey, fingerprint].join("::");
+  return [pointCount, pixelWidth, pixelHeight, mode, showVolume ? "1" : "0", paletteId, indicatorKey, marketSessionKey, fingerprint].join("::");
 }
 
 function buildNativeCrosshairBitmapKey(
@@ -1715,7 +1717,7 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     !compact && instrumentRef
       ? {
         instrument: instrumentRef,
-        bufferRange: indicatorBufferRange,
+        bufferRange: viewState.bufferRange,
         granularity: "range",
       }
       : null,
@@ -3044,6 +3046,14 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     themeColors.text,
     themeColors.textDim,
   ]);
+  const marketSession = useMemo(() => resolveChartMarketSession(ticker
+    ? [{
+      exchange: ticker.metadata.exchange,
+      currency: ticker.metadata.currency,
+      assetCategory: ticker.metadata.assetCategory,
+    }]
+    : []), [ticker]);
+  const marketSessionKey = useMemo(() => getChartMarketSessionKey(marketSession), [marketSession]);
 
   const cursorX = viewState.cursorX !== null ? clamp(viewState.cursorX, 0, chartWidth - 1) : null;
   const cursorY = viewState.cursorY !== null ? clamp(viewState.cursorY, 0, chartHeight - 1) : null;
@@ -3071,7 +3081,8 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     axisMode,
     colors: chartColors,
     timeAxisDates,
-  }), [axisMode, chartColors, chartHeight, chartWidth, compact, projection.effectiveMode, projection.points, selectionCursorX, selectionCursorY, showVolume, timeAxisDates, volumeHeight]);
+    marketSession,
+  }), [axisMode, chartColors, chartHeight, chartWidth, compact, marketSession, projection.effectiveMode, projection.points, selectionCursorX, selectionCursorY, showVolume, timeAxisDates, volumeHeight]);
   const displayScene = useMemo(() => buildChartScene(projection.points, {
     width: chartWidth,
     height: chartHeight,
@@ -3084,7 +3095,8 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     colors: chartColors,
     timeAxisDates,
     indicators,
-  }), [axisMode, chartColors, chartHeight, chartWidth, compact, displayCursorX, displayCursorY, indicators, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
+    marketSession,
+  }), [axisMode, chartColors, chartHeight, chartWidth, compact, displayCursorX, displayCursorY, indicators, marketSession, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
   const snappedSelectionCursorX = selectionScene
     ? getPointTerminalColumn(selectionScene.activeIdx, projection.points.length, chartWidth, projection.effectiveMode)
     : null;
@@ -3130,7 +3142,8 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     colors: chartColors,
     timeAxisDates,
     indicators,
-  }), [axisMode, chartColors, chartHeight, chartWidth, compact, indicators, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
+    marketSession,
+  }), [axisMode, chartColors, chartHeight, chartWidth, compact, indicators, marketSession, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
 
   const staticResult = useMemo(() => renderChart(projection.points, {
     width: chartWidth,
@@ -3146,7 +3159,8 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     colors: chartColors,
     timeAxisDates,
     indicators,
-  }), [axisMode, chartAssetCategory, chartColors, chartCurrency, chartHeight, chartWidth, compact, indicators, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
+    marketSession,
+  }), [axisMode, chartAssetCategory, chartColors, chartCurrency, chartHeight, chartWidth, compact, indicators, marketSession, projection.effectiveMode, projection.points, showVolume, timeAxisDates, volumeHeight]);
 
   const interactiveResult = useMemo(() => (
     effectiveRenderer === "kitty" || useCanvasChart
@@ -3165,8 +3179,9 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
         colors: chartColors,
         timeAxisDates,
         indicators,
+        marketSession,
       })
-  ), [axisMode, chartAssetCategory, chartColors, chartCurrency, chartHeight, chartWidth, compact, displayCursorX, displayCursorY, effectiveRenderer, indicators, projection.effectiveMode, projection.points, showVolume, timeAxisDates, useCanvasChart, volumeHeight]);
+  ), [axisMode, chartAssetCategory, chartColors, chartCurrency, chartHeight, chartWidth, compact, displayCursorX, displayCursorY, effectiveRenderer, indicators, marketSession, projection.effectiveMode, projection.points, showVolume, timeAxisDates, useCanvasChart, volumeHeight]);
 
   const result = effectiveRenderer === "kitty" || useCanvasChart ? staticResult : interactiveResult!;
 
@@ -3300,8 +3315,11 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
         chartColors.volumeDown,
         chartColors.candleUp,
         chartColors.candleDown,
+        chartColors.preMarketBgColor,
+        chartColors.postMarketBgColor,
       ].join(","),
       indicatorRenderKey,
+      marketSessionKey,
     );
     const cachedBitmap = lastNativeBaseBitmapRef.current?.key === bitmapKey
       ? lastNativeBaseBitmapRef.current.bitmap
@@ -3331,11 +3349,14 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     chartColors.fillColor,
     chartColors.gridColor,
     chartColors.lineColor,
+    chartColors.postMarketBgColor,
+    chartColors.preMarketBgColor,
     chartColors.volumeDown,
     chartColors.volumeUp,
     compact,
     effectiveRenderer,
     indicatorRenderKey,
+    marketSessionKey,
     nativeBaseScene,
     nativeBaseSurfaceId,
     nativeSurfaceManager,
@@ -3829,9 +3850,10 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
         colors: chartColors,
         timeAxisDates,
         indicators: canvasIndicators,
+        marketSession,
       })
       : null
-  ), [axisMode, canvasIndicators, canvasProjection, chartColors, chartHeight, compact, showVolume, timeAxisDates, volumeHeight]);
+  ), [axisMode, canvasIndicators, canvasProjection, chartColors, chartHeight, compact, marketSession, showVolume, timeAxisDates, volumeHeight]);
 
   const canvasBaseBitmapKey = useMemo(() => {
     if (!canvasBitmapSize || !canvasProjection || !hasHistory || isBlockingBody || bodyMessage) return null;
@@ -3850,8 +3872,11 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
         chartColors.volumeDown,
         chartColors.candleUp,
         chartColors.candleDown,
+        chartColors.preMarketBgColor,
+        chartColors.postMarketBgColor,
       ].join(","),
       canvasIndicatorRenderKey,
+      marketSessionKey,
     );
   }, [
     bodyMessage,
@@ -3863,11 +3888,14 @@ export const ResolvedStockChart = memo(function ResolvedStockChart({
     chartColors.fillColor,
     chartColors.gridColor,
     chartColors.lineColor,
+    chartColors.postMarketBgColor,
+    chartColors.preMarketBgColor,
     chartColors.volumeDown,
     chartColors.volumeUp,
     compact,
     hasHistory,
     isBlockingBody,
+    marketSessionKey,
     showVolume,
   ]);
 

package/src/components/chart/time-axis-label.tsx

@@ -23,6 +23,51 @@ function clamp(value: number, min: number, max: number): number {
   return Math.max(min, Math.min(max, value));
 }
 
+function normalizeDate(value: Date | string | number): Date | null {
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isFinite(date.getTime()) ? date : null;
+}
+
+export function resolveCursorDateFromAxis({
+  dates,
+  width,
+  cursorColumn,
+  cursorPixelX,
+  cellWidthPx,
+}: {
+  dates: Array<Date | string | number>;
+  width: number;
+  cursorColumn: number | null;
+  cursorPixelX?: number | null;
+  cellWidthPx?: number | null;
+}): Date | null {
+  const normalizedDates = dates
+    .map(normalizeDate)
+    .filter((date): date is Date => date !== null);
+  if (normalizedDates.length === 0) return null;
+  if (normalizedDates.length === 1) return normalizedDates[0]!;
+
+  let ratio: number | null = null;
+  if (
+    cursorPixelX !== null
+    && cursorPixelX !== undefined
+    && Number.isFinite(cursorPixelX)
+    && cellWidthPx !== null
+    && cellWidthPx !== undefined
+    && Number.isFinite(cellWidthPx)
+    && cellWidthPx > 0
+  ) {
+    const pixelWidth = Math.max(width * cellWidthPx, 1);
+    ratio = clamp(cursorPixelX / Math.max(pixelWidth - 1, 1), 0, 1);
+  } else if (cursorColumn !== null && Number.isFinite(cursorColumn) && width > 1) {
+    ratio = clamp(cursorColumn / Math.max(width - 1, 1), 0, 1);
+  }
+
+  if (ratio === null) return null;
+  const index = Math.round(ratio * (normalizedDates.length - 1));
+  return normalizedDates[clamp(index, 0, normalizedDates.length - 1)] ?? null;
+}
+
 export function buildCursorTimeAxisOverlay({
   segments,
   width,
@@ -61,13 +106,22 @@ export function TimeAxisLabel({
   cursorColor,
 }: TimeAxisLabelProps) {
   const { cellWidthPx = 8, fractionalViewport = false } = useUiCapabilities();
+  const resolvedCursorDate = useMemo(() => {
+    return resolveCursorDateFromAxis({
+      dates,
+      width,
+      cursorColumn,
+      cursorPixelX: fractionalViewport ? cursorPixelX : null,
+      cellWidthPx,
+    }) ?? cursorDate;
+  }, [cellWidthPx, cursorColumn, cursorDate, cursorPixelX, dates, fractionalViewport, width]);
   const segments = useMemo(() => buildCursorTimeAxisSegments({
     timeLabels,
     width,
     cursorColumn,
-    cursorDate,
+    cursorDate: resolvedCursorDate,
     dates,
-  }), [cursorColumn, cursorDate, dates, timeLabels, width]);
+  }), [cursorColumn, dates, resolvedCursorDate, timeLabels, width]);
   const overlay = useMemo(() => buildCursorTimeAxisOverlay({
     segments,
     width,

package/src/components/command-bar/command-bar.test.tsx

@@ -1276,7 +1276,7 @@ describe("CommandBar", () => {
     );
 
     await testSetup.renderOnce();
-    const frame = await waitForFrameToContain("DES");
+    const frame = await waitForFrameToContain("Exact Match");
     const resultLines = frame
       .split("\n")
       .filter((line) => /\b(AMD|AMDL|AMUU|DES)\b/.test(line) && /\b(NASDAQ|ASX)\b/.test(line));

package/src/components/command-bar/command-bar.tsx

@@ -4000,7 +4000,11 @@ export function CommandBar({
     rootResultModel.items,
     rootTickerSearchArg,
   ]);
-  const orderedRootResults = useMemo(() => orderListResults(rootResults), [rootResults]);
+  const rootSectionOrder = rootPlainTickerSearchArg ? "app-first" : "default";
+  const orderedRootResults = useMemo(
+    () => orderListResults(rootResults, { sectionOrder: rootSectionOrder }),
+    [rootResults, rootSectionOrder],
+  );
   const activeRootProviderResultsKey = useMemo(() => {
     if (!rootTickerSearchArg || rootProviderResultsQuery !== rootTickerSearchArg || !rootProviderResults) return null;
     return [
@@ -4316,6 +4320,7 @@ export function CommandBar({
         emptyDetail: emptyState.detail,
         footerLeft: getScreenFooterLeft(null),
         footerRight: getScreenFooterRight(null),
+        sectionOrder: rootSectionOrder,
       };
     }
 
@@ -4463,6 +4468,7 @@ export function CommandBar({
     rootModeInfo.kind,
     rootQuery,
     orderedRootResults,
+    rootSectionOrder,
     rootSearching,
     rootSelectedIdx,
     rootShortcutIntent,

package/src/components/command-bar/list-model.ts

@@ -1,4 +1,4 @@
-import { buildSections } from "./view-model";
+import { buildSections, type CommandBarSectionOrder } from "./view-model";
 
 export interface ResultItem {
   id: string;
@@ -31,6 +31,7 @@ export interface ListScreenState {
   emptyDetail: string;
   footerLeft: string;
   footerRight: string;
+  sectionOrder?: CommandBarSectionOrder;
 }
 
 export type CommandBarListRow =
@@ -41,13 +42,16 @@ export type CommandBarListRow =
   | { kind: "spinner"; id: string; label: string }
   | { kind: "filler"; id: string };
 
-export function orderListResults(results: ResultItem[]): ResultItem[] {
-  return buildSections(results).flatMap((section) => section.items);
+export function orderListResults(
+  results: ResultItem[],
+  options?: { sectionOrder?: CommandBarSectionOrder },
+): ResultItem[] {
+  return buildSections(results, options).flatMap((section) => section.items);
 }
 
 export function buildListRows(listState: ListScreenState): CommandBarListRow[] {
   const rows: CommandBarListRow[] = [];
-  const sections = buildSections(listState.results);
+  const sections = buildSections(listState.results, { sectionOrder: listState.sectionOrder });
   let globalIdx = 0;
   sections.forEach((section, sectionIndex) => {
     if (sectionIndex > 0) {

package/src/components/command-bar/view-model.test.ts

@@ -47,6 +47,26 @@ describe("command bar view model helpers", () => {
     expect(sections.map((section) => section.category)).toEqual(["Tickers", "Config", "Danger", "Debug"]);
   });
 
+  test("keeps provider ticker suggestions behind app sections in app-first order", () => {
+    const sections = buildSections([
+      { id: "pane", category: "Panes" },
+      { id: "primary", category: "Primary Listing" },
+      { id: "other", category: "Other Listings" },
+      { id: "fund", category: "Funds & Derivatives" },
+      { id: "saved", category: "Saved" },
+      { id: "exact", category: "Exact Match" },
+    ], { sectionOrder: "app-first" });
+
+    expect(sections.map((section) => section.category)).toEqual([
+      "Exact Match",
+      "Saved",
+      "Panes",
+      "Primary Listing",
+      "Other Listings",
+      "Funds & Derivatives",
+    ]);
+  });
+
   test("derives row presentation for toggles and current rows", () => {
     expect(getRowPresentation({
       id: "plugin:news",

package/src/components/command-bar/view-model.ts

@@ -15,6 +15,8 @@ export interface CommandBarSection<T> {
   items: T[];
 }
 
+export type CommandBarSectionOrder = "default" | "app-first";
+
 export interface CommandBarItemView {
   id: string;
   label: string;
@@ -59,7 +61,10 @@ export function resolveCommandBarMode(query: string, commandList?: Command[]): C
   }
 }
 
-export function buildSections<T extends { category: string }>(items: T[]): Array<CommandBarSection<T>> {
+export function buildSections<T extends { category: string }>(
+  items: T[],
+  options?: { sectionOrder?: CommandBarSectionOrder },
+): Array<CommandBarSection<T>> {
   const sections: Array<CommandBarSection<T>> = [];
   for (const item of items) {
     let section = sections.find((candidate) => candidate.category === item.category);
@@ -72,7 +77,9 @@ export function buildSections<T extends { category: string }>(items: T[]): Array
   return sections
     .map((section, index) => ({ section, index }))
     .sort((a, b) => {
-      const priorityDiff = getCategoryPriority(a.section.category) - getCategoryPriority(b.section.category);
+      const leftPriority = getCategoryPriority(a.section.category, options?.sectionOrder);
+      const rightPriority = getCategoryPriority(b.section.category, options?.sectionOrder);
+      const priorityDiff = leftPriority - rightPriority;
       return priorityDiff !== 0 ? priorityDiff : a.index - b.index;
     })
     .map(({ section }) => section);
@@ -126,10 +133,15 @@ export function truncateText(text: string, width: number): string {
   return `${text.slice(0, width - 3)}...`;
 }
 
-function getCategoryPriority(category: string): number {
+function getCategoryPriority(category: string, sectionOrder: CommandBarSectionOrder = "default"): number {
   const normalized = category.trim().toLowerCase();
   if (normalized === "exact match") return -50;
   if (normalized === "saved") return -40;
+  if (sectionOrder === "app-first") {
+    if (normalized === "primary listing") return 100;
+    if (normalized === "other listings") return 110;
+    if (normalized === "funds & derivatives") return 120;
+  }
   if (normalized === "primary listing") return -30;
   if (normalized === "other listings") return -20;
   if (normalized === "funds & derivatives") return -10;

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

@@ -56,17 +56,6 @@ const FLASHABLE_QUOTE_COLUMN_IDS = new Set([
   "pnl_pct",
 ]);
 
-function resolveQuoteFlashColor(direction: QuoteFlashDirection, fallbackColor: string): string {
-  switch (direction) {
-    case "up":
-      return colors.positive;
-    case "down":
-      return colors.negative;
-    default:
-      return fallbackColor === colors.textDim ? colors.text : colors.textBright;
-  }
-}
-
 export interface TickerListTableProps {
   columns: ColumnConfig[];
   tickers: TickerRecord[];
@@ -239,13 +228,13 @@ const TickerListRow = memo(function TickerListRow({
         const { text, color } = resolveCell(column, ticker, financials);
         const baseFg = color || (isSelected ? colors.selectedText : colors.text);
         const shouldFlash = flashDirection != null && FLASHABLE_QUOTE_COLUMN_IDS.has(column.id);
-        const cellFg = shouldFlash
-          ? resolveQuoteFlashColor(flashDirection, baseFg)
-          : baseFg;
 
         return (
           <Box key={column.id} width={column.width + 1}>
-            <Text fg={cellFg}>
+            <Text
+              fg={baseFg}
+              attributes={shouldFlash ? TextAttributes.DIM : TextAttributes.NONE}
+            >
               {padTo(text, column.width, column.align)}
             </Text>
           </Box>

package/src/core/state/session-persistence.ts

@@ -73,6 +73,23 @@ function targetFromTicker(ticker: TickerRecord): HydrationTarget {
   });
 }
 
+function resolvePortfolioPaneCollectionId(
+  config: AppConfig,
+  paneState: Record<string, unknown> | undefined,
+  instance: AppConfig["layout"]["instances"][number],
+): string | null {
+  const stateCollectionId = typeof paneState?.collectionId === "string" ? paneState.collectionId : null;
+  if (stateCollectionId) return stateCollectionId;
+  if (typeof instance.params?.collectionId === "string") return instance.params.collectionId;
+  return config.portfolios[0]?.id ?? config.watchlists[0]?.id ?? null;
+}
+
+function tickerInCollection(ticker: TickerRecord, collectionId: string | null): boolean {
+  if (!collectionId) return false;
+  return ticker.metadata.portfolios.includes(collectionId)
+    || ticker.metadata.watchlists.includes(collectionId);
+}
+
 export function buildAppSessionSnapshot(state: SessionStateInput): AppSessionSnapshot {
   const seen = new Set<string>();
   const hydrationTargets: HydrationTarget[] = [];
@@ -104,6 +121,14 @@ export function buildAppSessionSnapshot(state: SessionStateInput): AppSessionSna
     if (instance.binding?.kind === "fixed") {
       pushTarget(state.tickers.get(instance.binding.symbol));
     }
+    if (instance.paneId === "portfolio-list") {
+      const collectionId = resolvePortfolioPaneCollectionId(state.config, paneState, instance);
+      for (const ticker of state.tickers.values()) {
+        if (tickerInCollection(ticker, collectionId)) {
+          pushTarget(ticker);
+        }
+      }
+    }
   }
 
   return {

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

@@ -43,6 +43,79 @@ async function flushCoordinator(): Promise<void> {
 }
 
 describe("MarketDataCoordinator key subscriptions", () => {
+  test("subscribes active quote targets as one provider batch", () => {
+    const subscriptions: QuoteSubscriptionTarget[][] = [];
+    const provider = createTestDataProvider({
+      id: "test-provider",
+      subscribeQuotes: (targets) => {
+        subscriptions.push(targets);
+        return () => {};
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+
+    coordinator.subscribeQuotes([
+      {
+        instrument: { symbol: "AAPL", exchange: "NASDAQ" },
+        priority: { surface: "portfolio", visible: true, selected: true, weight: 100 },
+      },
+      { instrument: { symbol: "MSFT", exchange: "NASDAQ" } },
+    ]);
+
+    expect(subscriptions).toHaveLength(1);
+    expect(subscriptions[0]?.map((target) => target.symbol).sort()).toEqual(["AAPL", "MSFT"]);
+    expect(subscriptions[0]?.find((target) => target.symbol === "AAPL")).toMatchObject({
+      surface: "portfolio",
+      visible: true,
+      selected: true,
+      weight: 100,
+    });
+  });
+
+  test("keeps the highest-priority target when duplicate surfaces subscribe", () => {
+    const subscriptions: QuoteSubscriptionTarget[][] = [];
+    let disposals = 0;
+    const provider = createTestDataProvider({
+      id: "test-provider",
+      subscribeQuotes: (targets) => {
+        subscriptions.push(targets);
+        return () => {
+          disposals += 1;
+        };
+      },
+    });
+    const coordinator = new MarketDataCoordinator(provider);
+    const instrument = { symbol: "AAPL", exchange: "NASDAQ" };
+
+    const unsubscribeDetail = coordinator.subscribeQuotes([{
+      instrument,
+      priority: { surface: "detail", visible: true, selected: true, weight: 100 },
+    }]);
+    coordinator.subscribeQuotes([{
+      instrument,
+      priority: { surface: "portfolio", visible: false, selected: false, weight: 10 },
+    }]);
+
+    expect(subscriptions).toHaveLength(1);
+    expect(subscriptions[0]?.[0]).toMatchObject({
+      surface: "detail",
+      visible: true,
+      selected: true,
+      weight: 100,
+    });
+
+    unsubscribeDetail();
+
+    expect(subscriptions).toHaveLength(2);
+    expect(disposals).toBe(1);
+    expect(subscriptions[1]?.[0]).toMatchObject({
+      surface: "portfolio",
+      visible: false,
+      selected: false,
+      weight: 10,
+    });
+  });
+
   test("notifies listeners for changed keys only", async () => {
     const { provider, emitQuote } = createProvider();
     const coordinator = new MarketDataCoordinator(provider);
@@ -97,29 +170,40 @@ describe("MarketDataCoordinator key subscriptions", () => {
     expect(coordinator.getVersion()).toBe(1);
   });
 
-  test("ignores repeated stream quotes that only refresh timestamp noise", async () => {
+  test("applies repeated stream quotes that refresh quote freshness", async () => {
+    const realDateNow = Date.now;
     const { provider, emitQuote } = createProvider();
     const coordinator = new MarketDataCoordinator(provider);
     const aapl = { symbol: "AAPL", exchange: "NASDAQ" };
     let calls = 0;
 
-    coordinator.subscribeKeys([buildQuoteKey(aapl)], () => { calls += 1; });
-    coordinator.subscribeQuotes([{ instrument: aapl }]);
-
     const firstTimestamp = 1_700_000_000_000;
-    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp }));
-    await flushCoordinator();
-
-    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp + 10_000 }));
-    await flushCoordinator();
-
-    expect(calls).toBe(1);
-    expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp);
-
-    emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 101, { lastUpdated: firstTimestamp + 20_000 }));
-    await flushCoordinator();
-
-    expect(calls).toBe(2);
-    expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(101);
+    try {
+      coordinator.subscribeKeys([buildQuoteKey(aapl)], () => { calls += 1; });
+      coordinator.subscribeQuotes([{ instrument: aapl }]);
+
+      Date.now = () => firstTimestamp;
+      emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp }));
+      await flushCoordinator();
+
+      Date.now = () => firstTimestamp + 10_000;
+      emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 100, { lastUpdated: firstTimestamp + 10_000 }));
+      await flushCoordinator();
+
+      expect(calls).toBe(2);
+      expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp + 10_000);
+      expect(coordinator.getQuoteEntry(aapl).data?.receivedAt).toBe(firstTimestamp + 10_000);
+
+      Date.now = () => firstTimestamp + 20_000;
+      emitQuote({ symbol: "AAPL", exchange: "NASDAQ" }, quote("AAPL", 101, { lastUpdated: firstTimestamp + 10_000 }));
+      await flushCoordinator();
+
+      expect(calls).toBe(3);
+      expect(coordinator.getQuoteEntry(aapl).data?.price).toBe(101);
+      expect(coordinator.getQuoteEntry(aapl).data?.lastUpdated).toBe(firstTimestamp + 10_000);
+      expect(coordinator.getQuoteEntry(aapl).data?.receivedAt).toBe(firstTimestamp + 20_000);
+    } finally {
+      Date.now = realDateNow;
+    }
   });
 });