gloomberb 0.7.3 → 0.7.5

package/src/utils/api-client.ts

@@ -5,6 +5,7 @@ import type {
   Fundamentals,
   HolderData,
   HolderRecord,
+  OptionsChain,
   PricePoint,
   Quote,
   TickerFinancials,
@@ -100,6 +101,10 @@ export interface CloudQuotePayload extends Quote {
   dataSource: "live" | "delayed";
 }
 
+export interface CloudOptionsChainPayload extends OptionsChain {
+  providerId: "gloomberb-cloud";
+}
+
 export interface CloudCompanyProfile extends CompanyProfile {}
 
 export interface CloudFundamentals extends Fundamentals {}
@@ -317,10 +322,19 @@ export interface CloudMarketResponse<T> {
   reasonCode?: string;
   asOf?: string;
   staleAt?: string;
+  stale?: boolean;
+  currency?: string;
   providerMeta?: {
+    provider?: string;
     upstream?: string;
+    status?: CloudMarketStatus;
+    reasonCode?: string;
     normalizedSymbol?: string;
     normalizedExchange?: string;
+    stale?: boolean;
+    fallbackReason?: string;
+    requestedResolution?: string;
+    servedResolution?: string;
     latencyMs?: number;
     range?: string;
     granularity?: string;
@@ -356,6 +370,10 @@ export interface CloudVerificationResponse {
 export interface QuoteStreamTarget {
   symbol: string;
   exchange?: string;
+  surface?: "portfolio" | "watchlist" | "detail" | "monitor" | "inline" | "screener" | "unknown";
+  visible?: boolean;
+  selected?: boolean;
+  weight?: number;
 }
 
 function marketKey(symbol: string, exchange?: string): string {
@@ -602,18 +620,20 @@ class GloomApiClient {
   }
 
   private shouldKeepSocketOpen(): boolean {
+    if (this.quoteTargets.size > 0) return true;
     return !!this.getSocketAuthToken()
       && !!this.currentUser?.emailVerified
-      && (this.channelListeners.size > 0 || this.quoteTargets.size > 0);
+      && this.channelListeners.size > 0;
   }
 
   private ensureSocket(): void {
     if (!this.shouldKeepSocketOpen() || this.ws || this.reconnectTimer) return;
 
     const socketToken = this.getSocketAuthToken();
-    if (!socketToken) return;
     const usingWebSocketToken = !!this.websocketToken;
-    const url = `${this.getWebSocketBaseUrl()}/cloud/ws?token=${encodeURIComponent(socketToken)}`;
+    const url = socketToken
+      ? `${this.getWebSocketBaseUrl()}/cloud/ws?token=${encodeURIComponent(socketToken)}`
+      : `${this.getWebSocketBaseUrl()}/cloud/ws`;
     cloudApiLog.info("open websocket", {
       hasToken: !!socketToken,
       tokenSource: usingWebSocketToken ? "websocket" : "session",
@@ -714,10 +734,7 @@ class GloomApiClient {
     if (this.quoteTargets.size > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",
-        symbols: [...this.quoteTargets.values()].map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
+        symbols: [...this.quoteTargets.values()].map((target) => this.serializeQuoteStreamTarget(target)),
       });
     }
   }
@@ -761,23 +778,28 @@ class GloomApiClient {
     if (subscribes.length > 0) {
       this.sendSocketMessage({
         type: "market.subscribe",
-        symbols: subscribes.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
+        symbols: subscribes.map((target) => this.serializeQuoteStreamTarget(target)),
       });
     }
     if (unsubscribes.length > 0) {
       this.sendSocketMessage({
         type: "market.unsubscribe",
-        symbols: unsubscribes.map((target) => ({
-          symbol: target.symbol,
-          exchange: target.exchange ?? "",
-        })),
+        symbols: unsubscribes.map((target) => this.serializeQuoteStreamTarget(target)),
       });
     }
   }
 
+  private serializeQuoteStreamTarget(target: QuoteStreamTarget): QuoteStreamTarget {
+    return {
+      symbol: target.symbol,
+      exchange: target.exchange ?? "",
+      ...(target.surface ? { surface: target.surface } : {}),
+      ...(target.visible ? { visible: true } : {}),
+      ...(target.selected ? { selected: true } : {}),
+      ...(Number.isFinite(target.weight) ? { weight: target.weight } : {}),
+    };
+  }
+
   private async handleSocketMessage(raw: string): Promise<void> {
     let parsed: any;
     try {
@@ -808,6 +830,9 @@ class GloomApiClient {
       if (this.currentUser) {
         this.currentUser = { ...this.currentUser, emailVerified: false };
       }
+      if (this.quoteTargets.size > 0) {
+        return;
+      }
       this.teardownSocket();
       return;
     }
@@ -1036,17 +1061,27 @@ class GloomApiClient {
           const normalized = {
             symbol: normalizeSymbol(target.symbol),
             exchange: canonicalExchange(target.exchange),
+            surface: target.surface,
+            visible: target.visible,
+            selected: target.selected,
+            weight: target.weight,
           } satisfies QuoteStreamTarget;
           return [marketKey(normalized.symbol, normalized.exchange), normalized] as const;
         }),
     ).values()];
 
     const newSubscriptions: QuoteStreamTarget[] = [];
+    const updatedSubscriptions: QuoteStreamTarget[] = [];
     for (const target of uniqueTargets) {
       const key = marketKey(target.symbol, target.exchange);
       const listeners = this.quoteListeners.get(key) ?? new Set<QuoteListener>();
       if (listeners.size === 0) {
         newSubscriptions.push(target);
+      } else {
+        const existing = this.quoteTargets.get(key);
+        if (JSON.stringify(this.serializeQuoteStreamTarget(existing ?? target)) !== JSON.stringify(this.serializeQuoteStreamTarget(target))) {
+          updatedSubscriptions.push(target);
+        }
       }
       listeners.add(onQuote);
       this.quoteListeners.set(key, listeners);
@@ -1054,12 +1089,13 @@ class GloomApiClient {
     }
 
     this.ensureSocket();
-    if (newSubscriptions.length > 0) {
+    const subscriptionsToSend = [...newSubscriptions, ...updatedSubscriptions];
+    if (subscriptionsToSend.length > 0) {
       cloudApiLog.info("register quote listeners", {
-        count: newSubscriptions.length,
-        symbols: newSubscriptions.map((target) => marketKey(target.symbol, target.exchange)),
+        count: subscriptionsToSend.length,
+        symbols: subscriptionsToSend.map((target) => marketKey(target.symbol, target.exchange)),
       });
-      this.queueQuoteSubscribes(newSubscriptions);
+      this.queueQuoteSubscribes(subscriptionsToSend);
     }
 
     return () => {
@@ -1139,6 +1175,17 @@ class GloomApiClient {
     });
   }
 
+  async getCloudOptionsChain(
+    symbol: string,
+    exchange?: string,
+    expirationDate?: number,
+  ): Promise<CloudMarketResponse<CloudOptionsChainPayload>> {
+    const params = new URLSearchParams({ symbol });
+    if (exchange) params.set("exchange", exchange);
+    if (expirationDate != null) params.set("expirationDate", String(expirationDate));
+    return this.request<CloudMarketResponse<CloudOptionsChainPayload>>(`/market/options?${params.toString()}`);
+  }
+
   async getCloudProfile(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCompanyProfile>> {
     const params = new URLSearchParams({ symbol });
     if (exchange) params.set("exchange", exchange);

package/src/utils/exchanges.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from "bun:test";
+import { CANONICAL_EXCHANGE_ALIASES, EXCHANGE_TIME_ZONES } from "./exchanges";
+
+describe("exchange metadata", () => {
+  test("has a valid timezone for every canonical exchange", () => {
+    const canonicalExchanges = [...new Set(Object.values(CANONICAL_EXCHANGE_ALIASES))].sort();
+    const missing = canonicalExchanges.filter((exchange) => !EXCHANGE_TIME_ZONES[exchange]);
+
+    expect(missing).toEqual([]);
+    for (const exchange of canonicalExchanges) {
+      expect(() => new Intl.DateTimeFormat("en-US", {
+        timeZone: EXCHANGE_TIME_ZONES[exchange],
+      })).not.toThrow();
+    }
+  });
+});

package/src/utils/exchanges.ts

@@ -31,6 +31,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   TSX: "TSX",
   XTSE: "TSX",
   TSXV: "TSXV",
+  VAN: "TSXV",
   CN: "CSE",
   CNSX: "CSE",
   CSE: "CSE",
@@ -118,6 +119,7 @@ export const CANONICAL_EXCHANGE_ALIASES: Record<string, string> = {
   XJSE: "JSE",
   TLV: "TASE",
   XTAE: "TASE",
+  CCC: "CCC",
 };
 
 export const PUBLIC_EXCHANGE_ALIASES: Record<string, string> = {
@@ -128,6 +130,8 @@ export const PUBLIC_EXCHANGE_ALIASES: Record<string, string> = {
   HKEX: "XHKG",
   LSE: "XLON",
   TSX: "XTSE",
+  TSXV: "XTSX",
+  CSE: "XCNQ",
   ASX: "XASX",
   NZX: "XNZE",
   SWX: "XSWX",
@@ -172,6 +176,21 @@ export const EXCHANGE_TIME_ZONES: Record<string, string> = {
   SFB: "Europe/Stockholm",
   HKEX: "Asia/Hong_Kong",
   JPX: "Asia/Tokyo",
+  TSX: "America/Toronto",
+  TSXV: "America/Toronto",
+  CSE: "America/Toronto",
+  EPA: "Europe/Paris",
+  AMS: "Europe/Amsterdam",
+  BRU: "Europe/Brussels",
+  LIS: "Europe/Lisbon",
+  BIT: "Europe/Rome",
+  HEL: "Europe/Helsinki",
+  CPH: "Europe/Copenhagen",
+  OSL: "Europe/Oslo",
+  ICEX: "Atlantic/Reykjavik",
+  WSE: "Europe/Warsaw",
+  PSE: "Europe/Prague",
+  VIE: "Europe/Vienna",
   TPEX: "Asia/Taipei",
   TWSE: "Asia/Taipei",
   NSE: "Asia/Kolkata",
@@ -181,6 +200,15 @@ export const EXCHANGE_TIME_ZONES: Record<string, string> = {
   SGX: "Asia/Singapore",
   KRX: "Asia/Seoul",
   KOSDAQ: "Asia/Seoul",
+  NZX: "Pacific/Auckland",
+  SSE: "Asia/Shanghai",
+  SZSE: "Asia/Shanghai",
+  BMV: "America/Mexico_City",
+  B3: "America/Sao_Paulo",
+  BYMA: "America/Argentina/Buenos_Aires",
+  JSE: "Africa/Johannesburg",
+  TASE: "Asia/Jerusalem",
+  CCC: "UTC",
 };
 
 export function normalizeSymbol(value: string): string {
@@ -196,6 +224,11 @@ export function canonicalExchange(value?: string): string {
   return CANONICAL_EXCHANGE_ALIASES[normalized] ?? normalized;
 }
 
+export function resolveExchangeTimeZone(value?: string): string | null {
+  const canonical = canonicalExchange(value);
+  return canonical ? EXCHANGE_TIME_ZONES[canonical] ?? null : null;
+}
+
 export function publicExchange(value?: string): string {
   const canonical = canonicalExchange(value);
   return PUBLIC_EXCHANGE_ALIASES[canonical] ?? canonical;

package/src/utils/options.ts

@@ -23,7 +23,7 @@ export function parseOptionSymbol(symbol: string): { underlying: string; expTs:
   const year = 2000 + parseInt(yy!, 10);
   const month = parseInt(mm!, 10) - 1;
   const day = parseInt(dd!, 10);
-  const expTs = Math.floor(new Date(year, month, day).getTime() / 1000);
+  const expTs = Math.floor(Date.UTC(year, month, day) / 1000);
   return { underlying: underlying!, expTs, strike, side: side as "C" | "P" };
 }
 

package/src/utils/price-history.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { normalizePriceHistory } from "./price-history";
+import { isPriceHistoryStaleForCurrentWindow, normalizePriceHistory } from "./price-history";
 
 describe("normalizePriceHistory", () => {
   test("drops poisoned cached history when every timestamp collapses to the same value", () => {
@@ -22,4 +22,31 @@ describe("normalizePriceHistory", () => {
 
     expect(history.map((point) => point.close)).toEqual([101, 102, 103]);
   });
+
+  test("drops zero-price bars instead of treating missing upstream prices as real data", () => {
+    const history = normalizePriceHistory([
+      { date: new Date("2026-05-13T13:30:00Z"), close: 64 },
+      { date: new Date("2026-05-13T13:45:00Z"), close: 0 },
+      { date: new Date("2026-05-13T14:00:00Z"), close: Number.NaN },
+      { date: new Date("2026-05-13T14:15:00Z"), close: 65 },
+    ]);
+
+    expect(history.map((point) => point.close)).toEqual([64, 65]);
+  });
+
+  test("detects intraday history that is old even when the cache record is fresh", () => {
+    expect(
+      isPriceHistoryStaleForCurrentWindow(
+        [{ date: new Date("2026-04-17T20:00:00Z"), close: 67 }],
+        Date.parse("2026-05-13T23:00:00Z"),
+      ),
+    ).toBe(true);
+
+    expect(
+      isPriceHistoryStaleForCurrentWindow(
+        [{ date: new Date("2026-05-13T22:45:00Z"), close: 67 }],
+        Date.parse("2026-05-13T23:00:00Z"),
+      ),
+    ).toBe(false);
+  });
 });

package/src/utils/price-history.ts

@@ -1,5 +1,7 @@
 import type { PricePoint, TickerFinancials } from "../types/financials";
 
+const MAX_CURRENT_INTRADAY_HISTORY_LAG_MS = 18 * 60 * 60 * 1000;
+
 function getPointTimestamp(point: PricePoint): number {
   const value = point.date as Date | string | number | null | undefined;
   if (value instanceof Date) return value.getTime();
@@ -7,6 +9,10 @@ function getPointTimestamp(point: PricePoint): number {
   return new Date(value).getTime();
 }
 
+function hasValidClose(point: PricePoint): boolean {
+  return Number.isFinite(point.close) && point.close > 0;
+}
+
 function comparePricePointsByDate(left: PricePoint, right: PricePoint): number {
   const leftTime = getPointTimestamp(left);
   const rightTime = getPointTimestamp(right);
@@ -31,6 +37,7 @@ export function normalizePriceHistory(points: PricePoint[]): PricePoint[] {
   for (const point of points) {
     const time = getPointTimestamp(point);
     if (!Number.isFinite(time)) continue;
+    if (!hasValidClose(point)) continue;
 
     if (firstTimestamp === null) {
       firstTimestamp = time;
@@ -55,6 +62,15 @@ export function normalizePriceHistory(points: PricePoint[]): PricePoint[] {
   return validPoints.length === points.length ? points : validPoints;
 }
 
+export function isPriceHistoryStaleForCurrentWindow(points: PricePoint[], now = Date.now()): boolean {
+  const normalized = normalizePriceHistory(points);
+  const latest = normalized.at(-1);
+  if (!latest) return false;
+
+  const latestTime = getPointTimestamp(latest);
+  return Number.isFinite(latestTime) && now - latestTime > MAX_CURRENT_INTRADAY_HISTORY_LAG_MS;
+}
+
 export function normalizeTickerFinancialsPriceHistory(financials: TickerFinancials): TickerFinancials {
   const priceHistory = normalizePriceHistory(financials.priceHistory ?? []);
   return priceHistory === financials.priceHistory

package/src/utils/quote-freshness.test.ts

@@ -0,0 +1,150 @@
+import { describe, expect, test } from "bun:test";
+import type { Quote } from "../types/financials";
+import { isQuoteStaleForCurrentSession } from "./quote-freshness";
+
+function quote(overrides: Partial<Quote>): Quote {
+  return {
+    symbol: "2337",
+    price: 168,
+    currency: "TWD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.parse("2026-05-08T06:00:00Z"),
+    listingExchangeName: "TWSE",
+    exchangeName: "TWSE",
+    marketState: "CLOSED",
+    dataSource: "delayed",
+    ...overrides,
+  };
+}
+
+describe("quote freshness", () => {
+  test("treats multi-business-day-old non-US closed quotes as stale", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({}),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("treats stale Paris and Toronto quotes as refreshable", () => {
+    const now = Date.parse("2026-05-13T21:00:00Z");
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "ALRIB",
+          currency: "EUR",
+          lastUpdated: Date.parse("2026-05-08T15:30:00Z"),
+          listingExchangeName: "PAR",
+          exchangeName: "PAR",
+        }),
+        now,
+      ),
+    ).toBe(true);
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "HPS-A.TO",
+          currency: "CAD",
+          lastUpdated: Date.parse("2026-05-08T20:00:00Z"),
+          listingExchangeName: "TOR",
+          exchangeName: "TOR",
+        }),
+        now,
+      ),
+    ).toBe(true);
+  });
+
+  test("treats old crypto quotes as stale on the 24/7 venue", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "BTC-USD",
+          currency: "USD",
+          lastUpdated: Date.parse("2026-05-09T15:29:00Z"),
+          listingExchangeName: "CCC",
+          exchangeName: "CCC",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("allows the previous local business day before the market reopens", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "1211",
+          currency: "HKD",
+          lastUpdated: Date.parse("2026-05-13T08:00:00Z"),
+          listingExchangeName: "SEHK",
+          exchangeName: "SEHK",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("rejects previous-day weekday quotes that are older than a normal overnight close", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-12T21:00:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(true);
+
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-13T06:24:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-13T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("allows Friday closes before Monday reopen", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "285A.T",
+          currency: "JPY",
+          lastUpdated: Date.parse("2026-05-08T06:24:00Z"),
+          listingExchangeName: "JPX",
+          exchangeName: "JPX",
+        }),
+        Date.parse("2026-05-10T21:00:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("treats prior-date regular-session quotes as stale immediately", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "HY9H",
+          currency: "EUR",
+          lastUpdated: Date.parse("2026-04-07T19:55:00Z"),
+          listingExchangeName: "FWB2",
+          exchangeName: "FWB2",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-04-08T10:49:00Z"),
+      ),
+    ).toBe(true);
+  });
+});

package/src/utils/quote-freshness.ts

@@ -3,6 +3,8 @@ import { canonicalExchange, EXCHANGE_TIME_ZONES } from "./exchanges";
 
 const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
 const exchangeLocalDateFormatters = new Map<string, Intl.DateTimeFormat>();
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+const OVERNIGHT_CLOSE_MAX_AGE_MS = 20 * 60 * 60 * 1000;
 const usSessionFormatter = new Intl.DateTimeFormat("en-US", {
   timeZone: "America/New_York",
   weekday: "short",
@@ -43,6 +45,38 @@ function exchangeLocalDate(exchange: string, timestampMs: number): string | null
   return `${year}-${month}-${day}`;
 }
 
+function isoLocalDateToUtcDay(date: string): number | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+  if (!match) return null;
+
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(day)) return null;
+
+  return Math.floor(Date.UTC(year, month - 1, day) / MS_PER_DAY);
+}
+
+function localWeekdaysBetween(earlierDate: string, laterDate: string): number {
+  const earlierDay = isoLocalDateToUtcDay(earlierDate);
+  const laterDay = isoLocalDateToUtcDay(laterDate);
+  if (earlierDay == null || laterDay == null || laterDay <= earlierDay) return 0;
+
+  let weekdays = 0;
+  for (let day = earlierDay + 1; day <= laterDay; day += 1) {
+    const weekday = new Date(day * MS_PER_DAY).getUTCDay();
+    if (weekday !== 0 && weekday !== 6) {
+      weekdays += 1;
+    }
+  }
+  return weekdays;
+}
+
+function localWeekday(date: string): number | null {
+  const day = isoLocalDateToUtcDay(date);
+  return day == null ? null : new Date(day * MS_PER_DAY).getUTCDay();
+}
+
 function usSessionState(timestampMs: number): UsSessionState {
   const parts = usSessionFormatter.formatToParts(new Date(timestampMs));
 
@@ -85,9 +119,16 @@ export function isQuoteStaleForCurrentSession(quote: Quote | null | undefined, n
 
   if (isUsExtendedHoursExchange(exchange)) {
     const session = usSessionState(now);
-    return session === "PRE" || session === "REGULAR" || session === "POST";
+    if (session === "PRE" || session === "REGULAR" || session === "POST") {
+      return true;
+    }
   }
 
+  const weekdaysBehind = localWeekdaysBetween(quoteDate, currentDate);
+  if (weekdaysBehind > 1) return true;
+  if (weekdaysBehind === 1 && now - quote.lastUpdated > OVERNIGHT_CLOSE_MAX_AGE_MS) {
+    return localWeekday(currentDate) !== 1;
+  }
   return false;
 }
 

package/src/utils/quote-resolution.ts

@@ -30,6 +30,7 @@ const PRICE_FIELD_KEYS = [
   "low",
   "mark",
   "lastUpdated",
+  "receivedAt",
 ] as const;
 
 const SESSION_FIELD_KEYS = [
@@ -516,6 +517,7 @@ export function resolveCanonicalQuote(
     volume: resolved.volume as Quote["volume"],
     name: resolved.name as Quote["name"],
     lastUpdated: Number(resolved.lastUpdated ?? priceProvider?.lastUpdated ?? sessionProvider?.lastUpdated ?? now),
+    receivedAt: resolved.receivedAt as Quote["receivedAt"],
     exchangeName: resolved.exchangeName as Quote["exchangeName"],
     fullExchangeName: resolved.fullExchangeName as Quote["fullExchangeName"],
     listingExchangeName: resolved.listingExchangeName as Quote["listingExchangeName"],

package/src/utils/quote-time.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import { formatQuoteAge, formatQuoteAgeWithSource, getMostRecentQuoteUpdate } from "./quote-time";
+
+describe("quote-time", () => {
+  test("formats sub-second quote age in milliseconds", () => {
+    const now = 1_700_000_030_000;
+
+    expect(formatQuoteAge(now - 999, now)).toBe("999ms");
+    expect(formatQuoteAge(now, now)).toBe("0ms");
+    expect(formatQuoteAgeWithSource({
+      lastUpdated: now - 100,
+      dataSource: "delayed",
+    }, now)).toBe("◷100ms");
+  });
+
+  test("uses stream receipt time for displayed quote age when available", () => {
+    const now = 1_700_000_030_000;
+    const quote = {
+      lastUpdated: 1_700_000_000_000,
+      receivedAt: 1_700_000_029_000,
+    };
+
+    expect(formatQuoteAgeWithSource(quote, now)).toBe("1s");
+    expect(getMostRecentQuoteUpdate([quote], now)).toBe(1_700_000_029_000);
+  });
+
+  test("keeps delayed source marker while using receipt time for age", () => {
+    expect(formatQuoteAgeWithSource({
+      lastUpdated: 1_700_000_000_000,
+      receivedAt: 1_700_000_029_000,
+      dataSource: "delayed",
+    }, 1_700_000_030_000)).toBe("◷1s");
+  });
+});