gloomberb 0.18.4 → 0.19.0

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

@@ -14,9 +14,10 @@ import {
 } from "./client";
 import { historyStartNotice } from "../shared/history-span";
 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. */
@@ -24,20 +25,26 @@ function reportFormat(stat: StatDef): (value: number) => string {
   return stat.basisPoints ? (value) => formatBasisPoints(value) : stat.formatValue;
 }
 
-/** `cutoffShown`: the status line names when in the day the reading was taken, so the period does not repeat it. */
-function detailEntries(view: StatViewModel, cutoffShown: boolean): HeadlessPaneEntry[] {
+/**
+ * `cutoffShown`: the status line names when in the day the reading was taken, so the period does not repeat it.
+ * `text` is the report's text lines, where Previous says its period beside it; exports give the period a line of its own.
+ */
+function detailEntries(view: StatViewModel, cutoffShown: boolean, text: boolean): HeadlessPaneEntry[] {
   const format = reportFormat(view.stat);
   return [
     { label: "Latest", value: view.latest.value, formatted: format(view.latest.value) },
     {
       label: "Previous",
       value: view.previous?.value ?? null,
-      formatted: view.previous ? format(view.previous.value) : "-",
+      formatted: view.previous ? `${format(view.previous.value)}${text && view.previousReading ? ` (${view.previousReading})` : ""}` : "-",
+      ...earlierDating(view, view.previous),
     },
+    ...!text && view.previous ? [{ label: "Previous period", value: view.previous.date, formatted: view.previousReading ?? view.previous.date, ...earlierDating(view, view.previous) }] : [],
     {
       label: "1Y ago",
       value: view.yearAgo?.value ?? null,
       formatted: view.yearAgo ? format(view.yearAgo.value) : "-",
+      ...earlierDating(view, view.yearAgo),
     },
     { label: "Mean", value: view.mean, formatted: format(view.mean) },
     {
@@ -84,6 +91,29 @@ const PERCENTILE_WINDOW: Record<StatRangeId, string> = {
   ALL: "the full history",
 };
 
+/**
+ * An earlier reading's own dating (previous, a year ago): its period, no release (the server dates only the
+ * latest print's), and its own day for as-of when the series is observed daily or weekly. A reading there is
+ * none of is of no period, never the latest's.
+ */
+function earlierDating(view: StatViewModel, point: StatPoint | null): Pick<HeadlessPaneEntry, "period" | "released" | "asOf"> {
+  return { period: point?.date ?? null, released: null, asOf: point && !view.periodicity ? point.date : null };
+}
+
+/** The period a statistic's lines cover and the day they were released, for the `period` and `released` of each exported line. */
+function exportDating(view: StatViewModel): { period: string; released?: string; asOf: string | null } {
+  return { period: view.latest.date, ...(view.releasedOn ? { released: view.releasedOn } : {}), asOf: exportAsOf(view) };
+}
+
+/**
+ * What an exported row is as of: the day its figure was released, else its own
+ * day when it is observed daily or weekly (a Treasury yield), and nothing when
+ * the date only starts the period it covers.
+ */
+function exportAsOf(view: StatViewModel): string | null {
+  return view.releasedOn ?? (view.periodicity ? null : view.latest.date);
+}
+
 export function projectStatsHeadlessBundle(
   bundle: StatsBundle,
   range: StatRangeId,
@@ -94,35 +124,45 @@ export function projectStatsHeadlessBundle(
   const sections = STAT_CATEGORIES.flatMap((category) => {
     const categoryViews = views.filter((view) => view.stat.category === category.id);
     if (categoryViews.length === 0) return [];
+    // The text table keeps the columns a terminal has room for; exports add what each figure is of.
+    const columns = (text: boolean) => [
+      { key: "indicator", header: "Indicator" },
+      {
+        key: "latest",
+        header: "Latest",
+        align: "right" as const,
+        format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedLatest),
+      },
+      {
+        key: "previous",
+        header: "Previous",
+        align: "right" as const,
+        format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedPrevious),
+      },
+      // Which period Previous is: exports carry it beside the figure, the text table has its Period column for the latest.
+      ...text ? [] : [{ key: "previousPeriod", header: "Previous period" }],
+      {
+        key: "percentile",
+        header: "%ile",
+        align: "right" as const,
+        format: (value: unknown) => formatNumber(Number(value), 0),
+      },
+      // `period` and `released` are the names every dated export gives these (`econ`, `fred`).
+      { key: "asOf", header: "period", literalHeader: true, textHeader: "Period", format: (_value: unknown, row: Record<string, unknown>) => String(row.reading) },
+      {
+        key: "releasedOn",
+        header: "released",
+        literalHeader: true,
+        textHeader: "Released",
+        format: (_value: unknown, row: Record<string, unknown>) => typeof row.released === "string" ? row.released.replace(/^released /, "") : "",
+      },
+    ];
     return [{
       title: category.label,
-      columns: [
-        { key: "indicator", header: "Indicator" },
-        {
-          key: "latest",
-          header: "Latest",
-          align: "right" as const,
-          format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedLatest),
-        },
-        {
-          key: "previous",
-          header: "Previous",
-          align: "right" as const,
-          format: (_value: unknown, row: Record<string, unknown>) => String(row.formattedPrevious),
-        },
-        {
-          key: "percentile",
-          header: "%ile",
-          align: "right" as const,
-          format: (value: unknown) => formatNumber(Number(value), 0),
-        },
-        { key: "asOf", header: "Period", format: (_value: unknown, row: Record<string, unknown>) => String(row.reading) },
-        {
-          key: "releasedOn",
-          header: "Released",
-          format: (_value: unknown, row: Record<string, unknown>) => typeof row.released === "string" ? row.released.replace(/^released /, "") : "",
-        },
-      ],
+      columns: columns(false),
+      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) => ({
         id: view.stat.id,
         indicator: view.stat.shortLabel,
@@ -130,6 +170,7 @@ export function projectStatsHeadlessBundle(
         formattedLatest: reportFormat(view.stat)(view.latest.value),
         previous: view.previous?.value ?? null,
         formattedPrevious: view.previous ? reportFormat(view.stat)(view.previous.value) : "-",
+        previousPeriod: view.previous?.date ?? null,
         // A spread's values stay in percentage points; these carry the figures its text shows.
         ...(view.stat.basisPoints ? {
           latestBasisPoints: toBasisPoints(view.latest.value),
@@ -139,6 +180,7 @@ export function projectStatsHeadlessBundle(
         // The period the figure covers; `releasedOn` is when it was published, which the report is as of.
         asOf: view.latest.date,
         releasedOn: view.releasedOn,
+        exportAsOf: exportAsOf(view),
         ...(view.periodicity ? { periodicity: view.periodicity } : {}),
         reading: view.reading,
         released: view.released,
@@ -159,7 +201,12 @@ export function projectStatsHeadlessBundle(
     ...(cutoff ? { freshness: { ...ECST_FRESHNESS, schedule: cutoff } } : {}),
     sections: [
       ...sections,
-      ...(selected ? [{ title: selected.stat.label, entries: detailEntries(selected, cutoff != null) }] : []),
+      ...(selected ? [{
+        title: selected.stat.label,
+        entries: detailEntries(selected, cutoff != null, false),
+        textEntries: detailEntries(selected, cutoff != null, true),
+        ...exportDating(selected),
+      }] : []),
     ],
     errors: bundle.errors,
     notes: [
@@ -187,10 +234,11 @@ const ECST_FRESHNESS = { source: "FRED", status: "not-a-feed", basis: "published
 export const econStatisticsHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
   freshness: ECST_FRESHNESS,
+  exportDated: true,
   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: [{
@@ -202,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(", ")}.`,
@@ -213,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",
@@ -270,6 +272,7 @@ export const STATS: readonly StatDef[] = [
     reference: { value: 0, label: "flat" },
     staleAfterMs: NOWCAST_QUARTERLY,
     note: "Atlanta Fed model estimate of real GDP growth, updated within the quarter. Already an annualized percentage change, not a GDP level.",
+    keywords: ["nowcast", "GDP nowcast"],
   }),
   stat({
     id: "nfci",
@@ -636,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/econ-statistics/view.ts

@@ -34,6 +34,8 @@ export interface StatViewModel {
   periodicity: "monthly" | "quarterly" | "annual" | null;
   /** The print before this one, for the direction of the last move. */
   previous: StatPoint | null;
+  /** What that print is a reading of, as `reading` says the latest's: "Aug 2026"; null with no previous print. */
+  previousReading: string | null;
   yearAgo: StatPoint | null;
   changeOnPrevious: number | null;
   /** Where the current reading sits within the selected range. */
@@ -153,6 +155,7 @@ export function projectStat(
     readingReleased: periodReleasedText(reading, releasedOn, latest.date),
     periodicity: periodStartPeriodicity(latest.date, perYear),
     previous,
+    previousReading: previous ? formatStatReading(previous.date, perYear) : null,
     yearAgo,
     changeOnPrevious: previous ? latest.value - previous.value : null,
     percentile: visible.length === 0 ? 0 : (100 * atOrBelow) / visible.length,

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,
     ),