gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/options/view.tsx

@@ -15,13 +15,15 @@ import {
   type DataTableVisibleRange,
 } from "../../../components";
 import { useShortcut } from "../../../react/input";
-import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
+import { useLiveQuoteEntries, useQuoteUpdates } from "../../../state/hooks/quote-streaming";
+import { quoteSubscriptionTargetFromTicker } from "../../../market-data/request-types";
 import { usePluginAppActions } from "../../runtime";
 import {
   OPTIONS_CALCULATOR_TEMPLATE_ID,
   type OptionSide,
 } from "../options-calculator/model";
 import { buildChainCalcParams, resolveCalcSide } from "./calc-seed";
+import { useOptionsCatalogue } from "./expiry-catalogue";
 import { calculateOptionGreeks, calculateOptionsSummary, type OptionsSummary } from "./analytics";
 import {
   DEFAULT_OPTION_FIELD_IDS,
@@ -29,6 +31,7 @@ import {
   createOptionColumns,
   findNearestStrikeIndex,
   formatIv,
+  formatStrikeLabel,
   optionColumnColor,
   renderOptionCell,
   resolveDefaultStrikeTarget,
@@ -43,6 +46,8 @@ import {
 } from "./live-quotes";
 import { useOptionsAccessFooter } from "./footer";
 import { useLiveStreamingSetting } from "../shared/live-streaming";
+import { signedPositionDirection } from "../portfolio-list/position-metrics";
+import { optionMarketReference } from "./market-reference";
 
 type SummaryMetric = { label: string; value: string };
 
@@ -77,7 +82,7 @@ function OptionsSummaryStrip({ summary, secondary }: {
       <SummaryRow metrics={volatility} />
       {secondary && (
         <SummaryRow metrics={[
-          { label: "EXP VOL", value: summary ? formatCompact(summary.expirationVolume) : "—" },
+          { label: "EXP VOL", value: formatCompact(summary?.expirationVolume ?? undefined) },
           { label: "P/C VOL", value: formatRatio(summary?.putCallVolumeRatio) },
           { label: "P/C OI", value: formatRatio(summary?.putCallOpenInterestRatio) },
         ]} />
@@ -90,9 +95,12 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
   const { ticker, financials } = usePaneTicker();
   const { createPaneFromTemplate } = usePluginAppActions();
   const liveStreaming = useLiveStreamingSetting();
-  const [expIdx, setExpIdx] = useState(0);
+  const [expirySelection, setExpirySelection] = useState<{ targetKey: string; expiration: number } | null>(null);
   const [calcSide, setCalcSide] = useState<OptionSide | null>(null);
   const [strikeIdx, setStrikeIdx] = useState(0);
+  const [contractSelection, setContractSelection] = useState<{
+    context: string; strike: number; side: OptionSide; contractSymbol: string;
+  } | null>(null);
   const [autoScrollVersion, setAutoScrollVersion] = useState(0);
   const [scrollToIndexAlign, setScrollToIndexAlign] = useState<"nearest" | "center">("nearest");
   const [visibleStrikeViewport, setVisibleStrikeViewport] = useState<{
@@ -107,9 +115,19 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
   const parsed = target?.parsedOption ?? null;
   const effectiveTicker = target?.effectiveTicker ?? "";
   const effectiveExchange = target?.effectiveExchange ?? "";
+  const selectionTargetKey = `${ticker?.metadata.ticker ?? ""}|${target?.cacheKey ?? ""}`;
+  const underlyingQuoteTarget = isOpt
+    ? effectiveTicker ? { symbol: effectiveTicker, exchange: effectiveExchange, route: "provider" as const } : null
+    : quoteSubscriptionTargetFromTicker(ticker, effectiveTicker, "provider");
+  // A standalone chain has no parent research pane to subscribe to its stock.
+  // Its spot, ATM selection and Greeks must update independently of other panes.
+  useQuoteUpdates(underlyingQuoteTarget ? [{
+    ...underlyingQuoteTarget, surface: "options", visible: true, selected: true, weight: 100,
+  }] : [], { liveStreaming });
   const underlyingFinancials = useTickerFinancials(isOpt ? effectiveTicker : null, null);
   const underlying = isOpt ? underlyingFinancials : financials;
-  const spot = underlying?.quote?.price;
+  const underlyingStale = underlying?.quote?.stale === true;
+  const spot = underlyingStale ? undefined : underlying?.quote?.price;
   const dividendYield = underlying?.fundamentals?.dividendYield;
   const instrument = target?.instrument ?? null;
   const baseRequest = target
@@ -128,8 +146,14 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
   const optionFieldIds = useMemo(() => resolveOptionFieldIds(storedOptionFieldIds), [storedOptionFieldIds]);
   const initialChainEntry = useOptionsQuery(baseRequest);
   const initialChain = useResolvedEntryValue(initialChainEntry);
-  const selectedExpiration = initialChain?.expirationDates[expIdx];
+  const initialExpiration = initialChain?.expirationDates.reduce((best, expiration) => (
+    parsed && Math.abs(expiration - parsed.expTs) < Math.abs(best - parsed.expTs) ? expiration : best
+  ), initialChain.expirationDates[0]!);
+  const selectedExpiration = expirySelection?.targetKey === selectionTargetKey
+    ? expirySelection.expiration : initialExpiration;
   const viewportKey = `${effectiveTicker}:${selectedExpiration ?? "initial"}`;
+  const strikeSelectionKey = `${selectionTargetKey}|${selectedExpiration ?? "initial"}`;
+  const selectedContract = contractSelection?.context === strikeSelectionKey ? contractSelection : null;
   const expirationChainEntry = useOptionsQuery(
     baseRequest && selectedExpiration != null
       ? { ...baseRequest, expirationDate: selectedExpiration }
@@ -137,22 +161,42 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     { refreshIntervalMs: resolveChainRefreshIntervalMs(chainRefreshMinutes) },
   );
   const expirationChain = useResolvedEntryValue(expirationChainEntry);
-  // The expiration strip is expiry-independent, but strikes must never come from
-  // a different expiration than the selected one: the initial chain only covers
-  // whichever expiry the provider defaulted to.
-  const chain = expirationChain ?? initialChain;
-  const initialChainExpiration = initialChain?.calls[0]?.expiration ?? initialChain?.puts[0]?.expiration ?? null;
-  const strikeChain = expirationChain
-    ?? (selectedExpiration == null || initialChainExpiration === selectedExpiration ? initialChain : null);
-  const strikesLoading = strikeChain === null;
-  const expirationCount = chain?.expirationDates.length ?? 0;
+  // Either query can refresh the expiry catalogue. The selected date remains
+  // an identity even when an earlier date disappears or the catalogue reorders.
+  const { chain, expirationDates: availableExpirations } = useOptionsCatalogue(
+    selectionTargetKey, initialChainEntry, expirationChainEntry,
+  );
+  const selectedExpirationMissing = selectedExpiration != null && chain != null
+    && !availableExpirations.includes(selectedExpiration);
+  const matchesSelectedExpiration = (candidate: typeof initialChain) => candidate != null
+    && selectedExpiration != null
+    && [...candidate.calls, ...candidate.puts].every((contract) => contract.expiration === selectedExpiration);
+  const mismatchedExpiration = expirationChain != null && !matchesSelectedExpiration(expirationChain);
+  const expirationUnavailable = selectedExpirationMissing || mismatchedExpiration;
+  // A provider fallback or an old default-expiry response must not seed the
+  // table, export, Greeks or calculator for a different selected contract date.
+  const strikeChain = expirationUnavailable ? null : expirationChain
+    ?? (matchesSelectedExpiration(initialChain) ? initialChain : null);
+  const strikesLoading = strikeChain === null && !expirationUnavailable;
+  const expirationDates = useMemo(() => {
+    return selectedExpirationMissing
+      ? [...availableExpirations, selectedExpiration!].sort((left, right) => left - right) : availableExpirations;
+  }, [availableExpirations, selectedExpiration, selectedExpirationMissing]);
+  // Keep the date strip stable while a mouse press focuses this pane. A new
+  // tab list asks the web host to reveal the active tab and can move the date
+  // being clicked before mouse-up, cancelling selection of an offscreen expiry.
+  const expirationTabs = useMemo(() => expirationDates.map((ts) => ({
+    label: formatExpDate(ts),
+    value: String(ts),
+  })), [expirationDates]);
   const loading = (initialChainEntry?.phase === "loading" || initialChainEntry?.phase === "refreshing") && !chain
     || (expirationChainEntry?.phase === "loading" || expirationChainEntry?.phase === "refreshing");
-  const error = initialChainEntry?.phase === "error"
-    ? initialChainEntry.error?.message ?? "Failed to load options"
-    : expirationChainEntry?.phase === "error"
-      ? expirationChainEntry.error?.message ?? "Failed to load options"
-      : null;
+  // Refresh failures keep a ready entry with last-good data and an error.
+  // Surface that warning even when the cached chain is still usable.
+  const error = (expirationUnavailable ? "Selected expiration unavailable." : null)
+    ?? initialChainEntry?.error?.message ?? expirationChainEntry?.error?.message
+    ?? (initialChainEntry?.phase === "error" || expirationChainEntry?.phase === "error"
+      ? "Failed to load options" : null);
 
   useEffect(() => {
     onCaptureRef.current = onCapture;
@@ -172,35 +216,37 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     }
   }, [interactive]);
 
+  const selectExpiration = useCallback((expiration: number) => {
+    setExpirySelection({ targetKey: selectionTargetKey, expiration });
+  }, [selectionTargetKey]);
   const selectAdjacentExpiration = useCallback((offset: -1 | 1) => {
-    if (expirationCount === 0) return;
-    setExpIdx((index) => Math.max(0, Math.min(index + offset, expirationCount - 1)));
-  }, [expirationCount]);
+    if (expirationDates.length === 0) return;
+    const index = expirationDates.indexOf(selectedExpiration!);
+    selectExpiration(expirationDates[Math.max(0, Math.min(index + offset, expirationDates.length - 1))]!);
+  }, [expirationDates, selectExpiration, selectedExpiration]);
 
   useEffect(() => {
     userSelectedStrikeRef.current = false;
     setScrollToIndexAlign("nearest");
     setInteractive(false);
     onCaptureRef.current(false);
-    setExpIdx(0);
     setStrikeIdx(0);
     setCalcSide(null);
-  }, [effectiveTicker]);
+    setContractSelection(null);
+  }, [selectionTargetKey]);
 
   useEffect(() => {
-    if (!parsed || !initialChain || initialChain.expirationDates.length === 0) return;
-    const bestExpIdx = initialChain.expirationDates.reduce((best, ts, i) =>
-      Math.abs(ts - parsed.expTs) < Math.abs(initialChain.expirationDates[best]! - parsed.expTs) ? i : best, 0);
-    if (bestExpIdx !== expIdx) {
-      setExpIdx(bestExpIdx);
-    }
-  }, [expIdx, initialChain, parsed]);
+    if (expirySelection?.targetKey === selectionTargetKey || selectedExpiration == null) return;
+    // The holding/default chooses the date only on entering a new context.
+    selectExpiration(selectedExpiration);
+  }, [expirySelection?.targetKey, selectExpiration, selectedExpiration, selectionTargetKey]);
 
   useEffect(() => {
     userSelectedStrikeRef.current = false;
-  }, [expIdx]);
+  }, [selectedExpiration]);
 
   const strikes = useMemo(() => strikeChain ? buildStrikeList(strikeChain) : [], [strikeChain]);
