@gloom-sh/terminal 0.19.2 → 0.19.3

package/src/types/headless.ts

@@ -127,6 +127,8 @@ export interface HeadlessPaneContext {
   capabilities?: CapabilityInvoker;
   /** The catalog's name for the series charted as an expression (`FRED:DFII10`); undefined for one it does not list. */
   catalogSeriesName?: (expression: string) => string | undefined;
+  /** The catalog series a bare word is an alias of (`hashrate` is CAP:bitcoin:hashrate); undefined for any other word. */
+  catalogSeriesNamed?: (word: string) => { expression: string; name: string } | undefined;
   /** Locally registered broker adapters. Reports may read account data; they never submit orders. */
   resolveBroker?: (brokerType: string) => import("./broker").BrokerAdapter | null;
   /** Read one local portfolio without passing holdings through a remote endpoint. */
@@ -149,7 +151,9 @@ export interface HeadlessPaneContext {
    * `coinNote` is what `quote` says of a bare coin ticker read as a listing
    * that is not the coin (ETH, the Grayscale fund), for the report's warnings.
    */
-  resolveListing?: (symbol: string, argumentWith: (key: string) => string) => Promise<{ symbol: string; exchange?: string; name?: string; coinNote?: string } | null>;
+  resolveListing?: (symbol: string, argumentWith: (key: string) => string) => Promise<{ symbol: string; exchange?: string; name?: string; coinNote?: string;
+    /** What became of the company that had the symbol, as `quote` says it ("GOGL was Golden Ocean Group until 2025, now Cmb.Tech: CMBT"). */
+    successorNote?: string } | null>;
   /**
    * What a plugin keeps on this device only (its `ctx.resume` state, never
    * synced), such as ALRT's log of the alerts the app fired; null when none.
@@ -191,6 +195,13 @@ export interface HeadlessPaneColumn {
   stackRows?: number;
   /** The text table leaves the column out when fitted to fewer terminal columns than this; exports and piped output keep it. */
   minTableWidth?: number;
+  /**
+   * The narrow text table drops the column, rightmost first, before it moves any column under its rows: a figure
+   * the others imply (RETURN's interval $ beside its prices). Exports and a table that fits keep it.
+   */
+  optional?: boolean;
+  /** Among optional columns, a higher priority is dropped sooner. */
+  dropPriority?: number;
   description?: string;
   format?: (value: unknown, row: HeadlessPaneRow) => string;
   /** What the text report prints when it can say more than an export should (a unit word beside a number); CSV and NDJSON keep `format`. */
@@ -209,9 +220,10 @@ export interface HeadlessPaneColumn {
   /**
    * The text report prints the value on its own lines under the row instead
    * of in a column, for a footnote that belongs to that row; an empty value
-   * prints nothing. Exports keep it as a column.
+   * prints nothing. Exports keep it as a column. `"line"`: one line cut to
+   * the width, never wrapped (a story's summary under its headline).
    */
-  underRow?: boolean;
+  underRow?: boolean | "line";
 }
 
 export interface HeadlessPaneEntry {
@@ -284,6 +296,13 @@ export interface HeadlessPaneFreshness {
   delayMinutes?: number;
   /** What not-a-feed data is, in a few words: "filed data", "monthly release", "your inputs". */
   basis?: string;
+  /**
+   * The pane shows nothing from a market or a feed: the user's own notes and
+   * rules, the app's connections, documentation, an account. A screenshot's
+   * footer then carries no status line, which would date nothing or call the
+   * app's own state "not a live feed". `fn` still cites `source` and `basis`.
+   */
+  local?: boolean;
   /**
    * How often the data is published, when its dates mark the start of a period
    * (a monthly statistic is dated the 1st). The report then names the month,
@@ -403,12 +422,24 @@ export interface HeadlessPaneFreshness {
    * `newest story` dates a news list `newest story Tue 29 Sep 2026 20:17 UTC`.
    */
   asOfLabel?: string;
+  /**
+   * The newest observation is a bar of this many minutes that opens at the
+   * as-of: the line names its span, `last bar 15:00–16:00 UTC`, so the bar's
+   * open is not read as how far the data runs.
+   */
+  barMinutes?: number;
   /**
    * Say when the rows were retrieved too, after the newest one's date: a list
    * dated by its newest filing was not read then (`newest filing Tue 27 Oct
    * 2026 · retrieved Wed 28 Oct 2026 19:07 UTC`).
    */
   retrievedToo?: boolean;
+  /**
+   * When the source last read the data, when that is not now: a page the
+   * server reads hourly is retrieved when it read it, not when the report
+   * asked the server. An ISO instant; ignored when in the future.
+   */
+  retrievedAt?: string;
   /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
   note?: string;
   /**
@@ -504,6 +535,13 @@ export interface HeadlessRowsResult extends HeadlessPaneResultBase {
 export type HeadlessBundleSection =
   | {
     title: string;
+    /**
+     * The heading the text report prints in place of `title`, when it can say
+     * more than an export's section name should (the scale its amounts are
+     * printed in, "Total revenue, USD millions"). JSON, CSV and NDJSON keep
+     * `title`, so a section read by its name stays where it was.
+     */
+    textTitle?: string;
     columns?: HeadlessPaneColumn[];
     rows: HeadlessPaneRow[];
     /** What the report says when `rows` is empty, in place of "No data.": why there are none, and what to run instead. */
@@ -576,6 +614,7 @@ export type HeadlessBundleSection =
     /** In a report with `exportDated`: the period the figures cover, and when they were released (an ISO date or instant), which each exported line names in `period` and `released`. */
     period?: string;
     released?: string;
+    textTitle?: never;
     columns?: never;
     rows?: never;
     textColumns?: never;

package/src/types/plugin.ts

@@ -183,7 +183,7 @@ export interface PaneDef {
    * `headless` model) cites, when "Gloom Cloud" with the state the footer
    * shows would be wrong: local data, a calculator, filed records.
    */
-  reportFreshness?: Pick<HeadlessPaneFreshness, "source" | "status" | "basis">;
+  reportFreshness?: Pick<HeadlessPaneFreshness, "source" | "status" | "basis" | "local">;
   /**
    * Options a rendered-view report takes (`fn OMON AAPL --strikes 10`):
    * each sets the pane setting of its key, is checked by its `normalize`, and
@@ -203,7 +203,14 @@ export interface PaneDef {
    * catalog lists it, and `fn` refuses an argument from a function that
    * declares none here, in its shortcut or in a `headless` model.
    */
-  reportArgument?: Pick<HeadlessPaneArgumentDef, "kind" | "placeholder" | "description" | "optional">;
+  reportArgument?: Pick<HeadlessPaneArgumentDef, "kind" | "placeholder" | "description" | "optional"> & {
+    /**
+     * The argument names something the pane opens by its own id (the story
+     * pane's story id), never a symbol: `fn` does not look it up as a ticker.
+     * A query (X Feed's) leaves it unset and keeps its ticker reading.
+     */
+    identifier?: boolean;
+  };
   /**
    * Lines a rendered-view report prints above its table, from the settings it
    * ran with: what the default view leaves out and how to see more. `--json`
@@ -220,6 +227,12 @@ export interface PaneDef {
    * for the symbol (`lock.context` reads it), so the note may resolve later.
    */
   reportLockNote?(lock: PaneLock): string | Promise<string>;
+  /**
+   * The sign-in wall covers the whole pane whenever there is no Gloom Cloud
+   * session (ASKG): a rendered-view report without one prints its
+   * `reportLockNote` at once rather than render the wall to read it.
+   */
+  signInWall?: boolean;
   /**
    * What a rendered-view report needs before it shows anything, such as a
    * sign-in: `gloom catalog` lists it under Requires, as it does a
@@ -540,6 +553,13 @@ export interface PaneTemplateDef {
   listed?: boolean;
   /** Template-specific headless model. Takes precedence over the pane-level model. */
   headless?: HeadlessPaneDefinition;
+  /**
+   * A one-ticker template whose pane also opens on several at once (DVD's
+   * ranking): `fn` and `shot` pass a typed list (`shot DVD KO JNJ`) to
+   * createInstance as `symbols`. Any other one-ticker template gets the list
+   * as it always has, in `symbol` and `arg`.
+   */
+  opensTickerList?: boolean;
   /**
    * Source and status of the view this template opens, for a template that
    * opens one view of a pane hosting several (Fixed Income's Issuer Debt).
@@ -547,9 +567,16 @@ export interface PaneTemplateDef {
    * `reportFreshness`: each field set here wins, the rest are the pane's. So
    * they date the filings on screen, not the issuer's stock quote.
    */
-  reportFreshness?: Pick<HeadlessPaneFreshness, "source" | "status" | "basis">;
+  reportFreshness?: Pick<HeadlessPaneFreshness, "source" | "status" | "basis" | "local">;
   wizard?: WizardStep[];
   canCreate?: (context: PaneTemplateContext, options?: PaneTemplateCreateOptions) => boolean;
+  /**
+   * Settings shown by catalog discovery without running createInstance. Supply
+   * these when opening a pane needs live data or has side effects. An empty
+   * object means there are no settings to describe before the pane is opened.
+   * When omitted, discovery derives settings from createInstance as before.
+   */
+  catalogSettings?: Record<string, unknown>;
   createInstance?: (
     context: PaneTemplateContext,
     options?: PaneTemplateCreateOptions,
@@ -962,6 +989,8 @@ export interface AppNotificationRequest {
     label: string;
     onClick: () => void;
   };
+  /** Runs once, when the in-app toast is first drawn. Not called when `toast` is false. */
+  onShown?: () => void;
 }
 
 export interface BrokerInstanceUpdateOptions {

package/src/ui/host.tsx

@@ -375,6 +375,17 @@ export interface ImageSurfaceProps extends BoxProps {
   src?: string;
   alt?: string;
   objectFit?: "contain" | "cover";
+  /**
+   * Draw `children` until the image has loaded, not only without a `src` or
+   * once it fails, so a box that waits on a picture shows its stand-in rather
+   * than an empty one. The terminal always does.
+   */
+  fallbackWhileLoading?: boolean;
+  /**
+   * A colour behind the picture once it has loaded (a logo made for a light
+   * page), never behind `children`. The terminal draws none.
+   */
+  imageBackground?: string;
 }
 export interface MediaSurfaceProps extends BoxProps {
   src?: string;

package/src/ui/toast.tsx

@@ -1,4 +1,5 @@
-import { createContext, useContext, type ComponentType, type ReactNode } from "react";
+import { createContext, useContext, useEffect, useRef, type ComponentType, type ReactNode } from "react";
+import { logFailure } from "../utils/log-failure";
 
 /** @public */
 export interface ToastAction {
@@ -14,6 +15,8 @@ export interface ToastOptions {
   action?: ToastAction;
   /** Rendered next to `action`. Use for a dismissing counterpart such as snooze. */
   secondaryAction?: ToastAction;
+  /** Runs once, after a viewport first draws the toast. */
+  onShown?(): void;
 }
 
 export interface ToastHost {
@@ -141,6 +144,28 @@ export function useToastHost(): ToastHost {
   return host;
 }
 
+/**
+ * Every viewport calls this with the toasts it draws: each toast's `onShown`
+ * runs once, after the commit that first puts it on screen.
+ */
+export function useToastsShown(toasts: readonly { id: number; options?: ToastOptions }[]): void {
+  const shown = useRef(new Set<number>());
+  useEffect(() => {
+    const current = new Set<number>();
+    for (const toast of toasts) {
+      current.add(toast.id);
+      if (shown.current.has(toast.id)) continue;
+      try {
+        toast.options?.onShown?.();
+      } catch (error) {
+        // One failing callback must not keep the others from running.
+        logFailure("toast", "A toast's shown callback failed")(error);
+      }
+    }
+    shown.current = current;
+  }, [toasts]);
+}
+
 export function ToastViewport(props: { position?: string }) {
   const { Viewport } = useToastHost();
   return <Viewport {...props} />;

package/src/utils/ascii-text.ts

@@ -0,0 +1,140 @@
+/**
+ * Text for a terminal that shows only ASCII: a C locale, or a Windows console
+ * on a legacy code page (437, 850, 1252), where UTF-8 bytes print as `—`.
+ * What the CLI writes itself keeps its meaning: a dash is `-`, the `·`
+ * between a source line's parts `|`, a price in euros `EUR211.25` (as one in
+ * kroner is `NOK393.90`) and one in US cents `447.50c`.
+ */
+
+/** Spelled out before single characters, so the yuan's `CN¥` is not read as the yen's `¥`. */
+const ASCII_SEQUENCES: ReadonlyArray<readonly [string, string]> = [
+  ["CN¥", "CNY"],
+  ["JP¥", "JPY"],
+];
+
+const ASCII_SPELLINGS: Readonly<Record<string, string>> = {
+  // Dashes and the minus sign.
+  "\u2012": "-", "\u2013": "-", "\u2014": "-", "\u2015": "-", "\u2212": "-",
+  // Separators and marks.
+  "\u00B7": "|", "\u2022": "*", "\u2026": "...", "\u00A6": "|",
+  // Currencies, as their codes; a minor unit as its letter.
+  "\u20AC": "EUR", "\u00A3": "GBP", "\u00A5": "JPY", "\u00A2": "c", "\u20B9": "INR", "\u20A9": "KRW", "\u20AA": "ILS",
+  "\u20AB": "VND", "\u20B1": "PHP", "\u20BA": "TRY", "\u20BD": "RUB", "\u20A6": "NGN", "\u20B4": "UAH", "\u20B8": "KZT",
+  "\u20BF": "BTC", "\u0E3F": "THB",
+  // Quotes and primes.
+  "\u2018": "'", "\u2019": "'", "\u201A": "'", "\u201C": "\"", "\u201D": "\"", "\u201E": "\"", "\u2032": "'", "\u2033": "\"",
+  "\u00AB": "\"", "\u00BB": "\"",
+  // Arithmetic.
+  "\u00D7": "x", "\u00F7": "/", "\u00B1": "+/-", "\u2248": "~", "\u2264": "<=", "\u2265": ">=", "\u2260": "!=", "\u00B0": "deg",
+  "\u00BC": "1/4", "\u00BD": "1/2", "\u00BE": "3/4", "\u2030": "per mille", "\u00B5": "u",
+  // Arrows and markers.
+  "\u2192": "->", "\u2190": "<-", "\u2191": "^", "\u2193": "v", "\u25B2": "^", "\u25BC": "v", "\u21B5": "Enter",
+  "\u2713": "ok", "\u2714": "ok", "\u2717": "x", "\u2715": "x",
+  // Box drawing.
+  "\u2502": "|", "\u2500": "-", "\u2503": "|", "\u2501": "-",
+  // Spaces.
+  "\u00A0": " ", "\u2009": " ", "\u202F": " ", "\u2007": " ", "\u2002": " ", "\u2003": " ",
+  // Letters that do not decompose.
+  "\u00DF": "ss", "\u00E6": "ae", "\u00C6": "AE", "\u0153": "oe", "\u0152": "OE", "\u00F8": "o", "\u00D8": "O",
+  "\u0111": "d", "\u0110": "D", "\u0142": "l", "\u0141": "L", "\u00FE": "th", "\u00DE": "Th", "\u0131": "i",
+  // Signs.
+  "\u2122": "(TM)", "\u00AE": "(R)", "\u00A9": "(C)",
+};
+
+const NON_ASCII = /[^\x00-\x7F]/;
+const COMBINING_MARKS = /[\u0300-\u036F]/g;
+
+/**
+ * `text` in ASCII: each character above with its spelling, an accented letter
+ * without its accent (Société Générale is Societe Generale), a box or block
+ * drawing character as `|`, `-`, `+` or `#`, and anything else as `?`.
+ * Escape sequences (colour) are ASCII and pass through.
+ */
+export function asciiText(text: string): string {
+  if (!NON_ASCII.test(text)) return text;
+  let folded = text;
+  for (const [sequence, spelling] of ASCII_SEQUENCES) folded = folded.split(sequence).join(spelling);
+  let out = "";
+  for (const character of folded) {
+    if (character.charCodeAt(0) < 0x80) {
+      out += character;
+      continue;
+    }
+    const spelled = ASCII_SPELLINGS[character];
+    if (spelled !== undefined) {
+      out += spelled;
+      continue;
+    }
+    const bare = character.normalize("NFD").replace(COMBINING_MARKS, "");
+    if (bare && !NON_ASCII.test(bare)) {
+      out += bare;
+      continue;
+    }
+    const code = character.codePointAt(0)!;
+    // Box drawing (U+2500-257F): corners and joins as +; block elements (U+2580-259F), a bar or sparkline's, as #.
+    out += code >= 0x2500 && code <= 0x257F ? "+" : code >= 0x2580 && code <= 0x259F ? "#" : "?";
+  }
+  return out;
+}
+
+type LocaleEnv = Readonly<Record<string, string | undefined>>;
+
+/**
+ * The locale text is written in, by the variable POSIX reads first (LC_ALL,
+ * then LC_CTYPE, then LANG; an empty one is unset), or null when none is set.
+ */
+function localeName(env: LocaleEnv): string | null {
+  return env.LC_ALL || env.LC_CTYPE || env.LANG || null;
+}
+
+/**
+ * Whether the terminal may not read UTF-8: a locale that names no UTF-8
+ * (`C`, `POSIX`, `en_US.ISO-8859-1`), or a Windows shell that sets none, whose
+ * console code page then decides (`consoleReadsUtf8`). A locale that is UTF-8,
+ * or none set elsewhere, is taken to read it.
+ */
+export function localeMayNotReadUtf8(env: LocaleEnv = process.env, platform: string = process.platform): boolean {
+  const locale = localeName(env);
+  if (locale) return !/utf-?8/i.test(locale);
+  return platform === "win32";
+}
+
+/**
+ * Where Windows keeps `chcp.com`. Windows looks a bare program name up in the
+ * current folder before the system's, so a `chcp.com` left in the folder a
+ * command runs in would run in its place; the full path never does.
+ */
+export function windowsChcpPath(env: Readonly<Record<string, string | undefined>> = process.env): string {
+  const root = [env.SystemRoot, env.SYSTEMROOT, env.windir, env.WINDIR]
+    .find((dir): dir is string => !!dir && /^[A-Za-z]:[\\/]/.test(dir)) ?? "C:\\Windows";
+  return `${root.replace(/[\\/]+$/, "")}\\System32\\chcp.com`;
+}
+
+/** The console's code page as `chcp` prints it ("Active code page: 437"), or null when it cannot be read. */
+function consoleCodePage(): number | null {
+  try {
+    if (typeof Bun === "undefined" || process.platform !== "win32") return null;
+    const answer = Bun.spawnSync([windowsChcpPath()], { stdout: "pipe", stderr: "ignore" });
+    const page = /(\d+)\D*$/.exec(answer.stdout.toString().trim());
+    return page ? Number(page[1]) : null;
+  } catch {
+    // Intentional ignore: a console whose code page cannot be read is left to show what it gets.
+    return null;
+  }
+}
+
+/**
+ * Whether the terminal reads UTF-8: by the locale when one is set, else on
+ * Windows by the console's code page (65001 is UTF-8). A code page that
+ * cannot be read is taken to read it, so nothing changes where it is unknown.
+ */
+export function localeReadsUtf8(
+  env: LocaleEnv = process.env,
+  platform: string = process.platform,
+  codePage: () => number | null = consoleCodePage,
+): boolean {
+  if (!localeMayNotReadUtf8(env, platform)) return true;
+  if (localeName(env)) return false;
+  const page = codePage();
+  return page == null || page === 65001;
+}

package/src/utils/cli-output.ts

@@ -1,3 +1,4 @@
+import { asciiText, localeReadsUtf8 } from "./ascii-text";
 type CliAlign = "left" | "right" | "center";
 
 export interface CliTableColumn {
@@ -45,6 +46,8 @@ export interface CliTableOptions {
   indent?: number;
   /** Lines printed under each row, by row index, indented and muted: a footnote that belongs to the row. */
   below?: ReadonlyArray<readonly string[] | undefined>;
+  /** Each line under a row stays one line, cut to the table's width, rather than wrapping: a story's summary. */
+  cutBelow?: boolean;
 }
 
 export type CliStatEntry = readonly [label: string, value: string];
@@ -73,7 +76,12 @@ const NUMBER_JOINER = /^(?:\/|·|→|↑|↓|[-–]|to|up|down)$/;
 const PLAIN_EMPTY_CELL = "—";
 let colorEnabledOverride: boolean | null = null;
 let widthOverride: number | null = null;
+/** The widths `COLUMNS` is taken at for piped output, as `--width` takes them; anything else is ignored. */
+const MIN_COLUMNS_VARIABLE = 20;
+const MAX_COLUMNS_VARIABLE = 1000;
 let plainOverride: boolean | null = null;
+/** Whether the terminal reads only ASCII (`localeReadsUtf8`); undefined until first asked. */
+let asciiLocale: boolean | undefined;
 /** Output is being rendered for a file (`renderForFile`), which has no terminal width. */
 let renderingForFile = false;
 
@@ -143,6 +151,23 @@ export function cliPlainEnabled(): boolean {
   return plainOverride === true;
 }
 
+/** Tests say whether the terminal reads only ASCII; null asks the environment again. */
+export function setCliAsciiLocaleOverride(value: boolean | null): void {
+  asciiLocale = value ?? undefined;
+}
+
+/**
+ * Plain output to a terminal that cannot show UTF-8 (a C locale, a Windows
+ * code page such as 437): it is written in ASCII (`asciiText`), so a dash, a
+ * euro or a cent sign does not print as `—`. Output rendered for a file
+ * keeps its UTF-8.
+ */
+export function cliAsciiEnabled(): boolean {
+  if (plainOverride !== true || renderingForFile) return false;
+  asciiLocale ??= !localeReadsUtf8();
+  return asciiLocale;
+}
+
 /**
  * Whether output is plain without `--plain` or `--no-plain`: NO_COLOR is set
  * to a value (an empty one is unset, as the convention says), or stdout is
@@ -185,14 +210,20 @@ export function plainWords(text: string): string {
 }
 
 /** A table header's sort mark in words: `MKT VAL ▼` is "MKT VAL (sorted descending)". */
-function plainHeader(header: string): string {
+function plainHeader(header: string, ascii: boolean): string {
   const sorted = header.replace(/\s*([▲▼])\s*$/, (_match, mark: string) => ` (sorted ${mark === "▲" ? "ascending" : "descending"})`);
-  return plainWords(sorted.trimStart());
+  const worded = plainWords(sorted.trimStart());
+  return ascii ? asciiText(worded) : worded;
 }
 
-/** A plain table's cell: arrows in words, and "—" for no value. */
-function plainCell(cell: string): string {
-  return EMPTY_CELL.test(stripAnsi(cell).trim()) ? PLAIN_EMPTY_CELL : plainWords(cell);
+/**
+ * A plain table's cell: arrows in words, and "—" for no value. In ASCII
+ * (`cliAsciiEnabled`) before the columns are measured, so `EUR211.25` lines
+ * up as `€211.25` did.
+ */
+function plainCell(cell: string, ascii: boolean): string {
+  const plain = EMPTY_CELL.test(stripAnsi(cell).trim()) ? PLAIN_EMPTY_CELL : plainWords(cell);
+  return ascii ? asciiText(plain) : plain;
 }
 
 function applyAnsi(text: string, code: string): string {
@@ -217,11 +248,24 @@ export function setCliWidthOverride(value: number | null): void {
 /** Columns the output is fitted to: `--width`, else the terminal's, or null when output is piped or redirected. */
 export function cliTerminalWidth(): number | null {
   if (widthOverride != null) return widthOverride;
-  if (renderingForFile || !process.stdout.isTTY) return null;
+  if (renderingForFile) return null;
+  if (!process.stdout.isTTY) return columnsVariable();
   const columns = process.stdout.columns;
   return typeof columns === "number" && columns > 0 ? columns : null;
 }
 
+/**
+ * `COLUMNS=60 gloom ... | less`: piped output is fitted to the width the
+ * variable sets, as `--width` does, so a screen reader or a pager gets the
+ * same narrow layout a terminal does. Unset or not a width, output stays whole.
+ */
+function columnsVariable(): number | null {
+  const value = process.env.COLUMNS?.trim();
+  if (!value || !/^\d+$/.test(value)) return null;
+  const columns = Number(value);
+  return columns >= MIN_COLUMNS_VARIABLE && columns <= MAX_COLUMNS_VARIABLE ? columns : null;
+}
+
 function padDisplay(text: string, width: number, align: CliAlign = "left"): string {
   const padding = Math.max(0, width - visibleLength(text));
   if (padding === 0) return text;
@@ -263,7 +307,8 @@ export function truncateDisplay(text: string, width: number): string {
 
 /**
  * Word-wraps text to `width` cells. Lines that already fit are kept verbatim, so aligned
- * columns survive; continuation lines keep the paragraph's leading indent.
+ * columns survive; continuation lines keep the paragraph's leading indent, and words on one
+ * line keep the spaces between them (a heading's `  ·  `).
  */
 export function wrapText(text: string, width: number): string[] {
   const lines: string[] = [];
@@ -273,7 +318,13 @@ export function wrapText(text: string, width: number): string[] {
       continue;
     }
     const indent = /^ */.exec(paragraph)![0];
-    const words = paragraph.slice(indent.length).split(/ +/).filter(Boolean);
+    // Each word with the spaces before it, which a line break drops. A separator (`·`) ends its line, never starts one.
+    const words: { gap: string; word: string }[] = [];
+    for (const [, gap, word] of paragraph.slice(indent.length).matchAll(/( *)([^ ]+)/g)) {
+      const last = words.at(-1);
+      if (last && word === "·") last.word += `${gap}${word}`;
+      else words.push({ gap: gap!, word: word! });
+    }
     if (words.length === 0) {
       lines.push("");
       continue;
@@ -281,16 +332,16 @@ export function wrapText(text: string, width: number): string[] {
     let line = indent;
     let lineWidth = indent.length;
     let lineHasWord = false;
-    for (const word of words) {
+    for (const { gap, word } of words) {
       const wordWidth = visibleLength(word);
-      if (lineHasWord && lineWidth + 1 + wordWidth > width) {
+      if (lineHasWord && lineWidth + gap.length + wordWidth > width) {
         lines.push(line);
         line = indent;
         lineWidth = indent.length;
         lineHasWord = false;
       }
-      line += lineHasWord ? ` ${word}` : word;
-      lineWidth += (lineHasWord ? 1 : 0) + wordWidth;
+      line += lineHasWord ? `${gap}${word}` : word;
+      lineWidth += (lineHasWord ? gap.length : 0) + wordWidth;
       lineHasWord = true;
     }
     lines.push(line);
@@ -512,6 +563,22 @@ function wrapCell(text: string, width: number): string[] {
   });
 }
 
+/**
+ * The columns that say what a row is: the leading ones up to the first figure
+ * after a word (`#`, Coin and Name before Price; Symbol and Name before Last).
+ */
+function rowIdentityColumns(columns: readonly CliTableColumn[]): Set<number> {
+  const identity = new Set<number>();
+  let named = false;
+  for (const [index, column] of columns.entries()) {
+    const figure = column.align === "right";
+    if (figure && named) break;
+    identity.add(index);
+    named ||= !figure;
+  }
+  return identity;
+}
+
 interface TableLayout {
   kept: TableEntry[];
   stacked: TableEntry[];
@@ -532,13 +599,18 @@ function movesSooner(left: readonly number[], right: readonly number[]): boolean
  * (a name, a title) before dates and figures, then rightmost first. The
  * first column stays. The list ends at the first layout that keeps every
  * column it shows whole on one line: moving more only adds lines.
+ *
+ * Plain output (`--plain`, read aloud by a screen reader) keeps the columns
+ * that say what a row is on its first line, after only the ones too wide to
+ * sit there: a row is heard as "BTC Bitcoin" before its figures.
  */
-function tableLayouts(entries: TableEntry[], available: number): TableLayout[] {
+function tableLayouts(entries: TableEntry[], available: number, identity: ReadonlySet<number> = new Set()): TableLayout[] {
   const fit = (kept: TableEntry[]) => fitColumnWidths(kept.map((entry) => entry.width), kept.map((entry) => entry.floor), available);
   const first = entries[0]!;
   const room = available - first.floor - COLUMN_GAP;
   const order = (entry: TableEntry) => [
     entry.floor > room ? 1 : 0,
+    identity.has(entry.index) ? 0 : 1,
     entry.column.stackPriority ?? 0,
     entry.text && entry.width > SOFT_MIN_COLUMN_WIDTH ? 1 : 0,
     entry.index,
@@ -601,7 +673,7 @@ function renderTableLayout(
   const belowIndent = `${indent}${" ".repeat(COLUMN_GAP)}`;
   const belowWidth = Math.max(1, (available ?? 0) - COLUMN_GAP);
   const renderBelow = (index: number) => (options.below?.[index] ?? []).flatMap((line) => (
-    available == null ? [line] : wrapText(line, belowWidth)
+    available == null ? [line] : options.cutBelow ? [truncateDisplay(line, belowWidth)] : wrapText(line, belowWidth)
   )).map((line) => `${belowIndent}${cliStyles.muted(line)}`.trimEnd());
   // Columns moved under the rows print there as `Header value`, as many to a line as fit.
   const renderStacked = (cells: string[], rowIndex: number): string[] => {
@@ -645,9 +717,10 @@ function renderTableLayout(
  */
 export function renderTable(columns: CliTableColumn[], rows: string[][], options: CliTableOptions = {}): string {
   if (cliPlainEnabled()) {
-    columns = columns.map((column) => ({ ...column, header: plainHeader(column.header) }));
-    rows = rows.map((row) => columns.map((_, index) => plainCell(row[index] ?? "")));
-    if (options.below) options = { ...options, below: options.below.map((lines) => lines?.map(plainWords)) };
+    const ascii = cliAsciiEnabled();
+    columns = columns.map((column) => ({ ...column, header: plainHeader(column.header, ascii) }));
+    rows = rows.map((row) => columns.map((_, index) => plainCell(row[index] ?? "", ascii)));
+    if (options.below) options = { ...options, below: options.below.map((lines) => lines?.map((line) => ascii ? asciiText(plainWords(line)) : plainWords(line))) };
   }
   const maxWidth = options.maxWidth === undefined ? cliTerminalWidth() : options.maxWidth;
   const available = maxWidth == null ? null : maxWidth - (options.indent ?? 0);
@@ -674,7 +747,7 @@ export function renderTable(columns: CliTableColumn[], rows: string[][], options
   });
   let best = "";
   let bestLines = Infinity;
-  for (const layout of tableLayouts(entries, available)) {
+  for (const layout of tableLayouts(entries, available, cliPlainEnabled() ? rowIdentityColumns(columns) : undefined)) {
     const stacked = layout.stacked.filter((entry) => entry.column.stackRows !== 0).sort((left, right) => left.index - right.index);
     const text = renderTableLayout(columns, rows, options, layout.kept, stacked, available, true);
     const lines = text.split("\n").length;

package/src/utils/concurrency.ts

@@ -23,3 +23,27 @@ export function chunked<T>(items: readonly T[], size: number): T[][] {
   for (let index = 0; index < items.length; index += size) chunks.push(items.slice(index, index + size));
   return chunks;
 }
+
+/**
+ * One gate that every caller shares: at most `limit` tasks run at once, and
+ * the rest wait in the order they came. Unlike mapWithConcurrency, separate
+ * callers (two panes, a pane and a report) count against the same limit. A
+ * finished task hands its slot straight to the next waiting one, so a caller
+ * arriving in between never takes it.
+ */
+export function createConcurrencyLimiter(limit: number): <T>(task: () => Promise<T>) => Promise<T> {
+  const slots = Math.max(1, Math.floor(limit));
+  let active = 0;
+  const waiting: Array<() => void> = [];
+  return async (task) => {
+    if (active < slots) active += 1;
+    else await new Promise<void>((resolve) => waiting.push(resolve));
+    try {
+      return await task();
+    } finally {
+      const next = waiting.shift();
+      if (next) next();
+      else active -= 1;
+    }
+  };
+}

package/src/utils/exchanges.ts

@@ -93,6 +93,12 @@ export function isKnownExchangeCode(value?: string): boolean {
   return !!normalized && KNOWN_EXCHANGE_CODES.has(normalized);
 }
 
+/** "Warsaw Stock Exchange" for a venue with a name, the canonical code otherwise (NASDAQ, whose name is its code). */
+export function exchangeName(value?: string): string {
+  const code = canonicalExchange(value);
+  return EXCHANGE_NAMES[code] ?? code;
+}
+
 /** "Euronext Paris (EPA)" for a venue with a name, the canonical code otherwise. */
 export function exchangeLabel(value?: string): string {
   const code = canonicalExchange(value);