gloomberb 0.17.6 → 0.18.0

package/src/plugins/builtin/alerts/cli.ts

@@ -4,16 +4,15 @@ import { dryRunNote } from "../../../cli/helpers";
 import { requireArg, takeOption } from "../../../cli/commands/command-utils";
 import { EXCHANGE_OPTION, listingReadNotes, requireListingArg, type ListingArg } from "../../../cli/listing-arg";
 import { saveConfig } from "../../../data/config/store";
-import type { AppConfig } from "../../../types/config";
 import type { CliCommandContext, CliCommandDef } from "../../../types/plugin";
 import { getActiveQuoteDisplay } from "../../../market-data/market/status";
 import { settleWithin } from "../../../utils/async-deadline";
 import { cliStyles } from "../../../utils/cli-output";
 import { ambiguousNumberMessage, meantThousandsDot, parsePastedNumber, thousandsDotReadings, type ThousandsDotReadings } from "../../../utils/decimal-comma";
 import { newYorkToday } from "../earnings/board-model";
-import { createAlert, deserializeAlerts, rearmAlert, serializeAlerts } from "./alert-engine";
-import { ALERTS_KEY } from "./constants";
-import { EVENT_ALERTS_KEY, MAX_EVENT_ALERTS, eventAlertTarget, readEventAlerts, toggleEventAlert, type EventAlertRule } from "./events";
+import { createAlert, rearmAlert, serializeAlerts } from "./alert-engine";
+import { ALERTS_KEY, ALERTS_PLUGIN_ID } from "./constants";
+import { EVENT_ALERTS_KEY, MAX_EVENT_ALERTS, eventAlertTarget, toggleEventAlert, type EventAlertRule } from "./events";
 import { alertKindLabel } from "./history";
 import { MAX_LEAD_DAYS, type MacroAlertEvent } from "./research-rules";
 import {
@@ -36,10 +35,9 @@ import {
   type ScheduledEventTarget,
 } from "./scheduled";
 import { scheduledEventSources } from "./scheduled-sources";
+import { readAlertStores } from "./storage";
 import type { AlertCondition, AlertRule } from "./types";
 
-const ALERTS_PLUGIN_ID = "alerts";
-
 const ADD_USAGE = "Usage: gloomberb alerts add <symbol> <above|below|crosses> <price>, alerts add <symbol> earnings [--days <n>], or alerts add <CPI|FOMC> [--days <n>]";
 const DAYS_RULE = `--days takes a whole number of days from 1 to ${MAX_LEAD_DAYS}; without it the alert goes off 1 day before.`;
 
@@ -230,17 +228,6 @@ async function requireEventDate(
   return lookup.date;
 }
 
-function readAlertStores(config: AppConfig) {
-  const pluginState = config.pluginConfig[ALERTS_PLUGIN_ID] ?? {};
-  const rawPrice = pluginState[ALERTS_KEY];
-  const rawEvents = pluginState[EVENT_ALERTS_KEY];
-  return {
-    pluginState,
-    alerts: deserializeAlerts(typeof rawPrice === "string" ? rawPrice : "[]"),
-    events: readEventAlerts(typeof rawEvents === "string" ? rawEvents : "[]"),
-  };
-}
-
 export const alertsCliCommand: CliCommandDef = {
   name: "alerts",
   aliases: ["alert"],
@@ -385,10 +372,12 @@ export const alertsCliCommand: CliCommandDef = {
         await save({ events: [...rules, rule] });
         const eventDate = rule.eventDate!;
         const due = scheduledPhase(eventDate, scheduled.leadDays, undefined, today) === "due";
+        const delivery = scheduled.target.kind === "macro" ? ", only while it is running" : " while it is running, or on your phone with Cloud sync";
         ctx.printResult({ data: { changed: !ctx.cliOptions.dryRun, dryRun: ctx.cliOptions.dryRun, alert: rule }, ...(read.length > 0 ? { warnings: read } : {}) }, {
+          // Delivery, as docs/usage.md states it: CPI and FOMC notify in the running app only; earnings also reach the phone.
           text: (data) => `Added alert ${data.alert.id}: ${name} on ${eventDate}, ${plural(scheduled.leadDays, "day")} before (${due
             ? "already reached, so the app alerts at its next check"
-            : `the app alerts on ${leadStartDate(eventDate, scheduled.leadDays)}`}).${dryRunNote(data.dryRun)}`,
+            : `the app alerts on ${leadStartDate(eventDate, scheduled.leadDays)}`}${delivery}).${dryRunNote(data.dryRun)}`,
         });
         return;
       }

package/src/plugins/builtin/alerts/constants.ts

@@ -1,4 +1,12 @@
+export const ALERTS_PLUGIN_ID = "alerts";
 export const ALERTS_KEY = "alerts";
+
+/** The Alerts pane's tabs: what `ALRT --tab` takes, and the pane state `tab` holds. */
+export const ALERT_TABS = [
+  { label: "Prices", value: "prices" },
+  { label: "Events", value: "events" },
+  { label: "History", value: "history" },
+];
 /** Fallback cadence when the pane's Check interval setting is unset. */
 export const POLL_INTERVAL_MS = 30_000;
 export const POLL_SECONDS_KEY = "pollSeconds";

package/src/plugins/builtin/alerts/event-rows.ts

@@ -0,0 +1,16 @@
+import { eventAlertTarget, type EventAlertRule } from "./events";
+import { readScheduledRule, scheduledAlertStatus } from "./scheduled";
+
+/** Earnings and macro event rules name the event day they wait for; the rest name what they follow. */
+export function ruleTarget(rule: EventAlertRule): string {
+  const target = eventAlertTarget(rule);
+  if (!readScheduledRule(rule)) return target;
+  return `${target} · ${rule.eventDate ?? "date not known yet"}`;
+}
+
+/** The state word the Events tab shows: a scheduled rule is Alerted once it has gone off for its coming event. */
+export function ruleState(rule: EventAlertRule, today: string): "Active" | "Paused" | "Alerted" {
+  const scheduled = readScheduledRule(rule);
+  const status = scheduled ? scheduledAlertStatus(rule, scheduled.leadDays, today) : rule.status;
+  return status === "paused" ? "Paused" : status === "triggered" ? "Alerted" : "Active";
+}

package/src/plugins/builtin/alerts/events-pane.tsx

@@ -21,6 +21,7 @@ import {
   toggleEventAlert,
   type EventAlertRule,
 } from "./events";
+import { ruleState, ruleTarget } from "./event-rows";
 import { relativeTime } from "./format";
 import { alertKindLabel, fetchAlertHistory, ruleStateText } from "./history";
 import { isResearchAlertKind } from "./research-rules";
@@ -28,23 +29,10 @@ import { useAsyncResource } from "../../../public/react";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import { useResearchCloudSession } from "../shared/research-cloud-session";
 import { newYorkToday } from "../earnings/board-model";
-import { readScheduledRule, rearmScheduledAlert, scheduledAlertStatus } from "./scheduled";
+import { rearmScheduledAlert } from "./scheduled";
 import { checkScheduledEventAlertsNow } from "./scheduled-check";
 import { alertTarget, alertViewHints, eventRuleSubject, useOpenAlertTarget } from "./targets";
 
-/** Earnings and macro event rules name the event day they wait for; the rest name what they follow. */
-function ruleTarget(rule: EventAlertRule): string {
-  const target = eventAlertTarget(rule);
-  if (!readScheduledRule(rule)) return target;
-  return `${target} · ${rule.eventDate ?? "date not known yet"}`;
-}
-
-function ruleState(rule: EventAlertRule, today: string): "Active" | "Paused" | "Alerted" {
-  const scheduled = readScheduledRule(rule);
-  const status = scheduled ? scheduledAlertStatus(rule, scheduled.leadDays, today) : rule.status;
-  return status === "paused" ? "Paused" : status === "triggered" ? "Alerted" : "Active";
-}
-
 const columnsFor = (width: number, lastCheck: boolean): DataTableColumn[] => [
   { id: "kind", label: "Event", width: 15, align: "left" },
   { id: "target", label: "Following", width: 28, flexGrow: 1, align: "left" },

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

@@ -0,0 +1,182 @@
+/**
+ * `gloomberb fn ALRT`: the Alerts pane's three tabs as reports. Prices lists
+ * the price alerts as the pane's table does, Events the event alerts (earnings,
+ * CPI and FOMC with their dates, filings, news, market moves), History the
+ * alerts delivered to the account over the last 90 days.
+ */
+import type { HeadlessPaneColumn, HeadlessPaneContext, HeadlessPaneDefinition, HeadlessPaneRow, HeadlessRowsResult } from "../../../types/headless";
+import type { PaneLock } from "../../../types/plugin";
+import { newYorkToday } from "../earnings/board-model";
+import { explainRefusal } from "../shared/cloud-denied";
+import { ALERT_TABS, ALERTS_PLUGIN_ID } from "./constants";
+import { ruleState } from "./event-rows";
+import { eventAlertTarget, type EventAlertRule } from "./events";
+import {
+  conditionLabel,
+  formatAlertDistance,
+  formatAlertTargetPrice,
+  formatCurrentPrice,
+  formatQuoteChecked,
+  relativeTime,
+} from "./format";
+import { alertKindLabel, validateAlertHistory, type AlertHistory, type AlertHistoryItem } from "./history";
+import { readScheduledRule, scheduledEventName } from "./scheduled";
+import { readAlertStores } from "./storage";
+import type { AlertRule } from "./types";
+
+type AlertsTab = "prices" | "events" | "history";
+
+/** Pages of history one report reads; the pane reads more as it is scrolled. */
+const HISTORY_PAGES = 5;
+
+const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? "" : "s"}`;
+const asAlert = (row: HeadlessPaneRow) => row as unknown as AlertRule;
+const text = (value: unknown) => (typeof value === "string" && value ? value : "");
+
+/** The text report words each cell as the pane does; CSV and JSON keep the stored numbers and times. */
+const PRICE_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "status", header: "State", format: (value) => (value === "triggered" ? "Triggered" : "Active") },
+  { key: "symbol", header: "Symbol", format: (value, row) => (row.exchange ? `${text(value)}:${text(row.exchange)}` : text(value)) },
+  { key: "lastCheckedPrice", header: "Current", align: "right", textFormat: (_value, row) => formatCurrentPrice(asAlert(row), 14) },
+  { key: "targetPrice", header: "Target", align: "right", textFormat: (_value, row) => formatAlertTargetPrice(asAlert(row), 14) },
+  { key: "awayPercent", header: "Away", align: "right", textFormat: (_value, row) => formatAlertDistance(asAlert(row)) },
+  { key: "condition", header: "Trigger", format: (value) => conditionLabel(value as AlertRule["condition"]) },
+  { key: "lastCheckedAt", header: "Quote", textFormat: (_value, row) => formatQuoteChecked(asAlert(row)) },
+  { key: "triggeredAt", header: "Alerted", textFormat: (value) => (typeof value === "number" ? relativeTime(value) : "-") },
+];
+
+const EVENT_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "event", header: "Event" },
+  { key: "following", header: "Following" },
+  { key: "eventDate", header: "Event date", textFormat: (value, row) => text(value) || (row.leadDays == null ? "" : "not known yet") },
+  { key: "leadDays", header: "Days before", align: "right" },
+  { key: "state", header: "State" },
+  { key: "since", header: "Since" },
+];
+
+const HISTORY_COLUMNS: HeadlessPaneColumn[] = [
+  { key: "deliveredAt", header: "Sent (UTC)", format: (value) => text(value).slice(0, 16).replace("T", " ") },
+  { key: "event", header: "Event" },
+  { key: "title", header: "Alert" },
+  { key: "body", header: "Detail" },
+];
+
+/** A price alert as the Prices table lists it: the stored fields, without the quote's provider id, and the distance to target. */
+function priceRow(alert: AlertRule): HeadlessPaneRow {
+  const { lastQuoteProviderId: _provider, ...stored } = alert;
+  const price = alert.lastCheckError ? null : alert.lastCheckedPrice;
+  const away = price == null || !Number.isFinite(price) || price === 0 ? null : ((alert.targetPrice - price) / price) * 100;
+  return { ...stored, awayPercent: away != null && Number.isFinite(away) ? away : null };
+}
+
+/** Active alerts first, then the ones that went off, latest first, as the pane orders them. */
+function pricesResult(alerts: readonly AlertRule[], error: string | null, events: number): HeadlessRowsResult {
+  const active = alerts.filter((alert) => alert.status === "active");
+  const triggered = alerts.filter((alert) => alert.status === "triggered").sort((a, b) => (b.triggeredAt ?? 0) - (a.triggeredAt ?? 0));
+  return {
+    columns: PRICE_COLUMNS,
+    rows: [...active, ...triggered].map(priceRow),
+    empty: "No price alerts. Add one with gloomberb alerts add AAPL above 250.",
+    ...(error ? { errors: [error], complete: false } : {}),
+    ...(events > 0 ? { notes: [`${plural(events, "event alert")} not listed here: gloomberb fn ALRT --tab events`] } : {}),
+  };
+}
+
+/** An event alert as the Events table lists it: a scheduled one with its event date and lead time apart. */
+function eventRow(rule: EventAlertRule, today: string): HeadlessPaneRow {
+  const scheduled = readScheduledRule(rule);
+  return {
+    id: rule.id,
+    kind: rule.kind,
+    event: alertKindLabel(rule.kind),
+    following: scheduled ? scheduledEventName(scheduled.target) : eventAlertTarget(rule),
+    eventDate: scheduled ? rule.eventDate ?? null : null,
+    leadDays: scheduled?.leadDays ?? null,
+    state: ruleState(rule, today),
+    since: new Date(rule.createdAt).toISOString().slice(0, 10),
+  };
+}
+
+function eventsResult(rules: readonly EventAlertRule[], error: string | null): HeadlessRowsResult {
+  const today = newYorkToday();
+  return {
+    columns: EVENT_COLUMNS,
+    rows: [...rules].sort((a, b) => b.createdAt - a.createdAt).map((rule) => eventRow(rule, today)),
+    empty: "No event alerts. Add one with gloomberb alerts add CRWV earnings --days 3 or gloomberb alerts add CPI --days 1.",
+    ...(error ? { errors: [error], complete: false } : {}),
+  };
+}
+
+function historyRow(item: AlertHistoryItem): HeadlessPaneRow {
+  return { id: item.id, deliveredAt: item.deliveredAt, kind: item.kind, event: alertKindLabel(item.kind), title: item.title, body: item.body };
+}
+
+/** What a signed-out read of History says: the tab is the account's own list of delivered alerts. */
+export function alertHistoryLockNote({ verifyEmail }: PaneLock): string {
+  const account = verifyEmail
+    ? "verify your email (Ctrl+P, Resend Verification Email)"
+    : "log in or sign up free from the command bar (Ctrl+P, Log In or Sign Up)";
+  return [
+    `ALRT History needs a free Gloom sign-in: it lists the alerts Gloom delivered to your account over the last 90 days. ${verifyEmail ? "Until the email is verified" : "Signed out"} it shows none of them.`,
+    `To read it, open the app (gloomberb), ${account}; gloomberb fn ALRT --tab history then reads with that session.`,
+  ].join("\n");
+}
+
+async function historyResult(ctx: HeadlessPaneContext): Promise<HeadlessRowsResult> {
+  const items: AlertHistoryItem[] = [];
+  let first: AlertHistory | null = null;
+  let more = false;
+  try {
+    for (let offset: number | null = 0, page = 0; offset != null; page += 1) {
+      if (page === HISTORY_PAGES) {
+        more = true;
+        break;
+      }
+      const history: AlertHistory = validateAlertHistory(await ctx.apiClient.getMobileAlertHistory<unknown>(offset));
+      first ??= history;
+      if (history.status === "unavailable") break;
+      items.push(...history.items);
+      offset = history.hasMore ? history.nextOffset : null;
+    }
+  } catch (error) {
+    throw explainRefusal(error, alertHistoryLockNote, { symbol: null, token: "ALRT" });
+  }
+  const unavailable = first?.status === "unavailable";
+  return {
+    columns: HISTORY_COLUMNS,
+    rows: items.map(historyRow),
+    empty: "No alerts delivered in the last 90 days.",
+    freshness: { source: "Gloom Cloud", status: "not-a-feed", basis: "delivered alerts", ...(first ? { asOf: first.asOf } : {}) },
+    ...(unavailable ? { errors: [first?.warning ?? "Alert history is unavailable."], complete: false } : {}),
+    ...(more ? { notes: [`Showing the latest ${items.length} delivered alerts; the pane loads older ones as you scroll.`] } : {}),
+    metadata: { deviceEnabled: first?.deviceEnabled ?? null },
+  };
+}
+
+export const alertsHeadless: HeadlessPaneDefinition<"rows"> = {
+  shape: "rows",
+  description: "Your alerts: price alerts with current price and distance to target, event alerts (earnings, CPI and FOMC dates, filings, news, market moves) or the alerts delivered to your account.",
+  freshness: { source: "Your alerts", status: "not-a-feed", basis: "your alert rules" },
+  argument: { kind: "none" },
+  options: [{
+    key: "tab",
+    description: "Alerts tab: prices, events or history (delivered alerts, signed in).",
+    type: "enum",
+    values: ALERT_TABS.map(({ value }) => ({ value })),
+    defaultValue: "prices",
+    example: "--tab events",
+    pluginState: { pluginId: ALERTS_PLUGIN_ID, key: "tab" },
+  }],
+  discovery: {
+    screenshotReadiness: "live-dom",
+    dataRequirements: ["Your saved alerts; the History tab needs a Gloom sign-in"],
+    limitations: ["Current price and quote time are what the app saved at its last check, blank until it has checked the alert."],
+  },
+  describe: (args) => `Alerts | ${String(args.options.tab ?? "prices")}`,
+  async load(args, ctx) {
+    const tab = (args.options.tab ?? "prices") as AlertsTab;
+    if (tab === "history") return historyResult(ctx);
+    const { alerts, alertsError, events } = readAlertStores(ctx.config);
+    return tab === "events" ? eventsResult(events.rules, events.error) : pricesResult(alerts, alertsError, events.rules.length);
+  },
+};

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

