gloomberb 0.7.4 → 0.8.0

package/src/utils/market-format.test.ts

@@ -1,109 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  formatMarketCost,
-  formatMarketCostWithCurrency,
-  formatCompactMarketPriceWithCurrency,
-  formatMarketPrice,
-  formatMarketPriceWithCurrency,
-  formatMarketQuantity,
-  formatSignedMarketPrice,
-  resolveAssetDisplayKind,
-} from "./market-format";
-
-describe("resolveAssetDisplayKind", () => {
-  test("prefers explicit cash balances", () => {
-    expect(resolveAssetDisplayKind({ isCashBalance: true, assetCategory: "STK" })).toBe("cash");
-  });
-
-  test("maps common broker security types", () => {
-    expect(resolveAssetDisplayKind({ assetCategory: "CRYPTO" })).toBe("crypto");
-    expect(resolveAssetDisplayKind({ assetCategory: "STK" })).toBe("equity");
-    expect(resolveAssetDisplayKind({ contractSecType: "OPT" })).toBe("contract");
-    expect(resolveAssetDisplayKind({ assetCategory: "FOREX" })).toBe("cash");
-    expect(resolveAssetDisplayKind({ assetCategory: "CURRENCY" })).toBe("cash");
-    expect(resolveAssetDisplayKind({ assetCategory: "CCY" })).toBe("cash");
-  });
-
-  test("falls back to contract formatting when only a multiplier is present", () => {
-    expect(resolveAssetDisplayKind({ multiplier: 100 })).toBe("contract");
-  });
-});
-
-describe("formatMarketQuantity", () => {
-  test("preserves additional FX precision while trimming trailing zeroes", () => {
-    expect(formatMarketQuantity(-351957.025, { isCashBalance: true })).toBe("-351,957.025");
-    expect(formatMarketQuantity(-303029.144938754, { isCashBalance: true })).toBe("-303,029.144939");
-  });
-
-  test("shows whole equities without decimals and fractional equities with up to four decimals", () => {
-    expect(formatMarketQuantity(10, { assetCategory: "STK" })).toBe("10");
-    expect(formatMarketQuantity(10.125, { assetCategory: "STK" })).toBe("10.125");
-    expect(formatMarketQuantity(10.123456, { assetCategory: "STK" })).toBe("10.1235");
-  });
-
-  test("uses higher precision for crypto quantities", () => {
-    expect(formatMarketQuantity(0.123456789, { assetCategory: "CRYPTO" })).toBe("0.12345679");
-  });
-});
-
-describe("formatMarketPrice", () => {
-  test("uses semantic precision for equities, cash, and crypto", () => {
-    expect(formatMarketPrice(190.2, { assetCategory: "STK" })).toBe("190.2");
-    expect(formatMarketPrice(259.7499, { assetCategory: "STK" })).toBe("259.75");
-    expect(formatMarketPrice(1.084567, { isCashBalance: true })).toBe("1.084567");
-    expect(formatMarketPrice(1.17364, { assetCategory: "CURRENCY" })).toBe("1.17364");
-    expect(formatMarketPrice(0.000123456789, { assetCategory: "CRYPTO" })).toBe("0.00012346");
-  });
-
-  test("can adapt chart precision to the visible price range", () => {
-    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.12 })).toBe("1.17");
-    expect(formatMarketPrice(1.167815, { assetCategory: "CURRENCY", priceRange: 0.0024 })).toBe("1.1678");
-    expect(formatMarketPrice(259.7499, {
-      assetCategory: "STK",
-      minimumFractionDigits: 2,
-      precisionOffset: 1,
-      priceRange: 80,
-    })).toBe("259.75");
-  });
-
-  test("can lock price displays to a specific number of decimals", () => {
-    expect(formatMarketPrice(18, { assetCategory: "STK", fixedFractionDigits: 1 })).toBe("18.0");
-    expect(formatMarketPriceWithCurrency(18, "USD", { assetCategory: "STK", fixedFractionDigits: 2 })).toBe("$18.00");
-  });
-
-  test("fits within the supplied width before falling back to truncation elsewhere", () => {
-    expect(formatMarketPrice(1.084567, { isCashBalance: true, maxWidth: 6 })).toBe("1.0846");
-    expect(formatMarketQuantity(123456.789, { assetCategory: "CRYPTO", maxWidth: 7 })).toBe("123,457");
-  });
-
-  test("formats signed price changes without double signs", () => {
-    expect(formatSignedMarketPrice(0.123456, { isCashBalance: true })).toBe("+0.123456");
-    expect(formatSignedMarketPrice(-0.123456, { isCashBalance: true })).toBe("-0.123456");
-  });
-});
-
-describe("formatMarketCost", () => {
-  test("keeps equity cost displays conservative while preserving FX and crypto precision", () => {
-    expect(formatMarketCost(119.3687, { assetCategory: "STK" })).toBe("119.37");
-    expect(formatMarketCost(1.084567, { isCashBalance: true })).toBe("1.084567");
-    expect(formatMarketCost(113905.720075, { assetCategory: "CRYPTO" })).toBe("113,905.720075");
-  });
-});
-
-describe("formatMarketPriceWithCurrency", () => {
-  test("renders price-like values with a symbol and variable decimals", () => {
-    expect(formatMarketPriceWithCurrency(190.25, "USD", { assetCategory: "STK" })).toBe("$190.25");
-    expect(formatMarketPriceWithCurrency(1.084567, "EUR", { isCashBalance: true })).toBe("€1.084567");
-    expect(formatMarketPriceWithCurrency(1.17364, "USD", { assetCategory: "CURRENCY" })).toBe("$1.17364");
-  });
-
-  test("preserves chart-style compact notation for large values", () => {
-    expect(formatCompactMarketPriceWithCurrency(21_970, "JPY")).toBe("¥22.0K");
-    expect(formatCompactMarketPriceWithCurrency(12_340, "HKD")).toBe("HK$12.3K");
-  });
-
-  test("formats position cost values with tighter equity precision", () => {
-    expect(formatMarketCostWithCurrency(119.3687, "HKD", { assetCategory: "STK" })).toBe("HK$119.37");
-    expect(formatMarketCostWithCurrency(50.9507, "USD", { assetCategory: "OPT", multiplier: 100 })).toBe("$50.9507");
-  });
-});

