gloomberb 0.15.0 → 0.15.1

package/src/components/ticker/badge/format.ts

@@ -1,4 +1,4 @@
-import { formatMarketPriceWithCurrency } from "../../../market-data/market/format";
+import { formatMarketPriceWithCurrency, liveQuoteFormatOptions } from "../../../market-data/market/format";
 import type { Quote } from "../../../types/financials";
 import { displayWidth } from "../../../utils/format";
 
@@ -12,13 +12,11 @@ export type TickerBadgeStatus = "loading" | "ready" | "ambiguous";
 /** Padding inside the chip plus the gap that separates it from the next one. */
 export const TICKER_BADGE_CHROME_WIDTH = 3;
 
+/** One decimal on every tick, so a chip does not narrow when the move lands on a whole percent. */
 export function formatTickerBadgeChange(changePercent: number): string {
-  const rounded = Math.round(changePercent * 10) / 10;
-  const normalized = Object.is(rounded, -0) ? 0 : rounded;
-  if (normalized === 0) return "0%";
-  const abs = Math.abs(normalized);
-  const body = Number.isInteger(abs) ? abs.toFixed(0) : abs.toFixed(1);
-  return `${normalized > 0 ? "+" : "-"}${body}%`;
+  const body = Math.abs(changePercent).toFixed(1);
+  if (!/[1-9]/.test(body)) return `${body}%`;
+  return `${changePercent > 0 ? "+" : "-"}${body}%`;
 }
 
 export interface TickerBadgeTextOptions {
@@ -48,10 +46,14 @@ function tickerBadgeTextCandidates({
   const quoteForDisplay = liveQuote ? quote : null;
   const candidates: string[] = [];
   if (hovered && quoteForDisplay) {
-    candidates.push(`${symbol} ${formatMarketPriceWithCurrency(quoteForDisplay.price, quoteForDisplay.currency, { minimumFractionDigits: 2 })}`);
+    candidates.push(`${symbol} ${formatMarketPriceWithCurrency(
+      quoteForDisplay.price,
+      quoteForDisplay.currency,
+      liveQuoteFormatOptions(quoteForDisplay, quoteForDisplay.currency),
+    )}`);
   }
   if (liveQuote) {
-    if (status === "ready" && quoteForDisplay) {
+    if (status === "ready" && quoteForDisplay && Number.isFinite(quoteForDisplay.changePercent)) {
       candidates.push(`${symbol} ${formatTickerBadgeChange(quoteForDisplay.changePercent)}`);
     } else if (status === "loading") {
       candidates.push(`${symbol} \u2026`);

package/src/components/ticker/badge/text.test.tsx

@@ -44,7 +44,7 @@ describe("TickerBadgeText", () => {
 
     await testSetup.renderOnce();
 
-    expect(testSetup.captureCharFrame()).toContain("TSLA -5%");
+    expect(testSetup.captureCharFrame()).toContain("TSLA -5.0%");
   });
 
   test("falls back to the raw token when resolution failed", async () => {
@@ -63,7 +63,7 @@ describe("TickerBadgeText", () => {
 
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("$TSLA");
-    expect(frame).not.toContain("TSLA -5%");
+    expect(frame).not.toContain("TSLA -5.0%");
   });
 
   test("opens the Ticker Research pane when a badge is clicked", async () => {
@@ -82,8 +82,8 @@ describe("TickerBadgeText", () => {
     await testSetup.renderOnce();
 
     const lines = testSetup.captureCharFrame().split("\n");
-    const row = lines.findIndex((line) => line.includes("TSLA -5%"));
-    const col = lines[row]?.indexOf("TSLA -5%") ?? -1;
+    const row = lines.findIndex((line) => line.includes("TSLA -5.0%"));
+    const col = lines[row]?.indexOf("TSLA -5.0%") ?? -1;
 
     expect(row).toBeGreaterThanOrEqual(0);
     expect(col).toBeGreaterThanOrEqual(0);
@@ -112,7 +112,7 @@ describe("TickerBadgeText", () => {
 
     const frame = testSetup.captureCharFrame();
     expect(frame).toContain("https://example.com");
-    expect(frame).toContain("TSLA -5%");
+    expect(frame).toContain("TSLA -5.0%");
   });
 
   test("renders usernames as clickable tags when a username opener is provided", async () => {
@@ -186,7 +186,7 @@ describe("TickerBadgeText", () => {
 
     expect(firstRow).toBeGreaterThanOrEqual(0);
     expect(secondRow).toBeGreaterThan(firstRow);
-    expect(lines[firstRow]).toContain("TSLA -5%");
+    expect(lines[firstRow]).toContain("TSLA -5.0%");
   });
 
   test("opens detected links without trailing punctuation when clicked", async () => {

package/src/core/state/app/state.ts

@@ -41,9 +41,14 @@ export function appReducer(state: AppState, action: AppAction): AppState {
   if (layoutState) return layoutState;
 
   switch (action.type) {
-    case "SET_CONFIG":
+    case "SET_CONFIG": {
+      // A config that leaves the layouts alone (a broker sync, a setting) keeps
+      // the layout undo history; one that replaces them starts it over.
+      const sameLayouts = action.config.layout === state.config.layout
+        && action.config.layouts === state.config.layouts
+        && action.config.activeLayoutIndex === state.config.activeLayoutIndex;
       return withFocusedPane(
-        { ...state, themePreview: null, layoutHistory: {} },
+        { ...state, themePreview: null, layoutHistory: sameLayouts ? state.layoutHistory : {} },
         action.config,
         {
           paneState: {
@@ -52,6 +57,7 @@ export function appReducer(state: AppState, action: AppAction): AppState {
           },
         },
       );
+    }
 
     case "SET_ONBOARDING_STATE":
       return {

package/src/market-data/coordinator/events.ts

@@ -49,6 +49,11 @@ export class MarketDataCoordinatorEvents {
     return this.version;
   }
 
+  /** True while a mounted pane is subscribed to this key. */
+  hasKeyListeners(key: string): boolean {
+    return (this.keyListeners.get(key)?.size ?? 0) > 0;
+  }
+
   getKeysVersion(keys: readonly string[]): number {
     let version = 0;
     for (const key of new Set(keys)) {

package/src/market-data/coordinator/index.ts

@@ -2,7 +2,7 @@ import type { CachedAssetArgs, CachedAssetMethod, CachedAssetValue, DataProvider
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../../types/financials";
 import { fetchHistoryResult, type HistoryResultRequest } from "../../sources/history-result";
 import type { ChartRequest, InstrumentRef, OptionsRequest, SecFilingsRequest } from "../request-types";
-import { QueryStore } from "../query-store";
+import { QueryStore, type QueryStoreRetention } from "../query-store";
 import type { QueryEntry } from "../result-types";
 import type { CachedQueryHandle } from "../../data/cached-query";
 import {
@@ -23,6 +23,7 @@ import { resolveTickerFinancialsQuoteState } from "../quotes/resolution";
 import { measurePerf } from "../../utils/perf-marks";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { hasUsablePriceHistory } from "../../utils/price-history";
+import { fxFreshUntil } from "../../utils/fx-market-hours";
 import {
   createBaselineChartRequest,
   createChartLoadingEntry,
@@ -90,6 +91,23 @@ const STREAM_QUOTE_BASELINE_TTL_MS = 60_000;
 const STREAM_RECEIPT_REFRESH_MS = 5_000;
 /** Keeps a long session of browsing from holding a baseline per visited symbol. */
 const STREAM_QUOTE_BASELINE_LIMIT = 256;
+/**
+ * Per-store ceiling for entries nothing on screen is watching. Quotes and FX
+ * rates stay uncapped: they are a few fields each, and a large portfolio
+ * legitimately holds thousands. The capped stores are the heavy ones, where a
+ * single entry is a full price history, statement set or filing document.
+ *
+ * A key a pane is watching is never evicted, so this only governs entries left
+ * behind by navigation. 64 keeps a deep back-and-forth instant while bounding
+ * what browsing can retain. For scale: the refresh plan in #452 asked for 17
+ * financials on a 1934-ticker install, and a session there measured 2.33 MB of
+ * resident memory per distinct ticker visited.
+ *
+ * ponytail: one number for every capped store. Filing text is the heaviest
+ * entry of the group by some margin, so give secContentStore its own smaller
+ * cap if this ceiling turns out to be too generous for it.
+ */
+const RETAINED_ENTRIES_PER_STORE = 64;
 
 // A store hands out a fresh idle entry for every key it has never seen, so
 // two idle reads of the same key must count as the same entry.
@@ -112,14 +130,30 @@ export class MarketDataCoordinator {
   private readonly cachedQueries = new Map<string, { query: CachedQueryHandle<unknown>; dispose: () => void }>();
   private readonly streamQuoteBaselines = new Map<string, { baseline: TickerFinancials | null; readAt: number }>();
 
+  private readonly retained: QueryStoreRetention = {
+    maxRetainedEntries: RETAINED_ENTRIES_PER_STORE,
+    isWatched: (key) => this.events.hasKeyListeners(key),
+  };
+
+  /**
+   * The merged financials view below is derived from a snapshot entry and keyed
+   * the same way, so it has to go when that entry does. Left behind it would
+   * hold its own normalized copy of the price history, which is the larger half
+   * of what the snapshot key costs.
+   */
+  private readonly retainedSnapshots: QueryStoreRetention = {
+    ...this.retained,
+    onEvict: (key) => { this.financialsSnapshotCache.delete(key); },
+  };
+
   private readonly quoteStore = new QueryStore<Quote>((key) => this.events.bump(key));
-  private readonly snapshotStore = new QueryStore<TickerFinancials>((key) => this.events.bump(key));
-  private readonly chartStore = new QueryStore<PricePoint[]>((key) => this.events.bump(key));
-  private readonly optionsStore = new QueryStore<OptionsChain>((key) => this.events.bump(key));
-  private readonly secFilingsStore = new QueryStore<SecFilingItem[]>((key) => this.events.bump(key));
-  private readonly secDocumentsStore = new QueryStore<SecFilingDocument[]>((key) => this.events.bump(key));
-  private readonly secContentStore = new QueryStore<string | null>((key) => this.events.bump(key));
-  private readonly articleSummaryStore = new QueryStore<string | null>((key) => this.events.bump(key));
+  private readonly snapshotStore = new QueryStore<TickerFinancials>((key) => this.events.bump(key), this.retainedSnapshots);
+  private readonly chartStore = new QueryStore<PricePoint[]>((key) => this.events.bump(key), this.retained);
+  private readonly optionsStore = new QueryStore<OptionsChain>((key) => this.events.bump(key), this.retained);
+  private readonly secFilingsStore = new QueryStore<SecFilingItem[]>((key) => this.events.bump(key), this.retained);
+  private readonly secDocumentsStore = new QueryStore<SecFilingDocument[]>((key) => this.events.bump(key), this.retained);
+  private readonly secContentStore = new QueryStore<string | null>((key) => this.events.bump(key), this.retained);
+  private readonly articleSummaryStore = new QueryStore<string | null>((key) => this.events.bump(key), this.retained);
   private readonly liveFxRates = new Map<string, { rate: number; observedAt: number; receivedAt: number }>();
   /**
    * The last rate a request loaded per currency; a streamed rate must stay
@@ -135,7 +169,7 @@ export class MarketDataCoordinator {
   private readonly fxLegsByCurrency = new Map<string, FxLeg>();
   private readonly fxStore = new QueryStore<number>(
     (key) => this.events.bump(key),
-    (key, entry) => this.projectLiveFxRate(key, entry),
+    { project: (key, entry) => this.projectLiveFxRate(key, entry) },
   );
   private readonly financialCacheStores: FinancialCacheStores = {
     quoteStore: this.quoteStore,
@@ -635,7 +669,7 @@ export class MarketDataCoordinator {
       error: null,
       asOf: live.observedAt,
       fetchedAt: Math.max(entry.fetchedAt ?? 0, live.receivedAt),
-      staleAt: live.observedAt + FX_LIVE_RATE_STALE_MS,
+      staleAt: fxFreshUntil(live.observedAt, FX_LIVE_RATE_STALE_MS),
     };
   }
 

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

@@ -11,7 +11,9 @@ import {
   formatMarketPriceWithCurrency,
   formatMarketQuantity,
   formatSignedMarketPrice,
+  liveQuoteFormatOptions,
   resolveAssetDisplayKind,
+  stablePriceFractionDigits,
 } from "./format";
 
 describe("resolveAssetDisplayKind", () => {
@@ -228,3 +230,55 @@ test("money prices pad to the currency's minor unit without cutting crypto, FX o
   expect(pad(3025, "JPY", { assetCategory: "EQUITY" })).toBe("¥3,025");
   expect(pad(87, "USD", { assetCategory: "BOND", priceBasis: "percent-of-par" })).toBe("87% par");
 });
+
+// Streamed quotes re-render several times a second. Decimals chosen from each
+// tick made 150.10 print as 150.1 and a coin crossing $100 drop two digits, so
+// the numbers visibly jumped.
+describe("live quote precision", () => {
+  const live = (values: number[], quote: Parameters<typeof liveQuoteFormatOptions>[0], currency = "USD") =>
+    values.map((value) => formatMarketPrice(value, liveQuoteFormatOptions(quote, currency)));
+
+  test("keeps one decimal count per instrument whatever the tick", () => {
+    expect(live([150.1, 150.12, 150], { instrumentType: "EQUITY", previousClose: 149.99 }))
+      .toEqual(["150.10", "150.12", "150.00"]);
+    expect(live([0.9987, 1.0012, 1.01], { instrumentType: "EQUITY", previousClose: 0.9987 }))
+      .toEqual(["0.9987", "1.0012", "1.0100"]);
+    expect(live([99.9912, 100.01, 100], { instrumentType: "CRYPTOCURRENCY", previousClose: 101 }))
+      .toEqual(["99.99", "100.01", "100.00"]);
+    expect(live([0.16234, 0.16], { instrumentType: "CRYPTOCURRENCY", previousClose: 0.16234 }))
+      .toEqual(["0.16234", "0.16000"]);
+    expect(live([1.17364, 1.17], { instrumentType: "CURRENCY", previousClose: 1.17364 }))
+      .toEqual(["1.17364", "1.17000"]);
+    expect(live([153.554, 153.5], { instrumentType: "CURRENCY", previousClose: 153.5540008544922 }, "JPY"))
+      .toEqual(["153.554", "153.500"]);
+    expect(live([6012.25, 6012.5, 6013], { instrumentType: "FUTURE", previousClose: 6010.75 }))
+      .toEqual(["6,012.25", "6,012.50", "6,013.00"]);
+    expect(live([2.35, 2.4], { instrumentType: "OPTION", previousClose: 2.35 })).toEqual(["2.35", "2.40"]);
+  });
+
+  test("takes decimals from the currency's minor unit and from session prices, never from the tick", () => {
+    expect(live([3025, 3026], { instrumentType: "EQUITY", previousClose: 3025 }, "JPY")).toEqual(["3,025", "3,026"]);
+    expect(live([2710, 2710.5], { instrumentType: "EQUITY", previousClose: 2710, open: 2708.5 }, "JPY"))
+      .toEqual(["2,710.0", "2,710.5"]);
+    expect(live([35.365, 35.1], { instrumentType: "EQUITY", previousClose: 35.32, providerPriceDivisor: 100 }, "GBP"))
+      .toEqual(["35.3650", "35.1000"]);
+    // A provider's float32 close does not ask for its binary tail.
+    expect(stablePriceFractionDigits({ assetCategory: "FUTURE", referencePrice: 157.8800048828125, sessionPrices: [157.8800048828125] }))
+      .toBe(2);
+  });
+
+  test("a tick finer than the session prices keeps its digits, and a tiny move never prints as zero", () => {
+    // A half-yen print after whole-yen closes is not rounded to a price that never traded.
+    expect(live([1850.5], { instrumentType: "EQUITY", previousClose: 1850, open: 1851 }, "JPY")).toEqual(["1,850.5"]);
+    const shib = liveQuoteFormatOptions({ instrumentType: "CRYPTOCURRENCY", previousClose: 0.00001234 }, "USD");
+    expect(formatSignedMarketPrice(-0.00000036, { ...shib, maxWidth: 9 })).toBe("-3.6e-7");
+  });
+
+  test("changes use the price's decimals, and a move that rounds to zero is unsigned", () => {
+    const options = liveQuoteFormatOptions({ instrumentType: "EQUITY", previousClose: 150 }, "USD");
+    expect([0.135, 1.2, 0, -0.004, -0.5].map((change) => formatSignedMarketPrice(change, options)))
+      .toEqual(["+0.14", "+1.20", "0.00", "0.00", "-0.50"]);
+    expect(formatMarketChangeWithCurrency(-0.004, "USD", options)).toBe("$0.00");
+    expect(formatMarketPriceWithCurrency(-0.001, "USD", options)).toBe("$0.00");
+  });
+});

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();
+  });
+});