gloomberb 0.18.1 → 0.18.3

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

@@ -6,8 +6,9 @@ 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,
   buildInsiderSummary,
@@ -20,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";
@@ -58,6 +59,7 @@ import {
   insiderUsualRatio,
 } from "./signals-model";
 import { REPORT_ROWS } from "../shared/headless-options";
+import type { FxHistoryClient } from "../../../market-data/fx-closes";
 
 const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "form", header: "Form" },
@@ -106,6 +108,20 @@ const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "note", header: "Note", underRow: true, format: (value) => typeof value === "string" ? value : "" },
 ];
 
+/** With a base currency other than USD, the dollar columns say they are in USD ("Bought (USD)"), as $ alone is several currencies' sign. */
+function labelDollarColumns(columns: HeadlessPaneColumn[], keys: readonly string[], baseCurrency: string): HeadlessPaneColumn[] {
+  if (baseCurrency.trim().toUpperCase() === FORM4_CURRENCY) return columns;
+  return columns.map((column) => keys.includes(column.key) ? { ...column, header: `${column.header} (${FORM4_CURRENCY})` } : column);
+}
+
+/** The trades' columns with the money ones labelled by currency and the converted value and rate after them (`withInsiderBaseValues`). */
+function withMoneyColumns(money: readonly HeadlessPaneColumn[]): HeadlessPaneColumn[] {
+  const byKey = new Map(money.map((column) => [column.key, column]));
+  return INSIDER_COLUMNS.flatMap((column) => column.key === "totalValue"
+    ? money.filter((entry) => entry.key !== "pricePerShare")
+    : [byKey.get(column.key) ?? column]);
+}
+
 const figureOrDash = (value: unknown) => (typeof value === "number" ? value : null);
 
 /**
@@ -183,6 +199,7 @@ function insidersRows(activity: InsiderCompanyActivity, side: InsiderSignalSide)
       stakeBothWays: line.buyer.twoWay === true,
       bought: line.bought,
       sold: line.sold,
+      currency: FORM4_CURRENCY,
       shares: line.buyer.shares ?? null,
       last: line.buyer.lastBuy,
     }));
@@ -211,6 +228,7 @@ function signalRows(payload: InsiderSignalsPayload): HeadlessPaneRow[] {
       insiders: row.insiders,
       buys: row.buys,
       value: row.value,
+      currency: FORM4_CURRENCY,
       shares: row.shares,
       firstBuy: row.firstBuy,
       lastBuy: row.lastBuy,
@@ -251,6 +269,8 @@ function amendmentNote(entry: ParsedInsiderFiling): string {
 }
 
 export interface InsiderHeadlessDependencies {
+  /** Daily FX closes for values in a base currency other than USD; the report's API client unless a test stands in. */
+  fxHistory?: FxHistoryClient;
   loadSignals?(query: InsiderSignalsQuery, limit: number, ctx: HeadlessPaneContext): Promise<InsiderSignalsPayload>;
   loadCompany?(query: InsiderCompanyQuery, ctx: HeadlessPaneContext): Promise<InsiderCompanyActivity>;
   loadParsed(
@@ -290,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"> {
@@ -326,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,
       },
@@ -441,9 +475,9 @@ export function createInsiderHeadless(
         const payload = await (dependencies.loadSignals ?? defaultDependencies.loadSignals!)(query, Number(args.options.limit), ctx);
         const side = payload.side ?? "buy";
         return {
-          columns: signalColumns(side),
+          columns: labelDollarColumns(signalColumns(side), ["value"], ctx.config.baseCurrency),
           // The exports carry each row's insiders; the text leaves them to fn INS <ticker> --view insiders.
-          textColumns: signalColumns(side).filter((column) => column.key !== "buyers"),
+          textColumns: labelDollarColumns(signalColumns(side).filter((column) => column.key !== "buyers"), ["value"], ctx.config.baseCurrency),
           rows: signalRows(payload),
           ...(payload.rows.length === 0 ? { empty: insiderSignalsEmptyTitle(payload.window, side, insiderSignalsFiltered(query)) } : {}),
           metadata: {
@@ -472,7 +506,7 @@ export function createInsiderHeadless(
           .filter((notice): notice is string => !!notice))];
         const rows = insidersRows(activity, side);
         return {
-          columns: INSIDERS_COLUMNS,
+          columns: labelDollarColumns(INSIDERS_COLUMNS, ["bought", "sold"], ctx.config.baseCurrency),
           rows,
           ...(rows.length === 0 ? { empty: insiderActivityEmptyTitle(window) } : {}),
           metadata: {
@@ -490,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
@@ -503,12 +536,17 @@ export function createInsiderHeadless(
         .filter((row) => row.status !== "parsed" && row.status !== "disclosure")
         .map((row) => row.accessionNumber))];
       // A filing's lines sit together, so its note goes once, under the last of them.
-      const rows: HeadlessPaneRow[] = buildInsiderRows(filtered, parsed).map((row, index) => {
+      const filed: HeadlessPaneRow[] = buildInsiderRows(filtered, parsed).map((row, index) => {
         const entry = filtered[index]!;
         const last = filtered[index + 1]?.filing.accessionNumber !== entry.filing.accessionNumber;
         return isAmendedInsiderFiling(entry) && last ? { ...row, note: amendmentNote(entry) || null } : row;
       });
+      // Every value says its currency; a base currency other than USD gets each value converted beside it.
+      const based = await withInsiderBaseValues(filed, ctx.config.baseCurrency, dependencies.fxHistory ?? ctx.apiClient);
+      const rows = based.rows;
       return {
+        ...(based.columns ? { columns: withMoneyColumns(based.columns) } : {}),
+        ...(based.note ? { notes: [based.note] } : {}),
         rows,
         // Nothing at all: the company has no Form 4 of its own, which is the whole answer.
         ...(empty ? { empty, unavailableSymbols: [] } : {}),

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