gloomberb 0.17.2 → 0.17.3

package/src/plugins/builtin/options-calculator/pane.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { FieldGrid, KeyValueRow, QueryBar, usePaneFooter, usePaneNoticeFooter, type GridField } from "../../../components";
 import { CompositeChart } from "../../../components/chart/composite/composite-chart";
+import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource, useInputCapture } from "../../../public/react";
 import { useShortcut } from "../../../react/input";
 import { useAppSelector, usePaneInstance, usePaneStateValue } from "../../../state/app/context";
@@ -262,9 +263,6 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
     } else if (american && isPlainKey(event, "d")) {
       consume();
       setActiveFieldId("dividends");
-    } else if (surfaceSource && isPlainKey(event, "r")) {
-      consume();
-      void surfaceResource.reload();
     }
   }, {
     allowEditable: true,
@@ -273,6 +271,7 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
     scope: "options-calculator:fields",
   });
 
+  usePaneRefreshKey(() => { void surfaceResource.reload(); }, { focused: focused && !commandBarOpen && surfaceSource && activeFieldId === null });
   usePaneFooter(OPTIONS_CALCULATOR_PANE_ID, () => ({
     info: [
       ...(problem ? [{ id: "input", parts: [{ text: problem, tone: "warning" as const }] }] : []),

package/src/plugins/builtin/portfolio-list/cli/bulk-symbols.ts

@@ -65,12 +65,13 @@ interface CollectionRef {
 /**
  * One line per symbol and the summary under them; `--json` and `--csv` give
  * the rows, with the summary in the JSON metadata and on standard error beside
- * CSV. The command exits non-zero when no symbol ended up as asked.
+ * CSV. A separator dropped from a symbol of the list is named as a warning. The
+ * command exits non-zero when no symbol ended up as asked.
  */
 export function printSymbolRows(
   ctx: CliCommandContext,
   rows: SymbolRow[],
-  { verb, collection, repeated }: { verb: Verb; collection: CollectionRef; repeated: number },
+  { verb, collection, repeated, strays }: { verb: Verb; collection: CollectionRef; repeated: number; strays: readonly string[] },
 ): void {
   const summary = `${collection.kind === "watchlist" ? "Watchlist" : "Portfolio"} "${collection.name}": ${summarizeSymbolRows(rows, verb, repeated)}`;
   const count = (status: SymbolStatus) => rows.filter((row) => row.status === status).length;
@@ -80,6 +81,7 @@ export function printSymbolRows(
   ctx.printResult({
     data: rows,
     metadata: { [collection.kind]: collection.name, ...counts, repeated, summary },
+    ...strays.length > 0 ? { warnings: [...strays] } : {},
   }, {
     text: () => [...rows.map((row) => rowLines(row, verb)), "", summary].join("\n"),
   });
@@ -102,13 +104,14 @@ export async function requireSymbolList(
   args: readonly string[],
   file: string | undefined,
   usage: string,
-): Promise<{ symbols: string[]; repeated: number; single: string | null }> {
+): Promise<{ symbols: string[]; repeated: number; strays: string[]; single: string | null }> {
   try {
     const list = await readSymbolList({ args, file });
     if (list.symbols.length === 0) ctx.fail(usage);
-    // One symbol typed alone keeps the single-symbol output and errors.
+    // One symbol typed alone keeps the single-symbol output and errors. It goes as typed, so a separator
+    // left on it (`UPST;`) is named by the listing it resolves to.
     const typed = splitSymbolArgs(args);
-    const single = file == null && !args.includes("-") && typed.length === 1 ? typed[0]! : null;
+    const single = file == null && !args.includes("-") && typed.length === 1 ? (args.length === 1 ? args[0]!.trim() : typed[0]!) : null;
     return { ...list, single };
   } catch (error) {
     if (error instanceof SymbolListError) ctx.fail(error.message, usage);

package/src/plugins/builtin/portfolio-list/cli/portfolio-command.ts

@@ -51,6 +51,7 @@ import {
   misplacedSymbolList,
   parseFiniteNumber,
   PortfolioCliError,
+  refuseDryRun,
   rejectCashSymbol,
   requireManualPortfolio,
   requirePortfolio,
@@ -208,7 +209,7 @@ async function addToPortfolioCommand(args: string[], file: string | undefined, e
       retry: (key) => `gloomberb portfolio add ${/\s/.test(portfolio.name) ? `"${portfolio.name}"` : portfolio.name} ${key}`,
       add: (ticker) => addTickerToPortfolio(ticker, portfolio.id),
     });
-    printSymbolRows(ctx, rows, { verb: "add", collection: { kind: "portfolio", name: portfolio.name }, repeated: list.repeated });
+    printSymbolRows(ctx, rows, { verb: "add", collection: { kind: "portfolio", name: portfolio.name }, repeated: list.repeated, strays: list.strays });
   });
 }
 
@@ -275,7 +276,7 @@ async function removeFromPortfolioCommand(args: string[], file: string | undefin
       },
     });
     if (nextConfig !== context.config) await saveConfig(nextConfig);
-    printSymbolRows(ctx, rows, { verb: "remove", collection: { kind: "portfolio", name: portfolio.name }, repeated: list.repeated });
+    printSymbolRows(ctx, rows, { verb: "remove", collection: { kind: "portfolio", name: portfolio.name }, repeated: list.repeated, strays: list.strays });
   });
 }
 
@@ -814,7 +815,7 @@ export const portfolioCliCommand: CliCommandDef = {
     const importOnly = args.find((arg) => IMPORT_FLAGS.has(arg.split("=")[0]!));
     if (importOnly) ctx.fail(`${importOnly.split("=")[0]} is an option of portfolio import, not portfolio ${action}.`, IMPORT_USAGE);
     const mutating = MUTATING_ACTIONS.has(action ?? "") || ((action === "target" || action === "targets") && (args[1] === "set" || args[1] === "clear"));
-    if (ctx.cliOptions.dryRun && mutating) ctx.fail(`portfolio ${action} has no --dry-run; it changes the portfolio when it runs.`);
+    if (mutating) refuseDryRun(ctx, "portfolio", action!);
 
     if (!action || action === "list") {
       await listCollections(ctx);

package/src/plugins/builtin/portfolio-list/cli/shared.ts

@@ -24,6 +24,15 @@ export function failPortfolioCommand(ctx: CliCommandContext, error: unknown, fal
   return ctx.fail(fallback);
 }
 
+/**
+ * Fails an action that changes a portfolio or watchlist when `--dry-run` was
+ * given. None of them previews, so running it anyway would save the change
+ * under a flag that promises not to; this fails before anything is written.
+ */
+export function refuseDryRun(ctx: CliCommandContext, noun: "watchlist" | "portfolio", action: string): void {
+  if (ctx.cliOptions.dryRun) ctx.fail(`${noun} ${action} has no --dry-run; it changes the ${noun} when it runs.`);
+}
+
 /**
  * The portfolio or watchlist the leading arguments name, and the arguments
  * after it. The first argument is the name (quoted when it has spaces); an

package/src/plugins/builtin/portfolio-list/cli/watchlist-command.ts

@@ -22,12 +22,14 @@ import {
   removeTickerFromWatchlist as removeWatchlistMembership,
 } from "../mutations";
 import { showCollection } from "./render";
-import { listingFields, misplacedSymbolList, takeCollectionName } from "./shared";
+import { listingFields, misplacedSymbolList, refuseDryRun, takeCollectionName } from "./shared";
 import { addSymbols, FILE_OPTION, printSymbolRows, removeSymbols, requireSymbolList, retryNotice, SYMBOL_LIST_HELP } from "./bulk-symbols";
 import { CLI_COMMAND_GROUPS } from "../../../../cli/help";
 
 const ADD_USAGE = "Usage: gloomberb watchlist add <watchlist> <symbols...> [--file <path>]";
 const REMOVE_USAGE = "Usage: gloomberb watchlist remove <watchlist> <symbols...> [--file <path>]";
+/** Actions that change a watchlist: none of them previews, so --dry-run would change it anyway. */
+const MUTATING_ACTIONS = new Set(["create", "delete", "rm", "add", "remove"]);
 
 /** The watchlist the leading arguments name and the symbols after it; fails naming the watchlists there are. */
 function requireWatchlistArgs(
@@ -134,7 +136,7 @@ async function addToWatchlistCommand(args: string[], file: string | undefined, e
       suggest: true,
       add: (ticker) => addTickerToWatchlist(ticker, watchlist.id),
     });
-    printSymbolRows(ctx, rows, { verb: "add", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated });
+    printSymbolRows(ctx, rows, { verb: "add", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated, strays: list.strays });
   });
 }
 
