gloomberb 0.18.4 → 0.19.0

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

@@ -34,10 +34,12 @@ import type { ResolvedSeries } from "../../../time-series/types";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, Text } from "../../../ui";
 import { formatCompact } from "../../../utils/format";
+import { formatStrikeLabel } from "../../../utils/options";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
 import { isPlainKey } from "../../../utils/keyboard";
 import { nextHeaderSort, type SortDirection } from "../../../utils/sort-values";
 import { useCloudAccessFooter } from "../shared/cloud-upgrade";
+import { COIN_OPTIONS_HINT, isCoinWithoutOptions, optionsUnavailableTitle } from "../../../market-data/options-alternatives";
 import {
   loadGamma,
   loadOpenInterest,
@@ -49,18 +51,23 @@ import {
 } from "./client";
 import {
   ALL_EXPIRIES,
+  axisRatioOfDate,
   chartWindow,
   expiryAxis,
   expiryLabel,
-  formatCount,
+  expiryWithTimeLabel,
+  formatContracts,
+  isCoinContract,
+  settlementTime,
+  wallsByExpiry,
   formatCountChange,
   formatDistance,
   formatGamma,
   formatLevel,
+  gammaTimesFigure,
   positioningSpotDetail,
   formatPayout,
   formatRatio,
-  formatStrike,
   gammaWalls,
   netGammaByExpiry,
   openInterestTotal,
@@ -92,26 +99,30 @@ const expirySize = (row: { callOI: number; putOI: number }) => row.callOI + row.
 const reportedOpenInterest = (row: { callOI: number | null; putOI: number | null }) =>
   (row.callOI == null ? 0 : row.callOI) + (row.putOI == null ? 0 : row.putOI);
 
-function strikeColumns(changes: boolean): DataTableColumn[] {
+function strikeColumns(changes: boolean, unit = ""): DataTableColumn[] {
   return [
     { id: "strike", label: "Strike", width: 9, align: "left" },
-    { id: "callOI", label: "Call OI", width: 10, align: "right" },
+    { id: "callOI", label: `Call OI${unit}`, width: 10 + unit.length, align: "right" },
     ...(changes ? [{ id: "callChange", label: "Call chg", width: 9, align: "right" as const }] : []),
-    { id: "putOI", label: "Put OI", width: 10, align: "right" },
+    { id: "putOI", label: `Put OI${unit}`, width: 10 + unit.length, align: "right" },
     ...(changes ? [{ id: "putChange", label: "Put chg", width: 9, align: "right" as const }] : []),
     { id: "payout", label: "Payout $", width: 10, align: "right" },
   ];
 }
-function expiryColumns(changes: boolean, gamma: boolean): DataTableColumn[] {
+function expiryColumns(changes: boolean, gamma: boolean, options: { settles?: boolean; walls?: boolean; unit?: string } = {}): DataTableColumn[] {
+  const unit = options.unit ?? "";
   return [
-    { id: "date", label: "Expiry", width: 11, align: "left" },
+    // An expiry that settles at a stated time (Deribit's 08:00 UTC) names it.
+    { id: "date", label: "Expiry", width: options.settles ? 21 : 11, align: "left" },
     { id: "days", label: "Days", width: 5, align: "right" },
-    { id: "callOI", label: "Call OI", width: 11, align: "right" },
-    { id: "putOI", label: "Put OI", width: 11, align: "right" },
+    { id: "callOI", label: `Call OI${unit}`, width: 11 + unit.length, align: "right" },
+    { id: "putOI", label: `Put OI${unit}`, width: 11 + unit.length, align: "right" },
     { id: "putCallRatio", label: "P/C", width: 6, align: "right" },
     ...(changes ? [{ id: "change", label: "OI chg", width: 10, align: "right" as const }] : []),
     { id: "maxPain", label: "Max pain", width: 9, align: "right" },
     { id: "distance", label: "Vs spot", width: 8, align: "right" },
+    ...(options.walls ? [{ id: "callWall", label: "Call wall", width: 10, align: "right" as const },
+      { id: "putWall", label: "Put wall", width: 9, align: "right" as const }] : []),
     ...(gamma ? [{ id: "netGamma", label: "Net GEX $", width: 11, align: "right" as const }] : []),
   ];
 }
@@ -151,13 +162,18 @@ interface PositioningChartProps {
 
 /** Columns across a numeric axis (strikes, or expiries one slot apart), with spot and the other levels as guide lines. */
 function PositioningChart(props: PositioningChartProps) {
+  // The legend's values are one column's, under the cursor (the last column's
+  // without one), not the totals the figures above show: it names the column.
+  const column = props.formatCursor(props.selection.cursorDate ? axisRatioOfDate(props.selection.cursorDate) : 1);
+  const legendSeries = useMemo(() => column
+    ? props.series.map((entry) => ({ ...entry, label: `${entry.label} at ${column}` })) : undefined, [column, props.series]);
   const xAxis = useMemo(() => ({
     ticks: props.ticks(Math.max(1, props.width - VALUE_GUTTER)),
     markers: props.markers.flatMap((marker) => marker.ratio != null && marker.ratio >= 0 && marker.ratio <= 1
       ? [{ id: marker.id, xRatio: marker.ratio, label: marker.label, color: marker.color }] : []),
     formatCursor: props.formatCursor,
   }), [props.formatCursor, props.markers, props.ticks, props.width]);
-  return <CompositeChart series={props.series} panels={PANELS} width={props.width} height={props.height}
+  return <CompositeChart series={props.series} legendSeries={legendSeries} panels={PANELS} width={props.width} height={props.height}
     focused={false} navigable={false} showLegend showTimeAxis xAxis={xAxis}
     formatValue={(value) => props.formatValue(value)} formatAxisValue={props.formatAxisValue}
     cursorDate={props.selection.cursorDate} onCursorDateChange={props.selection.onCursorDateChange}
@@ -170,6 +186,8 @@ const UNDERLYING_STATE_KEY = /^opx:(expiry|gammaExpiry|strike|expiryRow|gammaStr
 
 export function OptionsPositioningPane(props: PaneProps) {
   const { symbol } = usePaneTickerIdentity();
+  // A coin nothing lists options on (SOL-USD) says which coins have them, before any request.
+  if (symbol && isCoinWithoutOptions(symbol)) return <EmptyState title={optionsUnavailableTitle(parsePublicTickerKey(symbol).symbol)} hint={COIN_OPTIONS_HINT} />;
   // A new underlying starts over rather than relabelling the last one's data.
   return symbol ? <OptionsPositioningView key={symbol} {...props} symbol={symbol} />
     : <EmptyState title="Choose an option underlying." />;
@@ -205,7 +223,13 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   const openInterest = useAsyncResource<OpenInterestPayload>(openInterestLoader, { keepPreviousData: true });
   const data = openInterest.data;
   const spot = data?.spot ?? null;
-  const spotStamp = useMemo(() => positioningSpotDetail(spot, data?.spotAsOf), [spot, data?.spotAsOf]);
+  const venue = data?.venue;
+  const spotStamp = useMemo(() => positioningSpotDetail(spot, data?.spotAsOf, venue, data?.spotBasis),
+    [spot, data?.spotAsOf, data?.spotBasis, venue]);
+  // A coin's options (Deribit's) count open interest in coins, to tenths.
+  const coin = isCoinContract(data?.contract);
+  const unit = coin ? ` ${data!.contract!.unit}` : "";
+  const count = useCallback((value: number | null | undefined) => formatContracts(value, coin), [coin]);
   const expiries = data?.expiries ?? [];
   const shownExpiry = data?.expiry ?? requestedExpiry;
   const changes = data?.previousOiDate != null;
@@ -276,9 +300,12 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   });
   const info = useMemo<PaneFooterSegment[]>(() => [
     ...(accessSegment ? [accessSegment] : []),
-    ...(data?.oiDate ? [{ id: "oi-date", parts: [{ text: `OI as of ${shortDate(data.oiDate)}`, tone: "muted" as const }] }] : []),
+    ...(venue ? [{ id: "venue", parts: [{ text: venue, tone: "muted" as const }] }] : []),
+    // A venue that publishes open interest live (Deribit) says when it was read.
+    ...(venue && data?.oiAsOf ? [{ id: "oi-date", parts: [{ text: `OI live ${data.oiAsOf.slice(11, 16)} UTC`, tone: "muted" as const }] }]
+      : data?.oiDate ? [{ id: "oi-date", parts: [{ text: `OI as of ${shortDate(data.oiDate)}`, tone: "muted" as const }] }] : []),
     ...(changes && tab !== "gex" ? [{ id: "oi-change", parts: [{ text: `chg since ${shortDate(data!.previousOiDate!)}`, tone: "muted" as const }] }] : []),
-  ], [accessSegment, changes, data?.oiDate, data?.previousOiDate, tab]);
+  ], [accessSegment, changes, data?.oiAsOf, data?.oiDate, data?.previousOiDate, tab, venue]);
   const activeResource = tab === "gex" ? gamma : openInterest;
   // Expiries' Net GEX column loads beside the open interest it sits with.
   const columnGamma = tab === "expiries" && gammaReady ? gamma : null;
@@ -305,7 +332,7 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
         : index === options.findIndex((entry) => entry.value === value) + 1 ? EXPIRY_NEXT_KEY : undefined,
     })),
   });
