gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/notes/ticker-notes-tab.test.tsx

@@ -3,39 +3,23 @@ import { act, useReducer, useState } from "react";
 import { PaneFooterProvider } from "../../../components/layout/pane/footer";
 import { TestDialogProvider, testRender } from "../../../renderers/opentui/test-utils";
 import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import {
-  AppContext,
-  PaneInstanceProvider,
-  appReducer,
-  createInitialState,
-} from "../../../state/app/context";
-import { cloneLayout, createDefaultConfig } from "../../../types/config";
-import type { TickerRecord } from "../../../types/ticker";
+import { appReducer, createInitialState } from "../../../state/app/context";
 import { Box, Text } from "../../../ui";
-import { PluginRenderProvider, type PluginRuntimeAccess } from "../../runtime";
+import type { PluginRuntimeAccess } from "../../runtime";
 import { createNotesTab } from "./ticker-notes-tab";
 import type { NotesFiles } from "./files";
+import { NotesStoreRegistry } from "./store";
+
+/** The tabs take a registry; while signed out it hands back the disk store. */
+function registryFor(files: NotesFiles): NotesStoreRegistry {
+  return new NotesStoreRegistry({ persistence: null, files, isSignedIn: () => false });
+}
+import { TestPaneProvider, createTestTicker as makeTicker, createTestPaneConfig } from "../../../test-support/pane";
 
 const TEST_PANE_ID = "ticker-detail:notes-test";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
