gloomberb 0.17.3 → 0.17.4

package/src/plugins/builtin/market-heatmap/index.tsx

@@ -1,12 +1,11 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, useUiCapabilities } from "../../../ui";
 import {
-  buildHeatTreemapScene,
   findMetricTreemapNeighbor,
   formatHeatTileMove,
-  heatTreemapCanvas,
   HeatTreemapSurface,
   settleTreemapLayoutItems,
+  useHeatTreemapScene,
 } from "../../../components/metric-treemap";
 import {
   loadingText,
@@ -262,7 +261,7 @@ function useSettledLayoutItems<T>(items: readonly MetricTreemapItem<T>[], tolera
 function MarketHeatmapPane({ focused, width, height }: PaneProps) {
   const { pinTicker } = usePluginTickerActions();
   const liveStreaming = useLiveStreamingSetting();
-  const { cellWidthPx = 8, cellHeightPx = 18, nativePaneChrome } = useUiCapabilities();
+  const { nativePaneChrome } = useUiCapabilities();
   // A pane setting, not private pane state, so the settings dialog can show it.
   const [universeSetting, setActiveUniverse] = usePaneSettingValue<string>("universe", "us-equity");
   const [linkPortfolio] = usePaneSettingValue<boolean>("linkPortfolio", false);
@@ -370,10 +369,6 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
   });
 
   const chartHeight = Math.max(1, height - (tabsInHeader ? 0 : 1));
-  const canvas = useMemo(
-    () => heatTreemapCanvas(width, chartHeight, { nativePaneChrome, cellWidthPx, cellHeightPx }),
-    [cellHeightPx, cellWidthPx, chartHeight, nativePaneChrome, width],
-  );
 
   // Stream weights by market-cap rank, fixed for this load of the board.
   const quoteWeightsRef = useRef<{ tab: string; weights: Map<string, number> } | null>(null);
@@ -430,14 +425,9 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
     useMemo(() => buildLayoutItems(boardAssets, layoutAssets, grouping, sizeBy), [boardAssets, grouping, layoutAssets, sizeBy]),
     byMove ? DAY_MOVE_LAYOUT_TOLERANCE : LAYOUT_TOLERANCE,
   );
