gloomberb 0.13.2 → 0.14.0

package/src/market-data/legacy-contract.test.ts

@@ -0,0 +1,99 @@
+import { useRegularMarketSession } from "../test-support/market-session";
+import { expect, test } from "bun:test";
+import { AppPersistence } from "../data/app-persistence";
+import { AssetDataRouter } from "../sources/provider-router";
+import { createTestDataProvider } from "../test-support/data-provider";
+import { MarketDataCoordinator } from "./coordinator";
+import type { InstrumentRef } from "./request-types";
+import { buildChartKey, buildInstrumentKey, buildOptionsKey, toMarketDataContext } from "./selectors";
+import { getRouterEntityKey } from "../sources/provider-router/cache";
+
+useRegularMarketSession();
+
+const instrument = (strike: number): InstrumentRef => ({ symbol: "ACME", exchange: "NASDAQ", brokerId: "fixture", brokerInstanceId: "feed", instrument: { brokerId: "fixture", brokerInstanceId: "feed", symbol: "ACME", localSymbol: "LEGACY", secType: "OPT", currency: "USD", exchange: "SMART", lastTradeDateOrContractMonth: "20261016", right: "C", strike, multiplier: "100" } });
+const quote = (price: number) => ({ symbol: "ACME", price, currency: "USD", change: 0, changePercent: 0, lastUpdated: Date.now(), stale: false });
+
+test("coordinator quote batching and independent resource keys retain two same-symbol derivatives", async () => {
+  const calls: number[] = [];
+  const c = new MarketDataCoordinator(createTestDataProvider({ getQuote: async (_symbol, _exchange, context) => { calls.push(context!.instrument!.strike!); return quote(context!.instrument!.strike! / 10); } }));
+  const a = instrument(100); const b = instrument(110);
+  try {
+    const entries = await c.loadQuotesBatch([a, b]);
+    expect(calls.sort()).toEqual([100, 110]); expect(entries.map(e => e.data?.price)).toEqual([10, 11]);
+    expect(c.getQuoteEntry(a).data?.price).toBe(10); expect(c.getQuoteEntry(b).data?.price).toBe(11);
+    expect(buildInstrumentKey(a)).not.toBe(buildInstrumentKey(b));
+    expect(buildChartKey({ instrument: a, bufferRange: "1Y" })).not.toBe(buildChartKey({ instrument: b, bufferRange: "1Y" }));
+    expect(buildOptionsKey({ instrument: a })).not.toBe(buildOptionsKey({ instrument: b }));
+  } finally { c.destroy(); }
+});
+
+test("router fallback identity excludes old local-symbol resource while conId and public keys remain compatible", async () => {
+  const persistence = new AppPersistence(":memory:"); const calls: number[] = [];
+  const provider = createTestDataProvider({ id: "fixture-provider", getQuote: async (_s, _e, context) => { calls.push(context!.instrument!.strike!); return quote(context!.instrument!.strike! / 10); } });
+  try {
+    persistence.resources.set({ namespace: "market", kind: "quote", entityKey: "contract:LEGACY", variantKey: "exchange=NASDAQ", sourceKey: "provider:fixture-provider" }, quote(999), { cachePolicy: { staleMs: 60000, expireMs: 120000 } });
+    const firstRouter = new AssetDataRouter(provider, [], persistence.resources);
+    expect((await firstRouter.getQuote("ACME", "NASDAQ", toMarketDataContext(instrument(100)))).price).toBe(10);
+    const reopenedRouter = new AssetDataRouter(provider, [], persistence.resources);
+    expect((await reopenedRouter.getQuote("ACME", "NASDAQ", toMarketDataContext(instrument(110)))).price).toBe(11);
+    expect((await reopenedRouter.getQuote("ACME", "NASDAQ", toMarketDataContext(instrument(100)))).price).toBe(10);
+    expect(calls).toEqual([100, 110]);
+    expect(getRouterEntityKey("ACME", { ...instrument(100).instrument!, conId: 123 })).toBe("contract:123");
+    expect(getRouterEntityKey(" acme ")).toBe("ACME");
+  } finally { persistence.close(); }
+});
+
+test("chart loading never seeds another definition and options retain separate successful observations", async () => {
+  const calls: number[] = [];
+  const history = (price: number) => [{ date: new Date("2026-09-11"), close: price }];
+  let resolveHistory!: (value: ReturnType<typeof history>) => void;
+  const c = new MarketDataCoordinator(createTestDataProvider({
+    getPriceHistory: async (_symbol, _exchange, _range, context) => context!.instrument!.strike === 100
+      ? history(10) : new Promise(resolve => { resolveHistory = resolve; }),
+    getOptionsChain: async (_symbol, _exchange, _date, context) => {
+      const strike = context!.instrument!.strike!; calls.push(strike);
+      return { underlyingSymbol: "ACME", expirationDates: strike === 100 ? ["2026-10-16"] : [], calls: [], puts: [] };
+    },
+  }));
+  const a = instrument(100); const b = instrument(110);
+  try {
+    await c.loadChart({ instrument: a, bufferRange: "1Y", granularity: "range" });
+    const request = { instrument: b, bufferRange: "5Y", granularity: "range" } as const;
+    const pending = c.loadChart(request);
+    expect(c.getChartEntry(request).data).toBeNull();
+    expect(c.getChartEntry(request).lastGoodData).toBeNull();
+    resolveHistory(history(11)); expect((await pending).data?.[0]?.close).toBe(11);
+    expect((await c.loadOptions({ instrument: a })).data?.expirationDates).toEqual(["2026-10-16"]);
+    const empty = await c.loadOptions({ instrument: b });
+    expect(empty.data?.expirationDates).toEqual([]); expect(empty.error?.reasonCode).toBe("NO_DATA");
+    await c.loadOptions({ instrument: a }); await c.loadOptions({ instrument: b });
+    expect(calls).toEqual([100, 110]);
+  } finally { c.destroy(); }
+});
+
+test.each([
+  { secType: "OPT", conId: undefined }, { secType: "STK", conId: undefined },
+  { secType: "OPT", conId: 123 }, { secType: "STK", conId: 456 },
+])("symbol enrichment cannot restore unproven declared contract prices or history", ({ secType, conId }) => {
+  const persistence = new AppPersistence(":memory:");
+  const provider = createTestDataProvider({ id: "fixture-provider" });
+  const router = new AssetDataRouter(provider, [], persistence.resources);
+  const contract = { ...instrument(110).instrument!, secType, conId };
+  const target = { ...instrument(110), instrument: contract };
+  const store = (kind: string, entityKey: string, value: unknown) => persistence.resources.set(
+    { namespace: "market", kind, entityKey, variantKey: "exchange=NASDAQ", sourceKey: "provider:fixture-provider" }, value,
+    { ...(kind === "financials" ? { schemaVersion: 7 } : {}), cachePolicy: { staleMs: 60000, expireMs: 120000 } },
+  );
+  try {
+    store("quote", "ACME", quote(999));
+    store("financials", "ACME", { quote: quote(999), quoteContributions: { public: quote(999) }, quoteMetadata: { currency: "USD", instrumentType: "Common Stock" }, profile: { description: "Issuer description" }, fundamentals: { marketCap: 1000 }, annualStatements: [], quarterlyStatements: [], priceHistory: [{ date: new Date("2026-09-11"), close: 999 }] });
+    const scoped = router.getCachedFinancialsForTargets([target]).get("ACME")!;
+    expect(scoped.quote).toBeUndefined(); expect(scoped.quoteContributions).toBeUndefined(); expect(scoped.quoteMetadata).toBeUndefined(); expect(scoped.priceHistory).toEqual([]);
+    expect(scoped.profile?.description).toBe("Issuer description"); expect(scoped.fundamentals?.marketCap).toBe(1000);
+    const publicValue = router.getCachedFinancialsForTargets([{ symbol: "ACME", exchange: "NASDAQ" }]).get("ACME")!;
+    expect(publicValue.quote?.price).toBe(999); expect(publicValue.priceHistory[0]?.close).toBe(999);
+    store("quote", getRouterEntityKey("ACME", contract), quote(11));
+    const recovered = router.getCachedFinancialsForTargets([target]).get("ACME")!;
+    expect(recovered.quote?.price).toBe(11); expect(recovered.profile?.description).toBe("Issuer description");
+  } finally { persistence.close(); }
+});

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

