@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/cli/pane-functions/headless.ts

@@ -1,9 +1,10 @@
 import { getSharedRegistry } from "../../plugins/registry";
+import { seriesExpression, seriesNamedBy } from "../../series/registry";
 import { findCachedPortfolioAccount } from "../../plugins/builtin/portfolio-list/cached-account";
-import { parsePublicTickerKey } from "../../utils/exchanges";
 import { findNamedCollection } from "../../portfolio/collection-name";
 import { readBareListing } from "../listing-arg";
 import { apiClient } from "../../api-client";
+import { resolveSavedInstrument } from "../../tickers/saved-instrument";
 import type { MarketContext } from "../types";
 import type {
   HeadlessArgumentExpansion,
@@ -190,7 +191,7 @@ async function loadHeadlessPaneModel(
   return result;
 }
 
-type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities" | "findCatalogSeries">> & {
+type HeadlessMarketContext = Pick<MarketContext, "config" | "store" | "refresh" | "resolveBroker"> & Partial<Pick<MarketContext, "persistence" | "seriesCapabilities" | "findCatalogSeries" | "findCatalogSeriesNamed">> & {
   dataProvider: HeadlessPaneContext["marketData"];
 };
 
@@ -210,6 +211,11 @@ export function createHeadlessPaneContext(
     capabilities: getSharedRegistry() ?? context.seriesCapabilities,
     catalogSeriesName: (expression) => (getSharedRegistry()?.series.findByExpression(expression)?.definition
       ?? context.findCatalogSeries?.(expression))?.name,
+    catalogSeriesNamed: (word) => {
+      const registered = getSharedRegistry()?.series?.list().map(({ definition }) => definition) ?? [];
+      const definition = seriesNamedBy(registered, word) ?? context.findCatalogSeriesNamed?.(word);
+      return definition ? { expression: seriesExpression(definition), name: definition.name } : undefined;
+    },
     resolveBroker: context.resolveBroker,
     async resolvePortfolio(id) {
       const portfolio = findNamedCollection(context.config.portfolios, id);
@@ -222,25 +228,21 @@ export function createHeadlessPaneContext(
       if (!watchlist) return null;
       return (await context.store.loadAllTickers()).filter(row => row.metadata.watchlists.includes(watchlist.id));
     },
-    async resolveInstrument(key) {
-      const parsed = parsePublicTickerKey(key);
-      const ticker = await context.store.loadTicker(key)
-        ?? (key !== parsed.symbol ? await context.store.loadTicker(parsed.symbol) : null);
-      return { symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange };
-    },
+    resolveInstrument: (key) => resolveSavedInstrument(key, (saved) => context.store.loadTicker(saved)),
     readDeviceState: <T,>(pluginId: string, key: string) =>
       context.persistence?.pluginState.get<T>(pluginId, resumeStateKey(key))?.value ?? null,
     async resolveListing(symbol, argumentWith) {
       const command = `fn ${resolved.token}`;
       const read = await readBareListing(symbol, context, {
         command, noun: "a quote", retry: (key) => `gloom ${command} ${argumentWith(key)}`,
-      }, { refresh: !!context.refresh });
+      }, { refresh: !!context.refresh, successor: true });
       if (!read) return null;
       return {
         symbol: read.symbol,
         ...read.exchange ? { exchange: read.exchange } : {},
         ...read.name ? { name: read.name } : {},
         ...read.coinNote ? { coinNote: read.coinNote } : {},
+        ...read.successorNote ? { successorNote: read.successorNote } : {},
       };
     },
   };
@@ -544,12 +546,17 @@ function renderRows(
       stackPriority: column.stackPriority,
       stackRows: column.stackRows,
       minTableWidth: column.minTableWidth,
+      optional: column.optional,
+      dropPriority: column.dropPriority,
     })),
     rows.map((row) => columns.map((column) => cell(row, column))),
     {
-      below: under.length === 0 ? undefined : rows.map((row) => under.flatMap((column) => (
-        row[column.key] == null || row[column.key] === "" ? [] : cell(row, column).split("\n")
-      ))),
+      // A value the text leaves out (a summary that only repeats the headline) takes no line.
+      below: under.length === 0 ? undefined : rows.map((row) => under.flatMap((column) => {
+        const text = row[column.key] == null || row[column.key] === "" ? "" : cell(row, column);
+        return text === "" ? [] : text.split("\n");
+      })),
+      ...(under.length > 0 && under.every((column) => column.underRow === "line") ? { cutBelow: true } : {}),
     },
   );
 }
