gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/options-calculator/binomial.ts

@@ -1,4 +1,6 @@
-import { valueOption, type ImpliedVolatilityResult, type OptionCalcDraft, type OptionValuation } from "./model";
+import type { OptionCalcDraft } from "./model";
+import { valueOption, type ImpliedVolatilityResult, type OptionValuation } from "../shared/volatility";
+import { isFiniteNumber } from "../../../utils/guards";
 
 const DAYS_PER_YEAR = 365;
 export const DEFAULT_BINOMIAL_STEPS = 400;
@@ -28,16 +30,15 @@ interface PreparedInputs extends BinomialInputs {
   discount: number;
 }
 
-const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
 const intrinsic = (draft: OptionCalcDraft, spot: number) => Math.max(0, draft.side === "call" ? spot - draft.strike : draft.strike - spot);
 
 export function validateBinomialInputs(draft: OptionCalcDraft, input: Partial<BinomialInputs> = {}): string | null {
   if (!draft || typeof draft !== "object") return "Option inputs are required.";
   if (draft.side !== "call" && draft.side !== "put") return "Side must be call or put.";
   for (const [key, label] of [["spot", "Spot"], ["strike", "Strike"], ["daysToExpiry", "Days to expiry"], ["volatility", "Volatility"]] as const) {
-    if (!finite(draft[key]) || draft[key] < 0) return `${label} must be finite and nonnegative.`;
+    if (!isFiniteNumber(draft[key]) || draft[key] < 0) return `${label} must be finite and nonnegative.`;
   }
-  if (!finite(draft.rate) || !finite(draft.dividendYield)) return "Rate and continuous dividend yield must be finite.";
+  if (!isFiniteNumber(draft.rate) || !isFiniteNumber(draft.dividendYield)) return "Rate and continuous dividend yield must be finite.";
   if (!input || typeof input !== "object" || Array.isArray(input)) return "Binomial settings must be an object.";
   const exercise = input.exercise === undefined ? "american" : input.exercise;
   if (exercise !== "american" && exercise !== "european") return "Exercise must be american or european.";
@@ -46,10 +47,10 @@ export function validateBinomialInputs(draft: OptionCalcDraft, input: Partial<Bi
   const dividends = input.dividends === undefined ? [] : input.dividends;
   if (!Array.isArray(dividends) || dividends.length > 64) return "Supply at most 64 discrete cash dividends.";
   for (const dividend of dividends) {
-    if (!dividend || typeof dividend !== "object" || !finite(dividend.days) || dividend.days < 0 || dividend.days > draft.daysToExpiry) {
+    if (!dividend || typeof dividend !== "object" || !isFiniteNumber(dividend.days) || dividend.days < 0 || dividend.days > draft.daysToExpiry) {
       return "Dividend dates must be finite days from valuation through expiry.";
     }
-    if (!finite(dividend.amount) || dividend.amount < 0) return "Dividend cash amounts must be finite and nonnegative.";
+    if (!isFiniteNumber(dividend.amount) || dividend.amount < 0) return "Dividend cash amounts must be finite and nonnegative.";
   }
   return null;
 }
@@ -61,7 +62,7 @@ function prepare(draft: OptionCalcDraft, input: Partial<BinomialInputs>): Prepar
   for (const dividend of input.dividends ?? []) {
     if (dividend.amount === 0) continue;
     const amount = (byDate.get(dividend.days) ?? 0) + dividend.amount;
-    if (!finite(amount)) throw new Error("Dividend amounts exceed model precision.");
+    if (!isFiniteNumber(amount)) throw new Error("Dividend amounts exceed model precision.");
     byDate.set(dividend.days, amount);
   }
   const dividends = [...byDate].sort((a, b) => a[0] - b[0]).map(([days, amount]) => ({ days, amount }));
@@ -82,8 +83,8 @@ function prepare(draft: OptionCalcDraft, input: Partial<BinomialInputs>): Prepar
     if (dx > 0 && (Math.exp(dx) === 1 || Math.exp(-dx) === 1)) throw new Error("Tree increments are below floating-point resolution.");
     const probability = Math.expm1(carry * dt + dx) / Math.expm1(2 * dx);
     const discount = Math.exp(-draft.rate * dt);
-    if (!finite(dx) || dx <= 0 || !finite(discount) || discount <= 0) break;
-    if (finite(probability) && probability > 0 && probability < 1) {
+    if (!isFiniteNumber(dx) || dx <= 0 || !isFiniteNumber(discount) || discount <= 0) break;
+    if (isFiniteNumber(probability) && probability > 0 && probability < 1) {
       return { ...base, effectiveSteps, dx, probability, discount };
     }
   }
@@ -96,7 +97,7 @@ export function effectiveBinomialSteps(draft: OptionCalcDraft, input: Partial<Bi
 }
 
 function finitePrice(value: number): number {
-  if (!finite(value)) throw new Error("Option inputs exceed binomial model precision.");
+  if (!isFiniteNumber(value)) throw new Error("Option inputs exceed binomial model precision.");
   return Math.max(0, value);
 }
 
@@ -112,12 +113,12 @@ function deterministicPrice(draft: OptionCalcDraft, inputs: PreparedInputs): num
     // Discounted intrinsic is a difference of two exponentials. Endpoints
     // plus its one possible stationary point exhaust every exercise choice.
     const ratio = rate * draft.strike / (yieldRate * spot);
-    if (inputs.exercise === "american" && duration > 0 && carry !== 0 && ratio > 0 && finite(ratio)) {
+    if (inputs.exercise === "american" && duration > 0 && carry !== 0 && ratio > 0 && isFiniteNumber(ratio)) {
       const stationary = Math.log(ratio) / carry;
       if (stationary > 0 && stationary < duration) best = Math.max(best, at(spot * Math.exp(carry * stationary), time + stationary));
     }
     if (spot > 0) spot *= Math.exp(carry * duration);
-    if (!finite(spot)) throw new Error("Deterministic stock carry exceeds model precision.");
+    if (!isFiniteNumber(spot)) throw new Error("Deterministic stock carry exceeds model precision.");
     time = end;
     if (inputs.exercise === "american") best = Math.max(best, at(spot, time));
   };
@@ -170,12 +171,12 @@ function cashDividendPrice(draft: OptionCalcDraft, inputs: PreparedInputs): numb
     spots[j] = Math.exp(logSpot + (lowerIndex + j) * dx);
     values[j] = intrinsic(draft, spots[j]!);
   }
-  if (spots[0] === 0 || !finite(spots.at(-1))) throw new Error("Cash-dividend grid exceeds model precision.");
+  if (spots[0] === 0 || !isFiniteNumber(spots.at(-1))) throw new Error("Cash-dividend grid exceeds model precision.");
   const cashByStep = new Map<number, number>();
   for (const dividend of inputs.dividends) {
     const step = Math.round(dividend.days / draft.daysToExpiry * n);
     const amount = (cashByStep.get(step) ?? 0) + dividend.amount;
-    if (!finite(amount)) throw new Error("Dividend amounts exceed model precision.");
+    if (!isFiniteNumber(amount)) throw new Error("Dividend amounts exceed model precision.");
     cashByStep.set(step, amount);
   }
   let zeroValue = intrinsic(draft, 0);
@@ -274,7 +275,7 @@ export function solveBinomialImpliedVolatility(
   draft: OptionCalcDraft, marketPrice: number, input: Partial<BinomialInputs> = {},
 ): ImpliedVolatilityResult {
   if (marketPrice === 0) return { volatility: null, note: null };
-  if (!finite(marketPrice) || marketPrice < 0) return { volatility: null, note: "Market price must be finite and positive." };
+  if (!isFiniteNumber(marketPrice) || marketPrice < 0) return { volatility: null, note: "Market price must be finite and positive." };
   const problem = validateBinomialInputs(draft, input);
   if (problem) return { volatility: null, note: problem };
   if (draft.daysToExpiry <= 0) return { volatility: null, note: "Expired, no implied volatility." };
@@ -285,7 +286,7 @@ export function solveBinomialImpliedVolatility(
     : draft.strike * Math.exp(-draft.rate * years);
   const bound = american ? Math.max(upper, draft.side === "call" ? draft.spot : draft.strike) : upper;
   const tolerance = Math.max(1, draft.spot, draft.strike) * 1e-8;
-  if (!finite(bound)) return { volatility: null, note: "Inputs exceed model precision." };
+  if (!isFiniteNumber(bound)) return { volatility: null, note: "Inputs exceed model precision." };
   if (marketPrice >= bound - tolerance) return { volatility: null, note: marketPrice > bound + tolerance
     ? "Market price is above the model's no-arbitrage maximum." : "No finite IV at the model maximum." };
   if (american && marketPrice < intrinsic(draft, draft.spot) - tolerance) {

package/src/plugins/builtin/options-calculator/evidence.ts

@@ -1,9 +1,14 @@
+import type { DesktopPaneShotPayload } from "../../../cli/desktop-pane-shot";
+import type { PaneScreenshotEvidenceHook } from "../../../cli/pane-functions/screenshot-evidence";
 import { useRemoteUiNode } from "../../../remote/semantic-tree";
+import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { DEFAULT_BINOMIAL_STEPS, MAX_BINOMIAL_STEPS, effectiveBinomialSteps, solveBinomialImpliedVolatility,
   validateBinomialInputs, valueBinomialOption } from "./binomial";
-import { solveImpliedVolatility, valueOption, type ImpliedVolatilityResult, type OptionCalcDraft,
-  type OptionValuation } from "./model";
-import type { CalculatorSurfaceVol } from "./surface";
+import { draftFromCalculatorInputs } from "./inputs";
+import { OPTIONS_CALCULATOR_PANE_ID, type OptionCalcDraft } from "./model";
+import { solveImpliedVolatility, valueOption, type ImpliedVolatilityResult, type OptionValuation } from "../shared/volatility";
+import { createCalculatorSurfaceDependencies, loadCalculatorSurfaceVol, type CalculatorSurfaceVol } from "./surface";
+import { isDateString, isFiniteNumber, isRecord, isStringArray } from "../../../utils/guards";
 
 export const CALCULATOR_IGNORED_DIVIDENDS_NOTICE = "Cash dividend schedule is ignored by the European model; continuous yield applies.";
 
@@ -43,11 +48,8 @@ export interface CalculatorEvidence {
   plottedValueCount: number;
 }
 
-const record = (value: unknown): value is Record<string, unknown> => !!value && typeof value === "object" && !Array.isArray(value);
-const finite = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
-const strings = (value: unknown): value is string[] => Array.isArray(value) && value.every((entry) => typeof entry === "string");
 const nullableText = (value: unknown): value is string | null => value === null || typeof value === "string";
-const nullableNumber = (value: unknown): value is number | null => value === null || finite(value);
+const nullableNumber = (value: unknown): value is number | null => value === null || isFiniteNumber(value);
 const metrics = ["price", "delta", "gamma", "thetaPerDay", "vegaPerPoint", "rhoPerPoint"] as const;
 const sameNumber = (actual: number, expected: number): boolean => Math.abs(actual - expected) <= 1e-9 * Math.max(1, Math.abs(expected));
 
@@ -68,37 +70,37 @@ export function normalizeCalculatorEvidenceDraft(draft: OptionCalcDraft): Calcul
 }
 
 function validDraft(value: unknown): value is CalculatorEvidenceDraft {
-  if (!record(value) || typeof value.symbol !== "string" || !["call", "put"].includes(String(value.side))
+  if (!isRecord(value) || typeof value.symbol !== "string" || !["call", "put"].includes(String(value.side))
     || !["european", "american"].includes(String(value.pricingModel)) || !["input", "surface"].includes(String(value.volSource))
-    || !["spot", "strike", "daysToExpiry", "rate", "volatility", "dividendYield", "marketPrice"].every((key) => finite(value[key]))
-    || !finite(value.marketPrice) || value.marketPrice < 0 || !finite(value.steps) || !Number.isInteger(value.steps)
+    || !["spot", "strike", "daysToExpiry", "rate", "volatility", "dividendYield", "marketPrice"].every((key) => isFiniteNumber(value[key]))
+    || !isFiniteNumber(value.marketPrice) || value.marketPrice < 0 || !isFiniteNumber(value.steps) || !Number.isInteger(value.steps)
     || value.steps < 1 || value.steps > MAX_BINOMIAL_STEPS || !Array.isArray(value.dividends)) return false;
   const draft = value as unknown as CalculatorEvidenceDraft;
   return validateBinomialInputs(draft, { exercise: draft.pricingModel, steps: draft.steps, dividends: draft.dividends }) === null;
 }
 
 function validValuation(value: unknown): value is OptionValuation {
-  return record(value) && metrics.every((key) => finite(value[key])) && (value.price as number) >= 0;
+  return isRecord(value) && metrics.every((key) => isFiniteNumber(value[key])) && (value.price as number) >= 0;
 }
 
 function validImplied(value: unknown): value is ImpliedVolatilityResult {
-  return record(value) && nullableNumber(value.volatility) && (value.volatility === null || value.volatility >= 0)
+  return isRecord(value) && nullableNumber(value.volatility) && (value.volatility === null || value.volatility >= 0)
     && nullableText(value.note);
 }
 
 function validSurface(value: unknown): value is CalculatorSurfaceVol {
-  return record(value) && nullableNumber(value.volatility) && nullableNumber(value.rate) && nullableNumber(value.dividendYield)
+  return isRecord(value) && nullableNumber(value.volatility) && nullableNumber(value.rate) && nullableNumber(value.dividendYield)
     && nullableNumber(value.sourceSpot) && nullableNumber(value.spotAsOf) && nullableText(value.asOf)
-    && (value.asOf === null || Number.isFinite(Date.parse(value.asOf)))
-    && strings(value.rateAsOf) && typeof value.source === "string" && value.source.length > 0
-    && strings(value.warnings) && nullableText(value.error);
+    && (value.asOf === null || isDateString(value.asOf))
+    && isStringArray(value.rateAsOf) && typeof value.source === "string" && value.source.length > 0
+    && isStringArray(value.warnings) && nullableText(value.error);
 }
 
 function sourceReady(draft: CalculatorEvidenceDraft, surface: CalculatorSurfaceVol | null): boolean {
   return draft.volSource === "input" || (!!draft.symbol.trim() && !!surface && validSurface(surface)
-    && surface.error === null && finite(surface.volatility) && surface.volatility > 0
-    && surface.volatility === draft.volatility && finite(surface.sourceSpot) && surface.sourceSpot > 0
-    && finite(surface.rate) && finite(surface.dividendYield));
+    && surface.error === null && isFiniteNumber(surface.volatility) && surface.volatility > 0
+    && surface.volatility === draft.volatility && isFiniteNumber(surface.sourceSpot) && surface.sourceSpot > 0
+    && isFiniteNumber(surface.rate) && isFiniteNumber(surface.dividendYield));
 }
 
 function noticesPreserved(draft: CalculatorEvidenceDraft, surface: CalculatorSurfaceVol | null, notices: string[]): boolean {
@@ -113,10 +115,10 @@ export function calculatorSemanticEvidence(input: CalculatorEvidenceInput): Calc
   const surface = draft.volSource === "surface" ? input.surface ?? null : null;
   const notices = [...(input.notices ?? [])];
   const stepsReady = draft.pricingModel === "american"
-    ? finite(input.effectiveSteps) && Number.isInteger(input.effectiveSteps) && input.effectiveSteps >= draft.steps
+    ? isFiniteNumber(input.effectiveSteps) && Number.isInteger(input.effectiveSteps) && input.effectiveSteps >= draft.steps
     : input.effectiveSteps == null;
-  const plottedValueCount = (valuation ? metrics.filter((key) => finite(valuation[key])).length : 0)
-    + (finite(input.implied.volatility) ? 1 : 0);
+  const plottedValueCount = (valuation ? metrics.filter((key) => isFiniteNumber(valuation[key])).length : 0)
+    + (isFiniteNumber(input.implied.volatility) ? 1 : 0);
   return { kind: "options-calculator", version: 1, symbol: draft.symbol, draft, valuation, implied: { ...input.implied },
     surface, effectiveSteps: input.effectiveSteps ?? null, loading: input.loading, error: input.error ?? null, notices,
     complete: !input.loading && input.error == null && validDraft(draft) && validValuation(valuation)
@@ -131,9 +133,9 @@ export function useCalculatorEvidence(input: CalculatorEvidenceInput): void {
 
 /** Reprice the selected exercise model, schedule, Greeks and IV before accepting rendered observations. */
 export function readCalculatorEvidence(value: unknown): CalculatorEvidence | null {
-  if (!record(value) || value.kind !== "options-calculator" || value.version !== 1 || typeof value.symbol !== "string"
+  if (!isRecord(value) || value.kind !== "options-calculator" || value.version !== 1 || typeof value.symbol !== "string"
     || !validDraft(value.draft) || value.symbol !== value.draft.symbol || !validValuation(value.valuation)
-    || !validImplied(value.implied) || !nullableText(value.error) || !strings(value.notices)
+    || !validImplied(value.implied) || !nullableText(value.error) || !isStringArray(value.notices)
     || typeof value.loading !== "boolean" || typeof value.complete !== "boolean"
     || (value.surface !== null && !validSurface(value.surface))) return null;
   const evidence = value as unknown as CalculatorEvidence;
@@ -160,3 +162,67 @@ export function readCalculatorEvidence(value: unknown): CalculatorEvidence | nul
   if (evidence.plottedValueCount !== count || evidence.complete !== (!evidence.loading && evidence.error === null)) return null;
   return evidence;
 }
+
+function capturedCalculatorSnapshot(payload: DesktopPaneShotPayload): CalculatorScreenshotSnapshot | undefined {
+  return payload.config?.layout?.instances.find((entry) => entry.instanceId === payload.paneId)
+    ?.settings?.calculatorSnapshot as CalculatorScreenshotSnapshot | undefined;
+}
+
+export const calculatorScreenshotEvidence: PaneScreenshotEvidenceHook<CalculatorEvidence> = {
+  paneId: OPTIONS_CALCULATOR_PANE_ID,
+  kind: "options-calculator",
+  label: "option calculator",
+  read: readCalculatorEvidence,
+  visibleLabels: ["Model", "Implied IV", "Delta", "Gamma", "Theta", "Vega", "Rho"],
+  async prepare({ resolved, context, settings }) {
+    // The screenshot and verifier consume the same inputs and market fit.
+    // Explicit input-IV pricing does not need unrelated quote/history requests.
+    const draft = draftFromCalculatorInputs({ ...settings, ...resolved.options });
+    let surface: CalculatorScreenshotSnapshot["surface"] = null;
+    if (draft.volSource === "surface") {
+      if (!draft.symbol) throw new Error("Surface volatility requires --symbol.");
+      const parsed = parsePublicTickerKey(draft.symbol);
+      const ticker = await context.store.loadTicker(draft.symbol)
+        ?? (draft.symbol !== parsed.symbol ? await context.store.loadTicker(parsed.symbol) : null);
+      surface = await loadCalculatorSurfaceVol({ symbol: parsed.symbol, exchange: parsed.exchange ?? ticker?.metadata.exchange,
+        spot: draft.spot, strike: draft.strike, daysToExpiry: draft.daysToExpiry,
+      }, createCalculatorSurfaceDependencies(context.dataProvider));
+    }
+    return { settings: { calculatorSnapshot: { draft, surface } satisfies CalculatorScreenshotSnapshot } };
+  },
+  symbols({ payload }) {
+    const symbol = capturedCalculatorSnapshot(payload)?.draft.symbol;
+    return symbol ? [symbol] : null;
+  },
+  expectedText({ resolved }) {
+    const symbol = resolved.options.symbol;
+    return typeof symbol === "string" && symbol ? [symbol] : [];
+  },
+  /** A self-consistent calculator must also represent the requested assumptions. */
+  mismatches(evidence, { resolved, payload }) {
+    const snapshot = capturedCalculatorSnapshot(payload);
+    if (!snapshot?.draft) return ["option calculator screenshot inputs are missing"];
+    const mismatches: string[] = [];
+    try {
+      const requested = normalizeCalculatorEvidenceDraft(draftFromCalculatorInputs({ ...resolved.instance?.settings, ...resolved.options }));
+      if (JSON.stringify(normalizeCalculatorEvidenceDraft(snapshot.draft)) !== JSON.stringify(requested)) {
+        mismatches.push("option calculator snapshot does not match requested inputs");
+      }
+    } catch {
+      mismatches.push("requested option calculator inputs are invalid");
+    }
+    const expectedDraft = normalizeCalculatorEvidenceDraft({ ...snapshot.draft,
+      ...(snapshot.draft.volSource === "surface" && snapshot.surface?.volatility != null
+        ? { volatility: snapshot.surface.volatility } : {}) });
+    if (JSON.stringify(evidence.draft) !== JSON.stringify(expectedDraft)) {
+      mismatches.push("rendered option calculator inputs do not match");
+    }
+    if (JSON.stringify(evidence.surface) !== JSON.stringify(snapshot.surface)) {
+      mismatches.push("rendered option calculator surface does not match");
+    }
+    return mismatches;
+  },
+  unavailable(evidence, { resolved }) {
+    return evidence?.complete && !evidence.loading ? [] : [evidence?.symbol || String(resolved.options.symbol ?? "option calculator")];
+  },
+};

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

@@ -2,7 +2,8 @@ import type { HeadlessBundleResult, HeadlessPaneDefinition, HeadlessPaneEntry }
 import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { effectiveBinomialSteps, valueBinomialOption, solveBinomialImpliedVolatility } from "./binomial";
 import { draftFromCalculatorInputs } from "./inputs";
-import { solveImpliedVolatility, valueOption, type OptionCalcDraft, type OptionValuation } from "./model";
+import type { OptionCalcDraft } from "./model";
+import { solveImpliedVolatility, valueOption, type OptionValuation } from "../shared/volatility";
 import { createCalculatorSurfaceDependencies, loadCalculatorSurfaceVol, type CalculatorSurfaceVol } from "./surface";
 
 const number = (value: number) => Number.isFinite(value) ? value.toFixed(6) : "--";

package/src/plugins/builtin/options-calculator/model.ts

@@ -1,27 +1,12 @@
-import { zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
 import { optionMarketReference, parseOptionMarketReference, type OptionMarketReference } from "../options/market-reference";
+import { daysToExpiryFrom, type OptionPricingInput, type OptionSide } from "../shared/volatility";
 import type { CashDividend } from "./binomial";
 
 export const OPTIONS_CALCULATOR_PANE_ID = "options-calculator";
 export const OPTIONS_CALCULATOR_TEMPLATE_ID = "options-calculator-pane";
-const DAY_MS = 86_400_000;
-const DAYS_PER_YEAR = 365;
-const OPTION_EXPIRY_TIME_ZONE = "America/New_York";
-const MAX_VOLATILITY = 5;
-const NORMAL_CDF_ERROR_BOUND = 7.5e-8;
 
-export type OptionSide = "call" | "put";
-
-export interface OptionCalcDraft {
+export interface OptionCalcDraft extends OptionPricingInput {
   symbol: string;
-  side: OptionSide;
-  spot: number;
-  strike: number;
-  daysToExpiry: number;
-  /** Continuously compounded, as a decimal (0.05 = 5%). */
-  rate: number;
-  volatility: number;
-  dividendYield: number;
   /** 0 means "not supplied", which is also the only price no option can trade at. */
   marketPrice: number;
   marketPriceSource?: "mid" | "last";
@@ -63,180 +48,6 @@ export const DEFAULT_OPTION_CALC_DRAFT: OptionCalcDraft = {
   marketPrice: 0,
 };
 
-export interface OptionValuation {
-  price: number;
-  delta: number;
-  gamma: number;
-  /** Value decay for one calendar day. */
-  thetaPerDay: number;
-  /** Value change for one volatility point (1%). */
-  vegaPerPoint: number;
-  /** Value change for one rate point (1%). */
-  rhoPerPoint: number;
-}
-
-const ZERO_GREEKS = { delta: 0, gamma: 0, thetaPerDay: 0, vegaPerPoint: 0, rhoPerPoint: 0 };
-
-/** Abramowitz & Stegun 26.2.17; |error| < 7.5e-8, well inside display precision. */
-function normalCdf(x: number): number {
-  const sign = x < 0 ? -1 : 1;
-  const z = Math.abs(x) / Math.SQRT2;
-  const t = 1 / (1 + 0.3275911 * z);
-  const poly = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;
-  return 0.5 * (1 + sign * (1 - poly * Math.exp(-z * z)));
-}
-
-function normalPdf(x: number): number {
-  return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
-}
-
-function finite(value: number, fallback = 0): number {
-  return Number.isFinite(value) ? value : fallback;
-}
-
-/**
- * Value with no optionality left: the discounted forward payoff. Covers expiry,
- * zero volatility, and a zero spot or strike, all of which make the
- * Black-Scholes ratios divide by zero.
- */
-function intrinsicValuation(
-  side: OptionSide,
-  spot: number,
-  strike: number,
-  years: number,
-  rate: number,
-  dividendYield: number,
-): OptionValuation {
-  const discountedSpot = spot * Math.exp(-dividendYield * years);
-  const discountedStrike = strike * Math.exp(-rate * years);
-  const inTheMoney = side === "call" ? discountedSpot > discountedStrike : discountedStrike > discountedSpot;
-  const price = side === "call"
-    ? Math.max(0, discountedSpot - discountedStrike)
-    : Math.max(0, discountedStrike - discountedSpot);
-  const direction = side === "call" ? 1 : -1;
-  return {
-    ...ZERO_GREEKS,
-    price,
-    delta: inTheMoney ? (side === "call" ? Math.exp(-dividendYield * years) : -Math.exp(-dividendYield * years)) : 0,
-    // Zero volatility removes uncertainty, but discounting still changes the
-    // forward payoff as time and interest rates change. At expiry only the
-    // terminal payoff remains.
-    thetaPerDay: inTheMoney && years > 0
-      ? direction * (dividendYield * discountedSpot - rate * discountedStrike) / DAYS_PER_YEAR
-      : 0,
-    rhoPerPoint: inTheMoney && years > 0 ? direction * years * discountedStrike / 100 : 0,
-  };
-}
-
-/** Black-Scholes-Merton for European calls and puts with a continuous dividend yield. */
-export function valueOption(draft: OptionCalcDraft): OptionValuation {
-  const spot = Math.max(0, finite(draft.spot));
-  const strike = Math.max(0, finite(draft.strike));
-  const years = Math.max(0, finite(draft.daysToExpiry)) / DAYS_PER_YEAR;
-  const rate = finite(draft.rate);
-  const dividendYield = finite(draft.dividendYield);
-  const volatility = Math.max(0, finite(draft.volatility));
-  const { side } = draft;
-
-  if (years <= 0 || volatility <= 0 || spot <= 0 || strike <= 0) {
-    return intrinsicValuation(side, spot, strike, years, rate, dividendYield);
-  }
-
-  const sqrtYears = Math.sqrt(years);
-  const carryFactor = Math.exp(-dividendYield * years);
-  const discountFactor = Math.exp(-rate * years);
-  const d1 = (Math.log(spot / strike) + (rate - dividendYield + volatility * volatility / 2) * years)
-    / (volatility * sqrtYears);
-  const d2 = d1 - volatility * sqrtYears;
-  const pdf = normalPdf(d1);
-
-  const price = side === "call"
-    ? spot * carryFactor * normalCdf(d1) - strike * discountFactor * normalCdf(d2)
-    : strike * discountFactor * normalCdf(-d2) - spot * carryFactor * normalCdf(-d1);
-
-  const thetaPerYear = side === "call"
-    ? -(spot * pdf * volatility * carryFactor) / (2 * sqrtYears)
-      - rate * strike * discountFactor * normalCdf(d2)
-      + dividendYield * spot * carryFactor * normalCdf(d1)
-    : -(spot * pdf * volatility * carryFactor) / (2 * sqrtYears)
-      + rate * strike * discountFactor * normalCdf(-d2)
-      - dividendYield * spot * carryFactor * normalCdf(-d1);
-
-  const rhoPerUnit = side === "call"
-    ? strike * years * discountFactor * normalCdf(d2)
-    : -strike * years * discountFactor * normalCdf(-d2);
-
-  return {
-    price: Math.max(0, price),
-    delta: side === "call" ? carryFactor * normalCdf(d1) : carryFactor * (normalCdf(d1) - 1),
-    gamma: carryFactor * pdf / (spot * volatility * sqrtYears),
-    thetaPerDay: thetaPerYear / DAYS_PER_YEAR,
-    vegaPerPoint: spot * carryFactor * pdf * sqrtYears / 100,
-    rhoPerPoint: rhoPerUnit / 100,
-  };
-}
-
-export interface ImpliedVolatilityResult {
-  volatility: number | null;
-  /** Why no volatility could be solved, phrased for the pane body. */
-  note: string | null;
-}
-
-/**
- * Price rises monotonically with volatility, so bisection always converges and
- * cannot diverge the way a Newton step can near zero vega. The arbitrage bounds
- * are checked first: outside them no volatility exists at all.
- */
-export function solveImpliedVolatility(
-  draft: OptionCalcDraft,
-  marketPrice: number,
-): ImpliedVolatilityResult {
-  if (!Number.isFinite(marketPrice) || marketPrice <= 0) return { volatility: null, note: null };
-  if (!(draft.daysToExpiry > 0)) return { volatility: null, note: "expired, no implied volatility" };
-  if (!(draft.spot > 0) || !(draft.strike > 0)) return { volatility: null, note: "needs a positive spot and strike" };
-
-  const years = draft.daysToExpiry / DAYS_PER_YEAR;
-  const discountedSpot = draft.spot * Math.exp(-draft.dividendYield * years);
-  const discountedStrike = draft.strike * Math.exp(-draft.rate * years);
-  const lowerBound = draft.side === "call"
-    ? Math.max(0, discountedSpot - discountedStrike)
-    : Math.max(0, discountedStrike - discountedSpot);
-  const upperBound = draft.side === "call" ? discountedSpot : discountedStrike;
-  if (![discountedSpot, discountedStrike, years].every(Number.isFinite) || !(upperBound > lowerBound)) {
-    return { volatility: null, note: "inputs exceed model precision" };
-  }
-  // Each CDF contributes at most this much absolute price error. Near a
-  // bound, a rounded-flat price curve cannot identify a positive volatility.
-  const priceTolerance = NORMAL_CDF_ERROR_BOUND * (discountedSpot + discountedStrike);
-  if (marketPrice < lowerBound - priceTolerance) {
-    return { volatility: null, note: "market price is below intrinsic value" };
-  }
-  if (marketPrice > upperBound + priceTolerance) {
-    return { volatility: null, note: "market price is above the no-arbitrage maximum" };
-  }
-  if (marketPrice === lowerBound) return { volatility: 0, note: null };
-  if (marketPrice === upperBound) return { volatility: null, note: "no finite IV at the model maximum" };
-  if (marketPrice - lowerBound <= priceTolerance || upperBound - marketPrice <= priceTolerance) {
-    return { volatility: null, note: "market price too close to a model bound to resolve IV" };
-  }
-
-  const priceAt = (volatility: number) => valueOption({ ...draft, volatility }).price;
-  const cap = priceAt(MAX_VOLATILITY);
-  if (marketPrice > cap) return { volatility: null, note: `market price implies volatility above ${MAX_VOLATILITY * 100}%` };
-
-  let low = 0;
-  let high = MAX_VOLATILITY;
-  for (let i = 0; i < 100 && high - low > 1e-8; i += 1) {
-    const mid = (low + high) / 2;
-    if (priceAt(mid) > marketPrice) high = mid;
-    else low = mid;
-  }
-  if (!(priceAt(high) > priceAt(low))) {
-    return { volatility: null, note: "market price cannot resolve IV at model precision" };
-  }
-  return { volatility: (low + high) / 2, note: null };
-}
-
 export function describeDraftProblem(draft: OptionCalcDraft): string | null {
   if (!(draft.spot > 0)) return "Spot must be positive.";
   if (!(draft.strike > 0)) return "Strike must be positive.";
@@ -245,22 +56,6 @@ export function describeDraftProblem(draft: OptionCalcDraft): string | null {
   return null;
 }
 
-/** Time to the option date's 16:00 ET close, preserving live 0DTE time value. */
-export function daysToExpiryFrom(expirationSeconds: number, now: number): number {
-  if (!Number.isFinite(expirationSeconds)) return 0;
-  const expirationDate = new Date(expirationSeconds * 1000);
-  const close = zonedWallClockToUtcMs(
-    OPTION_EXPIRY_TIME_ZONE,
-    expirationDate.getUTCFullYear(),
-    expirationDate.getUTCMonth() + 1,
-    expirationDate.getUTCDate(),
-    16,
-    0,
-    0,
-  );
-  return Math.max(0, (close - now) / DAY_MS);
-}
-
 export interface OptionCalcSeed {
   symbol?: string | null;
   side?: OptionSide | null;

package/src/plugins/builtin/options-calculator/pane.tsx

@@ -3,20 +3,19 @@ import { FieldGrid, KeyValueRow, QueryBar, usePaneFooter, usePaneNoticeFooter, t
 import { useAsyncResource, useInputCapture } from "../../../public/react";
 import { useShortcut } from "../../../react/input";
 import { useAppSelector, usePaneInstance, usePaneStateValue } from "../../../state/app/context";
-import { selectCommandBarOpen } from "../../../state/selectors-ui";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, ScrollBox } from "../../../ui";
 import { formatNumber } from "../../../utils/format";
 import { isPlainKey } from "../../../utils/keyboard";
-import { OPTIONS_CALCULATOR_PANE_ID, daysToExpiryFrom, describeDraftProblem, draftFromParams, reconcileOptionCalcDraft, solveImpliedVolatility, updateOptionCalcDraft, valueOption, type OptionCalcDraft, type OptionSide } from "./model";
+import { OPTIONS_CALCULATOR_PANE_ID, describeDraftProblem, draftFromParams, reconcileOptionCalcDraft, updateOptionCalcDraft, type OptionCalcDraft } from "./model";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
 import { liveQuoteFormatOptions } from "../../../market-data/market/format";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import { buildOptionQuoteKey, freshOptionQuote, OPTIONS_QUOTE_EXCHANGE } from "../options/live-quotes";
-import { useLiveStreamingSetting } from "../shared/live-streaming";
-import { optionMid } from "../shared/volatility";
+import { useLiveStreamingSetting } from "../../../state/hooks/live-streaming";
+import { daysToExpiryFrom, optionMid, solveImpliedVolatility, valueOption, type OptionSide } from "../shared/volatility";
 import { useThrottledValue } from "../shared/volatility/live-session";
 import { valueBinomialOption, solveBinomialImpliedVolatility, effectiveBinomialSteps } from "./binomial";
 import { draftFromCalculatorInputs, parseCashDividends } from "./inputs";
@@ -63,7 +62,7 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
   const draft = useMemo(() => reconcileOptionCalcDraft(storedDraft, seed), [storedDraft, seed]);
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [activeFieldId, setActiveFieldId] = useState<string | null>(null);
-  const commandBarOpen = useAppSelector(selectCommandBarOpen);
+  const commandBarOpen = useAppSelector((state) => state.commandBarOpen);
   const american = draft.pricingModel === "american";
   const surfaceSource = draft.volSource === "surface";
   const [dividendText, setDividendText] = usePaneStateValue("dividendText", seedResult.dividendText);
@@ -229,42 +228,13 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
   const editSelectedField = useCallback(() => setActiveFieldId(selectedField?.id ?? null), [selectedField?.id]);
   const editSymbol = useCallback(() => { setSymbolText(draft.symbol); setActiveFieldId("symbol"); }, [draft.symbol]);
 
-  // Tab walks the fields only while one is being edited, and past either end
-  // it leaves them, so the next Tab moves to the next pane as everywhere else.
   // Enter or `e` starts editing, Enter in a cell commits and keeps the exact
-  // number in view, and Esc stops.
+  // number in view. While a cell is being edited the grid has the keyboard:
+  // Tab walks the number cells, and Tab or Esc leaves (and commits) any cell.
   useShortcut((event) => {
     if (event.defaultPrevented || event.propagationStopped) return;
+    if (activeFieldId !== null || event.targetEditable) return;
     const consume = () => { event.preventDefault(); event.stopPropagation(); };
-    const plainTab = event.name === "tab"
-      && !event.ctrl && !event.meta && !event.super && !event.alt;
-    if (activeFieldId === "dividends" || activeFieldId === "symbol") {
-      // Enter reaches the text field itself, which submits and leaves.
-      if (plainTab || isPlainKey(event, "escape", "esc")) {
-        consume();
-        if (activeFieldId === "symbol") commitSymbol(symbolText); else setActiveFieldId(null);
-      }
-      return;
-    }
-    const ringIndex = activeFieldId ? fields.findIndex((field) => field.id === activeFieldId) : -1;
-    if (ringIndex >= 0) {
-      if (plainTab) {
-        consume();
-        const nextIndex = ringIndex + (event.shift ? -1 : 1);
-        if (nextIndex < 0 || nextIndex >= fields.length) {
-          setActiveFieldId(null);
-          return;
-        }
-        setSelectedIndex(nextIndex);
-        setActiveFieldId(fields[nextIndex]!.id);
-      } else if (isPlainKey(event, "escape", "esc")) {
-        // Leaving the cell commits what was typed.
-        consume();
-        setActiveFieldId(null);
-      }
-      return;
-    }
-    if (event.targetEditable) return;
     if (isPlainKey(event, "left", "right")) {
       consume();
       setSide(event.name === "left" ? "call" : "put");
@@ -316,10 +286,11 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
   }), [implied.note, problem, american, surfaceSource, surfaceResource.loading, surface, activeFieldId, draft.symbol, draft.steps, effectiveSteps, liveInputs?.delayed, !!liveInputs, selectedField?.id, selectedField?.label, editSelectedField, editSymbol]);
 
   const gridFields: GridField[] = [
-    { id: "symbol", kind: "text", label: "Underlying", valueText: symbolText, placeholder: "ticker",
+    // The text cells are not Tab stops: Tab leaves them, applying what was typed.
+    { id: "symbol", kind: "text", label: "Underlying", valueText: symbolText, placeholder: "ticker", tabStop: false,
       onText: (value) => setSymbolText(value.toUpperCase()) },
     ...fields,
-    ...(american ? [{ id: "dividends", kind: "text" as const, label: "Dividends", wide: true, valueText: dividendText,
+    ...(american ? [{ id: "dividends", kind: "text" as const, label: "Dividends", wide: true, tabStop: false, valueText: dividendText,
       placeholder: "day:amount; e.g. 30:0.25;90:0.25", onText: setDividendText }] : []),
   ];
   // Each paired metric needs room for its label, value and complete unit.
@@ -346,6 +317,7 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
         activeId={activeFieldId}
         width={width}
         focused={focused}
+        keyboard={!commandBarOpen}
         onActivate={(id) => {
           const index = fields.findIndex((field) => field.id === id);
           if (index >= 0) setSelectedIndex(index);