gloomberb 0.15.0 → 0.15.2

package/src/components/layout/market-summary.ts

@@ -10,7 +10,7 @@ import { useQuoteEntry, useResolvedEntryValue } from "../../market-data/hooks";
 import { useQuoteStreaming } from "../../state/hooks/quote-streaming";
 import type { QuoteSubscriptionTarget } from "../../types/data-provider";
 import { formatPercentRaw } from "../../utils/format";
-import { formatMarketPrice } from "../../market-data/market/format";
+import { formatMarketPrice, liveQuoteFormatOptions } from "../../market-data/market/format";
 import { getActiveQuoteDisplay, marketStateColor, marketStateCountdown, marketStateLabel } from "../../market-data/market/status";
 
 /**
@@ -115,8 +115,10 @@ export function useMarketSummary(): MarketSummary {
 
   const activeSpyQuote = getActiveQuoteDisplay(spyQuote);
   const spyColor = activeSpyQuote?.change != null ? priceColor(activeSpyQuote.change, colors) : colors.textDim;
+  // Fixed decimals and a percent slot as wide as "+0.53%", so a streamed tick
+  // never slides the market-state label or re-fits the cluster.
   const spyText = activeSpyQuote
-    ? `SPY ${formatMarketPrice(activeSpyQuote.price, { assetCategory: "ETF" })} ${formatPercentRaw(activeSpyQuote.changePercent)}`
+    ? `SPY ${formatMarketPrice(activeSpyQuote.price, liveQuoteFormatOptions(spyQuote, spyQuote?.currency, "ETF"))} ${formatPercentRaw(activeSpyQuote.changePercent).padStart(6)}`
     : "SPY —";
 
   const mktCountdown = mktState ? marketStateCountdown(mktState, now) : null;

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

@@ -16,10 +16,10 @@ const quote: Quote = {
 };
 
 describe("formatTickerBadgeChange", () => {
-  test("keeps one decimal and loses a pointless minus on zero", () => {
+  test("keeps one decimal on whole moves and loses a pointless minus on zero", () => {
     expect(formatTickerBadgeChange(1.24)).toBe("+1.2%");
-    expect(formatTickerBadgeChange(-5)).toBe("-5%");
-    expect(formatTickerBadgeChange(-0.01)).toBe("0%");
+    expect(formatTickerBadgeChange(-5)).toBe("-5.0%");
+    expect(formatTickerBadgeChange(-0.01)).toBe("0.0%");
   });
 });
 

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/components/ui/index.ts

@@ -22,7 +22,8 @@ export { Menu, MenuPopover } from "./menu";
 export type { MenuItem, MenuProps, MenuPopoverProps } from "./menu";
 
 export { MultiSelectDialogButton, MultiSelectDialogContent } from "./multi-select/dialog";
-export type { MultiSelectDialogButtonHandle, MultiSelectPopoverAnchorPoint } from "./multi-select/dialog";
+export type { MultiSelectDialogButtonHandle, MultiSelectPopoverAnchorPoint, MultiSelectRowAction } from "./multi-select/dialog";
+export { NumberPromptDialog } from "./number-prompt-dialog";
 
 export { SelectButton } from "./select-button";
 export type { SelectButtonOption, SelectButtonProps, SelectControl } from "./select-button";

package/src/components/ui/multi-select/dialog.tsx

@@ -37,6 +37,19 @@ import {
   type MultiSelectOption,
 } from "./index";
 
+/**
+ * One action on the highlighted row, shown beside Done: editing a value the
+ * option carries, such as an indicator's period.
+ */
+export interface MultiSelectRowAction {
+  label: string;
+  shortcut: string;
+  /** Whether the highlighted option offers it; `selected` is its checkbox. */
+  appliesTo(value: string, selected: boolean): boolean;
+  /** A returned label replaces the row's label while the dialog stays open. */
+  run(value: string): Promise<string | void> | string | void;
+}
+
 export interface MultiSelectDialogContentProps extends AlertContext {
   title: string;
   options: MultiSelectOption[];
@@ -45,6 +58,7 @@ export interface MultiSelectDialogContentProps extends AlertContext {
   ordered?: boolean;
   emptyLabel?: string;
   idPrefix?: string;
+  rowAction?: MultiSelectRowAction;
 }
 
 export interface MultiSelectDialogButtonProps {
@@ -61,6 +75,8 @@ export interface MultiSelectDialogButtonProps {
   shortcutKey?: string | string[];
   shortcutActive?: boolean;
   onOpenChange?: (open: boolean) => void;
+  /** Opens the dialog on desktop too, since the popover menu has no row actions. */
+  rowAction?: MultiSelectRowAction;
 }
 
 export interface MultiSelectPopoverAnchorPoint {
@@ -197,6 +213,7 @@ export function MultiSelectDialogContent({
   onChange,
   ordered = false,
   idPrefix,
+  rowAction,
 }: MultiSelectDialogContentProps) {
   const isDesktopWeb = useUiHost().kind === "desktop-web";
   const optionByValue = useMemo(() => new Map(options.map((option) => [option.value, option])), [options]);
@@ -216,6 +233,11 @@ export function MultiSelectDialogContent({
   const canMoveDown = ordered
     && selectedValueOrder >= 0
     && selectedValueOrder < knownSelectedValues.length - 1;
+  const [labelOverrides, setLabelOverrides] = useState<Record<string, string>>({});
+  const canRunRowAction = !!rowAction
+    && !!selectedOption
+    && !selectedOption.disabled
+    && rowAction.appliesTo(selectedOption.value, selectedValues.includes(selectedOption.value));
 
   useEffect(() => {
     setSelectedValues((values) => normalizeDialogSelectedValues(options, values, ordered));
@@ -235,7 +257,7 @@ export function MultiSelectDialogContent({
 
     return {
       id: option.value,
-      label: option.label,
+      label: labelOverrides[option.value] ?? option.label,
       disabled: option.disabled,
       enabled: selectedValues.includes(option.value),
       description: [option.description, orderDescription].filter((entry): entry is string => !!entry).join(" "),
@@ -278,6 +300,13 @@ export function MultiSelectDialogContent({
     );
   };
 
+  const runRowAction = async () => {
+    if (!rowAction || !canRunRowAction || !selectedOption) return;
+    const value = selectedOption.value;
+    const label = await rowAction.run(value);
+    if (typeof label === "string") setLabelOverrides((current) => ({ ...current, [value]: label }));
+  };
+
   useDialogKeyboard((event) => {
     event.stopPropagation();
     const move = listCursorMove(event, pageSize);
@@ -290,6 +319,8 @@ export function MultiSelectDialogContent({
       void moveOption("up").catch(() => {});
     } else if (event.name === "]" && ordered) {
       void moveOption("down").catch(() => {});
+    } else if (rowAction && event.name === rowAction.shortcut && !event.ctrl && !event.meta && !event.alt) {
+      void runRowAction().catch(() => {});
     } else if (event.name === "enter" || event.name === "return" || event.name === "escape" || isDetailBackNavigationKey(event)) {
       dismiss();
     }
@@ -331,6 +362,15 @@ export function MultiSelectDialogContent({
               <Button label="Move Down" shortcut="]" variant="ghost" disabled={!canMoveDown} onPress={() => { void moveOption("down").catch(() => {}); }} />
             </>
           )}
+          {rowAction && (
+            <Button
+              label={rowAction.label}
+              shortcut={rowAction.shortcut}
+              variant="ghost"
+              disabled={!canRunRowAction}
+              onPress={() => { void runRowAction().catch(() => {}); }}
+            />
+          )}
           <Button label="Done" shortcut="Enter" variant="primary" onPress={dismiss} />
         </Box>
       </Box>
@@ -352,6 +392,7 @@ function MultiSelectDialogButtonInner({
   shortcutKey,
   shortcutActive = false,
   onOpenChange,
+  rowAction,
 }: MultiSelectDialogButtonProps, ref: ForwardedRef<MultiSelectDialogButtonHandle>) {
   const isDesktopWeb = useUiHost().kind === "desktop-web";
   const dialog = useDialog();
@@ -364,7 +405,7 @@ function MultiSelectDialogButtonInner({
   const openDialog = useCallback((event?: DialogTriggerEvent, anchorPoint?: MultiSelectPopoverAnchorPoint) => {
     stopMouseEvent(event);
     if (disabled) return;
-    if (isDesktopWeb && !ordered) {
+    if (isDesktopWeb && !ordered && !rowAction) {
       setPopoverAnchorPoint(anchorPoint ?? null);
       setPopoverOpen(true);
       onOpenChange?.(true);
@@ -383,10 +424,11 @@ function MultiSelectDialogButtonInner({
           ordered={ordered}
           emptyLabel={emptyLabel}
           idPrefix={idPrefix}
+          rowAction={rowAction}
         />
       ),
     }).catch(() => {}).finally(() => onOpenChange?.(false));
-  }, [dialog, disabled, emptyLabel, idPrefix, isDesktopWeb, label, onChange, onOpenChange, options, ordered, selectedValues, title]);
+  }, [dialog, disabled, emptyLabel, idPrefix, isDesktopWeb, label, onChange, onOpenChange, options, ordered, rowAction, selectedValues, title]);
 
   const closePopover = useCallback(() => {
     setPopoverOpen(false);
@@ -469,7 +511,7 @@ function MultiSelectDialogButtonInner({
     );
   }
 
-  if (isDesktopWeb && !ordered) {
+  if (isDesktopWeb && !ordered && !rowAction) {
     return (
       <Popover
         open={popoverOpen}

package/src/components/ui/number-prompt-dialog.tsx

@@ -0,0 +1,71 @@
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, type InputRenderable } from "../../ui";
+import type { PromptContext } from "../../ui/dialog";
+import { useThemeColors } from "../../theme/theme-context";
+import { DialogFrame } from "./frame";
+import { TextField } from "./fields";
+
+/** A whole number within [min, max], or null for anything else. */
+export function parseWholeNumber(text: string, min: number, max: number): number | null {
+  const trimmed = text.trim();
+  if (!/^\d+$/.test(trimmed)) return null;
+  const value = Number(trimmed);
+  return value >= min && value <= max ? value : null;
+}
+
+export interface NumberPromptDialogProps extends PromptContext<number> {
+  title: string;
+  initialValue: number;
+  min: number;
+  max: number;
+  /** Shown under the field when Enter is pressed on something out of range. */
+  invalidMessage: string;
+}
+
+/**
+ * One prefilled number field. Enter keeps a valid value, Esc closes without
+ * one (the dialog host resolves the prompt with undefined).
+ */
+export function NumberPromptDialog({
+  resolve,
+  title,
+  initialValue,
+  min,
+  max,
+  invalidMessage,
+}: NumberPromptDialogProps) {
+  const colors = useThemeColors();
+  const inputRef = useRef<InputRenderable>(null);
+  const [value, setValue] = useState(String(initialValue));
+  const [invalid, setInvalid] = useState(false);
+
+  useEffect(() => {
+    inputRef.current?.focus?.();
+  }, []);
+
+  return (
+    <DialogFrame title={title}>
+      <Box flexDirection="column" width={32}>
+        <TextField
+          inputRef={inputRef}
+          value={value}
+          focused
+          onChange={(next) => {
+            setValue(next);
+            setInvalid(false);
+          }}
+          onSubmit={(submitted) => {
+            const parsed = parseWholeNumber(submitted, min, max);
+            if (parsed === null) setInvalid(true);
+            else resolve(parsed);
+          }}
+        />
+        {invalid && (
+          <Box height={1}>
+            <Text fg={colors.negative}>{invalidMessage}</Text>
+          </Box>
+        )}
+      </Box>
+    </DialogFrame>
+  );
+}

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