gloomberb 0.15.7 → 0.16.0

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

@@ -0,0 +1,226 @@
+import type { DataTableColumn } from "../../../components";
+import { displayWidth, formatCompact, formatCurrency } from "../../../utils/format";
+import { isAmendedInsiderFiling } from "./amendments";
+import { insiderSecurityTag, insiderTypeLabel, insiderTypeTone, isOpenMarketTrade, type InsiderTypeTone } from "./display";
+import {
+  insiderDisplayName,
+  insiderRole,
+  insiderTransactionId,
+  isInsiderDisclosureOnly,
+  type ParsedInsiderFiling,
+} from "./model";
+
+export type InsiderColumnId = "date" | "insider" | "role" | "type" | "security" | "shares" | "price" | "value";
+
+export interface InsiderColumn extends DataTableColumn {
+  id: InsiderColumnId;
+  /** The type column has room for the 10b5-1 marker. */
+  plan?: boolean;
+}
+
+/** One table row: a Form 4 line, or a filing without one (loading, unread, a disclosure). */
+export interface InsiderTableRow {
+  id: string;
+  entry: ParsedInsiderFiling;
+  date: Date | null;
+  name: string;
+  role: string;
+  type: string;
+  tone: InsiderTypeTone;
+  /** An amended filing (Form 4/A), marked after the type at every width. */
+  amended: boolean;
+  /** An open-market trade on a form with the Rule 10b5-1 box checked, marked after the type when there is room. */
+  plan: boolean;
+  security: string | null;
+  shares: number | null;
+  price: number | null;
+  value: number | null;
+}
+
+function validDate(value: Date | string | number | null | undefined): Date | null {
+  if (value == null) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isFinite(date.getTime()) ? date : null;
+}
+
+/** Joint filers (a fund and its general partners) read as the first one and how many more. */
+function tableName(entry: ParsedInsiderFiling): string | null {
+  const name = insiderDisplayName(entry);
+  const owners = name?.split("; ") ?? [];
+  return owners.length > 1 ? `${owners[0]} +${owners.length - 1}` : name;
+}
+
+export function buildInsiderTableRows(parsed: readonly ParsedInsiderFiling[]): InsiderTableRow[] {
+  return parsed.map((entry) => {
+    const { filing, transaction } = entry;
+    const amendment = isAmendedInsiderFiling(entry);
+    const name = tableName(entry);
+    if (!transaction) {
+      const disclosure = !entry.isLoading && isInsiderDisclosureOnly(entry);
+      return {
+        id: insiderTransactionId(entry),
+        entry,
+        date: validDate(filing.filingDate),
+        name: name ?? (entry.isLoading ? "Loading..." : "Unknown filer"),
+        role: insiderRole(entry),
+        type: entry.isLoading ? "" : disclosure ? "NOTICE" : "—",
+        tone: "neutral",
+        amended: amendment,
+        plan: false,
+        security: null,
+        shares: null,
+        price: null,
+        value: null,
+      };
+    }
+    return {
+      id: insiderTransactionId(entry),
+      entry,
+      date: validDate(transaction.filingDate ?? filing.filingDate),
+      name: name ?? "Unknown filer",
+      role: insiderRole(entry),
+      type: insiderTypeLabel(transaction.transactionType),
+      tone: insiderTypeTone(transaction.transactionType),
+      amended: amendment,
+      // The box covers the whole form; it is about the trade, not the vesting or tax lines beside it.
+      plan: transaction.rule10b51 === true && isOpenMarketTrade(transaction.transactionType),
+      security: insiderSecurityTag(transaction),
+      shares: transaction.shares,
+      price: transaction.pricePerShare,
+      value: transaction.totalValue,
+    };
+  });
+}
+
+/** A transaction date as m/d/yy, read in UTC because it names a calendar day. */
+export function formatInsiderDate(date: Date | null): string {
+  if (!date) return "—";
+  return `${date.getUTCMonth() + 1}/${date.getUTCDate()}/${String(date.getUTCFullYear()).slice(-2)}`;
+}
+
+export function formatInsiderShares(value: number | null): string {
+  return value == null ? "—" : formatCompact(value);
+}
+
+export function formatInsiderPrice(value: number | null): string {
+  return value == null ? "—" : formatCurrency(value);
+}
+
+export function formatInsiderValue(value: number | null): string {
+  return value == null ? "—" : `$${formatCompact(value)}`;
+}
+
+/** The quieter words after the type: "4/A" always, "10b5-1" when the column has room. */
+export function insiderTypeMarkers(row: InsiderTableRow, plan: boolean): string[] {
+  return [...(row.amended ? ["4/A"] : []), ...(plan && row.plan ? ["10b5-1"] : [])];
+}
+
+export function insiderTypeText(row: InsiderTableRow, plan: boolean): string {
+  return [row.type, ...insiderTypeMarkers(row, plan)].filter(Boolean).join(" ");
+}
+
+/** Cells left and right of the columns, and between two of them. */
+const TABLE_PADDING = 2;
+const COLUMN_GAP = 1;
+/** The kit widens a column to fit its header plus the sort arrow. */
+const HEADER_EXTRA = 2;
+
+function fitWidth(texts: readonly string[], label: string, max: number): number {
+  const widest = texts.reduce((width, text) => Math.max(width, displayWidth(text)), 0);
+  return Math.max(displayWidth(label) + HEADER_EXTRA, Math.min(max, widest));
+}
+
+/**
+ * The columns that fit `width` terminal cells (the desktop passes its width
+ * in the same cells). Every column takes the width its widest value needs.
+ * 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.
+ */
+export function buildInsiderColumns(width: number, rows: readonly InsiderTableRow[]): InsiderColumn[] {
+  const anyPlan = rows.some((row) => row.plan);
+  const anySecurity = rows.some((row) => row.security);
+  const names = rows.map((row) => row.name);
+  const widths = {
+    date: fitWidth(rows.map((row) => formatInsiderDate(row.date)), "Date", 8),
+    insider: fitWidth(names, "Insider", 28),
+    role: fitWidth(rows.map((row) => row.role), "Role", 12),
+    typeBase: fitWidth(rows.map((row) => insiderTypeText(row, false)), "Type", 12),
+    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),
+  };
+  const show = { role: true, price: true, plan: anyPlan, security: anySecurity, shares: true };
+  let insider = widths.insider;
+  const available = Math.max(0, Math.floor(width) - TABLE_PADDING);
+  const total = () => [
+    widths.date,
+    insider,
+    show.role ? widths.role : 0,
+    show.plan ? widths.typePlan : widths.typeBase,
+    show.security ? widths.security : 0,
+    show.shares ? widths.shares : 0,
+    show.price ? widths.price : 0,
+    widths.value,
+  ].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));
+  };
+  shrinkInsider(16);
+  for (const drop of ["role", "price", "plan", "security", "shares"] as const) {
+    if (total() <= available) break;
+    show[drop] = false;
+    shrinkInsider(16);
+  }
+  shrinkInsider(6);
+  // A dropped column can leave room for more of the names.
+  insider = Math.min(widths.insider, insider + Math.max(0, available - total()));
+
+  const typeWidth = show.plan ? widths.typePlan : widths.typeBase;
+  const columns: InsiderColumn[] = [
+    { id: "date", label: "Date", width: widths.date, align: "left" },
+    { id: "insider", label: "Insider", width: insider, align: "left" },
+    ...(show.role ? [{ id: "role" as const, label: "Role", width: widths.role, align: "left" as const }] : []),
+    { 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" },
+  ];
+  // Spare cells spread over the columns, so the value 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);
+  const each = Math.floor(spare / columns.length);
+  return columns.map((column) => ({
+    ...column,
+    width: column.width + each + (column.id === "insider" ? spare - each * columns.length : 0),
+  }));
+}
+
+function compareNullable(a: number | null, b: number | null): number {
+  if (a == null && b == null) return 0;
+  if (a == null) return 1;
+  if (b == null) return -1;
+  return a - b;
+}
+
+function compareText(a: string, b: string): number {
+  return a.localeCompare(b, "en-US", { sensitivity: "base" });
+}
+
+export function compareInsiderRows(a: InsiderTableRow, b: InsiderTableRow, columnId: InsiderColumnId): number {
+  switch (columnId) {
+    case "date": return compareNullable(a.date?.getTime() ?? null, b.date?.getTime() ?? null);
+    case "insider": return compareText(a.name, b.name);
+    case "role": return compareText(a.role, b.role);
+    case "type": return compareText(a.type, b.type);
+    case "security": return compareText(a.security ?? "", b.security ?? "");
+    case "shares": return compareNullable(a.shares, b.shares);
+    case "price": return compareNullable(a.price, b.price);
+    case "value": return compareNullable(a.value, b.value);
+  }
+}

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

