@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/plugins/builtin/earnings/scope.ts

@@ -2,40 +2,31 @@ import type { FundMember } from "../../../api-client/members";
 import type { Portfolio, Watchlist } from "../../../types/ticker";
 import { getSectorCollection } from "../sectors/sector-data";
 
-/**
- * The fund whose holdings name each company's GICS sector: the S&P 500's, as
- * MEMB reads it. A Select Sector SPDR holds the S&P 500's companies of one
- * sector, so its members are these holdings in that sector.
- */
-export const SECTOR_HOLDINGS_FUND = "IVV";
+/** Focused industries, named by the fund whose published holdings define the group. */
+const INDUSTRIES = [
+  { etf: "SOXX", name: "Semiconductors" },
+  { etf: "XPH", name: "Pharmaceuticals" },
+  { etf: "XBI", name: "Biotech" },
+  { etf: "ITA", name: "Aerospace & defense" },
+  { etf: "KRE", name: "Regional banks" },
+  { etf: "IGV", name: "Software" },
+  { etf: "XRT", name: "Retail" },
+  { etf: "XHB", name: "Homebuilders" },
+  { etf: "XOP", name: "Oil & gas exploration" },
+] as const;
 
-/** The GICS sector each of SECT's sector funds holds, as the S&P 500's holdings name it. */
-const SECTOR_OF_FUND: Readonly<Record<string, readonly string[]>> = {
-  XLK: ["Information Technology"],
-  XLV: ["Health Care"],
-  XLF: ["Financials"],
-  XLY: ["Consumer Discretionary"],
-  // The holdings file says "Communication"; GICS's own name is the longer one.
-  XLC: ["Communication", "Communication Services"],
-  XLI: ["Industrials"],
-  XLP: ["Consumer Staples"],
-  XLE: ["Energy"],
-  XLU: ["Utilities"],
-  XLRE: ["Real Estate"],
-  XLB: ["Materials"],
-};
-
-/** Which companies ERN lists: the market's, the user's, one portfolio or watchlist, or one sector fund's. */
+/** Which companies ERN lists: the market, the user's lists, or a fund's holdings. */
 export type EarningsScope =
   | { kind: "all" }
   | { kind: "mine" }
   | { kind: "portfolio" | "watchlist"; id: string; name: string }
-  | { kind: "sector"; etf: string; name: string; sectors: readonly string[] };
+  | { kind: "fund"; etf: string; name: string };
 
 export interface EarningsScopeOption {
   value: string;
   label: string;
   description?: string;
+  group?: string;
   scope: EarningsScope;
 }
 
@@ -47,30 +38,28 @@ export const MINE_SCOPE = "mine";
 const kindNote = (name: string, kind: "Portfolio" | "Watchlist") =>
   name.toLowerCase().includes(kind.toLowerCase()) ? undefined : kind;
 
-/**
- * The choices of ERN's Names filter, in menu order: the market, every held or
- * watched name, each portfolio and watchlist, then SECT's sector funds, each
- * named with its fund ("Technology (XLK)").
- */
+/** Personal lists, broad sectors and focused industries stay separate in the Names menu. */
 export function earningsScopeOptions(collections: { portfolios: readonly Portfolio[]; watchlists: readonly Watchlist[] }): EarningsScopeOption[] {
   return [
     { value: ALL_SCOPE, label: "All", scope: { kind: "all" } },
     { value: MINE_SCOPE, label: "Mine", description: "Portfolios and watchlists", scope: { kind: "mine" } },
     ...collections.portfolios.map((portfolio): EarningsScopeOption => ({
-      value: `portfolio:${portfolio.id}`, label: portfolio.name, description: kindNote(portfolio.name, "Portfolio"),
+      value: `portfolio:${portfolio.id}`, label: portfolio.name, description: kindNote(portfolio.name, "Portfolio"), group: "Your lists",
       scope: { kind: "portfolio", id: portfolio.id, name: portfolio.name },
     })),
     ...collections.watchlists.map((watchlist): EarningsScopeOption => ({
-      value: `watchlist:${watchlist.id}`, label: watchlist.name, description: kindNote(watchlist.name, "Watchlist"),
+      value: `watchlist:${watchlist.id}`, label: watchlist.name, description: kindNote(watchlist.name, "Watchlist"), group: "Your lists",
       scope: { kind: "watchlist", id: watchlist.id, name: watchlist.name },
     })),
-    ...getSectorCollection("sectors").items.flatMap((sector): EarningsScopeOption[] => {
-      const sectors = SECTOR_OF_FUND[sector.etf];
-      return sectors ? [{
-        value: `sector:${sector.etf}`, label: `${sector.name} (${sector.etf})`,
-        scope: { kind: "sector", etf: sector.etf, name: sector.name, sectors },
-      }] : [];
-    }),
+    ...getSectorCollection("sectors").items.map((sector): EarningsScopeOption => ({
+      // Keep the saved sector choice when switching to that fund's own holdings.
+      value: `sector:${sector.etf}`, label: `${sector.name} (${sector.etf})`, group: "Sectors",
+      scope: { kind: "fund", etf: sector.etf, name: sector.name },
+    })),
+    ...INDUSTRIES.map((industry): EarningsScopeOption => ({
+      value: `industry:${industry.etf}`, label: `${industry.name} (${industry.etf})`, group: "Industries",
+      scope: { kind: "fund", etf: industry.etf, name: industry.name },
+    })),
   ];
 }
 
