gloomberb 0.13.2 → 0.14.0

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

@@ -1,12 +1,13 @@
 import { zonedWallClockToUtcMs } from "../../../utils/zoned-date-time";
+import { optionMarketReference, parseOptionMarketReference, type OptionMarketReference } from "../options/market-reference";
 
 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 MIN_VOLATILITY = 1e-6;
 const MAX_VOLATILITY = 5;
+const NORMAL_CDF_ERROR_BOUND = 7.5e-8;
 
 export type OptionSide = "call" | "put";
 
@@ -22,6 +23,27 @@ export interface OptionCalcDraft {
   dividendYield: number;
   /** 0 means "not supplied", which is also the only price no option can trade at. */
   marketPrice: number;
+  marketPriceSource?: "mid" | "last";
+  marketReference?: OptionMarketReference;
+}
+
+/** Edited contracts retain numeric what-if inputs, but lose the old contract's market attribution. */
+export function updateOptionCalcDraft(current: OptionCalcDraft, patch: Partial<OptionCalcDraft>): OptionCalcDraft {
+  const changedContract = (["symbol", "side", "strike", "daysToExpiry"] as const)
+    .some((key) => patch[key] !== undefined && patch[key] !== current[key]);
+  const changedPrice = Object.hasOwn(patch, "marketPrice");
+  return { ...current, ...patch, ...(changedContract || changedPrice
+    ? { marketPriceSource: undefined, marketReference: undefined } : {}) };
+}
+
+/** Repair already-saved edited drafts from clients that retained the seed's attribution. */
+export function reconcileOptionCalcDraft(current: OptionCalcDraft, seed: OptionCalcDraft): OptionCalcDraft {
+  const sameContract = (["symbol", "side", "strike", "daysToExpiry"] as const)
+    .every((key) => current[key] === seed[key]);
+  if (!sameContract || current.marketPrice !== seed.marketPrice || current.marketPriceSource !== seed.marketPriceSource) {
+    return { ...current, marketPriceSource: undefined, marketReference: undefined };
+  }
+  return { ...current, marketReference: optionMarketReference(current.marketReference) };
 }
 
 export const DEFAULT_OPTION_CALC_DRAFT: OptionCalcDraft = {
@@ -86,10 +108,18 @@ function intrinsicValuation(
   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,
   };
 }
 
@@ -167,26 +197,38 @@ export function solveImpliedVolatility(
     ? Math.max(0, discountedSpot - discountedStrike)
     : Math.max(0, discountedStrike - discountedSpot);
   const upperBound = draft.side === "call" ? discountedSpot : discountedStrike;
-  if (marketPrice < lowerBound - 1e-8) {
+  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 + 1e-8) {
+  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 floor = priceAt(MIN_VOLATILITY);
   const cap = priceAt(MAX_VOLATILITY);
-  if (marketPrice < floor - 1e-8) return { volatility: null, note: "market price is below intrinsic value" };
   if (marketPrice > cap) return { volatility: null, note: `market price implies volatility above ${MAX_VOLATILITY * 100}%` };
 
-  let low = MIN_VOLATILITY;
+  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 };
 }
 