-function makeTicker(symbol: string): TickerRecord {
-  return {
-    metadata: {
-      ticker: symbol,
-      exchange: "NASDAQ",
-      currency: "USD",
-      name: symbol,
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      custom: {},
-      tags: [],
-    },
-  };
-}
-
 function createMockNotesFiles(options?: {
   loadDelayMs?: number;
   notes?: Record<string, string>;
@@ -46,6 +30,8 @@ function createMockNotesFiles(options?: {
   const loadDelayMs = options?.loadDelayMs ?? 0;
   return {
     saves,
+    readOnly: false,
+    owner: { kind: "user" },
     async load(symbol: string) {
       if (loadDelayMs > 0) {
         await new Promise((resolve) => setTimeout(resolve, loadDelayMs));
@@ -68,23 +54,11 @@ function createMockNotesFiles(options?: {
 }
 
 function createNotesHarnessConfig(symbol: string) {
-  const config = createDefaultConfig("/tmp/gloomberb-notes-tab");
-  const layout = {
-    dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
-    instances: [{
-      instanceId: TEST_PANE_ID,
-      paneId: "ticker-detail",
-      binding: { kind: "fixed" as const, symbol },
-    }],
-    floating: [],
-    detached: [],
-  };
-
-  return {
-    ...config,
-    layout,
-    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
-  };
+  return createTestPaneConfig("/tmp/gloomberb-notes-tab", {
+    instanceId: TEST_PANE_ID,
+    paneId: "ticker-detail",
+    binding: { kind: "fixed", symbol },
+  });
 }
 
 function NotesTabHarness({
@@ -124,26 +98,22 @@ function NotesTabHarness({
   return (
     <TestDialogProvider>
       <Box flexDirection="column" width={80} height={24}>
-        <AppContext value={{ state, dispatch }}>
-          <PaneInstanceProvider paneId={TEST_PANE_ID}>
-            <PluginRenderProvider pluginId="notes" runtime={runtime}>
-              <PaneFooterProvider>
-                {() => (
-                  <>
-                    <NotesTab
-                      width={78}
-                      height={20}
-                      focused={focused}
-                      onCapture={() => {}}
-                    />
-                    <Text onMouseDown={() => setFocused(false)}>blur-tab</Text>
-                    <Text onMouseDown={() => switchSymbol("MSFT")}>switch-msft</Text>
-                  </>
-                )}
-              </PaneFooterProvider>
-            </PluginRenderProvider>
-          </PaneInstanceProvider>
-        </AppContext>
+        <TestPaneProvider state={state} dispatch={dispatch} paneId={TEST_PANE_ID} pluginId="notes" runtime={runtime}>
+          <PaneFooterProvider>
+            {() => (
+              <>
+                <NotesTab
+                  width={78}
+                  height={20}
+                  focused={focused}
+                  onCapture={() => { }}
+                />
+                <Text onMouseDown={() => setFocused(false)}>blur-tab</Text>
+                <Text onMouseDown={() => switchSymbol("MSFT")}>switch-msft</Text>
+              </>
+            )}
+          </PaneFooterProvider>
+        </TestPaneProvider>
       </Box>
     </TestDialogProvider>
   );
@@ -162,7 +132,7 @@ describe("createNotesTab", () => {
   test("surfaces a save failure when the tab loses focus", async () => {
     const notifications: string[] = [];
     const notesFiles = createMockNotesFiles({ saveError: new Error("disk full") });
-    const NotesTab = createNotesTab(notesFiles);
+    const NotesTab = createNotesTab(registryFor(notesFiles));
     const runtime = createTestPluginRuntime({
       notify: ({ body }) => { notifications.push(body); },
     });
@@ -209,7 +179,7 @@ describe("createNotesTab", () => {
     }
 
     expect(notesFiles.saves).toEqual([{ symbol: "AAPL", text: "ab" }]);
-    expect(notifications).toEqual(["Failed to save note. Check disk space and permissions."]);
+    expect(notifications).toEqual(["disk full"]);
   });
 
   test("does not save stale buffer text to a new ticker before its notes load", async () => {
@@ -217,7 +187,7 @@ describe("createNotesTab", () => {
       loadDelayMs: 50,
       notes: { MSFT: "msft-note" },
     });
-    const NotesTab = createNotesTab(notesFiles);
+    const NotesTab = createNotesTab(registryFor(notesFiles));
 
     testSetup = await testRender(
       <NotesTabHarness NotesTab={NotesTab} initialSymbol="AAPL" />,
@@ -267,7 +237,7 @@ describe("createNotesTab", () => {
       loadDelayMs: 100,
       notes: { AAPL: "existing-aapl-note", MSFT: "" },
     });
-    const NotesTab = createNotesTab(notesFiles);
+    const NotesTab = createNotesTab(registryFor(notesFiles));
 
     testSetup = await testRender(
       <NotesTabHarness NotesTab={NotesTab} initialSymbol="AAPL" />,
@@ -297,7 +267,7 @@ describe("createNotesTab", () => {
       loadDelayMs: 100,
       notes: { MSFT: "msft-note" },
     });
-    const NotesTab = createNotesTab(notesFiles);
+    const NotesTab = createNotesTab(registryFor(notesFiles));
 
     testSetup = await testRender(
       <NotesTabHarness NotesTab={NotesTab} initialSymbol="AAPL" />,
@@ -352,7 +322,7 @@ describe("createNotesTab", () => {
       loadDelayMs: 100,
       notes: { AAPL: "existing-note" },
     });
-    const NotesTab = createNotesTab(notesFiles);
+    const NotesTab = createNotesTab(registryFor(notesFiles));
 
     testSetup = await testRender(
       <NotesTabHarness NotesTab={NotesTab} initialSymbol="AAPL" />,

package/src/plugins/builtin/notes/ticker-notes-tab.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, type TextareaRenderable } from "../../../ui";
 import { useShortcut } from "../../../react/input";
 import type { TickerResearchTabProps } from "../../../types/plugin";
@@ -7,14 +7,31 @@ import { colors } from "../../../theme/colors";
 import { MarkdownEditor } from "../../../components/markdown-editor";
 import { EmptyState, usePaneFooter } from "../../../components";
 import { usePluginAppActions } from "../../runtime";
-import type { NotesFiles } from "./files";
+import { useDialog } from "../../../ui/dialog";
 import { MarkdownNotePreview } from "./markdown-note-preview";
+import {
+  defaultNoteOwner,
+  NoteOwnerStrip,
+  ReadOnlyBanner,
+  resolveNoteConflict,
+  useNoteTeams,
+} from "./owner";
+import { NoteConflictError, type NoteOwner, type NotesStoreRegistry } from "./store";
 import { useSyncedText } from "./text-state";
 
-export function createNotesTab(notesFiles: NotesFiles) {
+export function createNotesTab(registry: NotesStoreRegistry) {
   return function NotesTab({ focused, width, onCapture }: TickerResearchTabProps) {
     const { ticker } = usePaneTicker();
     const { notify } = usePluginAppActions();
+    const dialog = useDialog();
+    const teams = useNoteTeams();
+    const [owner, setOwner] = useState<NoteOwner>(defaultNoteOwner);
+    // A team the account left falls back to personal notes.
+    const effectiveOwner = owner.kind === "team" && !teams.some((team) => team.id === owner.teamId)
+      ? { kind: "user" as const }
+      : owner;
+    const notesFiles = useMemo(() => registry.forOwner(effectiveOwner), [effectiveOwner.kind, effectiveOwner.kind === "team" ? effectiveOwner.teamId : ""]);
+    const ownerKey = `${effectiveOwner.kind}:${effectiveOwner.kind === "team" ? effectiveOwner.teamId : ""}`;
     const textareaRef = useRef<TextareaRenderable | null>(null);
     const [notesFocused, setNotesFocused] = useState(false);
     const [loadError, setLoadError] = useState<string | null>(null);
@@ -55,16 +72,35 @@ export function createNotesTab(notesFiles: NotesFiles) {
     }, [noteTextRef, setNoteText, tickerSymbol]);
 
     const saveNotesFor = useCallback((symbol: string | null, text: string) => {
-      if (!symbol) return;
+      if (!symbol || notesFiles.readOnly) return;
       // Blur and symbol switches both save; without this every ticker switch
       // rewrites an unchanged file and can clobber another pane on the same symbol.
       if (lastSavedTextRef.current.get(symbol) === text) return;
       lastSavedTextRef.current.set(symbol, text);
-      notesFiles.save(symbol, text).catch((error) => {
+      notesFiles.save(symbol, text).catch(async (error: unknown) => {
+        if (error instanceof NoteConflictError) {
+          // Keep the buffer; the person chooses between the two versions.
+          lastSavedTextRef.current.delete(symbol);
+          const choice = await resolveNoteConflict(dialog, error);
+          const cloud = registry.cloud(effectiveOwner);
+          if (choice === "reload") {
+            const theirs = error.current?.content ?? "";
+            if (cloud && error.current) cloud.acceptCurrent(symbol, error.current);
+            lastSavedTextRef.current.set(symbol, theirs);
+            if (loadedSymbolRef.current === symbol) applyNoteText(theirs);
+          } else if (choice === "overwrite") {
+            if (cloud && error.current) cloud.acceptCurrent(symbol, error.current);
+            lastSavedTextRef.current.set(symbol, text);
+            await notesFiles.save(symbol, text).catch((again: unknown) => {
+              notify({ body: again instanceof Error ? again.message : "Could not save the note.", type: "error" });
+            });
+          }
+          return;
+        }
         console.error("[notes] Failed to save ticker note:", error);
-        notify({ body: "Failed to save note. Check disk space and permissions.", type: "error" });
+        notify({ body: error instanceof Error ? error.message : "Failed to save note.", type: "error" });
       });
-    }, [notesFiles, notify]);
+    }, [applyNoteText, dialog, effectiveOwner, notesFiles, notify]);
 
     useEffect(() => {
       if (
@@ -86,6 +122,7 @@ export function createNotesTab(notesFiles: NotesFiles) {
 
     useEffect(() => {
       loadedSymbolRef.current = null;
+      lastSavedTextRef.current.clear();
       applyNoteText("");
       setLoadError(null);
 
@@ -113,12 +150,12 @@ export function createNotesTab(notesFiles: NotesFiles) {
           saveNotesFor(tickerSymbol, getCurrentNoteText());
         }
       };
-    }, [tickerSymbol, applyNoteText, getCurrentNoteText, saveNotesFor, notesFiles]);
+    }, [tickerSymbol, applyNoteText, getCurrentNoteText, saveNotesFor, notesFiles, ownerKey]);
 
     useShortcut((event) => {
       if (!focused || loadError) return;
       const isEnter = event.name === "enter" || event.name === "return";
-      if (isEnter && !notesFocused) {
+      if (isEnter && !notesFocused && !notesFiles.readOnly) {
         setNotesFocusedAndCapture(true);
         return;
       }
@@ -131,14 +168,24 @@ export function createNotesTab(notesFiles: NotesFiles) {
     usePaneFooter("ticker-notes", () => ({
       info: loadError
         ? [{ id: "load-error", parts: [{ text: loadError, tone: "warning" as const }] }]
-        : [{ id: "mode", parts: [{ text: notesFocused ? "editing" : "viewing", tone: "muted" as const }] }],
-    }), [loadError, notesFocused]);
+        : [{ id: "mode", parts: [{ text: notesFiles.readOnly ? "read-only" : notesFocused ? "editing" : "viewing", tone: "muted" as const }] }],
+    }), [loadError, notesFiles.readOnly, notesFocused]);
 
     if (!ticker) return <Text fg={colors.textDim}>Select a ticker to view notes.</Text>;
 
     return (
       <Box flexDirection="column" flexGrow={1}>
-        <Box flexGrow={1} minHeight={0} paddingX={1} onMouseDown={() => { if (!notesFocused && !loadError) setNotesFocusedAndCapture(true); }}>
+        <NoteOwnerStrip
+          owner={effectiveOwner}
+          teams={teams}
+          focused={focused && !notesFocused}
+          onSelect={(next) => {
+            if (tickerSymbol && loadedSymbolRef.current === tickerSymbol) saveNotesFor(tickerSymbol, getCurrentNoteText());
+            setOwner(next);
+          }}
+        />
+        {notesFiles.readOnly && <ReadOnlyBanner owner={effectiveOwner} teams={teams} />}
+        <Box flexGrow={1} minHeight={0} paddingX={1} onMouseDown={() => { if (!notesFocused && !loadError && !notesFiles.readOnly) setNotesFocusedAndCapture(true); }}>
           {loadError ? (
             <EmptyState
               title="These notes could not be read."
@@ -159,7 +206,7 @@ export function createNotesTab(notesFiles: NotesFiles) {
               text={noteText}
               width={width}
               placeholder="Write notes about this ticker..."
-              onActivate={() => { if (!loadError) setNotesFocusedAndCapture(true); }}
+              onActivate={() => { if (!loadError && !notesFiles.readOnly) setNotesFocusedAndCapture(true); }}
             />
           )}
         </Box>

package/src/plugins/builtin/options/analytics.test.ts

@@ -81,3 +81,68 @@ test("derives call and put Greeks from the chain IV", () => {
   expect(call?.gamma).toBeCloseTo(put!.gamma, 10);
   expect(call?.vegaPerPoint).toBeCloseTo(put!.vegaPerPoint, 10);
 });
+
+test("activity totals require each reported contract's input without discarding independent metrics", () => {
+  const chain: OptionsChain = {
+    underlyingSymbol: "AAPL", expirationDates: [],
+    calls: [contract(100, .25, 10, 20)], puts: [contract(100, .25, 0, 0)],
+  };
+  for (const invalid of [undefined, Number.NaN, Infinity, -1]) {
+    const partial = { ...chain, calls: [{ ...chain.calls[0]!, openInterest: invalid }] };
+    const summary = calculateOptionsSummary(partial, 100, []);
+    expect(summary.expirationVolume).toBe(10);
+    expect(summary.putCallVolumeRatio).toBe(0);
+    expect(summary.putCallOpenInterestRatio).toBeNull();
+    expect(summary.atmImpliedVolatility).toBe(.25);
+  }
+  const missingVolume = calculateOptionsSummary({ ...chain, puts: [{ ...chain.puts[0]!, volume: undefined }] }, 100, []);
+  expect(missingVolume.expirationVolume).toBeNull();
+  expect(missingVolume.putCallVolumeRatio).toBeNull();
+  expect(missingVolume.putCallOpenInterestRatio).toBe(0);
+  const zero = calculateOptionsSummary({ ...chain, calls: [{ ...chain.calls[0]!, volume: 0, openInterest: 0 }] }, 100, []);
+  expect(zero.expirationVolume).toBe(0);
+  expect(zero.putCallVolumeRatio).toBeNull();
+  expect(zero.putCallOpenInterestRatio).toBeNull();
+});
+
+
+test("rejects bad observations inside the selected HV window instead of bridging them", () => {
+  const good = priceHistory();
+  const extended = [{ date: new Date(Date.UTC(2025, 11, 31)), close: 100 }, ...good];
+  for (const bad of [{ high: 90, low: 110 }, { high: 99 }, { close: 0 }, { close: Number.NaN }]) {
+    const points = extended.map((point, i) => i === 15 ? { ...point, ...bad } : point);
+    expect(historicalVolatility30d(points)).toBeNull();
+    const summary = calculateOptionsSummary({ underlyingSymbol: "AAPL", expirationDates: [], calls: [contract(100, .2, 100, 200)], puts: [] }, 100, points);
+    expect(summary.historicalVolatilityUnavailableReason).toBeTruthy();
+    expect(summary.impliedHistoricalRatio).toBeNull();
+    expect(summary.atmImpliedVolatility).toBe(.2);
+  }
+  // An excluded earlier bad bar cannot contaminate a complete later window.
+  expect(historicalVolatility30d([{ ...extended[0]!, high: 90, low: 110 }, ...good])).toBeCloseTo(historicalVolatility30d(good)!, 12);
+});
+
+test("deduplicates corrections before selecting 31 observations and retains immutable rejected source data", () => {
+  const good = priceHistory();
+  expect(historicalVolatility30d(good.slice(1).flatMap((point) => [point, point]))).toBeNull();
+  const broken = { ...good[15]!, high: 90, low: 110 };
+  const corrected = [...good.slice(0, 15), broken, ...good.slice(16), good[15]!];
+  expect(historicalVolatility30d(corrected)).toBeCloseTo(historicalVolatility30d(good)!, 12);
+  const chain = { underlyingSymbol: "AAPL", expirationDates: [], calls: [], puts: [] };
+  const summary = calculateOptionsSummary(chain, 100, [...good, broken]);
+  expect(summary.historicalVolatility30d).toBeNull();
+  const diagnostic = summary.historicalVolatilityIntegrity!;
+  expect(diagnostic.sourcePoints).toHaveLength(1);
+  expect(diagnostic.sourcePoints[0]!.date).toBe(good[15]!.date.toISOString());
+  broken.high = 120;
+  expect(diagnostic.sourcePoints[0]!.high).toBe(90);
+  expect(Object.isFrozen(diagnostic.sourcePoints)).toBe(true);
+  expect(Object.isFrozen(diagnostic.sourcePoints[0])).toBe(true);
+});
+
+test("validates chronology without requiring full OHLC and handles finite extreme prices", () => {
+  const good = priceHistory();
+  expect(historicalVolatility30d([...good].reverse())).toBeCloseTo(historicalVolatility30d(good)!, 12);
+  expect(historicalVolatility30d([...good, { date: new Date(Number.NaN), close: 100 }])).toBeNull();
+  expect(historicalVolatility30d(good.map((point, i) => ({ ...point, close: i % 2 ? 1e300 : 1e-300 })))).toBeFinite();
+  expect(historicalVolatility30d(good.map((point) => ({ ...point, close: 100 })))).toBe(0);
+});

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

@@ -1,3 +1,4 @@
+import { mergePriceHistoryIntegrity, pricePointIntegrity, type PriceHistoryIntegrity } from "../../../utils/price-history-integrity";
 import type { OptionContract, OptionsChain, PricePoint } from "../../../types/financials";
 import {
   DEFAULT_OPTION_CALC_DRAFT,
@@ -13,8 +14,10 @@ const HISTORICAL_VOLATILITY_SESSIONS = 30;
 export interface OptionsSummary {
   atmImpliedVolatility: number | null;
   historicalVolatility30d: number | null;
+  historicalVolatilityUnavailableReason?: string;
+  historicalVolatilityIntegrity?: PriceHistoryIntegrity;
   impliedHistoricalRatio: number | null;
-  expirationVolume: number;
+  expirationVolume: number | null;
   putCallVolumeRatio: number | null;
   putCallOpenInterestRatio: number | null;
 }
@@ -23,15 +26,18 @@ function positive(value: number | undefined): value is number {
   return typeof value === "number" && Number.isFinite(value) && value > 0;
 }
 
-function ratio(numerator: number, denominator: number): number | null {
-  return denominator > 0 ? numerator / denominator : null;
+function ratio(numerator: number | null, denominator: number | null): number | null {
+  return numerator != null && denominator != null && denominator > 0 ? numerator / denominator : null;
 }
 
-function sum(contracts: readonly OptionContract[], field: "volume" | "openInterest"): number {
-  return contracts.reduce((total, contract) => {
+function sum(contracts: readonly OptionContract[], field: "volume" | "openInterest"): number | null {
+  let total = 0;
+  for (const contract of contracts) {
     const value = contract[field];
-    return total + (Number.isFinite(value) && value > 0 ? value : 0);
-  }, 0);
+    if (value == null || !Number.isFinite(value) || value < 0) return null;
+    total += value;
+  }
+  return Number.isFinite(total) ? total : null;
 }
 
 function atmImpliedVolatility(chain: OptionsChain, spot: number | undefined): number | null {
@@ -45,23 +51,53 @@ function atmImpliedVolatility(chain: OptionsChain, spot: number | undefined): nu
   return atTheMoney.reduce((total, value) => total + value, 0) / atTheMoney.length;
 }
 
-/** Annualized standard deviation of the latest 30 daily log returns. */
-export function historicalVolatility30d(points: readonly PricePoint[]): number | null {
-  const closes = points
-    .map((point) => ({
-      close: point.close,
-      time: point.date instanceof Date ? point.date.getTime() : Date.parse(String(point.date)),
-    }))
-    .filter((point) => positive(point.close) && Number.isFinite(point.time))
-    .sort((a, b) => a.time - b.time)
-    .slice(-(HISTORICAL_VOLATILITY_SESSIONS + 1))
-    .map((point) => point.close);
-  if (closes.length < HISTORICAL_VOLATILITY_SESSIONS + 1) return null;
+interface HistoricalVolatilityResult {
+  value: number | null;
+  unavailableReason?: string;
+  integrity?: PriceHistoryIntegrity;
+}
 
-  const returns = closes.slice(1).map((close, index) => Math.log(close / closes[index]!));
+/** Select observations before validating prices; a rejected close must never be bridged. */
+function historicalVolatilityResult(points: readonly PricePoint[]): HistoricalVolatilityResult {
+  const observations = new Map<number, PricePoint>();
+  for (const point of points) {
+    const time = new Date(point.date).getTime();
+    if (!Number.isFinite(time)) {
+      return { value: null, unavailableReason: "HV30 unavailable: invalid history date" };
+    }
+    // Persisted corrections replace the same observation, not an extra return.
+    observations.set(time, point);
+  }
+  const selected = [...observations.entries()]
+    .sort(([a], [b]) => a - b)
+    .slice(-(HISTORICAL_VOLATILITY_SESSIONS + 1))
+    .map(([, point]) => point);
+  const rejected = selected.flatMap((point) => {
+    const integrity = pricePointIntegrity(point);
+    return integrity ? [integrity] : [];
+  });
+  if (rejected.length > 0) {
+    return {
+      value: null,
+      unavailableReason: "HV30 unavailable: inconsistent OHLC history",
+      integrity: mergePriceHistoryIntegrity(...rejected),
+    };
+  }
+  if (selected.some((point) => !positive(point.close))) {
+    return { value: null, unavailableReason: "HV30 unavailable: missing or nonpositive close" };
+  }
+  if (selected.length < HISTORICAL_VOLATILITY_SESSIONS + 1) return { value: null };
+  // Subtract logs instead of taking a ratio that can overflow for finite prices.
+  const logs = selected.map((point) => Math.log(point.close));
+  const returns = logs.slice(1).map((log, index) => log - logs[index]!);
   const mean = returns.reduce((total, value) => total + value, 0) / returns.length;
   const variance = returns.reduce((total, value) => total + (value - mean) ** 2, 0) / (returns.length - 1);
-  return Math.sqrt(variance * TRADING_DAYS_PER_YEAR);
+  return { value: Math.sqrt(variance * TRADING_DAYS_PER_YEAR) };
+}
+
+/** Annualized sample standard deviation of the latest 30 daily log returns. */
+export function historicalVolatility30d(points: readonly PricePoint[]): number | null {
+  return historicalVolatilityResult(points).value;
 }
 
 export function calculateOptionsSummary(
@@ -70,7 +106,8 @@ export function calculateOptionsSummary(
   priceHistory: readonly PricePoint[],
 ): OptionsSummary {
   const atmIv = atmImpliedVolatility(chain, spot);
-  const historicalVolatility = historicalVolatility30d(priceHistory);
+  const historical = historicalVolatilityResult(priceHistory);
+  const historicalVolatility = historical.value;
   const callVolume = sum(chain.calls, "volume");
   const putVolume = sum(chain.puts, "volume");
   const callOpenInterest = sum(chain.calls, "openInterest");
@@ -79,10 +116,12 @@ export function calculateOptionsSummary(
   return {
     atmImpliedVolatility: atmIv,
     historicalVolatility30d: historicalVolatility,
+    ...(historical.unavailableReason ? { historicalVolatilityUnavailableReason: historical.unavailableReason } : {}),
+    ...(historical.integrity ? { historicalVolatilityIntegrity: historical.integrity } : {}),
     impliedHistoricalRatio: atmIv != null && historicalVolatility != null && historicalVolatility > 0
       ? atmIv / historicalVolatility
       : null,
-    expirationVolume: callVolume + putVolume,
+    expirationVolume: callVolume != null && putVolume != null ? callVolume + putVolume : null,
     putCallVolumeRatio: ratio(putVolume, callVolume),
     putCallOpenInterestRatio: ratio(putOpenInterest, callOpenInterest),
   };

package/src/plugins/builtin/options/calc-seed.test.ts

@@ -76,17 +76,21 @@ describe("buildChainCalcParams", () => {
     expect(draftFromParams(params!).daysToExpiry).toBeCloseTo(30 + 2 / 24, 8);
   });
 
-  test("uses the mid when the contract has not traded", () => {
+  test("uses a valid midpoint ahead of an old last trade", () => {
     const params = buildChainCalcParams({
       symbol: "AAPL",
-      row: row({ call: contract({ lastPrice: 0, bid: 7, ask: 8 }) }),
+      row: row({ call: contract({ lastPrice: 12, bid: 7, ask: 8 }) }),
       side: "call",
       spot: 231.5,
       dividendYield: null,
       now: NOW,
     });
 
-    expect(draftFromParams(params!).marketPrice).toBe(7.5);
+    expect(draftFromParams(params!)).toMatchObject({marketPrice: 7.5, marketPriceSource: "mid"});
+    expect(draftFromParams(params!).marketReference).toMatchObject({
+      contractSymbol: "AAPL260919C00230000", expiration: EXPIRATION, bid: 7, ask: 8,
+      lastPrice: 12, lastTradeDate: 0,
+    });
   });
 
   test("returns nothing without a contract or a trustworthy underlying spot", () => {
@@ -116,3 +120,11 @@ describe("buildChainCalcParams", () => {
     })).toBeNull();
   });
 });
+
+test("a crossed or one-sided market never becomes a midpoint", () => {
+  for (const [bid, ask] of [[8, 7], [0, 8], [7, 0], [NaN, 8], [7, Infinity]]) {
+    const params = buildChainCalcParams({symbol: "AAPL", row: row({call: contract({lastPrice: 6, bid, ask})}),
+      side: "call", spot: 230, dividendYield: null, now: NOW});
+    expect(draftFromParams(params!)).toMatchObject({marketPrice: 6, marketPriceSource: "last"});
+  }
+});

package/src/plugins/builtin/options/calc-seed.ts

@@ -1,6 +1,7 @@
 import type { OptionContract } from "../../../types/financials";
 import { buildOptionCalcParams, type OptionSide } from "../options-calculator/model";
 import type { OptionTableRow } from "./types";
+import { optionMarketReference } from "./market-reference";
 
 /**
  * Which contract the calculator should open on. An explicit pick (clicking a
@@ -21,10 +22,16 @@ export function resolveCalcSide(
   return null;
 }
 
-/** Last trade when there is one, otherwise the mid; never a one-sided quote. */
-function contractMarketPrice(contract: OptionContract): number {
-  if (contract.lastPrice > 0) return contract.lastPrice;
-  return contract.bid > 0 && contract.ask > 0 ? (contract.bid + contract.ask) / 2 : 0;
+/** A valid two-sided midpoint is more useful than a potentially old last trade. */
+function contractMarketPrice(contract: OptionContract): { price: number; source?: "mid" | "last" } {
+  if (Number.isFinite(contract.bid) && Number.isFinite(contract.ask)
+    && contract.bid > 0 && contract.ask >= contract.bid) {
+    return { price: (contract.bid + contract.ask) / 2, source: "mid" };
+  }
+  if (Number.isFinite(contract.lastPrice) && contract.lastPrice > 0) {
+    return { price: contract.lastPrice, source: "last" };
+  }
+  return { price: 0 };
 }
 
 export function buildChainCalcParams(options: {
@@ -39,14 +46,19 @@ export function buildChainCalcParams(options: {
   const contract = side === "put" ? row?.put : side === "call" ? row?.call : undefined;
   if (!contract || !(options.spot != null && Number.isFinite(options.spot) && options.spot > 0)) return null;
 
-  return buildOptionCalcParams({
+  const market = contractMarketPrice(contract);
+  const params = buildOptionCalcParams({
     symbol: options.symbol,
     side,
     spot: options.spot,
     strike: contract.strike,
     expiration: contract.expiration,
     volatility: contract.impliedVolatility,
-    marketPrice: contractMarketPrice(contract),
+    marketPrice: market.price,
     dividendYield: options.dividendYield,
   }, options.now);
+  if (market.source) params.marketPriceSource = market.source;
+  const reference = optionMarketReference(contract);
+  if (reference) params.marketReference = JSON.stringify(reference);
+  return params;
 }