@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/plugins/builtin/equity-screener/pane.tsx

@@ -54,6 +54,7 @@ import { useSampledValue } from "../../../state/hooks/live-ticker-financials";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import { SignInWall } from "../cloud/auth-actions";
 import { CriterionEditor } from "./criterion-editor";
+import { SCREEN_IDEAS, screenIdea } from "./ideas";
 import { ScreenTickerCheck } from "./ticker-check";
 import {
   fetchSavedScreens,
@@ -70,7 +71,9 @@ import {
   formatScreenValue,
   metricDate,
   parseScreenDefinition,
+  pickerFields,
   resultFields,
+  screenMetricSetting,
   SIGN_COLORED,
   screenColumnLabel,
   screenCurrencyEmpty,
@@ -80,6 +83,7 @@ import {
   screenYtdBase,
 } from "./model";
 import { useScreenResults } from "./results";
+import { unmatchedCategoryText, unmatchedCategoryValues } from "./categories";
 import { overlayLiveScreenRows, screenExtendedMove, screenExtendedSessions, sortLiveScreenRows, type LiveScreenRow } from "./live";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { buildScreenerQuoteTargets } from "../../../market-data/quotes/screener-live-quotes";
@@ -92,6 +96,7 @@ const TABS = [
   { value: "results", label: "Results" },
   { value: "criteria", label: "Criteria" },
   { value: "saved", label: "Saved" },
+  { value: "ideas", label: "Ideas" },
 ];
 const errorText = (error: unknown) =>
   error instanceof Error ? error.message : "Request failed.";
@@ -115,8 +120,10 @@ export function resultColumns(
   asOf: boolean,
   extendedSessions: readonly ExtendedSession[] = [],
   ytdBase: string | null = null,
+  /** Other metrics `--metric` asked for, shown first after the focus metric. */
+  otherMetrics: readonly NumericField[] = [],
 ): DataTableColumn[] {
-  const [focus, ...others] = resultFields(definition, metric);
+  const [focus, ...others] = resultFields(definition, metric, otherMetrics);
   const metricColumn = (field: NumericField, form: "pane" | "compact"): DataTableColumn => {
     const label = screenColumnLabel(field, ytdBase, form);
     return { id: `m:${field}`, label, width: columnWidth(field, label), align: "right" };
@@ -222,9 +229,12 @@ export function EquityScreenerPane(props: PaneProps) {
     "definition",
     undefined,
   );
+  // A ready screen from Ideas (`--preset`), which opens on its own metric.
+  const [presetId] = usePaneSettingValue<string | undefined>("preset", undefined);
+  const preset = screenIdea(presetId);
   let initial: ScreenDefinition;
   try {
-    initial = seed ? parseScreenDefinition(JSON.parse(seed)) : DEFAULT_SCREEN;
+    initial = preset?.definition ?? (seed ? parseScreenDefinition(JSON.parse(seed)) : DEFAULT_SCREEN);
   } catch (error) {
     return (
       <PaneStatusBody subject="screen definition" error={errorText(error)} />
@@ -232,9 +242,10 @@ export function EquityScreenerPane(props: PaneProps) {
   }
   return (
     <EquityScreenView
-      key={`${seed ?? "default"}:${session.requestKey}`}
+      key={`${preset?.id ?? seed ?? "default"}:${session.requestKey}`}
       {...props}
       initial={initial}
+      initialMetric={preset?.metric ?? "marketCap"}
     />
   );
 }
@@ -243,7 +254,8 @@ function EquityScreenView({
   height,
   focused,
   initial,
-}: PaneProps & { initial: ScreenDefinition }) {
+  initialMetric,
+}: PaneProps & { initial: ScreenDefinition; initialMetric: NumericField }) {
   const colors = useThemeColors(),
     dialog = useDialog(),
     host = useRendererHost();
@@ -253,10 +265,12 @@ function EquityScreenView({
   const session = useResearchCloudSession(),
     access = usePlanAccess();
   const [definition, setDefinition] = usePluginPaneState("definition", initial);
-  const [metric, setMetric] = usePaneSettingValue<NumericField>(
+  const [metricSetting, setMetric] = usePaneSettingValue<string>(
     "metric",
-    "marketCap",
+    initialMetric,
   );
+  // `--metric trailingPE,dividendYieldPercent` leads with the first and adds the others as columns.
+  const [metric, ...otherMetrics] = screenMetricSetting(metricSetting, initialMetric);
   const [mode, setMode] = usePluginPaneState("mode", "results");
   const [selectedId, setSelectedId] = usePluginPaneState<string | null>(
     "selected",
@@ -271,6 +285,10 @@ function EquityScreenView({
   const [savedSelectedId, setSavedSelectedId] = usePluginPaneState<
     string | null
   >("savedSelected", null);
+  const [ideaSelectedId, setIdeaSelectedId] = usePluginPaneState(
+    "ideaSelected",
+    SCREEN_IDEAS[0]!.id,
+  );
   const [currentSavedId, setCurrentSavedId] = usePluginPaneState<string | null>(
     "currentSaved",
     null,
@@ -356,8 +374,10 @@ function EquityScreenView({
     !opened && !results.loading && !results.loadingMore && !!data?.nextCursor,
     results.loadMore,
   );
-  const metricFields =
-    fields.data?.fields.filter((field) => field.kind === "number") ?? [];
+  const metricFields = pickerFields(
+    fields.data?.fields.filter((field) => field.kind === "number") ?? [],
+    [metric],
+  );
   // AS OF earns its column only when some row's focus metric is stale; the
   // snapshot decides, so a live quote freshening a row does not reflow the table.
   const staleFocus = snapshotRows.some((row) => row.metrics[metric]?.state === "stale");
@@ -367,7 +387,11 @@ function EquityScreenView({
   const ytdBase = screenYtdBase(snapshotRows, data?.snapshot?.assembledAt);
   // A screen its currency emptied says so, not that no company matches.
   const currencyEmpty = data && data.rows.length === 0 ? screenCurrencyEmpty(data.definition, data.universe) : null;
-  const columns = resultColumns(width, definition, metric, staleFocus, extendedSessions, ytdBase);
+  // A criterion's name that matches nothing (`Utility`) says so with the names it was likely meant as.
+  const unmatchedNames = data && data.rows.length === 0
+    ? unmatchedCategoryValues(data.definition, data).map(unmatchedCategoryText).join(" ") || null
+    : null;
+  const columns = resultColumns(width, definition, metric, staleFocus, extendedSessions, ytdBase, otherMetrics);
   const apply = (next: ScreenDefinition) => {
     try {
       setDefinition(parseScreenDefinition(next));
@@ -494,7 +518,7 @@ function EquityScreenView({
   useAutoRefresh(results.updatedAt, results.load);
   const openQueryControl = () => queryControl.current?.open();
   const hints =
-    saveForm || editing !== null || check
+    saveForm || editing !== null || check || mode === "ideas"
       ? []
       : mode === "criteria"
         ? [
@@ -783,7 +807,7 @@ function EquityScreenView({
               editing !== null ? (
                 <CriterionEditor
                   key={editing}
-                  fields={fields.data.fields}
+                  fields={pickerFields(fields.data.fields, editingCriterion ? [editingCriterion.field] : [])}
                   value={editingCriterion ?? null}
                   focused={focused}
                   width={width}
@@ -863,6 +887,36 @@ function EquityScreenView({
           />
         ) : null}
       </PaneStatusBody>
+    ) : mode === "ideas" ? (
+      <DataTableView
+        columns={[
+          { id: "name", label: "SCREEN", width: 28, align: "left" },
+          { id: "criteria", label: "CRITERIA", width: 20, flexGrow: 1, align: "left" },
+        ]}
+        items={SCREEN_IDEAS}
+        focused={focused && !saveForm}
+        rootWidth={width}
+        rootHeight={bodyHeight}
+        getItemKey={(row) => row.id}
+        selection={{
+          kind: "id",
+          selectedId: ideaSelectedId,
+          getId: (row) => row.id,
+          onChange: setIdeaSelectedId,
+        }}
+        onActivate={(row) => {
+          setMetric(row.metric);
+          apply(row.definition);
+          setCurrentSavedId(null);
+          setMode("results");
+        }}
+        renderCell={(row, column) => ({
+          text: column.id === "name" ? row.name : row.definition.criteria.map(criterionText).join("; "),
+        })}
+        sortColumnId={null}
+        sortDirection="asc"
+        emptyStateTitle="No ideas."
+      />
     ) : mode === "saved" ? (
       !access.emailVerified ? (
         <SignInWall
@@ -1042,8 +1096,9 @@ function EquityScreenView({
                 },
               });
             }}
-            emptyStateTitle={currencyEmpty?.title ?? "No equities match this screen."}
-            emptyStateHint={currencyEmpty ? `${currencyEmpty.detail} Choose ${currencyEmpty.base.currency} to screen in the base currency.` : undefined}
+            emptyStateTitle={(unmatchedNames ? null : currencyEmpty?.title) ?? "No equities match this screen."}
+            emptyStateHint={unmatchedNames
+              ?? (currencyEmpty ? `${currencyEmpty.detail} Choose ${currencyEmpty.base.currency} to screen in the base currency.` : undefined)}
           />
         </PaneStatusBody>
       </>

package/src/plugins/builtin/fixed-income/pane.tsx

@@ -51,7 +51,8 @@ const SECTION_VIEWS: Record<FixedIncomeSection, { defaultView: string; views: Vi
     defaultView: "documents",
     views: [
       { value: "documents", label: "Documents", paneType: "credit-documents", component: ResearchCreditDocumentsPane },
-      { value: "maturities", label: "Maturities", paneType: "debt-maturities", component: ResearchDebtMaturitiesPane },
+      // CRDOC's own Maturities tab is the contractual calendar-year wall; this is the filed fiscal-bucket schedule.
+      { value: "maturities", label: "Debt Schedule", paneType: "debt-maturities", component: ResearchDebtMaturitiesPane },
     ],
   },
   bonds: {

package/src/plugins/builtin/futures/use-board-terms.ts

@@ -1,12 +1,15 @@
 import { useEffect, useMemo, useState } from "react";
+import { ApiRequestError } from "../../../api-client/errors";
 import type { FuturesContractTermsPayload } from "../../../api-client/futures-curve";
 import type { FuturesContract } from "../../../market-data/futures-board";
+import { createTtlCache } from "../../../data/ttl-cache";
 import { loadFuturesContractTerms } from "../../../market-data/futures-contract";
+import { logFailure } from "../../../utils/log-failure";
 
 interface FuturesTermsState {
   /** The row's terms are still being asked for. */
   loading: boolean;
-  /** Null when the server has no terms for the symbol, or could not answer. */
+  /** Null while they are being asked for, when the server has none for the symbol, or when the read failed. */
   terms: FuturesContractTermsPayload | null;
 }
 
@@ -14,32 +17,35 @@ export type FuturesTermsMap = ReadonlyMap<string, FuturesTermsState>;
 
 /** The terms change with a roll, and a roll is decided once a day. */
 const TERMS_TTL_MS = 30 * 60_000;
+/**
+ * A read that failed is asked again after this: one blip leaves a row without
+ * its terms for a minute, not for the TTL, and a service that is down is asked
+ * once a minute, not once a tick.
+ */
+const TERMS_RETRY_MS = 60_000;
 /** Forty-odd rows open at once; a few requests at a time keep the board's quotes first. */
 const TERMS_CONCURRENCY = 4;
 
-interface CachedTerms {
-  at: number;
-  /** Null when the server has no terms for the symbol, or could not answer. */
-  terms: FuturesContractTermsPayload | null;
-}
-
-const termsCache = new Map<string, CachedTerms>();
-const inFlight = new Map<string, Promise<void>>();
+/**
+ * Null when the server has no terms for the symbol, which is an answer and is
+ * kept like any other. A read that fails is not kept as one: it rejects, and
+ * the cache holds the rejection for `TERMS_RETRY_MS`.
+ */
+const termsCache = createTtlCache<FuturesContractTermsPayload | null>({ ttlMs: TERMS_TTL_MS, rejectionMs: TERMS_RETRY_MS });
 
-function fresh(symbol: string, now: number): CachedTerms | undefined {
-  const cached = termsCache.get(symbol);
-  return cached && now - cached.at < TERMS_TTL_MS ? cached : undefined;
+async function readTerms(symbol: string): Promise<FuturesContractTermsPayload | null> {
+  try {
+    return await loadFuturesContractTerms(symbol);
+  } catch (error) {
+    if (error instanceof ApiRequestError && error.status === 404) return null;
+    throw error;
+  }
 }
 
-function loadTerms(symbol: string): Promise<void> {
-  const pending = inFlight.get(symbol);
-  if (pending) return pending;
-  const request = loadFuturesContractTerms(symbol)
-    .then((terms) => { termsCache.set(symbol, { at: Date.now(), terms }); })
-    .catch(() => { termsCache.set(symbol, { at: Date.now(), terms: null }); })
-    .finally(() => { inFlight.delete(symbol); });
-  inFlight.set(symbol, request);
-  return request;
+/** Whether the row has an answer; false when the read failed. */
+function loadTerms(symbol: string): Promise<boolean> {
+  return termsCache.load(symbol, () => readTerms(symbol))
+    .then(() => true, logFailure("futures", "Read a futures row's contract terms failed", false));
 }
 
 /**
@@ -51,32 +57,40 @@ function loadTerms(symbol: string): Promise<void> {
 export function useFuturesBoardTerms(contracts: readonly FuturesContract[], enabled: boolean): FuturesTermsMap {
   const symbolKey = contracts.map((contract) => contract.symbol).join(",");
   const [version, setVersion] = useState(0);
+  // Bumped once the retry delay has passed after a failed read, to ask again.
+  const [retry, setRetry] = useState(0);
 
   useEffect(() => {
     if (!enabled || !symbolKey) return;
-    const now = Date.now();
-    const queue = symbolKey.split(",").filter((symbol) => !fresh(symbol, now));
+    const queue = symbolKey.split(",").filter((symbol) => termsCache.peek(symbol) === undefined);
     if (queue.length === 0) return;
     let cancelled = false;
+    let failed = false;
+    let retryTimer: ReturnType<typeof setTimeout> | undefined;
     const worker = async () => {
       for (let symbol = queue.shift(); symbol; symbol = queue.shift()) {
-        await loadTerms(symbol);
+        if (!await loadTerms(symbol)) failed = true;
         if (!cancelled) setVersion((current) => current + 1);
       }
     };
-    void Promise.all(Array.from({ length: Math.min(TERMS_CONCURRENCY, queue.length) }, worker));
+    void Promise.all(Array.from({ length: Math.min(TERMS_CONCURRENCY, queue.length) }, worker)).then(() => {
+      if (failed && !cancelled) retryTimer = setTimeout(() => setRetry((current) => current + 1), TERMS_RETRY_MS);
+    });
     return () => {
       cancelled = true;
       queue.length = 0;
+      clearTimeout(retryTimer);
     };
-  }, [enabled, symbolKey]);
+  }, [enabled, symbolKey, retry]);
 
   return useMemo(() => {
     const result = new Map<string, FuturesTermsState>();
     if (!enabled) return result;
     for (const symbol of symbolKey ? symbolKey.split(",") : []) {
-      const cached = termsCache.get(symbol);
-      result.set(symbol, { loading: !cached, terms: cached?.terms ?? null });
+      // A row keeps the terms it had past their TTL until the next load lands, and
+      // one whose read failed draws without them rather than waiting on a retry.
+      const terms = termsCache.peek(symbol, { stale: true });
+      result.set(symbol, { loading: terms === undefined && !termsCache.failed(symbol), terms: terms ?? null });
     }
     return result;
     // `version` re-reads the cache as loads land.

package/src/plugins/builtin/futures/use-front-returns.ts

@@ -1,6 +1,9 @@
 import { useEffect, useMemo, useState } from "react";
+import { createTtlCache } from "../../../data/ttl-cache";
 import type { DataProvider } from "../../../types/data-provider";
+import { isNoSourceAnswer } from "../../../sources/provider-errors";
 import type { PricePoint } from "../../../types/financials";
+import { logFailure } from "../../../utils/log-failure";
 import type { BoardQuoteMap } from "../shared/use-quote-board";
 import type { FuturesContract } from "../../../market-data/futures-board";
 import {
@@ -24,32 +27,33 @@ export type FrontReturnsMap = ReadonlyMap<string, FrontReturnsState>;
  * for half an hour; the live quote moves the returns in between.
  */
 const HISTORY_TTL_MS = 30 * 60_000;
+/**
+ * A read that failed is asked again after this: one blip leaves a row without
+ * returns for a minute, not for the TTL, and a service that is down is asked
+ * once a minute, not once a tick.
+ */
+const HISTORY_RETRY_MS = 60_000;
 /** Forty-odd contracts open at once; a few requests at a time keep the board's quotes first. */
 const HISTORY_CONCURRENCY = 4;
 
-interface CachedHistory {
-  at: number;
-  /** Null when the contract has no history to read (delisted, unknown). */
-  points: readonly PricePoint[] | null;
-}
-
-const historyCache = new Map<string, CachedHistory>();
-const inFlight = new Map<string, Promise<void>>();
+/**
+ * Null when the source has no history for the contract (delisted, unknown),
+ * which is an answer and is kept like any other. A read that fails is not kept
+ * as one: it rejects, and the cache holds the rejection for `HISTORY_RETRY_MS`.
+ */
+const historyCache = createTtlCache<readonly PricePoint[] | null>({ ttlMs: HISTORY_TTL_MS, rejectionMs: HISTORY_RETRY_MS });
 
-function freshHistory(symbol: string, now: number): CachedHistory | undefined {
-  const cached = historyCache.get(symbol);
-  return cached && now - cached.at < HISTORY_TTL_MS ? cached : undefined;
+function readHistory(provider: DataProvider, symbol: string): Promise<readonly PricePoint[] | null> {
+  return provider.getPriceHistory(symbol, "", "1Y").then((points) => points.length > 0 ? points : null, (error: unknown) => {
+    if (isNoSourceAnswer(error)) return null;
+    throw error;
+  });
 }
 
-function loadHistory(provider: DataProvider, symbol: string): Promise<void> {
-  const pending = inFlight.get(symbol);
-  if (pending) return pending;
-  const request = provider.getPriceHistory(symbol, "", "1Y")
-    .then((points) => { historyCache.set(symbol, { at: Date.now(), points: points.length > 0 ? points : null }); })
-    .catch(() => { historyCache.set(symbol, { at: Date.now(), points: null }); })
-    .finally(() => { inFlight.delete(symbol); });
-  inFlight.set(symbol, request);
-  return request;
+/** Whether the contract has an answer; false when the read failed. */
+function loadHistory(provider: DataProvider, symbol: string): Promise<boolean> {
+  return historyCache.load(symbol, () => readHistory(provider, symbol))
+    .then(() => true, logFailure("futures", "Read a futures contract's history failed", false));
 }
 
 /**
@@ -73,27 +77,33 @@ export function useFrontContractReturns(
     return [symbol, list ? list.split(",") : []] as const;
   })), [candidateKey]);
   const [version, setVersion] = useState(0);
+  // Bumped once the retry delay has passed after a failed read, to ask again.
+  const [retry, setRetry] = useState(0);
   // A board left open overnight reloads once the day turns.
   const today = new Date().toISOString().slice(0, 10);
 
   useEffect(() => {
     if (!enabled || !provider) return;
-    const now = Date.now();
-    const queue = [...new Set([...candidates.values()].flat())].filter((symbol) => !freshHistory(symbol, now));
+    const queue = [...new Set([...candidates.values()].flat())].filter((symbol) => historyCache.peek(symbol) === undefined);
     if (queue.length === 0) return;
     let cancelled = false;
+    let failed = false;
+    let retryTimer: ReturnType<typeof setTimeout> | undefined;
     const worker = async () => {
       for (let symbol = queue.shift(); symbol; symbol = queue.shift()) {
-        await loadHistory(provider, symbol);
+        if (!await loadHistory(provider, symbol)) failed = true;
         if (!cancelled) setVersion((current) => current + 1);
       }
     };
-    void Promise.all(Array.from({ length: Math.min(HISTORY_CONCURRENCY, queue.length) }, worker));
+    void Promise.all(Array.from({ length: Math.min(HISTORY_CONCURRENCY, queue.length) }, worker)).then(() => {
+      if (failed && !cancelled) retryTimer = setTimeout(() => setRetry((current) => current + 1), HISTORY_RETRY_MS);
+    });
     return () => {
       cancelled = true;
       queue.length = 0;
+      clearTimeout(retryTimer);
     };
-  }, [candidates, enabled, provider, today]);
+  }, [candidates, enabled, provider, today, retry]);
 
   return useMemo(() => {
     const result = new Map<string, FrontReturnsState>();
@@ -101,12 +111,14 @@ export function useFrontContractReturns(
     for (const contract of contracts) {
       const quote = quotes.get(contract.symbol)?.quote;
       const symbols = candidates.get(contract.symbol) ?? [];
-      const loaded = symbols.map((symbol) => ({ symbol, cached: historyCache.get(symbol) }));
-      if (loaded.some((entry) => !entry.cached)) {
+      // A contract keeps the history it had past its TTL until the next load lands,
+      // and one whose read failed counts as having none rather than waiting on a retry.
+      const loaded = symbols.map((symbol) => ({ symbol, history: historyCache.peek(symbol, { stale: true }), failed: historyCache.failed(symbol) }));
+      if (loaded.some((entry) => entry.history === undefined && !entry.failed)) {
         result.set(contract.symbol, { loading: true, values: NO_FUTURES_RETURNS });
         continue;
       }
-      const available = loaded.flatMap((entry) => entry.cached?.points ? [{ symbol: entry.symbol, history: entry.cached.points }] : []);
+      const available = loaded.flatMap((entry) => entry.history ? [{ symbol: entry.symbol, history: entry.history }] : []);
       const front = pickFrontContract(available, quote?.price);
       const history = available.find((entry) => entry.symbol === front)?.history;
       result.set(contract.symbol, {
@@ -118,3 +130,8 @@ export function useFrontContractReturns(
     // `version` re-reads the history cache as loads land.
   }, [candidates, contracts, enabled, quotes, version]);
 }
+
+/** Forgets every cached contract's history (tests). */
+export function resetFrontContractReturns(): void {
+  historyCache.clear();
+}

package/src/plugins/builtin/fx-matrix/client.ts

@@ -5,7 +5,7 @@ import { resolveEntryData } from "../../../market-data/selectors";
 import type { DataProvider } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
 import { quoteChangeBasis, type QuoteChangeBasis } from "../../../market-data/market/change-basis";
-import { fxLegMoveReference, fxLegs, fxLegSavedAt, liveFxLegEntry, type FxLeg } from "./live-legs";
+import { fxBoardMoveDay, fxLegMoveReference, fxLegs, fxLegSavedAt, liveFxLegEntry, type FxLeg } from "./live-legs";
 
 /** One USD leg as the board reads it: the rate it draws and where that rate came from. */
 export interface FxLegReading {
@@ -17,7 +17,8 @@ export interface FxLegReading {
   /**
    * USD per unit at the pair quote's previous daily close, for the rate drawn
    * whether it is the quote's or a loaded rate of the same FX trading day
-   * (fxLegMoveReference); null when the quote is stale or has none.
+   * (fxLegMoveReference); null when the quote is stale, has none, or is not
+   * of the board's trading day (fxBoardMoveDay).
    */
   reference: number | null;
   /** The close `reference` is, as `quote` names it ("vs Wed 21 Oct close"). */
@@ -51,12 +52,14 @@ export async function loadFxBoard(
       coordinator.loadQuotesBatch(legs.map((leg) => ({ symbol: leg.symbol, exchange: "" })), { forceRefresh })
         .catch(logFailure("fx-matrix.client", "Load FX pair quotes failed", [] as QueryEntry<Quote>[])),
     ]);
+    // Every leg moves from the board's one close, read off the clock, as the pane's tint does.
+    const boardDay = fxBoardMoveDay(quotes);
     return new Map(legs.map((leg, index) => {
       const rate = rates[index]!;
       const quote = quotes[index];
       const live = liveFxLegEntry(leg, quote, rate);
       const entry = live ?? (resolveEntryData(rate) != null ? rate : null);
-      const close = fxLegMoveReference(leg, quote, entry);
+      const close = fxLegMoveReference(leg, quote, entry, boardDay);
       // A pair quote or a loaded rate whose refresh failed is the copy saved before, not a current answer.
       const savedAt = fxLegSavedAt(live ? resolveEntryData(quote) : null, rate);
       return [leg.currency, {

package/src/plugins/builtin/fx-matrix/headless.ts

@@ -94,7 +94,7 @@ export function projectFxCrosses(
     }, saved.length > 0 ? Math.min(...saved) : Number.NaN);
   }));
 
-  // The closes the moves are read from: one day for a board read at once, "vs mixed closes" otherwise.
+  // The close the moves are read from: the board's one trading day (fxBoardMoveDay), never mixed closes.
   const moveBasis = combinedChangeBasisLabel(currencies.map((currency) => readings.get(currency)?.changeBasis));
   const unavailable = currencies.filter((currency) => !rates.has(currency));
   const errors = unavailable.flatMap((currency) => {

package/src/plugins/builtin/fx-matrix/index.tsx

@@ -26,7 +26,7 @@ import { fxRateObservations } from "../shared/fx-rate-freshness";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { useAutoRefresh, useUpdatedAgo } from "../../../react/auto-refresh";
 import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
-import { fxLegMoveReference, fxLegQuoteKey, fxLegReferenceRate, fxLegSavedAt, fxLegTargets, fxLegs, fxLegsBehind, liveFxLegEntry } from "./live-legs";
+import { fxBoardMoveDay, fxLegMoveReference, fxLegQuoteKey, fxLegReferenceRate, fxLegSavedAt, fxLegTargets, fxLegs, fxLegsBehind, liveFxLegEntry } from "./live-legs";
 import { CURRENCY_FLAG_REGIONS, FX_CURRENCIES, formatRate, resolveCurrencies, type FxCurrency } from "./pairs";
 import { crossMovePercent, directionTint, nextTintLevel } from "./direction";
 import { fxMatrixSettings } from "./settings";
@@ -101,9 +101,11 @@ function FxMatrixPane({ focused, width, height }: PaneProps) {
   const directionReferences = useMemo(() => {
     const coordinator = getSharedMarketDataCoordinator();
     const references = new Map<string, number>([["USD", 1]]);
+    // One close for the board, read off the clock (fxBoardMoveDay): a leg on another day has no move.
+    const boardDay = fxBoardMoveDay(legs.map((leg) => legEntries.get(fxLegQuoteKey(leg))), Date.now());
     for (const leg of legs) {
       const drawn = liveEntries.get(leg.currency) ?? coordinator?.getFxEntry(leg.currency);
-      const reference = fxLegMoveReference(leg, legEntries.get(fxLegQuoteKey(leg)), drawn);
+      const reference = fxLegMoveReference(leg, legEntries.get(fxLegQuoteKey(leg)), drawn, boardDay);
       if (reference) references.set(leg.currency, reference.rate);
     }
     return references;

package/src/plugins/builtin/fx-matrix/live-legs.ts

@@ -3,7 +3,8 @@ import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors"
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { Quote } from "../../../types/financials";
 import { isStreamCarryingQuote } from "../shared/use-quote-board";
-import { fxTradingDay } from "../../../utils/fx-market-hours";
+import { fxPrintTradingDay, fxTradingDay, fxTradingDayAt } from "../../../utils/fx-market-hours";
+import { delayedFeedLagMs } from "../../../market-data/market/freshness";
 import { savedCopyAt } from "../../../data/saved-copies";
 
 /** Currencies the market quotes as USD per unit; the rest quote as units per USD. */
@@ -106,22 +107,60 @@ export function fxLegReferenceRate(leg: FxLeg, entry: QueryEntry<Quote> | undefi
   return leg.inverted ? 1 / close : close;
 }
 
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * The FX trading day a pair quote's move is of: the day its source dated
+ * (`changeSessionDate`), else the day of its print, which turns at 17:00 New
+ * York. Null for a stale quote, or an undated print made while the market was
+ * shut, which is of no trading day.
+ */
+function fxLegMoveDay(quote: Quote | null | undefined): string | null {
+  if (!quote || quote.stale === true || !Number.isFinite(quote.lastUpdated)) return null;
+  if (quote.changeSessionDate && ISO_DATE.test(quote.changeSessionDate)) return quote.changeSessionDate;
+  return fxPrintTradingDay(quote.lastUpdated);
+}
+
+/** How far behind the present a leg's quote is held: a delayed feed's lag, none for a live one. */
+function legDelayMs(quote: Quote | null | undefined): number {
+  return quote?.dataSource === "delayed" ? delayedFeedLagMs(quote.listingExchangeName || quote.exchangeName || "CCY") : 0;
+}
+
+/**
+ * The one FX trading day a board's moves are read on, from the clock: the
+ * day the market is on as the legs' feed shows it, `now` less the longest
+ * delay among their quotes, or the Friday that closed the week while FX is
+ * shut (fxTradingDayAt). A leg's quote is never trusted to set it, so a leg
+ * dated ahead of the clock, or on a weekend, cannot move the board's close:
+ * only its own move goes blank (fxLegMoveReference).
+ */
+export function fxBoardMoveDay(quotes: Iterable<QueryEntry<Quote> | undefined>, now = Date.now()): string | null {
+  let delay = 0;
+  for (const entry of quotes) delay = Math.max(delay, legDelayMs(resolveEntryData(entry)));
+  return fxTradingDayAt(now - delay);
+}
+
 /**
  * What a leg's move is read against: its pair quote's previous daily close
  * (USD per unit), the close `quote` measures the pair from, whichever rate
  * the board draws. A loaded rate a minute newer than the quote moves from the
  * same close, so it reads against it too, as long as it is of the quote's FX
- * trading day. Null when the quote is stale or carries no previous close, or
- * when the drawn rate is of a later trading day (or undated) than the quote.
+ * trading day. Null when the quote is stale or carries no previous close,
+ * when the drawn rate is of a later trading day (or undated) than the quote,
+ * or when the quote's move is not of the board's day (`boardDay`,
+ * fxBoardMoveDay): a quote dated ahead of it or on a weekend, or a thin pair
+ * that has not printed since the day turned, whose move is the day before's.
  */
 export function fxLegMoveReference(
   leg: FxLeg,
   entry: QueryEntry<Quote> | undefined,
   drawn: Pick<QueryEntry<number>, "asOf"> | null | undefined,
+  boardDay: string | null,
 ): { rate: number; quote: Quote } | null {
   const quote = resolveEntryData(entry);
   const rate = fxLegReferenceRate(leg, entry);
   if (!quote || quote.stale === true || rate == null || !Number.isFinite(quote.lastUpdated)) return null;
+  if (boardDay == null || fxLegMoveDay(quote) !== boardDay) return null;
   const drawnAt = drawn?.asOf;
   if (drawnAt == null || !Number.isFinite(drawnAt) || fxTradingDay(drawnAt) !== fxTradingDay(quote.lastUpdated)) return null;
   return { rate, quote };

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

@@ -1,6 +1,6 @@
 import type { GpuObservation } from "../../../api-client/gpu";
 import type { HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/plugin";
-import { formatUtcTime } from "../../../utils/utc-time";
+import { formatUtcTime, parseReportTime } from "../../../utils/utc-time";
 import { fetchGpuBoard, fetchGpuEvents, fetchGpuHistory, fetchGpuModelPreviews, gpuPreviewModels, loadGpuEquityHistory } from "./client";
 import {
   GPU_TABS, gpuBasisLabel, gpuChange, gpuChangesLocked, gpuEquityGap, gpuEquityModels, gpuEquityRows, gpuEventDate, gpuFamilies, gpuFamily,
@@ -16,7 +16,13 @@ const observationRow = (row: GpuObservation) => ({ gpu: gpuLabel(row), source: g
 const percent = (value: unknown) => gpuChange(typeof value === "number" ? value : null);
 /** Prices to the cent and times to the minute, as the pane draws them; exports keep the full value. */
 const price = (value: unknown) => typeof value === "number" ? gpuPrice(value) : "-";
-const minute = (value: unknown) => typeof value === "string" ? formatUtcTime(value) : "-";
+const DAY_MS = 86_400_000;
+/** A reference index's daily figure is stamped at 00:00 UTC: that is a day, not a time to the minute. */
+const minute = (value: unknown) => {
+  if (typeof value !== "string") return "-";
+  const time = parseReportTime(value);
+  return time && !time.dateOnly && time.time % DAY_MS === 0 ? formatUtcTime({ ...time, dateOnly: true }) : formatUtcTime(value);
+};
 /** A move the free preview leaves to Pro says so, instead of reading as missing. */
 const change = (value: unknown, row: HeadlessPaneRow) => row.changesLocked === true ? "Pro" : percent(value);
 const columns = [

package/src/plugins/builtin/help/function-index.ts

@@ -24,6 +24,8 @@ export interface HelpFunction {
   argPlaceholder?: string;
   argOptional?: boolean;
   help: FunctionHelp | null;
+  /** Left out of `HELP <words>` matches, as of every list (`listed: false`); `HELP` with its code still answers. */
+  unlisted?: true;
 }
 
 export interface HelpFunctionSources {
@@ -97,6 +99,7 @@ export function buildHelpFunctionIndex(sources: HelpFunctionSources): HelpFuncti
       argPlaceholder: template.shortcut?.argPlaceholder
         ?? (template.shortcut?.argKind === "ticker-list" ? "tickers" : template.shortcut?.argKind),
       argOptional: template.shortcut?.argOptional,
+      ...(template.listed === false ? { unlisted: true as const } : {}),
     }));
   }
 
@@ -165,7 +168,7 @@ export function parseHelpArgument(arg: string, index: HelpFunctionIndex): HelpRe
 
   const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
   const matches = listHelpFunctions(index)
-    .filter((fn) => fn.code !== HELP_CODE)
+    .filter((fn) => fn.code !== HELP_CODE && !fn.unlisted)
     .map((fn) => ({ fn, score: searchScore(fn, terms) }))
     .filter(({ score }) => score > 0)
     .sort((left, right) => right.score - left.score || left.fn.code.localeCompare(right.fn.code))