-  // The board on screen seeds the next layout's order, so a refresh nudges tiles instead of reshuffling them.
-  const sceneRef = useRef<{ tab: string; scene: ReturnType<typeof buildHeatTreemapScene<HeatmapBoardAsset>> } | null>(null);
-  const scene = useMemo(() => {
-    const previous = sceneRef.current?.tab === activeUniverse ? sceneRef.current.scene : null;
-    const next = buildHeatTreemapScene(layoutItems, canvas, previous);
-    sceneRef.current = { tab: activeUniverse, scene: next };
-    return next;
-  }, [activeUniverse, canvas, layoutItems]);
+  // The board on screen seeds the next layout's order, so a refresh nudges
+  // tiles instead of reshuffling them; a resize lays it out once it settles.
+  const { scene, resizing } = useHeatTreemapScene(layoutItems, width, chartHeight, activeUniverse);
   // The terminal repaints whole cells: colours there move at most four times a second.
   const paintAssets = useThrottledMemo(
     () => resolvedAssets,
@@ -726,6 +716,7 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
       >
         <HeatTreemapSurface
           scene={scene}
+          resizing={resizing}
           items={paintItems}
           width={width}
           height={chartHeight}

package/src/plugins/builtin/news/headless.ts

@@ -11,13 +11,15 @@ import {
   mapCloudNewsArticle,
 } from "../../../sources/gloomberb-cloud/news";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { formatUtcSeconds } from "../../../utils/utc-time";
 import { cloudNewsFreshness, cloudRealtimeAccess } from "../shared/report-freshness";
 
+// Stories carry their time to the second, so a story published on a whole minute prints its seconds too.
 const NEWS_COLUMNS = [
-  { key: "publishedAt", header: "Published" },
+  { key: "publishedAt", header: "Published", textFormat: formatUtcSeconds },
   { key: "source", header: "Source" },
   { key: "headline", header: "Headline" },
-  { key: "tickers", header: "Tickers" },
+  { key: "tickers", header: "Tickers", textFormat: (value: unknown) => Array.isArray(value) ? value.join(", ") : String(value ?? "") },
   { key: "sentiment", header: "Sentiment" },
   { key: "importance", header: "Score", align: "right" as const },
 ];

package/src/plugins/builtin/plugin-marketplace/pane.tsx

@@ -886,7 +886,7 @@ export function PluginMarketplacePane({ focused, width, height }: PaneProps) {
     <EmptyState
       title="Plugin catalog unavailable."
       status="error"
-      actions={<Button label="Retry" variant="primary" compact onPress={() => refresh(true)} />}
+      retry={{ onRetry: () => refresh(true) }}
     />
   ) : query || category ? (
     <EmptyState title="No plugins match." />

package/src/plugins/builtin/research/equity-diagnostic-pane.tsx

@@ -571,10 +571,9 @@ export function EquityDiagnosticView({ focused, width, height }: {
     return <Box paddingX={1} paddingY={1}><DiagnosticLoading step={loadingStep} /></Box>;
   }
   if (!report) {
-    const retryAction = <Button label="Retry" variant="secondary" onPress={retry} />;
     return failure
-      ? <PaneStatusBody error={failureText(failure)} actions={retryAction} />
-      : <PaneStatusBody empty emptyTitle={t("No diagnostic available yet.")} actions={retryAction} />;
+      ? <PaneStatusBody error={failureText(failure)} retry={{ onRetry: retry }} />
+      : <PaneStatusBody empty emptyTitle={t("No diagnostic available yet.")} retry={{ onRetry: retry }} />;
   }
 
   return (

package/src/renderers/dom/build-assets.ts

@@ -25,6 +25,18 @@ interface ViewBundleOptions {
   aliasRules?: AliasRule[];
   failureMessage: string;
   missingEntryMessage: string;
+  /**
+   * Leave identifiers unminified (whitespace and syntax still are), so the
+   * components keep their names and a page audit can say which one drew an
+   * element (`scripts/pane-chrome/ui-audit.ts`). Bun's `keepNames` alone did
+   * not keep them.
+   */
+  keepNames?: boolean;
+}
+
+/** Bun's minify setting: everything, or everything but identifiers when names are kept. */
+function minifyOption(keepNames: boolean | undefined) {
+  return keepNames ? { whitespace: true, syntax: true, identifiers: false } : true;
 }
 
 // From this file rather than the working directory, so a build started from
@@ -60,6 +72,7 @@ export async function buildViewBundle({
   aliasRules = [],
   failureMessage,
   missingEntryMessage,
+  keepNames,
 }: ViewBundleOptions): Promise<{ script: string; stylesheet: string | null }> {
   const chunks = new Map<string, string>();
   const result = await Bun.build({
@@ -69,7 +82,7 @@ export async function buildViewBundle({
     format: "esm",
     splitting: false,
     sourcemap,
-    minify: true,
+    minify: minifyOption(keepNames),
     define: {
       "process.env.NODE_ENV": "\"production\"",
       __GLOOM_WORLD_MAP_DATA__: JSON.stringify(WORLD_MAP_DATA_SPECIFIER),
@@ -88,7 +101,7 @@ export async function buildViewBundle({
 
   const script = result.outputs.find((output) => output.kind === "entry-point" && output.path.endsWith(".js"));
   if (!script) throw new Error(missingEntryMessage);
-  await buildLazyChunks(outdir, chunks, failureMessage);
+  await buildLazyChunks(outdir, chunks, failureMessage, keepNames);
 
   const stylesheet = result.outputs.find((output) => output.path.endsWith(".css"))?.path ?? null;
   if (stylesheet) await writeFile(stylesheet, withTitlebarOverlayHeight(await readFile(stylesheet, "utf8")));
@@ -181,7 +194,7 @@ function lazyChunkPlugin(rootOutdir: string, emitDir: string, chunks: Map<string
 }
 
 /** Builds each lazy chunk on its own, and the chunks those load in turn. */
-async function buildLazyChunks(rootOutdir: string, chunks: Map<string, string>, failureMessage: string): Promise<void> {
+async function buildLazyChunks(rootOutdir: string, chunks: Map<string, string>, failureMessage: string, keepNames?: boolean): Promise<void> {
   const built = new Set<string>();
   let pending = [...chunks.entries()];
   while (pending.length) {
@@ -197,7 +210,7 @@ async function buildLazyChunks(rootOutdir: string, chunks: Map<string, string>,
         format: "esm",
         splitting: false,
         sourcemap: "none",
-        minify: true,
+        minify: minifyOption(keepNames),
         plugins: [lazyChunkPlugin(rootOutdir, dirname(output), nested)],
       });
       if (!result.success) {

package/src/renderers/dom/desktop/controls.tsx

@@ -41,6 +41,7 @@ export function WebButton({
   onPress,
   variant = "secondary",
   disabled = false,
+  pending = false,
   active = false,
   shortcut,
   width,
@@ -61,6 +62,7 @@ export function WebButton({
       aria-keyshortcuts={ariaKeyShortcut(shortcut)}
       title={title}
       aria-expanded={expanded}
+      aria-busy={pending || undefined}
       disabled={disabled}
       onMouseDown={(event) => {
         if (stopPropagation) event.stopPropagation();

package/src/renderers/electrobun/bun/desktop/macos-dock-badge.ts

@@ -15,14 +15,15 @@ export function setMacosDockBadge(label: string): void {
     const dockTile = objc.send(app, objc.selector("dockTile"));
     if (!dockTile) return;
     const text = label
-      ? objc.sendObject(
+      ? objc.sendCString(
         objc.send(objc.getClass("NSString"), objc.selector("alloc")),
         objc.selector("initWithUTF8String:"),
         cString(label),
       )
-      : null;
+      : 0n;
     // AppKit only takes this on the main thread, and Bun runs on another one.
-    // The call retains the string until it has run; a null label is nil.
+    // The call retains the string until it has run; no label is nil. A label as
+    // short as a count is a tagged pointer, which is why objects travel as ids.
     objc.sendOnMainThread(
       dockTile,
       objc.selector("performSelectorOnMainThread:withObject:waitUntilDone:"),

package/src/renderers/electrobun/bun/desktop/macos-dock-icon.ts

@@ -1,11 +1,10 @@
-import type { Pointer } from "bun:ffi";
 import { appIconColors, appIconSvg } from "./app-icon";
 import { getTheme } from "../../../../theme/themes";
-import { objcOrNull, type Objc } from "./macos-objc";
+import { objcOrNull, type Objc, type ObjcId } from "./macos-objc";
 
 let appliedThemeId: string | null = null;
 
-function createImage(objc: Objc, svg: string): Pointer | null {
+function createImage(objc: Objc, svg: string): ObjcId | null {
   const bytes = Buffer.from(svg);
   const data = objc.sendBytes(
     objc.send(objc.getClass("NSData"), objc.selector("alloc")),

package/src/renderers/electrobun/bun/desktop/macos-objc.ts

@@ -4,28 +4,39 @@ const LIBOBJC = "/usr/lib/libobjc.A.dylib";
 
 export type Objc = ReturnType<typeof loadObjc>;
 
+/** An Objective-C object or class as its address, `0n` for nil. */
+export type ObjcId = bigint;
+
 let cachedObjc: Objc | null | undefined;
 
 export const cString = (value: string) => Buffer.from(`${value}\0`);
 
+// Objects cross the FFI as u64, never as ptr. Bun hands a ptr result to
+// JavaScript as a double, exact only up to 2**53, and Foundation keeps short
+// strings and small numbers (a Dock badge label such as "3") in tagged
+// pointers whose data sits in the top bits. Through a ptr they come back
+// rounded, and the next message to one crashes the process.
+const ID = FFIType.u64;
+
 // objc_msgSend has to be called with each method's exact C signature, so it is
 // bound once per call shape.
 function loadObjc() {
   const runtime = dlopen(LIBOBJC, {
-    objc_getClass: { args: [FFIType.ptr], returns: FFIType.ptr },
+    objc_getClass: { args: [FFIType.ptr], returns: ID },
     sel_registerName: { args: [FFIType.ptr], returns: FFIType.ptr },
   }).symbols;
   const msgSend = <const Args extends FFIType[], Returns extends FFIType>(args: Args, returns: Returns) =>
-    dlopen(LIBOBJC, { objc_msgSend: { args: [FFIType.ptr, FFIType.ptr, ...args], returns } }).symbols.objc_msgSend;
+    dlopen(LIBOBJC, { objc_msgSend: { args: [ID, FFIType.ptr, ...args], returns } }).symbols.objc_msgSend;
 
   return {
     getClass: (name: string) => runtime.objc_getClass(cString(name)),
     selector: (name: string) => runtime.sel_registerName(cString(name)),
-    send: msgSend([], FFIType.ptr),
+    send: msgSend([], ID),
     sendVoid: msgSend([], FFIType.void),
-    sendObject: msgSend([FFIType.ptr], FFIType.ptr),
-    sendBytes: msgSend([FFIType.ptr, FFIType.u64], FFIType.ptr),
-    sendOnMainThread: msgSend([FFIType.ptr, FFIType.ptr, FFIType.bool], FFIType.void),
+    sendObject: msgSend([ID], ID),
+    sendCString: msgSend([FFIType.ptr], ID),
+    sendBytes: msgSend([FFIType.ptr, FFIType.u64], ID),
+    sendOnMainThread: msgSend([FFIType.ptr, ID, FFIType.bool], FFIType.void),
   };
 }
 

package/src/sources/gloomberb-cloud/normalizers.ts

@@ -1,4 +1,4 @@
-import { futuresGenericListing, futuresGenericPriceBasis } from "../../utils/futures-generic";
+import { futuresListingPriceBasis } from "../../utils/futures-generic";
 import type { TimeRange } from "../../time-series/range";
 import { RANGE_HISTORY_RESOLUTION } from "../../time-series/resolution";
 import type {
@@ -55,6 +55,12 @@ function isImpossiblePreviousClose(
     && previousClose * IMPOSSIBLE_CLOSE_FACTOR < low52w;
 }
 
+/** A quote that says it is something other than a future (an equity, a fund) keeps its own price basis. */
+function isNonFutureType(instrumentType: string | undefined): boolean {
+  const type = instrumentType?.trim().toUpperCase();
+  return !!type && type !== "FUTURE" && type !== "FUTURES" && type !== "FUT";
+}
+
 export function mapQuote(
   quote: CloudQuotePayload,
   providerMeta?: CloudProviderMeta,
@@ -76,12 +82,14 @@ export function mapQuote(
   const changePercent = !impossibleClose && typeof quote.changePercent === "number" && Number.isFinite(quote.changePercent)
     ? quote.changePercent
     : Number.NaN;
-  // A generic future (VX1, TY1) reads in points or 32nds, not dollars.
-  const generic = futuresGenericListing(quote.symbol, quote.listingExchangeName ?? quote.exchangeName);
+  // A generic future (VX1, TY1) reads in points or 32nds, and an index future's
+  // continuous symbol or contract (ES=F, SXOZ26.CME) in points, not dollars.
+  const futuresBasis = isNonFutureType(quote.instrumentType) ? null
+    : futuresListingPriceBasis(quote.symbol, quote.listingExchangeName ?? quote.exchangeName);
   const priceObservation = quote.priceBasis === "nav" ? "nav" : undefined;
   const priceBasis = quote.priceBasis === "nav"
     ? "per-unit"
-    : (generic ? futuresGenericPriceBasis(generic) : null) ?? quote.priceBasis;
+    : futuresBasis ?? quote.priceBasis;
   return withoutUndefinedFields(reconcileQuoteDayRange({
     ...quote,
     priceBasis,

package/src/time-series/resolve.ts

@@ -83,7 +83,7 @@ import { getPricePointTimestamp, isPriceHistoryStaleForCurrentWindow } from "../
 import { timeZoneLabel, zonedDateKey, zonedWallClockMs } from "../utils/zoned-date-time";
 import { formatShortDate } from "../utils/datetime-format";
 import { latestSessionStart, latestTradingSessionOpen, listingTimeZone, priorSessionClose } from "../market-data/market/trading-sessions";
-import { futuresGenericCaption, futuresGenericListing, futuresGenericPriceBasis } from "../utils/futures-generic";
+import { futuresGenericCaption, futuresGenericListing, futuresListingPriceBasis } from "../utils/futures-generic";
 import { isOhlcSeriesStyle } from "./spec";
 import { SERIES_COLORS } from "../theme/series-colors";
 import type {
@@ -1166,8 +1166,10 @@ function baseSecuritySeries(
     : field.unit;
   const generic = field.unitGroup === "price"
     ? futuresGenericListing(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
-  // A generic future on an index, VIX or Treasuries reads in points or 32nds, not dollars.
-  const genericBasis = generic && isMarketFieldId(field.id) ? futuresGenericPriceBasis(generic) : null;
+  // A generic future on an index, VIX or Treasuries reads in points or 32nds, and an index
+  // future's continuous symbol or contract in points, not dollars, as its quote does.
+  const genericBasis = field.unitGroup === "price" && isMarketFieldId(field.id)
+    ? futuresListingPriceBasis(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
   const genericUnit = genericBasis === "points" ? "points" : genericBasis === "thirty-seconds" ? "32nds" : null;
   const unit = field.id === "market.volume" ? volumeUnit ?? ""
     : genericUnit ?? (unitTemplate.startsWith("currency") && currency ? unitTemplate.replace("currency", currency) : unitTemplate);

package/src/ui/resize-settle.ts

@@ -0,0 +1,128 @@
+import { useContext, useEffect, useRef, useState } from "react";
+import { isLiveResizing, onLiveResizeEnd } from "./live-resize";
+import { LivePaneFrameContext, type CellSize } from "./live-stretch";
+
+/**
+ * How long a box's size has to hold still before what is laid out in it
+ * settles at that size. A resize's content catches up every 100 ms
+ * (live-resize.ts), so a pane under the pointer stays resizing between its
+ * catch-ups.
+ */
+export const RESIZE_SETTLE_MS = 120;
+
+/**
+ * How far a box may stretch from the size its layout was made for, on either
+ * axis, before the layout is made again mid-resize: past this, tiles and
+ * blocks drawn in percentages of the old size would look squashed or pulled.
+ */
+const MAX_HELD_STRETCH = 1.5;
+
+export interface ResizeHold {
+  /** The box's size as it last rendered. */
+  size: CellSize;
+  /** While the box is resizing, the size its layout holds to; null at rest. */
+  held: CellSize | null;
+}
+
+function stretch(from: number, to: number): number {
+  return from > 0 && to > 0 ? Math.max(from / to, to / from) : Infinity;
+}
+
+/**
+ * The box rendered at `size`: the first change of a resize holds the layout at
+ * the size it had, later ones keep it there, and a stretch past
+ * MAX_HELD_STRETCH lays it out again at the new size (still resizing).
+ */
+export function nextResizeHold(state: ResizeHold, size: CellSize, maxStretch = MAX_HELD_STRETCH): ResizeHold {
+  if (state.size.width === size.width && state.size.height === size.height) return state;
+  const held = state.held ?? state.size;
+  const far = Math.max(stretch(held.width, size.width), stretch(held.height, size.height)) > maxStretch;
+  return { size, held: far ? size : held };
+}
+
+/** At rest: the layout takes the box's size. */
+export function settleResizeHold(state: ResizeHold): ResizeHold {
+  return state.held ? { size: state.size, held: null } : state;
+}
+
+export interface SettledLayoutSize extends CellSize {
+  /**
+   * The box is being resized: from the first move of a resize that has its
+   * pane's frame, or its first change of size, until it has held still for
+   * RESIZE_SETTLE_MS with the pointer let go. Nothing laid out in it should
+   * animate meanwhile.
+   */
+  resizing: boolean;
+}
+
+/**
+ * Desktop: the size to lay out a surface at whose content is placed in
+ * percentages of its box (a heat map's tiles), and whether that box is being
+ * resized. A pane resize, a divider, a maximise or restore and a window
+ * resize all change the box's size, often once a frame; laying the content
+ * out again at every one of them costs a full restyle and moves every tile
+ * each time. Instead, while the size changes the layout holds to the size it
+ * had and the box stretches it by CSS, and once the size has held still it is
+ * laid out once, at the size the box settled on. A stretch too far from the
+ * held size lays it out again on the way.
+ *
+ * `resizing` is the shared signal for anything that animates when its layout
+ * changes (a glide, a fade, a pulse): none of it while the size is changing.
+ * Off (`enabled: false`, the terminal), the size is the box's at once.
+ */
+export function useSettledLayoutSize(
+  width: number,
+  height: number,
+  { enabled = true }: { enabled?: boolean } = {},
+): SettledLayoutSize {
+  const [state, setState] = useState<ResizeHold>(() => ({ size: { width, height }, held: null }));
+  let current = state;
+  if (state.size.width !== width || state.size.height !== height) {
+    // Stored while rendering, so the render that has the new size already lays out at the held one.
+    current = enabled ? nextResizeHold(state, { width, height }) : { size: { width, height }, held: null };
+    setState(current);
+  }
+
+  // A resize that has this pane's frame: it holds still from the first move, before its content catches up.
+  const frame = useContext(LivePaneFrameContext);
+  const [framed, setFramed] = useState(false);
+  const framedRef = useRef(false);
+  useEffect(() => {
+    // Called on every move: only a resize starting or ending is news.
+    const follow = () => {
+      const next = enabled && frame !== null && frame.live() !== null;
+      if (next === framedRef.current) return;
+      framedRef.current = next;
+      setFramed(next);
+    };
+    follow();
+    return enabled ? frame?.subscribe(follow) : undefined;
+  }, [enabled, frame]);
+
+  useEffect(() => {
+    if (!state.held || framed) return;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    let stopWaiting: (() => void) | null = null;
+    const settle = () => {
+      timer = null;
+      // A box still under the pointer (a sidebar, a split) settles when it is let go, not when the pointer pauses.
+      if (isLiveResizing()) {
+        stopWaiting = onLiveResizeEnd(() => {
+          stopWaiting?.();
+          stopWaiting = null;
+          timer = setTimeout(settle, RESIZE_SETTLE_MS);
+        });
+        return;
+      }
+      setState(settleResizeHold);
+    };
+    timer = setTimeout(settle, RESIZE_SETTLE_MS);
+    return () => {
+      if (timer !== null) clearTimeout(timer);
+      stopWaiting?.();
+    };
+  }, [framed, state]);
+
+  const layout = current.held ?? current.size;
+  return { width: layout.width, height: layout.height, resizing: enabled && (current.held !== null || framed) };
+}

package/src/utils/calendar-date.ts

@@ -29,3 +29,59 @@ export function isoDateDaysAgo(days: number, now = new Date()): string {
 export function isoDateYearsAgo(years: number, now = new Date()): string {
   return isoDateBefore(now, years, 0);
 }
+
+/** YYYY-MM-DD for a day the calendar has; null for a month or day out of range. */
+function calendarDay(year: number, month: number, day: number): string | null {
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day
+    ? date.toISOString().slice(0, 10)
+    : null;
+}
+
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+/** A day and a month in either order, then a four-digit year, with one separator throughout: 14/10/2026, 14.10.2026, 14-10-2026. */
+const YEAR_LAST = /^(\d{1,2})([/.-])(\d{1,2})\2(\d{4})$/;
+/** A four-digit year first, written another way than YYYY-MM-DD: 2026/10/14, 2026.10.14, 2026-10-4. */
+const YEAR_FIRST = /^(\d{4})([/.-])(\d{1,2})\2(\d{1,2})$/;
+
+/**
+ * The YYYY-MM-DD date that a date written another way names: 14/10/2026 and
+ * 10/14/2026 are 2026-10-14, since a part over 12 can only be the day. When
+ * both parts could be the month (03/04/2026), only dots are read, day first,
+ * as dotted dates are written (`assumedDayFirst`); a slash or a dash is
+ * written both ways round, so that is null. Null as well for text that is not
+ * a date of the calendar.
+ */
+function isoDateReading(value: string): { date: string; assumedDayFirst: boolean } | null {
+  const text = value.trim();
+  const yearFirst = YEAR_FIRST.exec(text);
+  if (yearFirst) {
+    const date = calendarDay(Number(yearFirst[1]), Number(yearFirst[3]), Number(yearFirst[4]));
+    return date && date !== text ? { date, assumedDayFirst: false } : null;
+  }
+  const yearLast = YEAR_LAST.exec(text);
+  if (!yearLast) return null;
+  const [first, second, year] = [Number(yearLast[1]), Number(yearLast[3]), Number(yearLast[4])];
+  const monthFirst = first <= 12 && second > 12;
+  const either = first <= 12 && second <= 12 && first !== second;
+  if (either && yearLast[2] !== ".") return null;
+  const date = monthFirst ? calendarDay(year, first, second) : calendarDay(year, second, first);
+  return date ? { date, assumedDayFirst: either } : null;
+}
+
+/**
+ * A date option's value, checked before any request is made: YYYY-MM-DD as
+ * typed, or an error that names the format. A date written another way gets
+ * the option to type instead (`--from 2026-10-14` for 14/10/2026); one whose
+ * day and month could be either way round gets an example of the format. An
+ * empty value is no date.
+ */
+export function isoDateOption(value: string, flag: string, now = new Date()): string {
+  const text = value.trim();
+  const iso = ISO_DATE.exec(text);
+  if (!text || (iso && calendarDay(Number(iso[1]), Number(iso[2]), Number(iso[3])))) return text;
+  const format = `Use a --${flag} date in YYYY-MM-DD format`;
+  const reading = isoDateReading(text);
+  if (reading) throw new Error(`${format}: type --${flag} ${reading.date} for ${text}${reading.assumedDayFirst ? " (day first)" : ""}.`);
+  throw new Error(`${format}, such as --${flag} ${isoDateToday(now)}.`);
+}

package/src/utils/decimal-comma.ts

@@ -92,3 +92,34 @@ export function parsePastedNumber(value: unknown): PastedNumber {
 export function ambiguousNumberMessage(text: string, reading: { thousands: number; decimal: number }): string {
   return `${text.trim()} could be ${reading.thousands} (thousands) or ${reading.decimal} (decimal comma); type ${reading.thousands} or ${reading.decimal}`;
 }
+
+/** What a dot and exactly three digits after one to three (`81.000`, `81.250`) could mean. */
+export interface ThousandsDotReadings {
+  /** The number as written, the dot a decimal point: 81. */
+  decimal: number;
+  /** The dot as many locales write it, between thousands: 81000. */
+  thousands: number;
+}
+
+const THOUSANDS_DOT = /^([+-]?)([1-9]\d{0,2})\.(\d{3})$/;
+
+/** Both readings of `81.000`; null for any other text, which has one. */
+export function thousandsDotReadings(value: unknown): ThousandsDotReadings | null {
+  const match = THOUSANDS_DOT.exec(typeof value === "string" ? value.trim() : "");
+  if (!match) return null;
+  const sign = match[1] === "-" ? -1 : 1;
+  return { decimal: sign * Number(`${match[2]}.${match[3]}`), thousands: sign * Number(`${match[2]}${match[3]}`) };
+}
+
+/**
+ * Whether a dot and three digits was meant as a thousands separator, beside a
+ * price it must be near (the last price): the number as written is more than
+ * 90% away from it, while the thousands reading lands within 10%. A plain
+ * dotted number otherwise keeps its meaning, and without a reference it is
+ * read as written.
+ */
+export function meantThousandsDot(readings: ThousandsDotReadings, reference: number | null | undefined): boolean {
+  if (reference == null || !Number.isFinite(reference) || reference === 0) return false;
+  const scale = Math.abs(reference);
+  return Math.abs(readings.decimal - reference) * 10 > scale * 9 && Math.abs(readings.thousands - reference) * 10 <= scale;
+}

package/src/utils/futures-generic.ts

@@ -28,9 +28,11 @@ export interface FuturesGeneric {
 
 /** Roots Gloom Cloud archives daily, by the venue that lists them. */
 const ROOT_VENUES: Readonly<Record<string, string>> = Object.fromEntries(([
-  ["CME", ["ES", "NQ", "RTY", "6E", "6J", "6B", "6A", "6C", "6S", "SR3", "LE", "GF", "HE", "LBR", "DC", "CSC", "GD", "BTC", "ETH", "SOL", "XRP"]],
-  ["CBT", ["YM", "ZT", "ZF", "ZN", "ZB", "UB", "ZQ", "ZC", "ZS", "ZW", "ZM", "ZL", "KE", "ZO", "ZR"]],
-  ["NYM", ["CL", "BZ", "NG", "RB", "HO", "PL", "PA", "B0", "TTF"]],
+  ["CME", ["ES", "NQ", "RTY", "EMD", "RS1", "NKD", "NIY", "MES", "MNQ", "M2K",
+    "XAE", "XAB", "XAI", "XAY", "XAP", "XAV", "XAF", "XAK", "XAZ", "XAU", "XAR", "SXO", "SXR", "SXT", "SXB", "SXI", "SOX",
+    "6E", "6J", "6B", "6A", "6C", "6S", "SR3", "LE", "GF", "HE", "LBR", "DC", "CSC", "GD", "BTC", "ETH", "SOL", "XRP"]],
+  ["CBT", ["YM", "MYM", "RX", "ZT", "ZF", "ZN", "ZB", "UB", "ZQ", "ZC", "ZS", "ZW", "ZM", "ZL", "KE", "ZO", "ZR"]],
+  ["NYM", ["CL", "QM", "MCL", "BZ", "NG", "QG", "MNG", "HH", "RB", "HO", "PL", "PA", "B0", "TTF"]],
   ["CMX", ["GC", "SI", "HG", "ALI", "HRC", "UX"]],
   ["NYB", ["KC", "SB", "CC", "CT", "OJ"]],
   ["CFE", ["VX"]],
@@ -128,16 +130,35 @@ function futuresGenericOrdinal(position: number): string {
   return `${position}${tens >= 11 && tens <= 13 ? "th" : ["th", "st", "nd", "rd"][position % 10] ?? "th"}`;
 }
 
+/** Equity index, sector and industry futures, the S&P GSCI and VIX: their prices are index points. */
+const POINT_ROOTS: ReadonlySet<string> = new Set(["ES", "NQ", "RTY", "YM", "GD", "VX", "EMD", "RS1", "NKD", "NIY", "MES", "MNQ", "M2K", "MYM", "RX",
+  "XAE", "XAB", "XAI", "XAY", "XAP", "XAV", "XAF", "XAK", "XAZ", "XAU", "XAR", "SXO", "SXR", "SXT", "SXB", "SXI", "SOX"]);
+
 /**
  * How a generic's price reads: index and VIX futures in points (not dollars),
  * Treasury futures in 32nds of par; everything else in its quote currency.
  */
 export function futuresGenericPriceBasis(generic: Pick<FuturesGeneric, "root">): "points" | "thirty-seconds" | null {
-  if (["ES", "NQ", "RTY", "YM", "GD", "VX"].includes(generic.root)) return "points";
+  if (POINT_ROOTS.has(generic.root)) return "points";
   if (["ZT", "ZF", "ZN", "ZB", "UB"].includes(generic.root)) return "thirty-seconds";
   return null;
 }
 
+/**
+ * How a futures listing's price reads, whichever form it takes: a generic by
+ * its root (VX1 points, TY1 32nds), and a continuous (`ES=F`, `SXO=F`) or
+ * listed contract (`SXOZ26.CME`) of an index, sector or industry root in index
+ * points, on the root's own venue or with none. The quote keeps its currency
+ * for what a tick is worth. Null for every other listing, a security that
+ * shares a root's code on another venue (XAU on Toronto, the XAR ETF) included.
+ */
+export function futuresListingPriceBasis(symbol: string, exchange?: string | null): "points" | "thirty-seconds" | null {
+  const generic = futuresGenericListing(symbol, exchange);
+  if (generic) return futuresGenericPriceBasis(generic);
+  const listing = futuresListingVenue(symbol, exchange);
+  return listing?.root && ROOT_VENUES[listing.root] === listing.venue && POINT_ROOTS.has(listing.root) ? "points" : null;
+}
+
 /** Whether a root's date rules count back from first notice or from last trade. */
 export function futuresGenericNotice(root: string): "first notice" | "last trade" {
   return FIRST_NOTICE_ROOTS.has(root) ? "first notice" : "last trade";

package/src/utils/plugin-proxy-hosts.json

@@ -1,16 +1,21 @@
 {
   "hosts": [
+    "api.crypto.com",
     "api.elections.kalshi.com",
     "api.fda.gov",
     "api.fiscaldata.treasury.gov",
+    "api.gemini.com",
+    "api.limitless.exchange",
     "api.publisher.jodidata.org",
     "api.votehub.com",
     "apps.fas.usda.gov",
     "clinicaltrials.gov",
     "clob.polymarket.com",
     "data-api.polymarket.com",
+    "data.pascal.trade",
     "efts.sec.gov",
     "gamma-api.polymarket.com",
+    "gateway.polymarket.us",
     "markets.newyorkfed.org",
     "nasdaqtrader.com",
     "production.dataviz.cnn.io",