gloomberb 0.7.5 → 0.8.0

package/src/data/sqlite/retry.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from "bun:test";
+import { isSqliteBusyError, trySqliteBusyOperation, withSqliteBusyRetry } from "./retry";
+
+function createBusyError(): Error & { code: string; errno: number } {
+  const error = new Error("database is locked") as Error & { code: string; errno: number };
+  error.code = "SQLITE_BUSY";
+  error.errno = 5;
+  return error;
+}
+
+describe("sqlite busy retry", () => {
+  test("recognizes Bun SQLite busy errors", () => {
+    expect(isSqliteBusyError(createBusyError())).toBe(true);
+    expect(isSqliteBusyError(new Error("other failure"))).toBe(false);
+  });
+
+  test("retries busy errors until the operation succeeds", () => {
+    let attempts = 0;
+
+    const result = withSqliteBusyRetry("test retry", () => {
+      attempts += 1;
+      if (attempts < 3) throw createBusyError();
+      return "ok";
+    }, {
+      attempts: 3,
+      initialDelayMs: 0,
+      maxDelayMs: 0,
+    });
+
+    expect(result).toBe("ok");
+    expect(attempts).toBe(3);
+  });
+
+  test("stops after the configured busy retry attempts", () => {
+    let attempts = 0;
+
+    expect(() => withSqliteBusyRetry("test exhaustion", () => {
+      attempts += 1;
+      throw createBusyError();
+    }, {
+      attempts: 2,
+      initialDelayMs: 0,
+      maxDelayMs: 0,
+    })).toThrow("database is locked");
+
+    expect(attempts).toBe(2);
+  });
+
+  test("optional operations only swallow exhausted busy errors", () => {
+    const result = trySqliteBusyOperation("optional busy", () => {
+      throw createBusyError();
+    }, {
+      attempts: 1,
+      initialDelayMs: 0,
+      maxDelayMs: 0,
+    });
+
+    expect(result).toBeNull();
+    expect(() => trySqliteBusyOperation("optional non-busy", () => {
+      throw new Error("not sqlite");
+    })).toThrow("not sqlite");
+  });
+});

package/src/data/ticker-repository.ts

@@ -1,6 +1,6 @@
 import type { TickerRecord, TickerMetadata } from "../types/ticker";
 import type { TickerStore } from "./ticker-store";