-  const expiryOptions = useMemo(() => expiries.map((row) => ({ value: row.date, label: expiryLabel(row.date) })), [expiries]);
+  const expiryOptions = useMemo(() => expiries.map((row) => ({ value: row.date, label: expiryWithTimeLabel(row) })), [expiries]);
 
   // ---- Strikes ----
   const strikes = data?.strikes ?? [];
@@ -333,15 +360,17 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   ] : [], [colors.negative, colors.positive, strikeChart, strikeWindow]);
   const callTotal = expiries.find((row) => row.date === shownExpiry);
   const strikeFigures = useMemo<StatItem[]>(() => !callTotal ? [] : [
-    { id: "max-pain", label: "Max pain", value: maxPain == null ? "--" : formatStrike(maxPain), color: colors.warning,
+    { id: "max-pain", label: "Max pain", value: maxPain == null ? "--" : formatStrikeLabel(maxPain), color: colors.warning,
       detail: maxPain == null ? undefined : `${formatDistance(maxPain, spot)} vs spot` },
     { id: "spot", label: "Spot", value: formatLevel(spot), ...spotStamp },
     { id: "pc", label: "P/C OI", value: formatRatio(callTotal.putCallRatio) },
-    { id: "calls", label: "Call OI", value: formatCompact(callTotal.callOI), color: colors.positive,
+    { id: "calls", label: `Call OI${unit}`, value: formatCompact(callTotal.callOI), color: colors.positive,
       detail: callTotal.callChange == null ? undefined : formatCountChange(callTotal.callChange) },
-    { id: "puts", label: "Put OI", value: formatCompact(callTotal.putOI), color: colors.negative,
+    { id: "puts", label: `Put OI${unit}`, value: formatCompact(callTotal.putOI), color: colors.negative,
       detail: callTotal.putChange == null ? undefined : formatCountChange(callTotal.putChange) },
-  ], [callTotal, colors.negative, colors.positive, colors.warning, maxPain, spot, spotStamp]);
+    ...(settlementTime(callTotal.expiresAt) ? [{ id: "settles", label: "Settles", value: settlementTime(callTotal.expiresAt)!,
+      detail: expiryLabel(callTotal.date) }] : []),
+  ], [callTotal, colors.negative, colors.positive, colors.warning, maxPain, spot, spotStamp, unit]);
   const selectedStrikeRow = strikes.find((row) => strikeKey(row) === strikeSelectedId) ?? null;
   const strikeStrip = useMemo<ChartStripSpec | null>(() => strikeWindow.length < 3 ? null : {
     label: "Open interest by strike",
@@ -349,17 +378,17 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
       const value = openInterestTotal(row);
       return value == null ? [] : [value];
     }),
-    value: selectedStrikeRow ? `${formatStrike(selectedStrikeRow.strike)} ${formatCompact(openInterestTotal(selectedStrikeRow) ?? undefined)}` : "",
+    value: selectedStrikeRow ? `${formatStrikeLabel(selectedStrikeRow.strike)} ${formatCompact(openInterestTotal(selectedStrikeRow) ?? undefined)}` : "",
     color: colors.textMuted,
   }, [colors.textMuted, selectedStrikeRow, strikeWindow]);
   const renderStrike = useCallback((row: StrikeOpenInterest, column: DataTableColumn): DataTableCell => {
     switch (column.id) {
       case "strike": return {
-        text: formatStrike(row.strike), value: row.strike,
+        text: formatStrikeLabel(row.strike), value: row.strike,
         color: row.strike === maxPain ? colors.warning : colors.textBright,
       };
-      case "callOI": return { text: formatCount(row.callOI), value: row.callOI, color: colors.positive };
-      case "putOI": return { text: formatCount(row.putOI), value: row.putOI, color: colors.negative };
+      case "callOI": return { text: count(row.callOI), value: row.callOI, color: colors.positive };
+      case "putOI": return { text: count(row.putOI), value: row.putOI, color: colors.negative };
       case "callChange":
       case "putChange": {
         const change = row[column.id];
@@ -369,16 +398,18 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
       case "payout": return { text: formatPayout(row.payout), value: row.payout, color: colors.textMuted };
       default: return { text: "" };
     }
-  }, [colors, maxPain]);
+  }, [colors, count, maxPain]);
 
   // ---- Expiries ----
   // Older servers send no per-expiry gamma; the column then reads --.
   const netGammas = useMemo(() => netGammaByExpiry(gamma.data), [gamma.data]);