@@ -167,7 +169,7 @@ async function removeFromWatchlistCommand(args: string[], file: string | undefin
       store: context.store,
       remove: (ticker) => removeWatchlistMembership(ticker, watchlist.id),
     });
-    printSymbolRows(ctx, rows, { verb: "remove", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated });
+    printSymbolRows(ctx, rows, { verb: "remove", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated, strays: list.strays });
   });
 }
 
@@ -246,6 +248,7 @@ export const watchlistCliCommand: CliCommandDef = {
     const file = hasFile ? takeOption(args, "--file") ?? "" : undefined;
     const action = args[0];
     if (file != null && action !== "add" && action !== "remove") ctx.fail(`--file is an option of watchlist add and remove, not watchlist ${action ?? "list"}.`, ADD_USAGE);
+    if (MUTATING_ACTIONS.has(action ?? "")) refuseDryRun(ctx, "watchlist", action!);
 
     if (!action || action === "list") {
       await listWatchlists(ctx);

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

@@ -10,22 +10,20 @@ import type {
 import { apiClient } from "../../../api-client";
 import { ApiRequestError } from "../../../api-client/errors";
 import { Button, ChoiceDialog, EmptyState, PaneStatusBody, SectionHeading, Spinner, usePaneFooter, usePaneMenuItems } from "../../../components";
+import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { ExternalLinkText, PaneLinkMenu } from "../../../components/ui";
 import { t, tf } from "../../../i18n";
-import { useShortcut } from "../../../react/input";
 import { colors } from "../../../theme/colors";
 import { Box, ScrollBox, Text, TextAttributes, useRendererHost, useUiCapabilities } from "../../../ui";
 import { useOptionalDialog, type PromptContext } from "../../../ui/dialog";
 import { formatTimeAgo } from "../../../utils/datetime-format";
 import { truncateToDisplayWidth } from "../../../utils/format";
-import { isPlainKey } from "../../../utils/keyboard";
 import { ProWall, SignInWall } from "../cloud/auth-actions";
 import { useCloudPlanAction, useCloudUpgradeAction } from "../shared/cloud-upgrade";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import { useBoundTicker } from "../shared/ticker-request";
 
 const FOOTER_ID = "equity-diagnostic";
-const REFRESH_SCOPE = "equity-diagnostic:refresh";
 /** Width of the "Observed"/"Reading" label column before the layout stacks. */
 const LABEL_WIDTH = 10;
 const STACK_BELOW_WIDTH = 44;
@@ -494,12 +492,7 @@ export function EquityDiagnosticView({ focused, width, height }: {
   const refresh = useCallback(() => load("refresh"), [load]);
   const retry = useCallback(() => load("cache-first"), [load]);
 
-  useShortcut((event) => {
-    if (!isPlainKey(event, "r")) return;
-    event.preventDefault();
-    event.stopPropagation();
-    refresh();
-  }, { enabled: focused && canRefresh && !loading, scope: REFRESH_SCOPE });
+  usePaneRefreshKey(refresh, { focused, enabled: canRefresh && !loading });
 
   // The report's citations are links a keyboard cannot focus, so `o` opens
   // them: straight away for one, through a chooser for several.

package/src/plugins/builtin/research/event-model.ts

@@ -14,6 +14,7 @@ import {
   formatPercentRaw,
 } from "../../../utils/format";
 import { computeTTM } from "../ticker-detail/financials/aggregation";
+import { declaredDividends } from "../../../utils/declared-dividends";
 import {
   earningsDateStatus,
   earningsEpsBasis,
@@ -398,6 +399,19 @@ export function buildEventRows(
     });
   }
 
+  // Declared and unpaid: its own row at its ex-date, apart from the paid distributions above.
+  for (const dividend of declaredDividends(data)) {
+    rows.push({
+      id: `div-declared:${dividend.exDate}`,
+      date: dividend.exDate,
+      status: "Dividend",
+      period: "-",
+      detail: dividend.payDate ? `Declared, payable ${dividend.payDate}` : "Declared",
+      value: formatDistributionAmount(dividend.amount, data?.currency ?? currency),
+      tone: "positive",
+    });
+  }
+
   for (const split of data?.splits ?? []) {
     rows.push({
       id: `split:${split.date}:${split.description ?? ""}`,

package/src/plugins/builtin/research/headless-schema.ts

@@ -1,11 +1,41 @@
 import type { HeadlessPaneDefinition } from "../../../types/headless";
+import { EXTRA_COLUMN_IDS, normalizeExtraColumns } from "./relative-valuation-columns";
+import { normalizeCapCurrency } from "./relative-valuation-currency";
 
 type PaneSchema = Pick<HeadlessPaneDefinition, "argument" | "options" | "discovery">;
 
 export const paneSchemas = {
   "relative-valuation-pane": {
     argument: { kind: "tickers" },
-    options: [],
+    options: [
+      {
+        key: "peers",
+        type: "boolean",
+        settingKey: "autoPeers",
+        description: "With one symbol, add 4 to 6 competitors: the covered equities in its industry closest in market cap (an education company filed under software is compared with education companies, and an online learning company with its curated core first), or a curated list when too few are covered. The header names the method",
+        example: "--peers",
+      },
+      {
+        key: "columns",
+        type: "string",
+        settingKey: "extraColumns",
+        placeholder: "fields",
+        description: `Report columns to add, in order: ${EXTRA_COLUMN_IDS.join(", ")}. shortInterest is FINRA short interest as a percent of float at the latest settlement, `
+          + "nextEarnings the next report date on the earnings calendar, target the mean analyst target and the analyst count, grossMargin and evEbitda the screener's stored figures. "
+          + "Short interest, earnings dates, gross margin and EV/EBITDA cover US listings. CSV and JSON give each cell's source and as-of. The pane keeps its own columns",
+        example: "--columns shortInterest,nextEarnings,target,grossMargin,evEbitda",
+        normalize: normalizeExtraColumns,
+      },
+      {
+        key: "currency",
+        type: "string",
+        settingKey: "capCurrency",
+        placeholder: "ISO code",
+        description: "Show every market cap in this currency, converted at the app's FX rates; the status line names each rate and its time",
+        example: "--currency USD",
+        normalize: normalizeCapCurrency,
+      },
+    ],
     discovery: {
       id: "relative-valuation",
       aliases: ["relative valuation", "peer valuation", "valuation comps", "compare multiples"],

package/src/plugins/builtin/research/relative-valuation-columns.ts

@@ -0,0 +1,289 @@
+import type { ScreenDefinition, ScreenMetric, ScreenRow } from "../../../api-client/equity-screener";
+import type { HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneRow } from "../../../types/headless";
+import type { TickerFinancials } from "../../../types/financials";
+import { isUsListingExchange, parsePublicTickerKey } from "../../../utils/exchanges";
+import { errorMessage } from "../../../utils/errors";
+import { formatNumber } from "../../../utils/format";
+import { fetchScreen } from "../equity-screener/client";
+import { refusedLock } from "../shared/cloud-denied";
+import { resolveHeadlessInstrument } from "../shared/headless-market-data";
+import { loadShortInterest } from "../short-interest/client";
+import { buildShortWatchRow } from "../short-interest/watch-model";
+import { analystTargetCurrency, formatAnalystPrice, recommendationTotal } from "./analyst-model";
+
+/** The columns `--columns` adds to RV's report, each read from the path its own function uses. */
+export const EXTRA_COLUMN_IDS = ["shortInterest", "nextEarnings", "target", "grossMargin", "evEbitda"] as const;
+export type ExtraColumnId = (typeof EXTRA_COLUMN_IDS)[number];
+
+const COLUMN_ALIASES: Record<string, ExtraColumnId> = {
+  shortinterest: "shortInterest", short: "shortInterest", si: "shortInterest", shortfloat: "shortInterest",
+  nextearnings: "nextEarnings", earnings: "nextEarnings", earningsdate: "nextEarnings",
+  target: "target", targets: "target", analysttarget: "target", analysts: "target", pricetarget: "target",
+  grossmargin: "grossMargin", gross: "grossMargin", gm: "grossMargin",
+  evebitda: "evEbitda", evtoebitda: "evEbitda",
+};
+
+/** `--columns`: a comma list of the fields above (or their short names), in order, as the canonical names. */
+export function normalizeExtraColumns(value: string): string {
+  const tokens = value.split(/[,\s]+/).filter(Boolean);
+  if (tokens.length === 0) throw new Error(`--columns needs one or more of: ${EXTRA_COLUMN_IDS.join(", ")}.`);
+  const ids = tokens.map((token) => {
+    const id = COLUMN_ALIASES[token.toLowerCase().replace(/[^a-z]/g, "")];
+    if (!id) throw new Error(`Unknown --columns field "${token}". Use any of: ${EXTRA_COLUMN_IDS.join(", ")}.`);
+    return id;
+  });
+  return [...new Set(ids)].join(",");
+}
+
+export function parseExtraColumns(value: unknown): ExtraColumnId[] {
+  return typeof value === "string" && value ? value.split(",").filter((id): id is ExtraColumnId => (EXTRA_COLUMN_IDS as readonly string[]).includes(id)) : [];
+}
+
+const percent = (value: unknown) => (typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(2)}%` : "-");
+const text = (value: unknown) => (typeof value === "string" && value ? value : "-");
+
+/** Each added column, then (exports only) the source and as-of of its cells. */
+interface ColumnSpec {
+  columns: HeadlessPaneColumn[];
+  sourceKey: string;
+  asOfKey: string;
+  label: string;
+}
+
+const COLUMN_SPECS: Record<ExtraColumnId, ColumnSpec> = {
+  shortInterest: {
+    label: "Short % Float",
+    columns: [{ key: "shortInterestPercentFloat", header: "Short % Float", align: "right", format: percent }],
+    sourceKey: "shortInterestSource",
+    asOfKey: "shortInterestAsOf",
+  },
+  nextEarnings: {
+    label: "Next Earnings",
+    columns: [{
+      key: "nextEarningsDate", header: "Next Earnings", format: text, shrink: false,
+      // The text table says when in the day and whether the date is confirmed; exports keep them as columns.
+      textFormat: (value, row) => (typeof value === "string" && value
+        ? [value, row.nextEarningsTiming, row.nextEarningsStatus === "estimated" ? "est" : null].filter(Boolean).join(" ") : "-"),
+    }, { key: "nextEarningsTiming", header: "Next Earnings Timing", format: text }, { key: "nextEarningsStatus", header: "Next Earnings Status", format: text }],
+    sourceKey: "nextEarningsSource",
+    asOfKey: "nextEarningsAsOf",
+  },
+  target: {
+    label: "Avg Target",
+    columns: [
+      { key: "targetMean", header: "Avg Target", align: "right", unitKey: "targetCurrency",
+        format: (value, row) => (typeof value === "number" ? formatAnalystPrice(value, typeof row.targetCurrency === "string" ? row.targetCurrency : undefined) : "-") },
+      { key: "analystCount", header: "Analysts", align: "right", format: (value) => (typeof value === "number" ? String(value) : "-") },
+    ],
+    sourceKey: "targetSource",
+    asOfKey: "targetAsOf",
+  },
+  grossMargin: {
+    label: "Gross Margin",
+    columns: [{ key: "grossMarginPercent", header: "Gross Margin", align: "right", format: percent }],
+    sourceKey: "grossMarginSource",
+    asOfKey: "grossMarginAsOf",
+  },
+  evEbitda: {
+    label: "EV/EBITDA",
+    columns: [{ key: "evEbitda", header: "EV/EBITDA", align: "right", format: (value) => (typeof value === "number" ? formatNumber(value, 1) : "-") }],
+    sourceKey: "evEbitdaSource",
+    asOfKey: "evEbitdaAsOf",
+  },
+};
+
+/** The timing and status columns of Next Earnings stay out of the text table, which folds them into the date. */
+const EXPORT_ONLY_KEYS = new Set(["nextEarningsTiming", "nextEarningsStatus"]);
+
+/** The columns the added fields print as: `text` for the terminal table, `export` with each cell's source and as-of. */
+export function extraColumns(ids: readonly ExtraColumnId[]): { text: HeadlessPaneColumn[]; export: HeadlessPaneColumn[] } {
+  const specs = ids.map((id) => COLUMN_SPECS[id]);
+  return {
+    text: specs.flatMap((spec) => spec.columns.filter((column) => !EXPORT_ONLY_KEYS.has(column.key))),
+    export: specs.flatMap((spec) => [
+      ...spec.columns,
+      { key: spec.sourceKey, header: `${spec.label} source`, format: text },
+      { key: spec.asOfKey, header: `${spec.label} as of`, format: text, shrink: false },
+    ]),
+  };
+}
+
+/** Whether a symbol is a US listing, which FINRA short interest, the earnings calendar and the screener cover. */
+function usListing(symbol: string): string | null {
+  const { symbol: bare, exchange } = parsePublicTickerKey(symbol);
+  return !exchange || isUsListingExchange(exchange) ? bare.toUpperCase() : null;
+}
+
+/** A failed read of one column, as the report says it: a Pro or sign-in wall in the words its lock note uses, else why. */
+function failureMessage(label: string, error: unknown, symbol?: string): string {
+  const refused = refusedLock(error);
+  if (refused?.gate === "pro") return `${label} requires Gloom Pro.`;
+  if (refused) return `${label} needs a free Gloom sign-in.`;
+  return `${symbol ? `${symbol}: ` : ""}${label} unavailable: ${errorMessage(error)}`;
+}
+
+interface ExtraColumnsResult {
+  /** The added fields of each symbol's row, keyed by the symbol as given. */
+  fields: Map<string, HeadlessPaneRow>;
+  errors: string[];
+  notes: string[];
+}
+
+const SHORT_INTEREST_SOURCES: Record<string, string> = { finra: "FINRA", gloom: "Gloom Cloud" };
+
+/** Percent of float at the latest settlement, as `SIW` computes it, dated by that settlement. */
+async function loadShortInterestFields(symbols: readonly string[], financials: ReadonlyMap<string, TickerFinancials | null>, ctx: HeadlessPaneContext, out: ExtraColumnsResult) {
+  const label = COLUMN_SPECS.shortInterest.label;
+  await Promise.all(symbols.map(async (symbol) => {
+    const bare = usListing(symbol);
+    if (!bare) return;
+    try {
+      const result = await loadShortInterest(bare, ctx.apiClient);
+      const row = buildShortWatchRow({ symbol, records: result.records, floatShares: financials.get(symbol)?.fundamentals?.floatShares ?? null, history: null });
+      if (!row.settlementDate) return;
+      Object.assign(out.fields.get(symbol)!, {
+        shortInterestPercentFloat: row.percentFloat,
+        shortInterestSource: SHORT_INTEREST_SOURCES[result.source] ?? "FINRA",
+        shortInterestAsOf: row.settlementDate,
+      });
+    } catch (error) {
+      out.errors.push(failureMessage(label, error, symbol));
+    }
+  }));
+}
+
+/** The next report date on the earnings calendar `earnings` reads, dated by when the calendar was read. */
+async function loadNextEarningsFields(symbols: readonly string[], ctx: HeadlessPaneContext, out: ExtraColumnsResult) {
+  const label = COLUMN_SPECS.nextEarnings.label;
+  const listed = symbols.flatMap((symbol) => {
+    const bare = usListing(symbol);
+    return bare ? [{ symbol, bare }] : [];
+  });
+  if (listed.length === 0) return;
+  if (!ctx.marketData.getEarningsCalendar) {
+    out.errors.push(`${label} unavailable: the market data source has no earnings calendar.`);
+    return;
+  }
+  try {
+    const events = await ctx.marketData.getEarningsCalendar(listed.map(({ bare }) => bare));
+    const readAt = new Date().toISOString();
+    const today = readAt.slice(0, 10);
+    for (const { symbol, bare } of listed) {
+      const next = events
+        .filter((event) => event.symbol.toUpperCase() === bare && event.epsActual == null && event.earningsDate.toISOString().slice(0, 10) >= today)
+        .sort((left, right) => left.earningsDate.getTime() - right.earningsDate.getTime())[0];
+      if (!next) continue;
+      Object.assign(out.fields.get(symbol)!, {
+        nextEarningsDate: next.earningsDate.toISOString().slice(0, 10),
+        nextEarningsTiming: next.timing || null,
+        nextEarningsStatus: next.isDateEstimate === true ? "estimated" : next.isDateEstimate === false ? "confirmed" : null,
+        nextEarningsSource: "Gloom Cloud earnings calendar",
+        nextEarningsAsOf: readAt,
+      });
+    }
+  } catch (error) {
+    out.errors.push(failureMessage(label, error));
+  }
+}
+
+/** The mean analyst target and the analysts behind the latest recommendation mix, as `analyst` reads them. */
+async function loadTargetFields(symbols: readonly string[], ctx: HeadlessPaneContext, out: ExtraColumnsResult) {
+  const label = COLUMN_SPECS.target.label;
+  const read = ctx.marketData.getAnalystResearch?.bind(ctx.marketData);
+  if (!read) {
+    out.errors.push(`${label} unavailable: the market data source has no analyst research.`);
+    return;
+  }
+  await Promise.all(symbols.map(async (symbol) => {
+    try {
+      const { symbol: ticker, exchange } = await resolveHeadlessInstrument(ctx, symbol);
+      const data = await read(ticker, exchange ?? "");
+      const average = data.priceTarget?.average;
+      const count = recommendationTotal(data);
+      if (average == null && count == null) return;
+      Object.assign(out.fields.get(symbol)!, {
+        targetMean: average != null && Number.isFinite(average) ? average : null,
+        targetCurrency: analystTargetCurrency(data) ?? null,
+        analystCount: count,
+        targetSource: "Gloom Cloud analyst research",
+        targetAsOf: data.fetchedAt ?? new Date().toISOString(),
+      });
+    } catch (error) {
+      out.errors.push(failureMessage(label, error, symbol));
+    }
+  }));
+}
+
+function metricFields(metric: ScreenMetric | undefined): { value: number | null; source: string | null; asOf: string | null } | null {
+  if (!metric || metric.value == null || !Number.isFinite(metric.value) || metric.state === "unavailable") return null;
+  return { value: metric.value, source: metric.source || null, asOf: metric.asOf ?? metric.observedAt ?? null };
+}
+
+/** Gross margin and EV/EBITDA as the screener stores them, each with its own source and statement date. */
+async function loadScreenerFields(ids: readonly ExtraColumnId[], symbols: readonly string[], ctx: HeadlessPaneContext, out: ExtraColumnsResult) {
+  const wanted = ids.filter((id) => id === "grossMargin" || id === "evEbitda");
+  const listed = symbols.flatMap((symbol) => {
+    const bare = usListing(symbol);
+    return bare ? [{ symbol, bare }] : [];
+  });
+  if (wanted.length === 0 || listed.length === 0) return;
+  const definition: ScreenDefinition = {
+    version: 1,
+    criteria: [{ field: "symbol", op: "in", value: [...new Set(listed.map(({ bare }) => bare))] }],
+    sort: { field: "symbol", direction: "asc" },
+    currency: null,
+  };
+  let rows: ScreenRow[];
+  try {
+    rows = (await fetchScreen(definition, null, ctx.signal, ctx.apiClient)).rows;
+  } catch (error) {
+    out.errors.push(failureMessage(wanted.map((id) => COLUMN_SPECS[id].label).join(" and "), error));
+    return;
+  }
+  for (const { symbol, bare } of listed) {
+    const row = rows.find((candidate) => candidate.symbol.toUpperCase() === bare && isUsListingExchange(candidate.exchange));
+    if (!row) continue;
+    const fields = out.fields.get(symbol)!;
+    if (wanted.includes("grossMargin")) {
+      const gross = metricFields(row.metrics.grossMarginPercent);
+      if (gross) Object.assign(fields, { grossMarginPercent: gross.value, grossMarginSource: gross.source, grossMarginAsOf: gross.asOf });
+    }
+    if (wanted.includes("evEbitda")) {
+      const multiple = metricFields(row.metrics.evToEbitda);
+      if (multiple) Object.assign(fields, { evEbitda: multiple.value, evEbitdaSource: multiple.source, evEbitdaAsOf: multiple.asOf });
+    }
+  }
+}
+
+/** The US-only columns among `ids`, which a listing abroad leaves blank. */
+const US_ONLY: ReadonlySet<ExtraColumnId> = new Set(["shortInterest", "nextEarnings", "grossMargin", "evEbitda"]);
+
+/**
+ * The added fields for every symbol, each column read apart so one that
+ * fails (or is locked) leaves the others: short interest from FINRA's
+ * settlements, the next report date from the earnings calendar, the mean
+ * target and analyst count from analyst research, gross margin and EV/EBITDA
+ * from the screener's stored figures.
+ */
+export async function loadExtraColumns(
+  ids: readonly ExtraColumnId[],
+  symbols: readonly string[],
+  financials: ReadonlyMap<string, TickerFinancials | null>,
+  ctx: HeadlessPaneContext,
+): Promise<ExtraColumnsResult> {
+  const out: ExtraColumnsResult = { fields: new Map(symbols.map((symbol) => [symbol, {}])), errors: [], notes: [] };
+  if (ids.length === 0) return out;
+  await Promise.all([
+    ids.includes("shortInterest") ? loadShortInterestFields(symbols, financials, ctx, out) : null,
+    ids.includes("nextEarnings") ? loadNextEarningsFields(symbols, ctx, out) : null,
+    ids.includes("target") ? loadTargetFields(symbols, ctx, out) : null,
+    loadScreenerFields(ids, symbols, ctx, out),
+  ]);
+  ctx.signal.throwIfAborted();
+  const abroad = symbols.filter((symbol) => !usListing(symbol));
+  const usOnly = ids.filter((id) => US_ONLY.has(id)).map((id) => COLUMN_SPECS[id].label);
+  if (abroad.length > 0 && usOnly.length > 0) {
+    out.notes.push(`${usOnly.join(", ")} cover US listings; ${abroad.join(", ")} ${abroad.length === 1 ? "is" : "are"} left blank.`);
+  }
+  return out;
+}