gloomberb 0.16.3 → 0.16.4

package/src/plugins/builtin/options-scenario/client.ts

@@ -5,10 +5,11 @@ import type { QueryEntry } from "../../../market-data/result-types";
 import type { DataProvider } from "../../../types/data-provider";
 import type { OptionsChain, Quote, TickerFinancials } from "../../../types/financials";
 import { canonicalExchange, parsePublicTickerKey } from "../../../utils/exchanges";
+import { expiryIsoDate, findListedExpiry, missingExpiryText } from "../../../utils/option-expiry";
 import { surfaceTreasuryRate } from "../vol-surface/model";
 import { daysToExpiryFrom, extractImpliedForward, optionMid, solveImpliedVolatility } from "../shared/volatility";
 import type { YieldPoint } from "../yield-curve/treasury-data";
-import { parseLegs, validatePosition, type ScenarioControls, type ScenarioLeg, type ScenarioPosition } from "./model";
+import { parseLegs, scenarioCurrency, validatePosition, type ScenarioControls, type ScenarioLeg, type ScenarioPosition } from "./model";
 import { abortable, abortError } from "../../../utils/async-deadline";
 import { errorMessage } from "../../../utils/errors";
 
@@ -26,6 +27,8 @@ export interface ScenarioMarketSnapshot {
   underlyingQuote: Quote | null;
   rateAsOf: string[];
   warnings: string[];
+  /** Why the requested expiry has no chain, naming the listed dates nearest it. */
+  missingExpiry?: string;
 }
 
 export interface ScenarioLoaderDependencies {
@@ -99,15 +102,31 @@ export async function loadScenarioMarket(
   const validDividend = symbolMatches(financialsSymbol, symbol) && !fundamentals?.stale && !financialsEntry?.error
     && typeof fundamentals?.dividendYield === "number" && Number.isFinite(fundamentals.dividendYield) && fundamentals.dividendYield >= 0;
   if (!validDividend) warnings.push("Dividend yield unavailable; supply an explicit assumption");
-  const chainEntry = entry(chainResult, "Options chain");
+  let chainEntry = entry(chainResult, "Options chain");
   let chain = chainEntry ? resolveEntryValue(chainEntry) : null;
   if (chain && !symbolMatches(chain.underlyingSymbol, symbol)) {
     warnings.push("Options chain does not match the requested ticker"); chain = null;
   }
   const expirationDates = [...new Set((chain?.expirationDates ?? []).filter((expiration) =>
     positive(expiration) && daysToExpiryFrom(expiration, now) > 0))].sort((a, b) => a - b);
-  if (chain && request.expiration != null && (!expirationDates.includes(request.expiration)
-    || [...chain.calls, ...chain.puts].some((contract) => contract.expiration !== request.expiration))) {
+  // A typed date is that day's UTC midnight; the chain's own stamp for the
+  // expiry is matched by calendar date, as OMON matches it.
+  const listedExpiration = request.expiration == null ? undefined : findListedExpiry(request.expiration, expirationDates);
+  const onExpiry = (value: OptionsChain, expiration: number) => [...value.calls, ...value.puts]
+    .every((contract) => expiryIsoDate(contract.expiration) === expiryIsoDate(expiration));
+  if (chain && listedExpiration != null && listedExpiration !== request.expiration && !chain.calls.length && !chain.puts.length) {
+    // A source that keys chains by its exact stamp answered the midnight request empty.
+    chainEntry = await abortable(dependencies.loadOptions({ instrument: request.instrument, expirationDate: listedExpiration }, options)
+      .catch((error: unknown) => { warnings.push(`Options chain: ${errorMessage(error)}`); return null; }), request.signal, CANCELLED);
+    if (request.signal?.aborted) throw abortError(CANCELLED);
+    if (chainEntry?.error) warnings.push(`Options chain: ${chainEntry.error.message}`);
+    chain = chainEntry ? resolveEntryValue(chainEntry) : null;
+  }
+  let missingExpiry: string | undefined;
+  if (chain && request.expiration != null && listedExpiration == null) {
+    missingExpiry = sentence(missingExpiryText(request.expiration, expirationDates, symbol));
+    warnings.push(missingExpiry); chain = null;
+  } else if (chain && listedExpiration != null && !onExpiry(chain, listedExpiration)) {
     warnings.push("Selected expiration unavailable in the returned options chain"); chain = null;
   }
   if (!chain) warnings.push("Options chain unavailable");
@@ -117,15 +136,22 @@ export async function loadScenarioMarket(
   if (curveResult.status === "rejected") warnings.push(`Treasury: ${errorMessage(curveResult.reason)}`);
   const rate = surfaceTreasuryRate(curve, rateExpiration == null ? NaN : daysToExpiryFrom(rateExpiration, now) / 365);
   warnings.push(...rate.warnings);
+  // A currency does not go stale with its quote: the listing's quote, its snapshot, or its contracts name it.
+  const currency = [symbolMatches(quote?.symbol, symbol) ? quote?.currency : undefined,
+    symbolMatches(financialsSymbol, symbol) ? financials?.quote?.currency : undefined,
+    chain?.calls[0]?.currency, chain?.puts[0]?.currency].find((value) => !!value?.trim())?.trim().toUpperCase() ?? "";
   return {
-    symbol, exchange: request.instrument.exchange, spot: quoteCurrent ? quote!.price : null, currency: quoteCurrent ? quote!.currency : "",
+    symbol, exchange: request.instrument.exchange, spot: quoteCurrent ? quote!.price : null, currency,
     asOf: quoteCurrent && positive(quote!.lastUpdated) ? quote!.lastUpdated : now,
     chain, expirationDates, rate: rate.rate, dividendYield: validDividend ? fundamentals!.dividendYield! : null,
     source: quoteCurrent ? quoteEntry?.source ?? quote!.providerId ?? null : null,
     underlyingQuote: quoteCurrent ? quote : null, rateAsOf: rate.asOf, warnings: [...new Set(warnings)],
+    ...(missingExpiry ? { missingExpiry } : {}),
   };
 }
 
+const sentence = (text: string) => text.charAt(0).toUpperCase() + text.slice(1);
+
 function supplied(value: unknown): boolean { return value != null && value !== ""; }
 
 function numericSetting(settings: Record<string, unknown>, key: string): number | undefined {
@@ -175,13 +201,18 @@ export function scenarioPositionFromSettings(
   const dividendYield = dividendValue == null ? market?.dividendYield : dividendValue / 100;
   const legText = typeof settings.legs === "string" ? settings.legs : "";
   let legs = legText.trim() ? parseLegs(legText) : [];
+  const strike = numericSetting(settings, "strike");
+  if (strike != null && !(strike > 0)) throw new Error("strike must be positive");
+  if (strike != null && !supplied(settings.strategy)) throw new Error("strike picks the strike of --strategy; add --strategy put, vertical or straddle");
   if (!legs.length && supplied(settings.strategy)) {
-    if (settings.strategy !== "vertical" && settings.strategy !== "straddle") throw new Error("strategy must be vertical or straddle");
-    if (!market?.chain || market.warnings.includes("Options chain is stale")) throw new Error("A current options chain is required to seed a strategy");
+    if (!isScenarioStrategy(settings.strategy)) throw new Error("strategy must be vertical, straddle or put");
+    if (!market?.chain || market.warnings.includes("Options chain is stale")) {
+      throw new Error(market?.missingExpiry ?? "A current options chain is required to seed a strategy");
+    }
     if (spot == null) throw new Error("A current underlying price or explicit --spot is required");
     // Leg IVs are solved at the market's own spot and time, never at a what-if override.
     const pricing = market.spot != null && rate != null ? { spot: market.spot, asOf: market.asOf, rate } : null;
-    const seeded = scenarioStrategyLegs(market.chain, spot, settings.strategy, pricing);
+    const seeded = scenarioStrategyLegs(market.chain, spot, settings.strategy, pricing, strike);
     legs = seeded.legs;
     // Mids priced off the parity forward are worth their cost only at the spot
     // that forward implies on the scenario's own rate and dividend yield. The
@@ -198,7 +229,7 @@ export function scenarioPositionFromSettings(
   if (dividendYield == null) throw new Error("Dividend yield unavailable; supply --dividend-yield as an annual percentage");
   const position: ScenarioPosition = {
     symbol, exchange: exchange ?? market?.exchange,
-    currency: String(settings.currency ?? market?.currency ?? "").trim().toUpperCase() || "UNKNOWN",
+    currency: scenarioCurrency(settings.currency, market?.currency, exchange ?? market?.exchange),
     spot, rate, dividendYield, asOf: dateSetting(settings, "asOf") ?? market?.asOf ?? Date.now(), legs,
   };
   const error = validatePosition(position);
@@ -210,6 +241,9 @@ export function scenarioPositionFromSettings(
   return position;
 }
 
+type ScenarioStrategy = "vertical" | "straddle" | "put";
+const isScenarioStrategy = (value: unknown): value is ScenarioStrategy => value === "vertical" || value === "straddle" || value === "put";
+
 interface StrategyPricing { spot: number; asOf: number; rate: number }
 
 const usableVolatility = (value: unknown): value is number => positive(value) && value <= 5;
@@ -230,9 +264,13 @@ interface StrategyParity { forward: number; daysToExpiry: number }
  * keeps a usable provider IV, and without one it is not eligible. `parity` is
  * the forward a seeded leg was solved against, so the caller can start the
  * scenario at the spot it implies.
+ *
+ * Each strategy is anchored at the strike nearest spot, or at `strike` when
+ * one is given: a long put (a protective put), a call vertical from the
+ * anchor to the next listed strike up, or a straddle at the anchor.
  */
 function scenarioStrategyLegs(
-  chain: OptionsChain, spot: number, strategy: "vertical" | "straddle", pricing: StrategyPricing | null,
+  chain: OptionsChain, spot: number, strategy: ScenarioStrategy, pricing: StrategyPricing | null, strike?: number,
 ): { legs: ScenarioLeg[]; parity: StrategyParity | null } {
   const parity = new Map<number, StrategyParity | null>();
   const parityFor = (expiration: number) => {
@@ -256,12 +294,30 @@ function scenarioStrategyLegs(
     if (usableVolatility(volatility)) return [{ contract, mid, volatility, solved: true }];
     return usableVolatility(contract.impliedVolatility) ? [{ contract, mid, volatility: contract.impliedVolatility, solved: false }] : [];
   });
-  const calls = quoted(chain.calls, "call").sort((a, b) => Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot));
-  const puts = quoted(chain.puts, "put");
-  const first = calls.find(({ contract: call }) => strategy === "vertical"
-    ? calls.some(({ contract: other }) => other.expiration === call.expiration && other.strike > call.strike)
-    : puts.some(({ contract: put }) => put.expiration === call.expiration && put.strike === call.strike));
-  if (!first) throw new Error("The selected chain has no complete quoted strategy with usable IV");
+  const nearest = (a: { contract: { strike: number } }, b: { contract: { strike: number } }) =>
+    Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot);
+  const anchored = ({ contract }: { contract: { strike: number } }) => strike == null || Math.abs(contract.strike - strike) < 1e-9;
+  const calls = quoted(chain.calls, "call").sort(nearest);
+  const puts = quoted(chain.puts, "put").sort(nearest);
+  const missing = (candidates: { contract: { strike: number } }[]) => {
+    if (strike == null) return new Error("The selected chain has no complete quoted strategy with usable IV");
+    const listed = [...new Set(candidates.map(({ contract }) => contract.strike))]
+      .sort((a, b) => Math.abs(a - strike) - Math.abs(b - strike)).slice(0, 4).sort((a, b) => a - b);
+    return new Error(`The selected chain has no complete quoted ${strategy} at strike ${strike} with usable IV`
+      + (listed.length ? `; nearest quoted strikes: ${listed.join(", ")}` : ""));
+  };
+  if (strategy === "put") {
+    const put = puts.find(anchored);
+    if (!put) throw missing(puts);
+    return { legs: [{ id: put.contract.contractSymbol, side: "put", quantity: 1, strike: put.contract.strike,
+      expiration: put.contract.expiration, price: put.mid, priceSource: "mid", volatility: put.volatility, multiplier: 100,
+      ...(put.solved ? { volatilitySource: "mid" as const } : {}) }],
+    parity: put.solved ? parityFor(put.contract.expiration) : null };
+  }
+  const first = calls.find((entry) => anchored(entry) && (strategy === "vertical"
+    ? calls.some(({ contract: other }) => other.expiration === entry.contract.expiration && other.strike > entry.contract.strike)
+    : puts.some(({ contract: put }) => put.expiration === entry.contract.expiration && put.strike === entry.contract.strike)));
+  if (!first) throw missing(calls);
   const second = strategy === "vertical"
     ? calls.filter(({ contract }) => contract.expiration === first.contract.expiration && contract.strike > first.contract.strike)
       .sort((a, b) => a.contract.strike - b.contract.strike)[0]!
@@ -270,7 +326,7 @@ function scenarioStrategyLegs(
   const legs = [first, second].map(({ contract, mid, volatility, solved }, index): ScenarioLeg => ({
     id: contract.contractSymbol, side: index === 1 && strategy === "straddle" ? "put" : "call",
     quantity: index === 1 && strategy === "vertical" ? -1 : 1, strike: contract.strike,
-    expiration: contract.expiration, price: mid, volatility, multiplier: 100,
+    expiration: contract.expiration, price: mid, priceSource: "mid", volatility, multiplier: 100,
     ...(solved ? { volatilitySource: "mid" as const } : {}),
   }));
   return { legs, parity: first.solved || second.solved ? parityFor(first.contract.expiration) : null };

package/src/plugins/builtin/options-scenario/headless.ts

@@ -1,38 +1,66 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
+import {
+  expirationOptionSeconds, OPTION_EXPIRATION_FORMAT, OPTION_EXPIRATION_PLACEHOLDER, readOptionExpiration,
+} from "../../../utils/option-expiry";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import {
   createScenarioDependencies, loadScenarioMarket, scenarioControlsFromSettings, scenarioPositionFromSettings,
   type ScenarioMarketSnapshot,
 } from "./client";
-import { buildScenario, parseLegs } from "./model";
+import { buildScenario, currencyLabel, parseLegs, scenarioValueUnit } from "./model";
+import { hedgeInputsFromSettings, hedgeReportEntries, scenarioHedgeBudget } from "./hedge";
 
 // Float noise at a flat origin or a breakeven prints as 0.00, not -0.00.
 const money = (value: unknown) => typeof value === "number" ? (Math.abs(value) < 0.005 ? 0 : value).toFixed(2) : "--";
+const percent = (value: unknown) => typeof value === "number" ? `${(value * 100).toFixed(2)}%` : "--";
 const supplied = (value: unknown) => value != null && value !== "";
+// A seeded entry is a quote midpoint, often to the half cent (5.495), so it keeps up to four decimals.
+const premium = (value: unknown) => typeof value === "number"
+  ? value.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 4, useGrouping: false }) : "--";
+/** Entry prices and spot are quoted per share of the underlying. */
+const PRICE_UNIT = "per share";
+/** The Valuation entries, in model order, with the unit each is in. */
+const VALUATION_LABELS: Record<string, (currency: string) => string> = {
+  price: () => "Value", pnl: () => "P&L", delta: () => "Delta (shares)", gamma: () => "Gamma (shares per 1.00 move)",
+  thetaPerDay: (currency) => `Theta (${currency} per day)`, vegaPerPoint: (currency) => `Vega (${currency} per vol point)`,
+  rhoPerPoint: (currency) => `Rho (${currency} per rate point)`,
+};
 
 export const optionsScenarioHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Underlying ticker" },
   describe: (args) => `OSA ${args.symbols[0] ?? ""}`,
+  description: "A typed or chain-seeded options position valued across spot, date and volatility: its legs, value and Greeks, expiry risk and a "
+    + "scenario P&L grid. With --nav and --budget-bps, how many contracts a hedge budget buys, the premium spent, the notional protected and "
+    + "coverage of an equity sleeve.",
   discovery: { screenshotReadiness: "ready", limitations: ["European scenario values do not model early assignment or exercise."] },
   options: [
     { key: "tab", type: "enum", values: ["payoff", "grid", "legs"].map((value) => ({ value })), defaultValue: "payoff",
       description: "Initial view", pluginState: { pluginId: "ticker-research", key: "activeTabId" } },
-    { key: "legs", type: "string", description: "Semicolon-separated side,strike,YYYY-MM-DD,signed quantity,entry price,IV percent[,multiplier]" },
-    { key: "strategy", type: "enum", values: [{ value: "vertical" }, { value: "straddle" }], description: "Build an explicit example from current two-sided chain quotes" },
-    { key: "expiration", type: "integer", minimum: 1, description: "Chain expiration in Unix seconds" },
+    { key: "legs", type: "string", description: "Semicolon-separated side,strike,YYYY-MM-DD,signed quantity,entry price per share,IV percent[,multiplier]" },
+    { key: "strategy", type: "enum", values: [{ value: "vertical" }, { value: "straddle" }, { value: "put" }],
+      description: "Build a position from current two-sided chain quotes: a call vertical, a straddle, or one long put (a protective put)" },
+    { key: "strike", type: "string", description: "The --strategy strike: the put, the vertical's long call or the straddle. Nearest the money when omitted" },
+    { key: "expiration", type: "string", placeholder: OPTION_EXPIRATION_PLACEHOLDER, example: "--strategy vertical --expiration 2027-01-15",
+      description: `Chain expiry for --strategy, as ${OPTION_EXPIRATION_FORMAT}`, normalize: (value) => expirationOptionSeconds(value) },
     { key: "spot", type: "string", description: "Underlying price override, per share" },
     { key: "rate", type: "string", description: "Continuously compounded annual risk-free rate, percent" },
     { key: "dividendYield", aliases: ["dividend-yield"], type: "string", description: "Continuous annual dividend yield, percent" },
-    { key: "currency", type: "string", description: "Monetary unit for supplied inputs, such as USD" },
+    { key: "currency", type: "string", description: "Currency of the inputs, such as USD; the underlying's when omitted" },
     { key: "asOf", aliases: ["as-of"], type: "string", description: "Position valuation timestamp: UTC ISO or YYYY-MM-DD" },
     { key: "date", type: "string", description: "Scenario date: UTC ISO or YYYY-MM-DD" },
     { key: "volShift", aliases: ["vol-shift"], type: "string", defaultValue: "0", description: "Parallel volatility shift, percentage points" },
     { key: "spotRange", aliases: ["spot-range"], type: "string", defaultValue: "30", description: "Spot grid range above and below current spot, percent" },
+    { key: "nav", type: "string", description: "Portfolio NAV for a hedge budget, such as 100m, 2.5bn, 250k, 1,000,000 or $100m. Needs --budget-bps" },
+    { key: "budgetBps", aliases: ["budget-bps"], type: "string", example: "--strategy put --strike 700 --expiration 2027-01-15 --nav 100m --budget-bps 50",
+      description: "Hedge budget in basis points of --nav (50 is 0.5%): the report says how many of the position it buys, the premium, and the notional protected" },
+    { key: "sleeve", aliases: ["equity-sleeve"], type: "string", description: "Equity sleeve the hedge protects, for coverage = notional / sleeve. Same amount forms as --nav" },
   ],
   async load(args, ctx) {
     const symbol = args.symbols[0]!;
     const settings: Record<string, unknown> = { ...ctx.settings, ...args.options, symbol };
+    // Bad hedge inputs fail before any market request.
+    hedgeInputsFromSettings(settings);
     const suppliedInputs = !!settings.legs && ["spot", "rate", "dividendYield"].every((key) => settings[key] != null && settings[key] !== "");
     let market: ScenarioMarketSnapshot;
     if (suppliedInputs) {
@@ -42,8 +70,8 @@ export const optionsScenarioHeadless: HeadlessPaneDefinition<"bundle"> = {
     } else {
       const instrument = await resolveHeadlessInstrument(ctx, symbol);
       const typedExpiries = typeof settings.legs === "string" && settings.legs.trim() ? parseLegs(settings.legs).map((leg) => leg.expiration) : [];
-      market = await loadScenarioMarket({ instrument,
-        expiration: typeof args.options.expiration === "number" ? args.options.expiration : undefined,
+      const expiration = readOptionExpiration(args.options.expiration);
+      market = await loadScenarioMarket({ instrument, expiration: expiration ?? undefined,
         rateExpiration: typedExpiries.length ? Math.min(...typedExpiries) : undefined, signal: ctx.signal,
       }, createScenarioDependencies(ctx.marketData, ctx.apiClient));
     }
@@ -51,13 +79,21 @@ export const optionsScenarioHeadless: HeadlessPaneDefinition<"bundle"> = {
     const position = scenarioPositionFromSettings(settings, market);
     const controls = position ? scenarioControlsFromSettings(settings, position) : null;
     const scenario = position && controls ? buildScenario(position, controls) : null;
-    const errors = scenario ? [...new Set([...market.warnings, ...scenario.warnings])]
-      : [...market.warnings, "No position supplied; add --legs or select --strategy"];
+    const hedge = scenarioHedgeBudget(settings, position, market);
+    // A typed rate or yield stands in for the source that could not supply one.
+    const marketWarnings = market.warnings.filter((warning) => !(supplied(settings.dividendYield) && warning.startsWith("Dividend yield unavailable"))
+      && !(supplied(settings.rate) && warning.startsWith("Treasury")));
+    const errors = scenario ? [...new Set([...marketWarnings, ...scenario.warnings])]
+      : [...marketWarnings, "No position supplied; add --legs or select --strategy"];
     const midVolatility = !!position?.legs.some((leg) => leg.volatilitySource === "mid");
     // A seeded strategy starts at the spot its quote mids imply; the last print is reported beside it.
     const lastPrint = midVolatility && !supplied(settings.spot) && market.spot != null && money(market.spot) !== money(position!.spot)
       ? market.spot : null;
     const chain = market.chain;
+    const currency = position ? currencyLabel(position.currency) : null;
+    // Value, P&L, risk and the grid add every contract; entry prices and spot are per share.
+    const valueUnit = position ? scenarioValueUnit(position) : null;
+    const per = `${currency} ${valueUnit}`;
     return {
       freshness: suppliedInputs
         ? { source: "Your inputs", status: "not-a-feed", basis: "scenario" }
@@ -66,33 +102,44 @@ export const optionsScenarioHeadless: HeadlessPaneDefinition<"bundle"> = {
       sections: scenario ? [
         { title: "Position", columns: [
           { key: "side", header: "Side" }, { key: "strike", header: "Strike" }, { key: "expiry", header: "Expiry" },
-          { key: "quantity", header: "Quantity" }, { key: "price", header: "Entry", format: money },
+          { key: "quantity", header: "Contracts" }, { key: "price", header: "Entry/share", format: premium },
           { key: "volatility", header: "IV", format: (value) => typeof value === "number" ? `${(value * 100).toFixed(2)}%` : "--" },
           ...(midVolatility ? [{ key: "volatilityFrom", header: "IV from" }] : []),
           { key: "multiplier", header: "Multiplier" },
         ], rows: position!.legs.map((leg) => ({ ...leg, expiry: new Date(leg.expiration * 1000).toISOString().slice(0, 10),
           ...(midVolatility ? { volatilityFrom: leg.volatilitySource === "mid" ? "quote mid" : "provider" } : {}) })) },
-        ...(lastPrint != null ? [{ title: "Spot", entries: [
-          { key: "spot", label: "Implied by option quotes", value: position!.spot, formatted: money(position!.spot) },
-          { key: "last", label: "Last price", value: lastPrint, formatted: money(lastPrint) },
-        ] }] : []),
-        { title: "Valuation", entries: Object.entries(scenario.valuation).map(([key, value]) => ({ key, label: key, value, formatted: money(value) })) },
-        { title: "Expiry risk", entries: [
-          { label: "Breakevens", value: scenario.expiryRisk.breakevens },
-          { label: "Max profit", value: scenario.expiryRisk.maxProfit, formatted: scenario.expiryRisk.unlimitedProfit ? "Unlimited" : money(scenario.expiryRisk.maxProfit) },
-          { label: "Max loss", value: scenario.expiryRisk.maxLoss, formatted: scenario.expiryRisk.unlimitedLoss ? "Unlimited" : money(scenario.expiryRisk.maxLoss) },
-          ...(scenario.expiryRisk.reason ? [{ label: "Limitation", value: scenario.expiryRisk.reason }] : []),
+        { title: "Inputs", entries: [
+          { key: "spot", label: lastPrint != null ? "Spot implied by option quotes" : "Spot", value: position!.spot,
+            formatted: `${money(position!.spot)} ${PRICE_UNIT}` },
+          ...(lastPrint != null ? [{ key: "last", label: "Last price", value: lastPrint, formatted: `${money(lastPrint)} ${PRICE_UNIT}` }] : []),
+          { key: "rate", label: "Rate", value: position!.rate, formatted: percent(position!.rate) },
+          { key: "dividendYield", label: "Dividend yield", value: position!.dividendYield, formatted: percent(position!.dividendYield) },
+          { key: "currency", label: "Currency", value: position!.currency, formatted: currency! },
+        ] },
+        ...(hedge ? [{ title: "Hedge budget", entries: hedgeReportEntries(hedge) }] : []),
+        { title: `Valuation (${per})`, entries: Object.entries(scenario.valuation).map(([key, value]) => ({ key,
+          label: VALUATION_LABELS[key]?.(currency!) ?? key, value, formatted: money(value) })) },
+        { title: `Expiry risk (${per})`, entries: [
+          { key: "breakevens", label: "Breakevens (spot)", value: scenario.expiryRisk.breakevens,
+            formatted: scenario.expiryRisk.breakevens.map(money).join(", ") || "none" },
+          { key: "maxProfit", label: "Max profit", value: scenario.expiryRisk.maxProfit, formatted: scenario.expiryRisk.unlimitedProfit ? "Unlimited" : money(scenario.expiryRisk.maxProfit) },
+          { key: "maxLoss", label: "Max loss", value: scenario.expiryRisk.maxLoss, formatted: scenario.expiryRisk.unlimitedLoss ? "Unlimited" : money(scenario.expiryRisk.maxLoss) },
+          ...(scenario.expiryRisk.reason ? [{ key: "limitation", label: "Limitation", value: scenario.expiryRisk.reason }] : []),
         ] },
-        { title: "Scenario grid", columns: [
-          { key: "spot", header: "Spot" }, { key: "move", header: "Move", format: (value) => typeof value === "number" && Number.isFinite(value) ? `${(value * 100).toFixed(1)}%` : "--" },
+        { title: `Scenario grid (P&L, ${per})`, columns: [
+          { key: "spot", header: "Spot/share", format: money },
+          { key: "move", header: "Move", format: (value) => typeof value === "number" && Number.isFinite(value) ? `${(value * 100).toFixed(1)}%` : "--" },
           ...scenario.dates.map((date, index) => ({ key: `date${index}`, header: new Date(date).toISOString().slice(0, 10), format: money })),
         ], rows: scenario.grid.map((row) => ({ spot: row.spot, move: row.move,
           ...Object.fromEntries(row.values.map((value, index) => [`date${index}`, value])) })) },
       ] : [],
       complete: scenario != null && errors.length === 0,
       unavailableSymbols: scenario ? [] : [symbol], errors,
-      metadata: { scenario, position, controls, market, inputSource: suppliedInputs ? "user" : "market",
-        unit: position?.currency || "currency unspecified", methodology: "docs/research-data.md#options-scenario-analysis" },
+      metadata: { scenario, position, controls, market, ...(hedge ? { hedge } : {}), inputSource: suppliedInputs ? "user" : "market",
+        unit: position?.currency || "currency unspecified",
+        // Leg entry prices and spot are per share; value, P&L, risk, Greeks in currency and the grid are for valueUnit.
+        ...(position ? { units: { currency: position.currency, price: PRICE_UNIT, value: valueUnit } } : {}),
+        methodology: "docs/research-data.md#options-scenario-analysis" },
     };
   },
 };