+  const expiryWalls = useMemo(() => wallsByExpiry(gamma.data), [gamma.data]);
   const expiryRows = useMemo(() => sortRows(expiries, expirySort, (row, id) =>
     id === "date" ? row.date : id === "distance" ? (row.maxPain == null || spot == null ? null : row.maxPain / spot)
       : id === "change" ? (row.callChange == null ? null : row.callChange + (row.putChange ?? 0))
         : id === "netGamma" ? netGammas?.get(row.date) ?? null
-          : (row[id as keyof ExpiryOpenInterest] as number | null)), [expiries, expirySort, netGammas, spot]);
+          : id === "callWall" || id === "putWall" ? expiryWalls?.get(row.date)?.[id] ?? null
+            : (row[id as keyof ExpiryOpenInterest] as number | null)), [expiries, expiryWalls, expirySort, netGammas, spot]);
   const expiryChart = useMemo(() => expiries.length >= 3 ? expiryAxis(expiryDates) : null, [expiries.length, expiryDates]);
   const expirySelectedId = expiryRows.some((row) => row.date === selectedExpiry) ? selectedExpiry!
     : shownExpiry && expiryRows.some((row) => row.date === shownExpiry) ? shownExpiry : expiryRows[0]?.date ?? null;
@@ -416,17 +447,22 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   }, [colors.textMuted, expiries, selectedExpiryRow]);
   const renderExpiry = useCallback((row: ExpiryOpenInterest, column: DataTableColumn): DataTableCell => {
     switch (column.id) {
-      case "date": return { text: expiryLabel(row.date), value: row.date, color: colors.textBright };
+      case "date": return { text: expiryWithTimeLabel(row), value: row.date, color: colors.textBright };
       case "days": return { text: String(row.days), value: row.days, color: colors.textMuted };
-      case "callOI": return { text: formatCount(row.callOI), value: row.callOI, color: colors.positive };
-      case "putOI": return { text: formatCount(row.putOI), value: row.putOI, color: colors.negative };
+      case "callOI": return { text: count(row.callOI), value: row.callOI, color: colors.positive };
+      case "putOI": return { text: count(row.putOI), value: row.putOI, color: colors.negative };
+      case "callWall":
+      case "putWall": {
+        const strike = expiryWalls?.get(row.date)?.[column.id] ?? null;
+        return { text: strike == null ? "--" : formatStrikeLabel(strike), value: strike, color: colors.textMuted };
+      }
       case "putCallRatio": return { text: formatRatio(row.putCallRatio), value: row.putCallRatio };
       case "change": {
         const change = row.callChange == null ? null : row.callChange + (row.putChange ?? 0);
         return { text: formatCountChange(change), value: change,
           color: change == null || change === 0 ? colors.textMuted : change > 0 ? colors.positive : colors.negative };
       }
-      case "maxPain": return { text: row.maxPain == null ? "--" : formatStrike(row.maxPain), value: row.maxPain, color: colors.warning };
+      case "maxPain": return { text: row.maxPain == null ? "--" : formatStrikeLabel(row.maxPain), value: row.maxPain, color: colors.warning };
       case "distance": return {
         text: formatDistance(row.maxPain, spot),
         value: row.maxPain == null || spot == null ? null : Number(((row.maxPain / spot - 1) * 100).toFixed(4)),
@@ -439,7 +475,7 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
       }
       default: return { text: "" };
     }
-  }, [colors, netGammas, spot]);
+  }, [colors, count, expiryWalls, netGammas, spot]);
 
   // ---- GEX ----
   const gammaData = gamma.data;
