gloomberb 0.16.3 → 0.16.5

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

@@ -0,0 +1,49 @@
+import type { SecFilingItem } from "../../../types/data-provider";
+import { parseForm4IssuerCik } from "./insider-data";
+
+/**
+ * A company's SEC filing list holds every Form 4 it is named on: its insiders'
+ * trades in its shares, and the ones it filed itself as an owner of another
+ * company's shares (Banco Santander buying Santander Consumer, Sanofi
+ * converting Regeneron notes). Only the form's issuer tells them apart, so a
+ * filing is the company's own until its document names another issuer.
+ */
+export function isOtherIssuerFiling(filing: SecFilingItem, content: string | null | undefined): boolean {
+  if (!content) return false;
+  const issuer = parseForm4IssuerCik(content);
+  const company = filing.cik.trim().replace(/^0+/, "");
+  return issuer != null && /^\d+$/.test(company) && issuer !== company;
+}
+
+const FOREIGN_PRIVATE_ISSUER_FORM = /^(?:20-F|40-F|6-K)(?:\/A)?$/i;
+const DOMESTIC_REPORT_FORM = /^(?:10-KT?|10-QT?|8-K)(?:\/A)?$/i;
+
+function newestFiled(filings: readonly SecFilingItem[], form: RegExp): number {
+  let newest = Number.NEGATIVE_INFINITY;
+  for (const filing of filings) {
+    if (!form.test(filing.form.trim())) continue;
+    const time = new Date(filing.filingDate).getTime();
+    if (Number.isFinite(time) && time > newest) newest = time;
+  }
+  return newest;
+}
+
+/**
+ * The company reports as a foreign private issuer: its newest report is a
+ * 20-F, 40-F or 6-K rather than a 10-K, 10-Q or 8-K. Such an issuer's insiders
+ * file no Form 4, so its list holds only the forms it filed as an owner.
+ */
+export function filesAsForeignPrivateIssuer(filings: readonly SecFilingItem[]): boolean {
+  const foreign = newestFiled(filings, FOREIGN_PRIVATE_ISSUER_FORM);
+  return Number.isFinite(foreign) && foreign > newestFiled(filings, DOMESTIC_REPORT_FORM);
+}
+
+/**
+ * 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.
+ */
+export function insiderEmptyNotice(foreignPrivateIssuer: boolean): string {
+  return foreignPrivateIssuer
+    ? "No Form 4 insiders: foreign private issuers file none."
+    : "No Form 4 insider filings.";
+}

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

@@ -3,6 +3,7 @@ import { formatCompact, formatCurrency } from "../../../utils/format";
 import { parseForm4Xml, parseForm4Disclosure, transactionTypeLabel, type InsiderTransaction, type InsiderFilingDisclosure, type InsiderReportingOwner } from "./insider-data";
 import { affectingInsiderAmendments, buildInsiderAmendmentScopes, isAmendedInsiderFiling } from "./amendments";
 import { formatInsiderName, isOpenMarketTrade, shortInsiderRole } from "./display";
+import { isOtherIssuerFiling } from "./issuer";
 
 const NINETY_DAYS_MS = 90 * 24 * 60 * 60 * 1000;
 
@@ -13,7 +14,9 @@ export interface ParsedInsiderFiling {
   disclosure?: InsiderFilingDisclosure | null;
 }
 