@@ -1,9 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import {
+  quoteFormatOptions,
+  formatMarketChangeWithCurrency,
   formatMarketCost,
   formatMarketCostWithCurrency,
   formatCompactMarketPriceWithCurrency,
   formatMarketPrice,
+  formatPriceObservation,
   formatMarketPriceWithCurrency,
   formatMarketQuantity,
   formatSignedMarketPrice,
@@ -16,7 +19,9 @@ describe("resolveAssetDisplayKind", () => {
   });
 
   test("maps common broker security types", () => {
-    expect(resolveAssetDisplayKind({ assetCategory: "CRYPTO" })).toBe("crypto");
+    for (const assetCategory of ["CRYPTO", "CRYPTOCURRENCY", "Digital Currency"]) {
+      expect(resolveAssetDisplayKind({ assetCategory })).toBe("crypto");
+    }
     expect(resolveAssetDisplayKind({ assetCategory: "STK" })).toBe("equity");
     expect(resolveAssetDisplayKind({ contractSecType: "OPT" })).toBe("contract");
     expect(resolveAssetDisplayKind({ assetCategory: "FOREX" })).toBe("cash");
@@ -55,6 +60,25 @@ describe("formatMarketPrice", () => {
     expect(formatMarketPrice(0.000123456789, { assetCategory: "CRYPTO" })).toBe("0.00012346");
   });
 
+  test("scales crypto precision by magnitude instead of always spending eight decimals", () => {
+    expect(formatMarketPrice(109556.1640625, { assetCategory: "CRYPTO" })).toBe("109,556.16");
+    expect(formatMarketPrice(118531.39161566, { assetCategory: "CRYPTO" })).toBe("118,531.39");
+    expect(formatMarketPrice(3421.8843212, { assetCategory: "CRYPTO" })).toBe("3,421.88");
+    expect(formatMarketPrice(2.44190216, { assetCategory: "CRYPTO" })).toBe("2.4419");
+    expect(formatMarketPrice(0.8618999719619751, { assetCategory: "CRYPTO" })).toBe("0.86189997");
+    expect(formatMarketPrice(0.00000526, { assetCategory: "CRYPTO" })).toBe("0.00000526");
+  });
+
+  test("keeps tiny nonzero quotes, ranges and signed changes meaningful without asset metadata", () => {
+    expect(formatMarketPriceWithCurrency(0.000005100000180391362, "USD")).toBe("$0.0000051");
+    expect(formatMarketPriceWithCurrency(0.000005259999852569308, "USD")).toBe("$0.00000526");
+    expect(formatSignedMarketPrice(-0.00000015256411960863806)).toBe("-0.0000001526");
+    expect(formatMarketPrice(0.0000051, { maxWidth: 7 })).toBe("5.1e-6");
+    expect(formatMarketPrice(1.234e-25)).toBe("1.234e-25");
+    expect(formatMarketPrice(0)).toBe("0");
+    expect(formatMarketPriceWithCurrency(0, "USD")).toBe("$0");
+  });
+
   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");
@@ -114,3 +138,55 @@ describe("formatMarketPriceWithCurrency", () => {
     expect(formatMarketCostWithCurrency(50.9507, "USD", { assetCategory: "OPT", multiplier: 100 })).toBe("$50.9507");
   });
 });
+
+test("nominal quantity and percent-of-par prices retain their units in narrow existing cells", () => {
+  const options = { assetCategory: "BOND", priceBasis: "percent-of-par" as const };
+  expect(formatMarketQuantity(1000, { ...options, quantityCurrency: "EUR", maxWidth: 11 })).toBe("1k EUR face");
+  expect(formatMarketQuantity(1000, { ...options, maxWidth: 8 })).toBe("1k face");
+  expect(formatMarketPriceWithCurrency(86.359375, "EUR", { ...options, maxWidth: 9 })).toBe("86.4% par");
+  expect(formatMarketCostWithCurrency(87.742, "USD", options)).toBe("87.74% par");
+  expect(formatMarketPriceWithCurrency(86.359375, "EUR", { assetCategory: "BOND" })).toBe("—");
+});
+
+// Metadata is descriptive, while the quote declares the price convention.
+test("quote formatting uses metadata only to withhold unknown bond units", () => {
+  const unknown = quoteFormatOptions({}, "BOND", "STK");
+  expect(formatMarketPriceWithCurrency(87, "USD", unknown)).toBe("—");
+  expect(formatMarketChangeWithCurrency(1, "USD", unknown)).toBe("—");
+  const declared = quoteFormatOptions({ instrumentType: "STK" }, "BOND", "BOND");
+  expect(formatMarketPriceWithCurrency(87, "USD", declared)).toBe("$87");
+  expect(formatMarketChangeWithCurrency(-1, "USD", declared)).toBe("-$1.00");
+  const par = quoteFormatOptions({ priceBasis: "percent-of-par" }, "STK");
+  expect(formatMarketChangeWithCurrency(-1, "USD", par)).toBe("-1% par");
+});
+
+test("contract price precision does not change units, signed/zero/missing semantics, quantity or cost", () => {
+  for (const assetCategory of ["FUT", "FUTURE", "FUTURES", "FOP", "OPT"]) {
+    const options = { assetCategory };
+    expect(formatMarketPriceWithCurrency(1.17485, "USD", options)).toBe("$1.17485");
+    expect(formatMarketChangeWithCurrency(-0.0000005, "USD", options)).toBe("-$0.0000005");
+    expect(formatMarketChangeWithCurrency(0, "USD", options)).toBe("$0.00");
+    expect(formatMarketChangeWithCurrency(undefined, "USD", options)).toBe("—");
+    expect(formatMarketChangeWithCurrency(NaN, "USD", options)).toBe("—");
+    expect(formatMarketPriceWithCurrency(-37.63, "USD", options)).toBe("-$37.63");
+    expect(formatMarketChangeWithCurrency(.25, "USX", options)).toContain("USX");
+    expect(formatMarketQuantity(1.123456, options)).toBe("1.1235");
+    expect(formatMarketCost(1.123456, options)).toBe("1.1235");
+  }
+  expect(formatMarketPriceWithCurrency(259.7499, "USD", { assetCategory: "STK" })).toBe("$259.75");
+  expect(formatMarketChangeWithCurrency(1, "USD", { assetCategory: "STK" })).toBe("+$1.00");
+  expect(formatMarketChangeWithCurrency(.001, "USD", { assetCategory: "BOND" })).toBe("—");
+});
+
+test("untyped observations retain source decimals with bounded widths and missing/zero distinctions", () => {
+  expect(formatPriceObservation(-37.63001)).toBe("-37.63001");
+  expect(formatPriceObservation(0, { minimumFractionDigits: 2 })).toBe("0.00");
+  expect(formatPriceObservation(NaN)).toBe("—");
+  expect(formatPriceObservation(Infinity)).toBe("—");
+  expect(formatPriceObservation(.0123456)).toBe("0.0123456");
+  expect(formatPriceObservation(1.1602274179458618)).toBe("1.16022742");
+  expect(formatPriceObservation(.0062825, { maxWidth: 10 })).toBe("0.0062825");
+  expect(formatPriceObservation(.0000051, { maxWidth: 7 })).toBe("5.1e-6");
+  expect(formatPriceObservation(1.234e-25, { maxWidth: 10 })).toBe("1.234e-25");
+  expect(formatPriceObservation(1234567.891, { maxWidth: 8 }).length).toBeLessThanOrEqual(8);
+});

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

@@ -1,3 +1,8 @@
+import type { PriceBasis } from "../../types/instrument";
+import type { Quote } from "../../types/financials";
+import { resolvePriceBasis } from "./price-basis";
+import { formatCompact, formatCurrency } from "../../utils/format";
+
 export type AssetDisplayKind = "cash" | "crypto" | "equity" | "contract" | "other";
 
 export interface AssetDisplayContext {
@@ -5,6 +10,8 @@ export interface AssetDisplayContext {
   assetCategory?: string;
   contractSecType?: string;
   multiplier?: number;
+  priceBasis?: PriceBasis | null;
+  quantityCurrency?: string;
 }
 
 export interface MarketFormatOptions extends AssetDisplayContext {
@@ -15,9 +22,22 @@ export interface MarketFormatOptions extends AssetDisplayContext {
   fixedFractionDigits?: number;
 }
 
+/** Current price fields use the quote's source metadata; stored cost/mark
+ * conventions and independent history must not supply its missing basis. */
+export function quoteFormatOptions(
+  quote: Pick<Quote, "instrumentType" | "priceBasis"> | null | undefined,
+  fallbackAssetCategory?: string,
+  metadataInstrumentType?: string,
+): MarketFormatOptions {
+  // Separate metadata may identify a bond whose convention is unknown. It must
+  // never turn a saved bond into a monetary quote or supply a par declaration.
+  const fallback = metadataInstrumentType?.trim().toUpperCase() === "BOND" ? "BOND" : fallbackAssetCategory;
+  return { assetCategory: quote?.instrumentType?.trim() || fallback, priceBasis: quote?.priceBasis };
+}
+
 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 CRYPTO_TYPES = new Set(["CRYPTO", "CRYPTOCURRENCY", "DIGITALCURRENCY", "COIN", "TOKEN"]);
+const EQUITY_TYPES = new Set(["STK", "STOCK", "COMMONSTOCK", "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>();
@@ -112,11 +132,17 @@ function getBasePriceMaxFractionDigits(kind: AssetDisplayKind, value: number): n
     case "cash":
       return 6;
     case "crypto":
-      return 8;
+      // Sub-cent coins need eight decimals to stay distinguishable from zero,
+      // but a four-figure coin does not. Scaling the ceiling by magnitude keeps
+      // that detail where it carries information instead of surfacing the
+      // 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;
     case "contract":
-      return 4;
+      // 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;
@@ -134,6 +160,39 @@ function getAdaptivePriceFractionDigits(priceRange: number | undefined, precisio
   return Math.max(0, Math.ceil(-Math.log10(visibleStep)) + precisionOffset);
 }
 
+/** Keep four significant digits for tiny prices even when instrument metadata
+ * is absent. Decimal formatting below this floor otherwise turns real prices
+ * and day-range endpoints into identical zeroes. */
+function tinyPriceFractionDigits(value: number): number {
+  const absolute = Math.abs(value);
+  return absolute > 0 && absolute < 0.01 && Number.isFinite(absolute)
+    ? Math.max(0, 3 - Math.floor(Math.log10(absolute))) : 0;
+}
+
+function formatPriceNumber(value: number, decimals: number, maxWidth: number | undefined, minimumDecimals = 0): string {
+  const tinyDecimals = tinyPriceFractionDigits(value);
+  const rendered = tinyDecimals > 20
+    ? "0"
+    : formatVariableNumber(value, Math.max(decimals, tinyDecimals), tinyDecimals > 0 ? undefined : maxWidth, minimumDecimals);
+  if (value === 0 || !Number.isFinite(value) || (Number(rendered.replaceAll(",", "")) !== 0 && fitsWidth(rendered, maxWidth))) return rendered;
+  // A constrained cell must not imply a worthless asset or unchanged price.
+  for (let precision = 4; precision >= 1; precision -= 1) {
+    const scientific = Number(value.toPrecision(precision)).toExponential();
+    if (fitsWidth(scientific, maxWidth)) return scientific;
+  }
+  return "…";
+}
+
+/** Dated OHLC values may have no instrument or unit metadata. Display their
+ * numeric precision without treating them as equity prices or assigning units. */
+export function formatPriceObservation(
+  value: number,
+  options: Pick<MarketFormatOptions, "maxWidth" | "minimumFractionDigits"> = {},
+): string {
+  if (!Number.isFinite(value)) return "—";
+  return formatPriceNumber(value, 8, options.maxWidth, Math.max(0, Math.min(8, options.minimumFractionDigits ?? 0)));
+}
+
 function getPriceMaxFractionDigits(
   kind: AssetDisplayKind,
   value: number,
@@ -190,8 +249,8 @@ export function resolveAssetDisplayKind({
   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 (CASH_TYPES.has(normalizedType) || normalizedType.includes("FOREX") || normalizedType.includes("CURRENCY")) return "cash";
   if (EQUITY_TYPES.has(normalizedType)) return "equity";
   if (CONTRACT_TYPES.has(normalizedType)) return "contract";
   if ((multiplier ?? 1) > 1) return "contract";
@@ -200,6 +259,14 @@ export function resolveAssetDisplayKind({
 
 export function formatMarketQuantity(value: number | undefined, options: MarketFormatOptions = {}): string {
   if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  if (options.priceBasis === "percent-of-par") {
+    const suffix = `${options.quantityCurrency ? ` ${options.quantityCurrency}` : ""} face`;
+    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - suffix.length);
+    const quantity = formatMarketQuantity(value, { ...options, priceBasis: "per-unit", maxWidth });
+    const compact = formatCompact(value);
+    const numeric = fitsWidth(quantity, maxWidth) ? quantity : fitsWidth(compact, maxWidth) ? compact : formatPriceNumber(value, 0, maxWidth);
+    return `${numeric}${suffix}`;
+  }
   const kind = resolveAssetDisplayKind(options);
   const maxFractionDigits = getQuantityMaxFractionDigits(kind, value);
   return formatVariableNumber(value, maxFractionDigits, options.maxWidth);
@@ -207,6 +274,12 @@ export function formatMarketQuantity(value: number | undefined, options: MarketF
 
 export function formatMarketPrice(value: number | undefined, options: MarketFormatOptions = {}): string {
   if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const basis = resolvePriceBasis(options.priceBasis, options.assetCategory);
+  if (basis === null) return "—";
+  if (basis === "percent-of-par") {
+    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 5);
+    return `${formatMarketPrice(value, { ...options, priceBasis: "per-unit", maxWidth })}% par`;
+  }
   const kind = resolveAssetDisplayKind(options);
   const fixedFractionDigits = options.fixedFractionDigits;
   if (fixedFractionDigits !== undefined) {
@@ -224,17 +297,24 @@ export function formatMarketPrice(value: number | undefined, options: MarketForm
     getPriceMaxFractionDigits(kind, value, options.priceRange, options.precisionOffset ?? 0),
     minimumFractionDigits,
   );
-  return formatVariableNumber(value, maxFractionDigits, options.maxWidth, minimumFractionDigits);
+  return formatPriceNumber(value, maxFractionDigits, options.maxWidth, minimumFractionDigits);
 }
 
 export function formatMarketCost(value: number | undefined, options: MarketFormatOptions = {}): string {
   if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  const basis = resolvePriceBasis(options.priceBasis, options.assetCategory);
+  if (basis === null) return "—";
+  if (basis === "percent-of-par") {
+    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 5);
+    return `${formatMarketCost(value, { ...options, priceBasis: "per-unit", maxWidth })}% par`;
+  }
   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 (resolvePriceBasis(options.priceBasis, options.assetCategory) === null) return "—";
   if (value > 0) {
     const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 1);
     return `+${formatMarketPrice(value, { ...options, maxWidth })}`;
@@ -242,12 +322,25 @@ export function formatSignedMarketPrice(value: number | undefined, options: Mark
   return formatMarketPrice(value, options);
 }
 
+/** Preserve ordinary monetary change formatting while retaining declared par units. */
+export function formatMarketChangeWithCurrency(value: number | undefined, currency: string, options: MarketFormatOptions = {}): string {
+  if (value == null || !Number.isFinite(value)) return "—";
+  if (resolvePriceBasis(options.priceBasis, options.assetCategory) !== "per-unit") return formatSignedMarketPrice(value, options);
+  if (resolveAssetDisplayKind(options) === "contract") {
+    return `${value > 0 ? "+" : ""}${formatMarketPriceWithCurrency(value, currency, {
+      ...options, minimumFractionDigits: Math.max(2, options.minimumFractionDigits ?? 0),
+    })}`;
+  }
+  return `${value > 0 ? "+" : ""}${formatCurrency(value, currency)}`;
+}
+
 export function formatMarketPriceWithCurrency(
   value: number | undefined,
   currency = "USD",
   options: MarketFormatOptions = {},
 ): string {
   if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  if (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);
@@ -264,6 +357,7 @@ export function formatMarketCostWithCurrency(
   options: MarketFormatOptions = {},
 ): string {
   if (value === undefined || value === null || Number.isNaN(value)) return "—";
+  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);

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

@@ -153,6 +153,18 @@ function usSessionState(timestampMs: number): UsSessionState {
   return "POSTPOST";
 }
 
+/** Provider session labels may outlive the active session they described. */
+export function activeUsMarketSession(now: number): "PRE" | "REGULAR" | "POST" | null {
+  if (!Number.isFinite(new Date(now).getTime())) return null;
+  const session = usSessionState(now);
+  return session === "PRE" || session === "REGULAR" || session === "POST" ? session : null;
+}
+
+export function activeUsExtendedHoursSession(now: number): "PRE" | "POST" | null {
+  const session = activeUsMarketSession(now);
+  return session === "PRE" || session === "POST" ? session : null;
+}
+
 export function isTimestampStaleForExchangeSession(
   timestampMs: number,
   exchange?: string,
@@ -186,7 +198,7 @@ function isTimestampStaleForExchangeSessionUnsafe(
 
   if (isUsExtendedHoursExchange(canonical)) {
     const session = usSessionState(now);
-    if (session === "PRE" || session === "REGULAR" || session === "POST") {
+    if (session === "PRE" || session === "REGULAR" || session === "POST" || session === "POSTPOST") {
       return true;
     }
   }

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

@@ -0,0 +1,9 @@
+import type { PriceBasis } from "../../types/instrument";
+
+/** Legacy bond prices have no verified unit. Other existing asset contracts
+ * remain currency-per-unit unless the source explicitly declares otherwise. */
+export function resolvePriceBasis(basis: PriceBasis | null | undefined, assetCategory?: string): PriceBasis | null {
+  if (basis === "per-unit" || basis === "percent-of-par") return basis;
+  if (basis === null || assetCategory?.trim().toUpperCase() === "BOND") return null;
+  return "per-unit";
+}

package/src/market-data/market/status.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { marketStateCountdown } from "./status";
+import { getActiveQuoteDisplay, marketStateCountdown } from "./status";
 
 describe("marketStateCountdown", () => {
   test("adds precision as the US session boundary approaches", () => {
@@ -10,3 +10,17 @@ describe("marketStateCountdown", () => {
     expect(marketStateCountdown("REGULAR", Date.parse("2026-08-18T19:50:42Z"))).toBe("9m 18s");
   });
 });
+
+
+test("active after-hours price keeps daily change against previous close, including a regular-only primary quote", () => {
+  const quote = { symbol: "NVDA", currency: "USD", price: 218.36, change: -5.31, changePercent: -2.374,
+    previousClose: 223.67, marketState: "POST" as const, postMarketPrice: 218.47,
+    postMarketChange: 0.11, postMarketChangePercent: 0.0503755266532, lastUpdated: 1789072245412 };
+  const active = getActiveQuoteDisplay(quote)!;
+  expect(active.price).toBe(218.47);
+  expect(active.change).toBeCloseTo(-5.2, 8);
+  expect(active.changePercent).toBeCloseTo(-2.324853578933245, 8);
+  for (const previousClose of [undefined, 0, Number.NaN]) {
+    expect(getActiveQuoteDisplay({ ...quote, previousClose })).toEqual({ price: 218.47, change: undefined, changePercent: undefined });
+  }
+});

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

@@ -16,8 +16,8 @@ const CLOSING_COUNTDOWN_WINDOW_SECONDS = 60 * 60;
 
 export interface ActiveQuoteDisplay {
   price: number;
-  change: number;
-  changePercent: number;
+  change?: number;
+  changePercent?: number;
 }
 
 export function marketStateLabel(state: MarketState): string {
@@ -85,12 +85,13 @@ function isClosedMarketState(state?: MarketState): boolean {
 }
 
 /** Closed prices are final snapshots, so they should not look live or directional. */
-export function marketPriceColor(change: number, state?: MarketState): string {
-  return isClosedMarketState(state) ? colors.textDim : priceColor(change);
+export function marketPriceColor(change: number | undefined, state?: MarketState): string {
+  return change == null || isClosedMarketState(state) ? colors.textDim : priceColor(change);
 }
 
 /** Preserve a closed session's direction while visually distinguishing it from a live move. */
-export function marketChangeColor(change: number, state?: MarketState): string {
+export function marketChangeColor(change: number | undefined, state?: MarketState): string {
+  if (change == null) return colors.textDim;
   const directionalColor = priceColor(change);
   if (!isClosedMarketState(state) || change === 0) return directionalColor;
   return blendHex(directionalColor, colors.textDim, CLOSED_CHANGE_MUTING_RATIO);
@@ -104,7 +105,7 @@ export function exchangeShortName(exchangeName?: string, fullExchangeName?: stri
   const map: Record<string, string> = {
     NMS: "NASDAQ", NGM: "NASDAQ", NCM: "NASDAQ", NAS: "NASDAQ",
     NYQ: "NYSE", NYS: "NYSE",
-    PCX: "AMEX", ASE: "AMEX",
+    PCX: "ARCA", NYSEArca: "ARCA", "NYSE Arca": "ARCA", ASE: "AMEX",
     HKG: "HKEX",
     TYO: "TYO",
     LSE: "LSE",
@@ -126,22 +127,17 @@ export function exchangeShortName(exchangeName?: string, fullExchangeName?: stri
 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,
-    };
+    return { price: quote.preMarketPrice, change: quote.preMarketChange, changePercent: quote.preMarketChangePercent };
   }
-  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
-    return {
-      price: quote.postMarketPrice,
-      change: quote.postMarketChange ?? 0,
-      changePercent: quote.postMarketChangePercent ?? 0,
-    };
+  const extendedPrice = (quote.marketState === "POST" || quote.marketState === "POSTPOST") ? quote.postMarketPrice : undefined;
+  if (extendedPrice != null) {
+    // Generic quote/day-P&L views use the daily reference, while the separate
+    // extended-hours row uses the completed regular session as its reference.
+    const previousClose = quote.previousClose;
+    const change = previousClose != null && Number.isFinite(previousClose) && previousClose > 0
+      ? extendedPrice - previousClose : undefined;
+    return { price: extendedPrice, change,
+      changePercent: change != null ? (change / previousClose!) * 100 : undefined };
   }
-  return {
-    price: quote.price,
-    change: quote.change,
-    changePercent: quote.changePercent,
-  };
+  return { price: quote.price, change: quote.change, changePercent: quote.changePercent };
 }

package/src/market-data/performance.ts

@@ -1,4 +1,5 @@
 import type { PricePoint, Quote } from "../types/financials";
+import { pricePointIntegrity } from "../utils/price-history-integrity";
 
 export interface PriceReturnHorizon {
   id: string;
@@ -11,6 +12,7 @@ export interface PriceReturnField {
   id: string;
   label: string;
   value: number | null;
+  unavailableReason?: "inconsistent-ohlc";
 }
 
 export const PRICE_RETURN_HORIZONS: PriceReturnHorizon[] = [
@@ -31,7 +33,7 @@ function normalizePriceReturnHistory(points: readonly PricePoint[]): PricePoint[
   const byTimestamp = new Map<number, PricePoint>();
   for (const point of points) {
     const date = coercePointDate(point.date as Date | string | number);
-    if (!date || !Number.isFinite(point.close)) continue;
+    if (!date || (!Number.isFinite(point.close) && !pricePointIntegrity(point))) continue;
     byTimestamp.set(date.getTime(), { ...point, date });
   }
   return [...byTimestamp.entries()]
@@ -77,8 +79,18 @@ export function computePriceReturnForHorizon(
   points: readonly PricePoint[],
   horizon: PriceReturnHorizon,
 ): number | null {
+  return priceReturnForHorizon(points, horizon).value;
+}
+
+function priceReturnForHorizon(
+  points: readonly PricePoint[],
+  horizon: PriceReturnHorizon,
+): Pick<PriceReturnField, "value" | "unavailableReason"> {
   const history = normalizePriceReturnHistory(points);
-  if (history.length < 2) return null;
+  if (history.length < 2) return {
+    value: null,
+    ...(history.some(pricePointIntegrity) ? { unavailableReason: "inconsistent-ohlc" as const } : {}),
+  };
 
   const latest = history.at(-1)!;
   const cutoff = subtractHorizon(latest.date, horizon);
@@ -92,9 +104,12 @@ export function computePriceReturnForHorizon(
     }
   }
 
-  if (!baseline || !Number.isFinite(baseline.close) || baseline.close === 0) return null;
-  if (!Number.isFinite(latest.close)) return null;
-  return (latest.close - baseline.close) / baseline.close;
+  if (history.some((point) => point.date >= (baseline?.date ?? cutoff) && pricePointIntegrity(point))) {
+    return { value: null, unavailableReason: "inconsistent-ohlc" };
+  }
+  if (!baseline || !Number.isFinite(baseline.close) || baseline.close === 0) return { value: null };
+  if (!Number.isFinite(latest.close)) return { value: null };
+  return { value: (latest.close - baseline.close) / baseline.close };
 }
 
 export function buildPriceReturnFields(
@@ -104,6 +119,6 @@ export function buildPriceReturnFields(
   return horizons.map((horizon) => ({
     id: horizon.id,
     label: horizon.label,
-    value: computePriceReturnForHorizon(points, horizon),
+    ...priceReturnForHorizon(points, horizon),
   }));
 }

package/src/market-data/portfolio-financials.ts

@@ -0,0 +1,27 @@
+import type { TickerFinancials } from "../types/financials";
+import type { TickerRecord } from "../types/ticker";
+import { instrumentFromTicker, type TickerInstrumentOptions } from "./request-types";
+
+export function buildPortfolioFinancialsMap(
+  portfolioTickers: TickerRecord[],
+  cachedFinancials: Map<string, TickerFinancials>,
+  marketFinancials: Map<string, TickerFinancials>,
+  options: TickerInstrumentOptions = {},
+): Map<string, TickerFinancials> {
+  const result = new Map<string, TickerFinancials>();
+  for (const ticker of portfolioTickers) {
+    const symbol = ticker.metadata.ticker;
+    const cached = cachedFinancials.get(symbol);
+    const instrument = instrumentFromTicker(ticker, symbol, options);
+    if (cached) {
+      // The symbol-only app cache cannot establish a broker price's contract.
+      const ambiguousPrice = options.portfolioId && (!instrument || instrument.brokerId || ticker.metadata.broker_contracts?.length);
+      result.set(symbol, ambiguousPrice
+        ? { ...cached, quote: undefined, priceHistory: [] }
+        : cached);
+    }
+    const scoped = marketFinancials.get(symbol);
+    if (scoped) result.set(symbol, instrument ? scoped : { ...scoped, quote: undefined, priceHistory: [] });
+  }
+  return result;
+}