gloomberb 0.15.0 → 0.15.2

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

@@ -22,6 +22,10 @@ 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;
+  /** 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. */
+  referencePrice?: number;
 }
 
 /** Current price fields use the quote's source metadata; stored cost/mark
@@ -117,6 +121,11 @@ function formatVariableNumber(
       if (fitsWidth(formatted, maxWidth)) return formatted;
     }
   }
+  // A cell too narrow for the minimum gives up decimals one at a time.
+  for (let decimals = minimumFractionDigits - 1; decimals > 0; decimals -= 1) {
+    const formatted = getNumberFormatter(decimals, decimals, false).format(value);
+    if (fitsWidth(formatted, maxWidth)) return formatted;
+  }
 
   return getNumberFormatter(0, 0, false).format(value);
 }
@@ -194,7 +203,11 @@ function formatPriceNumber(value: number, decimals: number, maxWidth: number | u
     ? "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.
+  return scientificPrice(value, maxWidth);
+}
+
+/** A constrained cell must not imply a worthless asset or unchanged price. */
+function scientificPrice(value: number, maxWidth: number | undefined): string {
   for (let precision = 4; precision >= 1; precision -= 1) {
     const scientific = Number(value.toPrecision(precision)).toExponential();
     if (fitsWidth(scientific, maxWidth)) return scientific;
@@ -310,11 +323,21 @@ export function formatMarketPrice(value: number | undefined, options: MarketForm
   const quotedUnitDigits = kind === "equity" || kind === "other" ? quotedUnitFractionDigits(options.quotedUnitDivisor) : 0;
   const fixedFractionDigits = options.fixedFractionDigits;
   if (fixedFractionDigits !== undefined) {
+    const reference = positiveMagnitude(options.referencePrice);
     const maxFractionDigits = kind === "other" && options.priceRange !== undefined
       ? 6
-      : getBasePriceMaxFractionDigits(kind, value) + quotedUnitDigits;
-    const clampedFixedFractionDigits = Math.max(0, Math.min(fixedFractionDigits, maxFractionDigits));
-    return formatVariableNumber(value, clampedFixedFractionDigits, options.maxWidth, clampedFixedFractionDigits);
+      : reference === undefined
+        ? getBasePriceMaxFractionDigits(kind, value) + 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
+    // session prices showed (a half-yen print after whole-yen closes) is not
+    // rounded to a price that never traded.
+    if (reference !== undefined) digits = Math.max(digits, writtenFractionDigits(Math.abs(value), maxFractionDigits));
+    const fitted = formatVariableNumber(value, digits, options.maxWidth, digits);
+    return hasNonZeroDigit(fitted) || Number(Math.abs(value).toFixed(digits)) === 0
+      ? fitted
+      : scientificPrice(value, options.maxWidth);
   }
   const minimumFractionDigits = Math.max(
     0,
@@ -344,6 +367,13 @@ export function formatMarketCost(value: number | undefined, options: MarketForma
 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 (options.fixedFractionDigits !== undefined) {
+    // A move at the instrument's fixed decimals: the sign always has its column,
+    // and a move that rounds to zero is unsigned (0.00, never +0.00 or -0.00).
+    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 1);
+    const body = formatMarketPrice(Math.abs(value), { ...options, maxWidth });
+    return hasNonZeroDigit(body) ? `${value > 0 ? "+" : "-"}${body}` : body;
+  }
   if (value > 0) {
     const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 1);
     return `+${formatMarketPrice(value, { ...options, maxWidth })}`;
@@ -363,6 +393,11 @@ export function formatMarketChangeWithCurrency(
 ): string {
   if (value == null || !Number.isFinite(value)) return "—";
   if (resolvePriceBasis(options.priceBasis, options.assetCategory) !== "per-unit") return formatSignedMarketPrice(value, options);
+  if (options.fixedFractionDigits !== undefined) {
+    const maxWidth = options.maxWidth == null ? undefined : Math.max(1, options.maxWidth - 1);
+    const body = formatMarketPriceWithCurrency(Math.abs(value), currency, { ...options, maxWidth });
+    return hasNonZeroDigit(body) ? `${value > 0 ? "+" : "-"}${body}` : body;
+  }
   if (resolveAssetDisplayKind(options) === "contract" || quotedUnitFractionDigits(options.quotedUnitDivisor) > 0) {
     return `${value > 0 ? "+" : ""}${formatMarketPriceWithCurrency(value, currency, {
       ...options, minimumFractionDigits: Math.max(2, options.minimumFractionDigits ?? 0),
@@ -396,6 +431,130 @@ export function withCurrencyMinorDigits(options: MarketFormatOptions, currency:
   return { ...options, minimumFractionDigits: Math.max(options.minimumFractionDigits ?? 0, Math.min(2, currencyMinorDigits(currency))) };
 }
 
+function positiveMagnitude(value: number | null | undefined): number | undefined {
+  return value != null && Number.isFinite(value) && value !== 0 ? Math.abs(value) : undefined;
+}
+
+function hasNonZeroDigit(text: string): boolean {
+  return /[1-9]/.test(text);
+}
+
+/** Decimals a price was written with, ignoring binary noise: 6012.25 is 2, so
+ * is a provider's float32 157.8800048828125, and a change of
+ * 0.00004999999999988347 is 5. */
+function writtenFractionDigits(value: number, cap: number): number {
+  const float32 = Math.fround(value) === value;
+  for (let digits = 0; digits < cap; digits += 1) {
+    const written = Number(value.toFixed(digits));
+    if (Math.abs(written - value) <= 1e-9 * value) return digits;
+    if (float32 && Math.fround(written) === value) return digits;
+  }
+  return cap;
+}
+
+const OPTION_CONTRACT_TYPES = new Set(["OPT", "OPTION", "OPTIONS", "FOP"]);
+
+export interface StablePriceContext extends AssetDisplayContext {
+  /** The price's currency; its minor unit sets an equity's decimals (USD 2, JPY 0). */
+  currency?: string;
+  quotedUnitDivisor?: number;
+  /** A price that holds still for the session, such as the previous close.
+   * Never the live price: a precision read from each tick is what makes the
+   * digits jump. */
+  referencePrice?: number;
+  /** Session-fixed prices as the feed wrote them (previous close, open).
+   * Their decimals can ask for more than the default, such as a half-yen
+   * Tokyo line. */
+  sessionPrices?: readonly (number | null | undefined)[];
+}
+
+/**
+ * The decimals a live price keeps for its instrument, whatever the tick: an
+ * equity above $1 always shows cents (150.10, not 150.1), and a coin, pair or
+ * contract takes its count from the reference price, never from the latest
+ * trade, so crossing $100 or 1.0000 on a tick changes nothing. A floor per kind
+ * is raised to the decimals the reference and session prices were written
+ * with (a half-yen close, a 5-decimal FX feed), up to the kind's ceiling.
+ * Changes, bid, ask and ranges of the same instrument use the same count.
+ */
+export function stablePriceFractionDigits(context: StablePriceContext): number {
+  const reference = positiveMagnitude(context.referencePrice);
+  const kind = resolveAssetDisplayKind(context);
+  const unitDigits = kind === "equity" || kind === "other" ? quotedUnitFractionDigits(context.quotedUnitDivisor) : 0;
+  const ceiling = reference === undefined ? 8 : marketPriceFractionDigitCeiling(reference, context) + unitDigits;
+  const below = (limit: number) => reference !== undefined && reference < limit;
+  // Four significant digits for a sub-unit price.
+  const subUnitDigits = reference === undefined ? 4 : Math.min(8, Math.max(4, 3 - Math.floor(Math.log10(reference))));
+  let digits: number;
+  if (resolvePriceBasis(context.priceBasis, context.assetCategory) === "percent-of-par") {
+    digits = 2;
+  } 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;
+  } else if (kind === "cash") {
+    digits = below(10) ? 4 : 2;
+  } else if (kind === "crypto") {
+    digits = below(1) ? subUnitDigits : below(100) ? 4 : 2;
+  } else if (kind === "contract") {
+    const type = normalizeType(context.contractSecType || context.assetCategory);
+    digits = OPTION_CONTRACT_TYPES.has(type) || !CONTRACT_TYPES.has(type) || !below(1) ? 2 : subUnitDigits;
+  } else {
+    digits = 2;
+  }
+  if (kind !== "crypto" && reference !== undefined) digits = Math.max(digits, tinyPriceFractionDigits(reference));
+  for (const price of context.sessionPrices ?? []) {
+    const magnitude = positiveMagnitude(price);
+    if (magnitude !== undefined) digits = Math.max(digits, writtenFractionDigits(magnitude, ceiling));
+  }
+  return digits;
+}
+
+type LiveQuotePrices = Pick<Quote, "price" | "previousClose" | "regularClose" | "open">;
+
+/** The session-fixed price a quote's decimals are chosen from. */
+export function quoteReferencePrice(quote: Partial<LiveQuotePrices> | null | undefined): number | undefined {
+  return positiveMagnitude(quote?.previousClose)
+    ?? positiveMagnitude(quote?.regularClose)
+    ?? positiveMagnitude(quote?.open)
+    ?? positiveMagnitude(quote?.price);
+}
+
+/**
+ * Pins a live price's options to its instrument's decimals (see
+ * stablePriceFractionDigits). `prices` supplies the session-fixed prices, from
+ * the quote when there is one or a stored mark when there is not.
+ */
+export function withStablePriceDigits(
+  options: MarketFormatOptions,
+  currency: string | undefined,
+  prices: Partial<LiveQuotePrices> | null | undefined,
+): MarketFormatOptions {
+  if (resolvePriceBasis(options.priceBasis, options.assetCategory) === null) return options;
+  // Without any session price, the live price can only give the magnitude.
+  const referencePrice = quoteReferencePrice(prices);
+  return {
+    ...options,
+    referencePrice,
+    fixedFractionDigits: stablePriceFractionDigits({
+      ...options,
+      currency,
+      referencePrice,
+      sessionPrices: [prices?.previousClose, prices?.regularClose, prices?.open],
+    }),
+  };
+}
+
+/** Options for a quote's live prices and changes: its instrument's fixed decimals, whatever the tick. */
+export function liveQuoteFormatOptions(
+  quote: (Pick<Quote, "instrumentType" | "priceBasis" | "providerPriceDivisor"> & Partial<LiveQuotePrices>) | null | undefined,
+  currency: string | undefined,
+  fallbackAssetCategory?: string,
+  metadataInstrumentType?: string,
+): MarketFormatOptions {
+  return withStablePriceDigits(quoteFormatOptions(quote, fallbackAssetCategory, metadataInstrumentType), currency, quote);
+}
+
 export function formatMarketPriceWithCurrency(
   value: number | undefined,
   currency = "USD",
@@ -410,7 +569,7 @@ export function formatMarketPriceWithCurrency(
     ? undefined
     : Math.max(1, options.maxWidth - sign.length - symbol.length);
   const body = formatMarketPrice(Math.abs(value), { ...options, maxWidth: numericWidth });
-  return `${sign}${symbol}${body}`;
+  return `${hasNonZeroDigit(body) ? sign : ""}${symbol}${body}`;
 }
 
 export function formatMarketCostWithCurrency(

package/src/market-data/query-store.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "bun:test";
+import { QueryStore } from "./query-store";
+import type { QueryEntry } from "./result-types";
+
+function ready(value: string): QueryEntry<string> {
+  return {
+    phase: "ready",
+    data: value,
+    lastGoodData: value,
+    source: "test",
+    fetchedAt: 0,
+    staleAt: null,
+    error: null,
+    attempts: [],
+  };
+}
+
+describe("QueryStore retention", () => {
+  it("keeps every entry when no ceiling is configured", () => {
+    const store = new QueryStore<string>(() => {});
+    for (let index = 0; index < 500; index += 1) store.set(`k${index}`, ready(`v${index}`));
+    expect(store.size).toBe(500);
+  });
+
+  it("drops the oldest unwatched entries once past the ceiling", () => {
+    const store = new QueryStore<string>(() => {}, { maxRetainedEntries: 3 });
+    for (const key of ["a", "b", "c", "d", "e"]) store.set(key, ready(key));
+
+    expect(store.size).toBe(3);
+    expect(store.get("a").phase).toBe("idle");
+    expect(store.get("b").phase).toBe("idle");
+    expect(store.get("e").data).toBe("e");
+  });
+
+  it("never evicts a key a pane is watching, even past the ceiling", () => {
+    const watched = new Set(["a", "b", "c", "d"]);
+    const store = new QueryStore<string>(() => {}, {
+      maxRetainedEntries: 2,
+      isWatched: (key) => watched.has(key),
+    });
+    for (const key of ["a", "b", "c", "d"]) store.set(key, ready(key));
+
+    // Four visible panes outrank a ceiling of two: blanking one would be worse
+    // than holding the memory.
+    expect(store.size).toBe(4);
+
+    // Once they unmount, the next write collects them.
+    watched.clear();
+    store.set("e", ready("e"));
+    expect(store.size).toBe(2);
+    expect(store.get("e").data).toBe("e");
+  });
+
+  it("evicts around watched keys rather than stopping at the first one", () => {
+    const store = new QueryStore<string>(() => {}, {
+      maxRetainedEntries: 2,
+      isWatched: (key) => key === "a",
+    });
+    for (const key of ["a", "b", "c", "d"]) store.set(key, ready(key));
+
+    expect(store.size).toBe(2);
+    expect(store.get("a").data).toBe("a");
+    expect(store.get("d").data).toBe("d");
+  });
+
+  it("reports every evicted key so derived caches can drop it too", () => {
+    const evicted: string[] = [];
+    const store = new QueryStore<string>(() => {}, {
+      maxRetainedEntries: 2,
+      onEvict: (key) => evicted.push(key),
+    });
+    for (const key of ["a", "b", "c", "d"]) store.set(key, ready(key));
+
+    expect(evicted).toEqual(["a", "b"]);
+  });
+
+  it("returns an evicted key to idle so the next read refetches", () => {
+    const store = new QueryStore<string>(() => {}, { maxRetainedEntries: 1 });
+    store.set("a", ready("a"));
+    store.set("b", ready("b"));
+
+    const evicted = store.get("a");
+    expect(evicted.phase).toBe("idle");
+    expect(evicted.data).toBeNull();
+    expect(evicted.lastGoodData).toBeNull();
+  });
+});

package/src/market-data/query-store.ts

@@ -1,16 +1,35 @@
 import type { QueryEntry } from "./result-types";
 import { createIdleEntry } from "./result-types";
 
-export class QueryStore<T> {
-  private readonly entries = new Map<string, QueryEntry<T>>();
+/** How many entries a store keeps once nothing is watching them. */
+export interface QueryStoreRetention {
+  /**
+   * Entries to keep once nothing on screen is watching them. Browsing a ticker
+   * adds an entry to every store its panes touch, and nothing used to remove
+   * one, so a session that researched a few hundred symbols held every price
+   * history, statement set and filing it had ever shown until exit (#452).
+   */
+  maxRetainedEntries?: number;
+  /** True while a mounted pane is subscribed to this key, so it must be kept. */
+  isWatched?: (key: string) => boolean;
+  /** Called for each evicted key, for anything derived from it and keyed alike. */
+  onEvict?: (key: string) => void;
+}
 
+export interface QueryStoreOptions<T> extends QueryStoreRetention {
   /**
-   * `project` sees every entry before it is stored, so a store can overlay a
-   * newer source (a streamed FX rate over a loaded one) on whatever writes it.
+   * Sees every entry before it is stored, so a store can overlay a newer
+   * source (a streamed FX rate over a loaded one) on whatever writes it.
    */
+  project?: (key: string, entry: QueryEntry<T>) => QueryEntry<T>;
+}
+
+export class QueryStore<T> {
+  private readonly entries = new Map<string, QueryEntry<T>>();
+
   constructor(
     private readonly onChange: (key: string) => void,
-    private readonly project?: (key: string, entry: QueryEntry<T>) => QueryEntry<T>,
+    private readonly options: QueryStoreOptions<T> = {},
   ) {}
 
   get(key: string): QueryEntry<T> {
@@ -18,15 +37,53 @@ export class QueryStore<T> {
   }
 
   set(key: string, entry: QueryEntry<T>): void {
-    this.entries.set(key, this.project ? this.project(key, entry) : entry);
+    this.store(key, entry);
     this.onChange(key);
   }
 
   update(key: string, updater: (current: QueryEntry<T>) => QueryEntry<T>): QueryEntry<T> {
-    const updated = updater(this.get(key));
-    const next = this.project ? this.project(key, updated) : updated;
-    this.entries.set(key, next);
+    const next = this.store(key, updater(this.get(key)));
     this.onChange(key);
     return next;
   }
+
+  /**
+   * Only a new key can push the store over its ceiling, so only a new key
+   * runs the eviction scan. Streamed updates rewrite existing keys many times
+   * a second and skip it.
+   */
+  private store(key: string, entry: QueryEntry<T>): QueryEntry<T> {
+    const next = this.options.project ? this.options.project(key, entry) : entry;
+    const added = !this.entries.has(key);
+    this.entries.set(key, next);
+    if (added) this.evictUnwatched();
+    return next;
+  }
+
+  /** Entries held right now. */
+  get size(): number {
+    return this.entries.size;
+  }
+
+  /**
+   * Drop the oldest entries no pane is watching. A watched key is never
+   * evicted, so this cannot blank a visible pane; an evicted key returns to
+   * idle and refetches the next time something asks for it.
+   *
+   * ponytail: oldest-first over insertion order rather than true LRU. Reading
+   * an entry does not renew it, so a key held open only by a long read with no
+   * subscription can still age out and refetch. Move to touch-on-read if that
+   * refetch ever shows up in a profile.
+   */
+  private evictUnwatched(): void {
+    const limit = this.options.maxRetainedEntries;
+    if (limit === undefined || this.entries.size <= limit) return;
+    const isWatched = this.options.isWatched;
+    for (const key of [...this.entries.keys()]) {
+      if (this.entries.size <= limit) return;
+      if (isWatched?.(key)) continue;
+      this.entries.delete(key);
+      this.options.onEvict?.(key);
+    }
+  }
 }

package/src/plugins/builtin/alerts/format.ts

@@ -39,9 +39,10 @@ export function formatAlertDistance(alert: AlertRule): string {
   }
   const percent = ((alert.targetPrice - currentPrice) / currentPrice) * 100;
   if (!Number.isFinite(percent)) return "-";
-  const abs = Math.abs(percent);
-  const decimals = abs < 10 ? 1 : 0;
-  return `${percent >= 0 ? "+" : ""}${percent.toFixed(decimals)}%`;
+  // One decimal at any distance, so the column holds still as the price moves;
+  // a distance that rounds to zero is unsigned (0.0%, never -0.0%).
+  const fixed = Math.abs(percent).toFixed(1);
+  return `${/[1-9]/.test(fixed) ? (percent > 0 ? "+" : "-") : ""}${fixed}%`;
 }
 
 export function formatQuoteChecked(alert: AlertRule): string {

package/src/plugins/builtin/analytics/display.ts

@@ -1,5 +1,5 @@
 import { colors } from "../../../theme/colors";
-import { formatCompact } from "../../../utils/format";
+import { formatCompactAmount } from "../../../utils/format";
 
 export function sharpeColor(sharpe: number): string {
   if (sharpe > 1) return colors.positive;
@@ -25,9 +25,9 @@ export function betaColor(beta: number): string {
   return colors.positive;
 }
 
+// P&L moves with every streamed price; fixed decimals keep the percent detail after it still.
 export function formatSignedCompact(value: number | null): string {
-  if (value == null || !Number.isFinite(value)) return "—";
-  return `${value >= 0 ? "+" : ""}${formatCompact(value)}`;
+  return formatCompactAmount(value ?? undefined, { signed: true });
 }
 
 export function formatWeight(weight: number | null): string {

package/src/plugins/builtin/analytics/index.test.tsx

@@ -224,9 +224,9 @@ describe("PortfolioAnalyticsPane", () => {
       });
       for (let index = 0; index < 6; index++) await flushFrame();
       const frame = testSetup!.captureCharFrame();
-      expect(frame).toContain(currency ? "Net Liq       15k" : "Net Liq       —");
+      expect(frame).toContain(currency ? "Net Liq       15.0k" : "Net Liq       —");
       expect(frame).toContain(currency ? "Cash          13.5k" : "Cash          —");
-      expect(frame).not.toContain("Net Liq       20k");
+      expect(frame).not.toContain("Net Liq       20.0k");
       if (currency) expect(requested).toContain("CAD");
       else expect(frame).toContain("FX            Unavailable");
     });
@@ -253,17 +253,17 @@ describe("PortfolioAnalyticsPane", () => {
     for (let index = 0; index < 6; index++) await flushFrame();
     const frame = testSetup!.captureCharFrame();
     if (withAccount) {
-      expect(frame).toContain("Net Liq       6k");
-      expect(frame).toContain("Cash          6k");
+      expect(frame).toContain("Net Liq       6.0k");
+      expect(frame).toContain("Cash          6.0k");
     } else {
       expect(frame).not.toContain("Net Liq");
       expect(frame).not.toContain("Cash");
       expect(frame).not.toContain("Val           0");
-      expect(frame).not.toContain("P&L           +0");
+      expect(frame).not.toContain("P&L           0");
     }
     expect(frame).toContain("Broker return +10.00%");
-    expect(frame).not.toContain("Day           +0");
-    expect(frame).not.toContain("P&L           +0");
+    expect(frame).not.toContain("Day           0");
+    expect(frame).not.toContain("P&L           0");
     expect(frame).toContain("PORTFOLIO HISTORY");
     expect(frame).toContain("Value (USD)");
     expect(frame).not.toContain("CURRENT-WEIGHT BASKET ESTIMATES");
@@ -284,8 +284,8 @@ describe("PortfolioAnalyticsPane", () => {
     const frame = testSetup!.captureCharFrame();
     expect(frame).toContain("Source        Cached");
     expect(frame).not.toContain("Val           0");
-    expect(frame).not.toContain("Day           +0");
-    expect(frame).not.toContain("P&L           +0");
+    expect(frame).not.toContain("Day           0");
+    expect(frame).not.toContain("P&L           0");
     expect(frame).not.toContain("Net Liq");
     expect(frame).not.toContain("Cash");
   });
@@ -317,7 +317,7 @@ describe("PortfolioAnalyticsPane", () => {
     expect(frame).toContain("Account history unavailable.");
     expect(frame).toContain("Statement service unavailable");
     expect(frame).not.toContain("No positions");
-    expect(frame).not.toContain("P&L           +0");
+    expect(frame).not.toContain("P&L           0");
 
     await act(async () => { testSetup!.mockInput.pressArrow("left"); });
     await flushFrame();
@@ -386,7 +386,7 @@ describe("PortfolioAnalyticsPane", () => {
     expect(frame).toContain("Main Portfolio");
     expect(frame).toContain("Flex DU12345");
     expect(frame).toContain("Val           1.3k");
-    expect(frame).toContain("P&L           +250  (+25.00%)");
+    expect(frame).toContain("P&L           +250.00  (+25.00%)");
     expect(frame).toContain("CURRENT-WEIGHT BASKET ESTIMATES");
     expect(frame).toContain("Est. Sharpe");
     expect(frame).toContain("Beta (SPY)");
@@ -467,17 +467,17 @@ describe("PortfolioAnalyticsPane", () => {
     await flushFrame();
 
     const frame = testSetup!.captureCharFrame();
-    expect(frame).toContain("Net Liq       125k");
+    expect(frame).toContain("Net Liq       125.0k");
     expect(frame).toContain("Val           113.6k");
     expect(frame).toContain("Margin Lev    0.9x");
-    expect(frame).toContain("Cash          -50k");
-    expect(frame).toContain("Day           +900");
-    expect(frame).toContain("P&L           +777");
-    expect(frame).toContain("Realized      -25");
-    expect(frame).toContain("Settled       -45k");
-    expect(frame).toContain("Avail         15k");
-    expect(frame).toContain("Excess        12k");
-    expect(frame).toContain("BP            30k");
+    expect(frame).toContain("Cash          -50.0k");
+    expect(frame).toContain("Day           +900.00");
+    expect(frame).toContain("P&L           +777.00");
+    expect(frame).toContain("Realized      -25.00");
+    expect(frame).toContain("Settled       -45.0k");
+    expect(frame).toContain("Avail         15.0k");
+    expect(frame).toContain("Excess        12.0k");
+    expect(frame).toContain("BP            30.0k");
     expect(frame).toContain("As Of         Mar 26");
     expect(frame).toContain("Source        Flex Mar 26");
   });
@@ -593,8 +593,8 @@ describe("PortfolioAnalyticsPane", () => {
 
     const frame = testSetup!.captureCharFrame();
     expect(frame).toContain("Val           1.4k");
-    expect(frame).toContain("P&L           +400  (+40.00%)");
-    expect(frame).toContain("Technology               100.0%       1.4k       +400  +40.00%");
+    expect(frame).toContain("P&L           +400.00  (+40.00%)");
+    expect(frame).toContain("Technology               100.0%       1.4k    +400.00  +40.00%");
     expect(frame).not.toContain("1.3k");
   });
 });

package/src/plugins/builtin/analytics/pane-model.test.ts

@@ -74,13 +74,13 @@ test("converts every account balance while keeping leverage independent of displ
   expect(rows(1).get("margin-leverage")).toBe("1.5x");
   const converted = rows(1.2);
   expect(converted.get("margin-leverage")).toBe("1.5x");
-  expect(converted.get("net-liquidation")).toBe("120k");
-  expect(converted.get("total-value")).toBe("180k");
-  expect(converted.get("cash")).toBe("-60k");
-  expect(converted.get("settled-cash")).toBe("-48k");
-  expect(converted.get("available-funds")).toBe("36k");
-  expect(converted.get("excess-liquidity")).toBe("24k");
-  expect(converted.get("buying-power")).toBe("72k");
+  expect(converted.get("net-liquidation")).toBe("120.0k");
+  expect(converted.get("total-value")).toBe("180.0k");
+  expect(converted.get("cash")).toBe("-60.0k");
+  expect(converted.get("settled-cash")).toBe("-48.0k");
+  expect(converted.get("available-funds")).toBe("36.0k");
+  expect(converted.get("excess-liquidity")).toBe("24.0k");
+  expect(converted.get("buying-power")).toBe("72.0k");
 
   accountState.account.netLiquidation = 0;
   expect(rows(1).has("margin-leverage")).toBe(false);
@@ -103,10 +103,10 @@ test("cash-only summary uses reported account metrics and preserves explicit zer
   accountState.account.grossPositionValue = 0;
   accountState.account.dailyPnl = 0;
   accountState.account.unrealizedPnl = 0;
-  expect(rows().get("total-value")?.value).toBe("0");
+  expect(rows().get("total-value")?.value).toBe("0.00");
   expect(rows().get("margin-leverage")?.value).toBe("0.0x");
-  expect(rows().get("day-pnl")).toMatchObject({ value: "+0", detail: "(0.00%)" });
-  expect(rows().get("pnl")).toMatchObject({ value: "+0", detail: "(—)" });
+  expect(rows().get("day-pnl")).toMatchObject({ value: "0.00", detail: "(0.00%)" });
+  expect(rows().get("pnl")).toMatchObject({ value: "0.00", detail: "(—)" });
   delete accountState.account.netLiquidation;
   expect(rows().get("day-pnl")?.detail).toBe("(—)");
   expect(rows().has("margin-leverage")).toBe(false);

package/src/plugins/builtin/analytics/pane-model.ts

@@ -3,7 +3,7 @@ import { colors, priceColor } from "../../../theme/colors";
 import type { TickerFinancials, PricePoint } from "../../../types/financials";
 import type { BrokerAccount, BrokerPortfolioPerformance } from "../../../types/trading";
 import type { Portfolio, TickerRecord } from "../../../types/ticker";
-import { formatCompact, formatNumber, formatPercentRaw } from "../../../utils/format";
+import { formatCompact, formatCompactAmount, formatNumber, formatPercentRaw } from "../../../utils/format";
 import { formatRelativeAge } from "../../../utils/relative-time";
 import type { PriceHistoryIntegrity } from "../../../utils/price-history-integrity";
 import { instrumentFromTicker, type ChartRequest, type TickerInstrumentOptions } from "../../../market-data/request-types";
@@ -240,7 +240,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "net-liquidation",
       label: "Net Liq",
-      value: formatCompact(netLiquidation),
+      value: formatCompactAmount(netLiquidation),
       color: colors.text,
     });
   }
@@ -249,7 +249,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "total-value",
       label: "Val",
-      value: formatCompact(totalMarketValue),
+      value: formatCompactAmount(totalMarketValue),
       color: colors.text,
     });
   }
@@ -268,7 +268,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "cash",
       label: "Cash",
-      value: formatCompact(convertAccountValue(account.totalCashValue)),
+      value: formatCompactAmount(convertAccountValue(account.totalCashValue)),
       color: colors.text,
     });
   }
@@ -319,7 +319,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "settled-cash",
       label: "Settled",
-      value: formatCompact(convertAccountValue(account.settledCash)),
+      value: formatCompactAmount(convertAccountValue(account.settledCash)),
       color: colors.text,
     });
   }
@@ -327,7 +327,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "available-funds",
       label: "Avail",
-      value: formatCompact(convertAccountValue(account.availableFunds)),
+      value: formatCompactAmount(convertAccountValue(account.availableFunds)),
       color: colors.text,
     });
   }
@@ -335,7 +335,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "excess-liquidity",
       label: "Excess",
-      value: formatCompact(convertAccountValue(account.excessLiquidity)),
+      value: formatCompactAmount(convertAccountValue(account.excessLiquidity)),
       color: colors.text,
     });
   }
@@ -343,7 +343,7 @@ export function buildAnalyticsSummaryRows({
     rows.push({
       id: "buying-power",
       label: "BP",
-      value: formatCompact(convertAccountValue(account.buyingPower)),
+      value: formatCompactAmount(convertAccountValue(account.buyingPower)),
       color: colors.text,
     });
   }