gloomberb 0.18.0 → 0.18.2

package/src/plugins/builtin/econ/index.tsx

@@ -20,6 +20,7 @@ import type { PluginModule } from "../plugin-module";
 import { colors, blendHex } from "../../../theme/colors";
 import type { EconEvent } from "./types";
 import { FRED_CATALOG_SERIES } from "./fred-catalog";
+import { ECON_PRINT_NOTIFICATIONS_ENABLED_KEY, retainVisiblePrintRefresh, setupHighImpactPrintNotifications } from "./print-watch";
 import { EconDetailView } from "./detail-view";
 import {
   COUNTRY_CYCLE,
@@ -35,6 +36,7 @@ import {
   formatCountdown,
   formatStaleness,
   getCalendarCache,
+  subscribeCalendar,
   impactIndicator,
   loadCalendar,
   matchesCountry,
@@ -75,10 +77,16 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   // loadCalendar serves a fresh cache without a request, so the pane can always
   // ask and still follow the global cadence once the cache goes stale.
   const calendar = useAsyncResource<CalendarResult>(loadEvents, { initialData: cachedEvents });
+  // A load made elsewhere, such as the print watch asking while a release is
+  // due, reaches the open pane through the cache; the newer of the two wins.
+  const [cacheVersion, setCacheVersion] = useState(0);
+  useEffect(() => subscribeCalendar(() => setCacheVersion((version) => version + 1)), []);
+  const cached = useMemo(() => getCalendarCache(), [cacheVersion]);
+  const shown = cached && (!calendar.data || cached.fetchedAt > calendar.data.fetchedAt) ? cached : calendar.data;
   const { loading } = calendar;
-  const events = calendar.data?.data ?? NO_EVENTS;
-  const stale = calendar.data?.stale ?? false;
-  const fetchedAt = calendar.data?.fetchedAt ?? null;
+  const events = shown?.data ?? NO_EVENTS;
+  const stale = shown?.stale ?? false;
+  const fetchedAt = shown?.fetchedAt ?? null;
   // A cache that could not be refreshed arrives as a result, not a failure.
   const error = calendar.error ?? (loading ? null : calendar.data?.refreshError ?? null);
   // The selected row and the open event are remembered by event id, so a
@@ -94,8 +102,11 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
 
   useAutoRefresh(stale ? null : fetchedAt, calendar.load);
 
-  // Tick every 30s to update staleness + countdown, only while the pane can be seen.
   const paneVisible = usePaneVisible();
+  // In view, a due high-impact print is asked for on the print watch's timing
+  // and lands here through the cache; a covered or hidden pane asks nothing.
+  useEffect(() => (paneVisible ? retainVisiblePrintRefresh() : undefined), [paneVisible]);
+  // Tick every 30s to update staleness + countdown, only while the pane can be seen.
   useEffect(() => {
     if (!paneVisible) return;
     setNow(Date.now());
@@ -437,6 +448,8 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   );
 }
 
+let stopPrintWatch: (() => void) | null = null;
+
 export const economicCalendarModule: PluginModule = {
   series: FRED_CATALOG_SERIES,
   panes: [{
@@ -449,6 +462,16 @@ export const economicCalendarModule: PluginModule = {
     defaultMode: "floating",
     defaultFloatingSize: { width: 100, height: 30 },
     tableExport: true,
+    settings: {
+      title: "Economic Calendar Settings",
+      fields: [{
+        key: ECON_PRINT_NOTIFICATIONS_ENABLED_KEY,
+        label: "Notifications",
+        description: "Notify when a high-impact release prints, even while this pane is closed.",
+        type: "toggle",
+        storage: "plugin",
+      }],
+    },
   }],
   paneTemplates: [{
     id: "econ-calendar-pane",
@@ -461,8 +484,12 @@ export const economicCalendarModule: PluginModule = {
   }],
   setup(ctx) {
     attachEconCalendarPersistence(ctx.persistence);
+    stopPrintWatch?.();
+    stopPrintWatch = setupHighImpactPrintNotifications(ctx);
   },
   dispose() {
+    stopPrintWatch?.();
+    stopPrintWatch = null;
     resetEconCalendarPersistence();
   },
 };

package/src/plugins/builtin/econ/print-watch.ts

@@ -0,0 +1,279 @@
+import type { GloomPluginContext } from "../../../types/plugin";
+import {
+  getCalendarCache,
+  landedHighImpactPrints,
+  loadCalendar,
+  pendingHighImpactPrints,
+  PRINT_PENDING_MS,
+  subscribeCalendar,
+  type EconCalendarCacheEntry,
+} from "./calendar-model";
+import type { EconEvent } from "./types";
+
+/** The ECO setting that turns the print toast on. Off until the user turns it on, as breaking news is. */
+export const ECON_PRINT_NOTIFICATIONS_ENABLED_KEY = "econPrintNotificationsEnabled";
+
+const TOAST_DURATION_MS = 20_000;
+/**
+ * The waits between asks while a print is due: short just after the release
+ * time, when most prints land, then longer until the window closes, which
+ * keeps a release to about twenty asks per app instead of eighty.
+ */
+const PRINT_BACKOFF_MS = [15_000, 30_000, 60_000] as const;
+/** Each wait moves by up to a fifth either way, so apps that started together drift apart. */
+const PRINT_JITTER = 0.2;
+/** How often the watch looks at the calendar it already has while nothing is due. */
+const PRINT_IDLE_MS = 60_000;
+/** While idle, a calendar this old is asked for again, so a release added since is known. */
+const CALENDAR_RECHECK_MS = 6 * 60 * 60 * 1000;
+/** With no calendar at all, how long a failed ask waits before the next. */
+const NO_CALENDAR_RETRY_MS = 5 * 60 * 1000;
+
+type CalendarRead = Pick<EconCalendarCacheEntry, "data" | "fetchedAt">;
+
+export interface PrintWatchDeps {
+  now: () => number;
+  /** Asks for the calendar; `force` skips a fresh cache. */
+  load: (force: boolean) => Promise<CalendarRead>;
+  /** The cached calendar, however old, without a request. */
+  read: () => CalendarRead | null;
+  /** Called whenever anyone, a pane included, loads the calendar. */
+  subscribe: (listener: () => void) => () => void;
+  schedule: (run: () => Promise<void> | void, delay: number) => () => void;
+  random: () => number;
+}
+
+const DEFAULT_DEPS: PrintWatchDeps = {
+  now: Date.now,
+  load: (force) => loadCalendar(force),
+  read: () => getCalendarCache({ allowExpired: true }),
+  subscribe: subscribeCalendar,
+  schedule: (run, delay) => {
+    const timer = setTimeout(run, delay);
+    return () => clearTimeout(timer);
+  },
+  random: Math.random,
+};
+
+function printBody(event: EconEvent): string {
+  return event.forecast ? `${event.event} ${event.actual} vs ${event.forecast}` : `${event.event} ${event.actual}`;
+}
+
+type PrintWatchContext = Pick<GloomPluginContext, "notify" | "showPane">;
+
+/**
+ * Toasts a high-impact print once, when it lands within
+ * {@link PRINT_PENDING_MS} of its release time. While one is due the
+ * calendar is asked for on {@link PRINT_BACKOFF_MS}, and every read is
+ * compared: the watch's own, its idle look at the cache, and a pane's
+ * refresh. The first read only records what has already printed.
+ */
+export function startHighImpactPrintWatch(
+  ctx: PrintWatchContext,
+  overrides: Partial<PrintWatchDeps> = {},
+): () => void {
+  const deps: PrintWatchDeps = { ...DEFAULT_DEPS, ...overrides };
+  let stopped = false;
+  let running = false;
+  let cancel: (() => void) | null = null;
+  /** The newest calendar the watch has seen. */
+  let latest: CalendarRead | null = null;
+  let lastAskAt = Number.NEGATIVE_INFINITY;
+  let primed = false;
+  /**
+   * Each high-impact row not yet past its window, by id: null while blank,
+   * then its number. A number stays once seen, so a print that blanks and
+   * comes back is not a new print.
+   */
+  const actuals = new Map<string, string | null>();
+  const expiries = new Map<string, number>();
+  let attempt = 0;
+  let dueIds = new Set<string>();
+
+  const toast = (event: EconEvent) => {
+    ctx.notify({
+      title: event.country,
+      body: printBody(event),
+      type: "info",
+      desktop: "always",
+      sound: "Glass",
+      duration: TOAST_DURATION_MS,
+      refId: `econ:${event.id}`,
+      action: { label: "Open", onClick: () => ctx.showPane("econ-calendar") },
+    });
+  };
+
+  /** `now` is when the read was asked for, so a print the last ask in the window brings back still counts. */
+  const observe = (read: CalendarRead | null, now = deps.now()) => {
+    if (stopped || !read) return;
+    if (!latest || read.fetchedAt >= latest.fetchedAt) latest = read;
+    const landed = primed ? landedHighImpactPrints(actuals, read.data) : [];
+    for (const event of read.data) {
+      if (event.impact !== "high") continue;
+      const expiresAt = event.date.getTime() + PRINT_PENDING_MS;
+      if (expiresAt < now) continue;
+      expiries.set(event.id, expiresAt);
+      if (event.actual) actuals.set(event.id, event.actual);
+      else if (!actuals.has(event.id)) actuals.set(event.id, null);
+    }
+    for (const [id, expiresAt] of expiries) {
+      if (expiresAt >= now) continue;
+      expiries.delete(id);
+      actuals.delete(id);
+    }
+    primed = true;
+    // A print that turns up after its window is recorded, not announced late.
+    for (const event of landed) {
+      if (now - event.date.getTime() <= PRINT_PENDING_MS) toast(event);
+    }
+  };
+
+  /** Whether a print in the newest calendar is due and still within its window. */
+  const printDue = (now: number): boolean => {
+    const pending = latest ? pendingHighImpactPrints(latest.data, now) : [];
+    // A release that has just come due starts the waits over.
+    if (pending.length === 0 || pending.some((event) => !dueIds.has(event.id))) attempt = 0;
+    dueIds = new Set(pending.map((event) => event.id));
+    return pending.length > 0;
+  };
+
+  const backoff = (): number => {
+    const base = PRINT_BACKOFF_MS[Math.min(attempt, PRINT_BACKOFF_MS.length - 1)]!;
+    attempt += 1;
+    return Math.round(base * (1 + (deps.random() * 2 - 1) * PRINT_JITTER));
+  };
+
+  const askWhileIdle = (now: number): boolean => (latest
+    ? now - Math.max(latest.fetchedAt, lastAskAt) >= CALENDAR_RECHECK_MS
+    : now - lastAskAt >= NO_CALENDAR_RETRY_MS);
+
+  const arm = (delay: number) => {
+    if (stopped || cancel) return;
+    cancel = deps.schedule(() => {
+      cancel = null;
+      return run();
+    }, delay);
+  };
+
+  const run = async () => {
+    if (stopped || running) return;
+    observe(deps.read());
+    const before = deps.now();
+    const due = printDue(before);
+    if (!due && !askWhileIdle(before)) {
+      arm(PRINT_IDLE_MS);
+      return;
+    }
+    running = true;
+    lastAskAt = before;
+    try {
+      // A due print is asked for past the cache; otherwise a fresh cache answers without a request.
+      observe(await deps.load(due), before);
+    } catch {
+      // The next ask follows the same schedule.
+    } finally {
+      running = false;
+    }
+    if (stopped) return;
+    // Past the window nothing is due, so the asks stop and the watch goes back to idle looks.
+    arm(printDue(deps.now()) ? backoff() : PRINT_IDLE_MS);
+  };
+
+  // A load the watch is waiting on is compared when it answers, at the time it was asked.
+  const unsubscribe = deps.subscribe(() => {
+    if (!running) observe(deps.read());
+  });
+  void run();
+  return () => {
+    stopped = true;
+    unsubscribe();
+    cancel?.();
+    cancel = null;
+  };
+}
+
+type PrintNotificationContext = PrintWatchContext & Pick<GloomPluginContext, "configState" | "on">;
+
+function printNotificationsEnabled(ctx: Pick<GloomPluginContext, "configState">): boolean {
+  return ctx.configState.get<boolean>(ECON_PRINT_NOTIFICATIONS_ENABLED_KEY) === true;
+}
+
+/**
+ * The one print watch, run while anything wants it: the Notifications
+ * setting, or an ECO pane in view, which fills a print in as it lands. Every
+ * reason shares its timing and its requests; only the setting toasts.
+ */
+export interface PrintRefresh {
+  /** The plugin's context, for toasts and their Open; null once it is disposed. */
+  attach(ctx: PrintWatchContext | null): void;
+  setNotifying(on: boolean): void;
+  /** An ECO pane can be seen; the returned release says it no longer can. */
+  retainVisiblePane(): () => void;
+}
+
+export function createPrintRefresh(
+  start: (ctx: PrintWatchContext) => () => void = startHighImpactPrintWatch,
+): PrintRefresh {
+  let host: PrintWatchContext | null = null;
+  let notifying = false;
+  let visiblePanes = 0;
+  let stopWatch: (() => void) | null = null;
+  // A print that lands while only a pane wants the watch is recorded, not toasted.
+  const watchContext: PrintWatchContext = {
+    notify: (notice) => {
+      if (notifying) host?.notify(notice);
+    },
+    showPane: (paneId) => host?.showPane(paneId),
+  };
+  const sync = () => {
+    const wanted = notifying || visiblePanes > 0;
+    if (wanted && !stopWatch) stopWatch = start(watchContext);
+    if (!wanted && stopWatch) {
+      stopWatch();
+      stopWatch = null;
+    }
+  };
+  return {
+    attach(ctx) {
+      host = ctx;
+    },
+    setNotifying(on) {
+      notifying = on;
+      sync();
+    },
+    retainVisiblePane() {
+      visiblePanes += 1;
+      sync();
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        visiblePanes -= 1;
+        sync();
+      };
+    },
+  };
+}
+
+const printRefresh = createPrintRefresh();
+
+/** For the ECO pane: while it can be seen, a due high-impact print is asked for on the watch's timing. */
+export function retainVisiblePrintRefresh(): () => void {
+  return printRefresh.retainVisiblePane();
+}
+
+/** Toasts prints while the Notifications setting is on; off, only a pane in view keeps the watch asking. */
+export function setupHighImpactPrintNotifications(
+  ctx: PrintNotificationContext,
+  refresh: PrintRefresh = printRefresh,
+): () => void {
+  refresh.attach(ctx);
+  const sync = () => refresh.setNotifying(printNotificationsEnabled(ctx));
+  const disposeConfigListener = ctx.on("config:changed", sync);
+  sync();
+  return () => {
+    disposeConfigListener();
+    refresh.setNotifying(false);
+    refresh.attach(null);
+  };
+}

package/src/plugins/builtin/equity-screener/headless.ts

@@ -1,10 +1,12 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import type { HeadlessPaneColumn, HeadlessPaneContext } from "../../../types/headless";
 import {
+  KPI_FIELDS,
   NUMERIC_FIELDS,
   type NumericField,
   type ScreenRow,
 } from "../../../api-client/equity-screener";
+import { KPI_COVERAGE_NOTE } from "../company-kpis/model";
 import { EXTENDED_SESSION_LABELS, type ExtendedSession } from "../../../market-data/market/status";
 import { buildQuoteKey } from "../../../market-data/selectors";
 import type { Quote } from "../../../types/financials";
@@ -17,8 +19,11 @@ import {
   formatScreenValue,
   metricDate,
   parseScreenDefinition,
+  screenColumnLabel,
   screenDefinitionSyntax,
-  SHORT_LABELS,
+  screenLabel,
+  screenYtdBase,
+  withheldMetricNote,
 } from "./model";
 import type { ScreenDefinition } from "../../../api-client/equity-screener";
 
@@ -128,12 +133,21 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
     // A sort on one of them is redone on those figures.
     const rows = sortLiveScreenRows(overlayScreenQuotes(data.rows, await loadRowQuotes(data.rows, ctx)), data.definition.sort);
     const extendedSessions = screenExtendedSessions(rows);
+    // A Pro metric the server held back from Free says so once, as KPIS says it; a KPI
+    // with gaps says what a gap is, as KPIS does.
+    const withheld = rows.some((row) => row.metrics[metric].access === "pro");
+    const errors = withheld ? [...data.warnings, withheldMetricNote(metric)] : data.warnings;
+    const missing = rows.filter((row) => row.metrics[metric].value === null).length;
+    const kpiGaps = !withheld && missing > 0 && (KPI_FIELDS as readonly string[]).includes(metric)
+      ? [`${missing} of ${rows.length} ${rows.length === 1 ? "row has" : "rows have"} no ${screenLabel(metric)}. ${KPI_COVERAGE_NOTE}`]
+      : [];
     // Payload status also counts ordinary per-field sparsity; only generation
     // warnings are failures, and more pages are not an error.
     return {
       freshness: { asOf: data.snapshot?.sourceNewestAt ?? null },
-      complete: !data.nextCursor && data.warnings.length === 0,
-      errors: data.warnings,
+      complete: !data.nextCursor && errors.length === 0,
+      errors,
+      ...(kpiGaps.length ? { notes: kpiGaps } : {}),
       sections: [
         {
           title: "Matching equities",
@@ -145,7 +159,8 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
             ...(metric === "price" ? [] : [{ key: "price", header: "Last", align: "right" as const, format: price }]),
             ...(metric === "changePercent" ? [] : [{ key: "changePercent", header: "Chg%", align: "right" as const, format: percent }]),
             ...extendedSessions.map(extendedColumn),
-            { key: "value", header: SHORT_LABELS[metric], align: "right" },
+            // YTD names the close it is measured from: `YTD% vs 31 Dec close`.
+            { key: "value", header: screenColumnLabel(metric, screenYtdBase(data.rows, data.snapshot?.assembledAt), "report"), align: "right" },
             { key: "unit", header: "Unit" },
             { key: "percentile", header: "Covered pctl", align: "right" },
             { key: "asOf", header: "As of" },
@@ -172,7 +187,7 @@ export const equityScreenerHeadless: HeadlessPaneDefinition<"bundle"> = {
                   ? null
                   : Math.round(observation.percentile.value),
               asOf: stamp.collected ? `${stamp.text} (collected)` : stamp.text,
-              state: observation.state,
+              state: observation.access === "pro" ? "locked" : observation.state,
             };
           }),
         },

package/src/plugins/builtin/equity-screener/model.ts

@@ -17,9 +17,11 @@ import {
   type ScreenPayload,
   type ScreenRow,
 } from "../../../api-client/equity-screener";
+import { yearToDateBaseLabel } from "../../../market-data/market/year-to-date";
 import { canonicalExchange } from "../../../utils/exchanges";
 import { LATEST_DISTRIBUTION, TRAILING_DIVIDEND_BASIS } from "../../../utils/forward-dividend";
 import { formatCompact, formatNumber } from "../../../utils/format";
+import { kpiFreeLimitNote } from "../company-kpis/model";
 
 /**
  * Column headers. Currency sits in the footer; percentage fields carry %.
@@ -160,8 +162,29 @@ export function resultFields(definition: ScreenDefinition, metric: NumericField)
   return [...new Set(fields)].filter((field) => definition.currency || !MONETARY.has(field) || field === metric);
 }
 
+/**
+ * The close the screen's YTD returns are measured from, `31 Dec`: NYSE's last
+ * session of the year before the newest session a row's YTD ends on, the
+ * snapshot's day without one.
+ */
+export function screenYtdBase(rows: readonly ScreenRow[], assembledAt?: string | null, now = Date.now()): string | null {
+  const day = rows.map((row) => row.metrics.returnYtdPercent?.asOf?.slice(0, 10) ?? "").filter(Boolean).sort().at(-1)
+    ?? assembledAt?.slice(0, 10);
+  return day ? yearToDateBaseLabel(day, "NYSE", now) : null;
+}
+
+/**
+ * A column's header. YTD names the close it is measured from: `YTD% vs 31 Dec
+ * close` in a report, `YTD% vs 31 Dec` in the pane and `YTD% 31 Dec` where
+ * the pane is short of room.
+ */
+export function screenColumnLabel(field: NumericField, ytdBase: string | null, form: "report" | "pane" | "compact" = "pane"): string {
+  if (field !== "returnYtdPercent" || !ytdBase) return SHORT_LABELS[field];
+  return form === "compact" ? `YTD% ${ytdBase}` : `YTD% vs ${ytdBase}${form === "report" ? " close" : ""}`;
+}
+
 /** Prices get room for a separated six-figure quote (757,398.00). */
-export const columnWidth = (field: NumericField) => Math.max(field === "price" ? 10 : 8, SHORT_LABELS[field].length);
+export const columnWidth = (field: NumericField, label = SHORT_LABELS[field]) => Math.max(field === "price" ? 10 : 8, label.length);
 
 export const DEFAULT_SCREEN: ScreenDefinition = {
   version: 1,
@@ -481,6 +504,20 @@ const unavailableMetric = (): ScreenMetric => ({
   state: "unavailable", scope: "reported", reason: "Not provided by this server", sourceUrl: null,
   percentile: { value: null, sampleCount: 0, scope: "covered-universe" },
 });
+/** Company KPIs, guidance, hiring and app attention: the server leaves them out of a screen for a caller without Gloom Pro. */
+const PRO_FIELDS: ReadonlySet<string> = new Set([...KPI_FIELDS, ...HIRING_APP_FIELDS]);
+const withheldMetric = (): ScreenMetric => ({ ...unavailableMetric(), reason: "Needs Gloom Pro", access: "pro" });
+
+/**
+ * What a screen says once of a metric the server held back from Free, a
+ * KPI's in the words `fn KPIS` uses ("The free screener shows no KPI values;
+ * Gloom Pro shows each company's Backlog.").
+ */
+export function withheldMetricNote(field: NumericField): string {
+  return (KPI_FIELDS as readonly string[]).includes(field)
+    ? kpiFreeLimitNote({ metric: screenLabel(field), shown: 0, total: null, guidance: field.startsWith("guide"), where: "The free screener" })
+    : `${screenLabel(field)} needs Gloom Pro.`;
+}
 export function validateScreenPayload(value: unknown): ScreenPayload {
   const data = value as ScreenPayload;
   if (
@@ -523,8 +560,9 @@ export function validateScreenPayload(value: unknown): ScreenPayload {
     ids.add(screenRowId(row));
     for (const field of NUMERIC_FIELDS) {
       // A server from before social, research, volatility or dividend fields omits them; they read as unavailable.
+      // A Pro field it left out was held back from this caller.
       if (!row.metrics[field] && ([...SOCIAL_FIELDS, ...RESEARCH_FIELDS, ...VOLATILITY_FIELDS, ...ATTENTION_FIELDS, ...HIRING_APP_FIELDS, ...KPI_FIELDS, ...DIVIDEND_FIELDS] as readonly string[]).includes(field))
-        row.metrics[field] = unavailableMetric();
+        row.metrics[field] = PRO_FIELDS.has(field) ? withheldMetric() : unavailableMetric();
       const metric = row.metrics[field];
       if (
         !metric ||

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

@@ -67,10 +67,11 @@ import {
   metricDate,
   parseScreenDefinition,
   resultFields,
-  SHORT_LABELS,
   SIGN_COLORED,
+  screenColumnLabel,
   screenLabel,
   screenRowId,
+  screenYtdBase,
 } from "./model";
 import { useScreenResults } from "./results";
 import { overlayLiveScreenRows, screenExtendedMove, screenExtendedSessions, sortLiveScreenRows, type LiveScreenRow } from "./live";
@@ -101,20 +102,19 @@ const EXTENDED_COLUMN_PREFIX = "ext:";
  * CHG% for each session in `extendedSessions`, and is added only whole, as
  * the metrics are.
  */
-function resultColumns(
+export function resultColumns(
   width: number,
   definition: ScreenDefinition,
   metric: NumericField,
   asOf: boolean,
   extendedSessions: readonly ExtendedSession[] = [],
+  ytdBase: string | null = null,
 ): DataTableColumn[] {
   const [focus, ...others] = resultFields(definition, metric);
-  const metricColumn = (field: NumericField): DataTableColumn => ({
-    id: `m:${field}`,
-    label: SHORT_LABELS[field],
-    width: columnWidth(field),
-    align: "right",
-  });
+  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" };
+  };
   const extendedColumns = extendedSessions.map((session): DataTableColumn => ({
     id: `${EXTENDED_COLUMN_PREFIX}${session}`,
     label: extendedSessionStateLabel(session),
@@ -122,20 +122,21 @@ function resultColumns(
     align: "right",
   }));
   // The extended move reads beside CHG%, or first after the focus metric when that is CHG%.
-  const extras = [
+  const extras = (form: "pane" | "compact") => [
     ...(focus === "changePercent" ? extendedColumns : []),
-    ...others.flatMap((field) => field === "changePercent" ? [metricColumn(field), ...extendedColumns] : [metricColumn(field)]),
+    ...others.flatMap((field) => field === "changePercent" ? [metricColumn(field, form), ...extendedColumns] : [metricColumn(field, form)]),
   ];
   const build = (
     extra: DataTableColumn[],
     exchange: boolean,
     sector: boolean,
+    form: "pane" | "compact",
   ): DataTableColumn[] => [
     { id: "symbol", label: "SYMBOL", width: 8, align: "left" },
     { id: "name", label: "NAME", width: 18, flexGrow: 1, align: "left" },
     ...(exchange ? [{ id: "exchange", label: "EXCH", width: 7, align: "left" as const }] : []),
     ...(sector ? [{ id: "sector", label: "SECTOR", width: 22, align: "left" as const }] : []),
-    metricColumn(focus!),
+    metricColumn(focus!, form),
     { id: "percentile", label: "PCTL", width: 4, align: "right" },
     ...(asOf ? [{ id: "date", label: "AS OF", width: 10, align: "left" as const }] : []),
     ...extra,
@@ -143,15 +144,15 @@ function resultColumns(
   // Measured the way the table draws them (header floor, gaps, lead gaps), so a
   // column is only added when it fits whole.
   const fits = (columns: DataTableColumn[]) => getTableWidth(columns) <= width;
-  let shown: DataTableColumn[] = [];
-  for (const column of extras) {
-    const next = [...shown, column];
-    if (!fits(build(next, false, false))) break;
-    shown = next;
-  }
-  const exchange = fits(build(shown, true, false));
-  const sector = exchange && fits(build(shown, true, true));
-  return build(shown, exchange, sector);
+  // Columns are chosen with YTD's short header (`YTD% 31 Dec`), which reads
+  // `YTD% vs 31 Dec` when that still fits: naming the close never costs a column.
+  const compact = extras("compact");
+  let shown = 0;
+  while (shown < compact.length && fits(build(compact.slice(0, shown + 1), false, false, "compact"))) shown++;
+  const exchange = fits(build(compact.slice(0, shown), true, false, "compact"));
+  const sector = exchange && fits(build(compact.slice(0, shown), true, true, "compact"));
+  const named = build(extras("pane").slice(0, shown), exchange, sector, "pane");
+  return fits(named) ? named : build(compact.slice(0, shown), exchange, sector, "compact");
 }
 const loadFields = () => fetchScreenFields();
 function ScreenDetail({
@@ -351,7 +352,9 @@ function EquityScreenView({
   const staleFocus = snapshotRows.some((row) => row.metrics[metric]?.state === "stale");
   // A pre-market, after-hours or overnight column only while a row has such a print.
   const extendedSessions = screenExtendedSessions(rows);
-  const columns = resultColumns(width, definition, metric, staleFocus, extendedSessions);
+  // YTD names the close it is measured from, `31 Dec`.
+  const ytdBase = screenYtdBase(snapshotRows, data?.snapshot?.assembledAt);
+  const columns = resultColumns(width, definition, metric, staleFocus, extendedSessions, ytdBase);
   const apply = (next: ScreenDefinition) => {
     try {
       setDefinition(parseScreenDefinition(next));

package/src/plugins/builtin/estimate-revisions/headless.ts

@@ -45,10 +45,11 @@ export const estimateRevisionsHeadless: HeadlessPaneDefinition<"bundle"> = {
       instrument?.exchange ?? "",
       ctx.apiClient,
       ctx.marketData,
-    ).catch((error: unknown) => {
-      throw explainRefusal(error, estimateRevisionsLockNote, {
+    ).catch(async (error: unknown) => {
+      throw await explainRefusal(error, estimateRevisionsLockNote, {
         symbol: args.symbols[0] ?? null,
         token: ctx.settings?.tab === "guidance" ? "GUID" : "EM",
+        context: ctx,
       });
     });
     const periods = pinnedEstimatePeriods(