gloomberb 0.18.2 → 0.18.3

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

@@ -5,6 +5,7 @@ import type {
 } from "../../../types/plugin";
 import { loadHolderSnapshot } from "./client";
 import { holderValueCurrency } from "./format";
+import { logFailure } from "../../../utils/log-failure";
 import type { HolderData } from "../../../types/financials";
 import { SEC_FILINGS } from "../shared/report-freshness";
 import type { BeneficialOwnersPayload } from "../../../api-client/beneficial-owners";
@@ -157,7 +158,7 @@ export function createHoldersHeadless(
         const [payload, snapshot] = await Promise.all([
           dependencies.loadBeneficialOwners(symbol, { form: beneficialRouteForm(form), history }, ctx),
           // The 13F column is a join; the 13D/13G rows stand without it.
-          dependencies.loadSnapshot(symbol, args, ctx).catch(() => null),
+          dependencies.loadSnapshot(symbol, args, ctx).catch(logFailure("holders.headless", "Load holder snapshot for filing comparison failed", null)),
         ]);
         const sharesOutstanding = snapshot?.sharesOutstanding ?? null;
         const rows = buildBeneficialReportRows(payload, {

package/src/plugins/builtin/holders/thirteenf-match.ts

@@ -2,6 +2,7 @@ import { listThirteenFForms, normalizeCik, searchThirteenFFunds } from "../thirt
 import { isoDateToday, isoDateYearsAgo } from "../../../utils/calendar-date";
 import { buildPeriodReports } from "../thirteenf/model";
 import type { HolderRow } from "./types";
+import { logFailure } from "../../../utils/log-failure";
 
 export interface Holder13FMatch {
   cik: string;
@@ -100,8 +101,9 @@ export async function loadHolder13FMatches(
           filedAsOfDate: form?.filedAsOfDate,
           tableValueTotal: report?.complete && forms.length < 100 ? report.tableValueTotal : null,
         });
-      } catch {
+      } catch (error) {
         // Matching 13F metadata is an enhancement; holder rows should remain usable.
+        if (!signal.aborted) logFailure("holders.thirteenf-match", "Match holder fund filings failed")(error);
       }
     }
   }

package/src/plugins/builtin/insider/base-values.ts

@@ -2,6 +2,7 @@ import type { HeadlessPaneColumn, HeadlessPaneRow } from "../../../types/headles
 import { fxCloseOnOrBefore, loadDailyFxCloses, type FxCloses, type FxHistoryClient } from "../../../market-data/fx-closes";
 import { logFailure } from "../../../utils/log-failure";
 import { formatCompact, formatNumber } from "../../../utils/format";
+import { quotedFxPair } from "../../../utils/currency-pair";
 
 /** A Form 4 states its prices and values in US dollars. */
 export const FORM4_CURRENCY = "USD";