package/src/utils/market-format.ts

@@ -1,299 +0,0 @@
-import { formatCurrency } from "./format";
-
-export type AssetDisplayKind = "cash" | "crypto" | "equity" | "contract" | "other";
-
-export interface AssetDisplayContext {
-  isCashBalance?: boolean;
-  assetCategory?: string;
-  contractSecType?: string;
-  multiplier?: number;
-}
-
-export interface MarketFormatOptions extends AssetDisplayContext {
-  maxWidth?: number;
-  minimumFractionDigits?: number;
-  precisionOffset?: number;
-  priceRange?: number;
-  fixedFractionDigits?: number;
-}
-
-const CASH_TYPES = new Set(["CASH", "FX", "FOREX", "CCY", "CURRENCY", "CURRENCYPAIR"]);
-const CRYPTO_TYPES = new Set(["CRYPTO", "CRYPTOCURRENCY", "COIN", "TOKEN"]);
-const EQUITY_TYPES = new Set(["STK", "STOCK", "EQUITY", "ETF", "ETN", "ETP", "FUND", "MUTUALFUND", "CEF", "ADR"]);
-const CONTRACT_TYPES = new Set(["OPT", "OPTION", "OPTIONS", "FUT", "FUTURE", "FUTURES", "FOP"]);
-
-const currencySymbols = new Map<string, string>();
-const numberFormatters = new Map<string, Intl.NumberFormat>();
-
-function normalizeType(value?: string): string {
-  return (value ?? "").trim().toUpperCase().replace(/[\s_-]+/g, "");
-}
-
-function getNumberFormatter(
-  minimumFractionDigits: number,
-  maximumFractionDigits: number,
-  useGrouping: boolean,
-): Intl.NumberFormat {
-  const key = `${minimumFractionDigits}:${maximumFractionDigits}:${useGrouping ? 1 : 0}`;
-  let formatter = numberFormatters.get(key);
-  if (!formatter) {
-    formatter = new Intl.NumberFormat("en-US", {
-      minimumFractionDigits,
-      maximumFractionDigits,
-      useGrouping,
-    });
-    numberFormatters.set(key, formatter);
-  }
-  return formatter;
-}
-
-function getCurrencySymbol(currency: string): string {
-  const normalizedCurrency = currency.trim().toUpperCase() || "USD";
-  const cached = currencySymbols.get(normalizedCurrency);
-  if (cached) return cached;
-
-  const formatter = new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: normalizedCurrency,
-    currencyDisplay: "symbol",
-    minimumFractionDigits: 0,
-    maximumFractionDigits: 0,
-  });
-  const symbol = formatter.formatToParts(0).find((part) => part.type === "currency")?.value ?? normalizedCurrency;
-  currencySymbols.set(normalizedCurrency, symbol);
-  return symbol;
-}
-
-function fitsWidth(text: string, maxWidth: number | undefined): boolean {
-  return maxWidth == null || text.length <= maxWidth;
-}
-
-function isEffectivelyInteger(value: number): boolean {
-  return Math.abs(value - Math.round(value)) < 1e-9;
-}
-
-function formatVariableNumber(
-  value: number,
-  maxFractionDigits: number,
-  maxWidth: number | undefined,
-  minimumFractionDigits = 0,
-): string {
-  const groupedModes = [true, false];
-
-  for (const useGrouping of groupedModes) {
-    for (let decimals = maxFractionDigits; decimals >= minimumFractionDigits; decimals -= 1) {
-      const formatter = getNumberFormatter(Math.min(minimumFractionDigits, decimals), decimals, useGrouping);
-      const formatted = formatter.format(value);
-      if (fitsWidth(formatted, maxWidth)) return formatted;
-    }
-  }
-
-  return getNumberFormatter(0, 0, false).format(value);
-}
-
-function getQuantityMaxFractionDigits(kind: AssetDisplayKind, value: number): number {
-  if (isEffectivelyInteger(value)) return 0;
-
-  switch (kind) {
-    case "cash":
-      return 6;
-    case "crypto":
-      return 8;
-    case "equity":
-      return 4;
-    case "contract":
-      return 4;
-    case "other":
-    default:
-      return 4;
-  }
-}
-
-function getBasePriceMaxFractionDigits(kind: AssetDisplayKind, value: number): number {
-  switch (kind) {
-    case "cash":
-      return 6;
-    case "crypto":
-      return 8;
-    case "equity":
-      return Math.abs(value) >= 1 ? 2 : 4;
-    case "contract":
-      return 4;
-    case "other":
-    default:
-      return Math.abs(value) >= 1 ? 2 : 4;
-  }
-}
-
-function getAdaptivePriceFractionDigits(priceRange: number | undefined, precisionOffset = 0): number | null {
-  if (priceRange === undefined || !Number.isFinite(priceRange) || priceRange <= 0) return null;
-
-  // The chart price axis renders four labels by default, so the visible range
-  // divided across three intervals is a good proxy for the current zoom step.
-  const visibleStep = priceRange / 3;
-  if (!Number.isFinite(visibleStep) || visibleStep <= 0) return null;
-
-  return Math.max(0, Math.ceil(-Math.log10(visibleStep)) + precisionOffset);
-}
-
-function getPriceMaxFractionDigits(
-  kind: AssetDisplayKind,
-  value: number,
-  priceRange: number | undefined,
-  precisionOffset: number,
-): number {
-  const baseMaxFractionDigits = kind === "other" && priceRange !== undefined
-    ? 6
-    : getBasePriceMaxFractionDigits(kind, value);
-  const adaptiveFractionDigits = getAdaptivePriceFractionDigits(priceRange, precisionOffset);
-  return adaptiveFractionDigits === null
-    ? baseMaxFractionDigits
-    : Math.min(baseMaxFractionDigits, adaptiveFractionDigits);
-}
-
-function getCostMaxFractionDigits(kind: AssetDisplayKind): number {
-  switch (kind) {
-    case "cash":
-      return 6;
-    case "crypto":
-      return 8;
-    case "contract":
-      return 4;
-    case "equity":
-      return 2;
-    case "other":
-    default:
-      return 2;
-  }
-}
-
-function compactScaledPrice(
-  value: number,
-  divisor: number,
-  suffix: string,
-  currency: string,
-  maxWidth: number | undefined,
-): string {
-  const sign = value < 0 ? "-" : "";
-  const symbol = getCurrencySymbol(currency);
-  const numericWidth = maxWidth == null
-    ? undefined
-    : Math.max(1, maxWidth - sign.length - symbol.length - suffix.length);
-  const formatted = formatVariableNumber(Math.abs(value) / divisor, 1, numericWidth, 1);
-  return `${sign}${symbol}${formatted}${suffix}`;
-}
-
-export function resolveAssetDisplayKind({
-  isCashBalance,
-  assetCategory,
-  contractSecType,
-  multiplier,
-}: AssetDisplayContext): AssetDisplayKind {
-  if (isCashBalance) return "cash";
-
-  const normalizedType = normalizeType(contractSecType || assetCategory);
-  if (CASH_TYPES.has(normalizedType) || normalizedType.includes("FOREX") || normalizedType.includes("CURRENCY")) return "cash";
-  if (CRYPTO_TYPES.has(normalizedType) || normalizedType.includes("CRYPTO")) return "crypto";
-  if (EQUITY_TYPES.has(normalizedType)) return "equity";
-  if (CONTRACT_TYPES.has(normalizedType)) return "contract";
-  if ((multiplier ?? 1) > 1) return "contract";
-  return "other";
-}
-
-export function formatMarketQuantity(value: number | undefined, options: MarketFormatOptions = {}): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  const kind = resolveAssetDisplayKind(options);
-  const maxFractionDigits = getQuantityMaxFractionDigits(kind, value);
-  return formatVariableNumber(value, maxFractionDigits, options.maxWidth);
-}
-
-export function formatMarketPrice(value: number | undefined, options: MarketFormatOptions = {}): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  const kind = resolveAssetDisplayKind(options);
-  const fixedFractionDigits = options.fixedFractionDigits;
-  if (fixedFractionDigits !== undefined) {
-    const maxFractionDigits = kind === "other" && options.priceRange !== undefined
-      ? 6
-      : getBasePriceMaxFractionDigits(kind, value);
-    const clampedFixedFractionDigits = Math.max(0, Math.min(fixedFractionDigits, maxFractionDigits));
-    return formatVariableNumber(value, clampedFixedFractionDigits, options.maxWidth, clampedFixedFractionDigits);
-  }
-  const minimumFractionDigits = Math.max(
-    0,
-    Math.min(options.minimumFractionDigits ?? 0, getBasePriceMaxFractionDigits(kind, value)),
-  );
-  const maxFractionDigits = Math.max(
-    getPriceMaxFractionDigits(kind, value, options.priceRange, options.precisionOffset ?? 0),
-    minimumFractionDigits,
-  );
-  return formatVariableNumber(value, maxFractionDigits, options.maxWidth, minimumFractionDigits);
-}
-
-export function formatMarketCost(value: number | undefined, options: MarketFormatOptions = {}): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  const kind = resolveAssetDisplayKind(options);
-  return formatVariableNumber(value, getCostMaxFractionDigits(kind), options.maxWidth);
-}
-
-export function formatSignedMarketPrice(value: number | undefined, options: MarketFormatOptions = {}): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  if (value > 0) {
-    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 1);
-    return `+${formatMarketPrice(value, { ...options, maxWidth })}`;
-  }
-  return formatMarketPrice(value, options);
-}
-
-export function formatMarketPriceWithCurrency(
-  value: number | undefined,
-  currency = "USD",
-  options: MarketFormatOptions = {},
-): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  const normalizedCurrency = currency.trim().toUpperCase() || "USD";
-  const sign = value < 0 ? "-" : "";
-  const symbol = getCurrencySymbol(normalizedCurrency);
-  const numericWidth = options.maxWidth == null
-    ? undefined
-    : Math.max(1, options.maxWidth - sign.length - symbol.length);
-  const body = formatMarketPrice(Math.abs(value), { ...options, maxWidth: numericWidth });
-  return `${sign}${symbol}${body}`;
-}
-
-export function formatMarketCostWithCurrency(
-  value: number | undefined,
-  currency = "USD",
-  options: MarketFormatOptions = {},
-): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  const normalizedCurrency = currency.trim().toUpperCase() || "USD";
-  const sign = value < 0 ? "-" : "";
-  const symbol = getCurrencySymbol(normalizedCurrency);
-  const numericWidth = options.maxWidth == null
-    ? undefined
-    : Math.max(1, options.maxWidth - sign.length - symbol.length);
-  const body = formatMarketCost(Math.abs(value), { ...options, maxWidth: numericWidth });
-  return `${sign}${symbol}${body}`;
-}
-
-export function formatCompactMarketPriceWithCurrency(
-  value: number | undefined,
-  currency = "USD",
-  options: MarketFormatOptions = {},
-): string {
-  if (value === undefined || value === null || Number.isNaN(value)) return "—";
-  const abs = Math.abs(value);
-
-  if (abs >= 1e6) {
-    return compactScaledPrice(value, 1e6, "M", currency, options.maxWidth);
-  }
-  if (abs >= 1e3 && abs < 1e5) {
-    return compactScaledPrice(value, 1e3, "K", currency, options.maxWidth);
-  }
-
-  return formatMarketPriceWithCurrency(value, currency, options);
-}
-
-export function formatMarketMoney(value: number | undefined, currency = "USD"): string {
-  return formatCurrency(value, currency);
-}

