@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/plugins/builtin/econ/figures.ts

@@ -70,3 +70,51 @@ export function econRowFigures(row: { actual?: string | null; forecast?: string
     scale: first?.scale ?? null,
   };
 }
+
+/** A figure printed as a bare number, with no unit and no scale letter: `0.6`, `-3`, `1,5`. */
+const BARE_NUMBER = /^[+-]?(?:\d+(?:[.,]\d+)?|\.\d+)$/;
+
+/**
+ * Release names that are a percent whatever one row's figures say: a change
+ * month on month, quarter on quarter or year on year, and the rates published
+ * in percent. "Consumer Inflation Expectations" is a balance, not a rate, and
+ * is not one of them.
+ */
+const PERCENT_NAME = /\b(?:mom|qoq|yoy)\b|(?:^|\s)[mqy]\/[mqy](?=\s|$)|\b(?:inflation|unemployment|jobless|interest|growth|mortgage|funds|participation|savings) rate\b/i;
+
+type EconRowText = { country: string; event: string; indicatorId?: string | null; actual: string | null; forecast: string | null; prior: string | null };
+
+const FIGURE_KEYS = ["actual", "forecast", "prior"] as const;
+
+/** Every release of one indicator: its id, else its country and name. */
+const indicatorKey = (event: Pick<EconRowText, "country" | "event" | "indicatorId">) => event.indicatorId || `${event.country}|${event.event}`;
+
+/**
+ * The calendar with every figure of a percent indicator in percent. The feeds
+ * drop the sign on some rows: US Inflation Rate MoM's prior came as `0.6`, and
+ * the 30-year mortgage rate's as `7.32` beside its actual `7.41%`. An
+ * indicator is in percent when any of its figures is, or its name says so
+ * (`PERCENT_NAME`), and none of its figures is in another unit or scale; its
+ * bare figures then carry `%`. Anything else is left as the feed wrote it.
+ */
+export function withPercentUnits<T extends EconRowText>(events: readonly T[]): T[] {
+  const indicators = new Map<string, { percent: boolean; other: boolean }>();
+  for (const event of events) {
+    const key = indicatorKey(event);
+    const seen = indicators.get(key) ?? { percent: false, other: false };
+    if (PERCENT_NAME.test(event.event)) seen.percent = true;
+    for (const field of FIGURE_KEYS) {
+      const figure = parseEconFigure(event[field]);
+      if (!figure) continue;
+      if (figure.unit === "%") seen.percent = true;
+      else if (figure.unit || figure.scale !== 1) seen.other = true;
+    }
+    indicators.set(key, seen);
+  }
+  return events.map((event) => {
+    const seen = indicators.get(indicatorKey(event))!;
+    if (!seen.percent || seen.other) return event;
+    const bare = FIGURE_KEYS.filter((field) => BARE_NUMBER.test(event[field]?.trim() ?? ""));
+    return bare.length ? { ...event, ...Object.fromEntries(bare.map((field) => [field, `${event[field]!.trim()}%`])) } : event;
+  });
+}

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