@@ -21,8 +22,9 @@ const dash = (value: unknown, format: (value: number) => string) => (typeof valu
  * states them). With another base currency (CAD), each value is also given
  * in it at the daily close of USD/CAD on its transaction day, or the last
  * close before a weekend or holiday (`fxCloseOnOrBefore` over the history
- * PORT and PEB read), with the rate and that close's date beside it. When the
- * closes cannot be read the values stay in USD and the note says why.
+ * PORT and PEB read), with the rate and that close's date beside it. The rate
+ * reads as markets quote the pair (USD/CAD, EUR/USD), named by `fxPair`. When
+ * the closes cannot be read the values stay in USD and the note says why.
  */
 export async function withInsiderBaseValues(
   rows: readonly HeadlessPaneRow[],
@@ -33,7 +35,8 @@ export async function withInsiderBaseValues(
   const labelled: HeadlessPaneRow[] = rows.map((row) => ({ ...row, currency: FORM4_CURRENCY }));
   const base = baseCurrency.trim().toUpperCase();
   if (!base || base === FORM4_CURRENCY) return { rows: labelled, columns: null, note: null };
-  const pair = `${FORM4_CURRENCY}/${base}`;
+  // The pair as markets quote it: USD/CAD, but EUR/USD for a euro base.
+  const pair = quotedFxPair(FORM4_CURRENCY, base, 1).pair;
   const days = labelled.flatMap((row) => typeof row.transactionDate === "string" && typeof row.totalValue === "number"
     ? [row.transactionDate.slice(0, 10)] : []).sort();
   let closes: FxCloses | null = null;
@@ -47,13 +50,14 @@ export async function withInsiderBaseValues(
   const converted = labelled.map((row) => {
     const day = typeof row.transactionDate === "string" ? row.transactionDate.slice(0, 10) : null;
     const reading = closes && day && typeof row.totalValue === "number" ? fxCloseOnOrBefore(closes, day) : null;
-    // The close is USD per unit of the base currency; the rate is the base currency per dollar.
-    const fxRate = reading ? 1 / reading.rate : null;
+    // The close is USD per unit of the base currency: the base currency per dollar is its inverse.
+    const perDollar = reading ? 1 / reading.rate : null;
     return {
       ...row,
       baseCurrency: base,
-      valueBase: fxRate != null ? (row.totalValue as number) * fxRate : null,
-      fxRate,
+      valueBase: perDollar != null ? (row.totalValue as number) * perDollar : null,
+      fxPair: pair,
+      fxRate: perDollar != null ? quotedFxPair(FORM4_CURRENCY, base, perDollar).rate : null,
       fxDate: reading?.date ?? null,
     };
   });

package/src/plugins/builtin/insider/client.ts

@@ -7,6 +7,9 @@ import { filesAsForeignPrivateIssuer } from "./issuer";
 // this many filings or the company's history ends.
 const SEC_FILING_SCAN_LIMIT = 20_000;
 
+/** The company's own filings `fn INS` reads by default, and `insider` sums up as it does. */
+export const INSIDER_REPORT_FILINGS = 20;
+
 export interface InsiderFilingsLoad {
   /** The rows of the company's own Form 4 filings, newest first. */
   parsed: ParsedInsiderFiling[];

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

@@ -6,8 +6,8 @@ import type {
   HeadlessPaneRow,
 } from "../../../types/plugin";
 import { formatCompact, formatCurrency } from "../../../utils/format";
-import { loadParsedInsiderFilings, type InsiderFilingsLoad } from "./client";
-import { insiderEmptyNotice } from "./issuer";
+import { INSIDER_REPORT_FILINGS, loadParsedInsiderFilings, type InsiderFilingsLoad } from "./client";
+import { insiderEmptyNotice, loadHomeInsiderReportsNote } from "./issuer";
 import { FORM4_CURRENCY, withInsiderBaseValues } from "./base-values";
 import {
   buildInsiderRows,
@@ -21,7 +21,7 @@ import {
 import { isAmendedInsiderFiling, relevantInsiderAmendments } from "./amendments";
 import { formatInsiderName } from "./display";
 import { SEC_FILINGS } from "../shared/report-freshness";
-import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
+import { resolveHeadlessInstrument, resolveHeadlessIssuerListing } from "../shared/headless-market-data";
 import { noSecReportsNotice } from "../../../utils/sec";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
 import type { InsiderSignalRoleGroup, InsiderSignalSide, InsiderSignalsPayload } from "../../../api-client/insider-signals";
@@ -310,6 +310,20 @@ async function noSecReportsEmpty(ctx: HeadlessPaneContext, key: string): Promise
   return noSecReportsNotice({ symbol: parsePublicTickerKey(key).symbol, exchange: listing.exchange, name: listing.name ?? null });
 }
 
+/**
+ * What INS says for a company with no Form 4 of its own: why there is none,
+ * and for a company from abroad, that its home market's insider reports are
+ * not covered either ("Canadian insider reports (SEDI) not covered.").
+ */
+async function insiderEmpty(ctx: HeadlessPaneContext, key: string, foreignPrivateIssuer: boolean, noFilings: boolean): Promise<string> {
+  const [noReports, { exchange }] = await Promise.all([
+    noFilings ? noSecReportsEmpty(ctx, key) : null,
+    resolveHeadlessInstrument(ctx, key),
+  ]);
+  const home = await loadHomeInsiderReportsNote(ctx.marketData, key, exchange, foreignPrivateIssuer);
+  return noReports ? [noReports, home].filter(Boolean).join(" ") : insiderEmptyNotice(foreignPrivateIssuer, home);
+}
+
 export function createInsiderHeadless(
   dependencies: InsiderHeadlessDependencies = defaultDependencies,
 ): HeadlessPaneDefinition<"rows"> {
@@ -346,7 +360,7 @@ export function createInsiderHeadless(
         aliases: ["count", "rows"],
         description: "Maximum of the company's own Form 4 and Form 4/A filings to parse; without a ticker, companies to rank.",
         type: "integer",
-        defaultValue: 20,
+        defaultValue: INSIDER_REPORT_FILINGS,
         minimum: 1,
         maximum: 100,
       },
@@ -510,8 +524,7 @@ export function createInsiderHeadless(
       }
       const limit = Number(args.options.limit);
       const { parsed, foreignPrivateIssuer, noFilings } = await dependencies.loadParsed(symbol, limit, args, ctx);
-      const empty = parsed.length > 0 ? null
-        : (noFilings ? await noSecReportsEmpty(ctx, symbol) : null) ?? insiderEmptyNotice(foreignPrivateIssuer);
+      const empty = parsed.length > 0 ? null : await insiderEmpty(ctx, symbol, foreignPrivateIssuer, noFilings);
       const name = String(args.options.name ?? "").trim().toLocaleLowerCase();
       const type = isInsiderTypeFilter(args.options.type) ? args.options.type : "all";
       const owned = name

package/src/plugins/builtin/insider/index.tsx

@@ -30,7 +30,7 @@ import {
   type StatItem,
 } from "../../../components";
 import { useDebouncedPluginPaneState, usePluginPaneState } from "../../runtime";
-import { mayBeSecEquityListing, mayBeUsEquityTicker, noSecReportsNotice, nonUsSecListingVenue } from "../../../utils/sec";
+import { homeInsiderReportsNote, mayBeSecEquityListing, mayBeUsEquityTicker, noSecReportsNotice, nonUsSecListingVenue } from "../../../utils/sec";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { formatCompact } from "../../../utils/format";
 import { nextHeaderSort } from "../../../utils/sort-values";
@@ -56,6 +56,7 @@ import {
 } from "./model";
 import { formatInsiderName } from "./display";
 import { insiderHeadless } from "./headless";
+import { FORM4_CURRENCY } from "./base-values";
 import { isInsiderForm } from "./insider-data";
 import { filesAsForeignPrivateIssuer, insiderEmptyNotice, isOtherIssuerFiling } from "./issuer";
 import { relevantInsiderAmendments } from "./amendments";
@@ -116,9 +117,10 @@ const TYPE_FILTER_LABELS: Record<InsiderTypeFilter, string> = {
  * security when there are several. A side with no trades shows 0 shares,
  * muted. Buys read in the gain colour and sales in the loss colour, as in
  * the table; when the Type filter hides open-market trades the figures dim
- * and say so.
+ * and say so. With `currency` the dollars read with its code (1.2M USD), as
+ * the table's CCY column names them.
  */
-function summaryItems(figures: InsiderSummaryFigures, typeFilter: InsiderTypeFilter): StatItem[] {
+function summaryItems(figures: InsiderSummaryFigures, typeFilter: InsiderTypeFilter, currency?: string): StatItem[] {
   const securities = new Set(figures.totals.map((total) => total.security));
   const hidden = typeFilter === "other";
   const items: StatItem[] = [];
@@ -132,7 +134,8 @@ function summaryItems(figures: InsiderSummaryFigures, typeFilter: InsiderTypeFil
         label,
         value: total.unreconciled ? "Unavailable" : `${formatCompact(total.shares)} shares`,
         detail: [
-          total.unreconciled ? "amended" : total.knownValue ? `$${formatCompact(total.value)}` : "value unavailable",
+          total.unreconciled ? "amended" : !total.knownValue ? "value unavailable"
+            : currency ? `${formatCompact(total.value)} ${currency}` : `$${formatCompact(total.value)}`,
           securities.size > 1 ? total.security : null,
           hidden ? "not in this view" : null,
         ].filter(Boolean).join(" · "),
@@ -337,7 +340,10 @@ function InsiderTradesView({ ticker, viewBar, state, width, height, focused, sta
     const order = new Map(rows.map((row, index) => [row.id, index]));
     return sortStackItems(rows, sort, compareInsiderRows, (a, b) => order.get(a.id)! - order.get(b.id)!);
   }, [rows, sort]);
-  const columns = useMemo(() => buildInsiderColumns(width, rows), [rows, width]);
+  // Form 4 amounts are dollars: a reader whose base currency is another one gets them named, as PF names a holding's.
+  const baseCurrency = useAppSelector((state) => state.config.baseCurrency);
+  const amountCurrency = baseCurrency.trim().toUpperCase() === FORM4_CURRENCY ? undefined : FORM4_CURRENCY;
+  const columns = useMemo(() => buildInsiderColumns(width, rows, amountCurrency), [amountCurrency, rows, width]);
 
   // A narrowed list that cannot scroll cannot ask for older filings, so they
   // load here until it fills a page, back to a year at most.
@@ -358,7 +364,7 @@ function InsiderTradesView({ ticker, viewBar, state, width, height, focused, sta
   const lastSummaryRef = useRef<{ scope: string; figures: InsiderSummaryFigures } | null>(null);
   if (summary) lastSummaryRef.current = { scope: summaryScope, figures: summary };
   const shownSummary = summary ?? (lastSummaryRef.current?.scope === summaryScope ? lastSummaryRef.current.figures : null);
-  const statItems = useMemo(() => shownSummary ? summaryItems(shownSummary, typeFilter) : [], [shownSummary, typeFilter]);
+  const statItems = useMemo(() => shownSummary ? summaryItems(shownSummary, typeFilter, amountCurrency) : [], [amountCurrency, shownSummary, typeFilter]);
   // The totals miss window filings only when the window passes the cap.
   const windowPartial = shownCount < windowCount;
   const insiderOptions = useMemo(() => {
@@ -483,9 +489,12 @@ function InsiderTradesView({ ticker, viewBar, state, width, height, focused, sta
   if (loading && allFilings.length === 0) return underBar(<Spinner label="Loading insider filings..." />);
   if (error && allFilings.length === 0) return underBar(<EmptyState title="Insider filings unavailable." message={error} />);
   if (noOwnFilings) {
+    // A company from abroad also says its home market's insider reports are not covered (RY:TSX: SEDI).
+    const foreignPrivateIssuer = filesAsForeignPrivateIssuer(allFilings);
+    const home = homeInsiderReportsNote({ exchange: abroadVenue, foreignPrivateIssuer });
     return underBar(renderFilingNotice(abroadVenue && allFilings.length === 0
-      ? noSecReportsNotice({ symbol: parsePublicTickerKey(ticker.metadata.ticker).symbol, exchange: abroadVenue, name: ticker.metadata.name ?? null })
-      : insiderEmptyNotice(filesAsForeignPrivateIssuer(allFilings))));
+      ? [noSecReportsNotice({ symbol: parsePublicTickerKey(ticker.metadata.ticker).symbol, exchange: abroadVenue, name: ticker.metadata.name ?? null }), home].filter(Boolean).join(" ")
+      : insiderEmptyNotice(foreignPrivateIssuer, home)));
   }
 
   // Until a filing is read there is nothing to say; after that the empty

package/src/plugins/builtin/insider/issuer.ts

@@ -1,4 +1,7 @@
-import type { SecFilingItem } from "../../../types/data-provider";
+import type { DataProvider, SecFilingItem } from "../../../types/data-provider";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { logFailure } from "../../../utils/log-failure";
+import { homeInsiderReportsNote, venueHomeCountry } from "../../../utils/sec";
 import { parseForm4IssuerCik } from "./insider-data";
 
 /**
@@ -40,10 +43,37 @@ export function filesAsForeignPrivateIssuer(filings: readonly SecFilingItem[]):
 
 /**
  * What the pane, `fn INS` and `insider` say when a company has no Form 4 of
- * its own. Each already names the company above it.
+ * its own, and beside it, for a company from abroad, that its insiders'
+ * reports at home are not covered either (`homeInsiderReportsNote`). Each
+ * already names the company above it.
  */
-export function insiderEmptyNotice(foreignPrivateIssuer: boolean): string {
-  return foreignPrivateIssuer
+export function insiderEmptyNotice(foreignPrivateIssuer: boolean, home: string | null = null): string {
+  const notice = foreignPrivateIssuer
     ? "No Form 4 insiders: foreign private issuers file none."
     : "No Form 4 insider filings.";
+  return home ? `${notice} ${home}` : notice;
+}
+
+/**
+ * `homeInsiderReportsNote` for a listing with no Form 4 of its own, placed by
+ * its company's country where the source knows the company (RY in New York
+ * is Royal Bank of Canada), else by its venue abroad (RY:TSX). A lookup that
+ * fails leaves the venue to say. A US listing of a company filing as a
+ * domestic one has no home market to name, and costs no lookup.
+ */
+export async function loadHomeInsiderReportsNote(
+  provider: Pick<DataProvider, "getIssuerListings">,
+  key: string,
+  exchange: string | undefined,
+  foreignPrivateIssuer: boolean,
+): Promise<string | null> {
+  const parsed = parsePublicTickerKey(key);
+  const venue = parsed.exchange ?? exchange ?? "";
+  if (!foreignPrivateIssuer && !venueHomeCountry(venue)) return null;
+  const { getIssuerListings } = provider;
+  const issuer = getIssuerListings
+    ? await Promise.resolve().then(() => getIssuerListings.call(provider, parsed.symbol, venue))
+      .catch(logFailure("plugins.insider.issuer", "Reading the company's listings failed", null))
+    : null;
+  return homeInsiderReportsNote({ country: issuer?.country, exchange: venue, foreignPrivateIssuer });
 }

package/src/plugins/builtin/insider/signals-client.ts

@@ -109,7 +109,7 @@ export async function loadInsiderSignals(
       if (isAccessDenied(error)) throw new Error(CLOUD_SESSION_REQUIRED, { cause: error });
       throw unavailableOnServer(error, INSIDER_SIGNALS_NOT_AVAILABLE);
     }),
-    { force, validate: validateInsiderSignals },
+    { force, validate: validateInsiderSignals, signal },
   );
 }
 
@@ -187,7 +187,7 @@ export async function loadInsiderCompany(
       if (isAccessDenied(error)) throw new Error(CLOUD_SESSION_REQUIRED, { cause: error });
       throw unavailableOnServer(error, INSIDERS_NOT_AVAILABLE);
     }),
-    { force, validate: companyValidator(query.ticker) },
+    { force, validate: companyValidator(query.ticker), signal },
   )));
   return bothSides(buy!, sell!);
 }

package/src/plugins/builtin/insider/table-model.ts

@@ -1,5 +1,5 @@
 import type { DataTableColumn } from "../../../components";
-import { displayWidth, formatCompact, formatCurrency } from "../../../utils/format";
+import { displayWidth, formatCompact, formatCurrency, formatNumber } from "../../../utils/format";
 import { isAmendedInsiderFiling } from "./amendments";
 import { insiderSecurityTag, insiderTypeLabel, insiderTypeTone, isOpenMarketTrade, type InsiderTypeTone } from "./display";
 import {
@@ -10,12 +10,18 @@ import {
   type ParsedInsiderFiling,
 } from "./model";
 
-export type InsiderColumnId = "date" | "insider" | "role" | "type" | "security" | "shares" | "price" | "value";
+export type InsiderColumnId = "date" | "insider" | "role" | "type" | "security" | "shares" | "price" | "value" | "ccy";
 
 export interface InsiderColumn extends DataTableColumn {
   id: InsiderColumnId;
   /** The type column has room for the 10b5-1 marker. */
   plan?: boolean;
+  /**
+   * The currency the CCY column names, and that Price and Value are written
+   * in without a sign, as PF writes LAST beside CCY. Unset when the amounts
+   * keep their $.
+   */
+  currency?: string;
 }
 
 /** One table row: a Form 4 line, or a filing without one (loading, unread, a disclosure). */
@@ -102,12 +108,21 @@ export function formatInsiderShares(value: number | null): string {
   return value == null ? "—" : formatCompact(value);
 }
 
-export function formatInsiderPrice(value: number | null): string {
-  return value == null ? "—" : formatCurrency(value);
+/** A Form 4 price: $412.50, or 412.50 when a CCY column names its currency. */
+export function formatInsiderPrice(value: number | null, currency?: string): string {
+  if (value == null) return "—";
+  return currency ? formatNumber(value, 2) : formatCurrency(value);
 }
 
-export function formatInsiderValue(value: number | null): string {
-  return value == null ? "—" : `$${formatCompact(value)}`;
+/** A Form 4 value: $1.2M, or 1.2M when a CCY column names its currency. */
+export function formatInsiderValue(value: number | null, currency?: string): string {
+  if (value == null) return "—";
+  return currency ? formatCompact(value) : `$${formatCompact(value)}`;
+}
+
+/** What a row's CCY cell says: the currency of its price and value, or a dash for a filing without either. */
+export function insiderCurrencyText(row: Pick<InsiderTableRow, "price" | "value">, currency: string): string {
+  return row.price == null && row.value == null ? "—" : currency;
 }
 
 /** The quieter words after the type: "4/A" always, "10b5-1" when the column has room. */
@@ -136,9 +151,11 @@ function fitWidth(texts: readonly string[], label: string, max: number): number
  * When the pane runs short, the role goes first, then the price, the
  * 10b5-1 marker, the security and the share count, and only then does the name
  * column shrink below 16 cells, so a narrow pane still reads date, name,
- * type and value.
+ * type and value. With `currency` (Form 4 amounts read by someone whose base
+ * currency is not the dollar), CCY follows Value and is kept with it, as PF
+ * shows CCY once a row is in another currency than the totals.
  */
-export function buildInsiderColumns(width: number, rows: readonly InsiderTableRow[]): InsiderColumn[] {
+export function buildInsiderColumns(width: number, rows: readonly InsiderTableRow[], currency?: string): InsiderColumn[] {
   const anyPlan = rows.some((row) => row.plan);
   const anySecurity = rows.some((row) => row.security);
   const names = rows.map((row) => row.name);
@@ -150,8 +167,9 @@ export function buildInsiderColumns(width: number, rows: readonly InsiderTableRo
     typePlan: fitWidth(rows.map((row) => insiderTypeText(row, true)), "Type", 19),
     security: fitWidth(rows.map((row) => row.security ?? ""), "Security", 12),
     shares: fitWidth(rows.map((row) => formatInsiderShares(row.shares)), "Shares", 9),
-    price: fitWidth(rows.map((row) => formatInsiderPrice(row.price)), "Price", 10),
-    value: fitWidth(rows.map((row) => formatInsiderValue(row.value)), "Value", 9),
+    price: fitWidth(rows.map((row) => formatInsiderPrice(row.price, currency)), "Price", 10),
+    value: fitWidth(rows.map((row) => formatInsiderValue(row.value, currency)), "Value", 9),
+    ccy: currency ? fitWidth(rows.map((row) => insiderCurrencyText(row, currency)), "CCY", 4) : 0,
   };
   const show = { role: true, price: true, plan: anyPlan, security: anySecurity, shares: true };
   let insider = widths.insider;
@@ -165,6 +183,7 @@ export function buildInsiderColumns(width: number, rows: readonly InsiderTableRo
     show.shares ? widths.shares : 0,
     show.price ? widths.price : 0,
     widths.value,
+    widths.ccy,
   ].reduce((sum, columnWidth) => sum + (columnWidth > 0 ? columnWidth + COLUMN_GAP : 0), 0);
   const shrinkInsider = (floor: number) => {
     insider = Math.max(Math.min(insider, floor), insider - Math.max(0, total() - available));
@@ -187,10 +206,11 @@ export function buildInsiderColumns(width: number, rows: readonly InsiderTableRo
     { id: "type", label: "Type", width: typeWidth, align: "left", plan: show.plan },
     ...(show.security ? [{ id: "security" as const, label: "Security", width: widths.security, align: "left" as const }] : []),
     ...(show.shares ? [{ id: "shares" as const, label: "Shares", width: widths.shares, align: "right" as const }] : []),
-    ...(show.price ? [{ id: "price" as const, label: "Price", width: widths.price, align: "right" as const }] : []),
-    { id: "value", label: "Value", width: widths.value, align: "right" },
+    ...(show.price ? [{ id: "price" as const, label: "Price", width: widths.price, align: "right" as const, currency }] : []),
+    { id: "value", label: "Value", width: widths.value, align: "right", currency },
+    ...(currency ? [{ id: "ccy" as const, label: "CCY", width: widths.ccy, align: "left" as const, currency }] : []),
   ];
-  // Spare cells spread over the columns, so the value column ends at the
+  // Spare cells spread over the columns, so the last column ends at the
   // pane's edge in the terminal as it does on the desktop.
   const used = columns.reduce((sum, column) => sum + column.width + COLUMN_GAP, 0);
   const spare = Math.max(0, available - used);
@@ -222,5 +242,7 @@ export function compareInsiderRows(a: InsiderTableRow, b: InsiderTableRow, colum
     case "shares": return compareNullable(a.shares, b.shares);
     case "price": return compareNullable(a.price, b.price);
     case "value": return compareNullable(a.value, b.value);
+    // Every amount is in one currency: rows with one before filings without, as the CCY cells read.
+    case "ccy": return Number(a.price == null && a.value == null) - Number(b.price == null && b.value == null);
   }
 }

package/src/plugins/builtin/insider/table.tsx

@@ -9,6 +9,7 @@ import {
   formatInsiderPrice,
   formatInsiderShares,
   formatInsiderValue,
+  insiderCurrencyText,
   insiderTypeMarkers,
   insiderTypeText,
   type InsiderColumn,
@@ -72,8 +73,10 @@ export function renderInsiderCell(
     case "shares":
       return { text: formatInsiderShares(row.shares), value: row.shares, color: figureColor };
     case "price":
-      return { text: formatInsiderPrice(row.price), value: row.price, color: figureColor };
+      return { text: formatInsiderPrice(row.price, column.currency), value: row.price, color: figureColor };
     case "value":
-      return { text: formatInsiderValue(row.value), value: row.value, color: figureColor };
+      return { text: formatInsiderValue(row.value, column.currency), value: row.value, color: figureColor };
+    case "ccy":
+      return { text: insiderCurrencyText(row, column.currency ?? ""), color: colors.textMuted };
   }
 }

package/src/plugins/builtin/iv-history/events.ts

@@ -0,0 +1,145 @@
+import { getPublishedUsEquityCalendarDay, getPublishedUsEquitySession } from "../../../market-data/published-us-sessions";
+import { zonedDateKey, zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
+import type { MacroEventKind, MacroRelease } from "../macro-day/releases";
+import type { DatedValue, IvHistoryModel, IvLookback } from "./model";
+
+/** One release and the readings a set number of sessions from it. */
+interface ReleaseOffsetRow {
+  kind: MacroEventKind;
+  /** The release's New York calendar day. */
+  releaseDate: string;
+  /** Sessions from the release: 0 is the first session on or after its day, -6 the sixth session before that. */
+  offset: number;
+  /** The session the readings are of. */
+  date: string;
+  iv30: number | null;
+  iv90: number | null;
+  iv365: number | null;
+  hv: number | null;
+  spread: number | null;
+  /** 25-delta put IV minus call IV, and the risk reversal, call minus put. */
+  skew25d: number | null;
+  rr25d: number | null;
+}
+
+export interface ReleaseOffsets {
+  rows: ReleaseOffsetRow[];
+  /** Releases whose session at the offset has not closed or has no closing reading yet, oldest first. */
+  pending: string[];
+  /** Releases inside the stored history whose session at the offset is before the lookback. */
+  beforeLookback: number;
+  /** Releases before the IV history starts. */
+  beforeHistory: number;
+  /** The first session of the IV history read, when there is one. */
+  historyStart: string | null;
+}
+
+const NEW_YORK = "America/New_York";
+const day = (date: Date) => date.toISOString().slice(0, 10);
+const byDay = (points: readonly DatedValue[]) => new Map(points.map((point) => [day(point.date), point.value]));
+const nextDay = (date: string) => new Date(Date.parse(`${date}T00:00:00Z`) + 86_400_000).toISOString().slice(0, 10);
+
+/** Whether `date`'s regular session has closed at `now`: an earlier New York day, or today from its close on. */
+function sessionClosed(date: string, now: number): boolean {
+  const today = zonedDateKey(now, NEW_YORK);
+  if (date !== today) return date < today;
+  const session = getPublishedUsEquitySession("NYSE", date);
+  const [year, month, dayOfMonth] = date.split("-").map(Number) as [number, number, number];
+  return now >= (session?.kind === "session" ? session.close : zonedWallClockToUtcMs(NEW_YORK, year, month, dayOfMonth, 16, 0, 0));
+}
+
+/** The US equity sessions after `after` through the first on or after `until`; null where the published calendar ends. */
+function calendarSessions(after: string, until: string): string[] | null {
+  const sessions: string[] = [];
+  for (let date = nextDay(after); ; date = nextDay(date)) {
+    const kind = getPublishedUsEquityCalendarDay("NYSE", date);
+    if (kind == null) return null;
+    if (kind !== "session") continue;
+    sessions.push(date);
+    if (date >= until) return sessions;
+  }
+}
+
+/**
+ * One row per release of `kind`, with the readings on the session `offset`
+ * sessions from it (the "week before FOMC" is `-5` or `-6`), oldest first.
+ * Offset 0 is the first session on or after the release day, so a release on
+ * a day with no session counts from the next one. Sessions are the history's
+ * own, from the first IV reading in the lookback through the last closed
+ * session read (`readThrough`, or the last IV reading), and past that the
+ * published exchange calendar: an upcoming release whose session at a
+ * negative offset has closed and been read gets its row. A release whose
+ * session at the offset has not closed or has no reading yet is pending; one
+ * whose session falls before the history read is counted, before the lookback
+ * or before the history.
+ */
+export function releaseOffsetRows(
+  model: Pick<IvHistoryModel, "iv30" | "iv90" | "iv365" | "hv" | "spread" | "skew" | "since">,
+  releases: readonly MacroRelease[],
+  kind: MacroEventKind,
+  offset: number,
+  { lookback = "ALL", readThrough = null, now = Date.now() }: { lookback?: IvLookback; readThrough?: string | null; now?: number } = {},
+): ReleaseOffsets {
+  const result: ReleaseOffsets = { rows: [], pending: [], beforeLookback: 0, beforeHistory: 0, historyStart: null };
+  // Sessions from the first IV reading on: realized volatility alone, before it or without it, is no IV row.
+  const first = model.iv30[0] ? day(model.iv30[0].date) : null;
+  if (!first) return result;
+  const lastReading = day(model.iv30.at(-1)!.date);
+  const through = readThrough && readThrough > lastReading ? readThrough : lastReading;
+  // A session counts once it has closed and been read: today's bar before the close, or a session the IV history has not reached, is no reading.
+  const known = [...new Set([...model.iv30, ...model.hv].map((point) => day(point.date)))]
+    .filter((session) => session >= first && session <= through && sessionClosed(session, now)).sort();
+  if (known.length === 0) return result;
+  result.historyStart = known[0]!;
+  // The lookback cut a longer stored history: a release before it is outside the lookback, not before the history.
+  const trimmed = lookback !== "ALL" && model.since != null && model.since < first;
+  const before = (release: MacroRelease) => {
+    if (trimmed && release.date >= model.since!) result.beforeLookback += 1;
+    else result.beforeHistory += 1;
+  };
+  const iv30 = byDay(model.iv30), iv90 = byDay(model.iv90), iv365 = byDay(model.iv365);
+  const hv = byDay(model.hv), spread = byDay(model.spread), skew = byDay(model.skew);
+  for (const release of releases) {
+    if (release.kind !== kind) continue;
+    if (release.date < known[0]!) {
+      before(release);
+      continue;
+    }
+    const anchor = known.findIndex((session) => session >= release.date);
+    let index: number;
+    if (anchor >= 0) index = anchor + offset;
+    else {
+      // After the last session read: count on through the exchange calendar to the release's own session.
+      const ahead = calendarSessions(known.at(-1)!, release.date);
+      if (!ahead) {
+        result.pending.push(release.date);
+        continue;
+      }
+      index = known.length + ahead.length - 1 + offset;
+    }
+    if (index < 0) {
+      before(release);
+      continue;
+    }
+    if (index >= known.length) {
+      result.pending.push(release.date);
+      continue;
+    }
+    const date = known[index]!;
+    const skewValue = skew.get(date) ?? null;
+    result.rows.push({
+      kind, releaseDate: release.date, offset, date,
+      iv30: iv30.get(date) ?? null, iv90: iv90.get(date) ?? null, iv365: iv365.get(date) ?? null,
+      hv: hv.get(date) ?? null, spread: spread.get(date) ?? null,
+      skew25d: skewValue, rr25d: skewValue == null ? null : -skewValue,
+    });
+  }
+  return result;
+}
+
+/** "6 sessions before", "release day", "1 session after". */
+export function offsetText(offset: number): string {
+  if (offset === 0) return "release day";
+  const sessions = `${Math.abs(offset)} session${Math.abs(offset) === 1 ? "" : "s"}`;
+  return offset < 0 ? `${sessions} before` : `${sessions} after`;
+}

package/src/plugins/builtin/iv-history/format.ts

@@ -12,6 +12,9 @@ export const VCA_DEFINITIONS = [
   "VIX is Cboe's 30-day S&P 500 implied vol from the whole SPX strike strip, skew included; IV30 here is at the money, so VIX usually reads higher.",
 ] as const;
 
+/** Words for implied volatility that are no function's code: `fn IVOL` names HIVG and OVDV, which list them as `suggestFor`. */
+export const IMPLIED_VOL_WORDS = ["IVOL", "IV", "OVOL", "IMPVOL", "IMPLIEDVOL"];
+
 /**
  * A skew column's header names its sign, since the conventions differ: the
  * 25-delta skew is put minus call (HIVG, VCA), the risk reversal call minus