@@ -0,0 +1,79 @@
+import { Box, Text } from "../../../ui";
+import type { DataTableCell } from "../../../components";
+import { colors } from "../../../theme/colors";
+import { blendForContrast } from "../../../theme/color-utils";
+import { clipToDisplayWidth, displayWidth } from "../../../utils/format";
+import type { InsiderTypeTone } from "./display";
+import {
+  formatInsiderDate,
+  formatInsiderPrice,
+  formatInsiderShares,
+  formatInsiderValue,
+  insiderTypeMarkers,
+  insiderTypeText,
+  type InsiderColumn,
+  type InsiderTableRow,
+} from "./table-model";
+
+/** The contrast a buy or sell keeps against the selected row. */
+const SELECTED_TONE_MIN_CONTRAST = 3.6;
+
+/** The theme's gain and loss colours, as every pane draws a buy and a sale. */
+export function insiderToneColor(tone: InsiderTypeTone): string {
+  return tone === "buy" ? colors.positive : tone === "sell" ? colors.negative : colors.textDim;
+}
+
+function typeColor(tone: InsiderTypeTone, selected: boolean): string {
+  if (tone === "neutral") return selected ? colors.selectedText : colors.textDim;
+  const color = insiderToneColor(tone);
+  return selected ? blendForContrast(color, colors.selected, colors.selectedText, SELECTED_TONE_MIN_CONTRAST) : color;
+}
+
+function isoDay(date: Date | null): string | null {
+  return date ? date.toISOString().slice(0, 10) : null;
+}
+
+export function renderInsiderCell(
+  row: InsiderTableRow,
+  column: InsiderColumn,
+  _index: number,
+  rowState: { selected: boolean },
+): DataTableCell {
+  // Awards, exercises and tax lines are context; buys and sales carry the figures.
+  const figureColor = row.tone === "neutral" ? colors.textDim : colors.text;
+  switch (column.id) {
+    case "date":
+      return { text: formatInsiderDate(row.date), value: isoDay(row.date), color: colors.textDim };
+    case "insider":
+      return { text: row.name, color: row.entry.isLoading ? colors.textDim : colors.text };
+    case "role":
+      return { text: row.role, color: colors.textMuted };
+    case "type": {
+      const color = typeColor(row.tone, rowState.selected);
+      const text = insiderTypeText(row, column.plan === true);
+      const markers = insiderTypeMarkers(row, column.plan === true);
+      if (markers.length === 0) return { text, color, keepColorWhenSelected: true };
+      // The markers read after the type in a quieter colour.
+      const markerColor = rowState.selected ? colors.selectedText : colors.textMuted;
+      const label = clipToDisplayWidth(row.type, column.width);
+      const room = Math.max(0, column.width - displayWidth(label) - (label ? 1 : 0));
+      return {
+        text,
+        content: (
+          <Box flexDirection="row" width={column.width} overflow="hidden">
+            {label ? <Text fg={color}>{label}</Text> : null}
+            {room > 0 ? <Text fg={markerColor}>{`${label ? " " : ""}${clipToDisplayWidth(markers.join(" "), room)}`}</Text> : null}
+          </Box>
+        ),
+      };
+    }
+    case "security":
+      return { text: row.security ?? "", value: row.entry.transaction?.securityTitle || null, color: colors.textMuted };
+    case "shares":
+      return { text: formatInsiderShares(row.shares), value: row.shares, color: figureColor };
+    case "price":
+      return { text: formatInsiderPrice(row.price), value: row.price, color: figureColor };
+    case "value":
+      return { text: formatInsiderValue(row.value), value: row.value, color: figureColor };
+  }
+}

