gloomberb 0.15.0 → 0.15.2

package/src/plugins/builtin/cloud/thesis/board-pane.test.tsx

@@ -6,6 +6,7 @@ import { TestDialogProvider, testRender } from "../../../../renderers/opentui/te
 import { appReducer, createInitialState } from "../../../../state/app/context";
 import { createTestPaneConfig, createTestTicker, TestPaneProvider } from "../../../../test-support/pane";
 import { createTestPluginRuntime } from "../../../../test-support/plugin-runtime";
+import type { PluginPersistence } from "../../../../types/plugin";
 import { Box, Text } from "../../../../ui";
 import { ThesisBoardPane } from "./board-pane";
 import { thesisStore } from "./store";
@@ -193,6 +194,30 @@ describe("ThesisBoardPane", () => {
     expect(frame).toContain("Weights");
   });
 
+  test("the on-device copy is only called offline once the refresh fails", async () => {
+    let failList: (error: Error) => void = () => {};
+    setCloudApiFetchTransport(async (url, init) => {
+      const parsed = new URL(url);
+      if (parsed.pathname === "/theses") return new Promise<Response>((_, reject) => { failList = reject; });
+      const { status, body } = respond(parsed.pathname, init?.method ?? "GET");
+      return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+    });
+    const saved = new Map<string, unknown>([["thesis-cache", [nvda, asml]]]);
+    thesisStore.attach({ getState: (key: string) => saved.get(key) ?? null, setState: (key: string, value: unknown) => { saved.set(key, value); } } as unknown as PluginPersistence);
+    thesisStore.start();
+    await act(async () => {
+      setup = await testRender(<Harness />, { width: 110, height: 30 });
+    });
+    await flush(null);
+    const loading = setup!.captureCharFrame();
+    expect(loading).toContain("ASML");
+    expect(loading).toContain("footer: loading");
+    expect(loading).not.toContain("offline copy");
+    await act(async () => { failList(new Error("network down")); });
+    await flush(null);
+    expect(setup!.captureCharFrame()).toContain("offline copy");
+  });
+
   test("enter opens the thesis: pillars, kill conditions, catalysts, and the open signal with its source", async () => {
     thesisStore.start();
     await act(async () => {

package/src/plugins/builtin/cloud/thesis/board-pane.tsx

@@ -17,7 +17,7 @@ import { colors } from "../../../../theme/colors";
 import type { PaneProps } from "../../../../types/plugin";
 import { Box, TextAttributes, type InputRenderable } from "../../../../ui";
 import { useDialog } from "../../../../ui/dialog";
-import { formatCompactCurrency } from "../../../../utils/format";
+import { formatCompactAmount } from "../../../../utils/format";
 import { isPlainKey } from "../../../../utils/keyboard";
 import { stopSearchFocusNavigation } from "../../../../utils/search-focus-navigation";
 import { usePluginAppActions } from "../../../runtime";
@@ -344,7 +344,8 @@ export function ThesisBoardPane({ focused, width, height }: PaneProps) {
       case "weight":
         return { text: `${pct(row.weight)}${row.hasOptions ? "*" : ""}`, color: selectedColor ?? colors.text };
       case "value":
-        return { text: formatCompactCurrency(row.value, exposure.baseCurrency), color: selectedColor ?? colors.textDim };
+        // A thesis can be worth under 1000, where formatCompactCurrency would trim the cents as prices move.
+        return { text: `${formatCompactAmount(row.value)} ${exposure.baseCurrency}`, color: selectedColor ?? colors.textDim };
       case "gap": {
         const text = row.gap > 0 ? "under-sized" : row.gap < 0 ? "grew big" : "in line";
         const color = row.gap > 0 ? colors.warning : row.gap < 0 ? colors.negative : colors.textDim;

package/src/plugins/builtin/cloud/thesis/store.ts

@@ -8,7 +8,7 @@ interface ThesisStoreSnapshot {
   loaded: boolean;
   loading: boolean;
   error: string | null;
-  /** Set while the list is served from the on-device copy. */
+  /** Set when the last refresh failed and the list shown is the on-device copy. */
   offline: boolean;
 }
 
@@ -89,7 +89,7 @@ class ThesisStore {
     this.persistence = persistence;
     const cached = persistence.getState<CloudThesis[]>(CACHE_STATE_KEY);
     if (Array.isArray(cached) && cached.length > 0) {
-      this.update({ theses: cached, offline: true });
+      this.update({ theses: cached });
     }
   }
 

package/src/plugins/builtin/congress-trades/detail.tsx

@@ -80,7 +80,7 @@ export function TradeDetail({
         {/* The detail title already carries the member and ticker. */}
         <DetailLine label="chamber" value={`${trade.chamber === "senate" ? "Senate" : "House"}${trade.stateDistrict ? ` · ${trade.stateDistrict}` : ""}`} tone="muted" />
         <DetailLine label="party" value={trade.party ?? "--"} />
-        <DetailLine label="side" value={trade.transactionType} tone={trade.side === "BUY" ? "positive" : trade.side === "SELL" ? "negative" : "warning"} />
+        <DetailLine label="side" value={trade.transactionType} tone={trade.side === "BUY" ? "positive" : trade.side === "SELL" ? "negative" : trade.side === "OTHER" ? "muted" : undefined} />
         <DetailLine label="asset" value={truncate(trade.assetName, Math.max(10, lineWidth - 16))} />
         <DetailLine label="amount" value={trade.amount} tone="value" />
         <DetailLine label="owner" value={trade.owner} />

package/src/plugins/builtin/congress-trades/table.tsx

@@ -21,7 +21,7 @@ export function sideColor(side: CloudCongressTradePayload["side"], selected: boo
   if (selected) return colors.selectedText;
   if (side === "BUY") return colors.positive;
   if (side === "SELL") return colors.negative;
-  if (side === "EXCHANGE") return colors.warning;
+  if (side === "EXCHANGE") return colors.text;
   return colors.textDim;
 }
 

package/src/plugins/builtin/cot/client.ts

@@ -84,7 +84,8 @@ export interface CotDetailData { payload: CotContractPayload; price: PricePoint[
 export async function loadCotDetail(contractCode: string, family: CotFamily, client: Pick<typeof apiClient, "getCloudCotContract" | "getCloudHistory"> = apiClient): Promise<CotDetailData> {
   const payload = await fetchCotContract(contractCode, family, client);
   const mapping = cotPriceMapping(contractCode);
-  if (!mapping?.priceSymbol) return { payload, price: [], priceSymbol: null, priceAsOf: null, priceWarning: "No verified front-price mapping for this CFTC market. Positioning remains available." };
+  // An unmapped market simply has no price panel; that is not a data failure.
+  if (!mapping?.priceSymbol) return { payload, price: [], priceSymbol: null, priceAsOf: null, priceWarning: null };
   try {
     const result = await client.getCloudHistory(mapping.priceSymbol, mapping.exchange, { interval: "1day", rangeKey: "5Y", outputsize: 1500 });
     if (!Array.isArray(result.data)) throw new Error("Front-price history unavailable");

package/src/plugins/builtin/cot/model.test.ts

@@ -56,6 +56,15 @@ test("price-source failure leaves report history readable and never substitutes
   const resultVx = await loadCotDetail("1170E1", "legacy", { getCloudCotContract: async () => vx, getCloudHistory: async () => { priceRequested = true; throw new Error("must not substitute cash VIX"); } });
   expect(priceRequested).toBe(false);
   expect(resultVx.priceSymbol).toBeNull();
+  expect(resultVx.priceWarning).toBeNull();
+  const corn = payload(); corn.contract = { ...corn.contract!, contractCode: "002602", marketName: "CORN" };
+  const requested: string[] = [];
+  const resultCorn = await loadCotDetail("002602", "legacy", { getCloudCotContract: async () => corn,
+    getCloudHistory: async (symbol, exchange) => { requested.push(`${symbol} ${exchange}`); return { status: "success", data: [] } as never; } });
+  expect(requested).toEqual(["ZC=F CBT"]);
+  expect(resultCorn.priceSymbol).toBe("ZC=F");
+  // A market code is never an equity alias: Soybean Meal's ZM stays Zoom's.
+  expect(cotContractCode("ZM")).toBeNull();
 });
 
 test("missing migration gives unavailable state; access failures remain access failures", async () => {

package/src/plugins/builtin/cot/model.ts

@@ -19,6 +19,35 @@ const ROOTS: Record<string, { code: string; exchange: string; priceSymbol: strin
   SR3: { code: "134741", exchange: "CME", priceSymbol: null },
   ES: { code: "13874A", exchange: "CME", priceSymbol: "ES=F" },
 };
+/**
+ * Front-month price overlays for major markets without a root alias, each
+ * checked to return five years of daily history (2026-09-24). Keyed by CFTC
+ * code, never added to ROOTS: an alias would also claim the equity ticker under
+ * the cursor (ZM, ZS, PL). No cash index stands in, so the dollar index has none.
+ */
+const PRICE_OVERLAYS: Record<string, { exchange: string; priceSymbol: string }> = {
+  "209742": { exchange: "CME", priceSymbol: "NQ=F" }, "239742": { exchange: "CME", priceSymbol: "RTY=F" },
+  "124603": { exchange: "CBT", priceSymbol: "YM=F" },
+  "042601": { exchange: "CBT", priceSymbol: "ZT=F" }, "044601": { exchange: "CBT", priceSymbol: "ZF=F" },
+  "043607": { exchange: "CBT", priceSymbol: "TN=F" }, "020601": { exchange: "CBT", priceSymbol: "ZB=F" },
+  "020604": { exchange: "CBT", priceSymbol: "UB=F" },
+  "099741": { exchange: "CME", priceSymbol: "6E=F" }, "097741": { exchange: "CME", priceSymbol: "6J=F" },
+  "096742": { exchange: "CME", priceSymbol: "6B=F" }, "090741": { exchange: "CME", priceSymbol: "6C=F" },
+  "232741": { exchange: "CME", priceSymbol: "6A=F" }, "092741": { exchange: "CME", priceSymbol: "6S=F" },
+  "095741": { exchange: "CME", priceSymbol: "6M=F" },
+  "133741": { exchange: "CME", priceSymbol: "BTC=F" }, "146021": { exchange: "CME", priceSymbol: "ETH=F" },
+  "023651": { exchange: "NYM", priceSymbol: "NG=F" }, "111659": { exchange: "NYM", priceSymbol: "RB=F" },
+  "022651": { exchange: "NYM", priceSymbol: "HO=F" }, "06765T": { exchange: "NYM", priceSymbol: "BZ=F" },
+  "085692": { exchange: "CMX", priceSymbol: "HG=F" }, "076651": { exchange: "NYM", priceSymbol: "PL=F" },
+  "075651": { exchange: "NYM", priceSymbol: "PA=F" },
+  "002602": { exchange: "CBT", priceSymbol: "ZC=F" }, "005602": { exchange: "CBT", priceSymbol: "ZS=F" },
+  "001602": { exchange: "CBT", priceSymbol: "ZW=F" }, "001612": { exchange: "CBT", priceSymbol: "KE=F" },
+  "007601": { exchange: "CBT", priceSymbol: "ZL=F" }, "026603": { exchange: "CBT", priceSymbol: "ZM=F" },
+  "083731": { exchange: "NYB", priceSymbol: "KC=F" }, "080732": { exchange: "NYB", priceSymbol: "SB=F" },
+  "033661": { exchange: "NYB", priceSymbol: "CT=F" }, "073732": { exchange: "NYB", priceSymbol: "CC=F" },
+  "057642": { exchange: "CME", priceSymbol: "LE=F" }, "054642": { exchange: "CME", priceSymbol: "HE=F" },
+  "061641": { exchange: "CME", priceSymbol: "GF=F" },
+};
 /**
  * The markets most readers mean by "positioning", verified against the live
  * CFTC boards on 2026-09-22. A code missing from a report family simply does
@@ -55,7 +84,7 @@ export function cotContractCode(value: unknown): string | null {
 export function cotRoot(code: string): string | null {
   return Object.entries(ROOTS).find(([, row]) => row.code === code)?.[0] ?? null;
 }
-export function cotPriceMapping(code: string) { return Object.values(ROOTS).find((row) => row.code === code) ?? null; }
+export function cotPriceMapping(code: string) { return Object.values(ROOTS).find((row) => row.code === code) ?? PRICE_OVERLAYS[code] ?? null; }
 export function cotClass(family: CotFamily, value: unknown): CotClass {
   return COT_CLASSES[family].find((row) => row.value === value)?.value ?? COT_CLASSES[family][0]!.value;
 }

package/src/plugins/builtin/cot/pane.tsx

@@ -97,8 +97,7 @@ function CotBoard({ width, height, focused, family, initialCode }: PaneProps & {
   ] : [] }), [boardShown]);
   usePaneNoticeFooter({ registrationId: "cot:board-notices", focused, enabled: !open, notices: data?.gaps ?? [] });
   usePaneStatusFooter({ registrationId: "cot:board", enabled: !open, loading: resource.loading, error: resource.error,
-    info: data ? [{ id: "as-of", parts: [{ text: `CFTC futures only · ${data.asOf ?? "--"} · contracts`, tone: "muted" }] },
-      ...(data.status !== "available" ? [{ id: "partial", parts: [{ text: data.status, tone: "warning" as const }] }] : [])] : [] });
+    info: data ? [{ id: "as-of", parts: [{ text: `CFTC futures only · ${data.asOf ?? "--"} · contracts`, tone: "muted" }] }] : [] });
   if (!data && !open) return <PaneStatusBody loading={resource.loading} error={resource.error} empty={!resource.loading && !resource.error} subject="COT history" />;
   return <DataTableStackView<CotBoardRow> columns={BOARD_COLUMNS} items={rows} focused={focused && !searching}
     rootWidth={width} rootHeight={height} selection={{ kind: "id", selectedId: selected, getId: (row) => row.contractCode, onChange: setSelected }}
@@ -150,8 +149,7 @@ function CotDetail({ width, height, focused, code, family, traderClass, onClassC
   });
   usePaneNoticeFooter({ registrationId: "cot:detail-notices", focused, notices: [...(payload?.gaps ?? []), ...(data?.priceWarning ? [data.priceWarning] : []), ...partialRanks] });
   usePaneStatusFooter({ registrationId: "cot:detail", loading: resource.loading, error: resource.error,
-    info: payload ? [{ id: "as-of", parts: [{ text: `CFTC ${payload.asOf ?? "--"} · contracts${data?.priceAsOf ? ` · ${data.priceSymbol} ${data.priceAsOf}` : ""}`, tone: "muted" }] },
-      ...(payload.status !== "available" ? [{ id: "partial", parts: [{ text: payload.status, tone: "warning" as const }] }] : [])] : [] });
+    info: payload ? [{ id: "as-of", parts: [{ text: `CFTC ${payload.asOf ?? "--"} · contracts${data?.priceAsOf ? ` · ${data.priceSymbol} ${data.priceAsOf}` : ""}`, tone: "muted" }] }] : [] });
   return <PaneStatusBody loading={resource.loading && !data} error={!data ? resource.error : null} empty={!!payload && !payload.contract} subject="COT contract">
     {payload && data ? <Box width={width} height={height} flexDirection="column">
       <CompositeChart series={series} panels={data.price.length ? [{ id: "price", height: 2 }, { id: "net", height: 1 }] : [{ id: "net" }]}

package/src/plugins/builtin/credit-conditions/client.ts

@@ -45,7 +45,8 @@ export function getCachedCreditConditions(): CreditConditionsLoadResult | null {
     const cached = getCachedFredSeries(requestFor(definition.seriesId), { allowExpired: true });
     if (!cached) continue;
     try {
-      rows.push(normalizeCreditSeries(definition, cached.data, cached.stale));
+      // The pane revalidates this copy on mount; only the source or a failed refresh makes it stale.
+      rows.push(normalizeCreditSeries(definition, cached.data, cached.data.stale === true));
     } catch (error) {
       errors.push(error instanceof Error ? error.message : String(error));
     }

package/src/plugins/builtin/crypto-board/client.ts

@@ -105,7 +105,8 @@ export function cachedCryptoMarkets(): CryptoMarketsResource | null {
   const cached = cryptoMarketsCache.get("usd", { allowExpired: true });
   if (!cached) return null;
   try {
-    return { payload: validateCryptoMarkets(cached.data), stale: cached.stale, refreshError: null };
+    // The pane revalidates this copy on mount; only a failed refresh makes it stale.
+    return { payload: validateCryptoMarkets(cached.data), stale: false, refreshError: null };
   } catch {
     return null;
   }

package/src/plugins/builtin/crypto-board/model.test.ts

@@ -52,6 +52,15 @@ test("a live quote without a change percent is restated from the previous close"
   expect(row!.changePercent).toBeCloseTo(10, 6);
 });
 
+test("a live price crossing a power of ten keeps the decimals of its previous close", () => {
+  const coin = { ...cryptoFixture().assets[0]!, price: 9.95, previousClose: 9.9 };
+  const rowAt = (price: number) => buildCryptoRows(
+    [coin], "coin", new Map([[cryptoQuoteKey(coin), entry({ price, lastUpdated: CRYPTO_FIXTURE_NOW })]]), CRYPTO_FIXTURE_NOW,
+  )[0]!.priceText;
+  expect(rowAt(9.998)).toBe("9.998");
+  expect(rowAt(10.02)).toBe("10.020");
+});
+
 test("tabs split coins from stablecoins and keep market-cap rank order", () => {
   const assets = cryptoFixture().assets;
   expect(buildCryptoRows(assets, "coin", new Map()).map((row) => row.code)).toEqual(["BTC", "HYPE"]);

package/src/plugins/builtin/crypto-board/model.ts

@@ -41,6 +41,8 @@ export const cryptoQuoteKey = (asset: Pick<CryptoMarketAsset, "symbol">) =>
 const finite = (value: number | null | undefined): value is number =>
   typeof value === "number" && Number.isFinite(value);
 
+const positive = (value: number | null | undefined): value is number => finite(value) && value > 0;
+
 const utcDay = (ms: number) => Math.floor(ms / DAY_MS);
 
 /** The close `days` UTC days before today, the basis the day change also uses. */
@@ -102,6 +104,9 @@ export function buildCryptoRow(
     ? [...closes, { date: new Date(Math.max(now, start + closes.length * DAY_MS)), close: price }]
     : closes;
   const updatedAt = quote?.lastUpdated ?? (asset.quoteTime ? Date.parse(asset.quoteTime) : null);
+  // The digits follow a price that holds still for the day, so a tick across a
+  // power of ten (0.9998 to 1.0002) keeps the row's decimals.
+  const referencePrice = [asset.previousClose, quote?.previousClose, quote?.open].find(positive) ?? asset.price;
   return {
     asset,
     id: asset.symbol,
@@ -109,7 +114,7 @@ export function buildCryptoRow(
     code: asset.code,
     name: asset.name,
     price,
-    priceText: formatCryptoPrice(price, asset.kind === "stablecoin" ? 4 : 2),
+    priceText: formatCryptoPrice(price, asset.kind === "stablecoin" ? 4 : 2, referencePrice),
     changePercent,
     return7d: percentChange(price, closeDaysAgo(asset, 7, now)),
     return30d: percentChange(price, closeDaysAgo(asset, 30, now)),
@@ -149,10 +154,13 @@ export function buildCryptoRows(
  * Four significant digits and never fewer than two decimals, with trailing
  * zeros kept, so a column running from 84,399.24 to 0.000005660 reads evenly.
  * Stablecoins ask for four decimals so 1.0001 and 0.9998 show the same peg detail.
+ * The digits are counted at `referencePrice` (a session-fixed price such as the
+ * previous close) when there is one, so a live price crossing a power of ten
+ * keeps its decimals.
  */
-export function formatCryptoPrice(value: number | null, minimumDecimals = 2): string {
+export function formatCryptoPrice(value: number | null, minimumDecimals = 2, referencePrice?: number | null): string {
   if (value == null || !Number.isFinite(value) || value <= 0) return "—";
-  const magnitude = Math.floor(Math.log10(value));
+  const magnitude = Math.floor(Math.log10(positive(referencePrice) ? referencePrice : value));
   const decimals = Math.min(12, Math.max(minimumDecimals, 3 - magnitude));
   return value.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
 }

package/src/plugins/builtin/custom-view/live-quotes.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import type { Quote } from "../../../types/financials";
-import { liveViewColumns, overlayViewRow, viewStreamTargets } from "./live-quotes";
+import { liveViewColumns, liveViewDecimalFloors, overlayViewRow, viewStreamTargets } from "./live-quotes";
 
 const quote: Quote = { symbol: "NVDA", price: 181.5, change: 3, changePercent: 1.68, volume: 12_000_000, currency: "USD", lastUpdated: 1 };
 
@@ -24,6 +24,11 @@ test("only a listing's own last price, day change and volume stream into a view"
   expect(overlayViewRow(row, quote, fields)).toEqual({ ...row, price: 181.5, changePercent: 1.68, volume: 12_000_000 });
   expect(overlayViewRow(row, { ...quote, currency: "EUR" }, fields)).toBe(row);
   expect(overlayViewRow(row, { ...quote, stale: true }, fields)).toBe(row);
+
+  // A live price keeps cents whatever the tick, and none for a yen-only view.
+  expect(liveViewDecimalFloors([row], fields)).toEqual(new Map([["price", 2], ["changePercent", 2]]));
+  expect(liveViewDecimalFloors([{ ...row, currency: "JPY" }], fields).get("price")).toBe(0);
+  expect(liveViewDecimalFloors([{ ...row, currency: "JPY" }, row], fields).get("price")).toBe(2);
 });
 
 test("a view streams the rows on screen fast and one screen either side in the background", () => {

package/src/plugins/builtin/custom-view/live-quotes.ts

@@ -1,4 +1,5 @@
 import { resolveEntryValue } from "../../../market-data/coordinator";
+import { currencyMinorDigits } from "../../../market-data/market/format";
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
@@ -41,6 +42,31 @@ export function liveViewColumns(columns: readonly HeadlessPaneColumn[]): Map<str
   return fields;
 }
 
+/**
+ * The fewest decimals a live column shows, however a tick lands: a price its
+ * currency's minor unit (cents, none for yen), a percent change two.
+ */
+export function liveViewDecimalFloors(rows: readonly ViewRow[], fields: ReadonlyMap<string, LiveViewField>): Map<string, number> {
+  const floors = new Map<string, number>();
+  let priceDigits: number | undefined;
+  for (const [key, field] of fields) {
+    if (field === "changePercent") {
+      floors.set(key, 2);
+    } else if (field === "price") {
+      priceDigits ??= rowsMinorDigits(rows);
+      floors.set(key, priceDigits);
+    }
+  }
+  return floors;
+}
+
+/** Cents unless every row trades in a currency without them. */
+function rowsMinorDigits(rows: readonly ViewRow[]): number {
+  const currencies = new Set(rows.map((row) => (typeof row.currency === "string" ? row.currency.trim() : "")));
+  if (currencies.size === 0) return 2;
+  return Math.max(...[...currencies].map((currency) => Math.min(2, currencyMinorDigits(currency || undefined))));
+}
+
 export function viewRowSymbol(row: ViewRow, symbolKey: string | null): string | null {
   if (!symbolKey) return null;
   const value = row[symbolKey];

package/src/plugins/builtin/custom-view/pane.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { apiClient, TeamRevisionConflictError } from "../../../api-client";
 import { DataTableView } from "../../../components/data-table/view";
 import { ChoiceDialog } from "../../../components/ui/choice-dialog";
@@ -29,6 +29,7 @@ import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import { normalizeSymbol } from "../../../utils/exchanges";
 import {
   liveViewColumns,
+  liveViewDecimalFloors,
   overlayViewRow,
   viewRowQuote,
   viewRowSymbol,
@@ -39,8 +40,8 @@ import { loadViewSource, type LoadedView } from "./loader";
 import {
   applyViewProjection,
   formatViewValue,
+  growViewColumnDecimals,
   parseViewSpecOr,
-  viewColumnDecimals,
   type ViewColumn,
   type ViewRow,
   type ViewSort,
@@ -56,6 +57,7 @@ const DEFAULT_COLUMN_WIDTH = 14;
 const NO_ROWS: ViewRow[] = [];
 const NO_SYMBOLS: readonly (string | null)[] = [];
 const NO_TARGETS: QuoteSubscriptionTarget[] = [];
+const NO_DECIMALS: ReadonlyMap<string, number> = new Map();
 /** Live values move every tick; filters and sort follow them at most this often. */
 const LIVE_VIEW_ORDER_SAMPLE_MS = 5_000;
 /** Header and border rows above the table body. */
@@ -185,11 +187,20 @@ export function CustomViewPane({ focused, width, height }: PaneProps) {
     }
     return bases;
   }, [columns, rows]);
-  const decimalsByColumn = useMemo(() => new Map(columns.flatMap((column) => {
-    if (column.transform) return [];
-    const decimals = viewColumnDecimals(rows, column.key);
-    return decimals === undefined ? [] : [[column.key, decimals] as const];
-  })), [columns, rows]);
+  const decimalFloors = useMemo(() => liveViewDecimalFloors(sourceRows, liveFields), [liveFields, sourceRows]);
+  // A column's decimals only grow while this spec is shown, so a tick that
+  // crosses 100 or lands on a whole number never reflows the column.
+  const heldDecimals = useRef<{ spec: ViewSpec | null; decimals: ReadonlyMap<string, number> }>({ spec: null, decimals: NO_DECIMALS });
+  const decimalsByColumn = useMemo(() => {
+    const held = heldDecimals.current.spec === spec ? heldDecimals.current.decimals : NO_DECIMALS;
+    const decimals = growViewColumnDecimals(held, rows, columns.flatMap((column) => (
+      column.transform === "percent" || column.transform === "index100"
+        ? []
+        : [{ key: column.key, minimum: decimalFloors.get(column.key) }]
+    )));
+    heldDecimals.current = { spec, decimals };
+    return decimals;
+  }, [columns, decimalFloors, rows, spec]);
   const activeSort = sort === undefined ? spec?.projection.sort ?? null : sort;
   // Memoized so the table's row memo holds while the selection moves.
   const rowKey = useCallback((row: ViewRow, index: number) => (

package/src/plugins/builtin/custom-view/view-spec.test.ts

@@ -2,12 +2,13 @@ import { describe, expect, test } from "bun:test";
 import {
   applyViewProjection,
   formatViewValue,
+  growViewColumnDecimals,
   normalizeViewSpec,
   parseViewSpec,
   parseViewSpecOr,
   serializeViewSpec,
   validateViewSpec,
-  viewColumnDecimals,
+  type ViewRow,
 } from "./view-spec";
 
 const good = {
@@ -98,19 +99,36 @@ describe("applyViewProjection", () => {
 describe("formatViewValue", () => {
   test("applies transforms", () => {
     expect(formatViewValue(0.1234, "percent")).toBe("12.34%");
-    expect(formatViewValue(1_234_567, "compact")).toBe("1.2M");
+    expect(formatViewValue(1_234_567, "compact")).toBe("1.23M");
+    expect(formatViewValue(12_300_000, "compact")).toBe("12.30M");
     expect(formatViewValue(-3, "abs")).toBe("3");
     expect(formatViewValue(110, "index100", 100)).toBe("110.0");
     expect(formatViewValue(3.14159, undefined)).toBe("3.14");
+    expect(formatViewValue(-0.001, undefined, undefined, 2)).toBe("0.00");
     expect(formatViewValue("text", "percent")).toBe("text");
     expect(formatViewValue(null, "compact")).toBe("");
   });
 
-  test("reads midnight ISO stamps as dates and gives a numeric column one decimal count", () => {
+  test("reads midnight ISO stamps as dates", () => {
     expect(formatViewValue("2026-09-01T00:00:00.000Z", undefined)).toBe("2026-09-01");
     expect(formatViewValue("2026-09-01T14:30:00Z", undefined)).toBe("2026-09-01 14:30 UTC");
-    const rows = [{ close: 236 }, { close: 232.1 }, { close: null }];
-    const decimals = viewColumnDecimals(rows, "close");
-    expect(rows.map((row) => formatViewValue(row.close, undefined, undefined, decimals))).toEqual(["236.0", "232.1", ""]);
+  });
+
+  test("a numeric column keeps one decimal count that only grows while the view is shown", () => {
+    const columns = [{ key: "close" }];
+    const format = (rows: ViewRow[], decimals: ReadonlyMap<string, number>) => (
+      rows.map((row) => formatViewValue(row.close, undefined, undefined, decimals.get("close")))
+    );
+    const loaded = [{ close: 236 }, { close: 232.1 }, { close: null }];
+    const held = growViewColumnDecimals(new Map(), loaded, columns);
+    expect(format(loaded, held)).toEqual(["236.0", "232.1", ""]);
+    // A tick lands on whole numbers: the column keeps its decimal rather than reflowing.
+    const whole = [{ close: 236 }, { close: 232 }];
+    expect(growViewColumnDecimals(held, whole, columns)).toBe(held);
+    // One row under 100 grows the whole column, and it stays grown.
+    const grown = growViewColumnDecimals(held, [{ close: 99.5 }], columns);
+    expect(format(whole, growViewColumnDecimals(grown, whole, columns))).toEqual(["236.00", "232.00"]);
+    // A live price keeps its floor on a whole-number tick.
+    expect(growViewColumnDecimals(new Map(), whole, [{ key: "close", minimum: 2 }]).get("close")).toBe(2);
   });
 });

package/src/plugins/builtin/custom-view/view-spec.ts

@@ -5,6 +5,8 @@
  * version here never waits on a deploy. Modeled on `chart-composer/chart-spec`.
  */
 
+import { formatCompact, formatCompactAmount } from "../../../utils/format";
+
 export const VIEW_SPEC_VERSION = 1;
 export const MAX_VIEW_COLUMNS = 24;
 export const MAX_VIEW_FILTERS = 12;
@@ -337,48 +339,78 @@ function naturalDecimals(value: number): number {
   return Number.isInteger(value) ? 0 : Math.abs(value) >= 100 ? 1 : 2;
 }
 
-/**
- * One decimal count for a plain numeric column, so a column never mixes
- * "236" with "232.1": the most any of its values would show on its own.
- */
-export function viewColumnDecimals(rows: readonly ViewRow[], key: string): number | undefined {
+const MAX_NATURAL_DECIMALS = 2;
+
+/** The most decimals any of a column's values would show on its own. */
+function viewColumnDecimals(rows: readonly ViewRow[], key: string): number | undefined {
   let decimals: number | undefined;
   for (const row of rows) {
     const value = row[key];
     if (typeof value !== "number" || !Number.isFinite(value)) continue;
     decimals = Math.max(decimals ?? 0, naturalDecimals(value));
-    if (decimals === 2) break;
+    if (decimals === MAX_NATURAL_DECIMALS) break;
   }
   return decimals;
 }
 
+export interface ViewDecimalColumn {
+  key: string;
+  /** Decimals the column never shows fewer of, such as cents on a price. */
+  minimum?: number;
+}
+
+/**
+ * One decimal count per numeric column, so a column never mixes "236" with
+ * "232.1", grown with the rows now shown and never fewer than `held`. Live
+ * rows tick several times a second, and a count read from each tick flips the
+ * whole column when one value crosses 100 or lands on a whole number. Returns
+ * `held` itself when no count grew.
+ */
+export function growViewColumnDecimals(
+  held: ReadonlyMap<string, number>,
+  rows: readonly ViewRow[],
+  columns: readonly ViewDecimalColumn[],
+): ReadonlyMap<string, number> {
+  let grown: Map<string, number> | null = null;
+  for (const { key, minimum = 0 } of columns) {
+    const current = held.get(key);
+    if (current !== undefined && current >= Math.max(minimum, MAX_NATURAL_DECIMALS)) continue;
+    const seen = viewColumnDecimals(rows, key);
+    if (seen === undefined && current === undefined) continue;
+    const decimals = Math.max(current ?? 0, seen ?? 0, minimum);
+    if (decimals === current) continue;
+    grown ??= new Map(held);
+    grown.set(key, decimals);
+  }
+  return grown ?? held;
+}
+
+/** A value that rounds to zero is unsigned: 0.00, never -0.00. */
+function unsignedZero(text: string): string {
+  return text.startsWith("-") && !/[1-9]/.test(text) ? text.slice(1) : text;
+}
+
 /**
  * A transform's display text, given the raw value, (for index100) the column's
- * first value, and (for plain numbers) the column's decimal count.
+ * first value, and (for plain, abs and compact numbers) the column's decimal count.
  */
 export function formatViewValue(value: unknown, transform: ViewTransform | undefined, base?: number, decimals?: number): string {
   if (value === null || value === undefined) return "";
   if (typeof value !== "number") return typeof value === "string" ? formatViewString(value) : JSON.stringify(value);
   if (!Number.isFinite(value)) return "";
+  const columnDecimals = decimals ?? naturalDecimals(value);
   switch (transform) {
     case "percent":
-      return `${(value * 100).toFixed(2)}%`;
+      return unsignedZero(`${(value * 100).toFixed(2)}%`);
     case "compact":
-      return compactNumber(value);
+      // A whole-number column (counts, volume) stays whole below 1,000; any
+      // other keeps two decimals there. Scaled values keep their zeros either way.
+      return columnDecimals === 0 ? formatCompact(value, { fixedDecimals: true }) : formatCompactAmount(value);
     case "abs":
-      return String(Math.abs(value));
+      return Math.abs(value).toFixed(columnDecimals);
     case "index100":
-      return base && Number.isFinite(base) && base !== 0 ? (value / base * 100).toFixed(1) : "";
+      return base && Number.isFinite(base) && base !== 0 ? unsignedZero((value / base * 100).toFixed(1)) : "";
     default:
-      return value.toFixed(decimals ?? naturalDecimals(value));
-  }
-}
-
-function compactNumber(value: number): string {
-  const abs = Math.abs(value);
-  const units: Array<[number, string]> = [[1e12, "T"], [1e9, "B"], [1e6, "M"], [1e3, "K"]];
-  for (const [threshold, suffix] of units) {
-    if (abs >= threshold) return `${(value / threshold).toFixed(abs / threshold >= 100 ? 0 : 1)}${suffix}`;
+      return unsignedZero(value.toFixed(columnDecimals));
   }
-  return Number.isInteger(value) ? String(value) : value.toFixed(2);
 }

package/src/plugins/builtin/debt-maturities/client.ts

@@ -21,6 +21,15 @@ export const BUCKET_IDS = [
   "InYearFive",
   "AfterYearFive",
 ] as const;
+/** Rolling-period concepts some filers (JPM from FY2023) use for the same buckets. */
+const ROLLING_BUCKET_TAGS = [
+  "InNextRollingTwelveMonths",
+  "InRollingYearTwo",
+  "InRollingYearThree",
+  "InRollingYearFour",
+  "InRollingYearFive",
+  "InRollingAfterYearFive",
+] as const;
 const number = (value: unknown): value is number =>
   typeof value === "number" && Number.isFinite(value) && value >= 0;
 const nullableNumber = (value: unknown) => value === null || number(value);
@@ -177,8 +186,10 @@ export function validateDebtMaturities(
         : !sameFiling(bucket.fact) ||
           bucket.fact.end !== latest.asOf ||
           bucket.fact.start !== null ||
-          bucket.fact.tag !==
-            `LongTermDebtMaturitiesRepaymentsOfPrincipal${bucket.id}` ||
+          (bucket.fact.tag !==
+            `LongTermDebtMaturitiesRepaymentsOfPrincipal${bucket.id}` &&
+            bucket.fact.tag !==
+              `LongTermDebtMaturitiesRepaymentsOfPrincipal${ROLLING_BUCKET_TAGS[index]}`) ||
           bucket.fact.value !== bucket.value)
     )
       return invalid();
@@ -336,13 +347,15 @@ export interface DebtResource {
   stale: boolean;
   refreshError: string | null;
 }
+// Seeds the first paint while the mount load runs; cache age is not staleness,
+// and a failed refresh reports its own.
 export function cachedDebtMaturities(symbol: string): DebtResource | null {
   const cached = debtMaturitiesCache.get(symbol, { allowExpired: true });
   if (!cached) return null;
   try {
     return {
       payload: validateDebtMaturities(cached.data, symbol),
-      stale: cached.stale,
+      stale: false,
       refreshError: null,
     };
   } catch {

package/src/plugins/builtin/debt-maturities/debt-maturities.test.ts

@@ -214,6 +214,14 @@ describe("debt maturity Cloud boundary", () => {
     }
   });
 
+  test("accepts a bucket filed under its rolling-period concept, not another bucket's", () => {
+    const data = fixture();
+    data.latest!.buckets[1]!.fact!.tag = "LongTermDebtMaturitiesRepaymentsOfPrincipalInRollingYearTwo";
+    expect(validateDebtMaturities(data, "TEST").latest?.buckets[1]?.value).toBe(10);
+    data.latest!.buckets[1]!.fact!.tag = "LongTermDebtMaturitiesRepaymentsOfPrincipalInRollingYearThree";
+    expect(() => validateDebtMaturities(data, "TEST")).toThrow();
+  });
+
   test("missing bucket stays a chart gap and prevents a total and concentration denominator", () => {
     const data = fixture(),
       latest = data.latest!;