gloomberb 0.17.2 → 0.17.4

package/src/plugins/builtin/short-interest/model.ts

@@ -53,6 +53,64 @@ function formatPercent(value: number | null): string {
   return value == null ? "-" : `${formatNumber(value, 2)}%`;
 }
 
+const finiteNumber = (value: number | null | undefined): value is number => typeof value === "number" && Number.isFinite(value);
+
+/**
+ * Shares short over the float, in percent. Short interest above the float is
+ * possible (shares lent twice), twice it is not: such a float is another
+ * class's (BRK.B's is Berkshire's Class A), so it is not used. The bound
+ * Gloom Cloud's statistics use for their short % of float.
+ */
+function percentOfFloat(sharesShort: number, floatShares: number | null | undefined): number | null {
+  return finiteNumber(floatShares) && floatShares > 0 && sharesShort <= floatShares * 2 ? (sharesShort / floatShares) * 100 : null;
+}
+
+/**
+ * The statistics' short % of float (a fraction, null when not served) and the
+ * settlement it is of: Gloom Cloud serves it on the float it serves, from the
+ * settlement SI and SIW show, as the overview and `fundamentals` read it.
+ */
+export interface SettlementFloatStatistics {
+  settlementDate: string;
+  shortPercentOfFloat: number | null;
+}
+
+/**
+ * A settlement's percent of float: the statistics' own when they are of the
+ * same settlement, then a percentage the source states, then the shares short
+ * over the current float.
+ */
+export function settlementPercentFloat(
+  record: ShortInterestRecord,
+  floatShares: number | null | undefined,
+  statistics?: SettlementFloatStatistics | null,
+): number | null {
+  if (statistics && statistics.settlementDate === record.settlementDate.toISOString().slice(0, 10)) {
+    return finiteNumber(statistics.shortPercentOfFloat) ? statistics.shortPercentOfFloat * 100 : null;
+  }
+  return record.shortPercentFloat ?? percentOfFloat(record.sharesShort, floatShares);
+}
+
+/**
+ * The newest settlement's percent of float where the source gives none, read
+ * against the current float as SIW reads it (settlementPercentFloat). The
+ * float is undated, so the settlements before it stay blank rather than take
+ * today's float.
+ */
+export function withLatestPercentFloat(
+  records: readonly ShortInterestRecord[],
+  floatShares: number | null | undefined,
+  statistics?: SettlementFloatStatistics | null,
+): ShortInterestRecord[] {
+  const latest = records.reduce<ShortInterestRecord | null>(
+    (best, record) => (!best || record.settlementDate.getTime() > best.settlementDate.getTime() ? record : best),
+    null,
+  );
+  return records.map((record) => (record === latest
+    ? { ...record, shortPercentFloat: settlementPercentFloat(record, floatShares, statistics) }
+    : record));
+}
+
 export function buildRows(records: ShortInterestRecord[]): ShortInterestRow[] {
   return records.map((record, index) => ({
     key: `${record.settlementDate.toISOString()}:${index}`,
@@ -89,9 +147,10 @@ export function sortRows(rows: ShortInterestRow[], preference: SortPreference):
 /**
  * The columns sit together rather than spread across the pane, so the figures
  * of one settlement read as a row, and fit a 60-column pane without a
- * horizontal scrollbar. FINRA settlement history carries no float, so percent of float is null for
- * every row on that route. Keeping the column drew a header over a column of
- * dashes, which reads as missing data rather than data the source never had.
+ * horizontal scrollbar. FINRA settlement history carries no float, so percent of float
+ * is null for every row unless the latest one is read against the current float
+ * (`withLatestPercentFloat`). Keeping the column with nothing in it drew a header over a
+ * column of dashes, which reads as missing data rather than data the source never had.
  */
 export function buildColumns(
   records: readonly ShortInterestRecord[] = [],

package/src/plugins/builtin/short-interest/pane.tsx

@@ -19,7 +19,6 @@ import { Box, TextAttributes } from "../../../ui";
 import { isKnownNonUsEquityTicker } from "../../../utils/sec";
 import { nextHeaderSort } from "../../../utils/sort-values";
 import { usePluginPaneState } from "../../runtime";
-import { loadShortInterest } from "./client";
 import {
   DEFAULT_SORT,
   buildColumns,
@@ -34,6 +33,7 @@ import {
   type SortPreference,
 } from "./model";
 import type { ShortInterestRecord } from "./types";
+import { loadShortInterestWithFloat } from "./watch-client";
 import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
 
 const EMPTY_RECORDS: ShortInterestRecord[] = [];
@@ -45,7 +45,7 @@ function ShortInterestView({ width, height, focused }: { width: number; height:
   const symbol = ticker?.metadata.ticker ?? null;
 
   const skipNonUs = isKnownNonUsEquityTicker(ticker);
-  const request = useCallback(() => loadShortInterest(symbol!), [symbol]);
+  const request = useCallback(() => loadShortInterestWithFloat(symbol!), [symbol]);
   const resource = useAsyncResource(symbol && !skipNonUs ? request : null, { clearOnError: true });
   const { error, updatedAt, reload: refresh } = resource;
   const records = resource.data?.records ?? EMPTY_RECORDS;

package/src/plugins/builtin/short-interest/schedule.ts

@@ -0,0 +1,107 @@
+import { getPublishedUsEquityCalendarDay } from "../../../market-data/published-us-sessions";
+
+/**
+ * When a short interest settlement reaches readers. FINRA's calendar follows a
+ * fixed rule (Rule 4560): positions are struck on the 15th of the month, or the
+ * business day before when it is not one, and on the month's last business day;
+ * firms report two business days later and FINRA publishes seven business days
+ * after the settlement. The dataset carries only the settlement date, so the
+ * rest is read from that rule, against the US exchange holidays.
+ */
+const PUBLICATION_LAG_BUSINESS_DAYS = 7;
+const MID_MONTH_DAY = 15;
+const DAY_MS = 86_400_000;
+const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const;
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const;
+
+export interface ShortInterestSchedule {
+  /** The settlement the schedule is read from, `YYYY-MM-DD`. */
+  settlement: string;
+  /** When FINRA published that settlement. */
+  published: string;
+  /** The first settlement after it. */
+  nextSettlement: string;
+  /** When FINRA publishes that one. */
+  nextPublished: string;
+}
+
+const isoDay = (ms: number) => new Date(ms).toISOString().slice(0, 10);
+const parseDay = (date: string) => Date.parse(`${date}T00:00:00Z`);
+
+/** A US business day: a weekday the exchanges are open. Years the calendar does not cover read as weekdays only. */
+function isBusinessDay(ms: number): boolean {
+  const weekday = new Date(ms).getUTCDay();
+  if (weekday === 0 || weekday === 6) return false;
+  return getPublishedUsEquityCalendarDay("NYSE", isoDay(ms)) !== "closed";
+}
+
+function addBusinessDays(ms: number, count: number): number {
+  let day = ms;
+  for (let left = count; left > 0;) {
+    day += DAY_MS;
+    if (isBusinessDay(day)) left -= 1;
+  }
+  return day;
+}
+
+/** The business day on or before `ms`. */
+function businessDayOnOrBefore(ms: number): number {
+  let day = ms;
+  while (!isBusinessDay(day)) day -= DAY_MS;
+  return day;
+}
+
+/** The two settlements of a month, in order: the 15th and the last business day. */
+function monthSettlements(year: number, month: number): [number, number] {
+  return [
+    businessDayOnOrBefore(Date.UTC(year, month, MID_MONTH_DAY)),
+    // Day 0 of the next month is this month's last day.
+    businessDayOnOrBefore(Date.UTC(year, month + 1, 0)),
+  ];
+}
+
+/** The first settlement strictly after `ms`. */
+function settlementAfter(ms: number): number {
+  const from = new Date(ms);
+  for (let step = 0; step < 3; step += 1) {
+    const found = monthSettlements(from.getUTCFullYear(), from.getUTCMonth() + step).find((day) => day > ms);
+    if (found != null) return found;
+  }
+  throw new Error(`No short interest settlement follows ${isoDay(ms)}.`);
+}
+
+/** The publication dates of a settlement and of the one after it; null for a date that is not `YYYY-MM-DD`. */
+export function shortInterestSchedule(settlement: string): ShortInterestSchedule | null {
+  const ms = parseDay(settlement);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(settlement) || !Number.isFinite(ms) || isoDay(ms) !== settlement) return null;
+  const next = settlementAfter(ms);
+  return {
+    settlement,
+    published: isoDay(addBusinessDays(ms, PUBLICATION_LAG_BUSINESS_DAYS)),
+    nextSettlement: isoDay(next),
+    nextPublished: isoDay(addBusinessDays(next, PUBLICATION_LAG_BUSINESS_DAYS)),
+  };
+}
+
+/** `Fri 9 Oct`, with its year when it is not the settlement's: a reader sees the year once, in the settlement's own date. */
+function dayText(date: string, settlement: string): string {
+  const ms = parseDay(date);
+  const day = new Date(ms);
+  const year = date.slice(0, 4) === settlement.slice(0, 4) ? "" : ` ${date.slice(0, 4)}`;
+  return `${WEEKDAYS[day.getUTCDay()]} ${day.getUTCDate()} ${MONTHS[day.getUTCMonth()]}${year}`;
+}
+
+/**
+ * `published Fri 9 Oct, next settlement Thu 15 Oct, published Mon 26 Oct`: what a
+ * trader could see on a given day, beside the settlement date the report cites.
+ */
+export function shortInterestScheduleText(schedule: ShortInterestSchedule): string {
+  const day = (date: string) => dayText(date, schedule.settlement);
+  return `published ${day(schedule.published)}, next settlement ${day(schedule.nextSettlement)}, published ${day(schedule.nextPublished)}`;
+}
+
+/** The report's freshness for the newest settlement it shows; nothing when no settlement is dated. */
+export function shortInterestFreshness(latestSettlement: string | null | undefined): { schedule: string; publishedAt: string } | undefined {
+  const schedule = latestSettlement ? shortInterestSchedule(latestSettlement) : null;
+  return schedule ? { schedule: shortInterestScheduleText(schedule), publishedAt: schedule.published } : undefined;
+}

package/src/plugins/builtin/short-interest/watch-client.ts

@@ -5,7 +5,8 @@ import type { QueryEntry } from "../../../market-data/result-types";
 import type { DataProvider } from "../../../types/data-provider";
 import type { PricePoint, TickerFinancials } from "../../../types/financials";
 import { errorMessage } from "../../../utils/errors";
-import { loadShortInterest } from "./client";
+import { loadShortInterest, type ShortInterestResult } from "./client";
+import { type SettlementFloatStatistics, withLatestPercentFloat } from "./model";
 import { buildShortWatchRow, type ShortWatchRow } from "./watch-model";
 import type { ShortInterestRecord } from "./types";
 
@@ -30,10 +31,55 @@ export function createShortWatchDependencies(
   };
 }
 
+/** A symbol's current float and the statistics' short % of float with its settlement, from its snapshot. */
+interface FloatSnapshot {
+  floatShares: number | null;
+  statistics: SettlementFloatStatistics | null;
+}
+
+/** Each symbol's float and statistics, in order: empty where its snapshot is missing or carries none. */
+async function loadFloats(
+  symbols: readonly string[],
+  loadSnapshots: ShortWatchDependencies["loadSnapshots"],
+  options: { forceRefresh?: boolean } = {},
+): Promise<FloatSnapshot[]> {
+  const entries = await Promise.resolve()
+    .then(() => loadSnapshots(symbols.map((symbol) => ({ symbol, exchange: "" })), options))
+    .catch(() => []);
+  return symbols.map((_symbol, index) => {
+    const entry = entries[index];
+    const fundamentals = (entry ? resolveEntryValue(entry) : null)?.fundamentals;
+    return {
+      floatShares: fundamentals?.floatShares ?? null,
+      statistics: fundamentals?.shortInterestDate
+        ? { settlementDate: fundamentals.shortInterestDate, shortPercentOfFloat: fundamentals.shortPercentOfFloat ?? null }
+        : null,
+    };
+  });
+}
+
+/**
+ * A ticker's settlements with the newest one's percent of float, as SIW reads
+ * it (settlementPercentFloat). A snapshot that fails leaves the settlements as
+ * they are.
+ */
+export async function loadShortInterestWithFloat(
+  symbol: string,
+  { marketData, client = apiClient, loadSnapshots = createShortWatchDependencies(marketData, client).loadSnapshots }: {
+    marketData?: DataProvider;
+    client?: Pick<typeof apiClient, "getCloudShortInterest">;
+    loadSnapshots?: ShortWatchDependencies["loadSnapshots"];
+  } = {},
+): Promise<ShortInterestResult> {
+  const [result, [snapshot]] = await Promise.all([loadShortInterest(symbol, client), loadFloats([symbol], loadSnapshots)]);
+  return { ...result, records: withLatestPercentFloat(result.records, snapshot?.floatShares, snapshot?.statistics) };
+}
+
 /**
- * Every name's settlements, float and daily closes. The floats come in one
- * batched snapshot; settlements and closes are per symbol, six at a time. A
- * name whose closes fail keeps its short interest without a price move.
+ * Every name's settlements, float and daily closes. The floats, with the
+ * statistics' short % of float and its settlement, come in one batched
+ * snapshot; settlements and closes are per symbol, six at a time. A name
+ * whose closes fail keeps its short interest without a price move.
  */
 export async function loadShortWatch(
   symbols: readonly string[],
@@ -41,7 +87,7 @@ export async function loadShortWatch(
   dependencies: ShortWatchDependencies = createShortWatchDependencies(),
 ): Promise<ShortWatchRow[]> {
   const instruments = symbols.map((symbol) => ({ symbol, exchange: "" }));
-  const snapshots = dependencies.loadSnapshots(instruments, { forceRefresh: options.forceRefresh }).catch(() => []);
+  const floats = loadFloats(symbols, dependencies.loadSnapshots, { forceRefresh: options.forceRefresh });
   const rows = new Array<ShortWatchRow>(symbols.length);
   let next = 0;
   const worker = async () => {
@@ -53,12 +99,12 @@ export async function loadShortWatch(
         dependencies.loadChart({ instrument, bufferRange: "3M", granularity: "resolution", resolution: "1d" },
           { forceRefresh: options.forceRefresh }).then((entry) => resolveEntryValue(entry) ?? []),
       ]);
-      const entry = (await snapshots)[index];
-      const floatShares = (entry ? resolveEntryValue(entry) : null)?.fundamentals?.floatShares ?? null;
+      const snapshot = (await floats)[index];
       rows[index] = buildShortWatchRow({
         symbol: instrument.symbol,
         records: records.status === "fulfilled" ? records.value : null,
-        floatShares,
+        floatShares: snapshot?.floatShares ?? null,
+        statistics: snapshot?.statistics ?? null,
         history: history.status === "fulfilled" ? history.value : null,
         error: records.status === "rejected" ? errorMessage(records.reason) : null,
       });

package/src/plugins/builtin/short-interest/watch-headless.ts

@@ -1,5 +1,6 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { formatCompact, formatNumber } from "../../../utils/format";
+import { shortInterestFreshness } from "./schedule";
 import { createShortWatchDependencies, loadShortWatch } from "./watch-client";
 import { customUniverse, type ShortWatchSetup, setupLabel, SHORT_WATCH_LIMIT, sortShortWatchRows } from "./watch-model";
 
@@ -13,33 +14,37 @@ export const shortWatchHeadless: HeadlessPaneDefinition<"rows"> = {
   freshness: { source: "FINRA", status: "not-a-feed", basis: "twice-monthly settlement", observedKey: "settlementDate", maxAgeMinutes: 30 * 24 * 60 },
   argument: { kind: "symbol-list", maximum: SHORT_WATCH_LIMIT, description: "US tickers; the pane defaults to your portfolios and watchlists." },
   usListingsOnly: "FINRA short interest",
+  failsWithoutData: true,
   options: [],
   describe: "Short squeeze watch",
   discovery: {
     aliases: ["SIW"],
     screenshotReadiness: "live-dom",
     dataRequirements: ["FINRA short interest settlements", "Float", "Daily closes"],
-    limitations: ["Percent of float uses the current float against the settlement's shares short.",
+    limitations: ["Borrow fee, utilization and locate availability are not available: FINRA short interest counts shares short, not what they cost to borrow.",
+      "Percent of float uses the current float against the settlement's shares short.",
       "Crowded is a fixed threshold, not a squeeze forecast."],
   },
   columns: [
     { key: "symbol", header: "Symbol" },
     { key: "setup", header: "Setup", format: (value) => setupLabel(value as ShortWatchSetup | null) || "--" },
     { key: "percentFloat", header: "% Float", align: "right", format: number(2, "%") },
-    { key: "daysToCover", header: "Days to Cover", align: "right", format: number(2) },
+    { key: "daysToCover", header: "Days to cover", align: "right", format: number(2) },
     { key: "changePercent", header: "SI Chg %", align: "right", format: signedPercent },
     { key: "return1M", header: "1M %", align: "right", format: signedPercent },
     { key: "sharesShort", header: "Shares Short", align: "right", format: (value) => typeof value === "number" ? formatCompact(value) : "--" },
     { key: "settlementDate", header: "Settled" },
-    { key: "closeDate", header: "Close" },
+    { key: "closeDate", header: "Close date" },
   ],
   async load(args, ctx) {
     const universe = customUniverse(args.symbols.join(","));
     const rows = sortShortWatchRows(await loadShortWatch(universe.symbols, { signal: ctx.signal, forceRefresh: ctx.refresh },
       createShortWatchDependencies(ctx.marketData, ctx.apiClient)), "setup", "desc");
     const missing = rows.filter((row) => !row.settlementDate);
+    const freshness = shortInterestFreshness(rows.map((row) => row.settlementDate).filter((date): date is string => !!date).sort().at(-1));
     return {
       rows: rows.map(({ error: _error, ...row }) => row),
+      ...(freshness ? { freshness } : {}),
       complete: !missing.length && !universe.notice && rows.every((row) => row.return1M != null),
       symbols: universe.symbols,
       unavailableSymbols: missing.map((row) => row.symbol),

package/src/plugins/builtin/short-interest/watch-model.ts

@@ -3,7 +3,9 @@ import type { PricePoint } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import { isKnownNonUsListing, listingAbroadVenue } from "../../../utils/sec";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { splitSymbolArgs } from "../../../cli/symbol-args";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
+import { type SettlementFloatStatistics, settlementPercentFloat } from "./model";
 import type { ShortInterestRecord } from "./types";
 
 /** Short interest is published per settlement for each US listing, so a list fetches one symbol at a time. */
@@ -51,6 +53,8 @@ export interface ShortWatchInputs {
   symbol: string;
   records: readonly ShortInterestRecord[] | null;
   floatShares: number | null;
+  /** The statistics' short % of float and its settlement (settlementPercentFloat). */
+  statistics?: SettlementFloatStatistics | null;
   history: readonly PricePoint[] | null;
   error?: string | null;
 }
@@ -101,19 +105,16 @@ function shortWatchSetup(row: Pick<ShortWatchRow, "percentFloat" | "daysToCover"
 
 /**
  * One name's latest settlement, its change from the settlement before, its
- * shares short over the float, and its month's price move. A settlement that
- * carries its own percent of float keeps it; otherwise the float is the
- * snapshot's current float.
+ * shares short over the float, and its month's price move. The percent of
+ * float is the statistics' own when they are of the same settlement, so it
+ * reads as the overview and `fundamentals` do; otherwise the settlement's
+ * shares short over the snapshot's float.
  */
 export function buildShortWatchRow(inputs: ShortWatchInputs): ShortWatchRow {
   const records = [...(inputs.records ?? [])].sort((left, right) => left.settlementDate.getTime() - right.settlementDate.getTime());
   const latest = records.at(-1);
   const prior = records.at(-2);
-  // A float smaller than the shares short is another class's float (BRK.B reports Berkshire's Class A), not a short over 100%.
-  const percentFloat = latest
-    ? latest.shortPercentFloat ?? (finite(inputs.floatShares) && inputs.floatShares >= latest.sharesShort && inputs.floatShares > 0
-      ? latest.sharesShort / inputs.floatShares * 100 : null)
-    : null;
+  const percentFloat = latest ? settlementPercentFloat(latest, inputs.floatShares, inputs.statistics) : null;
   const move = inputs.history ? oneMonthReturn(inputs.history) : null;
   const row = {
     symbol: inputs.symbol,
@@ -163,10 +164,20 @@ export function sharedDate(rows: readonly ShortWatchRow[], key: "settlementDate"
 
 export interface ShortWatchUniverse { symbols: string[]; notice: string | null }
 
-/** US listings only: short interest settlements cover US-traded shares. */
-function listed(ticker: Pick<TickerRecord, "metadata">): boolean {
+const NOT_US_LISTED = "not US-listed";
+const NOT_A_US_TICKER = "not a US ticker symbol";
+const NOT_A_STOCK_OR_FUND = "not a US-listed stock or fund";
+
+/** A US-listed stock or fund; otherwise why this name has no short interest. */
+function listedReason(ticker: Pick<TickerRecord, "metadata">): string | null {
   const category = (ticker.metadata.assetCategory ?? "").toUpperCase().replace(/[\s_-]/g, "");
-  return LISTED_TYPES.has(category) && !isKnownNonUsListing(ticker as TickerRecord);
+  if (!LISTED_TYPES.has(category)) return NOT_A_STOCK_OR_FUND;
+  return isKnownNonUsListing(ticker as TickerRecord) ? NOT_US_LISTED : null;
+}
+
+/** "Left out: ABC.L: not US-listed; XYZ: not a US ticker symbol.", or null when every name was read. */
+function leftOut(skipped: readonly { name: string; reason: string }[]): string | null {
+  return skipped.length ? `Left out: ${skipped.map(({ name, reason }) => `${name}: ${reason}`).join("; ")}.` : null;
 }
 
 function cap(symbols: string[], skipped: string | null): ShortWatchUniverse {
@@ -177,22 +188,40 @@ function cap(symbols: string[], skipped: string | null): ShortWatchUniverse {
   };
 }
 
-const plural = (count: number) => `${count} name${count === 1 ? "" : "s"}`;
-
 /** Every name in the user's portfolios and watchlists. */
 export function ownNamesUniverse(tickers: readonly Pick<TickerRecord, "metadata">[]): ShortWatchUniverse {
   const members = tickers.filter((ticker) => ticker.metadata.portfolios.length > 0 || ticker.metadata.watchlists.length > 0);
-  const symbols = members.filter(listed).map((ticker) => ticker.metadata.ticker.toUpperCase()).filter((symbol) => SYMBOL.test(symbol));
-  const skipped = members.length - symbols.length;
-  return cap(symbols.sort(), skipped ? `${plural(skipped)} left out: short interest covers US-listed shares.` : null);
+  const symbols: string[] = [];
+  const skipped: { name: string; reason: string }[] = [];
+  for (const ticker of members) {
+    const symbol = ticker.metadata.ticker.toUpperCase();
+    const reason = listedReason(ticker) ?? (SYMBOL.test(symbol) ? null : NOT_A_US_TICKER);
+    if (reason) skipped.push({ name: symbol, reason });
+    else symbols.push(symbol);
+  }
+  return cap(symbols.sort(), leftOut(skipped.sort((left, right) => left.name.localeCompare(right.name))));
 }
 
+/** A share class written with a dash (BRK-B, BF-B) is the dotted symbol (BRK.B, BF.B) short interest is filed under. */
+const DASHED_CLASS_SHARE = /^([A-Z]{1,5})-([A-Z])$/;
+
+/**
+ * The names typed or pasted: split by commas, semicolons or blanks, each
+ * without the quote marks or the `$` around it. A name this cannot read as a US
+ * symbol is left out and named with its reason.
+ */
 export function customUniverse(text: string): ShortWatchUniverse {
-  const entries = text.split(/[\s,]+/).map((value) => value.toUpperCase()).filter(Boolean);
-  // A listing abroad (SAN:EPA) is not its symbol's US line, which can be another company's.
-  const valid = entries.filter((entry) => listingAbroadVenue(entry) == null)
-    .map((entry) => parsePublicTickerKey(entry).symbol)
-    .filter((symbol) => SYMBOL.test(symbol));
-  const skipped = entries.length - valid.length;
-  return cap(valid, skipped ? `${plural(skipped)} left out: short interest covers US-listed shares.` : null);
+  const symbols: string[] = [];
+  const skipped: { name: string; reason: string }[] = [];
+  for (const entry of splitSymbolArgs([text]).map((value) => value.replace(/^\$+/, "").toUpperCase())) {
+    // A listing abroad (SAN:EPA) is not its symbol's US line, which can be another company's.
+    if (listingAbroadVenue(entry) != null) {
+      skipped.push({ name: entry, reason: NOT_US_LISTED });
+      continue;
+    }
+    const symbol = parsePublicTickerKey(entry).symbol.replace(DASHED_CLASS_SHARE, "$1.$2");
+    if (SYMBOL.test(symbol)) symbols.push(symbol);
+    else skipped.push({ name: entry, reason: NOT_A_US_TICKER });
+  }
+  return cap(symbols, leftOut(skipped));
 }

package/src/plugins/builtin/short-interest/watch-pane.tsx

@@ -50,7 +50,7 @@ const COLUMNS: WatchColumn[] = [
   { id: "return1M", label: "1M%", width: 8, align: "right" },
   { id: "sharesShort", label: "Short", width: 8, align: "right" },
   { id: "settlementDate", label: "Settled", width: 8, align: "right" },
-  { id: "closeDate", label: "Close", width: 8, align: "right" },
+  { id: "closeDate", label: "Close date", width: 10, align: "right" },
 ];
 const DEFAULT_SORT = { columnId: "setup" as ShortWatchSortId, direction: "desc" as SortDirection };
 const rowKey = (row: ShortWatchRow) => row.symbol;

package/src/plugins/builtin/supply-chain/flow.tsx

@@ -183,9 +183,10 @@ export function SupplyFlow({ rows, symbol, focusName, focusId, width, height, fo
   const hasBand = (band: "suppliers" | "customers") => nodes.some((node) => node.band === band);
   return <Box width={width} height={height} flexGrow={1} flexBasis={0} minHeight={0} position="relative" overflow="hidden">
     <ChartSurface ref={surfaceRef} width={width} height={height} position="absolute" left={0} top={0}
-      vectors={desktop ? vectors : undefined} bitmap={bitmap} flexDirection="column" aria-label="Supply chain flow"
+      vectors={desktop ? vectors : undefined} bitmap={bitmap} flexDirection="column"
       onMouseMove={hoverAt} onMouseOut={() => setHovered(null)}
-      onMouseDown={() => { const node = hovered ? nodes.find((entry) => entry.id === hovered) : null; if (node) selectNode(node); }}>
+      onMouseDown={() => { const node = hovered ? nodes.find((entry) => entry.id === hovered) : null; if (node) selectNode(node); }}
+      aria-label={hovered ? flowNodeName(nodes.find((entry) => entry.id === hovered)!) : "Supply chain flow"}>
       {fallback ? fallback.map((spans, y) => <Text key={y}>{spans.map((span, i) => <Span key={i} fg={span.color}>{span.text}</Span>)}</Text>) : null}
     </ChartSurface>
     {header("suppliers", 1)}
@@ -217,6 +218,13 @@ export function SupplyFlow({ rows, symbol, focusName, focusId, width, height, fo
   </Box>;
 }
 
+function flowNodeName(node: PositionedNode): string {
+  if (node.more) return `Show ${node.more} more ${node.role ? ROLE_PLURAL[node.role].toLowerCase() : node.band}`;
+  const name = node.row ? counterpartyLabel(node.row) : node.label;
+  const role = node.role ? roleLabel(node.role) : node.band;
+  return `Open ${name}, ${role}`;
+}
+
 function tooltipAnchor(node: PositionedNode, ribbons: readonly FlowRibbon[], width: number) {
   const ribbon = ribbons.find((entry) => entry.id === node.id);
   const x = ribbon ? (ribbon.x0 + ribbon.x1) / 2 : node.x + node.width / 2;
@@ -275,7 +283,8 @@ function FlowCard({ node, focusId, desktop, active, onPress, onHover }: {
     backgroundColor={node.more ? undefined : active ? desktop ? blendHex(colors.bg, accent, 0.2) : colors.selected : blendHex(colors.bg, accent, desktop ? 0.09 : 0.12)}
     style={desktop ? { borderLeft: `3px ${node.more ? "dotted" : "solid"} ${node.more ? blendHex(colors.bg, accent, 0.5) : accent}`, borderRadius: 3, paddingLeft: 6, cursor: "pointer",
       boxShadow: active ? `inset 0 0 0 1px ${blendHex(colors.bg, accent, 0.6)}` : undefined } : undefined}
-    onMouseDown={onPress} onMouseOver={() => onHover(true)} onMouseOut={() => onHover(false)} data-gloom-role="supply-flow-node">
+    onMouseDown={onPress} onMouseOver={() => onHover(true)} onMouseOut={() => onHover(false)} data-gloom-role="supply-flow-node"
+    role="button" aria-label={flowNodeName(node)}>
     {/* The ticker shows only beside the whole name. On the desktop that is CSS: the row wraps, one line shows, and a ticker that does not fit goes to the hidden line. */}
     <Box flexDirection="row" height={1} overflow="hidden" style={desktop ? { flexWrap: "wrap" } : undefined}>
       {!desktop ? <Text fg={node.more ? colors.textMuted : accent}>▍</Text> : null}
@@ -295,7 +304,8 @@ function FlowChip({ node, desktop, active, onPress, onHover }: { node: Positione
   const background = active ? blendHex(colors.bg, accent, desktop ? 0.32 : 0.45) : node.more ? undefined : blendHex(colors.bg, accent, 0.14);
   const text = <ClippedText fg={node.more ? colors.textDim : active ? colors.textBright : accent} text={flowChipLabel(node)} width={node.width - 2} />;
   return <Box position="absolute" left={node.x} top={node.y} width={node.width} height={1} justifyContent={desktop ? "center" : undefined}
-    onMouseDown={onPress} onMouseOver={() => onHover(true)} onMouseOut={() => onHover(false)} data-gloom-role="supply-flow-chip">
+    onMouseDown={onPress} onMouseOver={() => onHover(true)} onMouseOut={() => onHover(false)} data-gloom-role="supply-flow-chip"
+    role="button" aria-label={flowNodeName(node)}>
     {/* The desktop chip leaves a hairline of row above and below, like ticker chips. */}
     {desktop ? <Box paddingX={1} minWidth={0} backgroundColor={background} justifyContent="center" style={{ height: "calc(100% - 4px)", borderRadius: 3, cursor: "pointer" }}>{text}</Box>
       : <Box paddingX={1} height={1} backgroundColor={background}>{text}</Box>}

package/src/plugins/builtin/themes/headless.ts

@@ -72,7 +72,7 @@ export const themesHeadless: HeadlessPaneDefinition<"rows"> = {
     const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument;
     if (argument) {
       const theme = matchTheme(board.themes, argument);
-      if (!theme) throw new Error(`No theme matches ${argument}`);
+      if (!theme) throw new Error(`No theme matches ${argument}. Themes: ${board.themes.map((row) => row.name).join(", ")}.`);
       const data = await fetchThemeMembers(theme.id, context.apiClient);
       const observation = boardObservation(data);
       // Price and 1D are the regular session's; an extended print gets a column only when a member has one.