@@ -468,19 +504,24 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   const band = gammaData?.band;
   const shares = band ? `${Math.round(band.shareLow * 100)}-${Math.round(band.shareHigh * 100)}%` : "";
   const walls = useMemo(() => gammaWalls(gammaStrikes), [gammaStrikes]);
+  const gammaTimes = useMemo(() => gammaTimesFigure(gammaData?.gammaAsOf, gammaData?.quotesAsOf),
+    [gammaData?.gammaAsOf, gammaData?.quotesAsOf]);
   const gammaFigures = useMemo<StatItem[]>(() => !gammaData?.total ? [] : [
     { id: "net", label: "Net GEX", value: formatGamma(gammaData.total.net), detail: "$ per 1% move",
       color: gammaData.total.net >= 0 ? colors.positive : colors.negative },
     { id: "flip", label: "Flip", value: formatLevel(gammaData.flip),
       detail: gammaData.flip == null ? "none within 15%" : `${formatDistance(gammaData.flip, gammaSpot)} vs spot` },
     ...([["call-wall", "Call wall", walls.callWall], ["put-wall", "Put wall", walls.putWall]] as const).map(([id, label, strike]) => ({
-      id, label, value: strike == null ? "--" : formatStrike(strike),
+      id, label, value: strike == null ? "--" : formatStrikeLabel(strike),
       detail: strike == null ? undefined : `${formatDistance(strike, gammaSpot)} vs spot`,
     })),
     ...(band ? [{ id: "band", label: "Dealer range", value: `${formatGamma(band.low)} to ${formatGamma(band.high)}`,
       detail: `${shares} with dealers${gammaData.boxes?.length ? ", boxes out" : ""}` }] : []),
-    { id: "spot", label: "Spot", value: formatLevel(gammaSpot), ...positioningSpotDetail(gammaSpot, gammaData.spotAsOf) },
-  ], [band, colors.negative, colors.positive, gammaData, gammaSpot, shares, walls]);
+    { id: "spot", label: "Spot", value: formatLevel(gammaSpot),
+      ...positioningSpotDetail(gammaSpot, gammaData.spotAsOf, gammaData.venue, gammaData.spotBasis) },
+    // Gamma is evaluated at the spot's time; before the open its volatilities are the last session's.
+    ...(gammaTimes ? [{ id: "gamma-at", ...gammaTimes }] : []),
+  ], [band, colors.negative, colors.positive, gammaData, gammaSpot, gammaTimes, shares, walls]);
   // The assumption rides in the legend, where the numbers it changes are read; the
   // dealer range figure names its own share. It gives way before the series name does.
   const assumption = width >= 60 ? "dealers long calls, short puts" : width >= 48 ? "long calls, short puts" : null;