+/** The rows of one filing; none for a Form 4 the company filed as an owner of another issuer. */
 export function parseInsiderFiling(filing: SecFilingItem, content: string | null, isLoading = false): ParsedInsiderFiling[] {
+  if (isOtherIssuerFiling(filing, content)) return [];
   const transactions = content ? parseForm4Xml(content) : [];
   const disclosure = content ? parseForm4Disclosure(content) : null;
   return transactions.length

package/src/plugins/builtin/iv-history/charts.tsx

@@ -3,7 +3,8 @@ import { CompositeChart } from "../../../components";
 import { resolveChartPalette } from "../../../components/chart/core/palette";
 import { formatCompositeSeriesValue } from "../../../components/chart/composite/format";
 import { staticSeries } from "../../../components/chart/static/series";
-import { useThemeColors } from "../../../theme/theme-context";
+import { useThemeColors, useThemeId } from "../../../theme/theme-context";
+import { themeSeriesColors } from "../../../theme/series-colors";
 import type { ResolvedSeries } from "../../../time-series/types";
 import { formatPoints } from "./format";
 import type { DatedValue, IvHistoryModel } from "./model";
@@ -11,8 +12,15 @@ import type { DatedValue, IvHistoryModel } from "./model";
 const PANELS = [{ id: "vol", height: 3 }, { id: "spread", height: 1 }];
 /** The chart drawing blue: IV90 must read apart from amber IV30 in every theme. */
 const IV90_COLOR = "#4c9aff";
-/** The live capture point must stand apart from the amber IV30 line it continues. */
-const LIVE_COLOR = "#c084fc";
+/** The quote capture point must stand apart from the amber IV30 line it continues. */
+const QUOTE_COLOR = "#c084fc";
+/** IV1Y: pink, apart from amber IV30, blue IV90, green HV and the violet quote points. */
+const IV365_COLOR = "#f783ac";
+/**
+ * Palette slots for a theme with its own series colours (the colour-blind
+ * ones), where the up colour HV takes elsewhere is the same blue as IV90.
+ */
+const THEMED_SLOTS = { iv30: 1, iv90: 0, hv: 2, quote: 5, iv365: 4 } as const;
 
 function volSeries(id: string, label: string, color: string, points: readonly DatedValue[], panelId: string,
   style: ResolvedSeries["style"] = "line"): ResolvedSeries {
@@ -27,22 +35,28 @@ function formatLegendValue(value: number, series: ResolvedSeries): string {
   return series.id === "spread" ? `${formatPoints(value / 100)} pts` : formatCompositeSeriesValue(value, series);
 }
 
-function ivHistorySeries(model: IvHistoryModel, colors: { iv30: string; iv90: string; hv: string; quote: string; spread: string },
+function ivHistorySeries(model: IvHistoryModel, colors: { iv30: string; iv90: string; iv365: string; hv: string; quote: string; spread: string },
   hvLabel: string): ResolvedSeries[] {
   return [
     volSeries("iv30", "IV 30d", colors.iv30, model.iv30, "vol"),
     volSeries("iv90", "IV 90d", colors.iv90, model.iv90, "vol"),
+    // Drawn only once there is a 1Y close, so an empty legend entry never suggests one.
+    ...(model.iv365.length ? [volSeries("iv365", "IV 1Y", colors.iv365, model.iv365, "vol")] : []),
     volSeries("hv", hvLabel, colors.hv, model.hv, "vol"),
-    ...(model.quoteIv30.length ? [volSeries("iv30-quote", "IV 30d live", colors.quote, model.quoteIv30, "vol", "points")] : []),
+    ...(model.quoteIv30.length ? [volSeries("iv30-quote", "IV 30d quote", colors.quote, model.quoteIv30, "vol", "points")] : []),
     { ...volSeries("spread", `IV 30d - ${hvLabel}`, colors.spread, model.spread, "spread", "columns"), ...SPREAD_UNIT },
   ];
 }
 
 export function IvHistoryChart({ model, width, height, hvLabel, focused = false }: { model: IvHistoryModel; width: number; height: number; hvLabel: string; focused?: boolean }) {
   const colors = useThemeColors();
+  const themed = themeSeriesColors(useThemeId());
   const palette = resolveChartPalette(colors);
-  const series = useMemo(() => ivHistorySeries(model, { iv30: colors.warning, iv90: IV90_COLOR, hv: colors.positive,
-    quote: LIVE_COLOR, spread: colors.textDim }, hvLabel), [model, colors, hvLabel]);
+  const series = useMemo(() => ivHistorySeries(model, themed
+    ? { iv30: themed[THEMED_SLOTS.iv30]!, iv90: themed[THEMED_SLOTS.iv90]!, iv365: themed[THEMED_SLOTS.iv365]!, hv: themed[THEMED_SLOTS.hv]!,
+      quote: themed[THEMED_SLOTS.quote]!, spread: colors.textDim }
+    : { iv30: colors.warning, iv90: IV90_COLOR, iv365: IV365_COLOR, hv: colors.positive, quote: QUOTE_COLOR, spread: colors.textDim },
+  hvLabel), [model, colors, themed, hvLabel]);
   return <CompositeChart series={series} panels={PANELS} width={width} height={height} focused={focused} navigable={false} showLegend showTimeAxis formatValue={formatLegendValue}
     remoteKind="implied-volatility-history"
     colors={{ background: palette.bgColor, grid: palette.gridColor, crosshair: palette.crosshairColor, text: colors.text,

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

@@ -1,5 +1,5 @@
 import { apiClient } from "../../../api-client";
-import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { listingAbroadVenue, usListingSymbol } from "../../../utils/sec";
 import { getSharedMarketDataCoordinator, MarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
 import type { ChartRequest, InstrumentRef } from "../../../market-data/request-types";
 import type { QueryEntry } from "../../../market-data/result-types";
@@ -8,7 +8,7 @@ import type { PricePoint } from "../../../types/financials";
 import { realizedVolatility, realizedVolatilityCadenceIssue } from "../shared/volatility";
 
 export type IvMethod = "quote-mid" | "trade-close";
-type IvCoverageStatus = "ready" | "backfilling" | "queued" | "unavailable";
+export type IvCoverageStatus = "ready" | "backfilling" | "queued" | "unavailable";
 export interface IvPoint {
   sessionDate: string;
   method: IvMethod;
@@ -33,6 +33,10 @@ export interface IvStats {
   high: number | null;
   samples: number;
   windowStart: string | null;
+  /** Prior sessions the rank needs: 120, or 60 for IV1Y. Absent from older servers. */
+  minSamples?: number;
+  /** Why rank or percentile is empty, when one is. */
+  rankNote?: string | null;
 }
 interface IvReading {
   date: string;
@@ -51,17 +55,30 @@ export interface IvHistoryPayload {
   symbol: string;
   asOf: string;
   status: IvCoverageStatus;
-  coverage: { source: "seed" | "demand"; addedAt: string; backfilledThrough: string | null; since: string | null } | null;
-  stats: { iv30: IvStats | null; iv90: IvStats | null };
+  coverage: {
+    source: "seed" | "demand"; addedAt: string; backfilledThrough: string | null; since: string | null;
+    /** First trade close with a one-year reading; the 1Y series starts later and is sparser. */
+    iv365Since?: string | null;
+  } | null;
+  stats: { iv30: IvStats | null; iv90: IvStats | null; iv365?: IvStats | null };
   latest: IvReading | null;
   series: IvPoint[];
   warnings: string[];
 }
 export interface IvScreenRow {
   symbol: string;
+  /** Has readings, or none yet. All an older server says; `coverageStatus` is exact. */
   status: "ready" | "queued";
+  /** Where the symbol's history stands, as in `IvHistoryPayload.status`. Absent from older servers. */
+  coverageStatus?: IvCoverageStatus;
+  /** When the symbol was queued and how far its backfill has got; null when it is not covered. */
+  coverage?: { source: "seed" | "demand"; addedAt: string; backfilledThrough: string | null } | null;
+  /** Why it is not covered yet, such as demand coverage being full. */
+  warnings?: string[];
   iv30: IvStats | null;
   iv90: IvStats | null;
+  iv365?: IvStats | null;
+  iv365Since?: string | null;
   latest: IvReading | null;
   skew: { date: string; put25: number; call25: number; skew: number } | null;
 }
@@ -78,14 +95,17 @@ export interface StoredSurfacePayload {
 export type ImpliedVolatilityApi = Pick<typeof apiClient, "impliedVolatility">;
 const query = (params: Record<string, string>) => new URLSearchParams(params).toString();
 /** Stored IV is keyed by the bare US symbol; a listing key ("SPY:ARCX") drops its exchange. */
-export const ivSymbol = (symbol: string) => parsePublicTickerKey(symbol.trim()).symbol.toUpperCase();
+/** A US listing's symbol; a listing abroad is refused, since its bare symbol's options are another company's. */
+export const ivSymbol = (symbol: string) => usListingSymbol(symbol, "Implied volatility");
 
 export function loadIvHistory(symbol: string, options: { signal?: AbortSignal; days?: number } = {}, api: ImpliedVolatilityApi = apiClient) {
   return api.impliedVolatility<IvHistoryPayload>(`history?${query({ symbol: ivSymbol(symbol), days: String(options.days ?? 1100) })}`,
     { signal: options.signal });
 }
+/** A listing abroad has no row: its bare symbol's options are another company's. */
 export function loadIvScreen(symbols: readonly string[], options: { signal?: AbortSignal } = {}, api: ImpliedVolatilityApi = apiClient) {
-  return api.impliedVolatility<IvScreenPayload>(`screen?${query({ symbols: symbols.map(ivSymbol).join(",") })}`, { signal: options.signal });
+  const us = symbols.filter((symbol) => listingAbroadVenue(symbol) == null).map(ivSymbol);
+  return api.impliedVolatility<IvScreenPayload>(`screen?${query({ symbols: us.join(",") })}`, { signal: options.signal });
 }
 export function loadSurfaceDates(symbol: string, options: { signal?: AbortSignal } = {}, api: ImpliedVolatilityApi = apiClient) {
   return api.impliedVolatility<{ version: 1; symbol: string; dates: string[] }>(`surface-dates?${query({ symbol: ivSymbol(symbol) })}`,

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

@@ -1,4 +1,16 @@
-import type { IvStatRow, IvStatUnit, RichCheap } from "./model";
+import type { IvMethod } from "./client";
+import type { IvStatRow, IvStatUnit, RichCheap, RichCheapDates } from "./model";
+
+/**
+ * VCA's sign conventions, and what VIX is beside an at-the-money IV30, one
+ * line each: under the table, in the shot and in the report's notes. The skew
+ * is the stored 25-delta put and call IVs at a 30-day constant maturity, from
+ * the latest quote capture; both differences are decimal IV shown in points.
+ */
+export const VCA_DEFINITIONS = [
+  "25D skew: 30-day 25-delta put IV minus 25-delta call IV, in vol points; positive means puts are richer. 30-90: IV30 minus IV90.",
+  "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;
 
 export const formatVol = (value: number | null | undefined) => value == null || !Number.isFinite(value) ? "--" : `${(value * 100).toFixed(1)}%`;
 export const formatPoints = (value: number | null | undefined) =>
@@ -13,6 +25,25 @@ export function formatStat(value: number | null | undefined, unit: IvStatUnit):
   if (value == null || !Number.isFinite(value)) return "--";
   return unit === "vol" ? formatVol(value) : unit === "points" ? formatPoints(value) : value.toFixed(2);
 }
+/**
+ * How a stored reading was taken. A quote capture is the option quote mids
+ * from the minutes before the close, taken once a session and never updated:
+ * it is not a live feed, so it is not called live.
+ */
+const readingSource = (method: IvMethod | null | undefined) => method === "quote-mid" ? "quote" : "close";
 export function statSource(row: Pick<IvStatRow, "method">): string {
-  return row.method === "quote-mid" ? "live" : row.method === "prices" ? "closes" : row.method === "trade-close" ? "close" : "";
+  return row.method === "prices" ? "closes" : row.method ? readingSource(row.method) : "";
+}
+/** "2026-10-09 quote": the session a reading belongs to and how it was taken. */
+export const readingLabel = (date: string, method: IvMethod | null | undefined, short = false) =>
+  `${short ? shortDate(date) : date} ${readingSource(method)}`;
+/**
+ * The dates every row agrees on, said once: the reading's, and the trade close
+ * its rank is measured on. `short` is for a footer with little room: month and
+ * day, and no window.
+ */
+export function sharedDates({ reading, rank }: Pick<RichCheapDates, "reading" | "rank">, short = false): string[] {
+  if (reading?.method === "trade-close" && reading.date === rank) return [readingLabel(reading.date, reading.method, short)];
+  return [reading && `IV30 ${readingLabel(reading.date, reading.method, short)}`,
+    rank && (short ? `IVR/IVP ${shortDate(rank)} close` : `IVR/IVP vs 52 weeks to ${rank} close`)].filter((part): part is string => !!part);
 }

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

@@ -2,8 +2,8 @@ import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { createRealizedVolatilityDependencies, loadRealizedVolatilityHistory } from "../realized-vol/client";
 import { createHvDependencies, loadIvHistory, loadIvScreen, loadRealizedVolatilities } from "./client";
-import { formatPoints, formatRank, formatStat, formatVol, verdictLabel } from "./format";
-import { HV_WINDOWS, type HvWindow, type IvLookback, type IvStatRow, projectIvHistory, projectRichCheap, sharedReading, VCA_LIMIT, VCA_PRESETS } from "./model";
+import { formatPoints, formatRank, formatStat, formatVol, readingLabel, sharedDates, VCA_DEFINITIONS, verdictLabel } from "./format";
+import { HV_WINDOWS, type HvWindow, type IvLookback, type IvStatRow, projectIvHistory, projectRichCheap, type RichCheapRow, richCheapDates, screenCoverage, VCA_LIMIT, VCA_PRESETS } from "./model";
 import { vcaUniverse } from "./universe";
 
 const METHODOLOGY = "docs/research-data.md#implied-volatility-history";
@@ -11,10 +11,12 @@ const percent = (value: unknown) => typeof value === "number" ? formatVol(value)
 
 export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "US option underlying" },
+  usListingsOnly: "Implied volatility history",
   freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily", observedKey: "date", oldest: null },
   describe: (args) => `HIVG ${args.symbols[0] ?? ""}`,
   discovery: { aliases: ["HIVG"], screenshotReadiness: "live-dom", dataRequirements: ["Cloud stored implied volatility", "Daily price history"],
-    limitations: ["History starts February 2024 (OPRA daily trade closes)", "Rank and percentile use trade-close readings only"] },
+    limitations: ["History starts February 2024 (daily option trade closes)", "Rank and percentile use trade-close readings only",
+      "IV1Y needs long-dated trades: it can start later, has gaps, and ranks from 60 prior sessions"] },
   options: [
     { key: "lookback", type: "enum", values: [{ value: "1Y" }, { value: "2Y" }, { value: "ALL" }], defaultValue: "1Y", description: "Visible history" },
     { key: "hvWindow", type: "enum", values: HV_WINDOWS.map((window) => ({ value: String(window) })), defaultValue: "20", description: "Realized volatility window in sessions" },
@@ -28,8 +30,10 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
     const model = projectIvHistory(payload, prices.history, { lookback: String(args.options.lookback) as IvLookback,
       hvWindow: (Number(args.options.hvWindow) === 30 ? 30 : 20) as HvWindow });
     const hvByDay = new Map(model.hv.map((point) => [point.date.getTime(), point.value]));
+    const iv365ByDay = new Map(model.iv365.map((point) => [point.date.getTime(), point.value]));
     const rows = model.iv30.map((point, index) => ({ date: point.date.toISOString().slice(0, 10), iv30: point.value,
       iv90: model.iv90.find((entry) => entry.date.getTime() === point.date.getTime())?.value ?? null,
+      iv365: iv365ByDay.get(point.date.getTime()) ?? null,
       hv: hvByDay.get(point.date.getTime()) ?? null, spread: model.spread[index]?.value ?? null })).reverse();
     const errors = [prices.error, ...model.warnings].filter((value): value is string => !!value);
     return {
@@ -45,11 +49,12 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
           { key: "samples", header: "Sessions" },
         ], rows: model.stats.map((row) => ({ ...row })) },
         { title: "Daily history", columns: [{ key: "date", header: "Session" },
-          ...["iv30", "iv90", "hv"].map((key) => ({ key, header: key.toUpperCase(), format: percent })),
+          ...[["iv30", "IV30"], ["iv90", "IV90"], ["iv365", "IV1Y"], ["hv", "HV"]].map(([key, header]) => ({ key: key!, header: header!, format: percent })),
           { key: "spread", header: "IV-HV", format: (value: unknown) => typeof value === "number" ? formatPoints(value) : "--" }], rows },
       ],
       complete: payload.status === "ready" && errors.length === 0,
       unavailableSymbols: model.iv30.length ? [] : [instrument.symbol], errors,
+      ...(model.oneYearNote ? { notes: [model.oneYearNote] } : {}),
       metadata: { status: payload.status, coverage: payload.coverage, latest: payload.latest, stats: payload.stats,
         unit: "decimal annualized volatility", methodology: METHODOLOGY },
     };
@@ -58,8 +63,10 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
 
 export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
-  freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily" },
+  // Dated by the readings themselves; the response's own date is the day it was fetched.
+  freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily", observedKey: "date" },
   argument: { kind: "symbol-list", optional: true, maximum: VCA_LIMIT, description: "US option underlyings; defaults to index and sector ETFs." },
+  usListingsOnly: "Implied volatility",
   options: [{ key: "preset", type: "enum", values: [{ value: "etfs" }, { value: "megacaps" }], defaultValue: "etfs", description: "Preset when no symbols are given" }],
   describe: "Volatility rich/cheap",
   discovery: { aliases: ["VCA"], screenshotReadiness: "live-dom", dataRequirements: ["Cloud stored implied volatility", "Daily price history"],
@@ -72,25 +79,33 @@ export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
       loadRealizedVolatilities(universe.instruments, 20, { signal: ctx.signal }, createHvDependencies(ctx.marketData)),
     ]);
     const rows = projectRichCheap(payload.rows, hv).sort((a, b) => (b.percentile ?? -1) - (a.percentile ?? -1));
-    const queued = rows.filter((row) => row.status === "queued").map((row) => row.symbol);
-    const shared = sharedReading(rows);
+    const coverage = screenCoverage(rows);
+    const dates = richCheapDates(rows);
     const hasSkew = rows.some((row) => row.skew != null);
+    const hasIv1y = rows.some((row) => row.iv1y != null), hasIv1yRank = rows.some((row) => row.iv1yPercentile != null);
+    const dated = (value: unknown) => typeof value === "string" ? value : "--";
     return {
-      sections: [{ title: `Rich/cheap · ${universe.label}${shared ? ` · ${shared.date} ${shared.method === "quote-mid" ? "live" : "close"}` : ""}`, columns: [
+      sections: [{ title: ["Rich/cheap", universe.label, ...sharedDates(dates)].join(" · "), columns: [
         { key: "symbol", header: "Symbol" }, { key: "iv30", header: "IV30", format: percent },
-        ...(shared ? [] : [{ key: "date", header: "As of" }]),
+        ...(dates.reading ? [] : [{ key: "date", header: "As of", format: (value: unknown, row?: unknown) =>
+          typeof value === "string" ? readingLabel(value, (row as RichCheapRow).method) : "--" }]),
+        ...(dates.rankApart ? [{ key: "rankDate", header: "Rank as of", format: (value: unknown) => typeof value === "string" ? `${value} close` : "--" }] : []),
         { key: "rank", header: "IVR", format: (value: unknown) => formatRank(value as number | null) },
         { key: "percentile", header: "IVP", format: (value: unknown) => formatRank(value as number | null) },
         { key: "verdict", header: "Rich/Cheap", format: (value: unknown) => verdictLabel(value as never) },
+        ...(hasIv1y ? [{ key: "iv1y", header: "IV1Y", format: percent }] : []),
+        ...(hasIv1yRank ? [{ key: "iv1yPercentile", header: "IVP1Y", format: (value: unknown) => formatRank(value as number | null) }] : []),
         { key: "termSlope", header: "30-90", format: (value: unknown) => formatPoints(value as number | null) },
         ...(hasSkew ? [{ key: "skew", header: "25D skew", format: (value: unknown) => formatPoints(value as number | null) }] : []),
+        ...(hasSkew && dates.skewApart ? [{ key: "skewDate", header: "Skew as of", format: dated }] : []),
         { key: "hv", header: "HV20", format: percent },
         { key: "ivHv", header: "IV/HV", format: (value: unknown) => typeof value === "number" ? value.toFixed(2) : "--" },
       ], rows: rows.map((row) => ({ ...row })) }],
-      complete: !queued.length && !universe.error, unavailableSymbols: queued,
+      // A symbol with no options history is final; only history still to come leaves the screen incomplete.
+      complete: !coverage.pending.length && !universe.error, unavailableSymbols: coverage.missing,
       errors: [universe.error].filter((value): value is string => !!value),
-      ...(queued.length ? { notes: [`Queued for backfill: ${queued.join(", ")}.`] } : {}),
-      metadata: { asOf: payload.asOf, presets: VCA_PRESETS, methodology: METHODOLOGY },
+      notes: [...coverage.notes, ...VCA_DEFINITIONS],
+      metadata: { presets: VCA_PRESETS, methodology: METHODOLOGY },
     };
   },
 };

package/src/plugins/builtin/iv-history/index.tsx

@@ -1,4 +1,5 @@
 import type { PluginModule } from "../plugin-module";
+import { IV_SERIES } from "./series";
 import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { ivHistoryHeadless, ivScreenHeadless } from "./headless";
 import { IvHistoryPane } from "./pane";
@@ -6,6 +7,7 @@ import { IvScreenPane, VCA_SCOPE_OPTIONS } from "./screen-pane";
 
 
 export const ivHistoryModule: PluginModule = {
+  series: IV_SERIES,
   panes: [{
     id: "iv-history", name: "Implied Volatility History", icon: "V", component: IvHistoryPane,
     defaultPosition: "right", tickerFollower: true, defaultMode: "floating", defaultFloatingSize: { width: 118, height: 36 },
@@ -26,12 +28,12 @@ export const ivHistoryModule: PluginModule = {
   paneTemplates: [
     { ...createTickerSurfacePaneTemplate({
       id: "iv-history-pane", paneId: "iv-history", label: "Implied Volatility History",
-      description: "30 and 90-day ATM implied volatility since 2024 against realized, with IV rank and percentile.",
-      keywords: ["hivg", "implied", "volatility", "history", "iv rank", "ivr", "percentile", "vrp"], shortcut: "HIVG", publicShare: true,
+      description: "30-day, 90-day and one-year ATM implied volatility since 2024 against realized, with IV rank and percentile.",
+      keywords: ["hivg", "implied", "volatility", "history", "iv rank", "ivr", "percentile", "vrp", "iv1y", "leaps"], shortcut: "HIVG", publicShare: true,
     }), headless: ivHistoryHeadless },
     {
       id: "iv-screen-pane", paneId: "iv-screen", label: "Volatility Rich/Cheap",
-      description: "IV rank, percentile, term slope, skew and IV/HV across a list, ranked rich to cheap.",
+      description: "IV rank, percentile, one-year IV, term slope, skew and IV/HV across a list, ranked rich to cheap.",
       keywords: ["vca", "rich", "cheap", "iv rank", "implied volatility", "screen"],
       shortcut: { prefix: "VCA", argKind: "ticker-list" as const, argOptional: true }, headless: ivScreenHeadless,
       createInstance: (_context, options) => ({