+  const selectedStrikeIdx = selectedContract ? strikes.indexOf(selectedContract.strike) : strikeIdx;
   const callsByStrike = useMemo(
     () => new Map(strikeChain?.calls.map((c) => [c.strike, c]) ?? []),
     [strikeChain],
@@ -220,7 +266,7 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
         put,
         callGreeks: calculateOptionGreeks(call, "call", spot, dividendYield, now),
         putGreeks: calculateOptionGreeks(put, "put", spot, dividendYield, now),
-        isPositionStrike: !!parsed && Math.abs(strike - parsed.strike) < 0.01,
+        isPositionStrike: !!parsed && strike === parsed.strike,
       };
     });
   }, [callsByStrike, dividendYield, parsed, putsByStrike, spot, strikes]);
@@ -245,10 +291,10 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
   const optionQuoteTargets = useMemo(
     () => buildOptionQuoteTargets(snapshotRows, {
       fallbackHeight: height,
-      selectedIndex: strikeIdx,
+      selectedIndex: selectedStrikeIdx,
       visibleRange: visibleStrikeRange,
     }),
-    [height, snapshotRows, strikeIdx, visibleStrikeRange],
+    [height, snapshotRows, selectedStrikeIdx, visibleStrikeRange],
   );
   const {
     entries: optionQuoteEntries,
@@ -282,16 +328,23 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     headerColor: optionColumnColor(column, colors.panel),
   })), [optionFieldIds]);
 