@@ -488,12 +529,12 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
   const gammaStrip = useMemo<ChartStripSpec | null>(() => gammaWindow.length < 3 ? null : {
     label: "Net GEX by strike",
     values: gammaWindow.map((row) => row.net),
-    value: selectedGammaRow ? `${formatStrike(selectedGammaRow.strike)} ${formatGamma(selectedGammaRow.net)}` : "",
+    value: selectedGammaRow ? `${formatStrikeLabel(selectedGammaRow.strike)} ${formatGamma(selectedGammaRow.net)}` : "",
     color: colors.textMuted,
   }, [colors.textMuted, gammaWindow, selectedGammaRow]);
   const renderGamma = useCallback((row: GammaStrike, column: DataTableColumn): DataTableCell => {
     switch (column.id) {
-      case "strike": return { text: formatStrike(row.strike), value: row.strike, color: colors.textBright };
+      case "strike": return { text: formatStrikeLabel(row.strike), value: row.strike, color: colors.textBright };
       case "calls": return { text: formatGamma(row.calls), value: row.calls, color: colors.positive };
       case "puts": return { text: formatGamma(-row.puts), value: -row.puts, color: colors.negative };
       case "net": return { text: formatGamma(row.net), value: row.net, color: row.net >= 0 ? colors.positive : colors.negative };
@@ -506,8 +547,10 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
     }
   }, [colors, gammaSpot]);
 
-  const strikeColumnList = useMemo(() => strikeColumns(changes), [changes]);
-  const expiryColumnList = useMemo(() => expiryColumns(changes, hasGamma), [changes, hasGamma]);
+  const strikeColumnList = useMemo(() => strikeColumns(changes, unit), [changes, unit]);
+  const settles = expiries.some((row) => settlementTime(row.expiresAt));
+  const expiryColumnList = useMemo(() => expiryColumns(changes, hasGamma, { settles, walls: !!expiryWalls, unit }),
+    [changes, expiryWalls, hasGamma, settles, unit]);
   const markerColor = colors.textBright;
 
   let content: ReactNode = null;
@@ -532,8 +575,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
               { id: "spot", ratio: spot == null ? null : strikeChart.ratio(spot), label: "spot", color: markerColor },
               { id: "max-pain", ratio: maxPain == null ? null : strikeChart.ratio(maxPain), label: "max pain", color: colors.warning },
             ]}
-            formatCursor={(ratio) => formatStrike(nearestStrike(strikeWindow, strikeChart.at(ratio)))}
-            formatValue={(value) => formatCount(Math.abs(value))}
+            formatCursor={(ratio) => formatStrikeLabel(nearestStrike(strikeWindow, strikeChart.at(ratio)))}
+            formatValue={(value) => count(Math.abs(value))}
             formatAxisValue={(value, domain) => formatCompactAxis(Math.abs(value), domain)}
             selection={strikeSelection} remoteKind="opx-strikes" />,
           minRows: CHART_MIN_ROWS,
@@ -550,7 +593,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
       onHeaderClick={(id) => setExpirySort((current) => nextHeaderSort(current, id))}
       emptyStateTitle="No listed expiries."
       getExportMetadata={() => [["open interest as of", data?.oiDate ?? ""], ["change since", data?.previousOiDate ?? ""], ["spot", spot ?? ""],
-        ...(hasGamma ? [["net GEX unit", "dollars of dealer delta per 1% move"], ["quotes as of", netGammas ? gamma.data?.quotesAsOf ?? "" : ""]] : [])]}
+        ...(hasGamma ? [["net GEX unit", "dollars of dealer delta per 1% move"], ["gamma at", netGammas ? gamma.data?.gammaAsOf ?? "" : ""],
+          ["vols from", netGammas ? gamma.data?.quotesAsOf ?? "" : ""]] : [])]}
       rootBefore={<ChartTableHeader width={width} height={bodyHeight} figures={ladderFigures}
         tableRows={expiryRows.length} tableChromeRows={chartTableChromeRows(expiryColumnList, width)}
         chart={expiryChart ? {
@@ -560,7 +604,7 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
               const date = expiryChart.at(ratio);
               return date ? expiryLabel(date) : "";
             }}
-            formatValue={(value) => formatCount(Math.abs(value))}
+            formatValue={(value) => count(Math.abs(value))}
             formatAxisValue={(value, domain) => formatCompactAxis(Math.abs(value), domain)}
             selection={expirySelection} remoteKind="opx-expiries" />,
           minRows: CHART_MIN_ROWS - 1,
@@ -589,7 +633,8 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
                 ["range with boxes high", gammaData.bandWithBoxes.high],
                 ["box legs left out", (gammaData.boxes ?? []).map((leg) => `${leg.expiry} ${leg.strike} x${leg.contracts}`).join("; ")]] : []),
               ["flip", gammaData.flip ?? ""], ["call wall", walls.callWall ?? ""], ["put wall", walls.putWall ?? ""],