@@ -259,6 +301,7 @@ function numberParam(params: Record<string, string>, key: string, fallback: numb
 
 export function draftFromParams(params: Record<string, string> | undefined): OptionCalcDraft {
   if (!params) return DEFAULT_OPTION_CALC_DRAFT;
+  const marketReference = parseOptionMarketReference(params.marketReference);
   return {
     symbol: params.symbol ?? DEFAULT_OPTION_CALC_DRAFT.symbol,
     side: params.side === "put" ? "put" : "call",
@@ -269,5 +312,8 @@ export function draftFromParams(params: Record<string, string> | undefined): Opt
     volatility: numberParam(params, "volatility", DEFAULT_OPTION_CALC_DRAFT.volatility),
     dividendYield: numberParam(params, "dividendYield", DEFAULT_OPTION_CALC_DRAFT.dividendYield),
     marketPrice: numberParam(params, "marketPrice", DEFAULT_OPTION_CALC_DRAFT.marketPrice),
+    ...(params.marketPriceSource === "mid" || params.marketPriceSource === "last"
+      ? { marketPriceSource: params.marketPriceSource } : {}),
+    ...(marketReference ? { marketReference } : {}),
   };
 }

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

@@ -2,7 +2,8 @@ import { afterEach, expect, test } from "bun:test";
 import { useReducer } from "react";
 import { act } from "react";
 import { useShortcut } from "../../../react/input";
-import { testRender } from "../../../renderers/opentui/test-utils";
+import { emitKeypress, testRender } from "../../../renderers/opentui/test-utils";
+import { PaneKeyboardScrollController } from "../../../state/pane-scroll-registry";
 import {
   AppContext,
   PaneInstanceProvider,
@@ -28,7 +29,7 @@ function GlobalTabHandler() {
   return null;
 }
 
-function Harness({ params }: { params?: Record<string, string> }) {
+function Harness({ params, width = 90, height = 18 }: { params?: Record<string, string>; width?: number; height?: number }) {
   const config = createDefaultConfig("/tmp/gloomberb-options-calculator-test");
   config.layout = {
     dockRoot: { kind: "pane", instanceId: TEST_PANE_ID },
@@ -51,13 +52,14 @@ function Harness({ params }: { params?: Record<string, string> }) {
     <AppContext value={{ state, dispatch }}>
       <GlobalTabHandler />
       <PaneInstanceProvider paneId={TEST_PANE_ID}>
+        <PaneKeyboardScrollController paneId={TEST_PANE_ID} focused />
         <PluginRenderProvider pluginId="ticker-research" runtime={createTestPluginRuntime()}>
           <OptionsCalculatorPane
             paneId={TEST_PANE_ID}
             paneType={OPTIONS_CALCULATOR_PANE_ID}
             focused
-            width={90}
-            height={18}
+            width={width}
+            height={height}
           />
         </PluginRenderProvider>
       </PaneInstanceProvider>
@@ -65,9 +67,9 @@ function Harness({ params }: { params?: Record<string, string> }) {
   );
 }
 
-async function render(params?: Record<string, string>) {
+async function render(params?: Record<string, string>, width = 90, height = 18) {
   await act(async () => {
-    testSetup = await testRender(<Harness params={params} />, { width: 90, height: 18 });
+    testSetup = await testRender(<Harness params={params} width={width} height={height} />, { width, height });
     await Promise.resolve();
     await testSetup.renderOnce();
   });
@@ -86,6 +88,30 @@ afterEach(async () => {
   }
 });
 
+test("narrow results keep contract context reachable while scrolling Greeks and editing fixed inputs", async () => {
+  await render({
+    symbol: "COST:XNAS", side: "call", spot: "902.63", strike: "905", days: "14.1784",
+    volatility: "0.269", rate: "0.04", marketPrice: "18.075", marketPriceSource: "mid",
+    marketReference: JSON.stringify({ contractSymbol: "COST260925C00905000", expiration: 1790294400,
+      currency: "USD", bid: 17.2, ask: 18.95, lastPrice: 18.67, lastTradeDate: 1789139450 }),
+  }, 48, 16);
+  expect(testSetup!.captureCharFrame()).toContain("COST260925C00905000");
+  await emitKeypress(testSetup!, { name: "end", sequence: "\u001B[F" });
+  const bottom = testSetup!.captureCharFrame();
+  expect(bottom).toMatch(/Theta\s+-[\d.]+\s+per day/);
+  expect(bottom).toMatch(/Vega\s+[\d.]+\s+per vol pt/);
+  expect(bottom).toMatch(/Rho\s+[+\d.]+\s+per rate pt/);
+
+  // Inputs stay reachable while the researcher reads the bottom of the results.
+  await emitKeypress(testSetup!, { name: "tab", sequence: "\t" });
+  await act(async () => { await testSetup!.mockInput.typeText("910"); testSetup!.mockInput.pressEnter(); });
+  await act(async () => { await testSetup!.renderOnce(); });
+  expect(testSetup!.captureCharFrame()).toMatch(/Spot\s+910/);
+  await emitKeypress(testSetup!, { name: "escape", sequence: "\u001B" });
+  await emitKeypress(testSetup!, { name: "home", sequence: "\u001B[H" });
+  expect(testSetup!.captureCharFrame()).toContain("COST260925C00905000");
+});
+
 test("prices the seeded contract and solves its implied volatility", async () => {
   await render({
     symbol: "AAPL",
@@ -103,18 +129,24 @@ test("prices the seeded contract and solves its implied volatility", async () =>
   expect(frame).toContain("5.5735");
   // The seeded market price is exactly the model put value, so IV solves back to 20%.
   expect(frame).toMatch(/Implied IV\s+20\.00%/);
-  expect(frame).toContain("European exercise");
 });
 
-test("opens on defaults with no seed and leaves implied volatility empty", async () => {
-  await render();
-
+test("shows the remaining fraction of a day for a live near-expiry contract", async () => {
+  await render({ days: "0.25" });
   const frame = testSetup!.captureCharFrame();
-  expect(frame).toContain("Spot");
-  expect(frame).toContain("Market");
+  expect(frame).toMatch(/Days\s+0\.25\s*d/);
   expect(frame).toMatch(/Implied IV\s+—/);
 });
 
+test("displays fractional strikes and spot prices without rounding them to whole dollars", async () => {
+  await render({ spot: "217.987", strike: "217.5", marketPrice: "100.125", marketPriceSource: "mid" });
+  const frame = testSetup!.captureCharFrame();
+  expect(frame).toMatch(/Spot\s+217\.987/);
+  expect(frame).toMatch(/Strike\s+217\.5/);
+  expect(frame).toMatch(/Mid\s+100\.125/);
+  expect(frame).toContain("per unit");
+});
+
 test("tabs into fields and edits them from the keyboard", async () => {
   await render();
 

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

@@ -1,23 +1,16 @@
 import { useCallback, useMemo, useState } from "react";
-import { SegmentedControl, usePaneFooter } from "../../../components";
+import { KeyValueRow, SegmentedControl, usePaneFooter } from "../../../components";
+import { useShortcut } from "../../../react/input";
 import { usePaneInstance, usePaneStateValue } from "../../../state/app/context";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
-import { Box, Text, TextAttributes, useUiHost } from "../../../ui";
+import { Box, ScrollBox, Text, TextAttributes, useUiHost } from "../../../ui";
 import { formatNumber } from "../../../utils/format";
 import { isPlainKey } from "../../../utils/keyboard";
-import { useShortcut } from "../../../react/input";
 import type { InlineField } from "../kelly-sizer/fields";
-import { InlineFieldView, MetricLine, truncateText } from "../kelly-sizer/view";
-import {
-  OPTIONS_CALCULATOR_PANE_ID,
-  describeDraftProblem,
-  draftFromParams,
-  solveImpliedVolatility,
-  valueOption,
-  type OptionCalcDraft,
-  type OptionSide,
-} from "./model";
+import { InlineFieldView, truncateText } from "../kelly-sizer/view";
+import { OPTIONS_CALCULATOR_PANE_ID, describeDraftProblem, draftFromParams, reconcileOptionCalcDraft, solveImpliedVolatility, updateOptionCalcDraft, valueOption, type OptionCalcDraft, type OptionSide } from "./model";
+import { OptionQuoteContext, optionQuoteContextHeight } from "../options/quote-context";
 
 const SIDE_OPTIONS = [
   { label: "Call", value: "call" },
@@ -31,23 +24,30 @@ function formatSigned(value: number, decimals: number): string {
 export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
   const ui = useUiHost();
   const paneInstance = usePaneInstance();
-  const [draft, setDraft] = usePaneStateValue<OptionCalcDraft>("draft", draftFromParams(paneInstance?.params));
+  const seed = useMemo(() => draftFromParams(paneInstance?.params), [paneInstance?.params]);
+  const [storedDraft, setDraft] = usePaneStateValue<OptionCalcDraft>("draft", seed);
+  const draft = useMemo(() => reconcileOptionCalcDraft(storedDraft, seed), [storedDraft, seed]);
   const [selectedIndex, setSelectedIndex] = useState(0);
   const [activeFieldId, setActiveFieldId] = useState<string | null>(null);
 
   const updateDraft = useCallback((patch: Partial<OptionCalcDraft>) => {
-    setDraft((current) => ({ ...current, ...patch }));
-  }, [setDraft]);
+    setDraft((current) => updateOptionCalcDraft(reconcileOptionCalcDraft(current, seed), patch));
+  }, [seed, setDraft]);
 
   const fields = useMemo<InlineField[]>(() => [
-    { id: "spot", label: "Spot", value: draft.spot, onValue: (value) => updateDraft({ spot: value }) },
-    { id: "strike", label: "Strike", value: draft.strike, onValue: (value) => updateDraft({ strike: value }) },
+    { id: "spot", label: "Spot", value: draft.spot, valueText: String(draft.spot), onValue: (value) => updateDraft({ spot: value }) },
+    { id: "strike", label: "Strike", value: draft.strike, valueText: String(draft.strike), onValue: (value) => updateDraft({ strike: value }) },
     {
       id: "days",
       label: "Days",
       value: draft.daysToExpiry,
-      // Whole days read better than the shared 2-decimal number format.
-      valueText: String(Math.round(draft.daysToExpiry)),
+      // Keep intraday expiry visible; rounding six hours to "0 d" makes a
+      // live contract appear expired while its time value is still priced.
+      valueText: Number.isInteger(draft.daysToExpiry)
+        ? String(draft.daysToExpiry)
+        : draft.daysToExpiry > 0 && draft.daysToExpiry < 0.0001
+          ? "<0.0001"
+          : String(Number(draft.daysToExpiry.toFixed(4))),
       suffix: "d",
       onValue: (value) => updateDraft({ daysToExpiry: Math.max(0, value) }),
     },
@@ -56,11 +56,12 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
     { id: "dividendYield", label: "Div yld", value: draft.dividendYield, percent: true, onValue: (value) => updateDraft({ dividendYield: value }) },
     {
       id: "marketPrice",
-      label: "Market",
+      label: draft.marketPriceSource === "mid" ? "Mid" : draft.marketPriceSource === "last" ? "Last" : draft.marketPrice > 0 ? "Input" : "Market",
       value: draft.marketPrice,
+      valueText: String(Number(draft.marketPrice.toPrecision(12))),
       // Clearing the field is how a standalone user says "no market price".
-      onValue: (value) => updateDraft({ marketPrice: Math.max(0, value) }),
-      onClear: () => updateDraft({ marketPrice: 0 }),
+      onValue: (value) => updateDraft({ marketPrice: Math.max(0, value), marketPriceSource: undefined }),
+      onClear: () => updateDraft({ marketPrice: 0, marketPriceSource: undefined }),
     },
   ], [draft, updateDraft]);
 
@@ -125,10 +126,13 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
   const columns = width >= 78 ? 3 : width >= 42 ? 2 : 1;
   const fieldWidth = Math.max(12, Math.min(26, Math.floor((width - 2) / columns)));
   const rows = Math.max(1, Math.ceil(fields.length / columns));
-  const pairMetrics = width >= 50;
-  const metricWidth = pairMetrics ? Math.floor((width - 2) / 2) : Math.max(1, width - 2);
-  const trailingMetricWidth = pairMetrics ? Math.max(1, width - 2 - metricWidth) : metricWidth;
-  const showGreeks = height >= 1 + rows + 1 + (pairMetrics ? 1 : 2) + (pairMetrics ? 3 : 5) + 1;
+  // Each paired metric needs room for its label, value and complete unit.
+  const pairMetrics = width >= 82;
+  // Leave a column for the native scrollbar beside the result body's padding.
+  const resultWidth = Math.max(1, width - 3);
+  const metricWidth = pairMetrics ? Math.floor(resultWidth / 2) : resultWidth;
+  const trailingMetricWidth = pairMetrics ? Math.max(1, resultWidth - metricWidth) : metricWidth;
+  const referenceHeight = optionQuoteContextHeight(draft.marketReference, resultWidth, Number.POSITIVE_INFINITY, true);
 
   return (
     <Box flexDirection="column" width={width} height={height}>
@@ -172,47 +176,41 @@ export function OptionsCalculatorPane({ focused, width, height }: PaneProps) {
 
       <Box height={1} />
 
-      <Box flexDirection={pairMetrics ? "row" : "column"} paddingX={1}>
-        <MetricLine
-          label="Fair value"
-          value={formatNumber(valuation.price, 4)}
-          detail={draft.side === "call" ? "call" : "put"}
-          color={colors.textBright}
-          width={metricWidth}
-        />
-        <MetricLine
-          label="Implied IV"
-          value={implied.volatility != null ? `${formatNumber(implied.volatility * 100, 2)}%` : "—"}
-          detail={implied.volatility != null ? "from market" : undefined}
-          color={implied.volatility != null ? colors.positive : colors.textDim}
-          width={trailingMetricWidth}
-        />
-      </Box>
+      <ScrollBox id="options-calculator-results" flexGrow={1} flexBasis={0} minHeight={0} scrollY focusable={false}>
+        {draft.marketReference && <Box paddingX={1} height={referenceHeight} flexShrink={0}>
+          <OptionQuoteContext reference={draft.marketReference} width={resultWidth} height={referenceHeight} snapshot scrollable={false} />
+        </Box>}
+
+        <Box flexDirection={pairMetrics ? "row" : "column"} paddingX={1}>
+          <KeyValueRow
+            label="Model"
+            value={formatNumber(valuation.price, 4)}
+            detail="per unit"
+            color={colors.textBright}
+            width={metricWidth}
+          />
+          <KeyValueRow
+            label="Implied IV"
+            value={implied.volatility != null ? `${formatNumber(implied.volatility * 100, 2)}%` : "—"}
+            detail={implied.volatility != null ? draft.marketPriceSource === "mid" ? "from mid"
+              : draft.marketPriceSource === "last" ? "from last" : "from input" : undefined}
+            color={implied.volatility != null ? colors.positive : colors.textDim}
+            width={trailingMetricWidth}
+          />
+        </Box>
 
-      {showGreeks ? (
         <Box flexDirection="column" paddingX={1}>
           <Box flexDirection={pairMetrics ? "row" : "column"}>
-            <MetricLine label="Delta" value={formatSigned(valuation.delta, 4)} width={metricWidth} />
-            <MetricLine label="Gamma" value={formatNumber(valuation.gamma, 4)} width={trailingMetricWidth} />
+            <KeyValueRow label="Delta" value={formatSigned(valuation.delta, 4)} width={metricWidth} />
+            <KeyValueRow label="Gamma" value={formatNumber(valuation.gamma, 4)} width={trailingMetricWidth} />
           </Box>
           <Box flexDirection={pairMetrics ? "row" : "column"}>
-            <MetricLine label="Theta" value={formatSigned(valuation.thetaPerDay, 4)} detail="per day" width={metricWidth} />
-            <MetricLine label="Vega" value={formatNumber(valuation.vegaPerPoint, 4)} detail="per vol pt" width={trailingMetricWidth} />
+            <KeyValueRow label="Theta" value={formatSigned(valuation.thetaPerDay, 4)} detail="per day" width={metricWidth} />
+            <KeyValueRow label="Vega" value={formatNumber(valuation.vegaPerPoint, 4)} detail="per vol pt" width={trailingMetricWidth} />
           </Box>
-          <MetricLine label="Rho" value={formatSigned(valuation.rhoPerPoint, 4)} detail="per rate pt" width={metricWidth} />
+          <KeyValueRow label="Rho" value={formatSigned(valuation.rhoPerPoint, 4)} detail="per rate pt" width={metricWidth} />
         </Box>
-      ) : null}
-
-      <Box flexGrow={1} />
-
-      <Box height={1} paddingX={1} overflow="hidden">
-        <Text fg={colors.textMuted}>
-          {truncateText(
-            "European exercise only: no early exercise or discrete dividends.",
-            Math.max(1, width - 2),
-          )}
-        </Text>
-      </Box>
+      </ScrollBox>
     </Box>
   );
 }

package/src/plugins/builtin/plugin-marketplace/ids.ts

@@ -0,0 +1,2 @@
+/** Kept apart from the pane so startup code can address it without importing the React tree. */
+export const PLUGIN_MARKETPLACE_PANE_ID = "plugin-marketplace";