-  const selectedRow = rows[strikeIdx] ?? null;
+  const selectedRow = rows[selectedStrikeIdx] ?? null;
+  const selectedContractAvailable = !selectedContract || (selectedContract.side === "call"
+    ? selectedRow?.call : selectedRow?.put)?.contractSymbol === selectedContract.contractSymbol;
+  const selectedSide = selectedContract
+    ? selectedContractAvailable ? selectedContract.side : null
+    : resolveCalcSide(calcSide, parsed?.side, selectedRow);
+  const selectedReference = optionMarketReference(selectedSide === "put" ? selectedRow?.put
+    : selectedSide === "call" ? selectedRow?.call : undefined);
   const calcParams = useMemo(() => buildChainCalcParams({
     symbol: effectiveTicker,
     row: selectedRow,
-    side: resolveCalcSide(calcSide, parsed?.side, selectedRow),
+    side: selectedSide,
     // On an option ticker the pane quote is the contract's own price, so load
     // the underlying snapshot rather than silently using the option mark as spot.
     spot,
     dividendYield,
-  }), [calcSide, dividendYield, effectiveTicker, parsed?.side, selectedRow, spot]);
+  }), [dividendYield, effectiveTicker, selectedSide, selectedRow, spot]);
 
   const openCalculator = useCallback(() => {
     if (!calcParams) return;
@@ -303,6 +356,19 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     [calcParams, openCalculator],
   );
 
+  const selectContract = useCallback((row: OptionTableRow, index: number, side?: OptionSide, preservePointer = false) => {
+    userSelectedStrikeRef.current = true;
+    setScrollToIndexAlign("nearest");
+    setStrikeIdx(index);
+    const chosenSide = resolveCalcSide(side ?? calcSide, parsed?.side, row);
+    const contract = chosenSide === "put" ? row.put : chosenSide === "call" ? row.call : undefined;
+    if (contract && chosenSide) {
+      setContractSelection((current) => preservePointer && current?.context === strikeSelectionKey && current.strike === row.strike
+        ? current : { context: strikeSelectionKey, strike: row.strike,
+          side: chosenSide, contractSymbol: contract.contractSymbol });
+    }
+  }, [calcSide, parsed?.side, strikeSelectionKey]);
+
   const renderCell = useCallback((
     row: OptionTableRow,
     column: OptionColumn,
@@ -318,21 +384,24 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
       ...cell,
       onMouseDown: () => {
         enterInteractive();
-        userSelectedStrikeRef.current = true;
-        setScrollToIndexAlign("nearest");
-        setStrikeIdx(index);
+        selectContract(row, index, side);
         setCalcSide(side);
       },
     };
-  }, [enterInteractive]);
+  }, [enterInteractive, selectContract]);
 
   useOptionsAccessFooter({
     chain,
-    error,
+    error: [error, underlyingStale ? "Underlying quote stale: Greeks and calculator unavailable" : null,
+      selectedContract && strikeChain && !selectedContractAvailable
+        ? `Selected ${formatStrikeLabel(selectedContract.strike)} ${selectedContract.side} unavailable` : null,
+      summary?.historicalVolatilityUnavailableReason].filter(Boolean).join(" · ") || null,
     focused,
     hints: footerHints,
     loading,
     quoteCoverage: optionQuoteCoverage,
+    reference: selectedReference,
+    spreadColumnVisible: optionFieldIds.includes("spread"),
   });
 
   useEffect(() => {
@@ -349,7 +418,7 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     setScrollToIndexAlign("center");
     setStrikeIdx(findNearestStrikeIndex(strikes, targetStrike));
     setAutoScrollVersion((version) => version + 1);
-  }, [expIdx, parsed?.strike, spot, strikes]);
+  }, [selectedExpiration, parsed?.strike, spot, strikes]);
 
   useShortcut((event) => {
     if (event.defaultPrevented || event.propagationStopped || event.targetEditable) return;
@@ -437,19 +506,22 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
     return <EmptyState title="No ticker selected." message="Select a ticker to view options." />;
   }
   if (loading && !chain) return <Spinner label="Loading options chain..." />;
-  if (error) return <EmptyState title="Options chain unavailable." message={error} />;
-  if (!chain || chain.expirationDates.length === 0) {
+  if (error && !chain) return <EmptyState title="Options chain unavailable." message={error} />;
+  if (!chain || expirationDates.length === 0) {
     return <EmptyState title={`No options available for ${effectiveTicker}.`} />;
   }
 
-  const posShares = isOpt && parsed
-    ? ticker.metadata.positions.reduce((sum, p) => sum + p.shares, 0)
+  const positionContracts = isOpt && parsed
+    ? ticker.metadata.positions.reduce((sum, p) => sum + Math.abs(p.shares) * signedPositionDirection(p), 0)
     : 0;
   const expirationTabsWidth = Math.max(width - 9 - (loading ? 2 : 0), 8);
   const summaryRowCount = height >= 10 ? 2 : height >= 7 ? 1 : 0;
+  // No term here follows the selection or the load, so an empty cold-expiry
+  // response cannot resize the table: growing it during loading would turn a
+  // clamped scroll into apparent user navigation.
   const tableHeight = Math.max(1, height - 1 - summaryRowCount - (isOpt && parsed ? 1 : 0));
   // The strip scrolls; without a marker a clipped last date reads as the last expiry.
-  const expirationStripOverflows = chain.expirationDates
+  const expirationStripOverflows = expirationDates
     .reduce((total, ts) => total + formatExpDate(ts).length + 2, 0) > expirationTabsWidth;
 
   return (
@@ -462,14 +534,11 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
         <Text fg={colors.textDim}>Exp:</Text>
         <Box width={expirationTabsWidth} height={1} overflow="hidden">
           <Tabs
-            tabs={chain.expirationDates.map((ts, i) => ({
-              label: formatExpDate(ts),
-              value: String(i),
-            }))}
-            activeValue={String(expIdx)}
+            tabs={expirationTabs}
+            activeValue={String(selectedExpiration)}
             onSelect={(value) => {
               enterInteractive();
-              setExpIdx(Number(value));
+              selectExpiration(Number(value));
             }}
             compact
             variant="bare"
@@ -485,7 +554,7 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
       {isOpt && parsed && (
         <Box height={1}>
           <Text fg={colors.textBright}>
-            {`Position: ${posShares} ${parsed.side === "C" ? "call" : "put"} contract${posShares !== 1 ? "s" : ""} @ $${parsed.strike}`}
+            {`Position: ${positionContracts} ${parsed.side === "C" ? "call" : "put"} contract${Math.abs(positionContracts) !== 1 ? "s" : ""}${positionContracts < 0 ? " (SHORT)" : ""} @ $${parsed.strike}`}
           </Text>
         </Box>
       )}
@@ -493,13 +562,14 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
       <DataTableView<OptionTableRow, OptionColumn>
         focused={focused}
         selection={{
-          kind: "index",
-          selectedIndex: strikeIdx,
-          onChange: (index) => {
-            userSelectedStrikeRef.current = true;
-            setScrollToIndexAlign("nearest");
+          kind: "id",
+          selectedId: selectedContract ? String(selectedContract.strike) : selectedRow ? String(selectedRow.strike) : null,
+          getId: (row) => String(row.strike),
+          onChange: (_id, row, index, reason) => {
             enterInteractive();
-            setStrikeIdx(index);
+            // A side-cell handler owns its precise contract choice. A later
+            // row pointer callback must not replace it with the prior side.
+            selectContract(row, index, undefined, reason === "pointer");
           },
         }}
         onCursorChange={() => {
@@ -516,17 +586,19 @@ export function OptionsView({ width, height, focused, onCapture = () => {} }: Op
         sortDirection="asc"
         onHeaderClick={() => {}}
         onTableMouseDown={enterInteractive}
-        onBodyScrollActivity={() => { userSelectedStrikeRef.current = true; }}
+        onBodyScrollActivity={(source) => {
+          if (source !== "programmatic") userSelectedStrikeRef.current = true;
+        }}
         visibleRangeKey={viewportKey}
         onVisibleRangeChange={handleVisibleStrikeRangeChange}
         getItemKey={(row) => String(row.strike)}
         renderCell={renderCell}
-        emptyStateTitle={strikesLoading ? "Loading strikes..." : "No strikes available."}
+        emptyStateTitle={error && !strikeChain ? "Selected expiration unavailable." : strikesLoading ? "Loading strikes..." : "No strikes available."}
         rootWidth={Math.max(1, width - 2)}
         rootHeight={tableHeight}
         columnGap={0}
         horizontalPadding={0}
-        scrollToIndex={strikeIdx}
+        scrollToIndex={selectedStrikeIdx >= 0 ? selectedStrikeIdx : undefined}
         scrollToIndexAlign={scrollToIndexAlign}
         scrollToIndexVersion={autoScrollVersion}
       />

package/src/plugins/builtin/options-calculator/boundary-integrity.test.tsx

@@ -0,0 +1,112 @@
+import { afterEach, expect, test } from "bun:test";
+import { act, useReducer } from "react";
+import { writeFileSync } from "node:fs";
+
+const source = process.env.OPTIONS_SOURCE ?? new URL("../../../../", import.meta.url).pathname.replace(/\/$/, "");
+const out = process.env.OPTIONS_OUT;
+const { testRender, emitKeypress } = await import(`${source}/src/renderers/opentui/test-utils.tsx`);
+const { AppContext, PaneInstanceProvider, appReducer, createInitialState } = await import(`${source}/src/state/app/context`);
+const { createTestPaneConfig } = await import(`${source}/src/test-support/pane.tsx`);
+const { PaneFooterProvider, PaneFooterBar } = await import(`${source}/src/components/layout/pane/footer`);
+const { Box } = await import(`${source}/src/ui`);
+const { OptionsCalculatorPane } = await import(`${source}/src/plugins/builtin/options-calculator/pane.tsx`);
+const paneId = "options-boundary:test";
+let setup: any;
+let observedState: any;
+let footer: any;
+
+afterEach(async () => {
+  if (setup) await act(async () => setup.renderer.destroy());
+  setup = undefined;
+});
+
+async function mount(params: Record<string, string>) {
+  const config = createTestPaneConfig("/tmp/options-boundary", {
+    instanceId: paneId, paneId: "options-calculator", binding: { kind: "none" }, params,
+  });
+  const initial = createInitialState(config);
+  initial.focusedPaneId = paneId;
+  function Harness() {
+    const [state, dispatch] = useReducer(appReducer, initial);
+    observedState = state;
+    return <AppContext value={{ state, dispatch }}><PaneInstanceProvider paneId={paneId}>
+      <PaneFooterProvider>{(current: any) => {
+        footer = current;
+        return <Box width={90} height={19} flexDirection="column">
+          <OptionsCalculatorPane paneId={paneId} paneType="options-calculator" focused width={90} height={18}/>
+          <PaneFooterBar footer={current} focused width={90}/>
+        </Box>;
+      }}</PaneFooterProvider>
+    </PaneInstanceProvider></AppContext>;
+  }
+  setup = await testRender(<Harness/>, { width: 90, height: 19 });
+  for (let i = 0; i < 4; i++) await act(async () => setup.renderOnce());
+}
+
+function capture(name: string) {
+  const frame = setup.captureCharFrame();
+  if (out) {
+    writeFileSync(`${out}/${name}.txt`, frame);
+    writeFileSync(`${out}/${name}.json`, JSON.stringify({ source, footer, state: observedState.paneState[paneId] }, null, 2));
+  }
+  return frame;
+}
+
+for (const side of ["call", "put"] as const) {
+  for (const offset of [0, 0.000001]) {
+    test(`${side} IV keeps an exact model boundary separate from unresolved nearby prices`, async () => {
+      await mount({ side, spot: side === "call" ? "150" : "50", strike: "100", days: "1", rate: "0", volatility: "0", marketPrice: String(50 + offset) });
+      const frame = capture(`${side}-${offset ? "near-bound" : "exact-bound"}`);
+      expect(frame).toContain("Model");
+      if (offset === 0) {
+        expect(frame).toMatch(/Implied IV\s+0\.00%/);
+        expect(footer.info).toEqual([]);
+      } else {
+        expect(frame).toMatch(/Implied IV\s+—/);
+        expect(frame).toContain("too close to a model bound");
+      }
+    });
+  }
+}
+
+test("a positive time value retains the ordinary IV solution", async () => {
+  await mount({ side: "call", spot: "100", strike: "100", days: "365", rate: "0.05", volatility: "0.2", marketPrice: "10.4506" });
+  const frame = capture("identifiable");
+  expect(frame).toMatch(/Implied IV\s+20\.00%/);
+  expect(frame).toContain("per unit");
+});
+
+test("the model maximum stays unavailable when the numerical price curve saturates", async () => {
+  // Numerical-domain boundary, not a claim that this duration is a listed LEAPS contract.
+  await mount({ spot: "100", strike: "100", days: "36500", rate: "0", marketPrice: "100" });
+  const frame = capture("model-maximum");
+  expect(frame).toMatch(/Implied IV\s+—/);
+  expect(frame).toContain("no finite IV at the model maximum");
+});
+
+for (const entry of [
+  { field: "spot", tabs: 1, input: "217.987" },
+  { field: "daysToExpiry", tabs: 3, input: "0.000347" },
+]) {
+  test(`keyboard submission retains the actual ${entry.field} input`, async () => {
+    await mount({});
+    for (let i = 0; i < entry.tabs; i++) await emitKeypress(setup, { name: "tab", sequence: "\t" });
+    await act(async () => { await setup.mockInput.typeText(entry.input); setup.mockInput.pressEnter(); await setup.renderOnce(); });
+    await act(async () => setup.renderOnce());
+    const frame = capture(`edit-${entry.field}`);
+    expect(observedState.paneState[paneId].draft[entry.field]).toBe(Number(entry.input));
+    expect(frame).toContain(entry.input);
+  });
+}
+
+test("mouse rate editing preserves entered negative percentage precision", async () => {
+  await mount({ days: "1095" });
+  const lines = setup.captureCharFrame().split("\n");
+  const y = lines.findIndex((line: string) => line.includes("Rate"));
+  const x = lines[y].indexOf("Rate");
+  await act(async () => { await setup.mockMouse.click(x + 1, y); await setup.renderOnce(); });
+  await act(async () => { await setup.mockInput.typeText("-1.235"); setup.mockInput.pressEnter(); await setup.renderOnce(); });
+  const frame = capture("mouse-negative-rate");
+  expect(frame).toContain("-1.235");
+  expect(observedState.paneState[paneId].draft.rate).toBeCloseTo(-0.01235, 10);
+});

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

@@ -14,7 +14,7 @@ export const optionsCalculatorModule: PluginModule = {
       component: OptionsCalculatorPane,
       defaultPosition: "right",
       defaultMode: "floating",
-      defaultFloatingSize: { width: 76, height: 16 },
+      defaultFloatingSize: { width: 76, height: 20 },
     },
   ],
 

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

@@ -7,6 +7,8 @@ import {
   draftFromParams,
   solveImpliedVolatility,
   valueOption,
+  updateOptionCalcDraft,
+  reconcileOptionCalcDraft,
   type OptionCalcDraft,
 } from "./model";
 
@@ -21,6 +23,37 @@ const CANONICAL: OptionCalcDraft = {
   dividendYield: 0,
 };
 
+test("contract edits retain numeric what-if inputs without borrowing market attribution", () => {
+  const original: OptionCalcDraft = { ...CANONICAL, marketPrice: 20.425, marketPriceSource: "mid",
+    marketReference: { contractSymbol: "COST260925C00900000", currency: "USD", expiration: 1790294400,
+      bid: 19.75, ask: 21.1, lastPrice: 21.34, lastTradeDate: 1789136721 } };
+  for (const patch of [{ side: "put" as const }, { strike: 105 }, { daysToExpiry: 14 }, { symbol: "COST" }]) {
+    const changed = updateOptionCalcDraft(original, patch);
+    expect(changed.marketPrice).toBe(20.425);
+    expect(changed.marketPriceSource).toBeUndefined();
+    expect(changed.marketReference).toBeUndefined();
+    const restored = updateOptionCalcDraft(changed, { side: original.side, strike: original.strike,
+      daysToExpiry: original.daysToExpiry, symbol: original.symbol });
+    expect(restored.marketPriceSource).toBeUndefined();
+  }
+  expect(updateOptionCalcDraft(original, { side: original.side })).toEqual(original);
+  expect(updateOptionCalcDraft(original, { volatility: 0.4, spot: 120 }).marketReference).toEqual(original.marketReference);
+  expect(updateOptionCalcDraft(original, { marketPrice: 20.425 }).marketPriceSource).toBeUndefined();
+  expect(updateOptionCalcDraft({ ...CANONICAL, marketPrice: 5 }, { side: "put" }).marketPrice).toBe(5);
+});
+
+test("restored legacy changed-contract drafts lose stale source attribution before interaction", () => {
+  const seed = { ...CANONICAL, marketPrice: 20.425, marketPriceSource: "mid" as const };
+  const legacyPut = { ...seed, side: "put" as const };
+  expect(reconcileOptionCalcDraft(legacyPut, seed)).toMatchObject({
+    side: "put", marketPrice: 20.425, marketPriceSource: undefined, marketReference: undefined,
+  });
+  expect(reconcileOptionCalcDraft(seed, seed).marketPriceSource).toBe("mid");
+  expect(reconcileOptionCalcDraft({ ...seed, marketPrice: 5 }, seed).marketPriceSource).toBeUndefined();
+  const manual = updateOptionCalcDraft(legacyPut, { side: "call" });
+  expect(reconcileOptionCalcDraft(manual, seed).marketPriceSource).toBeUndefined();
+});
+
 describe("valueOption", () => {
   test("matches the textbook Black-Scholes call and put", () => {
     expect(valueOption(CANONICAL).price).toBeCloseTo(10.4506, 3);
@@ -54,6 +87,22 @@ describe("valueOption", () => {
       .toBeCloseTo(100 - 100 * Math.exp(-0.05), 6);
   });
 
+  test("zero-volatility theta and rho agree with changes in the discounted payoff", () => {
+    for (const side of ["call", "put"] as const) {
+      const draft = { ...CANONICAL, side, spot: side === "call" ? 120 : 80, volatility: 0, dividendYield: 0.02 };
+      const value = valueOption(draft);
+      const dayStep = 0.001;
+      const rateStep = 0.000001;
+      const theta = (valueOption({ ...draft, daysToExpiry: draft.daysToExpiry - dayStep }).price
+        - valueOption({ ...draft, daysToExpiry: draft.daysToExpiry + dayStep }).price) / (2 * dayStep);
+      const rho = (valueOption({ ...draft, rate: draft.rate + rateStep }).price
+        - valueOption({ ...draft, rate: draft.rate - rateStep }).price) / (2 * rateStep * 100);
+      expect(value.thetaPerDay).toBeCloseTo(theta, 7);
+      expect(value.rhoPerPoint).toBeCloseTo(rho, 7);
+      expect(valueOption({ ...draft, daysToExpiry: 0 }).rhoPerPoint).toBe(0);
+    }
+  });
+
   test("never returns NaN or Infinity for impossible inputs", () => {
     const broken: OptionCalcDraft[] = [
       { ...CANONICAL, spot: 0 },
@@ -170,3 +219,24 @@ describe("describeDraftProblem", () => {
     expect(describeDraftProblem({ ...CANONICAL, volatility: -0.1 })).toMatch(/Volatility/);
   });
 });
+
+
+test("IV distinguishes exact zero-volatility prices from numerically unresolved nearby prices", () => {
+  for (const side of ["call", "put"] as const) {
+    const draft={...CANONICAL,side,spot:side==="call"?150:50,daysToExpiry:1,rate:-.01,dividendYield:.02};
+    const lower=valueOption({...draft,volatility:0}).price;
+    expect(solveImpliedVolatility(draft,lower)).toEqual({volatility:0,note:null});
+    for(const offset of [-.000001,.000001]) {
+      const result=solveImpliedVolatility(draft,lower+offset);
+      expect(result.volatility).toBeNull();expect(result.note).toContain("model bound");
+    }
+    expect(solveImpliedVolatility(draft,lower-.01).note).toContain("below intrinsic");
+  }
+});
+
+test("an asymptotic maximum and collapsed numerical bounds cannot produce a finite IV", () => {
+  const long={...CANONICAL,daysToExpiry:36500,rate:0};
+  expect(solveImpliedVolatility(long,100)).toEqual({volatility:null,note:"no finite IV at the model maximum"});
+  expect(solveImpliedVolatility({...CANONICAL,rate:-1e308},50).volatility).toBeNull();
+  expect(solveImpliedVolatility({...CANONICAL,strike:1e-30},100).note).toContain("precision");
+});