gloomberb 0.18.2 → 0.18.4

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

@@ -1,7 +1,15 @@
 // Alerts a number of days before a dated event: a company's next earnings, or
-// the next CPI release or FOMC decision. The rules are event alert rules
-// (`earnings_date`, `macro_event`) with the lead time in their config; this
-// module is the date arithmetic and the lookup of the next event date.
+// a release in the economic calendar, CPI and FOMC among them. An earnings
+// rule can instead go off once the report's actual EPS is out; a release also
+// alerts with its figures once they print (calendar-events.ts). The rules are
+// event alert rules (`earnings_date`, `macro_event`, `calendar_event`) with
+// the lead time in their config; this module is the date arithmetic and the
+// lookup of the next event date.
+import { formatNumber } from "../../../utils/format";
+import type { EconEvent } from "../econ/types";
+import { newYorkToday } from "../earnings/board-model";
+import { epsSurprise } from "../shared/earnings-report";
+import { calendarEventLabel, nextReleaseDate, type CalendarReleaseTarget } from "./calendar-events";
 import type { EventAlertRule } from "./events";
 import { MACRO_EVENT_NAMES } from "./research-builder";
 import {
@@ -15,21 +23,51 @@ import {
 
 const DAY_MS = 86_400_000;
 
-/** What a scheduled alert follows: one US-listed company's earnings, or a US macro release. */
+/**
+ * What a scheduled alert follows: one US-listed company's earnings, CPI or
+ * FOMC, or any release in the economic calendar by its name and country.
+ */
 export type ScheduledEventTarget =
   | { kind: "earnings"; symbol: string; exchange: string }
-  | { kind: "macro"; event: MacroAlertEvent };
+  | { kind: "macro"; event: MacroAlertEvent }
+  | CalendarReleaseTarget;
+
+/** CPI, FOMC and calendar releases alert again with their figures once they print; earnings do not. */
+export const followsRelease = (target: ScheduledEventTarget): target is Exclude<ScheduledEventTarget, { kind: "earnings" }> =>
+  target.kind !== "earnings";
+
+/**
+ * The day a rule's dates count from: New York's for earnings, CPI and FOMC,
+ * whose calendars give New York days; the UTC day for a calendar release,
+ * which the economic calendar lists by its UTC day.
+ */
+export function scheduledToday(target: ScheduledEventTarget, now: number = Date.now()): string {
+  return target.kind === "release" ? new Date(now).toISOString().slice(0, 10) : newYorkToday(new Date(now));
+}
+
+/** When a scheduled rule goes off: its lead time before the date, or (earnings only) once the results are out. */
+export type ScheduledTrigger = "date" | "results";
 
 export interface ScheduledRule {
   target: ScheduledEventTarget;
   leadDays: number;
+  trigger: ScheduledTrigger;
 }
 
+/**
+ * How long past its report date a results alert waits for the actual EPS:
+ * an after-close report is filled in overnight, and a late one a day or two
+ * later. Past it the alert lets that report go and follows the next one.
+ */
+const RESULTS_WAIT_DAYS = 3;
+
 /**
  * Where a scheduled alert stands on `today` (a New York calendar day):
  * `armed` before its lead time, `due` from the lead day through the event day
  * until it alerts, `fired` once it has for this event, `passed` after the
- * event day, and `unscheduled` with no event date to wait for.
+ * event day, and `unscheduled` with no event date to wait for. A results
+ * alert is due from the report day through `RESULTS_WAIT_DAYS` after it, and
+ * goes off within that only once the actual EPS is out.
  */
 export type ScheduledPhase = "unscheduled" | "armed" | "due" | "fired" | "passed";
 
@@ -49,9 +87,6 @@ export function parseMacroEventName(raw: string | null | undefined): MacroAlertE
   return isMacroAlertEvent(name) ? name : null;
 }
 
-/** The names a macro event alert takes, as the CLI spells them. */
-export const MACRO_EVENT_CLI_NAMES = "CPI or FOMC";
-
 function shiftDate(date: string, days: number): string {
   return new Date(Date.parse(`${date}T00:00:00Z`) + days * DAY_MS).toISOString().slice(0, 10);
 }
@@ -71,54 +106,88 @@ export function scheduledPhase(
   leadDays: number,
   firedFor: string | undefined,
   today: string,
+  trigger: ScheduledTrigger = "date",
 ): ScheduledPhase {
   if (!eventDate) return "unscheduled";
-  if (today > eventDate) return "passed";
+  const results = trigger === "results";
+  if (today > (results ? shiftDate(eventDate, RESULTS_WAIT_DAYS) : eventDate)) return "passed";
   if (firedFor === eventDate) return "fired";
-  return today >= leadStartDate(eventDate, leadDays) ? "due" : "armed";
+  return today >= (results ? eventDate : leadStartDate(eventDate, leadDays)) ? "due" : "armed";
 }
 
 /** The rule's target and lead time; null for a rule that is not a scheduled event or does not read. */
 export function readScheduledRule(rule: EventAlertRule): ScheduledRule | null {
-  if (rule.kind !== "earnings_date" && rule.kind !== "macro_event") return null;
+  if (rule.kind !== "earnings_date" && rule.kind !== "macro_event" && rule.kind !== "calendar_event") return null;
   const config = readResearchRule(rule.kind, rule.value);
   if (!config || typeof config.leadDays !== "number") return null;
   if (rule.kind === "macro_event") {
-    return isMacroAlertEvent(config.event) ? { target: { kind: "macro", event: config.event }, leadDays: config.leadDays } : null;
+    return isMacroAlertEvent(config.event) ? { target: { kind: "macro", event: config.event }, leadDays: config.leadDays, trigger: "date" } : null;
+  }
+  if (rule.kind === "calendar_event") {
+    return config.event && config.country
+      ? {
+          target: { kind: "release", event: config.event, country: config.country, ...(config.publisher ? { publisher: config.publisher } : {}) },
+          leadDays: config.leadDays,
+          trigger: "date",
+        }
+      : null;
   }
   return config.symbol
-    ? { target: { kind: "earnings", symbol: config.symbol, exchange: config.exchange ?? "" }, leadDays: config.leadDays }
+    ? {
+        target: { kind: "earnings", symbol: config.symbol, exchange: config.exchange ?? "" },
+        leadDays: config.leadDays,
+        trigger: config.when === "results" ? "results" : "date",
+      }
     : null;
 }
 
 /** One key per thing to look up, shared by every rule on the same event. */
 export function scheduledTargetKey(target: ScheduledEventTarget): string {
+  if (target.kind === "release") return `release:${target.country}:${target.event.toLowerCase()}:${target.publisher ?? ""}`;
   return target.kind === "earnings" ? `earnings:${target.symbol}` : `macro:${target.event}`;
 }
 
-/** "CRWV earnings", "CPI release", "FOMC decision". */
+/** "CRWV earnings", "CPI release", "FOMC decision", "NBS Manufacturing PMI (CN)". */
 export function scheduledEventName(target: ScheduledEventTarget): string {
+  if (target.kind === "release") return calendarEventLabel(target);
   return target.kind === "earnings" ? `${target.symbol} earnings` : MACRO_EVENT_NAMES[target.event];
 }
 
 /**
- * A new rule for `target`, alerting `leadDays` before it, with the event date
- * the caller looked up. Throws for a listing the rule cannot follow.
+ * "1 day before", "3 days before", "when results are out": when a rule goes
+ * off, as lists say it; a release's ("1 day before and when it prints")
+ * also once its figures are out.
+ */
+export function scheduledTriggerText(rule: Pick<ScheduledRule, "leadDays" | "trigger"> & { prints?: boolean }): string {
+  if (rule.trigger === "results") return "when results are out";
+  return `${rule.leadDays} day${rule.leadDays === 1 ? "" : "s"} before${rule.prints ? " and when it prints" : ""}`;
+}
+
+/**
+ * A new rule for `target`, alerting `lead` days before it or, for earnings,
+ * once the results are out, with the event date the caller looked up. Throws
+ * for a listing the rule cannot follow.
  */
 export function createScheduledAlert(
   target: ScheduledEventTarget,
-  leadDays: number,
+  lead: number | "results",
   eventDate: string | null,
   now = Date.now(),
 ): EventAlertRule {
-  const kind = target.kind === "earnings" ? "earnings_date" : "macro_event";
+  if (target.kind !== "earnings" && lead === "results") throw new Error("Only earnings alerts can wait for results.");
+  const kind = target.kind === "earnings" ? "earnings_date" : target.kind === "release" ? "calendar_event" : "macro_event";
+  const timing = lead === "results" ? { when: "results" } : { leadDays: lead };
   const value = normalizeResearchRule(kind, target.kind === "earnings"
-    ? { version: 1, symbol: target.symbol, exchange: target.exchange, leadDays }
-    : { version: 1, event: target.event, leadDays });
+    ? { version: 1, symbol: target.symbol, exchange: target.exchange, ...timing }
+    : target.kind === "release"
+      ? { version: 1, event: target.event, country: target.country, ...(target.publisher ? { publisher: target.publisher } : {}), ...timing }
+      : { version: 1, event: target.event, ...timing });
   if (!value) {
     throw new Error(target.kind === "earnings"
       ? `Earnings alerts follow US listings, such as CRWV or AAPL:NASDAQ. ${target.exchange ? `${target.symbol}:${target.exchange}` : target.symbol} is not one.`
-      : `Days before must be a whole number from 1 to ${MAX_LEAD_DAYS}.`);
+      : target.kind === "release"
+        ? `A calendar event alert takes the event's name, a two-letter country and 1 to ${MAX_LEAD_DAYS} days before.`
+        : `Days before must be a whole number from 1 to ${MAX_LEAD_DAYS}.`);
   }
   return {
     id: crypto.randomUUID(),
@@ -131,9 +200,9 @@ export function createScheduledAlert(
   };
 }
 
