gloomberb 0.16.3 → 0.16.5

package/src/{plugins/builtin/futures/contracts.ts → market-data/futures-board.ts}

@@ -25,8 +25,22 @@ export interface FuturesContract {
   venue: "CME" | "CBT" | "NYM" | "CMX" | "NYB";
   /** Lists a contract for every calendar month. */
   everyMonth?: true;
-  /** False where the contract curve (CTM) does not cover the root yet. */
-  curve?: false;
+  /**
+   * What a price counts where the server sends no contract terms for the root:
+   * Dutch TTF gas quotes in euros per MWh, which a bare "EUR" does not say, and
+   * live cattle in US cents per pound, where the server's "USX" does not.
+   */
+  unit?: string;
+  /**
+   * No listed security answers to the code typed alone, so a bare TTF, ZN or 6E
+   * is this future wherever a symbol is typed. Codes a security also uses (NG
+   * is NovaGold, CL Colgate, ZM Zoom, GC several venues' listings) leave it
+   * unset: the security keeps the code and the future is its `=F` symbol.
+   * Checked with `gloomberb quote <code>` signed out on 2026-10-11: each of
+   * these was "Not a ticker", or for ZT and ZF a quote last updated in 2023 and
+   * 2021 that search no longer lists.
+   */
+  bareCode?: true;
 }
 
 /** 0.005 -> 3, 0.25 -> 2, 1 -> 0. Written for ticks, not general numbers. */