@@ -571,7 +578,7 @@ function renderBundle(
   return result.sections.filter((section) => !isLockedSection(section)).flatMap((section, index) => [
     ...(index > 0 ? [""] : []),
     // A section with no title is its rows, or its empty message, alone.
-    ...(section.title ? [renderSection(section.title)] : []),
+    ...(section.title ? [renderSection(section.textTitle ?? section.title)] : []),
     "rows" in section && section.rows
       ? renderRows(section.textRows ?? section.rows, section.textColumns ?? section.columns, definition.columns, section.empty)
       : renderEntries(section.textEntries ?? section.entries),
@@ -898,7 +905,8 @@ export function renderHeadlessPaneText(
 ): string {
   // A long title wraps to a narrow --width like the text under a table; each line stays bold.
   const lines = [...wrapToTerminal(reportTitle(definition, args, result, fallbackTitle)).split("\n").map(cliStyles.bold), ""];
-  const notices = textNotices(result);
+  // A notice wraps to a narrow --width, as the notes and errors under the tables do.
+  const notices = textNotices(result).map((notice) => wrapToTerminal(notice));
   if (notices.length) lines.push(...notices, "");
   const gate = reportGate(definition, result);
   const reason = emptyReportReason(definition, result, args, token, gate);

package/src/cli/pane-functions/index.ts

@@ -46,6 +46,7 @@ import { checkOutputPath, resolveOutputPath, writeOutputFile } from "../output-f
 import type { CatalogCommandHit } from "../unknown-command";
 import { CLI_EXIT_CODES } from "../exit-codes";
 import { shotOptionRefusal } from "./shot-options";
+import { listingChangeLine } from "../../tickers/listing-fate";
 import {
   GLOSSARY,
   glossaryRecord,
@@ -312,7 +313,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       let quoted: ReturnType<typeof loadListingQuoteAnswer> | null = null;
       const quoteAnswer = listing ? () => quoted ??= loadListingQuoteAnswer(context.dataProvider, listing) : null;
       const fate = listing && quoteAnswer && isTickerLinkPeer(resolved.instance, registry.panes)
-        ? listingFateLoader(listing, context, quoteAnswer().then((answer) => answer.quote))
+        ? listingFateLoader(listing, context, quoteAnswer().then((answer) => answer.quote), { successor: true })
         : null;
       const moved = { command: "fn", retry: (key: string) => `gloom fn ${resolved.token} ${key}` };
       // A report that fails or comes back empty for an exchange the symbol is not listed on says so.
@@ -356,7 +357,10 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       const data = glossary
         ? { ...report.data, glossary: glossary.map(({ term, short, definition }) => ({ term, ...(short ? { short } : {}), definition })) }
         : report.data;
-      const warnings = [...parsed.listingNotes ?? [], ...await choice ?? [], ...report.data.warnings ?? []];
+      // What became of the company that had the symbol (GOGL), as `quote` says it, leads.
+      const successor = fate ? listingChangeLine(await fate()) : null;
+      // A note the listing and the report both make (a coin's code charted as a fund) is said once.
+      const warnings = [...new Set([...successor ? [successor] : [], ...parsed.listingNotes ?? [], ...await choice ?? [], ...report.data.warnings ?? []])];
       // A report with no data is printed as it is, and fails: exit 1, and `ok: false` in JSON with the reason.
       const failure = reportFailure(report.data, ["fn", resolved.token, parsed.arg.trim()].filter(Boolean).join(" "), {
         failsWithoutData: resolved.headless?.failsWithoutData, tables: report.tables });

package/src/cli/pane-functions/options.ts

@@ -1,4 +1,4 @@
-import type { HeadlessPaneDefinition, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
+import type { HeadlessPaneDefinition, PaneDef, PaneTemplateCreateOptions, PaneTemplateDef } from "../../types/plugin";
 import { parseTickerListInput } from "../../tickers/list";
 import { normalizeTickerInput } from "../../tickers/search";
 import { resolveFinancialPeriodOption } from "../../plugins/builtin/ticker-detail/financials/model";
@@ -85,12 +85,16 @@ export function cleanTickerInput(value: string): string {
 /**
  * Whether a function's argument names the ticker its pane shows. Its report
  * says first: AUCT's `10Y` and IPO's `pending` are free text its own resolver
- * reads, never a symbol to look up. Without a report, the shortcut says.
+ * reads, never a symbol to look up. Without a report, a rendered pane whose
+ * argument is an id it opens (the story pane's story id) says so, then the
+ * shortcut.
  */
 export function argumentNamesTicker(
   template: Pick<PaneTemplateDef, "shortcut"> | undefined,
   headless: Pick<HeadlessPaneDefinition, "argument"> | undefined,
+  pane?: Pick<PaneDef, "reportArgument">,
 ): boolean {
+  if (!headless && pane?.reportArgument?.identifier) return false;
   const kind = headless?.argument.kind;
   if (kind === "free-text" || kind === "none") return false;
   return kind === "tickers" || kind === "symbol-list" || template?.shortcut?.argKind !== "text";

package/src/cli/pane-functions/resolver.ts

@@ -11,7 +11,7 @@ import { applyChartComposerCapabilityOptions } from "../../plugins/builtin/chart
 import { parseChartSpec } from "../../plugins/builtin/chart-composer/chart-spec";
 import { normalizeTickerInput } from "../../tickers/search";
 import { slugifyName } from "../../utils/slugify";
-import { ListingArgError, listingInstrument, listingReadNotes, resolveCliListing, usListingsOnlyMessage } from "../listing-arg";
+import { listCoinNotes, ListingArgError, listingInstrument, listingReadNotes, resolveCliListing, usListingsOnlyMessage } from "../listing-arg";
 import { uncoveredInstrumentKind, uncoveredInstrumentMessage } from "../../tickers/instrument-coverage";
 import { uncoveredInstrumentCommand } from "../uncovered-instrument";
 import { listingAbroadVenue } from "../../utils/sec";
@@ -83,7 +83,7 @@ async function buildPaneInstance(
   // Free text is a phrase, not a symbol. Treating it as a ticker makes the
   // pane look for a provider for values such as "HIGH GROWTH SOFTWARE".
   const headlessArgKind = resolved.headless?.argument.kind;
-  const fallbackSymbol = !argumentNamesTicker(resolved.template, resolved.headless)
+  const fallbackSymbol = !argumentNamesTicker(resolved.template, resolved.headless, resolved.pane)
     ? null
     : headlessArgKind === "tickers" || headlessArgKind === "symbol-list"
       ? normalizeTickerInput(null, cleanTickerInput(target.split(/[,\s]+/)[0] ?? ""))
@@ -254,8 +254,9 @@ export async function applyListingArgument(
     }
     notes.push(...answers.map((answer) => `${answer.message} ${answer.details.replaceAll("\n", " ")}`));
   }
-  // One listing's notes come with its choice note; a list's are said here.
-  if (listings.length > 1) notes.unshift(...listings.flatMap(listingReadNotes));
+  // One listing's notes come with its choice note; a list's are said here, with a coin's code read as a listing
+  // (CORR RIOT,BTC: BTC is the Grayscale fund) as `quote BTC` says it.
+  if (listings.length > 1) notes.unshift(...listings.flatMap(listingReadNotes), ...await listCoinNotes(listings, context));
   return {
     ...args,
     arg: listings.map((listing) => listing.key).join(", "),
@@ -349,8 +350,8 @@ export async function resolvePaneFunction(
   if (!pane) {
     throw new Error(`Template "${template?.id}" points at missing pane "${template?.paneId}".`);
   }
-  const createOptions = buildCreateOptions(template, args.arg);
   const headless = getHeadlessPaneDefinition(template, pane);
+  const createOptions = withTickerList(template, buildCreateOptions(template, args.arg), headless, args.arg, paneFunctionCode(template, pane));
   const capability = getPaneFunctionCapability(template, pane);
   let tableSection: string | true | undefined;
   if (resolutionSettings.tableSection) {
@@ -400,6 +401,27 @@ export async function resolvePaneFunction(
   return resolved;
 }
 
+/**
+ * A one-ticker template whose pane also opens on a list (`opensTickerList`:
+ * DVD's ranking): the list is passed as `symbols`, so `shot` draws the same
+ * tickers `fn` reads, in one pane, and fetches each; past the most the
+ * function's report takes, it is refused as `fn` refuses it. One ticker, and
+ * any other template, stays as it was.
+ */
+export function withTickerList(
+  template: PaneTemplateDef | undefined,
+  createOptions: PaneTemplateCreateOptions | undefined,
+  headless: HeadlessPaneDefinition | undefined,
+  arg: string,
+  token = template?.shortcut?.prefix ?? "",
+): PaneTemplateCreateOptions | undefined {
+  if (!template?.opensTickerList || !createOptions || createOptions.symbols?.length) return createOptions;
+  const symbols = [...new Set(arg.split(/[,\s]+/).map((word) => cleanTickerInput(word)).filter(Boolean))];
+  if (symbols.length < 2) return createOptions;
+  if (headless) validateSymbolCount(headless, token, symbols, "shot");
+  return { ...createOptions, symbol: symbols[0]!, arg: symbols.join(","), symbols };
+}
+
 function validateTickerCardinality(
   capability: PaneFunctionCapability,
   createOptions: PaneTemplateCreateOptions | undefined,

package/src/cli/pane-functions/screenshot-assessment.ts

@@ -208,6 +208,39 @@ export function filledKeyValueCount(rows: DesktopPaneShotRenderResult["visibleKe
   }).length;
 }
 
+/**
+ * Whether a capture shows nothing that was loaded: a wall that needs an
+ * account, or an empty, loading or failed state, with no rows, labeled values
+ * or plotted chart beside it. Its footer carries no status line then, as it
+ * has no data to date: the quotes the capture loaded for its symbol are not on
+ * screen. A pane that only locks or fails part of what it shows keeps it.
+ */
+export function shotLoadedNothing(
+  render: Pick<DesktopPaneShotRenderResult, "accessGate" | "emptyStateDetected" | "loadingStateDetected" | "errorStateDetected" | "rows" | "visibleKeyValues" | "semanticUi">,
+): boolean {
+  const stated = !!render.accessGate || render.emptyStateDetected || render.loadingStateDetected || render.errorStateDetected;
+  return stated
+    && render.rows.length === 0
+    && filledKeyValueCount(render.visibleKeyValues) === 0
+    && !render.semanticUi.some(plotsData);
+}
+
+/**
+ * A pane's chart evidence node that says it plotted something: a count of
+ * plotted values, or series with points. A node that is neither (a shape this
+ * does not know) counts as plotted, so its pane keeps its line.
+ */
+function plotsData(node: RemoteUiNodeSnapshot): boolean {
+  if (node.role !== "chart-data") return false;
+  const metadata = node.metadata;
+  if (!isRecord(metadata)) return true;
+  const counts = [metadata.plottedValueCount, metadata.projectedPointCount].filter((count): count is number => typeof count === "number");
+  if (counts.length > 0) return counts.some((count) => count > 0);
+  const lists = [metadata.series, metadata.baseSeries, metadata.resolvedSeries].filter(Array.isArray);
+  if (lists.length === 0) return true;
+  return lists.some((list) => list.some((series) => isRecord(series) && typeof series.pointCount === "number" && series.pointCount > 0));
+}
+
 /**
  * A 3D surface that is not the real drawing: the frame has no mesh, or the 2D
  * grid stands in for it. Both are fine for a person using the pane and wrong

package/src/cli/pane-functions/screenshot-bridge.ts

@@ -1,14 +1,20 @@
+import { lookup } from "dns/promises";
+import { isIP } from "net";
 import { fetchTape } from "../../plugins/builtin/time-sales/client";
 import {
+  encodeResponseBody,
   readRequestInit,
-  toResponseEnvelope,
+  toResponseHead,
   type HttpProxyRequestEnvelope,
   type HttpProxyResponseEnvelope,
 } from "../../utils/http-proxy-response";
+import { fetchCheckingRedirects, readBytesWithin } from "../../utils/http-proxy-upstream";
+import { isPublicAddress } from "../../utils/public-address";
 import type { DesktopPaneShotApiProxy, DesktopPaneShotBridge } from "../desktop-pane-shot";
 import type { MarketContext } from "../types";
 import { resolvePersistedCloudSessionToken } from "./cloud-session";
 import { getCloudApiBaseUrl } from "../../api-client/request";
+import { fetchShotHttpAddress } from "./screenshot-http";
 
 const CREDENTIAL_FIELD_NAMES = new Set([
   "accesstoken",
@@ -98,10 +104,27 @@ const SHOT_BRIDGE_MARKET_OPERATIONS = new Set([
 ]);
 
 const SHOT_BRIDGE_HTTP_TIMEOUT_MS = 20_000;
+/** Feeds and API answers are far smaller; the answer goes to the page whole, as JSON. */
+const SHOT_BRIDGE_HTTP_MAX_BYTES = 25 * 1024 * 1024;
+/** What panes send through `httpFetch` while they draw: reads, and the POST a few APIs take a query as. */
+const SHOT_BRIDGE_HTTP_METHODS = new Set(["GET", "HEAD", "POST"]);
+
+/** The addresses a host name resolves to. */
+type ResolveHost = (hostname: string) => Promise<string[]>;
+
+const resolveHost: ResolveHost = async (hostname) => (
+  await lookup(hostname, { all: true, verbatim: true })
+).map((entry) => entry.address);
+
+interface ShotHttpOptions {
+  resolveHost?: ResolveHost;
+  fetch?: typeof fetch;
+}
 
 export function createDesktopShotBridge(
   context: Pick<MarketContext, "dataProvider">,
   tapeBootstrap: typeof fetchTape = fetchTape,
+  httpOptions: ShotHttpOptions = {},
 ): DesktopPaneShotBridge {
   return {
     async marketData(operation, args) {
@@ -123,30 +146,88 @@ export function createDesktopShotBridge(
         args,
       );
     },
-    httpFetch: (request) => runDesktopShotHttpFetch(request),
+    httpFetch: (request) => runDesktopShotHttpFetch(request, httpOptions),
   };
 }
 
+/**
+ * Whether the page may reach `raw`: http or https on a host whose every
+ * address is on the public internet. Panes read public APIs and news feeds;
+ * nothing they draw lives on this machine or its network, and a URL that
+ * names one (or a host that resolves to one) is refused.
+ */
+async function checkShotHttpTarget(
+  raw: string,
+  resolve: ResolveHost,
+): Promise<{ url: URL; address: string } | { error: string; status: number }> {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    // Intentional ignore: a URL that does not parse is answered as an invalid target, never fetched.
+    return { error: "The target URL is not valid.", status: 400 };
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    return { error: `Screenshot HTTP bridge refuses ${url.protocol} requests.`, status: 400 };
+  }
+  if (url.username || url.password) return { error: "Credentials in the URL are not allowed.", status: 400 };
+  const host = url.hostname.replace(/^\[|\]$/g, "").replace(/\.$/, "").toLowerCase();
+  const refused = { error: `Screenshot HTTP bridge refuses ${url.hostname}: it is not on the public internet.`, status: 403 };
+  if (host === "localhost" || host.endsWith(".localhost")) return refused;
+  let addresses: string[];
+  try {
+    addresses = isIP(host) ? [host] : await resolve(host);
+  } catch {
+    return { error: `Could not resolve ${url.hostname}.`, status: 502 };
+  }
+  if (addresses.length === 0) return { error: `Could not resolve ${url.hostname}.`, status: 502 };
+  if (!addresses.every(isPublicAddress)) return refused;
+  const address = addresses.find((candidate) => isIP(candidate) === 4) ?? addresses[0]!;
+  return { url, address };
+}
+
 /**
  * Panes such as DVD fetch a third-party API directly. A browser cannot: the
  * request is cross-origin and dies in CORS, so the pane reported that the
  * ticker pays no dividend. The desktop renderer already proxies these through
- * its native half; the screenshot page gets the same treatment.
+ * its native half; the screenshot page gets the same treatment, limited to
+ * public hosts, each redirect checked like the first URL.
  */
 async function runDesktopShotHttpFetch(
   request: HttpProxyRequestEnvelope,
+  options: ShotHttpOptions,
 ): Promise<HttpProxyResponseEnvelope> {
-  const target = new URL(request.url);
-  if (target.protocol !== "http:" && target.protocol !== "https:") {
-    throw new Error(`Screenshot HTTP bridge refuses ${target.protocol} requests.`);
+  const resolve = options.resolveHost ?? resolveHost;
+  const addresses = new Map<string, string>();
+  const checkTarget = async (raw: string) => {
+    const checked = await checkShotHttpTarget(raw, resolve);
+    if ("url" in checked) addresses.set(checked.url.href, checked.address);
+    return checked;
+  };
+  const target = await checkTarget(typeof request?.url === "string" ? request.url : "");
+  if ("error" in target) throw new Error(target.error);
+  const init = readRequestInit(request.init);
+  if (!SHOT_BRIDGE_HTTP_METHODS.has(init.method)) {
+    throw new Error(`Screenshot HTTP bridge refuses ${init.method} requests.`);
   }
-  const { method, headers, body, redirect } = readRequestInit(request.init);
-  const response = await fetch(target, {
-    method,
-    headers,
-    body,
-    redirect,
+  const result = await fetchCheckingRedirects(target.url, init, {
+    fetch: options.fetch ?? (async (input, init) => {
+      const url = new URL(String(input));
+      const address = addresses.get(url.href);
+      if (!address) throw new Error("The screenshot target has not been checked.");
+      return fetchShotHttpAddress(url, init ?? {}, address);
+    }) as typeof fetch,
+    check: checkTarget,
     signal: AbortSignal.timeout(SHOT_BRIDGE_HTTP_TIMEOUT_MS),
   });
-  return toResponseEnvelope(response);
+  if ("error" in result) throw new Error(result.error);
+  const { response } = result;
+  const tooLarge = `The response from ${target.url.hostname} is larger than ${SHOT_BRIDGE_HTTP_MAX_BYTES / (1024 * 1024)} MB.`;
+  if (init.method !== "HEAD" && Number(response.headers.get("content-length") ?? 0) > SHOT_BRIDGE_HTTP_MAX_BYTES) {
+    await response.body?.cancel().catch(() => { /* Intentional ignore: an answer over the cap is dropped unread. */ });
+    throw new Error(tooLarge);
+  }
+  const body = await readBytesWithin(response.body, SHOT_BRIDGE_HTTP_MAX_BYTES);
+  if (body === null) throw new Error(tooLarge);
+  return { ...toResponseHead(response), ...encodeResponseBody(body) };
 }

package/src/cli/pane-functions/screenshot-http.ts

@@ -0,0 +1,70 @@
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+import { Readable } from "node:stream";
+import { checkServerIdentity } from "node:tls";
+import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+
+/**
+ * A single HTTP hop to an address already checked by the screenshot bridge.
+ * The socket uses that address directly, while Host and TLS keep the URL's
+ * name. A fresh connection keeps another request's DNS result out of the hop.
+ */
+export function fetchShotHttpAddress(url: URL, init: RequestInit, address: string): Promise<Response> {
+  if (!isIP(address)) return Promise.reject(new Error("The screenshot address must be an IP address."));
+  const headers = new Headers(init.headers);
+  headers.set("host", url.host);
+  headers.set("accept-encoding", "gzip, deflate, br");
+  if (!headers.has("accept")) headers.set("accept", "*/*");
+  if (!headers.has("user-agent")) headers.set("user-agent", `Bun/${Bun.version}`);
+  if (typeof init.body === "string" && !headers.has("content-type")) headers.set("content-type", "text/plain;charset=UTF-8");
+  const requestHeaders: Record<string, string> = {};
+  headers.forEach((value, name) => { requestHeaders[name] = value; });
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  return new Promise((resolve, reject) => {
+    const request = (url.protocol === "https:" ? httpsRequest : httpRequest)(url, {
+      hostname: address,
+      method: init.method,
+      headers: requestHeaders,
+      agent: false,
+      signal: init.signal ?? undefined,
+      ...(url.protocol === "https:" ? {
+        servername: isIP(hostname) ? "" : hostname,
+        checkServerIdentity: (_name: string, certificate: Parameters<typeof checkServerIdentity>[1]) => checkServerIdentity(hostname, certificate),
+      } : {}),
+    }, (incoming) => {
+      try {
+        const responseHeaders = new Headers();
+        for (let index = 0; index < incoming.rawHeaders.length; index += 2) {
+          responseHeaders.append(incoming.rawHeaders[index]!, incoming.rawHeaders[index + 1]!);
+        }
+        const status = incoming.statusCode ?? 502;
+        if (init.method === "HEAD" || status === 204 || status === 205 || status === 304) {
+          incoming.resume();
+          resolve(new Response(null, { status, statusText: incoming.statusMessage, headers: responseHeaders }));
+          return;
+        }
+        const encoding = responseHeaders.get("content-encoding")?.toLowerCase();
+        const decoder = encoding === "gzip" ? createGunzip()
+          : encoding === "deflate" ? createInflate()
+          : encoding === "br" ? createBrotliDecompress() : null;
+        if (decoder) {
+          responseHeaders.delete("content-encoding");
+          responseHeaders.delete("content-length");
+          incoming.on("error", (error) => decoder.destroy(error));
+          decoder.once("close", () => incoming.destroy());
+        }
+        const stream = decoder ? incoming.pipe(decoder) : incoming;
+        resolve(new Response(Readable.toWeb(stream) as unknown as ReadableStream<Uint8Array>, {
+          status, statusText: incoming.statusMessage, headers: responseHeaders,
+        }));
+      } catch (error) {
+        incoming.destroy();
+        reject(error);
+      }
+    });
+    request.once("error", reject);
+    if (init.body !== undefined && init.body !== null) request.write(init.body);
+    request.end();
+  });
+}

package/src/cli/pane-functions/screenshot-render.ts

@@ -1,8 +1,7 @@
 import { logFailure } from "../../utils/log-failure";
 import { apiClient } from "../../api-client";
 import { loadResolvedHeadlessPaneModel, reportCoverage, reportGaps, type LoadedHeadlessPaneModel } from "./headless";
-import { dirname } from "path";
-import { mkdir } from "fs/promises";
+import { createOutputFolder } from "../output-file";
 import type { Quote } from "../../types/financials";
 import { isRecord } from "../../utils/guards";
 import {
@@ -28,7 +27,18 @@ import { quotesFreshness } from "../freshness";
 import { paneFitsRows, shotMaxHeightCells, buildDesktopShotPayload } from "./screenshot-payload";
 import { resolveDesktopShotApiProxy, createDesktopShotBridge } from "./screenshot-bridge";
 import type { PaneScreenshotResult } from "./screenshot-types";
-import { assessPaneScreenshot } from "./screenshot-assessment";
+import { assessPaneScreenshot, shotLoadedNothing } from "./screenshot-assessment";
+
+/**
+ * Whether a capture's footer keeps a row for the dated status line. A pane of
+ * the user's own state (notes, connections, documentation) declares `local`:
+ * it has no data to date, and "not a live feed" would be said of its own
+ * state. A capture that loaded nothing gives the row back later
+ * (`shotLoadedNothing`).
+ */
+export function shotHasStatusLine(resolved: Pick<ResolvedPaneFunction, "pane" | "template">): boolean {
+  return !declaredReportFreshness(resolved).local;
+}
 
 /** The bridge, keeping every quote it serves the page: what a pane that loads its own quotes (WEI) shows. */
 function recordBridgedQuotes(bridge: DesktopPaneShotBridge): { bridge: DesktopPaneShotBridge; quotes: Quote[] } {
@@ -241,7 +251,7 @@ export async function renderDesktopShot({
    */
   onStalledReport?: () => void;
 }): Promise<PaneScreenshotResult> {
-  if (captureImage) await mkdir(dirname(outputPath), { recursive: true });
+  if (captureImage) await createOutputFolder(outputPath);
   const apiProxy = resolveDesktopShotApiProxy(context);
   const previousSessionToken = apiClient.getSessionToken();
   let payload: DesktopPaneShotPayload;
@@ -277,7 +287,7 @@ export async function renderDesktopShot({
       watermark ?? null,
       loadModel,
     );
-    if (statusLine && captureImage) payload.statusLine = true;
+    if (statusLine && captureImage && shotHasStatusLine(resolved)) payload.statusLine = true;
     const fitRoles = [
       ...(fitRows && paneFitsRows(resolved) ? ["data-table-body-scroll"] : []),
       ...(fitReader && resolved.pane.shotFitsReader ? ["detail-scroll-body"] : []),
@@ -296,6 +306,10 @@ export async function renderDesktopShot({
       captureImage,
       bridge: recorded.bridge,
       statusLine: async (rendered) => {
+        if (shotLoadedNothing(rendered)) {
+          abandonReports();
+          return null;
+        }
         const tab = report && shownReportTab(resolved, rendered.semanticUi);
         const shown = tab ? reportShotFreshness(resolved, () => loadReport({ ...resolved, options: { ...resolved.options, tab } })) : report;
         const line = shotFreshness(resolved, shotPayload, rendered, recorded.quotes, shown && await settledWithin(shown, SHOT_REPORT_WAIT_MS));

package/src/cli/quote-answer.ts

@@ -2,6 +2,7 @@ import type { QuoteBatchResult } from "../types/data-provider";
 import type { Quote } from "../types/financials";
 import { bareListingNote } from "../tickers/listing-fate";
 import { notATickerSymbol } from "../sources/provider-errors";
+import { listingSuffixCandidate } from "../sources/listing-symbols";
 import { looksLikeCurrencyPair } from "../utils/currency-pair";
 import { canonicalExchange } from "../utils/exchanges";
 import type { CliCommandDef } from "../types/plugin";
@@ -21,6 +22,8 @@ import {
   notTradedMessage,
   oneWordCompanyName,
   quoteBareListing,
+  serviceNamedCompany,
+  type ListingArg,
   requireCliListing,
   resolveCliListing,
   tradingBoardNote,
@@ -64,7 +67,9 @@ export interface QuoteAnswer {
 /**
  * One symbol's row of `quote` and `compare`. A listing on an exchange its symbol
  * is not listed on says so. A bare symbol the data service read on its home
- * listing abroad names that venue (SXR8 -> XETRA). One no source quotes is
+ * listing abroad names that venue (SXR8 -> XETRA). One no source quotes that
+ * the service marks as another listing's company name is that company
+ * (`serviceNamedCompany`: "siemens" is SIE:XETRA); else it is
  * quoted on its listings (`quoteBareListing`), else names them, or asks for an
  * exchange when several companies list it (2222); a bare index root (VIX) also
  * names its index (^VIX), and a futures board code a security keeps (GC) its
@@ -98,6 +103,13 @@ export async function answerQuote(
   const notTraded = await notTradedMessage(listing, market);
   if (notTraded) return { result, listing, failure: { message: notTraded, oneLine: notTraded }, notes: [] };
   if (!isNoProviderError(result.error)) return { result, listing, notes: [] };
+  // HCI.L is HCI on LSE written with a vendor's suffix: one that does not trade there says so as HCI:LSE does.
+  const suffixed = await notTradedOnSuffixVenue(listing, market);
+  if (suffixed) return { result, listing, failure: { message: suffixed, oneLine: suffixed }, notes: [] };
+  // A word the service marks as a company's name is that company, before the symbol is read on its listings abroad.
+  const named = !listing.exchange && listing.typed ? await serviceNamedCompany(listing.typed, market) : null;
+  const meant = named ? await answerNamedListing(named, market, request, refresh, datesChangeBasis) : null;
+  if (meant) return meant;
   const other = await quoteBareListing(listing, market, request, { refresh, datesChangeBasis });
   if (other?.kind === "quoted") {
     return {
@@ -129,6 +141,22 @@ export async function answerQuote(
   return { result, listing, failure: { message, details, oneLine }, notes: [] };
 }
 
+/**
+ * "HCI does not trade on LSE. HCI trades on: NYSE, IEX, JSE." for a symbol
+ * written with a venue's suffix (HCI.L) that no source quotes, when its base
+ * symbol trades elsewhere and not on the venue the suffix names: the answer
+ * `HCI:LSE` gets. Only for London's `.L` and suffixes of two letters or more
+ * (`.IS`, `.JO`): another one-letter suffix is as likely a US share class
+ * (MKC.V, BRK.B) and keeps its own answer. Null otherwise.
+ */
+async function notTradedOnSuffixVenue(listing: CliListing, market: MarketContext): Promise<string | null> {
+  if (listing.exchange) return null;
+  const suffix = listing.symbol.slice(listing.symbol.lastIndexOf(".") + 1);
+  if (!listing.symbol.includes(".") || (suffix.length < 2 && suffix.toUpperCase() !== "L")) return null;
+  const venue = listingSuffixCandidate(listing.symbol);
+  return venue ? notTradedMessage(venue, market) : null;
+}
+
 /**
  * A company's name typed as one word (`Apple`) that the source says is not a
  * ticker, answered as the listing search names for it with the line saying so
@@ -155,17 +183,32 @@ async function answerCompanyName(
   const named = await oneWordCompanyName(listing.typed, market);
   // A real ticker a source failed to quote is not a company's name, even when the company carries the word.
   if (!named || (unsettled && named.symbol.toUpperCase() === listing.symbol.toUpperCase())) return null;
-  // A listing on a venue the app cannot read is no answer: the word keeps its own "Not a ticker".
+  const answer = await answerNamedListing(named, market, request, refresh, datesChangeBasis);
+  if (answer) return answer;
+  if (!unsettled) return null;
+  const sentence = await notATickerWords(listing.typed, market);
+  return { result: { ...result, error: new Error(sentence) }, listing, notes: [] };
+}
+
+/**
+ * The row of the listing a company's name was read as (`named`), saying so;
+ * null when the app cannot read its venue or it has no quote.
+ */
+async function answerNamedListing(
+  named: ListingArg,
+  market: MarketContext,
+  request: ListingDataRequest,
+  refresh: boolean,
+  datesChangeBasis: boolean,
+): Promise<QuoteAnswer | null> {
+  // A listing on a venue the app cannot read is no answer: the word keeps its own.
   const resolved = await resolveCliListing(named.key, null, market).catch((error: unknown) => {
     if (error instanceof ListingArgError) return null;
     throw error;
   });
   const found = resolved ? { ...resolved, readAs: named.readAs, ...named.meant ? { meant: named.meant } : {}, ...named.readFromName ? { readFromName: named.readFromName } : {} } : null;
   const [quoted] = found ? await market.dataProvider.getQuotesBatch([found.request], { forceRefresh: refresh, revalidate: true, datesChangeBasis }) : [];
-  if (found && quoted?.quote) return answerQuote(quoted, found, market, request, refresh, null, { datesChangeBasis });
-  if (!unsettled) return null;
-  const sentence = await notATickerWords(listing.typed, market);
-  return { result: { ...result, error: new Error(sentence) }, listing, notes: [] };
+  return found && quoted?.quote ? answerQuote(quoted, found, market, request, refresh, null, { datesChangeBasis }) : null;
 }
 
 /** A listing a command found a quote for, with what `quote` says beside it. */