gloomberb 0.18.0 → 0.18.2

package/src/market-data/futures-contract.ts

@@ -6,6 +6,8 @@ import { parsePublicTickerKey } from "../utils/exchanges";
 import { logFailure } from "../utils/log-failure";
 import { futuresBoardContract, type FuturesContract } from "./futures-board";
 import { formatMarketPrice, formatMarketPriceWithCurrency, quoteFormatOptions, withCurrencyMinorDigits } from "./market/format";
+import { minorUnitSign } from "../utils/currency-units";
+import { contractPriceUnit } from "../time-series/price-units";
 
 /**
  * What a futures symbol trades, as `ticker`, `quote` and the Overview tab read
@@ -120,6 +122,95 @@ export function futuresSettleText(
 
 const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 
+/** The quantities a cents price is per, as traders abbreviate them: 467.25¢/bu for corn. */
+const PER_ABBREVIATIONS: Readonly<Record<string, string>> = { bushel: "bu", bushels: "bu", pound: "lb", pounds: "lb" };
+
+/**
+ * What a price in a minor unit is per, to follow its sign: "/lb" for coffee at
+ * 314.95¢/lb, "/bu" for corn, from the contract's unit ("US cents / lb").
+ * Empty for a price in a major currency, which reads as it always has, and
+ * when the terms name no unit in the quote's own currency.
+ */
+export function minorUnitPricePer(
+  terms: Pick<FuturesContractTermsPayload, "spec"> | null | undefined,
+  currency: string | null | undefined,
+): string {
+  if (!minorUnitSign(currency)) return "";
+  const per = contractPriceUnit(terms?.spec?.unit, currency)?.split("/")[1]?.trim();
+  return per ? `/${PER_ABBREVIATIONS[per.toLowerCase()] ?? per}` : "";
+}
+
+const DAY_MS = 86_400_000;
+const isoDate = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * The weekday on or before a date (`back` 0) or before it (`back` 1), Saturday
+ * and Sunday skipped. Futures venues' holidays are not in the app's calendars,
+ * so a holiday reads as a session.
+ */
+function weekdayBefore(date: string, back: 0 | 1): string {
+  let at = Date.parse(`${date}T00:00:00Z`) - back * DAY_MS;
+  while (new Date(at).getUTCDay() % 6 === 0) at -= DAY_MS;
+  return new Date(at).toISOString().slice(0, 10);
+}
+
+/**
+ * How far apart two prices can be and still be the same settlement: half the
+ * contract's tick, so a move the source rounded still meets the settlement it
+ * was measured from, and a price a tick away does not. Without a tick, half a
+ * basis point of the price.
+ */
+function settlementTolerance(tick: number | null | undefined, price: number): number {
+  const half = typeof tick === "number" && Number.isFinite(tick) && tick > 0 ? tick / 2 : Math.abs(price) * 5e-5;
+  // Floating point never splits a price exactly half a tick away from the settlement.
+  return half * (1 + 1e-9);
+}
+
+/**
+ * What a futures move is measured from: a session's settlement, the last
+ * trade of a session that settled elsewhere, or a session's close that the
+ * settlement in the contract terms cannot confirm either way. `session` is
+ * the date of that reference.
+ */
+export interface FuturesChangeBasis {
+  kind: "settle" | "last trade" | "close";
+  session: string;
+}
+
+/**
+ * What the move a futures quote headlines is measured from, for the words
+ * after it ("vs Fri 16 Oct settle", quoteChangeBasis). `sessionDate` is the session the move belongs
+ * to (regularSessionDisplayDate); a Saturday or Sunday is Friday's, as no
+ * session is dated on one. The basis is only what the numbers show, against
+ * the one settlement the contract terms carry: a reference (the price less
+ * the move) within half a tick of it is that settlement, of whichever session
+ * it is. A reference that is not the settlement of the session just before
+ * the move's is that session's last trade. Otherwise, when the terms carry no
+ * settlement that old or one the reference can be checked against (the move's
+ * own session has settled, and the one before is not in the terms), it is the
+ * session before's close, left unnamed. Null without a session date, a move
+ * or terms.
+ */
+export function futuresChangeBasis(
+  terms: Pick<FuturesContractTermsPayload, "settlement"> & { spec?: Pick<FuturesContractSpec, "tick"> | null } | null | undefined,
+  move: { price: number; change?: number | null; sessionDate?: string | null } | null | undefined,
+): FuturesChangeBasis | null {
+  const dated = move?.sessionDate;
+  if (!terms || !move || !dated || !isoDate.test(dated) || move.change == null) return null;
+  const reference = move.price - move.change;
+  if (!Number.isFinite(reference)) return null;
+  const session = weekdayBefore(dated, 0);
+  const previous = weekdayBefore(session, 1);
+  const settled = terms.settlement;
+  if (settled && settled.date <= session) {
+    if (Math.abs(reference - settled.price) <= settlementTolerance(terms.spec?.tick, settled.price)) {
+      return { kind: "settle", session: settled.date };
+    }
+    if (settled.date < session && settled.date >= previous) return { kind: "last trade", session: settled.date };
+  }
+  return { kind: "close", session: previous };
+}
+
 /** A listed contract as code and month: "NGX26 (Nov 26)". */
 function contractWithMonth(contract: { contract: string; deliveryMonth: string }): string {
   const [year, month] = contract.deliveryMonth.split("-");

package/src/market-data/fx-closes.ts

@@ -1,5 +1,7 @@
+import type { CloudHistoryParams } from "../api-client/paths";
 import type { CloudMarketResponse, CloudPricePointPayload } from "../api-client/types";
-import type { FxLeg } from "./coordinator/fx-legs";
+import { isCurrencyCode } from "../utils/currency-pair";
+import { fxLegForCurrency, type FxLeg } from "./coordinator/fx-legs";
 
 /** USD per unit of one currency at each completed daily FX close, by date. */
 export interface FxCloses {
@@ -70,3 +72,78 @@ export function fxCloseOnOrBefore(fx: FxCloses, date: string): { date: string; r
   }
   return null;
 }
+
+/** Reads a pair's daily bars: `apiClient` in the app, a fake in tests. */
+export interface FxHistoryClient {
+  getCloudHistory(symbol: string, exchange: string, params: CloudHistoryParams): Promise<CloudMarketResponse<CloudPricePointPayload[]>>;
+}
+
+/** One unit of a currency in USD at a dated daily close. */
+export interface FxCloseReading {
+  /** USD per unit. */
+  rate: number;
+  /** The UTC day of the close: the day asked for, or the last trading day before it. */
+  date: string;
+}
+
+/**
+ * The daily pair a currency's USD value is read from: the leg the app streams
+ * it on, or USD/XXX for any other ISO currency, which the service also keeps
+ * daily closes of. Null for a code that is no currency.
+ */
+export function dailyFxLeg(currency: string): FxLeg | null {
+  const code = currency.trim().toUpperCase();
+  const leg = fxLegForCurrency(code);
+  if (leg) return leg;
+  return isCurrencyCode(code) ? { currency: code, instrument: { symbol: `${code}=X`, exchange: "" }, invert: true } : null;
+}
+
+const isoDay = (time: number) => new Date(time).toISOString().slice(0, 10);
+
+/**
+ * USD per unit of the leg's currency at its last completed daily close on or
+ * before `date` (YYYY-MM-DD), looking back a week at most, so a weekend or a
+ * holiday finds the close before it but a gap in the data is not bridged.
+ * Today's bar, still trading, is never read. Null when the pair has no close
+ * in that week. A cost bought on a date and `fx --date` both read it.
+ */
+export async function fxCloseOnDate(leg: FxLeg, date: string, client: FxHistoryClient, now = new Date()): Promise<FxCloseReading | null> {
+  const day = Date.parse(`${date}T00:00:00Z`);
+  const response = await client.getCloudHistory(leg.instrument.symbol, leg.instrument.exchange ?? "", {
+    interval: "1day", startDate: isoDay(day - FX_MAX_AGE_DAYS * DAY_MS), endDate: isoDay(day + DAY_MS), outputsize: FX_MAX_AGE_DAYS + 4,
+  });
+  if (response.status !== "success" && response.status !== "partial") return null;
+  const today = isoDay(now.getTime());
+  let best: FxCloseReading | null = null;
+  for (const row of Array.isArray(response.data) ? response.data : []) {
+    const at = typeof row?.date === "string" ? Date.parse(row.date) : Number.NaN;
+    if (!Number.isFinite(at) || !Number.isFinite(row.close) || row.close <= 0) continue;
+    const rowDay = isoDay(at);
+    if (rowDay > date || rowDay >= today || Date.parse(`${rowDay}T00:00:00Z`) < day - FX_MAX_AGE_DAYS * DAY_MS) continue;
+    if (!best || rowDay > best.date) best = { rate: leg.invert ? 1 / row.close : row.close, date: rowDay };
+  }
+  return best;
+}
+
+/**
+ * The completed daily closes of a currency's USD pair (`dailyFxLeg`) from a
+ * week before `since` (YYYY-MM-DD) to today, read by `dailyFxCloses`, so the
+ * first day finds the close before it. Throws `FxHistoryError` when the pair
+ * has no usable history, and a plain error for a code that is no currency.
+ */
+export async function loadDailyFxCloses(
+  currency: string,
+  since: string,
+  client: FxHistoryClient,
+  now = new Date(),
+): Promise<FxCloses> {
+  const leg = dailyFxLeg(currency);
+  if (!leg) throw new Error(`${currency} is not a currency with daily FX closes`);
+  const start = Math.min(Date.parse(`${since}T00:00:00Z`), now.getTime()) - FX_MAX_AGE_DAYS * DAY_MS;
+  // A trading week has five closes; seven a week leaves room for a source that also dates weekends.
+  const rows = Math.ceil((now.getTime() - start) / DAY_MS) + 4;
+  const response = await client.getCloudHistory(leg.instrument.symbol, leg.instrument.exchange ?? "", {
+    interval: "1day", startDate: isoDay(start), endDate: isoDay(now.getTime()), outputsize: rows,
+  });
+  return dailyFxCloses(response, leg, now, Math.max(rows, 1500));
+}

package/src/market-data/market/change-basis.ts

@@ -0,0 +1,219 @@
+import { classifyInstrumentType, kindFromListingSyntax } from "../../tickers/instrument-kind";
+import { isPerpetualExchange } from "../../tickers/perpetual-listing";
+import type { Quote } from "../../types/financials";
+import { canonicalExchange } from "../../utils/exchanges";
+import { isFiniteNumber } from "../../utils/guards";
+import { formatUtcDayTime } from "../../utils/utc-time";
+import { zonedDateKey } from "../../utils/zoned-date-time";
+import { futuresChangeBasis, isFuturesInstrument } from "../futures-contract";
+import { quoteTradingDay } from "../quotes/day-range";
+import { previousPublishedSession } from "./freshness";
+import { getActiveQuoteDisplay, getRegularSessionDisplay, regularSessionDisplayDate } from "./status";
+
+const DAY_MS = 86_400_000;
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * What a quote's day change is measured from, so every change line can say
+ * it: the close of a dated session (a future's settlement or last trade), a
+ * previous close the venue's calendar cannot date, a coin's previous UTC
+ * day (its price at 00:00 UTC) or the last 24 hours.
+ */
+export type QuoteChangeBasis =
+  | DatedChangeBasis
+  | { kind: "previous close" }
+  | { kind: "utc day" }
+  | { kind: "24h" };
+
+/** A move from a dated session's close, settlement or last trade. */
+interface DatedChangeBasis {
+  kind: "close" | "settle" | "last trade";
+  /** The exchange-local date of the session the move is measured from. */
+  date: string;
+  /** The venue, when its calendar dated the close. */
+  venue?: string;
+  /** Days of the venue's trading week it was closed between that session and the move's (holidays). */
+  closed?: readonly string[];
+}
+
+export interface QuoteChangeBasisOptions {
+  /**
+   * Which move: the regular session a headline shows (getRegularSessionDisplay,
+   * the default), or the latest print a position's day is valued at
+   * (getActiveQuoteDisplay), extended hours included.
+   */
+  session?: "regular" | "active";
+  /** A future's contract terms, whose settlement names what its move is from. */
+  terms?: Parameters<typeof futuresChangeBasis>[0];
+}
+
+const dayBefore = (date: string) => new Date(Date.parse(`${date}T00:00:00Z`) - DAY_MS).toISOString().slice(0, 10);
+
+/**
+ * The weekday before the one a move is dated to, Saturday and Sunday skipped:
+ * a currency pair's week. A move dated on a weekend is Friday's, from Thursday.
+ */
+function weekdayBefore(date: string): string {
+  let at = Date.parse(`${date}T00:00:00Z`);
+  while (new Date(at).getUTCDay() % 6 === 0) at -= DAY_MS;
+  at -= DAY_MS;
+  while (new Date(at).getUTCDay() % 6 === 0) at -= DAY_MS;
+  return new Date(at).toISOString().slice(0, 10);
+}
+
+function quoteVenue(quote: Quote): string {
+  return canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+}
+
+function isCurrencyPair(quote: Quote): boolean {
+  return classifyInstrumentType(quote.instrumentType) === "currency"
+    || kindFromListingSyntax(quote.symbol, quote.listingExchangeName || quote.exchangeName) === "currency";
+}
+
+/** A coin on the spot crypto venue: its day is the UTC day. */
+function isSpotCoin(quote: Quote): boolean {
+  return quoteVenue(quote) === "CCC";
+}
+
+/**
+ * The index session before the one a move is dated to, from the regular
+ * sessions an index quote carries (indexSession): the latest one on or before
+ * `date` is the move's (a quote read on a Saturday has Friday's), and the one
+ * before that is what it moves from.
+ */
+function previousIndexSession(quote: Quote, date: string): string | null {
+  const session = quote.indexSession;
+  if (!session?.timeZone) return null;
+  const windows = [...session.regular, ...(session.current ? [session.current] : [])];
+  const days = [...new Set(windows.map((window) => zonedDateKey(window.start, session.timeZone)))]
+    .filter((day) => day <= date)
+    .sort();
+  return days.length >= 2 ? days.at(-2)! : null;
+}
+
+/**
+ * The session before the one a move is dated to: from the venue's published
+ * calendar, with the closures in between; for an index from its own sessions;
+ * for a currency pair the weekday before. Null when nothing dates it.
+ */
+function previousSession(quote: Quote, sessionDate: string): DatedChangeBasis | null {
+  const venue = quoteVenue(quote);
+  const published = previousPublishedSession(venue, sessionDate);
+  if (published) return { kind: "close", date: published.date, venue, closed: published.closed };
+  const index = previousIndexSession(quote, sessionDate);
+  if (index) return { kind: "close", date: index };
+  if (isCurrencyPair(quote)) return { kind: "close", date: weekdayBefore(sessionDate) };
+  return null;
+}
+
+/**
+ * What the quote's move is measured from. A coin moves from its previous UTC
+ * day's close, the price at 00:00 UTC, unless Gloom Cloud says it moves over
+ * the last 24 hours; a perpetual always moves over 24 hours. A future's is the
+ * settlement or trade its terms name (futuresChangeBasis). Anything else is
+ * the close of the session before the move's, dated by the venue's calendar;
+ * a venue without one has a previous close that is left undated, never
+ * guessed. Null for a quote with no move: none reported, or a listing that no
+ * longer trades.
+ */
+export function quoteChangeBasis(
+  quote: Quote | null | undefined,
+  { session = "regular", terms = null }: QuoteChangeBasisOptions = {},
+): QuoteChangeBasis | null {
+  if (!quote || quote.delisting || quote.changeBasis === "none") return null;
+  const display = session === "active" ? getActiveQuoteDisplay(quote) : getRegularSessionDisplay(quote);
+  if (!display || !isFiniteNumber(display.change)) return null;
+  if (quote.changeBasis === "24h" || isPerpetualExchange(quote.listingExchangeName || quote.exchangeName)) return { kind: "24h" };
+  if (isSpotCoin(quote)) return { kind: "utc day" };
+  const sessionDate = (session === "active" ? quote.changeSessionDate : regularSessionDisplayDate(quote)) ?? quoteTradingDay(quote);
+  if (isFuturesInstrument(quote.symbol, quote.instrumentType)) {
+    const basis = futuresChangeBasis(terms ?? { settlement: null }, { ...display, sessionDate });
+    return basis ? { kind: basis.kind, date: basis.session } : { kind: "previous close" };
+  }
+  if (!sessionDate || !ISO_DATE.test(sessionDate)) return { kind: "previous close" };
+  return previousSession(quote, sessionDate) ?? { kind: "previous close" };
+}
+
+/**
+ * The exchange-local date of `quote.previousClose`: the session before the
+ * one the quote's change is declared for (changeSessionDate), the UTC day
+ * before for a coin. Null when the quote has no previous close or nothing
+ * dates it, and for a coin or perpetual measured over 24 hours.
+ */
+export function quotePreviousCloseDate(quote: Quote | null | undefined): string | null {
+  if (!quote || !isFiniteNumber(quote.previousClose) || quote.changeBasis != null) return null;
+  if (isPerpetualExchange(quote.listingExchangeName || quote.exchangeName)) return null;
+  const sessionDate = quote.changeSessionDate ?? quoteTradingDay(quote);
+  if (!sessionDate || !ISO_DATE.test(sessionDate)) return null;
+  if (isSpotCoin(quote)) return dayBefore(sessionDate);
+  if (isFuturesInstrument(quote.symbol, quote.instrumentType)) return futuresChangeBasis({ settlement: null }, { price: quote.price, change: 0, sessionDate })?.session ?? null;
+  return previousSession(quote, sessionDate)?.date ?? null;
+}
+
+/** `Fri 16 Oct`, with the year when it is not `now`'s. */
+function sessionDay(date: string, now: number): string {
+  return formatUtcDayTime({ time: Date.parse(`${date}T00:00:00Z`), dateOnly: true }, now);
+}
+
+/**
+ * The words a change line ends with, the same on every surface: "vs Fri 16
+ * Oct close", "vs Fri 16 Oct settle", "vs prev close", "since 00:00 UTC",
+ * "24h".
+ */
+export function changeBasisLabel(basis: QuoteChangeBasis, now = Date.now()): string {
+  switch (basis.kind) {
+    case "previous close":
+      return "vs prev close";
+    case "utc day":
+      return "since 00:00 UTC";
+    case "24h":
+      return "24h";
+    default:
+      return `vs ${sessionDay(basis.date, now)} ${basis.kind}`;
+  }
+}
+
+/**
+ * The days a venue was closed since the close a move is measured from, when
+ * there were any: "HKEX closed Mon 19 Oct, holiday"; three or more read as a
+ * span, "TWSE closed Thu 12 Feb to Fri 20 Feb, holidays". Null otherwise.
+ */
+export function changeBasisNote(basis: QuoteChangeBasis | null | undefined, now = Date.now()): string | null {
+  if (!basis || basis.kind !== "close" || !basis.venue || !basis.closed?.length) return null;
+  const days = basis.closed.map((date) => sessionDay(date, now));
+  const span = days.length === 1 ? days[0] : days.length === 2 ? `${days[0]} and ${days[1]}` : `${days[0]} to ${days.at(-1)}`;
+  return `${basis.venue} closed ${span}, ${days.length === 1 ? "holiday" : "holidays"}`;
+}
+
+/** What several moves summed into one (a portfolio's day) are measured from, when they say. */
+const MIXED_CHANGE_BASIS_LABEL = "vs mixed closes";
+
+/**
+ * The label of a total over moves measured from different closes: the one
+ * label when they agree, "vs mixed closes" when they do not, so a total over
+ * an HKEX and a US listing never names one date for both. Null without a
+ * basis.
+ */
+export function combinedChangeBasisLabel(bases: Iterable<QuoteChangeBasis | null | undefined>, now = Date.now()): string | null {
+  const labels = new Set<string>();
+  for (const basis of bases) if (basis) labels.add(changeBasisLabel(basis, now));
+  if (labels.size === 0) return null;
+  return labels.size === 1 ? [...labels][0]! : MIXED_CHANGE_BASIS_LABEL;
+}
+
+/**
+ * The basis as `--json` gives it beside a move: the kind, the dated session
+ * (`date`), the venue's closures in between and the label and note a change
+ * line shows.
+ */
+export function changeBasisJson(basis: QuoteChangeBasis | null, now = Date.now()) {
+  if (!basis) return null;
+  const note = changeBasisNote(basis, now);
+  return {
+    kind: basis.kind,
+    date: "date" in basis ? basis.date : null,
+    ...("closed" in basis && basis.closed?.length ? { closed: [...basis.closed] } : {}),
+    label: changeBasisLabel(basis, now),
+    ...(note ? { note } : {}),
+  };
+}

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

@@ -2,7 +2,8 @@ import type { PriceBasis } from "../../types/instrument";
 import type { Quote } from "../../types/financials";
 import { resolvePriceBasis } from "./price-basis";
 import { isIndexLevel } from "./index-level";
-import { currencyPriceDigits, formatCompact, formatCurrency } from "../../utils/format";
+import { currencyPriceDigits, formatCompact, formatCurrency, formatCurrencyCode } from "../../utils/format";
+import { minorUnitSign } from "../../utils/currency-units";
 
 export type AssetDisplayKind = "cash" | "crypto" | "equity" | "contract" | "other";
 
@@ -25,6 +26,8 @@ export interface MarketFormatOptions extends AssetDisplayContext {
   fixedFractionDigits?: number;
   /** Source units per displayed currency unit; a price quoted in pence keeps its pence decimals in pounds. */
   quotedUnitDivisor?: number;
+  /** Write the currency's code after a money price (259.36 USD) instead of its sign ($259.36): a report for a base currency other than USD. */
+  currencyCode?: boolean;
   /** A price that holds still for the session, such as the previous close. With
    * `fixedFractionDigits`, the kind's decimal ceiling is read at this price
    * instead of at the value, so a live price keeps its decimals as it moves. */
@@ -283,12 +286,12 @@ function compactScaledPrice(
   maxWidth: number | undefined,
 ): string {
   const sign = value < 0 ? "-" : "";
-  const symbol = getCurrencySymbol(currency);
+  const marks = currencyMarks(currency, currency.trim().toUpperCase() || "USD");
   const numericWidth = maxWidth == null
     ? undefined
-    : Math.max(1, maxWidth - sign.length - symbol.length - suffix.length);
+    : Math.max(1, maxWidth - sign.length - marks.prefix.length - suffix.length - marks.suffix.length);
   const formatted = formatVariableNumber(Math.abs(value) / divisor, 1, numericWidth, 1);
-  return `${sign}${symbol}${formatted}${suffix}`;
+  return `${sign}${marks.prefix}${formatted}${suffix}${marks.suffix}`;
 }
 
 export function resolveAssetDisplayKind({
@@ -449,9 +452,10 @@ export function formatMarketChangeWithCurrency(
       return `${value > 0 ? "+" : ""}${formatMarketPriceWithCurrency(value, currency, options)}`;
     }
   }
+  const money = options.currencyCode ? formatCurrencyCode : formatCurrency;
   // A move that rounds to zero cents is unsigned rather than -$0.00.
-  if (Math.abs(value) < smallestMove) return formatCurrency(0, currency);
-  return `${value > 0 ? "+" : ""}${formatCurrency(value, currency)}`;
+  if (Math.abs(value) < smallestMove) return money(0, currency);
+  return `${value > 0 ? "+" : ""}${money(value, currency)}`;
 }
 
 /** Decimals the currency's minor unit has: two for GBP, none for JPY. */
@@ -612,6 +616,18 @@ export function liveQuoteFormatOptions(
   return withStablePriceDigits(quoteFormatOptions(quote, fallbackAssetCategory, metadataInstrumentType), currency, quote);
 }
 
+/**
+ * Where an amount's currency is written: a major currency's symbol before it
+ * ($314.95, CHF314.95), a minor unit's sign after it (314.95¢ for US cents,
+ * 412.50p for pence), as `minorUnitSign` names them. A minor unit is read
+ * before upper-casing, as GBp is pence and GBP pounds.
+ */
+function currencyMarks(currency: string, normalizedCurrency: string, code = false): { prefix: string; suffix: string } {
+  const minor = minorUnitSign(currency);
+  if (minor) return { prefix: "", suffix: minor };
+  return code ? { prefix: "", suffix: ` ${normalizedCurrency}` } : { prefix: getCurrencySymbol(normalizedCurrency), suffix: "" };
+}
+
 export function formatMarketPriceWithCurrency(
   value: number | undefined,
   currency = "USD",
@@ -621,12 +637,12 @@ export function formatMarketPriceWithCurrency(
   if (isIndexLevel(options.assetCategory) || resolvePriceBasis(options.priceBasis, options.assetCategory) !== "per-unit") return formatMarketPrice(value, options);
   const normalizedCurrency = currency.trim().toUpperCase() || "USD";
   const sign = value < 0 ? "-" : "";
-  const symbol = getCurrencySymbol(normalizedCurrency);
+  const { prefix, suffix } = currencyMarks(currency, normalizedCurrency, options.currencyCode);
   const numericWidth = options.maxWidth == null
     ? undefined
-    : Math.max(1, options.maxWidth - sign.length - symbol.length);
+    : Math.max(1, options.maxWidth - sign.length - prefix.length - suffix.length);
   const body = formatMarketPrice(Math.abs(value), { ...options, currency: normalizedCurrency, maxWidth: numericWidth });
-  return `${hasNonZeroDigit(body) ? sign : ""}${symbol}${body}`;
+  return `${hasNonZeroDigit(body) ? sign : ""}${prefix}${body}${suffix}`;
 }
 
 export function formatMarketCostWithCurrency(
@@ -638,10 +654,10 @@ export function formatMarketCostWithCurrency(
   if (resolvePriceBasis(options.priceBasis, options.assetCategory) !== "per-unit") return formatMarketCost(value, options);
   const normalizedCurrency = currency.trim().toUpperCase() || "USD";
   const sign = value < 0 ? "-" : "";
-  const symbol = getCurrencySymbol(normalizedCurrency);
+  const { prefix, suffix } = currencyMarks(currency, normalizedCurrency, options.currencyCode);
   const numericWidth = options.maxWidth == null
     ? undefined
-    : Math.max(1, options.maxWidth - sign.length - symbol.length);
+    : Math.max(1, options.maxWidth - sign.length - prefix.length - suffix.length);
   // A money cost keeps its currency's minor unit: $189.20, not $189.2 (JPY has none).
   const body = formatMarketCost(Math.abs(value), {
     minimumFractionDigits: currencyPriceMinDigits(normalizedCurrency),
@@ -649,7 +665,7 @@ export function formatMarketCostWithCurrency(
     currency: normalizedCurrency,
     maxWidth: numericWidth,
   });
-  return `${sign}${symbol}${body}`;
+  return `${sign}${prefix}${body}${suffix}`;
 }
 
 /** @deprecated Slated for removal. Use `formatMarketPriceWithCurrency` with `maxWidth` to fit a column. */

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

@@ -498,6 +498,44 @@ export function hasPublishedSessionCalendar(exchange: string | undefined, date:
   return !!getPublishedUsEquityCalendarYears(canonical)?.includes(year);
 }
 
+/**
+ * The venue's regular session before the one a move is dated to (`date`, its
+ * local `YYYY-MM-DD`), from its published calendar, with the days of its
+ * trading week it was closed in between (the Chung Yeung holiday HKEX took on
+ * Mon 19 Oct 2026 lies between Fri 16 and Tue 20 Oct). A `date` that is no
+ * session (a quote dated by when it was read, on a Saturday or a holiday) is
+ * the latest session on or before it: Friday's move, read on Saturday, is
+ * from Thursday's close. Null for round-the-clock and unknown venues, and
+ * when a day the walk passes is in a year whose closures the venue has not
+ * published: a holiday there would read as a session.
+ */
+export function previousPublishedSession(
+  exchange: string | undefined,
+  date: string,
+): { date: string; closed: string[] } | null {
+  const canonical = canonicalExchange(exchange);
+  const day = isoLocalDateToUtcDay(date);
+  if (day == null || ALWAYS_OPEN_EXCHANGES.has(canonical) || !sessionCalendarTimeZone(canonical)) return null;
+  let session: number | null = null;
+  const closed: string[] = [];
+  for (let offset = 0; offset <= SESSION_LOOKBACK_DAYS * 2; offset++) {
+    const at = new Date((day - offset) * MS_PER_DAY);
+    const iso = at.toISOString().slice(0, 10);
+    if (!isTradingWeekday(canonical, at.getUTCDay())) continue;
+    if (!hasPublishedSessionCalendar(canonical, iso)) return null;
+    const open = !isPublishedClosure(canonical, iso);
+    // First the session the move is from's own day, then the one before it.
+    if (session == null) {
+      if (open) session = offset;
+      continue;
+    }
+    if (offset - session > SESSION_LOOKBACK_DAYS) return null;
+    if (open) return { date: iso, closed: closed.reverse() };
+    closed.push(iso);
+  }
+  return null;
+}
+
 /** How far the delayed feed runs behind the venue's trades. */
 export function delayedFeedLagMs(exchange: string | undefined): number {
   return SLOWER_DELAYED_FEEDS.has(canonicalExchange(exchange)) ? SLOWER_DELAYED_FEED_LAG_MS : DELAYED_FEED_LAG_MS;