@@ -36,10 +36,12 @@ import {
   FILTER_CYCLE,
   attachEconCalendarPersistence,
   actualColor,
+  awaitsConsensus,
   calendarDisplayRows,
   CALENDAR_TIME_ZONE_LABEL,
   dateKey,
   dayLabel,
+  econEventName,
   filteredEmptyTitle,
   formatStaleness,
   getCalendarCache,
@@ -50,6 +52,7 @@ import {
   eventCountry,
   matchesCountry,
   matchesImpact,
+  NO_CONSENSUS_NOTE,
   noScheduledReleasesMessage,
   parseCountryFilter,
   resetEconCalendarPersistence,
@@ -322,7 +325,7 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
     : formatCountdown(nextEvent.date.getTime() - now);
   // The countdown changes every tick, so it is footer status, not query bar
   // context; the footer ellipsizes a long event name.
-  const nextText = nextEvent && nextCountdown ? `next ${nextEvent.event} ${nextCountdown}` : null;
+  const nextText = nextEvent && nextCountdown ? `next ${econEventName(nextEvent)} ${nextCountdown}` : null;
   // The cached first paint is being replaced; its age only counts once a load has answered.
   const showStale = stale && (!loading || calendar.updatedAt !== null);
   // An empty list says it in its empty state instead.
@@ -330,6 +333,9 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
   // What the High filter, where the calendar opens, leaves out, and the key that lists it (Shift+F steps back to All).
   const hiddenCount = useMemo(() => lowerImpactHidden(events, impactFilter, countryFilter), [countryFilter, events, impactFilter]);
   const hiddenStatus = hiddenCount > 0 && !detailEvent ? `${hiddenCount} lower-impact hidden` : null;
+  // The dash under Forecast on the row in hand, while its consensus is not in yet.
+  const focusedEvent = detailEvent ?? filtered[selectedIdx];
+  const noConsensus = !!focusedEvent && awaitsConsensus(focusedEvent);
   const calendarStatus = useMemo<PaneFooterSegment[]>(() => [
     ...(hiddenStatus ? [{
       id: "hidden-impact",
@@ -341,8 +347,11 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
     ...(nextText && !detailEvent ? [{ id: "next", parts: [{ text: nextText, tone: "muted" as const }] }] : []),
     ...(listedAfterStatus ? [{ id: "listed-after", parts: [{ text: listedAfterStatus, tone: "warning" as const }] }] : []),
     ...(showStale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
+    // Behind the warnings, so a narrow footer gives it up before them, and ahead of the update time, which goes first.
+    ...(noConsensus ? [{ id: "no-consensus", parts: [{ text: NO_CONSENSUS_NOTE, tone: "muted" as const }],
+      variants: [[{ text: "no consensus yet", tone: "muted" as const }]] }] : []),
     ...(staleness ? [{ id: "updated", parts: [{ text: staleness, tone: "muted" as const }] }] : []),
-  ], [detailEvent, hiddenStatus, listedAfterStatus, nextText, showStale, staleness]);
+  ], [detailEvent, hiddenStatus, listedAfterStatus, nextText, noConsensus, showStale, staleness]);
   // A report of the pane (`gloom fn ECO`) says it too.
   const listedThrough = listedEnd ? dateKey(listedEnd) : null;
   useRemoteUiNode(listedAfter && listedThrough ? {
@@ -433,7 +442,7 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
         return withCountryFlag({ text: country, color: colors.textMuted }, country, flagged);
       }
       case "event":
-        return { text: ev.event, color: colors.text };
+        return { text: econEventName(ev), color: colors.text };
       case "actual":
         return {
           text: ev.actual ?? "—",
@@ -480,7 +489,7 @@ function EconCalendarPane({ focused, width, height }: PaneProps) {
       focused={focused}
       detailOpen={!!detailEvent}
       onBack={() => setOpenKey(null)}
-      detailTitle={detailEvent?.event}
+      detailTitle={detailEvent ? econEventName(detailEvent) : undefined}
       detailContent={detailContent}
       rootWidth={width}
       rootHeight={Math.max(1, height - 1)}
@@ -576,7 +585,7 @@ export const economicCalendarModule: PluginModule = {
     description: "Upcoming economic events, releases, and indicators.",
     // "econ" stays a keyword so the old ECON prefix still finds this pane.
     keywords: ["econ", "economic", "calendar", "events", "macro", "releases", "fed", "cpi", "gdp", "rate decision", "ipca",
-      "brazil inflation", "pmi", "ism", "purchasing managers", "flash pmi"],
+      "brazil inflation", "pmi", "ism", "purchasing managers", "flash pmi", "jobs report", "nfp", "payrolls", "nonfarm"],
     // ECO MX,BR opens the calendar on those countries.
     shortcut: {
       prefix: "ECO",

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

@@ -1,5 +1,6 @@
 import type { GloomPluginContext } from "../../../types/plugin";
 import {
+  econEventName,
   eventCountry,
   getCalendarCache,
   landedHighImpactPrints,
@@ -57,7 +58,8 @@ const DEFAULT_DEPS: PrintWatchDeps = {
 };
 
 function printBody(event: EconEvent): string {
-  return event.forecast ? `${event.event} ${event.actual} vs ${event.forecast}` : `${event.event} ${event.actual}`;
+  const name = econEventName(event);
+  return event.forecast ? `${name} ${event.actual} vs ${event.forecast}` : `${name} ${event.actual}`;
 }
 
 type PrintWatchContext = Pick<GloomPluginContext, "notify" | "showPane">;

package/src/plugins/builtin/econ/types.ts

@@ -29,6 +29,8 @@ export interface EconEvent {
   source?: { name: string; url?: string };
   /** The indicator this release is of, the same from one release to the next; `id` is this row's alone. */
   indicatorId?: string | null;
+  /** Which feed the forecast was read from (`week-feed`, `release-calendar`) and when that feed was read. */
+  consensus?: { source: string; readAt: string } | null;
 }
 
 /** Whether a row's time is blank because its publisher states none (a bank whose calendar gives the day only). */

package/src/plugins/builtin/econ-statistics/client.ts

@@ -101,6 +101,17 @@ function bundleFrom(unaligned: StatBuild[], errors: string[]): StatsBundle {
   };
 }
 
+/**
+ * The bundle's errors less the refresh failures of statistics the copy an
+ * earlier read saved answered for: those say when that copy is from instead.
+ */
+export function unansweredErrors(bundle: StatsBundle): string[] {
+  const answered = new Set(bundle.builds.flatMap(({ stat, cache }) => (
+    cache?.source === "stale-fallback" && cache.refreshError ? [`${stat.seriesId}: ${cache.refreshError}`] : []
+  )));
+  return bundle.errors.filter((error) => !answered.has(error));
+}
+
 /** Builds whatever the on-disk cache can already answer, for an instant first paint. */
 export function getCachedStatsBundle(stats: readonly StatDef[] = STATS): StatsBundle | null {
   const builds: StatBuild[] = [];

package/src/plugins/builtin/econ-statistics/defs.ts

@@ -60,6 +60,12 @@ export interface StatDef {
   note: string;
   /** Other words the catalog and the pane's filter find it by: `PMMS` for the mortgage rate. */
   keywords?: readonly string[];
+  /**
+   * The names a reader gives the indicator, read as an argument ahead of any
+   * FRED series id: `PCE` is the price index release, not the series FRED files
+   * under that id (personal spending), and `gdp` is real GDP, not its nowcast.
+   */
+  aliases?: readonly string[];
   /** Concise measurement identity that must remain beside the values. */
   measurementBasis?: string;
   /**

package/src/plugins/builtin/econ-statistics/headless.ts

@@ -3,6 +3,7 @@ import type {
   HeadlessPaneDefinition,
   HeadlessPaneEntry,
 } from "../../../types/plugin";
+import { servedFromSavedCopy } from "../../../data/saved-copies";
 import { fredSourceLabel } from "../../../sources/gloomberb-cloud/fred-series";
 import { formatBasisPoints, toBasisPoints } from "../../../utils/basis-points";
 import { formatNumber } from "../../../utils/format";
@@ -10,6 +11,7 @@ import type { StatDef } from "./defs";
 import {
   createStatSeriesLoader,
   loadStatsBundle,
+  unansweredErrors,
   type StatsBundle,
 } from "./client";
 import { historyStartNotice } from "../shared/history-span";
@@ -17,7 +19,7 @@ import { formatMoveRank } from "../shared/move-rank";
 import type { StatPoint } from "../shared/stat-transform";
 import { formatSigma } from "../shared/trend";
 import { STAT_CATEGORIES } from "./defs";
-import { DEFAULT_STAT_ID, resolveStatArg, STATS } from "./stats";
+import { DEFAULT_STAT_ID, readStatArg, STATS } from "./stats";
 import { selectStatViews, type StatRangeId, type StatViewModel } from "./view";
 
 /** How a report reads a statistic: a spread in basis points, everything else as the pane does. */
@@ -84,6 +86,11 @@ function detailEntries(view: StatViewModel, cutoffShown: boolean, text: boolean)
   ];
 }
 
+/** A statistic answered from the copy saved by an earlier read, its refresh having failed, says so in its row. */
+function savedCopyRow<T extends object>(view: StatViewModel, row: T): T {
+  return view.cacheSource === "stale-fallback" && view.fetchedAt != null ? servedFromSavedCopy(row, view.fetchedAt) : row;
+}
+
 /** The window the %ile column counts over, in words. */
 const PERCENTILE_WINDOW: Record<StatRangeId, string> = {
   "5Y": "the last 5 years",
@@ -163,7 +170,7 @@ export function projectStatsHeadlessBundle(
       textColumns: columns(true),
       // `as_of` is the release; a figure with none stated is as of its own day when it is observed daily or weekly, never its period's first day.
       rowAsOfKey: "exportAsOf",
-      rows: categoryViews.map((view) => ({
+      rows: categoryViews.map((view) => savedCopyRow(view, {
         id: view.stat.id,
         indicator: view.stat.shortLabel,
         latest: view.latest.value,
@@ -208,7 +215,8 @@ export function projectStatsHeadlessBundle(
         ...exportDating(selected),
       }] : []),
     ],
-    errors: bundle.errors,
+    // A statistic answered from its saved copy says so in the source line, not as an error.
+    errors: unansweredErrors(bundle),
     notes: [
       `%ile is the share of past readings at or below the latest one, over ${PERCENTILE_WINDOW[range]}.`
       + (range === "ALL" ? "" : " Full history: --range ALL."),
@@ -238,7 +246,7 @@ export const econStatisticsHeadless: HeadlessPaneDefinition<"bundle"> = {
   argument: {
     kind: "free-text",
     placeholder: "statistic",
-    description: "Optional statistic id, FRED series id, label, or prefix.",
+    description: "Optional statistic id, name (PCE, GDP), label, FRED series id, or prefix.",
     optional: true,
   },
   options: [{
@@ -250,7 +258,8 @@ export const econStatisticsHeadless: HeadlessPaneDefinition<"bundle"> = {
   }],
   describe: (args) => `Economic Statistics | ${String(args.options.range)}`,
   async load(args, ctx) {
-    const requested = typeof args.argument === "string" ? resolveStatArg(args.argument) : null;
+    const read = typeof args.argument === "string" ? readStatArg(args.argument) : null;
+    const requested = read?.stat ?? null;
     if (args.argument && !requested) {
       throw new Error(
         `Unknown economic statistic "${String(args.argument)}". Use one of: ${STATS.map(({ id }) => id).join(", ")}.`,
@@ -261,6 +270,7 @@ export const econStatisticsHeadless: HeadlessPaneDefinition<"bundle"> = {
       loader: createStatSeriesLoader(ctx.apiClient),
       ...(requested ? { stats: [requested] } : {}),
     });
-    return projectStatsHeadlessBundle(bundle, range, requested?.id ?? DEFAULT_STAT_ID);
+    const report = projectStatsHeadlessBundle(bundle, range, requested?.id ?? DEFAULT_STAT_ID);
+    return read?.readAs ? { ...report, warnings: [read.readAs] } : report;
   },
 };

package/src/plugins/builtin/econ-statistics/pane.tsx

@@ -12,8 +12,9 @@ import type { PaneProps } from "../../../types/plugin";
 import { formatNumber } from "../../../utils/format";
 import { useAutoRefresh } from "../../../react/auto-refresh";
 import { usePaneStatusFooter } from "../../../components/layout/pane/status-footer";
+import { savedCopyFooterSegment } from "../../../components/layout/pane/footer";
 import { SeriesListDetail, useSeriesList } from "../shared/series-list-detail";
-import { getCachedStatsBundle, loadStatsBundle } from "./client";
+import { getCachedStatsBundle, loadStatsBundle, unansweredErrors } from "./client";
 import { categoryLabel, changeColor, type StatCategoryId } from "./defs";
 import { StatDetail } from "./detail";
 import { DEFAULT_STAT_ID } from "./stats";
@@ -145,7 +146,7 @@ export function EconStatisticsPane({ focused, width, height }: PaneProps) {
   const { selected, searchFocused } = list;
   const rows = useMemo(() => withCategoryHeaders(list.visible), [list.visible]);
 
-  const error = resource.error ?? bundle?.errors[0] ?? null;
+  const error = resource.error ?? (bundle ? unansweredErrors(bundle)[0] : null) ?? null;
   const footerInfo = useMemo<PaneFooterSegment[]>(() => {
     if (!selected) return [];
     // A Treasury yield names when in the day it was taken, as GC does, so it is not read against ^TNX's earlier close.
@@ -153,11 +154,14 @@ export function EconStatisticsPane({ focused, width, height }: PaneProps) {
     const info: PaneFooterSegment[] = [
       { id: "as-of", parts: [{ text: `reading for ${cutoff ? selected.reading : selected.readingReleased}${cutoff}`, tone: "muted" }] },
     ];
-    // The cached first paint is being replaced; its age only counts once that load fails.
+    // The cached first paint is being replaced; its age only counts once that load fails, and then it is the
+    // copy an earlier read saved, which says when that was.
     const seeding = resource.loading && resource.updatedAt === null && !selected.refreshError;
-    if (selected.observationStale || (selected.cacheStale && !seeding)) {
+    const savedAt = selected.cacheSource === "stale-fallback" ? selected.fetchedAt : null;
+    if (selected.observationStale || (selected.cacheStale && !seeding && savedAt == null)) {
       info.push({ id: "stale", parts: [{ text: "STALE", tone: "warning", bold: true }] });
     }
+    if (savedAt != null) info.push(savedCopyFooterSegment("saved-copy", savedAt));
     return info;
   }, [resource.loading, resource.updatedAt, selected]);
 

package/src/plugins/builtin/econ-statistics/stats.ts

@@ -68,6 +68,7 @@ export const STATS: readonly StatDef[] = [
   }),
   stat({
     id: "pce-yoy",
+    aliases: ["pce", "pce inflation", "pce price index"],
     label: "PCE Prices",
     shortLabel: "PCE y/y",
     category: "inflation",
@@ -143,6 +144,9 @@ export const STATS: readonly StatDef[] = [
     reference: { value: 0, label: "flat" },
     staleAfterMs: MONTHLY_EARLY,
     note: "Jobs added or lost last month, the single most watched release.",
+    // The jobs report as it is called: `ECST nfp` opens it.
+    aliases: ["nfp", "nonfarm", "nonfarm payrolls", "jobs report"],
+    keywords: ["jobs report", "nfp", "nonfarm"],
     limit: 900,
   }),
   stat({
@@ -179,6 +183,7 @@ export const STATS: readonly StatDef[] = [
   // ---- Growth ----------------------------------------------------------
   stat({
     id: "real-gdp",
+    aliases: ["gdp", "gdp growth"],
     measurementBasis: "q/q annualized",
     label: "Real GDP",
     shortLabel: "Real GDP q/q",
@@ -637,15 +642,40 @@ export const STATS: readonly StatDef[] = [
 
 export const DEFAULT_STAT_ID = STATS[0]!.id;
 
-/** Resolves shortcut arguments like `ECST cpi` onto a statistic. */
-export function resolveStatArg(arg: string | null | undefined): StatDef | null {
+/** A statistic an argument names, and what to say when it had to be read. */
+interface StatArgRead {
+  stat: StatDef;
+  /** "Read "PCE" as PCE Prices (PCE y/y)." when the argument is a name or a prefix, not the statistic's id, label or FRED series; null when it spelled one. */
+  readAs: string | null;
+}
+
+/**
+ * Reads a shortcut argument like `ECST cpi` as a statistic. What it is called
+ * comes before what FRED files it under: a statistic's id, its label, one of
+ * its common names (`PCE`, `gdp`), then a FRED series id, then the start of an
+ * id or a label. A name or a start says what it read, and a name that is also
+ * another statistic's FRED series (`PCE` is personal spending there) points at it.
+ */
+export function readStatArg(arg: string | null | undefined): StatArgRead | null {
   const query = arg?.trim().toLowerCase();
   if (!query) return null;
-  return STATS.find((entry) => entry.id === query)
-    ?? STATS.find((entry) => entry.seriesId.toLowerCase() === query)
-    ?? STATS.find((entry) =>
-      entry.id.startsWith(query)
-      || entry.label.toLowerCase().startsWith(query)
-      || entry.shortLabel.toLowerCase().startsWith(query))
-    ?? null;
+  const exact = STATS.find((entry) => entry.id === query)
+    ?? STATS.find((entry) => entry.label.toLowerCase() === query || entry.shortLabel.toLowerCase() === query);
+  if (exact) return { stat: exact, readAs: null };
+  const named = STATS.find((entry) => entry.aliases?.some((alias) => alias.toLowerCase() === query));
+  const series = STATS.find((entry) => entry.seriesId.toLowerCase() === query);
+  if (!named && series) return { stat: series, readAs: null };
+  const stat = named ?? STATS.find((entry) =>
+    entry.id.startsWith(query)
+    || entry.label.toLowerCase().startsWith(query)
+    || entry.shortLabel.toLowerCase().startsWith(query));
+  if (!stat) return null;
+  const otherSeries = series && series !== stat
+    ? ` FRED's series ${series.seriesId} is ${series.label.toLowerCase()}: type ${series.id} for it.` : "";
+  return { stat, readAs: `Read "${arg!.trim()}" as ${stat.label} (${stat.shortLabel}).${otherSeries}` };
+}
+
+/** Resolves shortcut arguments like `ECST cpi` onto a statistic. */
+export function resolveStatArg(arg: string | null | undefined): StatDef | null {
+  return readStatArg(arg)?.stat ?? null;
 }

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

@@ -0,0 +1,179 @@
+import type { ScreenDefinition, ScreenPayload, ScreenRow } from "../../../api-client/equity-screener";
+
+/**
+ * The sector and industry names a screen's `sector` and `industry` criteria
+ * match, as the screener's rows carry them (read from the covered universe on
+ * 2026-10-28): the eleven sectors and the industries under them. A criterion
+ * matches a name exactly, so `Utility` or `utilities` matches nothing.
+ */
+export const SCREEN_SECTORS = [
+  "Basic Materials", "Communication Services", "Consumer Cyclical", "Consumer Defensive", "Energy",
+  "Financial Services", "Healthcare", "Industrials", "Real Estate", "Technology", "Utilities",
+] as const;
+
+export const SCREEN_INDUSTRIES = [
+  "Advertising Agencies", "Aerospace & Defense", "Agricultural Inputs", "Airlines", "Airports & Air Services",
+  "Aluminum", "Apparel Manufacturing", "Apparel Retail", "Asset Management", "Auto Manufacturers", "Auto Parts",
+  "Auto & Truck Dealerships", "Banks - Diversified", "Banks - Regional", "Beverages - Brewers",
+  "Beverages - Non-Alcoholic", "Beverages - Wineries & Distilleries", "Biotechnology", "Broadcasting",
+  "Building Materials", "Building Products & Equipment", "Business Equipment & Supplies", "Capital Markets",
+  "Chemicals", "Coking Coal", "Communication Equipment", "Computer Hardware", "Confectioners", "Conglomerates",
+  "Consulting Services", "Consumer Electronics", "Copper", "Credit Services", "Department Stores",
+  "Diagnostics & Research", "Discount Stores", "Drug Manufacturers - General",
+  "Drug Manufacturers - Specialty & Generic", "Education & Training Services", "Electrical Equipment & Parts",
+  "Electronic Components", "Electronic Gaming & Multimedia", "Electronics & Computer Distribution",
+  "Engineering & Construction", "Entertainment", "Farm & Heavy Construction Machinery", "Farm Products",
+  "Financial Conglomerates", "Financial Data & Stock Exchanges", "Food Distribution", "Footwear & Accessories",
+  "Furnishings, Fixtures & Appliances", "Gambling", "Gold", "Grocery Stores", "Healthcare Plans",
+  "Health Information Services", "Home Improvement Retail", "Household & Personal Products",
+  "Industrial Distribution", "Information Technology Services", "Infrastructure Operations", "Insurance Brokers",
+  "Insurance - Diversified", "Insurance - Life", "Insurance - Property & Casualty", "Insurance - Reinsurance",
+  "Insurance - Specialty", "Integrated Freight & Logistics", "Internet Content & Information", "Internet Retail",
+  "Leisure", "Lodging", "Lumber & Wood Production", "Luxury Goods", "Marine Shipping", "Medical Care Facilities",
+  "Medical Devices", "Medical Distribution", "Medical Instruments & Supplies", "Metal Fabrication",
+  "Mortgage Finance", "Oil & Gas Drilling", "Oil & Gas E&P", "Oil & Gas Equipment & Services",
+  "Oil & Gas Integrated", "Oil & Gas Midstream", "Oil & Gas Refining & Marketing",
+  "Other Industrial Metals & Mining", "Other Precious Metals & Mining", "Packaged Foods",
+  "Packaging & Containers", "Paper & Paper Products", "Personal Services", "Pharmaceutical Retailers",
+  "Pollution & Treatment Controls", "Publishing", "Railroads", "Real Estate - Development",
+  "Real Estate Services", "Recreational Vehicles", "REIT - Diversified", "REIT - Healthcare Facilities",
+  "REIT - Hotel & Motel", "REIT - Industrial", "REIT - Mortgage", "REIT - Office", "REIT - Residential",
+  "REIT - Retail", "REIT - Specialty", "Rental & Leasing Services", "Residential Construction",
+  "Resorts & Casinos", "Restaurants", "Scientific & Technical Instruments", "Security & Protection Services",
+  "Semiconductor Equipment & Materials", "Semiconductors", "Shell Companies", "Silver",
+  "Software - Application", "Software - Infrastructure", "Solar", "Specialty Business Services",
+  "Specialty Chemicals", "Specialty Industrial Machinery", "Specialty Retail", "Staffing & Employment Services",
+  "Steel", "Telecom Services", "Textile Manufacturing", "Thermal Coal", "Tobacco", "Tools & Accessories",
+  "Travel Services", "Trucking", "Uranium", "Utilities - Diversified", "Utilities - Independent Power Producers",
+  "Utilities - Regulated Electric", "Utilities - Regulated Gas", "Utilities - Regulated Water",
+  "Utilities - Renewable", "Waste Management",
+] as const;
+
+/** GICS sector names, which these sectors are not, as the sector each means. */
+const GICS_SECTORS: Record<string, (typeof SCREEN_SECTORS)[number]> = {
+  informationtechnology: "Technology",
+  financials: "Financial Services",
+  healthcare: "Healthcare",
+  consumerstaples: "Consumer Defensive",
+  consumerdiscretionary: "Consumer Cyclical",
+  materials: "Basic Materials",
+  telecommunicationservices: "Communication Services",
+};
+
+/** The category fields whose names a screen can be checked against. A symbol has no list to check. */
+type NamedField = "sector" | "industry" | "exchange" | "currency";
+const NAMED_FIELDS: readonly NamedField[] = ["sector", "industry", "exchange", "currency"];
+
+/** A criterion's value that names nothing the screen covers, with the names it was likely meant as. */
+interface UnmatchedCategoryValue {
+  field: NamedField;
+  value: string;
+  closest: string[];
+  /** The value is a name of the other of sector and industry: `Solar` given as a sector. */
+  otherField?: "sector" | "industry";
+}
+
+/** Names compared without case, spaces or punctuation: `Oil and Gas E&P` beside `oil & gas e&p`. */
+const fold = (name: string) => name.toLowerCase().replace(/\band\b/g, "&").replace(/[^a-z0-9&]+/g, "");
+
+function editDistance(left: string, right: string): number {
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let row = 1; row <= left.length; row += 1) {
+    const current = [row];
+    for (let column = 1; column <= right.length; column += 1) {
+      const cost = left[row - 1] === right[column - 1] ? 0 : 1;
+      current[column] = Math.min(previous[column]! + 1, current[column - 1]! + 1, previous[column - 1]! + cost);
+    }
+    previous = current;
+  }
+  return previous[right.length]!;
+}
+
+/** How far a typed name is from a candidate, 0 the same and 1 nothing alike: against the whole name or one of its parts. */
+function nameDistance(typed: string, candidate: string): number {
+  const needle = fold(typed);
+  if (!needle) return 1;
+  const parts = [candidate, ...candidate.split(/\s+-\s+|\s+/)].map(fold).filter(Boolean);
+  return Math.min(...parts.map((part) => {
+    if (part === needle) return 0;
+    // "Bank" in "Banks - Regional", "Regulated" in "Utilities - Regulated Gas".
+    if (needle.length >= 4 && part.startsWith(needle)) return 0.2;
+    return editDistance(needle, part) / Math.max(needle.length, part.length);
+  }));
+}
+
+/** Names further than this from what was typed are not offered. */
+const CLOSEST_DISTANCE = 0.4;
+const CLOSEST_LIMIT = 5;
+
+/** The names a typed one was likely meant as, closest first. */
+function closestCategoryNames(typed: string, names: Iterable<string>, limit = CLOSEST_LIMIT): string[] {
+  const scored = [...new Set(names)].map((name) => ({ name, distance: nameDistance(typed, name) }));
+  // The name typed in another case or spacing is the one meant, whatever else is near it.
+  const same = scored.filter(({ name }) => fold(name) === fold(typed));
+  return (same.length > 0 ? same : scored)
+    .filter(({ distance }) => distance <= CLOSEST_DISTANCE)
+    .sort((a, b) => a.distance - b.distance || a.name.localeCompare(b.name))
+    .slice(0, limit)
+    .map(({ name }) => name);
+}
+
+/**
+ * The names each category field matches: the sector and industry lists above
+ * with those the rows carry, and the exchanges and currencies the covered
+ * universe reports. A field with no list (an older server's universe) is left
+ * out, so nothing is said of its values.
+ */
+function knownNames(payload: Pick<ScreenPayload, "universe">, rows: readonly Pick<ScreenRow, NamedField>[]): Record<NamedField, Set<string> | null> {
+  const seen = (field: NamedField) => rows.flatMap((row) => row[field] ? [row[field]!] : []);
+  const served = (list: readonly string[] | undefined, field: NamedField) =>
+    list?.length ? new Set([...list, ...seen(field)]) : null;
+  return {
+    sector: new Set([...SCREEN_SECTORS, ...payload.universe.sectors ?? [], ...seen("sector")]),
+    industry: new Set([...SCREEN_INDUSTRIES, ...seen("industry")]),
+    exchange: served(payload.universe.exchanges, "exchange"),
+    currency: served(payload.universe.currencies, "currency"),
+  };
+}
+
+/**
+ * The values of a screen's category criteria that name nothing the screen
+ * covers (`Utility` for the Utilities sector), so the screen reads why it
+ * matched nothing, or less than it should, rather than "No data".
+ */
+export function unmatchedCategoryValues(
+  definition: ScreenDefinition,
+  payload: Pick<ScreenPayload, "universe">,
+  rows: readonly Pick<ScreenRow, NamedField>[] = [],
+): UnmatchedCategoryValue[] {
+  const known = knownNames(payload, rows);
+  const unmatched: UnmatchedCategoryValue[] = [];
+  for (const criterion of definition.criteria) {
+    if (criterion.op !== "in" || !(NAMED_FIELDS as readonly string[]).includes(criterion.field)) continue;
+    const field = criterion.field as NamedField;
+    const names = known[field];
+    if (!names) continue;
+    for (const value of criterion.value) {
+      if (names.has(value)) continue;
+      const other = field === "sector" ? "industry" : field === "industry" ? "sector" : null;
+      const otherNames = other ? known[other] : null;
+      const otherField = other && otherNames && [...otherNames].some((name) => fold(name) === fold(value)) ? other : undefined;
+      const gics = field === "sector" ? GICS_SECTORS[fold(value)] : undefined;
+      const closest = gics ? [gics] : closestCategoryNames(value, names);
+      unmatched.push({ field, value, closest, ...(otherField ? { otherField } : {}) });
+    }
+  }
+  return unmatched;
+}
+
+const quoted = (value: string) => JSON.stringify(value);
+
+/** What a screen says of a value that names nothing: `No sector is named "Utility". Closest: Utilities.` */
+export function unmatchedCategoryText(entry: UnmatchedCategoryValue): string {
+  const head = `No ${entry.field} is named ${quoted(entry.value)}`;
+  if (entry.otherField) return `${head}; it is ${entry.otherField === "industry" ? "an industry" : "a sector"} name, so use "field": ${quoted(entry.otherField)}.`;
+  return entry.closest.length > 0 ? `${head}. Closest: ${entry.closest.join(", ")}.` : `${head}.`;
+}
+
+/** Where every sector and industry name is listed, said once after the values that name nothing. */
+export const CATEGORY_NAMES_POINTER = "gloom catalog EQS lists every sector and industry.";

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

@@ -21,7 +21,7 @@ const savedPath = (id: string) => `saved/${encodeURIComponent(id)}`;
 export const screenerApi = {
   query: (query: ScreenQuery, signal?: AbortSignal, client: ScreenerClient = apiClient) =>
     client.equityScreener<ScreenPayload>("query", json("POST", query, { signal })),
-  fields: (signal?: AbortSignal) => apiClient.equityScreener<ScreenFieldsResponse>("fields?include=social,research,attention,hiring-apps,kpis,volatility,dividends", { signal }),
+  fields: (signal?: AbortSignal) => apiClient.equityScreener<ScreenFieldsResponse>("fields?include=social,research,attention,hiring-apps,kpis,volatility,dividends,technical,option-volatility,ownership", { signal }),
   export: (definition: ScreenDefinition, snapshotId: string) =>
     apiClient.equityScreener<ScreenExportResponse>("export", json("POST", { ...definition, snapshotId }, { headers: { Accept: "application/json" } })),
   saved: async (signal?: AbortSignal, client: ScreenerClient = apiClient) =>
@@ -40,10 +40,12 @@ export async function fetchScreen(
   cursor: string | null = null,
   signal?: AbortSignal,
   client: ScreenerClient = apiClient,
+  /** Rows a page holds, at most the server's 200. */
+  limit = 100,
 ): Promise<ScreenPayload> {
   const payload = validateScreenPayload(
     await screenerApi.query(
-      { ...parseScreenDefinition(definition), limit: 100, cursor },
+      { ...parseScreenDefinition(definition), limit, cursor },
       signal,
       client,
     ),