-import { hydrateTickerMetadata } from "../utils/ticker-metadata";
+import { hydrateTickerMetadata } from "../tickers/metadata";
 
 function parseTickerMetadata(json: string): TickerMetadata {
   return hydrateTickerMetadata(JSON.parse(json) as Record<string, unknown>);

package/src/data/ticker-store.ts

@@ -1,6 +1,6 @@
 import type { Database } from "bun:sqlite";
-import { serializeJson } from "./sqlite-json";
-import { withSqliteBusyRetry } from "./sqlite-retry";
+import { serializeJson } from "./sqlite/json";
+import { withSqliteBusyRetry } from "./sqlite/retry";
 
 export interface StoredTickerRecord {
   symbol: string;

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

@@ -0,0 +1,252 @@
+import type { DataProvider, SecFilingItem } from "../../types/data-provider";
+import type { NewsArticle } from "../../news/types";
+import type { OptionsChain } from "../../types/financials";
+import type { NewsRequest, OptionsRequest, SecFilingsRequest } from "../request-types";
+import type { QueryEntry } from "../result-types";
+import { QueryStore } from "../query-store";
+import {
+  ARTICLE_SUMMARY_CACHE_TTL_MS,
+  EXPECTED_EMPTY,
+  FX_CACHE_TTL_MS,
+  NEWS_CACHE_TTL_MS,
+  OPTIONS_CACHE_TTL_MS,
+  SEC_CONTENT_CACHE_TTL_MS,
+  SEC_FILINGS_CACHE_TTL_MS,
+  classifyError,
+  createAttempt,
+  errorEntry,
+  hasFreshEntryData,
+  hasFreshReadyEntry,
+  loadingEntry,
+  readyEntry,
+} from "./entries";
+import {
+  buildArticleSummaryKey,
+  buildFxKey,
+  buildNewsKey,
+  buildOptionsKey,
+  buildSecContentKey,
+  buildSecFilingsKey,
+  toMarketDataContext,
+} from "../selectors";
+
+type RunSingleFlight = <T>(key: string, task: () => Promise<T>) => Promise<T>;
+
+interface AuxiliaryLoaderOptions<T> {
+  dataProvider: DataProvider;
+  key: string;
+  store: QueryStore<T>;
+  ttlMs: number;
+  runSingleFlight: RunSingleFlight;
+  load: (startedAt: number) => Promise<QueryEntry<T>>;
+}
+
+interface NewsDataProvider extends DataProvider {
+  getNews?: (query: {
+    feed: "ticker";
+    ticker: string;
+    exchange?: string;
+    tickerTier: "primary";
+    limit?: number;
+  }) => Promise<NewsArticle[]>;
+}
+
+export function loadNewsEntry(options: {
+  dataProvider: DataProvider;
+  request: NewsRequest;
+  store: QueryStore<NewsArticle[]>;
+  runSingleFlight: RunSingleFlight;
+}): Promise<QueryEntry<NewsArticle[]>> {
+  const { dataProvider, request, store, runSingleFlight } = options;
+  const key = buildNewsKey(request);
+  return loadAuxiliaryEntry({
+    dataProvider,
+    key,
+    store,
+    ttlMs: NEWS_CACHE_TTL_MS,
+    runSingleFlight,
+    load: async (startedAt) => {
+      const newsProvider = dataProvider as NewsDataProvider;
+      if (!newsProvider.getNews) throw new Error("No news provider available");
+      const data = await newsProvider.getNews({
+        feed: "ticker",
+        ticker: request.instrument.symbol,
+        exchange: request.instrument.exchange ?? "",
+        tickerTier: "primary",
+        limit: request.count ?? 50,
+      });
+      const attempts = [createAttempt(dataProvider.id, startedAt, data.length > 0 ? "success" : "empty", data.length === 0 ? "NO_DATA" : undefined)];
+      return store.update(key, (current) => readyEntry(current, data.length > 0 ? data : null, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+    },
+  });
+}
+
+export function loadOptionsEntry(options: {
+  dataProvider: DataProvider;
+  request: OptionsRequest;
+  store: QueryStore<OptionsChain>;
+  runSingleFlight: RunSingleFlight;
+}): Promise<QueryEntry<OptionsChain>> {
+  const { dataProvider, request, store, runSingleFlight } = options;
+  const key = buildOptionsKey(request);
+  return loadAuxiliaryEntry({
+    dataProvider,
+    key,
+    store,
+    ttlMs: OPTIONS_CACHE_TTL_MS,
+    runSingleFlight,
+    load: async (startedAt) => {
+      if (!dataProvider.getOptionsChain) {
+        const attempt = createAttempt(dataProvider.id, startedAt, "unsupported", "UNSUPPORTED_RANGE", "Options are not available");
+        return store.update(key, (current) => errorEntry(current, attempt));
+      }
+      const data = await dataProvider.getOptionsChain(
+        request.instrument.symbol,
+        request.instrument.exchange ?? "",
+        request.expirationDate,
+        toMarketDataContext(request.instrument),
+      );
+      const attempts = [createAttempt(dataProvider.id, startedAt, data.expirationDates.length > 0 ? "success" : "empty", data.expirationDates.length === 0 ? "NO_DATA" : undefined)];
+      return store.update(key, (current) => readyEntry(current, data.expirationDates.length > 0 ? data : null, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+    },
+  });
+}
+
+export function loadSecFilingsEntry(options: {
+  dataProvider: DataProvider;
+  request: SecFilingsRequest;
+  store: QueryStore<SecFilingItem[]>;
+  runSingleFlight: RunSingleFlight;
+}): Promise<QueryEntry<SecFilingItem[]>> {
+  const { dataProvider, request, store, runSingleFlight } = options;
+  const key = buildSecFilingsKey(request);
+  return loadAuxiliaryEntry({
+    dataProvider,
+    key,
+    store,
+    ttlMs: SEC_FILINGS_CACHE_TTL_MS,
+    runSingleFlight,
+    load: async (startedAt) => {
+      if (!dataProvider.getSecFilings) {
+        const attempt = createAttempt(dataProvider.id, startedAt, "unsupported", "UNSUPPORTED_RANGE", "SEC filings are not available");
+        return store.update(key, (current) => errorEntry(current, attempt));
+      }
+      const data = await dataProvider.getSecFilings(
+        request.instrument.symbol,
+        request.count ?? 50,
+        request.instrument.exchange ?? "",
+        toMarketDataContext(request.instrument),
+      );
+      const attempts = [createAttempt(dataProvider.id, startedAt, data.length > 0 ? "success" : "empty", data.length === 0 ? "NO_DATA" : undefined)];
+      return store.update(key, (current) => readyEntry(current, data.length > 0 ? data : null, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+    },
+  });
+}
+
+export function loadSecFilingContentEntry(options: {
+  dataProvider: DataProvider;
+  filing: SecFilingItem;
+  store: QueryStore<string | null>;
+  runSingleFlight: RunSingleFlight;
+}): Promise<QueryEntry<string | null>> {
+  const { dataProvider, filing, store, runSingleFlight } = options;
+  const key = buildSecContentKey(filing.accessionNumber);
+  return loadAuxiliaryEntry({
+    dataProvider,
+    key,
+    store,
+    ttlMs: SEC_CONTENT_CACHE_TTL_MS,
+    runSingleFlight,
+    load: async (startedAt) => {
+      if (!dataProvider.getSecFilingContent) {
+        const attempt = createAttempt(dataProvider.id, startedAt, "unsupported", "UNSUPPORTED_RANGE", "SEC filing content is not available");
+        return store.update(key, (current) => errorEntry(current, attempt));
+      }
+      const data = await dataProvider.getSecFilingContent(filing);
+      const status = data ? "success" : "empty";
+      const attempts = [createAttempt(dataProvider.id, startedAt, status, data ? undefined : "NO_DATA")];
+      return store.update(key, (current) => readyEntry(current, data, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+    },
+  });
+}
+
+export function loadArticleSummaryEntry(options: {
+  dataProvider: DataProvider;
+  url: string;
+  store: QueryStore<string | null>;
+  runSingleFlight: RunSingleFlight;
+}): Promise<QueryEntry<string | null>> {
+  const { dataProvider, url, store, runSingleFlight } = options;
+  const key = buildArticleSummaryKey(url);
+  return loadAuxiliaryEntry({
+    dataProvider,
+    key,
+    store,
+    ttlMs: ARTICLE_SUMMARY_CACHE_TTL_MS,
+    runSingleFlight,
+    load: async (startedAt) => {
+      const data = await dataProvider.getArticleSummary(url);
+      const status = data ? "success" : "empty";
+      const attempts = [createAttempt(dataProvider.id, startedAt, status, data ? undefined : "NO_DATA")];
+      return store.update(key, (current) => readyEntry(current, data, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+    },
+  });
+}
+
+export function loadFxRateEntry(options: {
+  dataProvider: DataProvider;
+  currency: string;
+  store: QueryStore<number>;
+  runSingleFlight: RunSingleFlight;
+}): Promise<QueryEntry<number>> {
+  const { dataProvider, store, runSingleFlight } = options;
+  const normalizedCurrency = options.currency.trim().toUpperCase();
+  const key = buildFxKey(normalizedCurrency);
+  const current = store.get(key);
+  if (hasFreshEntryData(current, FX_CACHE_TTL_MS)) {
+    return Promise.resolve(current);
+  }
+  if (normalizedCurrency === "USD") {
+    const startedAt = Date.now();
+    const attempts = [createAttempt("static", startedAt, "success")];
+    return Promise.resolve(store.update(key, (current) => readyEntry(current, 1, "static", attempts, { keepLastGoodOnEmpty: true })));
+  }
+  return runSingleFlight(key, async () => {
+    store.update(key, loadingEntry);
+    const startedAt = Date.now();
+    try {
+      const rate = await dataProvider.getExchangeRate(normalizedCurrency);
+      const attempts = [createAttempt(dataProvider.id, startedAt, "success")];
+      return store.update(key, (current) => readyEntry(current, rate, dataProvider.id, attempts, { keepLastGoodOnEmpty: true }));
+    } catch (error) {
+      const classified = classifyError(error);
+      const attempt = createAttempt(dataProvider.id, startedAt, "fatal_error", classified.reasonCode, classified.message);
+      return store.update(key, (current) => errorEntry(current, attempt));
+    }
+  });
+}
+
+function loadAuxiliaryEntry<T>({
+  dataProvider,
+  key,
+  store,
+  ttlMs,
+  runSingleFlight,
+  load,
+}: AuxiliaryLoaderOptions<T>): Promise<QueryEntry<T>> {
+  const current = store.get(key);
+  if (hasFreshReadyEntry(current, ttlMs)) {
+    return Promise.resolve(current);
+  }
+  return runSingleFlight(key, async () => {
+    store.update(key, loadingEntry);
+    const startedAt = Date.now();
+    try {
+      return await load(startedAt);
+    } catch (error) {
+      const classified = classifyError(error);
+      const attempt = createAttempt(dataProvider.id, startedAt, EXPECTED_EMPTY.test(classified.message) ? "empty" : "fatal_error", classified.reasonCode, classified.message);
+      return store.update(key, (current) => errorEntry(current, attempt));
+    }
+  });
+}

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

@@ -0,0 +1,141 @@
+import { isIntradayResolution, TIME_RANGE_ORDER } from "../../components/chart/core/resolution";
+import type { PricePoint } from "../../types/financials";
+import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory } from "../../utils/price-history";
+import type { ChartRequest, InstrumentRef } from "../request-types";
+import type { QueryEntry } from "../result-types";
+import { buildInstrumentKey } from "../selectors";
+import { loadingEntry } from "./entries";
+
+const TIME_RANGE_INDEX = new Map(TIME_RANGE_ORDER.map((range, index) => [range, index]));
+
+export function createBaselineChartRequest(instrument: InstrumentRef): ChartRequest {
+  return {
+    instrument,
+    bufferRange: "5Y",
+    granularity: "range",
+  };
+}
+
+function getChartGranularity(request: ChartRequest): NonNullable<ChartRequest["granularity"]> {
+  return request.granularity ?? "range";
+}
+
+function getTimeRangeIndex(range: ChartRequest["bufferRange"]): number {
+  return TIME_RANGE_INDEX.get(range) ?? 0;
+}
+
+function isCurrentHistoryWindow(endDate?: Date): boolean {
+  if (!endDate) return true;
+  const endMs = endDate.getTime();
+  return Number.isFinite(endMs) && Date.now() - endMs < 60 * 60_000;
+}
+
+function isIntradayChartRequest(request: ChartRequest): boolean {
+  const granularity = getChartGranularity(request);
+  if (granularity === "detail") return isCurrentHistoryWindow(request.endDate);
+  if (granularity === "resolution") {
+    return request.resolution ? isIntradayResolution(request.resolution) : false;
+  }
+  return request.bufferRange === "1D" || request.bufferRange === "1W" || request.bufferRange === "1M" || request.bufferRange === "3M";
+}
+
+export function normalizeFreshChartData(points: PricePoint[] | null | undefined, request: ChartRequest): PricePoint[] {
+  const normalized = normalizePriceHistory(points ?? []);
+  if (
+    isIntradayChartRequest(request)
+    && isPriceHistoryStaleForCurrentWindow(normalized, Date.now(), { exchange: request.instrument.exchange })
+  ) {
+    return [];
+  }
+  return normalized;
+}
+
+function isSeedableChartRequest(
+  target: ChartRequest,
+  candidate: ChartRequest,
+): boolean {
+  const targetGranularity = getChartGranularity(target);
+  const candidateGranularity = getChartGranularity(candidate);
+  if (targetGranularity !== candidateGranularity) return false;
+  if (targetGranularity === "detail") return false;
+  if (targetGranularity === "resolution" && target.resolution !== candidate.resolution) return false;
+  if (buildInstrumentKey(target.instrument) !== buildInstrumentKey(candidate.instrument)) return false;
+  return getTimeRangeIndex(candidate.bufferRange) <= getTimeRangeIndex(target.bufferRange);
+}
+
+interface ChartSeedLookupArgs {
+  key: string;
+  request: ChartRequest;
+  chartRequests: Iterable<[string, ChartRequest]>;
+  getEntry: (key: string) => QueryEntry<PricePoint[]>;
+  resolveEntryData: (entry: QueryEntry<PricePoint[]>) => PricePoint[] | null;
+}
+
+function findChartSeedEntry({
+  key,
+  request,
+  chartRequests,
+  getEntry,
+  resolveEntryData,
+}: ChartSeedLookupArgs): { entry: QueryEntry<PricePoint[]>; data: PricePoint[]; score: number } | null {
+  let best: { entry: QueryEntry<PricePoint[]>; data: PricePoint[]; score: number } | null = null;
+  for (const [candidateKey, candidateRequest] of chartRequests) {
+    if (candidateKey === key) continue;
+    if (!isSeedableChartRequest(request, candidateRequest)) continue;
+    const entry = getEntry(candidateKey);
+    const data = resolveEntryData(entry);
+    if (!data?.length) continue;
+    const score = getTimeRangeIndex(candidateRequest.bufferRange);
+    if (!best || score > best.score) {
+      best = { entry, data, score };
+    }
+  }
+  return best;
+}
+
+export function createChartLoadingEntry({
+  key,
+  request,
+  current,
+  chartRequests,
+  getEntry,
+  resolveEntryData,
+}: ChartSeedLookupArgs & {
+  current: QueryEntry<PricePoint[]>;
+}): QueryEntry<PricePoint[]> {
+  const currentData = normalizeFreshChartData(resolveEntryData(current), request);
+  if (currentData.length) {
+    return loadingEntry<PricePoint[]>({
+      ...current,
+      data: currentData,
+      lastGoodData: currentData,
+    });
+  }
+
+  const seed = findChartSeedEntry({ key, request, chartRequests, getEntry, resolveEntryData });
+  if (!seed) {
+    return loadingEntry<PricePoint[]>({
+      ...current,
+      data: null,
+      lastGoodData: null,
+    });
+  }
+
+  const seedData = normalizeFreshChartData(seed.data, request);
+  if (!seedData.length) {
+    return loadingEntry<PricePoint[]>({
+      ...current,
+      data: null,
+      lastGoodData: null,
+    });
+  }
+
+  return loadingEntry({
+    ...current,
+    data: seedData,
+    lastGoodData: seedData,
+    source: seed.entry.source,
+    fetchedAt: seed.entry.fetchedAt,
+    staleAt: seed.entry.staleAt,
+  });
+}

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

@@ -0,0 +1,129 @@
+import type { Quote, TickerFinancials } from "../../types/financials";
+import { hasFreshQuoteForCurrentSession, isQuoteStaleForCurrentSession } from "../quotes/freshness";
+import type { InstrumentRef } from "../request-types";
+import type { ProviderAttempt, ProviderReasonCode, QueryEntry } from "../result-types";
+import { resolveEntryData } from "../selectors";
+
+const EMPTY_MESSAGE = "No data available";
+export const EXPECTED_EMPTY = /no data|not found|delisted|unavailable|unsupported/i;
+export const SNAPSHOT_CACHE_TTL_MS = 5 * 60_000;
+export const CHART_CACHE_TTL_MS = 10 * 60_000;
+export const NEWS_CACHE_TTL_MS = 2 * 60_000;
+export const OPTIONS_CACHE_TTL_MS = 10 * 60_000;
+export const SEC_FILINGS_CACHE_TTL_MS = 10 * 60_000;
+export const SEC_CONTENT_CACHE_TTL_MS = 24 * 60 * 60_000;
+export const ARTICLE_SUMMARY_CACHE_TTL_MS = 24 * 60 * 60_000;
+export const FX_CACHE_TTL_MS = 30 * 60_000;
+
+export function classifyError(error: unknown): { reasonCode: ProviderReasonCode; message: string } {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  if (/timeout/i.test(message)) return { reasonCode: "TIMEOUT", message };
+  if (/unsupported/i.test(message)) return { reasonCode: "UNSUPPORTED_RANGE", message };
+  if (/mapping|symbol/i.test(message)) return { reasonCode: "BAD_MAPPING", message };
+  if (/not found|no data|unavailable|delisted/i.test(message)) return { reasonCode: "NOT_FOUND", message };
+  return { reasonCode: "UPSTREAM_ERROR", message };
+}
+
+export function hasFreshEntryData<T>(entry: QueryEntry<T>, ttlMs: number, now = Date.now()): boolean {
+  if (resolveEntryData(entry) == null) return false;
+  return entry.fetchedAt != null && now - entry.fetchedAt < ttlMs;
+}
+
+export function hasFreshReadyEntry<T>(entry: QueryEntry<T>, ttlMs: number, now = Date.now()): boolean {
+  return entry.phase === "ready" && entry.fetchedAt != null && now - entry.fetchedAt < ttlMs;
+}
+
+export function hasFreshQuoteEntry(
+  entry: QueryEntry<Quote>,
+  instrument: InstrumentRef,
+  ttlMs: number,
+  now = Date.now(),
+): boolean {
+  const quote = resolveEntryData(entry);
+  if (!quote || entry.fetchedAt == null || now - entry.fetchedAt >= ttlMs) return false;
+  const quoteForFreshness = instrument.exchange && !quote.listingExchangeName && !quote.exchangeName
+    ? { ...quote, listingExchangeName: instrument.exchange }
+    : quote;
+  return !isQuoteStaleForCurrentSession(quoteForFreshness, now);
+}
+
+export function createAttempt(
+  providerId: string,
+  startedAt: number,
+  status: ProviderAttempt["status"],
+  reasonCode?: ProviderReasonCode,
+  message?: string,
+): ProviderAttempt {
+  const finishedAt = Date.now();
+  return {
+    providerId,
+    status,
+    startedAt,
+    finishedAt,
+    latencyMs: Math.max(0, finishedAt - startedAt),
+    reasonCode,
+    message,
+  };
+}
+
+export function loadingEntry<T>(current: QueryEntry<T>): QueryEntry<T> {
+  return {
+    ...current,
+    phase: current.lastGoodData || current.data ? "refreshing" : "loading",
+    error: null,
+    attempts: [],
+  };
+}
+
+export function readyEntry<T>(
+  current: QueryEntry<T>,
+  data: T | null,
+  source: string,
+  attempts: ProviderAttempt[],
+  options: { keepLastGoodOnEmpty?: boolean } = {},
+): QueryEntry<T> {
+  const resolvedData = data ?? (options.keepLastGoodOnEmpty ? current.lastGoodData : null);
+  return {
+    phase: "ready",
+    data,
+    lastGoodData: resolvedData,
+    source,
+    fetchedAt: Date.now(),
+    staleAt: null,
+    error: data == null ? { reasonCode: "NO_DATA", message: EMPTY_MESSAGE } : null,
+    attempts,
+  };
+}
+
+export function readyQuoteEntry(
+  current: QueryEntry<Quote>,
+  quote: Quote,
+  source: string,
+  attempts: ProviderAttempt[],
+): QueryEntry<Quote> {
+  if (isQuoteStaleForCurrentSession(quote)) {
+    const keepFreshQuote = hasFreshQuoteForCurrentSession([current.data, current.lastGoodData]);
+    return readyEntry(current, null, current.source ?? source, attempts, { keepLastGoodOnEmpty: keepFreshQuote });
+  }
+  return readyEntry(current, quote, source, attempts, { keepLastGoodOnEmpty: true });
+}
+
+export function errorEntry<T>(current: QueryEntry<T>, attempt: ProviderAttempt): QueryEntry<T> {
+  return {
+    ...current,
+    phase: current.lastGoodData ? "ready" : "error",
+    data: current.lastGoodData,
+    error: {
+      reasonCode: attempt.reasonCode ?? "UPSTREAM_ERROR",
+      message: attempt.message ?? EMPTY_MESSAGE,
+    },
+    attempts: [attempt],
+  };
+}
+
+export function hasCachedSnapshotData(financials: TickerFinancials): boolean {
+  return !!financials.profile
+    || Object.keys(financials.fundamentals ?? {}).length > 0
+    || financials.annualStatements.length > 0
+    || financials.quarterlyStatements.length > 0;
+}

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

@@ -0,0 +1,74 @@
+import { measurePerf } from "../../utils/perf-marks";
+
+export class MarketDataCoordinatorEvents {
+  private version = 0;
+  private pendingVersionBump = false;
+  private pendingChangedKeys = new Set<string>();
+  private readonly listeners = new Set<() => void>();
+  private readonly keyListeners = new Map<string, Set<() => void>>();
+  private readonly keyVersions = new Map<string, number>();
+
+  bump(changeKey?: string): void {
+    if (changeKey) this.pendingChangedKeys.add(changeKey);
+    if (this.pendingVersionBump) return;
+    this.pendingVersionBump = true;
+    queueMicrotask(() => this.flushBump());
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  subscribeKeys(keys: readonly string[], listener: () => void): () => void {
+    const uniqueKeys = [...new Set(keys)];
+    for (const key of uniqueKeys) {
+      if (!this.keyListeners.has(key)) this.keyListeners.set(key, new Set());
+      this.keyListeners.get(key)!.add(listener);
+    }
+    return () => {
+      for (const key of uniqueKeys) {
+        const listeners = this.keyListeners.get(key);
+        listeners?.delete(listener);
+        if (listeners?.size === 0) {
+          this.keyListeners.delete(key);
+        }
+      }
+    };
+  }
+
+  getVersion(): number {
+    return this.version;
+  }
+
+  getKeysVersion(keys: readonly string[]): number {
+    let version = 0;
+    for (const key of new Set(keys)) {
+      version += this.keyVersions.get(key) ?? 0;
+    }
+    return version;
+  }
+
+  private flushBump(): void {
+    this.pendingVersionBump = false;
+    const changedKeys = this.pendingChangedKeys;
+    this.pendingChangedKeys = new Set();
+    measurePerf("market-data.bump", () => {
+      this.version += 1;
+      for (const key of changedKeys) {
+        this.keyVersions.set(key, (this.keyVersions.get(key) ?? 0) + 1);
+      }
+      const keyListeners = new Set<() => void>();
+      for (const key of changedKeys) {
+        for (const listener of this.keyListeners.get(key) ?? []) {
+          keyListeners.add(listener);
+        }
+      }
+
+      for (const listener of this.listeners) listener();
+      for (const listener of keyListeners) listener();
+    }, { changedKeyCount: changedKeys.size });
+  }
+}