gloomberb 0.17.6 → 0.18.0

package/src/time-series/price-comparison.ts

@@ -3,6 +3,7 @@ import { getTimeSeriesField } from "./field-catalog";
 import type { ChartSpec, ResolvedSeries, TimeSeriesPoint } from "./types";
 import type { ManualChartResolution } from "./resolution";
 import { zonedDateTimeParts } from "../utils/zoned-date-time";
+import { barLastSession } from "../market-data/market/bar-period";
 
 const PRICE_COMPARISON_BASIS = "Price returns in each listing's currency; cash distributions and FX conversion excluded.";
 
@@ -102,6 +103,10 @@ export function resolvePriceComparison(
     seriesIds, start: null, end: null,
     notice: `${PRICE_COMPARISON_BASIS} Comparison unavailable: need two shared dates and a nonzero baseline.`,
   };
+  // A weekly or monthly bar's close is from the last session of its period, which the notice dates it by.
+  const period = resolution === "1wk" ? "week" : resolution === "1mo" ? "month" : null;
+  const venue = byId.get(seriesIds[0]!)?.timeBasis?.exchange || byId.get(seriesIds[0]!)?.listing?.exchange || undefined;
+  const sessionDay = (key: string) => (period ? barLastSession(key, period, venue, Date.now()) : null) ?? key;
   const sourceBounds = Object.fromEntries(seriesIds.map((id, index) => [id, {
     start: observations[index]!.get(start)!.date.getTime(),
     end: observations[index]!.get(end)!.date.getTime(),
@@ -113,7 +118,7 @@ export function resolvePriceComparison(
     alignment: calendarBars ? "session-date" : "timestamp",
     sourceBounds,
     notice: calendarBars
-      ? `${PRICE_COMPARISON_BASIS} Shared calendar dates: ${start} to ${end}; market session times may differ.`
+      ? `${PRICE_COMPARISON_BASIS} Shared calendar dates: ${sessionDay(start)} to ${sessionDay(end)}; market session times may differ.`
       : `${PRICE_COMPARISON_BASIS} Shared observations: ${displayDate(Number(start))} to ${displayDate(Number(end))}.`,
   };
 }

package/src/time-series/resolve.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../utils/log-failure";
 import { resolveAssetDisplayKind } from "../market-data/market/format";
 import { hasValidQuoteObservationTime } from "../market-data/quotes/freshness";
 import { SnapshotHistoryUnavailableError } from "../market-data/snapshot-provider";
@@ -45,6 +46,7 @@ import {
 } from "./field-catalog";
 import {
   fundamentalSeriesUsesAvailabilityFallback,
+  unreportedStatementPeriod,
   valuationCurrencyWarning,
   valuationPriceIssues,
   valuationSeriesUsesLiveQuote,
@@ -76,6 +78,7 @@ import {
 import {
   canonicalExchange,
   isUsListingExchange,
+  parsePublicTickerKey,
   publicTickerKey,
   resolveExchangeTimeZone,
 } from "../utils/exchanges";
@@ -86,6 +89,7 @@ import { latestSessionStart, latestTradingSessionOpen, listingTimeZone, priorSes
 import { futuresGenericCaption, futuresGenericListing, futuresListingPriceBasis } from "../utils/futures-generic";
 import { classifyInstrumentType, kindFromListingSyntax } from "../tickers/instrument-kind";
 import { contractPriceUnit } from "./price-units";
+import { INDEX_POINTS_UNIT, isIndexLevel } from "../market-data/market/index-level";
 import { isDatasetChart, isOhlcSeriesStyle } from "./spec";
 import { SERIES_COLORS } from "../theme/series-colors";
 import type {
@@ -1177,6 +1181,7 @@ function baseSecuritySeries(
   const field = getTimeSeriesField(spec.source.fieldId);
   if (!field) return null;
   const points = extractSecuritySeries(financials, spec.source);
+  const unreportedPeriod = points.length === 0 ? unreportedStatementPeriod(financials, spec.source) : null;
   const symbol = instrumentLabel(spec.source);
   const statementCurrency = field.id.startsWith("fundamental.") && field.unit.startsWith("currency")
     ? reportingCurrencySeries(points, financials.financialCurrency) : null;
@@ -1197,7 +1202,10 @@ function baseSecuritySeries(
   // future's continuous symbol or contract in points, not dollars, as its quote does.
   const genericBasis = field.unitGroup === "price" && isMarketFieldId(field.id)
     ? futuresListingPriceBasis(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
-  const genericUnit = genericBasis === "points" ? "points" : genericBasis === "thirty-seconds" ? "32nds" : null;
+  // An index's level is points too, never the currency its members trade in.
+  const indexLevel = field.unitGroup === "price" && isMarketFieldId(field.id)
+    && isIndexLevel(financials.quote?.instrumentType || quoteMetadata?.instrumentType);
+  const genericUnit = genericBasis === "points" || indexLevel ? INDEX_POINTS_UNIT : genericBasis === "thirty-seconds" ? "32nds" : null;
   // A future's price in a currency counts what its contract terms say: heating
   // oil is USD / gallon and crude USD / barrel, which a bare USD does not tell apart.
   const statedUnit = !genericUnit && unitTemplate === "currency" ? contractPriceUnit(contractUnit, currency) : null;
@@ -1241,6 +1249,7 @@ function baseSecuritySeries(
       ? "Volume unit unknown." : statementCurrency?.warning ?? valuationCurrencyWarning(financials, spec.source),
     nativeFrequency: marketField ? marketSeriesFrequency(spec.source, marketResolution)
       : spec.source.period && spec.source.period !== "auto" ? spec.source.period : field.nativeFrequency,
+    ...(unreportedPeriod ? { unreportedPeriod } : {}),
     ...(marketField ? { historyResolution: marketResolution } : {}),
     timestampMode: spec.source.timestampMode,
     dataShape: field.dataShape,
@@ -1375,6 +1384,39 @@ function assignAxes(
   });
 }
 
+/**
+ * A series drawn in a ticker's price (a moving average of it, a band around
+ * it) takes the units of that ticker's price series when the chart has it, so
+ * the two share an axis and the line sits on the price instead of on a scale
+ * of its own.
+ */
+function adoptPriceUnits(series: ResolvedSeries[], specs: readonly ChartSeriesSpec[]): ResolvedSeries[] {
+  if (!series.some((entry) => entry.priceOf)) return series;
+  const specsById = new Map(specs.map((spec) => [spec.id, spec]));
+  const prices = series.filter((entry) => {
+    const source = specsById.get(entry.id)?.source;
+    return source?.kind === "security" && getTimeSeriesField(source.fieldId)?.unitGroup === "price"
+      && entry.transform === "raw";
+  });
+  if (prices.length === 0) return series;
+  return series.map((entry) => {
+    if (!entry.priceOf) return entry;
+    const wanted = parsePublicTickerKey(entry.priceOf.toUpperCase());
+    const key = publicTickerKey(wanted.symbol, wanted.exchange);
+    const named = (price: ResolvedSeries) => {
+      const source = specsById.get(price.id)?.source;
+      if (source?.kind !== "security") return false;
+      return publicTickerKey(source.instrument.symbol, source.instrument.exchange) === key
+        || (!wanted.exchange && source.instrument.symbol.toUpperCase() === wanted.symbol);
+    };
+    const price = prices.find((candidate) => named(candidate) && candidate.panelId === entry.panelId)
+      ?? prices.find(named);
+    return price && entry.transform === "raw"
+      ? { ...entry, unit: price.unit, unitGroup: price.unitGroup }
+      : entry;
+  });
+}
+
 function prepareBaseSeriesForStudies(
   series: ResolvedSeries,
   bounds: DateBounds,
@@ -1612,7 +1654,11 @@ async function resolveChartSpecPass(
           if (statementHistory && (!value.statementHistory || value.statementHistory.status === "retryable-failure")) cache.financialsByInstrument.delete(key);
           return value;
         })
-        .catch(() => { cache.financialsByInstrument.delete(key); return null; });
+        .catch((error) => {
+          logFailure("time-series-resolve", "Loading chart financials failed")(error);
+          cache.financialsByInstrument.delete(key);
+          return null;
+        });
       cache.financialsByInstrument.set(key, pending);
       cache.revision += 1;
     }
@@ -1628,7 +1674,11 @@ async function resolveChartSpecPass(
         : provider.getQuote(source.instrument.symbol, source.instrument.exchange ?? "", requestContext(source)).then(quoteMetadataFromQuote))
         .then((metadata) => metadata && quoteMetadataMatchesTarget(metadata, source.instrument.symbol, source.instrument.exchange) ? metadata : null)
         .then((metadata) => { if (!metadata) cache.quoteMetadataByInstrument.delete(key); return metadata; })
-        .catch(() => { cache.quoteMetadataByInstrument.delete(key); return null; });
+        .catch((error) => {
+          logFailure("time-series-resolve", "Loading chart quote metadata failed")(error);
+          cache.quoteMetadataByInstrument.delete(key);
+          return null;
+        });
       cache.quoteMetadataByInstrument.set(key, pending);
       cache.revision += 1;
     }
@@ -1671,7 +1721,7 @@ async function resolveChartSpecPass(
         // preset in charge, the same as a source without the capability.
         pending = Promise.resolve(result)
           .then((value) => normalizeChartResolutionSupport(value))
-          .catch(() => [] as ChartResolutionSupport[]);
+          .catch(logFailure("time-series-resolve", "Could not load chart resolution support", [] as ChartResolutionSupport[]));
         const settledPending = pending;
         settledPending.then((settled) => {
           if (cache.resolutionSupportByInstrument.get(key) !== settledPending) return;
@@ -1976,7 +2026,7 @@ async function resolveChartSpecPass(
     const key = symbol.trim().toUpperCase();
     let pending = cache.futuresPriceUnits.get(key);
     if (!pending) {
-      pending = sources.loadFuturesPriceUnit(key).catch(() => null).then((unit) => {
+      pending = sources.loadFuturesPriceUnit(key).catch(logFailure("time-series-resolve", "Could not load futures price unit", null)).then((unit) => {
         // Terms that did not say are asked again on a later pass, when the source allows.
         if (unit === null) cache.futuresPriceUnits.delete(key);
         else cache.revision += 1;
@@ -2250,7 +2300,7 @@ async function resolveChartSpecPass(
     errors.push(...studyResult.errors);
   }
 
-  const bufferedSeries = assignAxes(resolved, [...spec.series, ...spec.studies], warnings)
+  const bufferedSeries = assignAxes(adoptPriceUnits(resolved, spec.series), [...spec.series, ...spec.studies], warnings)
     .map((entry) => clipPriceComparison(entry, priceComparison));
   resolved = bufferedSeries.map((entry) => {
     const entryBounds = presentationBounds(entry, spec.studies, priceComparison, bounds);
@@ -2297,8 +2347,10 @@ async function resolveChartSpecPass(
   ];
   for (const entry of resolved) {
     if (entry.warning) warnings.push(`${entry.label}: ${entry.warning}`);
-    // A currency mismatch already explains an empty valuation series.
-    if (entry.points.length === 0 && !entry.warning?.startsWith(VALUATION_CURRENCY_WARNING_PREFIX)) {
+    if (entry.points.length === 0 && entry.unreportedPeriod) {
+      warnings.push(`${entry.label}: no ${entry.unreportedPeriod} figures are reported; annual figures are available.`);
+    } else if (entry.points.length === 0 && !entry.warning?.startsWith(VALUATION_CURRENCY_WARNING_PREFIX)) {
+      // A currency mismatch already explains an empty valuation series.
       warnings.push(`${entry.label}: no observations in the selected date range.`);
     }
   }
@@ -2385,7 +2437,10 @@ export function reconcileChartTail(
   }
   const run: Promise<boolean> = Promise.all([...cache.liveTails].map(async ([key, tail]) => {
     const pending = cache.priceHistoryByRequest.get(key);
-    const loaded = pending ? await pending.catch(() => null) : null;
+    const loaded = pending ? await pending.catch(() => {
+      // Intentional ignore: resolveChartSpecPass already includes this history failure in the series errors.
+      return null;
+    }) : null;
     if (!pending || !loaded || loaded.resolution !== tail.resolution) return false;
     const accumulated = cache.accumulatedPriceHistory.get(tail.accumulationKey);
     const latest = latestObservationTime(accumulated?.points ?? loaded.points);
@@ -2406,7 +2461,7 @@ export function reconcileChartTail(
     if (!request) {
       const fetched = fetchHistoryResult(provider, symbol, exchange ?? "",
         { kind: "detail", start: new Date(start), end: new Date(end), interval: tail.resolution }, context)
-        .catch(() => null)
+        .catch(logFailure("time-series-resolve", "Could not reconcile chart history", null))
         .finally(() => {
           if (shared.get(requestKey) === fetched) shared.delete(requestKey);
         });

package/src/time-series/spec.ts

@@ -36,7 +36,8 @@ import { recordOrNull } from "../utils/guards";
 const RANGE_SET = new Set<TimeRange>(TIME_RANGES);
 const RESOLUTIONS = new Set<ChartResolution>(CHART_RESOLUTIONS);
 const PERIODS = new Set<SeriesPeriod>(["auto", "daily", "weekly", "monthly", "quarterly", "annual", "ttm"]);
-const STYLES = new Set<SeriesStyle>(["line", "area", "step", "columns", "points", "candles", "ohlc", "hlc"]);
+// `band` only stays on a capability series: a field's styles and an economic series' leave it out.
+const STYLES = new Set<SeriesStyle>(["line", "area", "step", "columns", "points", "candles", "ohlc", "hlc", "band"]);
 const ECONOMIC_STYLES = new Set<SeriesStyle>(["line", "area", "step", "columns", "points"]);
 const TRANSFORMS = new Set<SeriesTransform>(["raw", "percent", "index100", "yoy", "qoq", "log"]);
 const AXES = new Set<SeriesAxis>(["auto", "left", "right"]);

package/src/time-series/studies.ts

@@ -377,9 +377,9 @@ function resolveMacd(spec: ChartStudySpec, input: ResolvedSeries, color: string)
 }
 
 function resolveVolume(spec: ChartStudySpec, input: ResolvedSeries, color: string, nameInput: boolean): ResolvedSeries[] {
-  // Spot FX and similar quotes report 0 for every bar: there is no volume to
-  // plot, so the study adds no panel rather than an empty one.
-  if (input.points.some((point) => point.volume === 0) && input.points.every((point) => !point.volume)) return [];
+  // No bar has volume to plot (spot FX quotes 0 for every bar; a coin's window
+  // can miss every bar's), so the study adds no panel rather than an empty one.
+  if (input.points.length > 0 && !input.points.some((point) => isFiniteNumber(point.volume) && point.volume !== 0)) return [];
   const points = [...input.points]
     .sort((left, right) => left.date.getTime() - right.date.getTime())
     .flatMap((point) => isFiniteNumber(point.volume)

package/src/time-series/types.ts

@@ -122,6 +122,12 @@ export interface TimeSeriesPoint {
   close?: number | null;
   volume?: number | null;
   periodLabel?: string;
+  /**
+   * A financial statement period as the FA columns name it: `FY2025`, `Q3 FY26`,
+   * `TTM Q3 FY26`, or the period's end date off the issuer's fiscal calendar.
+   * The legend prints it beside the value.
+   */
+  fiscalPeriod?: string;
   provenance?: {
     priceHistoryIntegrity?: import("../utils/price-history-integrity").PriceHistoryIntegrity;
     valuationPriceIssues?: import("./valuation-price").ValuationPriceIssue[];
@@ -169,6 +175,11 @@ export interface ResolvedSeries {
   /** Volume basis established by the source instrument; omitted when unspecified. */
   volumeUnit?: "shares" | "contracts";
   nativeFrequency: SeriesPeriod;
+  /**
+   * Set on a series with nothing to draw because its company reports no
+   * figures of the period asked for, while its annual ones exist.
+   */
+  unreportedPeriod?: "quarterly";
   /** Acquired market-history cadence; null is explicitly unknown, undefined is legacy or nonmarket. */
   historyResolution?: ManualChartResolution | null;
   /**
@@ -203,11 +214,22 @@ export interface ResolvedSeries {
   points: TimeSeriesPoint[];
   /** Who a report of a loaded series cites, when its loader names the dataset and publisher. */
   attribution?: SeriesAttribution;
+  /**
+   * The ticker whose price the values are in, such as a moving average of it:
+   * the chart draws the series on that price's axis when it shows the price.
+   */
+  priceOf?: string;
   /** Rejected valuation price inputs, retained independently of usable observations. */
   valuationPriceIssues?: import("./valuation-price").ValuationPriceIssue[];
   warning?: string;
   /** Listed in the legend so it can be restored, but not drawn. */
   hidden?: boolean;
+  /**
+   * A layer of a stacked area (`stackedSeries`): a band from the layers below
+   * to its own top, each point's `value` the top and `rawValue` the layer's own
+   * amount, which the legend shows.
+   */
+  stacked?: boolean;
   /** Columns below zero take this colour instead, so a change reads by its sign. */
   negativeColor?: string;
   /**

package/src/time-series/use-chart-resolution.ts

@@ -1,3 +1,4 @@
+import { logFailure } from "../utils/log-failure";
 import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import {
   ChartResolveCache,
@@ -401,7 +402,7 @@ export function useChartResolution(
       if (disposed || quoteActivityAt <= lastReconcileAt) return;
       lastReconcileAt = Date.now();
       const changed = await reconcileChartTail(latestRequestRef.current.sources, resolveCacheRef.current)
-        .catch(() => false);
+        .catch(logFailure("time-series-use-chart-resolution", "Could not reconcile live chart", false));
       if (disposed) return;
       if (!changed) {
         // A window that settles nothing, or that this history cannot take, is not asked for again at once.

package/src/types/config.ts

@@ -299,6 +299,12 @@ export interface AppConfig {
   recentTickers: string[];
   /** Pane templates recently run from the command bar, newest first. */
   recentCommands: RecentCommand[];
+  /**
+   * How many times the empty command bar has opened, counted to one past its
+   * introduction (see `command-bar-intro.ts`). A new config starts at 0; one
+   * from an earlier build has none and reads as past it. Kept on this machine only.
+   */
+  commandBarOpens?: number;
   language?: LanguagePreference;
   onboardingComplete?: boolean;
   /** App version at the last launch, used to show release notes after an update. */
@@ -995,6 +1001,7 @@ export function createDefaultConfig(dataDir: string): AppConfig {
     fontSize: 12,
     recentTickers: [],
     recentCommands: [],
+    commandBarOpens: 0,
   };
 }
 

package/src/types/data-provider.ts

@@ -45,6 +45,13 @@ export interface SecFilingItem {
   companyName?: string;
   filingUrl: string;
   primaryDocumentUrl?: string;
+  /**
+   * The SEC file number EDGAR lists the filing under for this company, empty
+   * when it lists none: a 13D/13G about the company carries its 005- number,
+   * one it filed as a holder of another company none. Absent when the source
+   * does not say (an older server).
+   */
+  fileNumber?: string;
 }
 
 export interface SecFilingDocument {
@@ -235,6 +242,19 @@ export interface AssetDataProvider {
    * META), or what its holder was called before. Null when none is on record.
    */
   getTickerChanges?(symbol: string, options?: { signal?: AbortSignal }): Promise<TickerChanges | null>;
+  /**
+   * `getTickerChanges` for several symbols in a few requests, by symbol as
+   * asked: null for one with no change on record. A symbol the source could not
+   * answer for is left out; null when the source cannot answer a batch at all.
+   */
+  getTickerChangesBatch?(symbols: string[], options?: { signal?: AbortSignal }): Promise<Map<string, TickerChanges | null> | null>;
+  /**
+   * Several searches in a few requests, each answered with the rows `search`
+   * gives it from this source (up to `limit`), by query as asked. A query the
+   * source could not search is left out; null when it cannot search a batch at
+   * all, or when another source (a connected broker) adds rows of its own.
+   */
+  searchBatch?(queries: string[], options?: { limit?: number; signal?: AbortSignal }): Promise<Map<string, InstrumentSearchResult[]> | null>;
   getEarningsCalendar?(symbols: string[], context?: MarketDataRequestContext): Promise<EarningsEvent[]>;
   getSecFilingDocuments?(filing: SecFilingItem): Promise<SecFilingDocument[]>;
   getSecFilingContent?(filing: SecFilingItem): Promise<string | null>;

package/src/types/headless.ts

@@ -26,6 +26,12 @@ export interface HeadlessPaneArgumentDef {
   minimum?: number;
   /** Maximum item count for ticker and symbol list arguments. */
   maximum?: number;
+  /**
+   * Arguments as typed after the function (`GAS`, `EUA`), which the catalog
+   * shows as examples: for an argument that takes forms its placeholder does
+   * not name.
+   */
+  examples?: readonly string[];
 }
 
 export interface HeadlessPaneOptionValue {
@@ -33,6 +39,7 @@ export interface HeadlessPaneOptionValue {
   aliases?: string[];
 }
 
+
 /**
  * Declarative option schema shared by headless panes and the pane function CLI.
  * `settingKey` and `pluginState` keep existing screenshot state wiring compatible.
@@ -51,10 +58,21 @@ export interface HeadlessPaneOptionDef {
     pluginId: string;
     key?: string;
   };
-  /** The value's name in the catalog's flag, `--expiration <YYYY-MM-DD|unix>`; the type when absent. */
+  /**
+   * Set when the pane does not draw the option and only the report reads it
+   * (`--limit`'s rows of text): `shot` refuses it rather than capture the
+   * pane without it; `reportOnly` says what the report does with it, for
+   * the refusal (`sets how many rows the report lists`). Left out, the pane
+   * draws it, through `settingKey`, `pluginState`, a setting of the option's
+   * own key, or `shotState`.
+   */
+  shot?: { reportOnly: string };
+  /** The value's name in the catalog's flag, `--expiration <date|unix>`; the type when absent. */
   placeholder?: string;
   /** The option in use as typed after the function, such as `--expiration 2028-01-21`; the catalog shows it as an example. */
   example?: string;
+  /** The example runs without the function's optional argument, as an option that works only then does (`fn INS --side sell`). */
+  exampleWithoutArgument?: boolean;
   /**
    * Checks a typed value and returns it as the pane reads it, in place of the
    * type's own check; throws an Error that names what is wrong.
@@ -96,6 +114,14 @@ export interface HeadlessPaneContext {
   resolveWatchlist?: (id: string) => Promise<import("./ticker").TickerRecord[] | null>;
   /** Resolve locally remembered exchange identities without coupling plugins to storage. */
   resolveInstrument?: (symbol: string) => Promise<{ symbol: string; exchange?: string }>;
+  /**
+   * Read a bare symbol as `quote` reads it: the listing its quote is for and
+   * that listing's company, or null when nothing better than the symbol is
+   * known. A code several companies list (BDI) throws asking which, with
+   * `quote`'s message; `argumentWith(key)` is the function's argument naming
+   * that listing instead (`BDI:TSX`), for the retry each listing offers.
+   */
+  resolveListing?: (symbol: string, argumentWith: (key: string) => string) => Promise<{ symbol: string; exchange?: string; name?: string } | null>;
 }
 
 export type HeadlessPaneRow = Record<string, unknown>;
@@ -254,6 +280,13 @@ export interface HeadlessPaneFreshness {
    * never a market's session. Rows that are quotes keep the market line.
    */
   dataset?: boolean;
+  /**
+   * The rows are a listing's price bars, which its quote carries on (`G AAPL`,
+   * `HP`). A screenshot dates them as it dates a quote board, by the quotes it
+   * shows with their delay and market. Any other report that declares a
+   * `status` ends its screenshot as it ends `fn`, whatever quotes the page loaded.
+   */
+  prices?: boolean;
   /**
    * What a dataset's newest observation is, when its every line names it:
    * `last trade` makes the `fn` footer, the pane footer and a screenshot read
@@ -282,6 +315,11 @@ export interface HeadlessPaneFreshness {
    * listing's Friday close and another's later print.
    */
   citeOldest?: boolean;
+  /**
+   * What the newest observation is, said before its time so the time is not read as when the report was read:
+   * `newest story` dates a news list `newest story Tue 29 Sep 2026 20:17 UTC`.
+   */
+  asOfLabel?: string;
   /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
   note?: string;
   /**
@@ -318,6 +356,17 @@ interface HeadlessPaneResultBase {
   freshness?: HeadlessPaneFreshness;
 }
 
+/** A table only `--csv` and `--ndjson` write, after the report's own rows. */
+export interface HeadlessExportTable {
+  title: string;
+  columns: HeadlessPaneColumn[];
+  rows: HeadlessPaneRow[];
+  /** The unit every figure is in, which each exported row names in `currency_or_unit`. */
+  unit?: string;
+  /** The interval the rows are at (`1d`), which each exported row names in `interval`. */
+  interval?: string;
+}
+
 export interface HeadlessRowsResult extends HeadlessPaneResultBase {
   columns?: HeadlessPaneColumn[];
   /**
@@ -327,8 +376,27 @@ export interface HeadlessRowsResult extends HeadlessPaneResultBase {
    */
   textColumns?: HeadlessPaneColumn[];
   rows: HeadlessPaneRow[];
+  /** The rows `textColumns` read, when the text report adds lines that are no record (the position under its lots); `rows` when absent. CSV, NDJSON and JSON keep `rows`. */
+  textRows?: HeadlessPaneRow[];
   /** What the report says when `rows` is empty, in place of "No data.": why there are none. */
   empty?: string;
+  /**
+   * The row fields naming each row's own unit, symbol and observation date
+   * (an ISO date or instant), for rows of several series dated apart: each
+   * exported row names them in `currency_or_unit`, `symbol_or_series` and
+   * `as_of`, as a bundle section's `rowUnitKey`, `rowSymbolKey` and `rowAsOfKey` do.
+   */
+  rowUnitKey?: string;
+  rowSymbolKey?: string;
+  rowAsOfKey?: string;
+  /** The interval every row is at (`daily`), which each exported row names in `interval`. */
+  interval?: string;
+  /**
+   * Tables `--csv` and `--ndjson` write after the rows, each in its own
+   * section, such as the dated history the rows sum up. The text report and
+   * JSON leave them out.
+   */
+  exportTables?: HeadlessExportTable[];
 }
 
 export type HeadlessBundleSection =
@@ -352,6 +420,35 @@ export type HeadlessBundleSection =
      * which every exported row names in `currency_or_unit`.
      */
     unit?: string;
+    /**
+     * The row field naming each row's own unit, for a table of metrics whose
+     * rows differ (`%`, a ratio, a count): each exported row names it in
+     * `currency_or_unit` in place of `unit`, blank when the field is empty.
+     */
+    rowUnitKey?: string;
+    /**
+     * The row field naming the symbol each row is of, for a table of several
+     * (a ranking): each exported row names it in `symbol_or_series`.
+     */
+    rowSymbolKey?: string;
+    /**
+     * The row field holding when each row's figures were observed (an ISO
+     * date or instant), for rows dated apart: each exported row names it in
+     * `as_of`, blank when the field is empty.
+     */
+    rowAsOfKey?: string;
+    /** The bar interval the rows are of (`1d`), which every exported row names in `interval`. */
+    interval?: string;
+    /** The symbol every row is of, where the report's own is not (a section per name): each exported row names it in `symbol_or_series`. */
+    symbol?: string;
+    /** When every row was observed (an ISO date or instant), where it is not the report's newest: each exported row names it in `as_of`. */
+    asOf?: string;
+    /**
+     * The free view holds this table back for Gloom Pro. Left empty, the text
+     * report leaves it out and says once, on its Pro line, what Pro adds, in
+     * place of a lock under each table; JSON keeps the section with `locked`.
+     */
+    locked?: boolean;
     entries?: never;
     textEntries?: never;
   }
@@ -365,15 +462,27 @@ export type HeadlessBundleSection =
      * JSON keep `entries`.
      */
     textEntries?: HeadlessPaneEntry[];
+    /** The symbol the figures are of, where the report's own is not: each exported line names it in `symbol_or_series`. */
+    symbol?: string;
+    /** When the figures were observed (an ISO date or instant), where it is not the report's newest: each exported line names it in `as_of`. */
+    asOf?: string;
     columns?: never;
     rows?: never;
     textColumns?: never;
     textRows?: never;
     unit?: never;
+    rowUnitKey?: never;
+    interval?: never;
+    locked?: never;
   };
 
 export interface HeadlessBundleResult extends HeadlessPaneResultBase {
   sections: HeadlessBundleSection[];
+  /**
+   * What the report says once when no section has a row, in place of each
+   * section's own `empty`: one reason covers them all (a ticker no source maps).
+   */
+  empty?: string;
 }
 
 export interface HeadlessSeriesPoint extends HeadlessPaneRow {
@@ -389,6 +498,8 @@ export interface HeadlessSeriesPoint extends HeadlessPaneRow {
 export interface HeadlessSeries {
   id: string;
   label: string;
+  /** The company or security a security's series is of (Apple Inc.), from its quote. */
+  name?: string;
   /** Explicit unit of the point values; report formatting does not rescale them. */
   unit?: string;
   /** The symbol or series ID the series was asked for as (`USDZAR=X`, `DEXSFUS`), which exports name each row by. */
@@ -462,8 +573,30 @@ export interface HeadlessPaneDefinition<Shape extends HeadlessPaneShape = Headle
     args: HeadlessPaneLoadArgs,
     ctx: HeadlessPaneContext,
   ): Promise<HeadlessArgumentExpansion | null>;
+  /**
+   * How `shot` opens the pane on a request, past the settings its options
+   * name: 13F opens the fund a name resolved to, on the tab its view names.
+   * `load` is the report's own load, for state that depends on what it found.
+   * `given` names the options typed, by key: `args` carries every option's
+   * default too, which the pane may open on differently (M&A of one company
+   * opens on every status, its report on pending), so state an option sets
+   * is written only when it was asked for.
+   * Throws when the pane cannot draw the request, which `shot` reports
+   * instead of capturing another view.
+   */
+  shotState?(
+    args: HeadlessPaneLoadArgs,
+    load: () => Promise<HeadlessPaneResultByShape[Shape]>,
+    given: ReadonlySet<string>,
+  ): HeadlessShotState | Promise<HeadlessShotState>;
   /** What is true of every load: its source, and whether it is a feed. */
   freshness?: HeadlessPaneFreshness;
+  /**
+   * A `--csv` export also closes with the report's warnings, as notes, for a
+   * report whose warnings say which rows it left out (a backtest's dropped
+   * sessions), so a saved file keeps what stderr said.
+   */
+  exportWarnings?: boolean;
   columns?: HeadlessPaneColumn[];
   /**
    * The report title. A report passes the loaded result, so a title can name
@@ -487,6 +620,14 @@ export interface HeadlessPaneDefinition<Shape extends HeadlessPaneShape = Headle
 
 export type HeadlessPaneResult = HeadlessPaneResultByShape[HeadlessPaneShape];
 
+/** What `shot` merges into the captured pane for a request (`shotState`). */
+export interface HeadlessShotState {
+  /** Merged into the pane's settings. */
+  settings?: Record<string, unknown>;
+  /** Merged into the pane's plugin state, by plugin id. */
+  pluginState?: Record<string, Record<string, unknown>>;
+}
+
 /** What a function runs with once it has widened its argument (`expandArgument`). */
 export interface HeadlessArgumentExpansion {
   /** The argument as it would be typed: `DUOL, COUR, CHGG`. */

package/src/types/instrument.ts

@@ -71,4 +71,10 @@ export interface InstrumentSearchResult {
    * Albemarle, which the lithium funds hold), sent by newer cloud servers on a
    * row a theme query added. Matched like the name, ranked after name matches. */
   searchKeywords?: string[];
+  /** The company that merged into this one whose old name the query is
+   * (Golden Ocean Group Ltd, GOGL until 2025-08-20, on CMB.Tech's CMBT), sent
+   * by newer cloud servers on a row such a query added. `searchAliases` then
+   * carries that name. A leftover listing of the merged company (GOGLC on
+   * BYMA) is linked to it by search, naming the `successor`. */
+  formerIssuer?: { symbol: string; name: string; until: string; successor?: { symbol: string; name: string | null } };
 }