-              ["open interest as of", gammaData.oiDate ?? ""], ["quotes as of", gammaData.quotesAsOf ?? ""]]}
+              ["open interest as of", gammaData.oiDate ?? ""], ["gamma at", gammaData.gammaAsOf ?? ""],
+              ["vols from", gammaData.quotesAsOf ?? ""]]}
             rootBefore={<ChartTableHeader width={width} height={bodyHeight} query={query} figures={gammaFigures}
               tableRows={gammaRows.length} tableChromeRows={chartTableChromeRows(GAMMA_COLUMNS, width)}
               chart={gammaChart ? {
@@ -599,7 +644,7 @@ function OptionsPositioningView({ width, height, focused, symbol }: PaneProps &
                     { id: "spot", ratio: gammaSpot == null ? null : gammaChart.ratio(gammaSpot), label: "spot", color: markerColor },
                     { id: "flip", ratio: gammaData.flip == null ? null : gammaChart.ratio(gammaData.flip), label: "flip", color: colors.warning },
                   ]}
-                  formatCursor={(ratio) => formatStrike(nearestStrike(gammaWindow, gammaChart.at(ratio)))}
+                  formatCursor={(ratio) => formatStrikeLabel(nearestStrike(gammaWindow, gammaChart.at(ratio)))}
                   formatValue={formatGamma} formatAxisValue={formatCompactAxis}
                   legendAccessory={assumption ? <Text fg={colors.textMuted}>{assumption}</Text> : undefined}
                   legendAccessoryWidth={assumption?.length}

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

@@ -384,11 +384,52 @@ export const SCENARIO_STRATEGIES = ["vertical", "straddle", "put", "csp", "colla
 type ScenarioStrategy = typeof SCENARIO_STRATEGIES[number];
 const isScenarioStrategy = (value: unknown): value is ScenarioStrategy => SCENARIO_STRATEGIES.includes(value as ScenarioStrategy);
 
-interface StrategyPricing { spot: number; asOf: number; rate: number; dividendYield: number }
+export interface StrategyPricing { spot: number; asOf: number; rate: number; dividendYield: number }
 
 const usableVolatility = (value: unknown): value is number => positive(value) && value <= 5;
 
-interface StrategyParity { forward: number; daysToExpiry: number }
+export interface StrategyParity { forward: number; daysToExpiry: number }
+
+/**
+ * The contracts a strategy seed picks from: every two-sided quote with the IV
+ * its midpoint implies against its expiry's parity forward (or a usable
+ * provider IV), each side nearest `spot` first. `parityFor` is the forward an
+ * expiry's IVs were solved on, null without a rate to solve them by.
+ */
+export interface QuotedChain {
+  calls: QuotedContract[];
+  puts: QuotedContract[];
+  parityFor(expiration: number): StrategyParity | null;
+}
+
+/** The quoted chain every seed reads, as `scenarioStrategyLegs` describes it. */
+function quoteStrategyChain(chain: OptionsChain, spot: number, pricing: StrategyPricing | null): QuotedChain {
+  const parity = new Map<number, StrategyParity | null>();
+  const parityFor = (expiration: number) => {
+    if (!pricing) return null;
+    if (!parity.has(expiration)) {
+      const daysToExpiry = daysToExpiryFrom(expiration, pricing.asOf);
+      const { forward } = extractImpliedForward(chain.calls.filter((call) => call.expiration === expiration),
+        chain.puts.filter((put) => put.expiration === expiration), pricing.spot, daysToExpiry / 365, pricing.rate,
+        chain.underlyingSymbol);
+      parity.set(expiration, forward == null ? null : { forward, daysToExpiry });
+    }
+    return parity.get(expiration)!;
+  };
+  const quoted = (contracts: OptionsChain["calls"], side: ScenarioLeg["side"]) => contracts.flatMap((contract): QuotedContract[] => {
+    const mid = optionMid(contract);
+    if (!positive(contract.strike) || mid == null) return [];
+    const expiry = parityFor(contract.expiration);
+    // q=r turns the spot pricer into discounted forward pricing.
+    const volatility = expiry ? solveImpliedVolatility({ side, spot: expiry.forward, strike: contract.strike,
+      daysToExpiry: expiry.daysToExpiry, rate: pricing!.rate, dividendYield: pricing!.rate }, mid).volatility : null;
+    if (usableVolatility(volatility)) return [{ contract, side, mid, volatility, solved: true }];
+    return usableVolatility(contract.impliedVolatility) ? [{ contract, side, mid, volatility: contract.impliedVolatility, solved: false }] : [];
+  });
+  const nearest = (a: { contract: { strike: number } }, b: { contract: { strike: number } }) =>
+    Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot);
+  return { calls: quoted(chain.calls, "call").sort(nearest), puts: quoted(chain.puts, "put").sort(nearest), parityFor };
+}
 
 /**
  * An explicit strategy request uses only two-sided quotes and enters each leg
@@ -418,33 +459,8 @@ function scenarioStrategyLegs(
   chain: OptionsChain, spot: number, strategy: ScenarioStrategy, pricing: StrategyPricing | null, strike?: number,
   collar: { put?: number; call?: number } = {}, delta?: number, unusable: UnusableChainText = defaultUnusableChainText,
 ): { legs: ScenarioLeg[]; parity: StrategyParity | null } {
-  const parity = new Map<number, StrategyParity | null>();
-  const parityFor = (expiration: number) => {
-    if (!pricing) return null;
-    if (!parity.has(expiration)) {
-      const daysToExpiry = daysToExpiryFrom(expiration, pricing.asOf);
-      const { forward } = extractImpliedForward(chain.calls.filter((call) => call.expiration === expiration),
-        chain.puts.filter((put) => put.expiration === expiration), pricing.spot, daysToExpiry / 365, pricing.rate,
-        chain.underlyingSymbol);
-      parity.set(expiration, forward == null ? null : { forward, daysToExpiry });
-    }
-    return parity.get(expiration)!;
-  };
-  const quoted = (contracts: OptionsChain["calls"], side: ScenarioLeg["side"]) => contracts.flatMap((contract) => {
-    const mid = optionMid(contract);
-    if (!positive(contract.strike) || mid == null) return [];
-    const expiry = parityFor(contract.expiration);
-    // q=r turns the spot pricer into discounted forward pricing.
-    const volatility = expiry ? solveImpliedVolatility({ side, spot: expiry.forward, strike: contract.strike,
-      daysToExpiry: expiry.daysToExpiry, rate: pricing!.rate, dividendYield: pricing!.rate }, mid).volatility : null;
-    if (usableVolatility(volatility)) return [{ contract, mid, volatility, solved: true }];
-    return usableVolatility(contract.impliedVolatility) ? [{ contract, mid, volatility: contract.impliedVolatility, solved: false }] : [];
-  });
-  const nearest = (a: { contract: { strike: number } }, b: { contract: { strike: number } }) =>
-    Math.abs(a.contract.strike - spot) - Math.abs(b.contract.strike - spot);
+  const { calls, puts, parityFor } = quoteStrategyChain(chain, spot, pricing);
   const anchored = ({ contract }: { contract: { strike: number } }) => strike == null || Math.abs(contract.strike - strike) < 1e-9;
-  const calls = quoted(chain.calls, "call").sort(nearest);
-  const puts = quoted(chain.puts, "put").sort(nearest);
   const missing = (candidates: { contract: { strike: number } }[], at = strike, what: string = strategy === "csp" ? "put to sell" : strategy) => {
     if (at == null) return new Error(unusable("strategy"));
     const listed = [...new Set(candidates.map(({ contract }) => contract.strike))]
@@ -455,7 +471,7 @@ function scenarioStrategyLegs(
   };
   if (strategy === "collar") return collarLegs(calls, puts, spot, collar, missing, parityFor, unusable);
   if (strategy === "put" || strategy === "csp") {
-    const put = delta == null ? puts.find(anchored) : nearestDelta(puts, -delta, spot, pricing, parityFor);
+    const put = delta == null ? puts.find(anchored) : nearestDeltaContract(puts, -delta, spot, pricing, parityFor);
     if (!put) throw missing(puts);
     return { legs: [{ id: put.contract.contractSymbol, side: "put", quantity: strategy === "csp" ? -1 : 1, strike: put.contract.strike,
       expiration: put.contract.expiration, price: put.mid, priceSource: "mid", volatility: put.volatility, multiplier: 100,
@@ -480,10 +496,10 @@ function scenarioStrategyLegs(
   return { legs, parity: first.solved || second.solved ? parityFor(first.contract.expiration) : null };
 }
 
-interface QuotedContract { contract: OptionsChain["calls"][number]; mid: number; volatility: number; solved: boolean }
+export interface QuotedContract { contract: OptionsChain["calls"][number]; side: ScenarioLeg["side"]; mid: number; volatility: number; solved: boolean }
 
 /** Why a chain seeds nothing: `what` it has no usable quote for, then the next live expiry to try unless `next` is false. */
-type UnusableChainText = (what: string, next?: boolean) => string;
+export type UnusableChainText = (what: string, next?: boolean) => string;
 const defaultUnusableChainText: UnusableChainText = (what) => `The selected chain has no complete quoted ${what} with usable IV`;
 
 /**
@@ -502,38 +518,91 @@ function unusableChainText(market: ScenarioMarketSnapshot, exchange: string | un
 }
 
 /**
- * A put's spot delta at the IV it trades at: against the parity forward its
- * IV was solved on when it was (forward delta, carried to spot), else at the
- * seed's spot. Null when it cannot be valued.
+ * An option's spot delta at the IV it trades at: against the parity forward
+ * its IV was solved on when it was (forward delta, carried to spot), else at
+ * the seed's spot. Null when it cannot be valued.
  */
-function quotedPutDelta(quoted: QuotedContract, spot: number, pricing: StrategyPricing | null, parity: StrategyParity | null): number | null {
-  const { contract, volatility, solved } = quoted;
+function quotedDelta(quoted: QuotedContract, spot: number, pricing: StrategyPricing | null, parity: StrategyParity | null): number | null {
+  const { contract, side, volatility, solved } = quoted;
   if (!pricing) return null;
   if (solved && parity) {
     // On the forward, with the dividend yield set to the rate so it carries no drift, as the IV was solved.
-    const forwardDelta = valueOption({ side: "put", spot: parity.forward, strike: contract.strike, daysToExpiry: parity.daysToExpiry,
+    const forwardDelta = valueOption({ side, spot: parity.forward, strike: contract.strike, daysToExpiry: parity.daysToExpiry,
       rate: pricing.rate, dividendYield: pricing.rate, volatility }).delta;
     return Number.isFinite(forwardDelta) ? forwardDelta * Math.exp((pricing.rate - pricing.dividendYield) * parity.daysToExpiry / 365) : null;
   }
   const years = daysToExpiryFrom(contract.expiration, pricing.asOf) / 365;
-  return optionDelta({ spot, years, volatility, rate: pricing.rate, dividendYield: pricing.dividendYield }, contract.strike, "put");
+  return optionDelta({ spot, years, volatility, rate: pricing.rate, dividendYield: pricing.dividendYield }, contract.strike, side);
 }
 
-/** The put whose delta is nearest `target` (negative, as a put's delta reads), the lower strike on a tie; null when none can be valued. */
-function nearestDelta(
-  puts: readonly QuotedContract[], target: number, spot: number, pricing: StrategyPricing | null,
+/**
+ * The contract whose delta is nearest `target` (negative for a put, as its
+ * delta reads), the one further out of the money on a tie (the lower strike
+ * of two puts, the higher of two calls); null when none can be valued.
+ */
+export function nearestDeltaContract(
+  candidates: readonly QuotedContract[], target: number, spot: number, pricing: StrategyPricing | null,
   parityFor: (expiration: number) => StrategyParity | null,
 ): QuotedContract | null {
-  let best: { put: QuotedContract; distance: number } | null = null;
-  for (const put of puts) {
-    const delta = quotedPutDelta(put, spot, pricing, put.solved ? parityFor(put.contract.expiration) : null);
+  let best: { quoted: QuotedContract; distance: number } | null = null;
+  for (const quoted of candidates) {
+    const delta = quotedDelta(quoted, spot, pricing, quoted.solved ? parityFor(quoted.contract.expiration) : null);
     if (delta == null) continue;
     const distance = Math.abs(delta - target);
-    if (!best || distance < best.distance - 1e-12 || (Math.abs(distance - best.distance) <= 1e-12 && put.contract.strike < best.put.contract.strike)) {
-      best = { put, distance };
+    const further = quoted.side === "put" ? quoted.contract.strike < (best?.quoted.contract.strike ?? Infinity)
+      : quoted.contract.strike > (best?.quoted.contract.strike ?? -Infinity);
+    if (!best || distance < best.distance - 1e-12 || (Math.abs(distance - best.distance) <= 1e-12 && further)) {
+      best = { quoted, distance };
     }
   }
-  return best?.put ?? null;
+  return best?.quoted ?? null;
+}
+
+/** A seeded leg: `quantity` contracts of a quoted option, entered at its midpoint with the IV that midpoint implies, as every seed enters it. */
+export function seededLeg({ contract, side, mid, volatility, solved }: QuotedContract, quantity: number): ScenarioLeg {
+  return { id: contract.contractSymbol, side, quantity, strike: contract.strike, expiration: contract.expiration, price: mid,
+    priceSource: "mid", volatility, multiplier: 100, ...(solved ? { volatilitySource: "mid" as const } : {}) };
+}
+
+/** What a strategy screen picks from a quoted chain: its legs, and the shares it holds with them (a covered call's). */
+export interface ScreenSeed { legs: ScenarioLeg[]; shares?: number }
+
+/**
+ * A position a strategy screen seeds as OSA seeds `--strategy`: legs picked
+ * from the market's chain (or `merged`, a calendar's two expiries together) at
+ * their quote midpoints, valued at the market's rate and dividend yield from
+ * the spot the first expiry's parity forward implies when a leg's IV was solved
+ * against it. Shares are bought at that spot. `pick` reads the quoted chain
+ * with its pricing, so a leg can be chosen by delta.
+ */
+export function seedScreenPosition(
+  market: ScenarioMarketSnapshot,
+  pick: (quoted: QuotedChain, pricing: StrategyPricing, unusable: UnusableChainText) => ScreenSeed,
+  merged?: OptionsChain,
+): ScenarioPosition {
+  if (!market.chain || market.warnings.includes("Options chain is stale")) {
+    throw new Error(market.missingExpiry ?? "A current options chain is required to seed a strategy");
+  }
+  const chain = merged ?? market.chain;
+  if (market.spot == null) throw new Error("A current underlying price is required");
+  if (market.rate == null) throw new Error("Choosing legs by delta needs the Treasury rate");
+  if (market.dividendYield == null) throw new Error("Dividend yield unavailable");
+  const pricing = { spot: market.spot, asOf: market.asOf, rate: market.rate, dividendYield: market.dividendYield };
+  const quoted = quoteStrategyChain(chain, market.spot, pricing);
+  const { legs, shares } = pick(quoted, pricing, unusableChainText(market, market.exchange));
+  const first = Math.min(...legs.map((leg) => leg.expiration));
+  const parity = legs.some((leg) => leg.expiration === first && leg.volatilitySource === "mid") ? quoted.parityFor(first) : null;
+  const spot = parity ? parity.forward * Math.exp(-(pricing.rate - pricing.dividendYield) * parity.daysToExpiry / 365) : market.spot;
+  const position: ScenarioPosition = {
+    symbol: market.symbol, exchange: market.exchange, currency: scenarioCurrency(undefined, market.currency, market.exchange),
+    spot, rate: pricing.rate, dividendYield: pricing.dividendYield, asOf: market.asOf, legs,
+    ...(shares ? { underlying: { quantity: shares, price: spot } } : {}),
+  };
+  const error = validatePosition(position);
+  if (error) throw new Error(error);
+  const contracts = [...chain.calls, ...chain.puts].filter((contract) => legs.some((leg) => leg.id === contract.contractSymbol));
+  if (contracts.some((contract) => contract.currency && contract.currency !== position.currency)) throw new Error("Strategy currency differs from the underlying quote currency");
+  return position;
 }
 
 /** How far out of the money a collar's put and call sit when their strikes are not given. */