@@ -79,11 +68,10 @@ export function readEarningsScope(value: string, options: readonly EarningsScope
   return options.find((option) => option.value === value) ?? options[0]!;
 }
 
-/** A sector fund's companies: the S&P 500's holdings in its sector, largest weight first. */
-export function sectorSymbols(members: readonly FundMember[], sectors: readonly string[]): string[] {
-  const symbols = members
-    .filter((member) => member.symbol && member.sector && sectors.includes(member.sector))
+/** A fund's companies, largest weight first; cash and other unlisted holdings have no symbol. */
+export function fundSymbols(members: readonly FundMember[]): string[] {
+  const symbols = [...members]
     .sort((left, right) => (right.weight ?? 0) - (left.weight ?? 0))
-    .map((member) => member.symbol!.trim().toUpperCase());
+    .flatMap((member) => member.symbol?.trim() ? [member.symbol.trim().toUpperCase()] : []);
   return [...new Set(symbols)];
 }

package/src/plugins/builtin/earnings-calls/calendar.tsx

@@ -29,7 +29,7 @@ import { usePluginPaneState } from "../../runtime";
 import { newYorkToday } from "../earnings/board-model";
 import { ProWall, SignInWall } from "../cloud/auth-actions";
 import { cachedUpcomingCalls, calendarAway, loadUpcomingCalls, statusOf, upcomingCutNotice, type UpcomingCallsResult } from "./data";
-import { formatPeriod } from "./format";
+import { callPeriod } from "./format";
 import {
   calendarDays,
   calendarSections,
@@ -106,7 +106,7 @@ function renderCalendarCell(row: CalendarRow, column: CalendarColumn, now: numbe
       return clock ? { text: clock, color: tone(colors.textDim) } : { text: MISSING, color: colors.textMuted };
     }
     case "period":
-      return { text: formatPeriod(call.fiscalYear, call.fiscalQuarter), color: tone(colors.textDim) };
+      return { text: callPeriod(call), color: tone(colors.textDim) };
     case "away":
       return { text: calendarAway(call, now), color: over ? colors.textMuted : colors.textBright };
   }

package/src/plugins/builtin/earnings-calls/format.ts

@@ -2,7 +2,7 @@ import type { CloudEarningsCallPayload } from "../../../api-client";
 import { formatShortDate } from "../../../utils/datetime-format";
 
 /** "FQ4 26" — fiscal period, compact enough for a table column. */
-export function formatPeriod(
+function formatPeriod(
   fiscalYear: number | null,
   fiscalQuarter: number | null,
 ): string {
@@ -36,8 +36,37 @@ export function formatTimestamp(seconds: number): string {
   return `${minutes}:${String(remainder).padStart(2, "0")}`;
 }
 
+type NamedCall = Pick<
+  CloudEarningsCallPayload,
+  "ticker" | "fiscalYear" | "fiscalQuarter" | "eventKind" | "eventLabel"
+>;
+
+/** An event that is not an earnings call (a deal call, an investor day), shown by its label and never as a quarter. */
+export function eventLabelOf(call: Omit<NamedCall, "ticker">): string | null {
+  return call.eventKind === "other" && call.eventLabel ? call.eventLabel : null;
+}
+
+// Fits the period column; the full label is in the detail title.
+const SHORT_EVENT_LABELS: Record<string, string> = {
+  "M&A call": "M&A",
+  conference: "Conf",
+  "investor day": "Inv day",
+  "business update": "Update",
+  "trial results": "Trial",
+  "shareholder call": "Holders",
+};
+
+/** The period column: "FQ4 26", or a short event label ("M&A", "Inv day"). */
+export function callPeriod(call: Omit<NamedCall, "ticker">): string {
+  const label = eventLabelOf(call);
+  if (label) return SHORT_EVENT_LABELS[label] ?? label;
+  return formatPeriod(call.fiscalYear, call.fiscalQuarter);
+}
+
 /** Title for the detail stack: names the call so the body need not repeat it. */
-export function callTitle(call: CloudEarningsCallPayload): string {
+export function callTitle(call: NamedCall): string {
+  const label = eventLabelOf(call);
+  if (label) return `${call.ticker} ${label}`;
   const period = formatPeriod(call.fiscalYear, call.fiscalQuarter);
   return period === "—" ? call.ticker : `${call.ticker} ${period}`;
 }

package/src/plugins/builtin/earnings-calls/headless.ts

@@ -23,7 +23,7 @@ import {
   type UpcomingCallsResult,
   type UpcomingDays,
 } from "./data";
-import { formatPeriod } from "./format";
+import { callPeriod, eventLabelOf } from "./format";
 import type { MarketDay } from "../earnings/board-model";
 import {
   calendarDays,
@@ -53,6 +53,7 @@ const CALL_COLUMNS = [
   { key: "callAt", header: "Call date" },
   { key: "fiscalYear", header: "FY", align: "right" as const },
   { key: "fiscalQuarter", header: "FQ", align: "right" as const },
+  { key: "event", header: "Event" },
   { key: "status", header: "Status" },
   { key: "durationSeconds", header: "Seconds", align: "right" as const },
   { key: "wordCount", header: "Words", align: "right" as const },
@@ -124,6 +125,8 @@ function callRow(call: CloudEarningsCallPayload, now: number) {
     callAt: call.callAt,
     fiscalYear: call.fiscalYear,
     fiscalQuarter: call.fiscalQuarter,
+    // A deal call, a conference, an investor day: not a quarter's earnings call.
+    event: eventLabelOf(call),
     status: call.hasTranscript ? "transcribed" : callStatusLabel(call, now) || call.status,
     upcoming,
     in: upcoming ? callCountdown(call, now) : null,
@@ -219,6 +222,7 @@ function transcriptResult(
       company: transcript.companyName,
       fiscalYear: transcript.fiscalYear,
       fiscalQuarter: transcript.fiscalQuarter,
+      event: eventLabelOf(transcript),
       callAt: transcript.callAt,
       durationSeconds: transcript.durationSeconds,
       wordCount: transcript.wordCount,
@@ -259,7 +263,8 @@ function projectCalendar(
     timeKnown: callTimeKnown(call),
     local: callLocalClock(call),
     newYork: callNewYorkClock(call),
-    period: formatPeriod(call.fiscalYear, call.fiscalQuarter),
+    period: callPeriod(call),
+    event: eventLabelOf(call),
     fiscalYear: call.fiscalYear,
     fiscalQuarter: call.fiscalQuarter,
     in: calendarAway(call, now),

package/src/plugins/builtin/earnings-calls/model.ts

@@ -3,6 +3,7 @@ import type {
   CloudEarningsTranscriptPayload,
   CloudTranscriptTurnPayload,
 } from "../../../api-client";
+import { eventLabelOf } from "./format";
 import { splitParagraphs } from "./prose";
 
 export type TranscriptSection =
@@ -210,7 +211,11 @@ export function findCallForQuarter(
 ): CloudEarningsCallPayload | null {
   const sorted = sortCallsNewest(calls);
   const token = requestedQuarter.trim().toUpperCase().replace(/[\s_-]+/g, "");
-  if (!token || token === "LATEST") return sorted[0] ?? null;
+  // The latest earnings call: a deal call or an investor day held after it is
+  // not the quarter's call, unless the company has nothing else.
+  if (!token || token === "LATEST") {
+    return sorted.find((call) => !eventLabelOf(call)) ?? sorted[0] ?? null;
+  }
 
   const quarterFirst = token.match(/^(?:F?Q)?([1-4])(?:\/?(\d{2}|\d{4}))?$/);
   if (quarterFirst) {

package/src/plugins/builtin/earnings-calls/pane.tsx

@@ -49,7 +49,7 @@ import {
   loadTranscript,
   statusOf,
 } from "./data";
-import { callTitle, formatCallDate, formatDuration, formatPeriod, formatSentiment } from "./format";
+import { callPeriod, callTitle, eventLabelOf, formatCallDate, formatDuration, formatSentiment } from "./format";
 import { findCallForQuarter, findInLines, MIN_FIND_LENGTH, turnParagraphs } from "./model";
 import { READER_TABS, TranscriptView, type ReaderTab, type TranscriptPlayback } from "./transcript-view";
 import { PLAYBACK_RATES, SEEK_STEP_SECONDS, useCallPlayback } from "./use-call-playback";
@@ -101,7 +101,7 @@ function renderCell(call: CloudEarningsCallPayload, column: CallColumn, now: num
     case "date":
       return { text: formatCallDate(call.callAt), color: colors.textDim };
     case "period":
-      return { text: formatPeriod(call.fiscalYear, call.fiscalQuarter) };
+      return { text: callPeriod(call) };
     case "length":
       return { text: formatDuration(call.durationSeconds), color: colors.textDim };
     case "sentiment": {
@@ -525,7 +525,8 @@ function CallsListView({
           [
             call.ticker,
             call.companyName ?? "",
-            formatPeriod(call.fiscalYear, call.fiscalQuarter),
+            callPeriod(call),
+            eventLabelOf(call) ?? "",
             formatCallDate(call.callAt),
           ]
             .join(" ")
@@ -1020,7 +1021,7 @@ function CallsListView({
         <AudioPlayer
           src={playback.audio.url}
           sourceKey={selected.id}
-          label={`${callTitle(selected)} call recording`}
+          label={`${callTitle(selected)}${eventLabelOf(selected) ? "" : " call"} recording`}
           durationSeconds={playback.audio.durationSeconds}
           rates={PLAYBACK_RATES}
           rate={playback.rate}

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/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

@@ -17,7 +17,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. */
@@ -238,7 +238,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 +250,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 +262,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/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",
@@ -179,6 +180,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 +639,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,
     ),