gloomberb 0.10.0 → 0.10.2

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

@@ -1,6 +1,7 @@
 import type { DataProvider, QuoteSubscriptionTarget } from "../../types/data-provider";
 import type { Quote } from "../../types/financials";
 import type { InstrumentRef } from "../request-types";
+import { mergeQuoteSubscriptionTargets } from "../quote-subscription-target";
 import { QueryStore } from "../query-store";
 import type { QueryEntry } from "../result-types";
 import { buildQuoteKey, toMarketDataContext } from "../selectors";
@@ -61,47 +62,10 @@ const STREAM_QUOTE_FIELDS: Array<keyof Quote> = [
   "low",
   "mark",
   "dataSource",
+  "delivery",
+  "stale",
 ];
 
-function quoteSubscriptionPriorityScore(target: QuoteSubscriptionTarget): number {
-  let score = Number.isFinite(target.weight) ? Math.max(0, target.weight ?? 0) : 0;
-  if (target.selected) score += 10_000;
-  if (target.visible) score += 5_000;
-  if (target.surface === "detail" || target.surface === "monitor") score += 4_000;
-  if (target.surface === "portfolio" || target.surface === "watchlist") score += 1_000;
-  if (target.surface === "screener") score += 700;
-  if (target.surface === "inline") score += 200;
-  return score;
-}
-
-function mergeQuoteSubscriptionTargets(targets: Iterable<QuoteSubscriptionTarget>): QuoteSubscriptionTarget | null {
-  let selectedTarget: QuoteSubscriptionTarget | null = null;
-  let selectedScore = -1;
-  let visible = false;
-  let selected = false;
-  let weight = 0;
-
-  for (const target of targets) {
-    const score = quoteSubscriptionPriorityScore(target);
-    if (!selectedTarget || score > selectedScore) {
-      selectedTarget = target;
-      selectedScore = score;
-    }
-    visible ||= target.visible === true;
-    selected ||= target.selected === true;
-    weight = Math.max(weight, Number.isFinite(target.weight) ? Math.max(0, target.weight ?? 0) : 0);
-  }
-
-  return selectedTarget
-    ? {
-      ...selectedTarget,
-      visible,
-      selected,
-      weight,
-    }
-    : null;
-}
-
 function quoteTargetFromInstrument(
   instrument: InstrumentRef,
   priority: QuoteSubscriptionPriority = {},
@@ -289,7 +253,7 @@ export class QuoteSubscriptionManager {
     if (!this.dataProvider.subscribeQuotes) return;
 
     const activeEntries = [...this.quoteSubscriptions.entries()]
-      .filter(([, entry]) => entry.targets.size > 0 || entry.removeTimer)
+      .filter(([, entry]) => entry.targets.size > 0)
       .sort(([left], [right]) => left.localeCompare(right));
     const nextSignature = activeEntries.map(([key, entry]) => [
       key,

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, jest, test } from "bun:test";
 import { MarketDataCoordinator } from "./index";
 import { buildQuoteKey } from "../selectors";
 import { createTestDataProvider } from "../../test-support/data-provider";
@@ -117,6 +117,43 @@ describe("MarketDataCoordinator key subscriptions", () => {
     });
   });
 
+  test("replaces a capped target window without retaining pending removals", () => {
+    jest.useFakeTimers();
+    try {
+      const subscriptions: string[][] = [];
+      let disposals = 0;
+      const provider = createTestDataProvider({
+        id: "test-provider",
+        subscribeQuotes: (targets) => {
+          subscriptions.push(targets.map((target) => target.symbol));
+          return () => {
+            disposals += 1;
+          };
+        },
+      });
+      const coordinator = new MarketDataCoordinator(provider);
+      const oldTargets = Array.from({ length: 16 }, (_, index) => ({
+        instrument: { symbol: `OPT${index}`, exchange: "OPTIONS" },
+      }));
+      const newTargets = Array.from({ length: 16 }, (_, index) => ({
+        instrument: { symbol: `OPT${index + 2}`, exchange: "OPTIONS" },
+      }));
+
+      const unsubscribeOld = coordinator.subscribeQuotes(oldTargets);
+      unsubscribeOld();
+      const unsubscribeNew = coordinator.subscribeQuotes(newTargets);
+
+      expect(disposals).toBe(1);
+      expect(subscriptions).toHaveLength(2);
+      expect(subscriptions[1]).toEqual(newTargets.map(({ instrument }) => instrument.symbol).sort());
+
+      unsubscribeNew();
+      jest.runAllTimers();
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
   test("notifies listeners for changed keys only", async () => {
     const { provider, emitQuote } = createProvider();
     const coordinator = new MarketDataCoordinator(provider);
@@ -207,4 +244,55 @@ describe("MarketDataCoordinator key subscriptions", () => {
       Date.now = realDateNow;
     }
   });
+
+  test("does not refresh receipt time from an explicitly stale polled quote", async () => {
+    const realDateNow = Date.now;
+    const { provider, emitQuote } = createProvider();
+    const coordinator = new MarketDataCoordinator(provider);
+    const option = { symbol: "AAPL260731C00110000", exchange: "OPTIONS" };
+    const firstTimestamp = 1_800_000_000_000;
+    try {
+      coordinator.subscribeQuotes([{ instrument: option }]);
+
+      Date.now = () => firstTimestamp;
+      emitQuote(
+        option,
+        quote(option.symbol, 2.5, {
+          lastUpdated: firstTimestamp,
+          dataSource: "live",
+          delivery: "stream",
+          stale: false,
+        }),
+      );
+      await flushCoordinator();
+
+      expect(coordinator.getQuoteEntry(option).data).toMatchObject({
+        delivery: "stream",
+        stale: false,
+        receivedAt: firstTimestamp,
+      });
+
+      Date.now = () => firstTimestamp + 10_000;
+      emitQuote(
+        option,
+        quote(option.symbol, 2.5, {
+          lastUpdated: firstTimestamp,
+          dataSource: "live",
+          delivery: "poll",
+          stale: true,
+        }),
+      );
+      await flushCoordinator();
+
+      const entry = coordinator.getQuoteEntry(option);
+      expect(entry.data).toBeNull();
+      expect(entry.lastGoodData).toMatchObject({
+        delivery: "stream",
+        stale: false,
+        receivedAt: firstTimestamp,
+      });
+    } finally {
+      Date.now = realDateNow;
+    }
+  });
 });

package/src/market-data/hooks.tsx

@@ -30,6 +30,10 @@ interface ChartQueryOptions {
   refreshIntervalMs?: number;
 }
 
+interface OptionsQueryOptions {
+  refreshIntervalMs?: number;
+}
+
 type SharedCoordinator = NonNullable<ReturnType<typeof getSharedMarketDataCoordinator>>;
 
 function loadChartRequests(
@@ -180,6 +184,34 @@ export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerR
   return entry;
 }
 
+/**
+ * Observe quote entries already populated by the shared stream without issuing
+ * one HTTP snapshot request per instrument.
+ */
+export function useQuoteEntries(
+  instruments: readonly InstrumentRef[],
+): Map<string, QueryEntry<Quote>> {
+  const instrumentKey = instruments
+    .map((instrument) => buildQuoteKey(instrument))
+    .join("\u001f");
+  const keys = useMemo(
+    () => instruments.map((instrument) => buildQuoteKey(instrument)),
+    [instrumentKey],
+  );
+  const keysVersion = useCoordinatorKeysVersion(keys);
+  const coordinator = getSharedMarketDataCoordinator();
+
+  return useMemo(() => {
+    if (!coordinator) return new Map<string, QueryEntry<Quote>>();
+    return new Map(
+      instruments.map((instrument) => [
+        buildQuoteKey(instrument),
+        coordinator.getQuoteEntry(instrument),
+      ]),
+    );
+  }, [coordinator, instrumentKey, keysVersion]);
+}
+
 export function useChartQuery(
   request: ChartRequest | null | undefined,
   options: ChartQueryOptions = {},
@@ -275,11 +307,16 @@ export function useChartQueries(
   return useMemo(() => new Map(entries), [entries]);
 }
 
-export function useOptionsQuery(request: OptionsRequest | null | undefined): QueryEntry<OptionsChain> | null {
+export function useOptionsQuery(
+  request: OptionsRequest | null | undefined,
+  options: OptionsQueryOptions = {},
+): QueryEntry<OptionsChain> | null {
   const requestKey = request ? buildOptionsKey(request) : null;
   useCoordinatorKeysVersion(requestKey ? [requestKey] : []);
   const coordinator = getSharedMarketDataCoordinator();
   const entry = coordinator && request ? coordinator.getOptionsEntry(request) : null;
+  const appActive = useAppActive();
+  const refreshIntervalMs = Math.max(0, options.refreshIntervalMs ?? 0);
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();
@@ -287,6 +324,15 @@ export function useOptionsQuery(request: OptionsRequest | null | undefined): Que
     void coordinator.loadOptions(request).catch(() => {});
   }, [requestKey]);
 
+  useEffect(() => {
+    const coordinator = getSharedMarketDataCoordinator();
+    if (!coordinator || !request || !appActive || refreshIntervalMs <= 0) return;
+    const interval = setInterval(() => {
+      void coordinator.loadOptions(request, { forceRefresh: true }).catch(() => {});
+    }, refreshIntervalMs);
+    return () => clearInterval(interval);
+  }, [appActive, refreshIntervalMs, requestKey]);
+
   return entry;
 }
 

package/src/market-data/market/status.ts

@@ -1,5 +1,5 @@
 import type { MarketState, Quote, QuoteFieldProvenance } from "../../types/financials";
-import { blendHex, colors, priceColor } from "../../theme/colors";
+import { blendHex, colors, priceColor, type ThemeColors } from "../../theme/colors";
 
 const CLOSED_CHANGE_MUTING_RATIO = 0.55;
 
@@ -20,14 +20,14 @@ export function marketStateLabel(state: MarketState): string {
   }
 }
 
-export function marketStateColor(state: MarketState): string {
+export function marketStateColor(state: MarketState, palette: ThemeColors = colors): string {
   switch (state) {
-    case "REGULAR": return colors.positive;
+    case "REGULAR": return palette.positive;
     case "PRE":
-    case "POST": return colors.textBright;
+    case "POST": return palette.textBright;
     case "PREPRE":
     case "POSTPOST":
-    case "CLOSED": return colors.textDim;
+    case "CLOSED": return palette.textDim;
   }
 }
 
@@ -47,7 +47,7 @@ export function marketStateDot(state?: MarketState): string {
   }
 }
 
-export function isClosedMarketState(state?: MarketState): boolean {
+function isClosedMarketState(state?: MarketState): boolean {
   return state === "CLOSED" || state === "PREPRE" || state === "POSTPOST";
 }
 

package/src/market-data/performance.ts

@@ -27,7 +27,7 @@ function coercePointDate(value: Date | string | number): Date | null {
   return Number.isFinite(date.getTime()) ? date : null;
 }
 
-export function normalizePriceReturnHistory(points: readonly PricePoint[]): PricePoint[] {
+function normalizePriceReturnHistory(points: readonly PricePoint[]): PricePoint[] {
   const byTimestamp = new Map<number, PricePoint>();
   for (const point of points) {
     const date = coercePointDate(point.date as Date | string | number);

package/src/market-data/quote-subscription-target.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { mergeQuoteSubscriptionTargets } from "./quote-subscription-target";
+
+describe("mergeQuoteSubscriptionTargets", () => {
+  test("does not synthesize optional priority fields", () => {
+    const merged = mergeQuoteSubscriptionTargets([
+      { symbol: "AAPL", exchange: "NASDAQ" },
+      { symbol: "AAPL", exchange: "NASDAQ" },
+    ]);
+
+    expect(merged).toEqual({ symbol: "AAPL", exchange: "NASDAQ" });
+    expect(merged).not.toHaveProperty("visible");
+    expect(merged).not.toHaveProperty("selected");
+    expect(merged).not.toHaveProperty("weight");
+  });
+
+  test("combines priority fields that callers explicitly provide", () => {
+    const merged = mergeQuoteSubscriptionTargets([
+      { symbol: "TSLA", surface: "watchlist" as const, visible: true, selected: false, weight: 5 },
+      { symbol: "TSLA", surface: "detail" as const, visible: false, selected: true, weight: 20 },
+    ]);
+
+    expect(merged).toEqual({
+      symbol: "TSLA",
+      surface: "detail",
+      visible: true,
+      selected: true,
+      weight: 20,
+    });
+  });
+
+  test("preserves explicit false and zero values", () => {
+    expect(mergeQuoteSubscriptionTargets([
+      { symbol: "MSFT", visible: false, selected: false, weight: 0 },
+    ])).toEqual({ symbol: "MSFT", visible: false, selected: false, weight: 0 });
+  });
+});

package/src/market-data/quote-subscription-target.ts

@@ -0,0 +1,60 @@
+export interface QuoteSubscriptionPriorityTarget {
+  surface?: "portfolio" | "watchlist" | "detail" | "monitor" | "inline" | "options" | "screener" | "unknown";
+  visible?: boolean;
+  selected?: boolean;
+  weight?: number;
+}
+
+function quoteSubscriptionPriorityScore(target: QuoteSubscriptionPriorityTarget): number {
+  let score = Number.isFinite(target.weight) ? Math.max(0, target.weight ?? 0) : 0;
+  if (target.selected) score += 10_000;
+  if (target.visible) score += 5_000;
+  if (target.surface === "detail" || target.surface === "monitor" || target.surface === "options") score += 4_000;
+  if (target.surface === "portfolio" || target.surface === "watchlist") score += 1_000;
+  if (target.surface === "screener") score += 700;
+  if (target.surface === "inline") score += 200;
+  return score;
+}
+
+export function mergeQuoteSubscriptionTargets<T extends QuoteSubscriptionPriorityTarget>(
+  targets: Iterable<T>,
+): T | null {
+  let selectedTarget: T | null = null;
+  let selectedScore = -1;
+  let visible = false;
+  let selected = false;
+  let weight = 0;
+  let hasVisible = false;
+  let hasSelected = false;
+  let hasWeight = false;
+
+  for (const target of targets) {
+    const score = quoteSubscriptionPriorityScore(target);
+    if (!selectedTarget || score > selectedScore) {
+      selectedTarget = target;
+      selectedScore = score;
+    }
+    if (target.visible !== undefined) {
+      hasVisible = true;
+      visible ||= target.visible;
+    }
+    if (target.selected !== undefined) {
+      hasSelected = true;
+      selected ||= target.selected;
+    }
+    if (Number.isFinite(target.weight)) {
+      hasWeight = true;
+      weight = Math.max(weight, Math.max(0, target.weight ?? 0));
+    }
+  }
+
+  if (!selectedTarget) return null;
+  const merged = { ...selectedTarget };
+  if (hasVisible) merged.visible = visible;
+  else delete merged.visible;
+  if (hasSelected) merged.selected = selected;
+  else delete merged.selected;
+  if (hasWeight) merged.weight = weight;
+  else delete merged.weight;
+  return merged;
+}

package/src/market-data/quotes/freshness.ts

@@ -21,6 +21,7 @@ function isQuoteMissingActiveSessionPrice(quote: Quote): boolean {
 
 export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, now = Date.now()): boolean {
   if (!quote) return false;
+  if (quote.stale === true) return true;
   if (isQuoteMissingActiveSessionPrice(quote)) return true;
 
   return isTimestampStaleForExchangeSession(

package/src/market-data/quotes/resolution.ts

@@ -41,6 +41,8 @@ const PRICE_FIELD_KEYS = [
   "mark",
   "lastUpdated",
   "receivedAt",
+  "delivery",
+  "stale",
 ] as const;
 
 const SESSION_FIELD_KEYS = [
@@ -441,6 +443,8 @@ export function resolveCanonicalQuote(
     name: resolved.name as Quote["name"],
     lastUpdated: Number(resolved.lastUpdated ?? priceProvider?.lastUpdated ?? sessionProvider?.lastUpdated ?? now),
     receivedAt: resolved.receivedAt as Quote["receivedAt"],
+    delivery: resolved.delivery as Quote["delivery"],
+    stale: resolved.stale as Quote["stale"],
     exchangeName: resolved.exchangeName as Quote["exchangeName"],
     fullExchangeName: resolved.fullExchangeName as Quote["fullExchangeName"],
     listingExchangeName: resolved.listingExchangeName as Quote["listingExchangeName"],

package/src/market-data/request-types.ts

@@ -1,5 +1,5 @@
-import type { TimeRange } from "../components/chart/core/types";
-import type { ManualChartResolution } from "../components/chart/core/resolution";
+import type { TimeRange } from "../time-series/range";
+import type { ManualChartResolution } from "../time-series/resolution";
 import type { QuoteSubscriptionTarget } from "../types/data-provider";
 import type { BrokerContractRef } from "../types/instrument";
 import type { TickerRecord } from "../types/ticker";
@@ -95,7 +95,7 @@ export function quoteSubscriptionTargetFromTicker(
   return quoteSubscriptionTargetFromInstrument(instrument, route);
 }
 
-export function quoteSubscriptionTargetFromInstrument(
+function quoteSubscriptionTargetFromInstrument(
   instrument: InstrumentRef | null | undefined,
   route: QuoteSubscriptionTarget["route"] = "auto",
 ): QuoteSubscriptionTarget | null {

package/src/news/aggregator.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, mock } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
 import { NewsService } from "./aggregator";
 import { newsProvider, type NewsCapability } from "../capabilities";
 import type { MarketNewsItem } from "../types/news-source";
@@ -69,6 +69,10 @@ describe("NewsService", () => {
     agg = new NewsService();
   });
 
+  afterEach(() => {
+    agg.stop();
+  });
+
   it("deduplicates by URL, keeping higher importance", async () => {
     const low = makeItem({ url: "https://example.com/1", importance: 40 });
     const high = makeItem({ url: "https://example.com/1", importance: 80 });
@@ -224,6 +228,98 @@ describe("NewsService", () => {
     expect(states).toHaveLength(callCount);
   });
 
+  it("polls referenced queries only and stops after the last watcher leaves", async () => {
+    const query = { feed: "latest" as const, limit: 20 };
+    let fetchCount = 0;
+    const source = newsProvider({
+      id: "poll-lifecycle",
+      name: "poll-lifecycle",
+      provider: {
+        fetchNews: async () => {
+          fetchCount++;
+          return [];
+        },
+      },
+    });
+    agg.register(source);
+    await agg.load(query);
+    expect(fetchCount).toBe(1);
+
+    agg.start();
+    agg.register(makeSource("inactive-trigger", []));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fetchCount).toBe(1);
+
+    const dispose = agg.watchQuery(query, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fetchCount).toBe(2);
+
+    const disposeSecond = agg.watchQuery(query, () => {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fetchCount).toBe(3);
+
+    agg.register(makeSource("active-trigger", []));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fetchCount).toBe(4);
+
+    dispose();
+    agg.register(makeSource("single-watcher-trigger", []));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fetchCount).toBe(5);
+
+    disposeSecond();
+    agg.register(makeSource("disposed-trigger", []));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(fetchCount).toBe(5);
+  });
+
+  it("retains inactive query state for remounts", async () => {
+    const item = makeItem({ url: "https://remount.example.com/1" });
+    const query = { feed: "latest" as const, limit: 20 };
+    agg.register(makeSource("remount", [item]));
+    await agg.load(query);
+
+    const firstStates: string[][] = [];
+    const dispose = agg.watchQuery(query, (state) => {
+      firstStates.push(state.articles.map((article) => article.url));
+    });
+    dispose();
+
+    const remountedStates: string[][] = [];
+    const disposeRemount = agg.watchQuery(query, (state) => {
+      remountedStates.push(state.articles.map((article) => article.url));
+    });
+
+    expect(firstStates[0]).toEqual([item.url]);
+    expect(remountedStates[0]).toEqual([item.url]);
+    disposeRemount();
+  });
+
+  it("bounds inactive query state by LRU and TTL", async () => {
+    let now = 0;
+    agg = new NewsService({
+      inactiveQueryTtlMs: 10,
+      maxInactiveQueries: 2,
+      now: () => now,
+    });
+    agg.register(makeSource("bounded", [makeItem({ url: "https://bounded.example.com/1" })]));
+    const first = { feed: "latest" as const, topics: ["first"], limit: 20 };
+    const second = { feed: "latest" as const, topics: ["second"], limit: 20 };
+    const third = { feed: "latest" as const, topics: ["third"], limit: 20 };
+
+    await agg.load(first);
+    now = 1;
+    await agg.load(second);
+    now = 2;
+    await agg.load(third);
+
+    expect(agg.getQueryState(first).phase).toBe("idle");
+    expect(agg.getQueryState(third).phase).toBe("ready");
+
+    now = 20;
+    expect(agg.getQueryState(third).phase).toBe("idle");
+  });
+
   it("seeds cached source items immediately on register", () => {
     const cached = makeItem({ url: "https://cached.example.com/1", importance: 70 });
     let callCount = 0;