@@ -41,28 +55,28 @@ export function tickDecimals(tick: number): number {
  */
 export const FUTURES_CONTRACTS: FuturesContract[] = [
   { symbol: "ES=F", code: "ES", name: "E-Mini S&P 500", sector: "equity-index", venue: "CME", tick: 0.25 },
-  { symbol: "NQ=F", code: "NQ", name: "E-Mini Nasdaq 100", sector: "equity-index", venue: "CME", tick: 0.25 },
-  { symbol: "YM=F", code: "YM", name: "E-Mini Dow", sector: "equity-index", venue: "CBT", tick: 1 },
-  { symbol: "RTY=F", code: "RTY", name: "E-Mini Russell 2000", sector: "equity-index", venue: "CME", tick: 0.1 },
+  { symbol: "NQ=F", code: "NQ", name: "E-Mini Nasdaq 100", sector: "equity-index", venue: "CME", tick: 0.25, bareCode: true },
+  { symbol: "YM=F", code: "YM", name: "E-Mini Dow", sector: "equity-index", venue: "CBT", tick: 1, bareCode: true },
+  { symbol: "RTY=F", code: "RTY", name: "E-Mini Russell 2000", sector: "equity-index", venue: "CME", tick: 0.1, bareCode: true },
 
-  { symbol: "ZT=F", code: "ZT", name: "2-Year T-Note", sector: "rates", venue: "CBT" },
-  { symbol: "ZF=F", code: "ZF", name: "5-Year T-Note", sector: "rates", venue: "CBT" },
-  { symbol: "ZN=F", code: "ZN", name: "10-Year T-Note", sector: "rates", venue: "CBT" },
-  { symbol: "ZB=F", code: "ZB", name: "30-Year T-Bond", sector: "rates", venue: "CBT" },
-  { symbol: "UB=F", code: "UB", name: "Ultra T-Bond", sector: "rates", venue: "CBT" },
+  { symbol: "ZT=F", code: "ZT", name: "2-Year T-Note", sector: "rates", venue: "CBT", bareCode: true },
+  { symbol: "ZF=F", code: "ZF", name: "5-Year T-Note", sector: "rates", venue: "CBT", bareCode: true },
+  { symbol: "ZN=F", code: "ZN", name: "10-Year T-Note", sector: "rates", venue: "CBT", bareCode: true },
+  { symbol: "ZB=F", code: "ZB", name: "30-Year T-Bond", sector: "rates", venue: "CBT", bareCode: true },
+  { symbol: "UB=F", code: "UB", name: "Ultra T-Bond", sector: "rates", venue: "CBT", bareCode: true },
 
   { symbol: "CL=F", code: "CL", name: "WTI Crude Oil", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.01 },
   { symbol: "BZ=F", code: "BZ", name: "Brent Crude Oil", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.01 },
   { symbol: "NG=F", code: "NG", name: "Natural Gas", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.001 },
   // Quoted in euros per MWh.
-  { symbol: "TTF=F", code: "TTF", name: "Dutch TTF Gas", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.001, curve: false },
+  { symbol: "TTF=F", code: "TTF", name: "Dutch TTF Gas", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.001, unit: "EUR / MWh", bareCode: true },
   { symbol: "RB=F", code: "RB", name: "RBOB Gasoline", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.0001 },
   { symbol: "HO=F", code: "HO", name: "Heating Oil", sector: "energy", venue: "NYM", everyMonth: true, tick: 0.0001 },
 
   { symbol: "GC=F", code: "GC", name: "Gold", sector: "metals", venue: "CMX", tick: 0.1 },
   { symbol: "SI=F", code: "SI", name: "Silver", sector: "metals", venue: "CMX", tick: 0.005 },
   { symbol: "HG=F", code: "HG", name: "Copper", sector: "metals", venue: "CMX", tick: 0.0005 },
-  { symbol: "ALI=F", code: "ALI", name: "Aluminum", sector: "metals", venue: "CMX", tick: 0.25, curve: false },
+  { symbol: "ALI=F", code: "ALI", name: "Aluminum", sector: "metals", venue: "CMX", tick: 0.25, unit: "USD / metric ton" },
   { symbol: "PL=F", code: "PL", name: "Platinum", sector: "metals", venue: "NYM", tick: 0.1 },
   { symbol: "PA=F", code: "PA", name: "Palladium", sector: "metals", venue: "NYM", tick: 0.1 },
 
@@ -70,27 +84,27 @@ export const FUTURES_CONTRACTS: FuturesContract[] = [
   // dollars); a tick is in the quote's own units.
   { symbol: "ZC=F", code: "ZC", name: "Corn", sector: "agriculture", venue: "CBT", tick: 0.25 },
   { symbol: "ZS=F", code: "ZS", name: "Soybeans", sector: "agriculture", venue: "CBT", tick: 0.25 },
-  { symbol: "ZM=F", code: "ZM", name: "Soybean Meal", sector: "agriculture", venue: "CBT", tick: 0.1, curve: false },
-  { symbol: "ZL=F", code: "ZL", name: "Soybean Oil", sector: "agriculture", venue: "CBT", tick: 0.01, curve: false },
-  { symbol: "ZW=F", code: "ZW", name: "Chicago SRW Wheat", sector: "agriculture", venue: "CBT", tick: 0.25 },
-  { symbol: "KE=F", code: "KE", name: "KC HRW Wheat", sector: "agriculture", venue: "CBT", tick: 0.25, curve: false },
+  { symbol: "ZM=F", code: "ZM", name: "Soybean Meal", sector: "agriculture", venue: "CBT", tick: 0.1 },
+  { symbol: "ZL=F", code: "ZL", name: "Soybean Oil", sector: "agriculture", venue: "CBT", tick: 0.01, bareCode: true },
+  { symbol: "ZW=F", code: "ZW", name: "Chicago SRW Wheat", sector: "agriculture", venue: "CBT", tick: 0.25, bareCode: true },
+  { symbol: "KE=F", code: "KE", name: "KC HRW Wheat", sector: "agriculture", venue: "CBT", tick: 0.25 },
   { symbol: "KC=F", code: "KC", name: "Coffee", sector: "agriculture", venue: "NYB", tick: 0.05 },
   { symbol: "SB=F", code: "SB", name: "Sugar #11", sector: "agriculture", venue: "NYB", tick: 0.01 },
   { symbol: "CC=F", code: "CC", name: "Cocoa", sector: "agriculture", venue: "NYB", tick: 1 },
-  { symbol: "CT=F", code: "CT", name: "Cotton #2", sector: "agriculture", venue: "NYB", tick: 0.01 },
-  { symbol: "OJ=F", code: "OJ", name: "Orange Juice", sector: "agriculture", venue: "NYB", tick: 0.05, curve: false },
-  { symbol: "LBR=F", code: "LBR", name: "Lumber", sector: "agriculture", venue: "CME", tick: 0.5, curve: false },
+  { symbol: "CT=F", code: "CT", name: "Cotton #2", sector: "agriculture", venue: "NYB", tick: 0.01, bareCode: true },
+  { symbol: "OJ=F", code: "OJ", name: "Orange Juice", sector: "agriculture", venue: "NYB", tick: 0.05, unit: "US cents / lb", bareCode: true },
+  { symbol: "LBR=F", code: "LBR", name: "Lumber", sector: "agriculture", venue: "CME", tick: 0.5, unit: "USD / 1,000 board ft", bareCode: true },
 
   // Quoted in US cents per pound.
-  { symbol: "LE=F", code: "LE", name: "Live Cattle", sector: "livestock", venue: "CME", tick: 0.025, curve: false },
-  { symbol: "HE=F", code: "HE", name: "Lean Hogs", sector: "livestock", venue: "CME", tick: 0.025, curve: false },
-
-  { symbol: "6E=F", code: "6E", name: "Euro FX", sector: "currencies", venue: "CME", tick: 0.00005 },
-  { symbol: "6J=F", code: "6J", name: "Japanese Yen", sector: "currencies", venue: "CME", tick: 0.0000005 },
-  { symbol: "6B=F", code: "6B", name: "British Pound", sector: "currencies", venue: "CME", tick: 0.0001 },
-  { symbol: "6A=F", code: "6A", name: "Australian Dollar", sector: "currencies", venue: "CME", tick: 0.00005 },
-  { symbol: "6C=F", code: "6C", name: "Canadian Dollar", sector: "currencies", venue: "CME", tick: 0.00005 },
-  { symbol: "6S=F", code: "6S", name: "Swiss Franc", sector: "currencies", venue: "CME", tick: 0.00005 },
+  { symbol: "LE=F", code: "LE", name: "Live Cattle", sector: "livestock", venue: "CME", tick: 0.025, unit: "US cents / lb" },
+  { symbol: "HE=F", code: "HE", name: "Lean Hogs", sector: "livestock", venue: "CME", tick: 0.025, unit: "US cents / lb" },
+
+  { symbol: "6E=F", code: "6E", name: "Euro FX", sector: "currencies", venue: "CME", tick: 0.00005, bareCode: true },
+  { symbol: "6J=F", code: "6J", name: "Japanese Yen", sector: "currencies", venue: "CME", tick: 0.0000005, bareCode: true },
+  { symbol: "6B=F", code: "6B", name: "British Pound", sector: "currencies", venue: "CME", tick: 0.0001, bareCode: true },
+  { symbol: "6A=F", code: "6A", name: "Australian Dollar", sector: "currencies", venue: "CME", tick: 0.00005, bareCode: true },
+  { symbol: "6C=F", code: "6C", name: "Canadian Dollar", sector: "currencies", venue: "CME", tick: 0.00005, bareCode: true },
+  { symbol: "6S=F", code: "6S", name: "Swiss Franc", sector: "currencies", venue: "CME", tick: 0.00005, bareCode: true },
 ];
 
 export const FUTURES_SECTOR_LABELS: Record<FuturesSector, string> = {
@@ -120,3 +134,42 @@ export function getContractsBySector(): Map<FuturesSector, FuturesContract[]> {
   }
   return map;
 }
+
+const BY_CODE: ReadonlyMap<string, FuturesContract> = new Map(FUTURES_CONTRACTS.map((contract) => [contract.code, contract]));
+const BY_SYMBOL: ReadonlyMap<string, FuturesContract> = new Map(FUTURES_CONTRACTS.map((contract) => [contract.symbol, contract]));
+
+const typed = (value: unknown) => typeof value === "string" ? value.trim().toUpperCase() : "";
+
+/** The board row a bare code names, in any case: NG is Natural Gas whether or not a security also uses NG. */
+export function futuresContractByCode(code: unknown): FuturesContract | null {
+  return BY_CODE.get(typed(code)) ?? null;
+}
+
+/**
+ * The board row a futures function's typed argument names, by code or
+ * continuous symbol: ttf, TTF and TTF=F are Dutch TTF Gas. A typed argument
+ * always means the future, so NG here is natural gas, never NovaGold.
+ */
+export function futuresBoardContract(value: unknown): FuturesContract | null {
+  return BY_SYMBOL.get(typed(value)) ?? futuresContractByCode(value);
+}
+
+/**
+ * The future a bare symbol typed for a security stands for: a code no listed
+ * security answers to (TTF is TTF=F). Null for every other symbol, and for a
+ * code a security keeps (NG), whose future is NG=F.
+ */
+export function bareFuturesCode(symbol: unknown): FuturesContract | null {
+  const contract = futuresContractByCode(symbol);
+  return contract?.bareCode ? contract : null;
+}
+
+/**
+ * The board row the ticker under the cursor names, for a futures function
+ * opened without an argument: its continuous symbol (NG=F) or a code no
+ * security answers to (TTF). A bare code a security keeps (NG, ZM, PL) is that
+ * security's, never the future's.
+ */
+export function futuresBoardContractForTicker(ticker: unknown): FuturesContract | null {
+  return BY_SYMBOL.get(typed(ticker)) ?? bareFuturesCode(ticker);
+}

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

@@ -0,0 +1,151 @@
+import { apiClient } from "../api-client";
+import type { FuturesContractSpec, FuturesContractTermsPayload } from "../api-client/futures-curve";
+import { classifyInstrumentType } from "../tickers/instrument-kind";
+import type { Quote } from "../types/financials";
+import { parsePublicTickerKey } from "../utils/exchanges";
+import { formatMarketPrice, formatMarketPriceWithCurrency, quoteFormatOptions, withCurrencyMinorDigits } from "./market/format";
+
+/**
+ * What a futures symbol trades, as `ticker`, `quote` and the Overview tab read
+ * it: one Settle value dated by its session and one list of contract lines, so
+ * the three cannot word the same contract differently. Margins are not part of
+ * the terms: nothing here shows or estimates one.
+ */
+
+/** A settlement the exchange has not confirmed reads as CTM writes a missing price. */
+const FUTURES_MISSING = "--";
+
+type FuturesContractLineKey = "contract" | "unit" | "size" | "tick" | "pointValue" | "settlement" | "firstNotice" | "lastTrade";
+
+export interface FuturesContractLine {
+  key: FuturesContractLineKey;
+  label: string;
+  value: string;
+  /** Past first notice: a long can be assigned delivery. */
+  warning?: true;
+}
+
+/**
+ * Which lines a short or narrow block keeps, best first: the month the symbol
+ * prices, what one contract and one tick are worth, and when delivery starts.
+ * The unit, last trade, settlement type and point value follow from those.
+ */
+const LINE_RANK: Readonly<Record<FuturesContractLineKey, number>> = {
+  contract: 0, size: 1, tick: 2, firstNotice: 3, unit: 4, lastTrade: 5, settlement: 6, pointValue: 7,
+};
+
+const SETTLEMENT_TYPE: Readonly<Record<FuturesContractSpec["settlement"], string>> = {
+  physical: "Physical delivery",
+  cash: "Cash settled",
+};
+
+/** Whether a symbol is a futures contract, an alias (GC=F) or a generic (CL1), whose contract terms are worth asking for. */
+export function isFuturesInstrument(symbol: string, instrumentType: string | null | undefined): boolean {
+  return classifyInstrumentType(instrumentType) === "future" || /=F$/i.test(symbol.trim());
+}
+
+function decimals(value: number): number {
+  return value.toFixed(10).replace(/0+$/, "").split(".")[1]?.length ?? 0;
+}
+
+/** A tick at its own precision and what it makes on one contract: "0.10 = $10.00", "0.015625 = $15.625". */
+export function futuresTickText(spec: Pick<FuturesContractSpec, "tick" | "tickValue">): string {
+  const value = spec.tickValue.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: Math.max(2, decimals(spec.tickValue)) });
+  return `${spec.tick.toFixed(Math.max(2, decimals(spec.tick)))} = $${value}`;
+}
+
+/** One contract of a root, from the exchange's rulebook: the terms a hedge is sized on. */
+export function futuresSpecLines(spec: FuturesContractSpec): FuturesContractLine[] {
+  return [
+    { key: "unit", label: "Unit", value: spec.unit },
+    { key: "size", label: "Size", value: spec.size },
+    { key: "tick", label: "Tick", value: futuresTickText(spec) },
+    { key: "pointValue", label: "Point Value", value: `$${spec.pointValue.toLocaleString("en-US")}` },
+    { key: "settlement", label: "Settlement", value: SETTLEMENT_TYPE[spec.settlement] },
+  ];
+}
+
+/** A contract as traders write it: GCZ26.CMX is GCZ26. */
+function contractCode(symbol: string): string {
+  return parsePublicTickerKey(symbol).symbol.replace(/\.[A-Z]+$/, "");
+}
+
+/**
+ * The Contract block: the contract an alias or a generic prices, its terms and
+ * the dates a long faces delivery. A line with nothing to say is left out, so
+ * a cash-settled root has no first notice and a listed contract no Contract line.
+ */
+export function futuresContractLines(terms: FuturesContractTermsPayload, symbol: string): FuturesContractLine[] {
+  const lines: FuturesContractLine[] = [];
+  if (terms.contract && terms.contract !== contractCode(symbol)) lines.push({ key: "contract", label: "Contract", value: terms.contract });
+  if (terms.spec) lines.push(...futuresSpecLines(terms.spec));
+  if (terms.firstNotice) {
+    lines.push(terms.inDelivery
+      ? { key: "firstNotice", label: "First Notice", value: `${terms.firstNotice} (passed)`, warning: true }
+      : { key: "firstNotice", label: "First Notice", value: terms.firstNotice });
+  }
+  if (terms.lastTrade) lines.push({ key: "lastTrade", label: "Last Trade", value: terms.lastTrade });
+  return lines;
+}
+
+/** At most `max` lines, the least useful dropped first, in the block's own order. */
+export function fitFuturesContractLines(lines: readonly FuturesContractLine[], max: number): FuturesContractLine[] {
+  if (lines.length <= max) return [...lines];
+  const kept = new Set([...lines].sort((a, b) => LINE_RANK[a.key] - LINE_RANK[b.key]).slice(0, Math.max(0, max)));
+  return lines.filter((line) => kept.has(line));
+}
+
+/**
+ * The exchange settlement dated by its session, `$4,216.30 (2026-10-09)`, as
+ * `ticker` prints a futures price: in the quote's currency, padded to its minor
+ * unit and at the contract's own precision, with or without a quote to hand.
+ * Without a quote currency the price is a bare number, never a guessed `$`: a
+ * grain settles in cents. A contract without a confirmed settlement reads
+ * `--`: never an older settlement, and never the last trade.
+ */
+export function futuresSettleText(
+  terms: Pick<FuturesContractTermsPayload, "settlement">,
+  quote: Pick<Quote, "currency" | "instrumentType" | "priceBasis" | "providerPriceDivisor"> | null | undefined,
+): string {
+  if (!terms.settlement) return FUTURES_MISSING;
+  const currency = quote?.currency;
+  const options = withCurrencyMinorDigits(quoteFormatOptions(quote, "FUTURE"), currency);
+  const price = currency ? formatMarketPriceWithCurrency(terms.settlement.price, currency, options) : formatMarketPrice(terms.settlement.price, options);
+  return `${price} (${terms.settlement.date})`;
+}
+
+const isDate = (value: unknown) => typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value)
+  && new Date(`${value}T00:00:00Z`).toISOString().slice(0, 10) === value;
+const optionalDate = (value: unknown) => value === null || isDate(value);
+const positive = (value: unknown) => typeof value === "number" && Number.isFinite(value) && value > 0;
+
+/** Contract terms the text is computed from: a tick, its value and a point value, all positive. */
+export function isFuturesContractSpec(spec: unknown): spec is FuturesContractSpec {
+  if (!spec || typeof spec !== "object") return false;
+  const row = spec as Record<string, unknown>;
+  return typeof row.unit === "string" && typeof row.size === "string"
+    && positive(row.tick) && positive(row.tickValue) && positive(row.pointValue)
+    && (row.settlement === "physical" || row.settlement === "cash");
+}
+
+export function validateFuturesContractTerms(data: FuturesContractTermsPayload): FuturesContractTermsPayload {
+  const settlement = data?.settlement as unknown;
+  if (!data || typeof data !== "object" || typeof data.root !== "string"
+    || !(data.contract === null || typeof data.contract === "string")
+    || !(data.spec === null || isFuturesContractSpec(data.spec))
+    || !optionalDate(data.lastTrade) || !optionalDate(data.firstNotice) || typeof data.inDelivery !== "boolean"
+    || !(settlement === null || typeof settlement === "object" && Number.isFinite((settlement as { price?: unknown }).price)
+      && isDate((settlement as { date?: unknown }).date))) {
+    throw new Error("The server returned invalid futures contract terms");
+  }
+  return data;
+}
+
+/** A futures symbol's contract, terms and latest confirmed settlement; throws when the server has none for it. */
+export async function loadFuturesContractTerms(
+  symbol: string,
+  client: Pick<typeof apiClient, "getCloudFuturesContract"> = apiClient,
+): Promise<FuturesContractTermsPayload> {
+  // The terms are the contract's wherever it is listed: GC=F:CMX asks for GC=F.
+  return validateFuturesContractTerms(await client.getCloudFuturesContract(parsePublicTickerKey(symbol).symbol));
+}