@@ -27,6 +27,7 @@ import {
   parseAlertShortcutValues,
 } from "./command";
 import { POLL_INTERVAL_MS, POLL_SECONDS_KEY } from "./constants";
+import { alertHistoryLockNote, alertsHeadless } from "./headless";
 import { AlertsPane } from "./pane";
 import { alertsCliCommand } from "./cli";
 import {
@@ -317,6 +318,7 @@ export const alertsPlugin: GloomPlugin = {
     ctx.registerPane({
       id: "alerts",
       reportFreshness: { source: "Your alerts", status: "not-a-feed", basis: "your alert rules" },
+      reportLockNote: alertHistoryLockNote,
       name: "Alerts",
       icon: "A",
       component: AlertsPane,
@@ -349,6 +351,7 @@ export const alertsPlugin: GloomPlugin = {
       description: "Price, market and filing event alerts",
       keywords: ["alerts", "price", "trigger", "alarm", "watch", "notify"],
       shortcut: { prefix: "ALRT" },
+      headless: alertsHeadless,
     });
   },
 

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

@@ -28,7 +28,7 @@ import {
   serializeAlerts,
 } from "./alert-engine";
 import { parseAlertCommandValues } from "./command";
-import { ALERTS_KEY } from "./constants";
+import { ALERT_TABS, ALERTS_KEY } from "./constants";
 import {
   conditionLabel,
   formatAlertDistance,
@@ -73,12 +73,6 @@ const ALERT_TABLE_CONTENT_WIDTH = ALERT_COLUMNS.reduce(
   2,
 );
 
-const ALERT_TABS = [
-  { label: "Prices", value: "prices" },
-  { label: "Events", value: "events" },
-  { label: "History", value: "history" },
-];
-
 export function AlertsPane(props: PaneProps) {
   const [tab, setTab] = usePluginPaneState<string>("tab", "prices");
   // A missed price alert opened from the Unread list selects its rule on Prices.

package/src/plugins/builtin/alerts/storage.ts

@@ -1,9 +1,12 @@
+import type { AppConfig } from "../../../types/config";
 import type { GloomPluginContext } from "../../../types/plugin";
 import {
   deserializeAlerts,
+  readAlertsStoreError,
   serializeAlerts,
 } from "./alert-engine";
-import { ALERTS_KEY } from "./constants";
+import { ALERTS_KEY, ALERTS_PLUGIN_ID } from "./constants";
+import { EVENT_ALERTS_KEY, readEventAlerts } from "./events";
 import type { AlertRule } from "./types";
 
 export function loadAlerts(ctx: GloomPluginContext): AlertRule[] {
@@ -18,3 +21,16 @@ export function saveAlerts(
 ): void {
   ctx.configState.set(ALERTS_KEY, serializeAlerts(alerts));
 }
+
+/** Both alert stores as the saved config holds them, for the CLI and the reports, which have no plugin context. */
+export function readAlertStores(config: AppConfig) {
+  const pluginState = config.pluginConfig[ALERTS_PLUGIN_ID] ?? {};
+  const rawPrice = pluginState[ALERTS_KEY];
+  const rawEvents = pluginState[EVENT_ALERTS_KEY];
+  return {
+    pluginState,
+    alerts: deserializeAlerts(typeof rawPrice === "string" ? rawPrice : "[]"),
+    alertsError: typeof rawPrice === "string" ? readAlertsStoreError(rawPrice) : null,
+    events: readEventAlerts(typeof rawEvents === "string" ? rawEvents : "[]"),
+  };
+}

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

@@ -257,6 +257,10 @@ function LegacyPortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
     ...(sectorAllocation.unvaluedSymbols.length > 0 ? [{
       text: `Weights unavailable: missing prices or FX for ${sectorAllocation.unvaluedSymbols.join(", ")}.`, tone: "warning" as const,
     }] : []),
+    // Named once in the pane's notices: its totals and its sectors leave the same futures out.
+    ...(sectorAllocation.unsizedSymbols.length > 0 ? [{
+      text: `No contract size, so not valued: ${sectorAllocation.unsizedSymbols.join(", ")}.`, tone: "warning" as const,
+    }] : []),
   ];
   const sectorRows = sectorAllocation.rows;
   const sortedSectorRows = useMemo(
@@ -453,9 +457,10 @@ export const portfolioAnalyticsModule: PluginModule = {
       headless: portfolioRiskHeadless,
       tableExport: true,
       // The risk window reads as trailing until it is set.
-      settings: (context) => ({ values: { riskSince: context.settings.riskSince ?? "trailing" }, fields: [
+      settings: (context) => ({ values: { riskSince: context.settings.riskSince ?? "trailing", riskWeights: context.settings.riskWeights ?? "13f" }, fields: [
         { key: "analyticsView", label: "View", type: "select", options: [{ value: "overview", label: "Overview" }, { value: "risk", label: "Risk depth" }] },
         { key: "riskSince", label: "Risk window", type: "select", options: [{ value: "trailing", label: "Trailing 60 sessions" }, { value: "filed", label: "Since 13F filing" }] },
+        { key: "riskWeights", label: "Since-filing weights", type: "select", options: [{ value: "13f", label: "13F weights, bought and held" }, { value: "current", label: "Current weights, held fixed" }] },
         { key: "riskEvidence", label: "Local evidence JSON", type: "text" },
         { key: "equityShift", label: "Index shift (%)", type: "text" },
         { key: "rateShift", label: "10Y shift (bp)", type: "text" },

package/src/plugins/builtin/analytics/metrics.ts

@@ -138,23 +138,61 @@ function returnIntervalKey(point: DatedReturn): string {
   return `${point.startDateKey}/${point.dateKey}`;
 }
 
+/** The intervals every series covers, and each series' return on them, in the first series' order. */
+interface AlignedSeries {
+  series: DatedReturn[][];
+  lengths: number[];
+  points: DatedReturn[];
+  values: Float64Array[];
+}
+
+/**
+ * Lined-up holdings, kept with their series: weights move with every quote,
+ * the series only with their bars, so a portfolio valued again (each Cloud
+ * sync values every one, GLO-925) only weighs returns already lined up
+ * instead of matching every interval of every holding again. A few lists per
+ * first series, since one holding can open more than one portfolio.
+ */
+const alignedByFirstSeries = new WeakMap<DatedReturn[], AlignedSeries[]>();
+
+function alignSeries(series: DatedReturn[][]): AlignedSeries {
+  const kept = alignedByFirstSeries.get(series[0]!) ?? [];
+  const cached = kept.find((entry) => entry.series.length === series.length
+    && entry.series.every((returns, index) => returns === series[index] && entry.lengths[index] === returns.length));
+  if (cached) return cached;
+  const samples = series.map((returns) => new Map(returns
+    .filter(validReturnInterval)
+    .map((point) => [returnIntervalKey(point), point])));
+  const points: DatedReturn[] = [];
+  const columns: number[][] = series.map(() => []);
+  for (const [key, first] of samples[0]!) {
+    const row: number[] = [];
+    for (const sample of samples) {
+      const point = sample.get(key);
+      if (!point) break;
+      row.push(point.value);
+    }
+    if (row.length < samples.length) continue;
+    points.push(first);
+    row.forEach((value, index) => columns[index]!.push(value));
+  }
+  const aligned = { series: [...series], lengths: series.map((returns) => returns.length), points, values: columns.map((column) => Float64Array.from(column)) };
+  alignedByFirstSeries.set(series[0]!, [aligned, ...kept].slice(0, 4));
+  return aligned;
+}
+
 export function computeWeightedPortfolioReturns(series: WeightedReturnSeries[]): DatedReturn[] {
   const holdings = series.filter((entry) => Number.isFinite(entry.weight) && entry.weight > 0);
   const totalWeight = holdings.reduce((sum, entry) => sum + entry.weight, 0);
   if (!holdings.length || !Number.isFinite(totalWeight) || totalWeight <= 0) return [];
-  const samples = holdings.map((entry) => new Map(entry.returns
-    .filter(validReturnInterval)
-    .map((point) => [returnIntervalKey(point), point])));
+  const { points, values } = alignSeries(holdings.map((entry) => entry.returns));
   const returns: DatedReturn[] = [];
-  for (const [key, first] of samples[0]!) {
+  for (let row = 0; row < points.length; row++) {
     let value = 0;
-    let complete = true;
     for (let index = 0; index < holdings.length; index++) {
-      const point = samples[index]!.get(key);
-      if (!point) { complete = false; break; }
-      value += point.value * (holdings[index]!.weight / totalWeight);
+      value += values[index]![row]! * (holdings[index]!.weight / totalWeight);
     }
-    if (complete && Number.isFinite(value)) returns.push({ ...first, value });
+    if (Number.isFinite(value)) returns.push({ ...points[row]!, value });
   }
   return returns.sort((left, right) => left.dateKey.localeCompare(right.dateKey));
 }

package/src/plugins/builtin/analytics/risk-headless.ts

@@ -17,6 +17,7 @@ import {
   riskPercentile,
   riskValue,
   sinceFallbackNote,
+  sinceFiledMethod,
   type PortfolioRiskModel,
   type RiskCoverage,
   type RiskDisplayRow,
@@ -142,6 +143,7 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
     ],
     limitations: [
       `Fixed-current-weight USD equity basket over the holdings that qualify, largest ${RISK_HISTORY_LIMIT} by value; foreign listings convert to USD at daily FX closes; metadata.coverage states the covered share of market value and each holding left out.`,
+      "--since filed buys the 13F's own weights at the filing-date close and holds them (--weights current holds today's weights fixed instead).",
       "No account performance inferred.",
       "ETF price-return factor proxies.",
       "Historical percentiles need 20 rolling samples.",
@@ -163,6 +165,13 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       values: [{ value: "filed" }],
       description: "Risk rows since the 13F filing date of a portfolio made with portfolio import --13f, instead of the trailing 60 sessions.",
     },
+    {
+      key: "weights",
+      type: "enum",
+      settingKey: "riskWeights",
+      values: [{ value: "13f" }, { value: "current" }],
+      description: "With --since filed: 13f (when left out) buys the 13F's own weights at the filing-date close and holds them; current holds today's weights fixed over the same sessions.",
+    },
     {
       key: "evidence",
       type: "string",
@@ -254,16 +263,19 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
         rates: Number(args.options["rate-shift"] ?? 100),
         volatility: Number(args.options["vol-shift"] ?? 10),
       },
-      args.options.since === "filed" ? { since: "filed" } : {},
+      args.options.since === "filed"
+        ? { since: "filed", weights: args.options.weights === "current" ? "current" : "13f" }
+        : {},
     );
     // Options for views the report does not print are named, not dropped silently; the fallback from --since opens the report.
     const fallback = sinceFallbackNote(local.portfolio);
     const shifted = ["equity-shift", "rate-shift", "vol-shift"].filter((key) => args.options[key] != null);
     const notices = [
-      ...(model.window.kind === "since-filed" ? [`Risk rows since the 13F filing on ${model.window.filed}, against ${model.benchmark}`] : []),
+      ...(model.window.kind === "since-filed" ? [sinceFiledMethod(model.window, model.benchmark)] : []),
       ...(args.options.since === "filed" && model.window.kind !== "since-filed" ? [fallback] : []),
       ...(requestedView && requestedView !== "stress" && shifted.length ? [`${shifted.map((key) => `--${key}`).join(", ")} change${shifted.length === 1 ? "s" : ""} the stress view only, not --view ${requestedView}`] : []),
       ...(requestedView && args.options.since != null && requestedView !== "risk" ? [`--since changes the risk view only, not --view ${requestedView}`] : []),
+      ...(args.options.weights != null && args.options.since !== "filed" ? ["--weights applies with --since filed only"] : []),
     ];
     // A basket view is complete only when the basket covers every holding.
     const covered = model.coverage.leftOut.length === 0;

package/src/plugins/builtin/analytics/risk-math.ts

@@ -340,6 +340,89 @@ export function sinceBasketRisk(
   });
 }
 
+/** A held basket's daily returns, and why it stops or leaves a holding out when it does. */
+export interface HeldBasket {
+  returns: DatedReturn[];
+  /**
+   * Set when the basket ends before the last session: the holding (its index
+   * in the input) whose daily closes end first, and the day they end.
+   */
+  cutShort: { holding: number; date: string } | null;
+  /** Holdings with no close on or before `since`, which cannot be bought at it and are left out. */
+  unpriced: number[];
+}
+
+/**
+ * Daily returns of a basket bought at the close on or before `since` (a 13F
+ * filing date) at `weights` and held: each holding's share drifts with its
+ * price, nothing is rebalanced. The basket is valued at every session of
+ * `calendar` (the benchmark's, so the two pair; the holdings' own dates when
+ * left out). A holding with no close for a session (a halt, a missing bar)
+ * holds its value flat, and its multi-day return lands on the session it
+ * arrives. The basket ends where the first holding's closes end, and says
+ * which.
+ */
+export function buyAndHoldReturns(
+  holdings: readonly { weight: number; returns: readonly DatedReturn[] }[],
+  since: string,
+  calendar?: readonly DatedReturn[],
+): HeldBasket {
+  const unpriced: number[] = [];
+  // Each holding's price relative to its start close, by date, along its own unbroken run of closes.
+  const paths = holdings.flatMap((row, index) => {
+    if (!Number.isFinite(row.weight) || row.weight <= 0) return [];
+    const points = row.returns
+      .filter((point) => valid(point) && point.dateKey > since)
+      .toSorted((left, right) => left.dateKey.localeCompare(right.dateKey));
+    if (!points.length || points[0]!.startDateKey > since) {
+      unpriced.push(index);
+      return [];
+    }
+    const levels: Array<{ date: string; level: number }> = [];
+    let level = 1;
+    for (const [at, point] of points.entries()) {
+      if (at > 0 && point.startDateKey !== points[at - 1]!.dateKey) break;
+      level *= 1 + point.value;
+      levels.push({ date: point.dateKey, level });
+    }
+    return [{ index, weight: row.weight, start: points[0]!.startDateKey, levels }];
+  });
+  if (!paths.length) return { returns: [], cutShort: null, unpriced };
+  const sessions = (calendar
+    ? calendar.filter((point) => valid(point) && point.dateKey > since).map((point) => point.dateKey)
+    : [...new Set(paths.flatMap((path) => path.levels.map((point) => point.date)))]
+  ).toSorted();
+  // Known up to the earliest last close: past it a holding's value is unknown, not flat.
+  const last = paths.reduce((first, path) => (path.levels.at(-1)!.date < first.levels.at(-1)!.date ? path : first));
+  const end = last.levels.at(-1)!.date;
+  const total = paths.reduce((sum, path) => sum + path.weight, 0);
+  // The close the basket is bought at: the latest start close among the holdings.
+  const bought = paths.reduce((latest, path) => (path.start > latest ? path.start : latest), "");
+  const cursor = paths.map(() => -1);
+  const returns: DatedReturn[] = [];
+  let previous = { date: since, value: 1 };
+  for (const date of sessions) {
+    if (date > end) break;
+    let value = 0;
+    for (const [at, path] of paths.entries()) {
+      let next = cursor[at]!;
+      while (next + 1 < path.levels.length && path.levels[next + 1]!.date <= date) next += 1;
+      cursor[at] = next;
+      value += (path.weight / total) * (next < 0 ? 1 : path.levels[next]!.level);
+    }
+    const start = returns.length ? previous.date
+      : (calendar?.find((point) => point.dateKey === date)?.startDateKey ?? bought);
+    returns.push({ startDateKey: start, dateKey: date, value: value / previous.value - 1 });
+    previous = { date, value };
+  }
+  const lastSession = sessions.at(-1);
+  return {
+    returns,
+    cutShort: lastSession && end < lastSession ? { holding: last.index, date: end } : null,
+    unpriced,
+  };
+}
+
 export function rollingBeta(
   asset: readonly DatedReturn[],
   factor: readonly DatedReturn[],