package/src/utils/market-status.ts

@@ -1,141 +0,0 @@
-import type { MarketState, Quote, QuoteFieldProvenance } from "../types/financials";
-import { colors, priceColor } from "../theme/colors";
-import { formatPercentRaw } from "./format";
-import { formatMarketPrice } from "./market-format";
-
-export interface ActiveQuoteDisplay {
-  price: number;
-  change: number;
-  changePercent: number;
-}
-
-export function marketStateLabel(state: MarketState): string {
-  switch (state) {
-    case "PRE": return "PRE-MKT";
-    case "REGULAR": return "OPEN";
-    case "POST": return "AFTER-HRS";
-    case "PREPRE":
-    case "POSTPOST":
-    case "CLOSED": return "CLOSED";
-  }
-}
-
-export function marketStateColor(state: MarketState): string {
-  switch (state) {
-    case "REGULAR": return colors.positive;
-    case "PRE":
-    case "POST": return colors.textBright;
-    case "PREPRE":
-    case "POSTPOST":
-    case "CLOSED": return colors.textDim;
-  }
-}
-
-export function marketStateDot(state?: MarketState): string {
-  switch (state) {
-    case "REGULAR":
-      return "\u25CF";
-    case "PRE":
-    case "POST":
-      return "\u25D0";
-    case "CLOSED":
-    case "PREPRE":
-    case "POSTPOST":
-      return "\u25CB";
-    default:
-      return "\u25CC";
-  }
-}
-
-/** Short exchange display name */
-export function exchangeShortName(exchangeName?: string, fullExchangeName?: string): string {
-  if (!exchangeName && !fullExchangeName) return "";
-  const name = exchangeName || fullExchangeName || "";
-  // Common Yahoo Finance exchange abbreviations
-  const map: Record<string, string> = {
-    NMS: "NASDAQ", NGM: "NASDAQ", NCM: "NASDAQ", NAS: "NASDAQ",
-    NYQ: "NYSE", NYS: "NYSE",
-    PCX: "AMEX", ASE: "AMEX",
-    HKG: "HKEX",
-    TYO: "TYO",
-    LSE: "LSE",
-    ASX: "ASX",
-    SGX: "SGX",
-    KSC: "KRX", KOE: "KOSDAQ",
-    TAI: "TWSE",
-    SHH: "SSE", SHZ: "SZSE",
-    PAR: "EURONEXT", AMS: "EURONEXT", BRU: "EURONEXT",
-    GER: "XETRA",
-    OSL: "OSE",
-    BOM: "BSE", NSI: "NSE",
-    SAO: "B3",
-    JPX: "TYO",
-  };
-  return map[name] || name;
-}
-
-export function quoteProviderLabel(providerId?: string): string {
-  switch (providerId) {
-    case "ibkr":
-      return "Broker";
-    case "gloomberb-cloud":
-      return "Cloud";
-    case "yahoo":
-      return "Yahoo";
-    default:
-      return providerId || "Unknown";
-  }
-}
-
-export function quoteSourceLabel(
-  provenance?: QuoteFieldProvenance,
-  kind: "price" | "session" = "price",
-): string {
-  if (!provenance?.providerId) return "Unknown";
-  if (provenance.providerId === "ibkr") {
-    if (kind === "session") return "Broker";
-    if (provenance.dataSource === "live") return "IBKR live";
-    if (provenance.dataSource === "delayed") return "IBKR delayed";
-    return "IBKR";
-  }
-  if (provenance.providerId === "gloomberb-cloud") return "Cloud";
-  if (provenance.providerId === "yahoo") return "Yahoo";
-  return provenance.providerId;
-}
-
-/** Get extended hours price info (pre-market or after-hours) for display */
-export function getExtendedHoursInfo(quote: Quote | null | undefined): { text: string; color: string } | null {
-  if (!quote) return null;
-  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
-    const chg = quote.preMarketChangePercent ?? 0;
-    return { text: `Pre ${formatMarketPrice(quote.preMarketPrice)} ${formatPercentRaw(chg)}`, color: priceColor(chg) };
-  }
-  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
-    const chg = quote.postMarketChangePercent ?? 0;
-    return { text: `AH ${formatMarketPrice(quote.postMarketPrice)} ${formatPercentRaw(chg)}`, color: priceColor(chg) };
-  }
-  return null;
-}
-
-export function getActiveQuoteDisplay(quote: Quote | null | undefined): ActiveQuoteDisplay | null {
-  if (!quote) return null;
-  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
-    return {
-      price: quote.preMarketPrice,
-      change: quote.preMarketChange ?? 0,
-      changePercent: quote.preMarketChangePercent ?? 0,
-    };
-  }
-  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
-    return {
-      price: quote.postMarketPrice,
-      change: quote.postMarketChange ?? 0,
-      changePercent: quote.postMarketChangePercent ?? 0,
-    };
-  }
-  return {
-    price: quote.price,
-    change: quote.change,
-    changePercent: quote.changePercent,
-  };
-}

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

@@ -1,150 +0,0 @@
-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);
-  });
-});