-/** Re-armed: it alerts again for the event it already alerted for, and a paused rule resumes. */
+/** Re-armed: it alerts again for the event it already alerted for, its figures too, and a paused rule resumes. */
 export function rearmScheduledAlert(rule: EventAlertRule, now = Date.now()): EventAlertRule {
-  const { firedFor: _fired, ...rest } = rule;
+  const { firedFor: _fired, printedFor: _printed, ...rest } = rule;
   return { ...rest, status: "active", createdAt: rule.status === "paused" ? now : rule.createdAt };
 }
 
@@ -151,9 +220,80 @@ export function scheduledAlertMessage(target: ScheduledEventTarget, eventDate: s
 }
 
 /** A list's state word: paused, active, or triggered while it has alerted for the coming event. */
-export function scheduledAlertStatus(rule: EventAlertRule, leadDays: number, today: string): "active" | "paused" | "triggered" {
+export function scheduledAlertStatus(
+  rule: EventAlertRule,
+  leadDays: number,
+  today: string,
+  trigger: ScheduledTrigger = "date",
+): "active" | "paused" | "triggered" {
   if (rule.status === "paused") return "paused";
-  return scheduledPhase(rule.eventDate, leadDays, rule.firedFor, today) === "fired" ? "triggered" : "active";
+  return scheduledPhase(rule.eventDate, leadDays, rule.firedFor, today, trigger) === "fired" ? "triggered" : "active";
+}
+
+/** A company's report as ERN has it: its day and, once out, the actual EPS. */
+export interface EarningsResultRow {
+  symbol: string;
+  date: string;
+  epsActual: number | null;
+  epsEstimate: number | null;
+}
+
+/**
+ * The report `symbol` was waited for on `eventDate`, once its actual EPS is
+ * out: the reported row nearest that day, from a few days before it (a date
+ * moved up) through `RESULTS_WAIT_DAYS` after. Null while it is not out.
+ */
+export function reportedResult(rows: readonly EarningsResultRow[], symbol: string, eventDate: string): EarningsResultRow | null {
+  const wanted = symbol.trim().toUpperCase();
+  const from = shiftDate(eventDate, -RESULTS_WAIT_DAYS);
+  const to = shiftDate(eventDate, RESULTS_WAIT_DAYS);
+  return rows
+    .filter((row) => row.symbol.trim().toUpperCase() === wanted && row.epsActual != null && Number.isFinite(row.epsActual)
+      && row.date >= from && row.date <= to)
+    .sort((left, right) => Math.abs(daysBetween(eventDate, left.date)) - Math.abs(daysBetween(eventDate, right.date)))[0] ?? null;
+}
+
+type ResultsRead = (symbols: string[]) => Promise<readonly EarningsResultRow[]>;
+
+/**
+ * The reports results alerts wait on, from ERN's board and, for each symbol
+ * the board has no actual EPS for (a listing the stored calendar does not
+ * cover, or the board unreadable), the per-ticker calendar. Either read
+ * failing leaves the other's rows; only both failing, or the board failing
+ * with no other read, is an error.
+ */
+export async function readEarningsResults(
+  symbols: readonly string[],
+  board: ResultsRead,
+  calendar: ResultsRead | null,
+): Promise<EarningsResultRow[]> {
+  const [fromBoard] = await Promise.allSettled([board([...symbols])]);
+  const rows = fromBoard.status === "fulfilled" ? [...fromBoard.value] : [];
+  const reported = new Set(rows.filter((row) => row.epsActual != null).map((row) => row.symbol.trim().toUpperCase()));
+  const missing = symbols.filter((symbol) => !reported.has(symbol.trim().toUpperCase()));
+  if (missing.length === 0 || !calendar) {
+    if (fromBoard.status === "rejected") throw fromBoard.reason;
+    return rows;
+  }
+  const [fromCalendar] = await Promise.allSettled([calendar(missing)]);
+  if (fromCalendar.status === "fulfilled") return [...rows, ...fromCalendar.value];
+  if (fromBoard.status === "rejected") throw fromBoard.reason;
+  return rows;
+}
+
+/** The days to read reports over for results alerts waiting on `eventDates`. */
+export function resultsLookupRange(eventDates: readonly string[]): { from: string; to: string } | null {
+  const sorted = [...eventDates].sort();
+  return sorted.length === 0 ? null : { from: shiftDate(sorted[0]!, -RESULTS_WAIT_DAYS), to: shiftDate(sorted.at(-1)!, RESULTS_WAIT_DAYS) };
+}
+
+/** The notification once results are out: "CRWV reported EPS 0.12 vs 0.10 expected (+20.0%)". */
+export function scheduledResultsMessage(symbol: string, result: Pick<EarningsResultRow, "epsActual" | "epsEstimate">): string {
+  const actual = `${symbol} reported EPS ${formatNumber(result.epsActual ?? undefined, 2)}`;
+  if (result.epsEstimate == null) return actual;
+  const surprise = epsSurprise(result.epsActual, result.epsEstimate);
+  const shown = surprise == null ? null : Number((surprise * 100).toFixed(1));
+  return `${actual} vs ${formatNumber(result.epsEstimate, 2)} expected${shown == null ? "" : ` (${shown > 0 ? "+" : ""}${shown.toFixed(1)}%)`}`;
 }
 
 export interface EarningsDateRow {
@@ -163,7 +303,7 @@ export interface EarningsDateRow {
 
 /**
  * The next earnings day of `symbol` on or after `today`. The day is the UTC
- * date of the report time, the day ERN and `gloomberb earnings` show.
+ * date of the report time, the day ERN and `gloom earnings` show.
  */
 export function nextEarningsDate(events: readonly EarningsDateRow[], symbol: string, today: string): string | null {
   const wanted = symbol.trim().toUpperCase();
@@ -203,6 +343,14 @@ export interface ScheduledEventSources {
   earnings(symbols: string[]): Promise<readonly EarningsDateRow[]>;
   cpi(): Promise<CpiReleaseCalendar>;
   fomc(): Promise<ReadonlyArray<{ date: string }>>;
+  /**
+   * The economic calendar ECO lists: the dates of calendar releases, and the
+   * figures every release alert sends once they print. `force` asks past a
+   * fresh cache, while a print is due.
+   */
+  calendar?(force?: boolean): Promise<readonly EconEvent[]>;
+  /** The reports of `symbols` from `from` to `to`, actual EPS included once out; results alerts read it. */
+  results?(symbols: string[], from: string, to: string): Promise<readonly EarningsResultRow[]>;
 }
 
 export type ScheduledDateLookup = { date: string | null } | { error: string };
@@ -211,18 +359,27 @@ const errorText = (error: unknown) => (error instanceof Error ? error.message :
 
 /**
  * The next date of every target, keyed by `scheduledTargetKey`: one earnings
- * request for all the symbols, one CPI and one FOMC read. A source that fails
- * gives its targets an error and leaves the others alone.
+ * request for all the symbols, one CPI, one FOMC and one calendar read. A
+ * source that fails gives its targets an error and leaves the others alone.
+ * `today` is New York's day; a calendar release follows its next row still
+ * to come at `now`.
  */
 export async function lookupScheduledDates(
   targets: readonly ScheduledEventTarget[],
   sources: ScheduledEventSources,
   today: string,
+  now: number = Date.now(),
 ): Promise<Map<string, ScheduledDateLookup>> {
   const result = new Map<string, ScheduledDateLookup>();
   const symbols = [...new Set(targets.flatMap((target) => (target.kind === "earnings" ? [target.symbol] : [])))];
   const macros = new Set(targets.flatMap((target) => (target.kind === "macro" ? [target.event] : [])));
+  const releases = targets.filter((target): target is CalendarReleaseTarget => target.kind === "release");
+  const readCalendar = sources.calendar?.bind(sources) ?? (() => Promise.reject(new Error("The economic calendar is not available.")));
   await Promise.all([
+    releases.length === 0 ? null : readCalendar().then(
+      (events) => { for (const target of releases) result.set(scheduledTargetKey(target), { date: nextReleaseDate(events, target, now) }); },
+      (error) => { for (const target of releases) result.set(scheduledTargetKey(target), { error: errorText(error) }); },
+    ),
     symbols.length === 0 ? null : sources.earnings(symbols).then(
       (events) => { for (const symbol of symbols) result.set(`earnings:${symbol}`, { date: nextEarningsDate(events, symbol, today) }); },
       (error) => { for (const symbol of symbols) result.set(`earnings:${symbol}`, { error: errorText(error) }); },
@@ -241,6 +398,7 @@ export async function lookupScheduledDates(
 
 /** Why no alert was added when the next date could not be looked up. */
 export function eventDateUnavailableMessage(target: ScheduledEventTarget, error: string): string {
+  if (target.kind === "release") return `The economic calendar could not be loaded (${error}), so no alert was added.`;
   return target.kind === "earnings"
     ? `Earnings dates for ${target.symbol} could not be loaded (${error}), so no alert was added. Check the symbol, or try again later.`
     : `The next ${MACRO_EVENT_NAMES[target.event]} date could not be loaded (${error}), so no alert was added.`;
@@ -248,6 +406,7 @@ export function eventDateUnavailableMessage(target: ScheduledEventTarget, error:
 
 /** Why no alert was added for an event with no known next date. */
 export function noUpcomingEventMessage(target: ScheduledEventTarget): string {
+  if (target.kind === "release") return `The economic calendar lists no upcoming ${calendarEventLabel(target)}, so no alert was added.`;
   return target.kind === "earnings"
     ? `No upcoming earnings date is known for ${target.symbol}, so no alert was added.`
     : `No upcoming ${MACRO_EVENT_NAMES[target.event]} date is known, so no alert was added.`;

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

@@ -6,31 +6,34 @@ import {
   serializeAlerts,
 } from "./alert-engine";
 import { ALERTS_KEY, ALERTS_PLUGIN_ID } from "./constants";
-import { EVENT_ALERTS_KEY, readEventAlerts } from "./events";
+import { readEventAlertStores } from "./events";
 import type { AlertRule } from "./types";
 
 export function loadAlerts(ctx: GloomPluginContext): AlertRule[] {
-  const json = ctx.configState.get<string>(ALERTS_KEY);
-  if (!json) return [];
+  const json = ctx.configState.get<unknown>(ALERTS_KEY);
+  // Background evaluation must not notify from a partial store it cannot safely update.
+  if (readAlertsStoreError(json)) return [];
   return deserializeAlerts(json);
 }
 
-export function saveAlerts(
+export async function saveAlerts(
   ctx: GloomPluginContext,
   alerts: AlertRule[],
-): void {
-  ctx.configState.set(ALERTS_KEY, serializeAlerts(alerts));
+): Promise<void> {
+  const error = readAlertsStoreError(ctx.configState.get<unknown>(ALERTS_KEY));
+  if (error) throw new Error(error);
+  await 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 : "[]"),
+    alerts: deserializeAlerts(rawPrice),
+    alertsError: readAlertsStoreError(rawPrice),
+    // The event alerts, and the IV levels kept apart from them.
+    events: readEventAlertStores((key) => pluginState[key]),
   };
 }

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

@@ -18,6 +18,8 @@ export interface AlertSubject {
   marketId?: string;
   /** A macro event rule's release: `cpi` or `fomc`. */
   event?: string;
+  /** A calendar event rule's country, which ECO opens on. */
+  country?: string;
   keyword?: string;
   cik?: string;
 }
@@ -32,8 +34,9 @@ const pane = (templateId: string, options?: PaneTemplateCreateOptions): AlertTar
 
 /**
  * The one map from what an alert follows to what it opens, for every rule kind and every delivered alert:
- * a perpetual opens PERP on its market; a dated event the pane its date comes from (ERN, CPI, WIRP); catalyst,
- * Congress and 13F rules their calendar or list, on the company or fund they name; any other rule on a security
+ * a perpetual opens PERP on its market; a dated event the pane its date comes from (ERN, CPI, WIRP, ECO); catalyst,
+ * Congress and 13F rules their calendar or list, on the company or fund they name; an IV level the symbol's
+ * OVDV, whose fits it reads; a hiring move HIRE on the company; any other rule on a security
  * that listing's DES. A rule on no security opens the pane it watches (SRCH for a news keyword, FLOW for flow
  * on the user's lists, FIRST for breaking news). Null when there is nothing to open.
  */
@@ -43,13 +46,18 @@ export function alertTarget(subject: AlertSubject): AlertTarget | null {
     case "perps_threshold": return subject.marketId ? pane("perps-pane", { arg: subject.marketId }) : null;
     case "earnings_date":
     case "earnings": return symbol ? pane("earnings-calendar-pane", { arg: symbol }) : null;
+    case "iv_level": return symbol ? pane("vol-surface-pane", { symbol }) : null;
     case "macro_event": return subject.event === "cpi" ? pane("cpi-pane") : subject.event === "fomc" ? pane("rate-path-pane") : null;
+    // Any other release opens the economic calendar on its country.
+    case "calendar_event": return pane("econ-calendar-pane", subject.country ? { arg: subject.country } : undefined);
     case "catalyst": return pane("catalysts-pane", symbol ? { symbol } : undefined);
     case "congress_trade": return pane("congress-trades-pane");
     case "thirteenf_filing": return pane(THIRTEENF_TEMPLATE_ID, subject.cik ? { arg: subject.cik } : undefined);
     case "news_keyword": if (!symbol) return pane(RESEARCH_SEARCH_TEMPLATE_ID, subject.keyword ? { arg: subject.keyword } : undefined); break;
     case "options_flow": if (!symbol) return pane("scanner-flow-pane"); break;
     case "breaking_news": if (!symbol) return pane("news-breaking-pane"); break;
+    // A hiring move opens HIRE on the company, where its Moves tab says why.
+    case "hiring_move": return symbol ? pane("hiring-pane", { symbol }) : null;
   }
   return symbol ? { kind: "description", symbol, ...(subject.exchange ? { exchange: subject.exchange } : {}) } : null;
 }
@@ -61,7 +69,8 @@ const venue = (exchange: string | undefined) => exchange && exchange !== "US" ?
 export function eventRuleSubject(rule: EventAlertRule): AlertSubject {
   if (isResearchAlertKind(rule.kind)) {
     const config = readResearchRule(rule.kind, rule.value);
-    return { kind: rule.kind, symbol: config?.symbol, exchange: venue(config?.exchange), marketId: config?.marketId, event: config?.event, keyword: config?.keyword };
+    return { kind: rule.kind, symbol: config?.symbol, exchange: venue(config?.exchange), marketId: config?.marketId, event: config?.event, keyword: config?.keyword,
+      ...config?.country ? { country: config.country } : {} };
   }
   return { kind: rule.kind, ...(rule.target === "ticker" ? { symbol: rule.value } : rule.target === "fund" ? { cik: rule.value } : {}) };
 }

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

@@ -66,7 +66,7 @@ import {
   type SectorTableColumn,
 } from "./sector-model";
 import { describePortfolioTab, resolvePortfolioId, resolveTemplatePortfolioId } from "./portfolio-selection";
-import { findNamedCollection } from "../../../portfolio/collection-name";
+import { findNamedCollection, unknownCollectionArgError } from "../../../portfolio/collection-name";
 import {
   analyticsFigures,
   riskFigureNotices,
@@ -465,6 +465,8 @@ export const portfolioAnalyticsModule: PluginModule = {
         { key: "equityShift", label: "Index shift (%)", type: "text" },
         { key: "rateShift", label: "10Y shift (bp)", type: "text" },
         { key: "volShift", label: "VIX shift (points)", type: "text" },
+        { key: "fxShift", label: "FX shift vs USD (TRY -20)", type: "text" },
+        { key: "assetShift", label: "Asset shift (GLD 10)", type: "text" },
       ] }),
       defaultPosition: "right",
       defaultMode: "floating",
@@ -483,7 +485,11 @@ export const portfolioAnalyticsModule: PluginModule = {
       label: prefix === "PORT" ? "Portfolio Analytics" : "Portfolio Market Risk",
       description: "Benchmark-relative risk, factor betas, stress shifts and local account evidence.",
       keywords: ["risk", "analytics", "sharpe", "beta", "sector", "allocation", "portfolio", "style", "quality", "factor tilt"],
-      shortcut: { prefix, argKind: "text", argOptional: true, argPlaceholder: "portfolio-id" },
+      shortcut: {
+        prefix, argKind: "text", argOptional: true, argPlaceholder: "portfolio-id",
+        // `PORT Nope` names no portfolio: the bar says so, not the first portfolio's risk.
+        argError: (arg, context) => unknownCollectionArgError(arg, context.config.portfolios, "portfolio"),
+      },
       headless: portfolioRiskHeadless,
       canCreate: (context) => context.config.portfolios.length > 0,
       createInstance: (context, options) => {

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

@@ -149,7 +149,7 @@ interface AlignedSeries {
 /**
  * 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
+ * sync values every one) 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.
  */