package/src/plugins/builtin/iv-history/screen-pane.tsx

@@ -35,7 +35,7 @@ export function IvScreenPane({ width, height, focused }: PaneProps) {
   const { collectionId } = usePaneCollection();
   const tickers = useTickers();
   const { createPaneFromTemplate } = usePluginAppActions();
-  const universe = useMemo(() => vcaUniverse(scope, symbolsText, collectionId, Object.values(tickers)), [scope, symbolsText, collectionId, tickers]);
+  const universe = useMemo(() => vcaUniverse(scope, symbolsText, collectionId, [...tickers.values()]), [scope, symbolsText, collectionId, tickers]);
   const key = universe.instruments.map((instrument) => instrument.symbol).join(",");
   const controller = useRef<AbortController | null>(null);
   const [hv, setHv] = useState<Map<string, number | null>>(new Map());

package/src/plugins/builtin/jobs/pane.tsx

@@ -70,6 +70,7 @@ import {
 } from "./model";
 import { ShareBars } from "./share-bars";
 import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
+import { listingIdentity } from "../shared/ticker-request";
 
 export const JOBS_PANE_ID = "jobs";
 
@@ -79,9 +80,11 @@ const MOVERS_PAGE = 200;
 
 type DetailTab = "roles" | "locations" | "seniority" | "salary";
 
-function HiringProWall({ symbol }: { symbol: string | null }) {
+function HiringProWall({ symbol, exchange, width, height }: { symbol: string | null; exchange?: string; width: number; height: number }) {
   return (
     <ProWall
+      placement="jobs-wall"
+      symbol={symbol} exchange={exchange} width={width} height={height}
       title="Hiring data is part of Gloom Cloud Pro."
       message={`Gloomberb reads every listed company's own careers system daily: open roles over time, hiring by function and location, new roles, and pay ranges.${symbol ? ` Open ${symbol}'s hiring picture with Pro.` : ""}`}
     />
@@ -511,6 +514,7 @@ function CompanyView({
  */
 function CompanyPanel({
   symbol,
+  exchange = "US",
   companyName,
   width,
   height,
@@ -519,6 +523,7 @@ function CompanyPanel({
   embedded = false,
 }: {
   symbol: string;
+  exchange?: string;
   companyName: string | null;
   width: number;
   height: number;
@@ -544,8 +549,8 @@ function CompanyPanel({
   }, [data, reload]);
 
   if (data?.kind === "denied") {
-    if (data.status === 402) return <HiringProWall symbol={symbol} />;
-    return <SignInWall action="see who is hiring" needsVerification={data.status === 403} />;
+    if (data.status === 402) return <HiringProWall symbol={symbol} exchange={exchange} width={width} height={height} />;
+    return <SignInWall placement="jobs-detail-signin" width={width} height={height} symbol={symbol} exchange={exchange} action="see who is hiring" needsVerification={data.status === 403} />;
   }
   if ((status === "idle" || status === "loading") && !data) {
     return <PaneStatusBody loading align="center" loadingLabel={`Loading ${symbol} hiring...`} />;
@@ -733,15 +738,16 @@ interface JobsViewProps {
 }
 
 function JobsView({ width, height, focused, companyOnly = false }: JobsViewProps) {
-  const { ticker } = usePaneTickerIdentity();
+  const { ticker, symbol: boundSymbol } = usePaneTickerIdentity();
   const symbol = ticker?.metadata.ticker ?? null;
+  const exchange = listingIdentity(boundSymbol, ticker?.metadata.exchange)?.exchange;
   const companyName = ticker?.metadata.name ?? null;
   const access = usePlanAccess();
   const registrationId = JOBS_PANE_ID;
 
-  if (!access.signedIn) return <SignInWall action="see who is hiring" />;
-  if (!access.emailVerified) return <SignInWall action="see who is hiring" needsVerification />;
-  if (!access.hasProAccess) return <HiringProWall symbol={symbol} />;
+  if (!access.signedIn) return <SignInWall placement="jobs-signin" width={width} height={height} symbol={symbol} exchange={exchange} action="see who is hiring" />;
+  if (!access.emailVerified) return <SignInWall placement="jobs-signin" width={width} height={height} symbol={symbol} exchange={exchange} action="see who is hiring" needsVerification />;
+  if (!access.hasProAccess) return <HiringProWall symbol={symbol} exchange={exchange} width={width} height={height} />;
 
   if (!symbol) {
     if (companyOnly) return <EmptyState title="No ticker selected." message="Select a ticker to see its hiring." />;
@@ -750,6 +756,7 @@ function JobsView({ width, height, focused, companyOnly = false }: JobsViewProps
   return (
     <CompanyPanel
       symbol={symbol}
+      exchange={exchange}
       companyName={companyName}
       width={width}
       height={height}

package/src/plugins/builtin/kelly-sizer/pane.tsx

@@ -449,7 +449,7 @@ export function KellySizerPane({ focused, width, height }: PaneProps) {
   const bodyRows = Math.max(0, height - 1 - tabRows - gridRows - resultRows);
   const chartHeight = showSensitivity ? 0 : bodyRows;
   const showChart = !showSensitivity && chartHeight >= 6 && curvePoints.length > 0;
-  const quoteCurrency = positionFinancials?.quote?.currency ?? ticker?.metadata.currency ?? config.baseCurrency;
+  const quoteCurrency = positionFinancials?.quote?.currency || ticker?.metadata.currency || config.baseCurrency;
   // The search shows the ticker and the Portfolio filter the account, so the
   // context is the price first, then the account only when there is no filter.
   const meta = [

package/src/plugins/builtin/macro-day/client.ts

@@ -0,0 +1,50 @@
+import { getSharedMarketDataCoordinator, MarketDataCoordinator, resolveEntryValue } from "../../../market-data/coordinator";
+import type { InstrumentRef } from "../../../market-data/request-types";
+import { tickerHasListingSuffix } from "../../../sources/listing-symbols";
+import type { DataProvider } from "../../../types/data-provider";
+import type { PricePoint } from "../../../types/financials";
+import { abortable, abortError } from "../../../utils/async-deadline";
+import { errorMessage } from "../../../utils/errors";
+import { resolveExchangeTimeZone } from "../../../utils/exchanges";
+
+export interface MacroDayHistory {
+  history: PricePoint[];
+  stale: boolean;
+  error: string | null;
+  fetchedAt: number;
+}
+
+const CANCELLED = "Macro-day history load was cancelled";
+const US_LISTINGS_ONLY = "Macro-day moves are for US listings.";
+
+/**
+ * A listing whose venue sits outside New York trades US releases on a different clock.
+ * A bare symbol such as 7203.T carries no exchange, so its venue suffix names it.
+ */
+function isNonUsVenue(instrument: InstrumentRef): boolean {
+  if (tickerHasListingSuffix(instrument.symbol)) return true;
+  const zone = resolveExchangeTimeZone(instrument.exchange);
+  return !!zone && zone !== "America/New_York";
+}
+
+/** Five years of daily closes, the longest daily history served; the lookback is cut in the model. */
+export async function loadMacroDayHistory(
+  request: { instrument: InstrumentRef; signal?: AbortSignal; forceRefresh?: boolean },
+  marketData?: DataProvider,
+): Promise<MacroDayHistory> {
+  if (request.signal?.aborted) throw abortError(CANCELLED);
+  const now = Date.now();
+  if (isNonUsVenue(request.instrument)) return { history: [], stale: false, error: US_LISTINGS_ONLY, fetchedAt: now };
+  const coordinator = marketData ? new MarketDataCoordinator(marketData) : getSharedMarketDataCoordinator();
+  try {
+    if (!coordinator) throw new Error("Market data coordinator unavailable");
+    const entry = await abortable(coordinator.loadChart({ instrument: request.instrument, bufferRange: "5Y",
+      granularity: "resolution", resolution: "1d" }, { forceRefresh: request.forceRefresh }), request.signal, CANCELLED);
+    const history = resolveEntryValue(entry) ?? [];
+    return { history, stale: !!entry.error || (entry.staleAt != null && entry.staleAt <= now),
+      error: entry.error?.message ?? (history.length ? null : "Daily price history unavailable"), fetchedAt: entry.fetchedAt ?? now };
+  } catch (error) {
+    if (request.signal?.aborted || (error instanceof Error && error.name === "AbortError")) throw abortError(CANCELLED);
+    return { history: [], stale: false, error: errorMessage(error), fetchedAt: now };
+  }
+}

package/src/plugins/builtin/macro-day/headless.ts

@@ -0,0 +1,51 @@
+import type { HeadlessPaneDefinition } from "../../../types/plugin";
+import { resolveHeadlessInstrument } from "../shared/headless-market-data";
+import { loadMacroDayHistory } from "./client";
+import { projectMacroDays, type MacroDayStats } from "./model";
+import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_RELEASE_BASIS } from "./releases";
+
+// A mean that rounds to zero reads 0.00%, never -0.00%.
+const percent = (value: unknown) => typeof value !== "number" ? "--" : /[1-9]/.test((value * 100).toFixed(2)) ? `${(value * 100).toFixed(2)}%` : "0.00%";
+const multiple = (value: unknown) => typeof value === "number" ? `${value.toFixed(2)}x` : "--";
+const share = (value: unknown) => typeof value === "number" ? `${Math.round(value * 100)}%` : "--";
+
+export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
+  shape: "bundle", argument: { kind: "ticker", description: "Ticker" },
+  describe: (args) => `MDAY ${args.symbols[0] ?? ""}`,
+  discovery: { screenshotReadiness: "live-dom", limitations: [
+    "US listings; close-to-close on the release day.",
+    `Published CPI, jobs and FOMC days through ${MACRO_RELEASE_BASIS.coveredThrough}.`,
+  ] },
+  options: [
+    { key: "release", type: "enum", values: [{ value: "all" }, ...MACRO_EVENT_KINDS.map((value) => ({ value }))], defaultValue: "all",
+      description: "Release the pane lists", pluginState: { pluginId: "ticker-research", key: "release" } },
+    { key: "lookbackYears", type: "integer", minimum: 1, maximum: 5, defaultValue: 5, description: "Years of daily closes" },
+  ],
+  async load(args, ctx) {
+    const instrument = await resolveHeadlessInstrument(ctx, args.symbols[0]!);
+    const history = await loadMacroDayHistory({ instrument, signal: ctx.signal }, ctx.marketData);
+    ctx.signal.throwIfAborted();
+    const model = projectMacroDays(history.history, { symbol: instrument.symbol, lookbackYears: Number(args.options.lookbackYears) || 5 });
+    const row = (label: string, stats: MacroDayStats) => ({ label, ...stats });
+    const release = String(args.options.release ?? "all");
+    const events = release === "all" ? model.events : model.events.filter((event) => event.kind === release);
+    return {
+      sections: [
+        { title: "By release", columns: [{ key: "label", header: "Day" }, { key: "count", header: "Days" },
+          { key: "meanAbs", header: "Avg |move|", format: percent }, { key: "multiple", header: "vs normal", format: multiple },
+          { key: "mean", header: "Avg move", format: percent }, { key: "hitRate", header: "Up", format: share }],
+        rows: [...MACRO_EVENT_KINDS.map((kind) => row(MACRO_EVENT_LABELS[kind], model.byKind[kind])),
+          row("Any release", model.allEvents), row("Normal day", model.normal)] },
+        { title: "Release days", columns: [{ key: "date", header: "Date" }, { key: "event", header: "Release" },
+          { key: "session", header: "Session" }, { key: "move", header: "Move", format: percent }, { key: "multiple", header: "vs normal", format: multiple }],
+        rows: events.map((event) => ({ ...event, event: MACRO_EVENT_LABELS[event.kind] })) },
+      ],
+      complete: !history.stale && !history.error && model.events.length > 0,
+      unavailableSymbols: model.events.length ? [] : [instrument.symbol],
+      errors: history.error ? [history.error] : [],
+      metadata: { unit: "decimal return, close to close on the release day", start: model.start, asOf: model.asOf,
+        releasesThrough: MACRO_RELEASE_BASIS.coveredThrough, releaseSources: MACRO_RELEASE_BASIS.sources,
+        stale: history.stale, fetchedAt: history.fetchedAt, methodology: "docs/research-data.md#macro-day-reaction" },
+    };
+  },
+};

package/src/plugins/builtin/macro-day/index.tsx

@@ -0,0 +1,21 @@
+import type { PluginModule } from "../plugin-module";
+import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
+import { macroDayHeadless } from "./headless";
+import { LOOKBACK_OPTIONS, MacroDayPane } from "./pane";
+
+export const macroDayModule: PluginModule = {
+  panes: [{
+    id: "macro-day", name: "Macro-Day Reaction", icon: "M", component: MacroDayPane,
+    defaultPosition: "right", tickerFollower: true, defaultMode: "floating", defaultFloatingSize: { width: 76, height: 26 },
+    tableExport: true,
+    settings: { title: "Macro-Day Reaction Settings", fields: [
+      { key: "lookbackYears", label: "Lookback", type: "select", options: LOOKBACK_OPTIONS },
+    ] },
+  }],
+  paneTemplates: [{ ...createTickerSurfacePaneTemplate({
+    id: "macro-day-pane", paneId: "macro-day", label: "Macro-Day Reaction",
+    description: "How a name moves on CPI, jobs and FOMC days against a normal day: average move, direction, hit rate and every release day.",
+    keywords: ["mday", "macro day", "cpi day", "fomc day", "jobs day", "nfp", "payrolls", "event study", "release reaction"],
+    shortcut: "MDAY", publicShare: true,
+  }), headless: macroDayHeadless }],
+};

package/src/plugins/builtin/macro-day/model.ts

@@ -0,0 +1,137 @@
+import type { PricePoint } from "../../../types/financials";
+import { zonedDateTimeParts } from "../../../utils/zoned-date-time";
+import { MACRO_EVENT_KINDS, MACRO_RELEASE_BASIS, macroReleases, type MacroEventKind, type MacroRelease } from "./releases";
+
+const DAY_MS = 86_400_000;
+/** Longest calendar gap between two closes that is still one session apart: Thursday to Monday over a Friday holiday. */
+const MAX_SESSION_GAP_DAYS = 4;
+
+export interface MacroDayEvent {
+  kind: MacroEventKind;
+  /** Release day, New York date. */
+  date: string;
+  /** The session whose close carries the reaction: the release day, or the next session when the market was shut. */
+  session: string;
+  /** Close before the release to the session's close. */
+  move: number;
+  /** |move| over the normal day's average |move|. */
+  multiple: number | null;
+}
+
+export interface MacroDayStats {
+  count: number;
+  meanAbs: number | null;
+  mean: number | null;
+  /** Share of days that closed up. */
+  hitRate: number | null;
+  /** meanAbs over the normal day's. */
+  multiple: number | null;
+}
+
+export interface MacroDayModel {
+  symbol: string;
+  /** Newest first. */
+  events: MacroDayEvent[];
+  byKind: Record<MacroEventKind, MacroDayStats>;
+  /** Every release day of the three kinds together; a day with two releases counts once. */
+  allEvents: MacroDayStats;
+  /** Sessions with no release of the three kinds. */
+  normal: MacroDayStats;
+  start: string | null;
+  asOf: string | null;
+}
+
+/** Daily labels at UTC midnight name that date; any other stamp reads in New York. */
+function sessionDate(time: number): string {
+  if (time % DAY_MS === 0) return new Date(time).toISOString().slice(0, 10);
+  const { year, month, day } = zonedDateTimeParts(time, "America/New_York");
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+
+const dayNumber = (date: string) => Date.parse(`${date}T00:00:00Z`) / DAY_MS;
+const isWeekday = (date: string) => { const day = new Date(`${date}T00:00:00Z`).getUTCDay(); return day > 0 && day < 6; };
+
+function stats(moves: number[], normalAbs: number | null): MacroDayStats {
+  if (!moves.length) return { count: 0, meanAbs: null, mean: null, hitRate: null, multiple: null };
+  const meanAbs = moves.reduce((sum, move) => sum + Math.abs(move), 0) / moves.length;
+  return { count: moves.length, meanAbs, mean: moves.reduce((sum, move) => sum + move, 0) / moves.length,
+    hitRate: moves.filter((move) => move > 0).length / moves.length,
+    multiple: normalAbs ? meanAbs / normalAbs : null };
+}
+
+/**
+ * Close to close on the release day: 8:30 ET releases land before the open
+ * and 14:00 FOMC statements before the close, so the release day's close
+ * carries either. A release on a weekday the market was shut (Good Friday)
+ * is read on the next session, from the close before the release. A release
+ * whose close-to-close would span a gap in the history is left out rather
+ * than read across it. A lone missing bar on the release day itself cannot
+ * be told from a holiday and is read on the next session.
+ */
+export function projectMacroDays(history: readonly PricePoint[], options: {
+  symbol: string;
+  lookbackYears: number;
+  releases?: readonly MacroRelease[];
+  coveredThrough?: string;
+}): MacroDayModel {
+  const coveredThrough = options.coveredThrough ?? MACRO_RELEASE_BASIS.coveredThrough;
+  const byDate = new Map<string, number>();
+  for (const point of history) {
+    const time = new Date(point.date).getTime();
+    if (!Number.isFinite(time) || !Number.isFinite(point.close) || point.close <= 0) continue;
+    byDate.set(sessionDate(time), point.close);
+  }
+  const sessions = [...byDate.keys()].sort();
+  const last = sessions.at(-1) ?? null;
+  const empty = (): MacroDayStats => stats([], null);
+  if (!last) return { symbol: options.symbol, events: [], byKind: { cpi: empty(), jobs: empty(), fomc: empty() },
+    allEvents: empty(), normal: empty(), start: null, asOf: null };
+
+  // Sessions after the published lists end may be unlisted release days, so they are left out of both sides.
+  const end = last < coveredThrough ? last : coveredThrough;
+  const startYear = Number(end.slice(0, 4)) - Math.max(1, options.lookbackYears);
+  const start = `${startYear}${end.slice(4)}`;
+  /** Session date -> close-to-close move from the session before, when the two are one session apart. */
+  const moves = new Map<string, number>();
+  for (let index = 1; index < sessions.length; index++) {
+    const date = sessions[index]!, previous = sessions[index - 1]!;
+    if (date <= start || date > end || dayNumber(date) - dayNumber(previous) > MAX_SESSION_GAP_DAYS) continue;
+    moves.set(date, byDate.get(date)! / byDate.get(previous)! - 1);
+  }
+
+  const reactionSessions = new Set<string>();
+  const found: Omit<MacroDayEvent, "multiple">[] = [];
+  for (const release of options.releases ?? macroReleases()) {
+    if (release.date <= start || release.date > end || !isWeekday(release.date)) continue;
+    const at = sessions.findIndex((date) => date >= release.date);
+    if (at < 1) continue;
+    const session = sessions[at]!;
+    const move = moves.get(session);
+    if (move == null || (session !== release.date && skipsAnotherWeekday(release.date, sessions[at - 1]!, session))) continue;
+    reactionSessions.add(session);
+    found.push({ kind: release.kind, date: release.date, session, move });
+  }
+
+  const normalMoves = [...moves].filter(([date]) => !reactionSessions.has(date)).map(([, move]) => move);
+  const normal = stats(normalMoves, null);
+  const normalAbs = normal.meanAbs;
+  const events = found.map((event) => ({ ...event, multiple: normalAbs ? Math.abs(event.move) / normalAbs : null }))
+    .sort((left, right) => right.date.localeCompare(left.date) || left.kind.localeCompare(right.kind));
+  const byKind = Object.fromEntries(MACRO_EVENT_KINDS.map((kind) =>
+    [kind, stats(events.filter((event) => event.kind === kind).map((event) => event.move), normalAbs)])) as Record<MacroEventKind, MacroDayStats>;
+  const allEvents = stats([...reactionSessions].map((session) => moves.get(session)!), normalAbs);
+  return { symbol: options.symbol, events, byKind, allEvents, normal, start, asOf: end };
+}
+
+/**
+ * A release weekday with no close of its own reads as a holiday only when the
+ * closes either side have nothing but it and a weekend between them; any other
+ * weekday between them is a gap in the data, and the move would span it.
+ */
+function skipsAnotherWeekday(release: string, previous: string, next: string): boolean {
+  for (let day = dayNumber(previous) + 1; day < dayNumber(next); day++) {
+    const date = new Date(day * DAY_MS).toISOString().slice(0, 10);
+    if (date !== release && isWeekday(date)) return true;
+  }
+  return false;
+}