package/src/market-data/hooks.tsx

@@ -315,9 +315,17 @@ export function useSecFilingsQuery(request: SecFilingsRequest | null | undefined
 
 export function useSecFilingContent(filing: SecFilingItem | null | undefined): QueryEntry<string | null> | null {
   const key = filing ? buildSecContentKey(filing.accessionNumber) : null;
-  useCoordinatorKeysVersion(key ? [key] : []);
+  const version = useCoordinatorKeysVersion(key ? [key] : []);
   const coordinator = getSharedMarketDataCoordinator();
-  const entry = coordinator && filing ? coordinator.getSecContentEntry(filing.accessionNumber) : null;
+  // Read at the version React holds. A store write is announced a frame
+  // later; a render in between that changes no state is thrown away, and with
+  // it the effects of a reader that saw the new entry early, which then never
+  // see it change (a filing queue stalled on "loading").
+  const accession = filing?.accessionNumber ?? null;
+  const entry = useMemo(
+    () => coordinator && accession ? coordinator.getSecContentEntry(accession) : null,
+    [accession, coordinator, version],
+  );
 
   useEffect(() => {
     const coordinator = getSharedMarketDataCoordinator();

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

@@ -1,11 +1,13 @@
 import type { PriceBasis } from "../../types/instrument";
 import type { Quote } from "../../types/financials";
 import { resolvePriceBasis } from "./price-basis";
-import { formatCompact, formatCurrency } from "../../utils/format";
+import { currencyPriceDigits, formatCompact, formatCurrency } from "../../utils/format";
 
 export type AssetDisplayKind = "cash" | "crypto" | "equity" | "contract" | "other";
 
 export interface AssetDisplayContext {
+  /** The price's currency; the thousandth currencies (OMR, KWD) keep three decimals above one unit. */
+  currency?: string;
   isCashBalance?: boolean;
   assetCategory?: string;
   contractSecType?: string;
@@ -159,7 +161,7 @@ function integerDigits(value: number): number {
   return absolute >= 1 && Number.isFinite(absolute) ? Math.floor(Math.log10(absolute)) + 1 : 0;
 }
 
-function getBasePriceMaxFractionDigits(kind: AssetDisplayKind, value: number): number {
+function getBasePriceMaxFractionDigits(kind: AssetDisplayKind, value: number, currency?: string): number {
   switch (kind) {
     case "cash":
       // Six decimals, but no more than seven significant digits: providers send
@@ -172,14 +174,14 @@ function getBasePriceMaxFractionDigits(kind: AssetDisplayKind, value: number): n
       // provider's float tail on quotes like 109556.1640625.
       return Math.abs(value) >= 100 ? 2 : Math.abs(value) >= 1 ? 4 : 8;
     case "equity":
-      return Math.abs(value) >= 1 ? 2 : 4;
+      return Math.abs(value) >= 1 ? currencyPriceDigits(currency) : 4;
     case "contract":
       // Currency futures include five- and seven-decimal prices. This is a
       // display ceiling, not a declaration of the contract's minimum tick.
       return 8;
     case "other":
     default:
-      return Math.abs(value) >= 1 ? 2 : 4;
+      return Math.abs(value) >= 1 ? currencyPriceDigits(currency) : 4;
   }
 }
 
@@ -234,7 +236,10 @@ export function formatPriceObservation(
 /** The most decimals formatMarketPrice shows for this asset kind and magnitude,
  * for callers that render a whole column with one fixed decimal count. */
 export function marketPriceFractionDigitCeiling(value: number, context: AssetDisplayContext): number {
-  return Math.max(getBasePriceMaxFractionDigits(resolveAssetDisplayKind(context), value), tinyPriceFractionDigits(value));
+  return Math.max(
+    getBasePriceMaxFractionDigits(resolveAssetDisplayKind(context), value, context.currency),
+    tinyPriceFractionDigits(value),
+  );
 }
 
 function getPriceMaxFractionDigits(
@@ -243,17 +248,18 @@ function getPriceMaxFractionDigits(
   priceRange: number | undefined,
   precisionOffset: number,
   quotedUnitDigits = 0,
+  currency?: string,
 ): number {
   const baseMaxFractionDigits = kind === "other" && priceRange !== undefined
     ? 6
-    : getBasePriceMaxFractionDigits(kind, value) + quotedUnitDigits;
+    : getBasePriceMaxFractionDigits(kind, value, currency) + quotedUnitDigits;
   const adaptiveFractionDigits = getAdaptivePriceFractionDigits(priceRange, precisionOffset);
   return adaptiveFractionDigits === null
     ? baseMaxFractionDigits
     : Math.min(baseMaxFractionDigits, adaptiveFractionDigits);
 }
 
-function getCostMaxFractionDigits(kind: AssetDisplayKind): number {
+function getCostMaxFractionDigits(kind: AssetDisplayKind, currency?: string): number {
   switch (kind) {
     case "cash":
       return 6;
@@ -262,10 +268,9 @@ function getCostMaxFractionDigits(kind: AssetDisplayKind): number {
     case "contract":
       return 4;
     case "equity":
-      return 2;
     case "other":
     default:
-      return 2;
+      return currencyPriceDigits(currency);
   }
 }
 
@@ -356,7 +361,7 @@ export function formatMarketPrice(value: number | undefined, options: MarketForm
     const maxFractionDigits = kind === "other" && options.priceRange !== undefined
       ? 6
       : reference === undefined
-        ? getBasePriceMaxFractionDigits(kind, value) + quotedUnitDigits
+        ? getBasePriceMaxFractionDigits(kind, value, options.currency) + quotedUnitDigits
         : marketPriceFractionDigitCeiling(reference, options) + quotedUnitDigits;
     let digits = Math.max(0, Math.min(fixedFractionDigits, maxFractionDigits));
     // A live price keeps its instrument's decimals, but a trade finer than the
@@ -370,10 +375,10 @@ export function formatMarketPrice(value: number | undefined, options: MarketForm
   }
   const minimumFractionDigits = Math.max(
     0,
-    Math.min(options.minimumFractionDigits ?? 0, getBasePriceMaxFractionDigits(kind, value)),
+    Math.min(options.minimumFractionDigits ?? 0, getBasePriceMaxFractionDigits(kind, value, options.currency)),
   );
   const maxFractionDigits = Math.max(
-    getPriceMaxFractionDigits(kind, value, options.priceRange, options.precisionOffset ?? 0, quotedUnitDigits),
+    getPriceMaxFractionDigits(kind, value, options.priceRange, options.precisionOffset ?? 0, quotedUnitDigits, options.currency),
     minimumFractionDigits,
   );
   return formatPriceNumber(value, maxFractionDigits, options.maxWidth, minimumFractionDigits);
@@ -390,7 +395,7 @@ export function formatMarketCost(value: number | undefined, options: MarketForma
     return `${formatMarketCost(value, { ...options, priceBasis: "per-unit", maxWidth })}% par`;
   }
   const kind = resolveAssetDisplayKind(options);
-  const maxFractionDigits = getCostMaxFractionDigits(kind);
+  const maxFractionDigits = getCostMaxFractionDigits(kind, options.currency);
   const minimumFractionDigits = Math.max(0, Math.min(options.minimumFractionDigits ?? 0, maxFractionDigits));
   return formatVariableNumber(value, maxFractionDigits, options.maxWidth, minimumFractionDigits);
 }
@@ -435,14 +440,16 @@ export function formatMarketChangeWithCurrency(
     })}`;
   }
   // Cents hide the whole move of a sub-cent asset (-$0.00 for a SHIB day change).
-  if (Math.abs(value) < 0.005 && referencePrice != null && Number.isFinite(referencePrice)) {
-    const priceDigits = marketPriceFractionDigitCeiling(referencePrice, options);
-    if (priceDigits > 2 && Math.abs(value) >= 0.5 * 10 ** -priceDigits) {
+  const unitDigits = currencyPriceDigits(currency);
+  const smallestMove = 0.5 / 10 ** unitDigits;
+  if (Math.abs(value) < smallestMove && referencePrice != null && Number.isFinite(referencePrice)) {
+    const priceDigits = marketPriceFractionDigitCeiling(referencePrice, { ...options, currency });
+    if (priceDigits > unitDigits && Math.abs(value) >= 0.5 * 10 ** -priceDigits) {
       return `${value > 0 ? "+" : ""}${formatMarketPriceWithCurrency(value, currency, options)}`;
     }
   }
   // A move that rounds to zero cents is unsigned rather than -$0.00.
-  if (Math.abs(value) < 0.005) return formatCurrency(0, currency);
+  if (Math.abs(value) < smallestMove) return formatCurrency(0, currency);
   return `${value > 0 ? "+" : ""}${formatCurrency(value, currency)}`;
 }
 
@@ -455,11 +462,20 @@ export function currencyMinorDigits(currency: string | undefined): number {
   }
 }
 
+/** Decimals a money price is padded to: its minor unit up to two (USD 2, JPY 0), three for the thousandth currencies (OMR, KWD). */
+export function currencyPriceMinDigits(currency: string | undefined): number {
+  return currencyPriceDigits(currency) === 3 ? 3 : Math.min(2, currencyMinorDigits(currency));
+}
+
 /** Pads a money price to its currency's minor unit (two for USD, none for JPY),
  * so one card or column never mixes $309.9 with $339.75. Par-quoted prices are left as they are. */
 export function withCurrencyMinorDigits(options: MarketFormatOptions, currency: string | undefined): MarketFormatOptions {
   if (resolvePriceBasis(options.priceBasis, options.assetCategory) !== "per-unit") return options;
-  return { ...options, minimumFractionDigits: Math.max(options.minimumFractionDigits ?? 0, Math.min(2, currencyMinorDigits(currency))) };
+  return {
+    ...options,
+    ...(currency ? { currency } : {}),
+    minimumFractionDigits: Math.max(options.minimumFractionDigits ?? 0, currencyPriceMinDigits(currency)),
+  };
 }
 
 function positiveMagnitude(value: number | null | undefined): number | undefined {
@@ -522,7 +538,7 @@ export function stablePriceFractionDigits(context: StablePriceContext): number {
   } else if (kind === "equity" || kind === "other") {
     // A sub-unit price keeps four decimals of the major unit, pence lines
     // included; above one unit the currency's minor unit (and pence) apply.
-    digits = below(1) ? 4 : Math.min(2, currencyMinorDigits(context.currency)) + unitDigits;
+    digits = below(1) ? 4 : currencyPriceMinDigits(context.currency) + unitDigits;
   } else if (kind === "cash") {
     digits = below(10) ? 4 : 2;
   } else if (kind === "crypto") {
@@ -566,6 +582,7 @@ export function withStablePriceDigits(
   const referencePrice = quoteReferencePrice(prices);
   return {
     ...options,
+    ...(currency ? { currency } : {}),
     referencePrice,
     fixedFractionDigits: stablePriceFractionDigits({
       ...options,
@@ -599,7 +616,7 @@ export function formatMarketPriceWithCurrency(
   const numericWidth = options.maxWidth == null
     ? undefined
     : Math.max(1, options.maxWidth - sign.length - symbol.length);
-  const body = formatMarketPrice(Math.abs(value), { ...options, maxWidth: numericWidth });
+  const body = formatMarketPrice(Math.abs(value), { ...options, currency: normalizedCurrency, maxWidth: numericWidth });
   return `${hasNonZeroDigit(body) ? sign : ""}${symbol}${body}`;
 }
 
@@ -618,8 +635,9 @@ export function formatMarketCostWithCurrency(
     : Math.max(1, options.maxWidth - sign.length - symbol.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: Math.min(2, currencyMinorDigits(normalizedCurrency)),
+    minimumFractionDigits: currencyPriceMinDigits(normalizedCurrency),
     ...options,
+    currency: normalizedCurrency,
     maxWidth: numericWidth,
   });
   return `${sign}${symbol}${body}`;