@gloom-sh/terminal 0.18.5 → 0.19.0

package/src/plugins/builtin/openfda/pane.tsx

@@ -23,6 +23,7 @@ import {
 } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import {
+  useAssetData,
   useDebouncedPluginPaneState,
   usePaneSettingValue,
   usePaneTitle,
@@ -34,6 +35,7 @@ import type { PaneProps } from "../../../types/plugin";
 import { Box, type ScrollBoxRenderable } from "../../../ui";
 import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { toneColor, withoutQuietColumns } from "../shared/research-cells";
+import { looksLikeTicker, useTickerCompanySearch } from "../shared/ticker-company";
 import { OpenFdaClient, parseOpenFdaDate } from "./client";
 import {
   activeFilters,
@@ -41,6 +43,7 @@ import {
   FILTER_DEFAULT,
   recordColumns,
   recordTone,
+  termsCellText,
   type ColumnId,
   type FilterKey,
   type FilterState,
@@ -75,6 +78,16 @@ const formatDate = (date: Date | null): string => (date ? date.toISOString().sli
 
 const capitalize = (text: string): string => text.charAt(0).toUpperCase() + text.slice(1);
 
+/** A search written as a ticker is, in capitals (`AZN`, `BRK.B`); `cat` or `azn` is a word to search for. */
+const writtenAsTicker = (term: string): boolean => looksLikeTicker(term) && term === term.toUpperCase();
+
+/** What a search that matched nothing points to, by what each dataset is searched on. */
+const EMPTY_SEARCH_HINTS: Record<OpenFdaDataset, string> = {
+  drug: "Try the drug's brand or generic name…",
+  device: "Try the device or manufacturer name…",
+  recall: "Try the firm or product name…",
+};
+
 /** A generic's record lists every labeler; the cell counts them instead of naming one. */
 function labelerText(record: DrugReport): string | null {
   if (record.manufacturer) return record.manufacturer;
@@ -95,13 +108,19 @@ function cellFor(record: OpenFdaRecord, column: ColumnId, colors: ThemeColors):
         return text ? { text, color: record.manufacturer ? colors.text : colors.textMuted } : missing;
       }
       if (column === "role") return toned(record.role ? capitalize(record.role) : null);
-      if (column === "reactions") return record.reactions.length > 0 ? { text: record.reactions.join(", "), color: colors.text } : missing;
+      // The row names the first few; its export, like the record, keeps every one.
+      if (column === "reactions") {
+        return record.reactions.length > 0 ? { text: termsCellText(record.reactions), value: record.reactions.join(", "), color: colors.text } : missing;
+      }
       if (column === "outcome") return toned(record.outcome);
       break;
     case "device":
       if (column === "product") return { text: record.product, color: colors.textBright };
       if (column === "manufacturer") return record.manufacturer ? { text: record.manufacturer, color: colors.text } : missing;
-      if (column === "problems") return record.productProblems.length > 0 ? { text: record.productProblems.join(", "), color: colors.text } : missing;
+      if (column === "problems") {
+        return record.productProblems.length > 0
+          ? { text: termsCellText(record.productProblems), value: record.productProblems.join(", "), color: colors.text } : missing;
+      }
       if (column === "event") return toned(record.eventType);
       break;
     case "recall":
@@ -201,6 +220,7 @@ const isDataset = (value: unknown): value is OpenFdaDataset => DATASETS.some((en
 
 export function OpenFdaPane({ width, height, focused }: PaneProps) {
   const client = useMemo(() => new OpenFdaClient(), []);
+  const dataProvider = useAssetData();
   const [storedQuery] = usePaneSettingValue("query", "");
   const initialQuery = String(storedQuery ?? "").trim();
   const [query, setQuery] = usePluginPaneState("query", initialQuery);
@@ -278,9 +298,25 @@ export function OpenFdaPane({ width, height, focused }: PaneProps) {
     setOpenItemId(null);
   }, [setFilterState, setOpenItemId, setSelectedId]);
 
-  const loading = records.loading && rows.length === 0;
-  const error = records.error?.message ?? null;
-  usePaneRefreshKey(records.reload, { focused, enabled: !searchFocused && !openItemId });
+  // `FDA AZN`: FDA records name the firm and its products, never a symbol, so a
+  // ticker that finds nothing is searched as its company's name (AstraZeneca),
+  // as TRIAL reads one, and the search box then shows it. Only a term written in
+  // capitals, as a ticker is (the search box or `fn FDA AZN`): a word such as
+  // "cat" stays the search it is. Each term is looked up once.
+  const companySearch = useTickerCompanySearch(dataProvider, term, {
+    eligible: records.status === "loaded" && rows.length === 0 && !records.error && writtenAsTicker(term),
+    key: term,
+    onCompany: updateQuery,
+  });
+  const retryCompanySearch = companySearch.retry;
+
+  const loading = (records.loading && rows.length === 0) || companySearch.resolving;
+  const error = records.error?.message ?? companySearch.error;
+  const reload = useCallback(() => {
+    retryCompanySearch();
+    records.reload();
+  }, [records, retryCompanySearch]);
+  usePaneRefreshKey(reload, { focused, enabled: !searchFocused && !openItemId });
 
   const linkRecord = openRecord ?? selected;
   const info = useMemo<PaneFooterSegment[]>(() => [
@@ -420,7 +456,7 @@ export function OpenFdaPane({ width, height, focused }: PaneProps) {
       resetScrollKey={`${dataset}:${term}:${filtersKey}`}
       selectedTextOverridesCellColor
       emptyStateTitle={term ? `No ${datasetLabel.toLowerCase()} match ${term}.` : `No ${datasetLabel.toLowerCase()}.`}
-      emptyStateHint="Press / to search…"
+      emptyStateHint={term ? EMPTY_SEARCH_HINTS[dataset] : "Press / to search…"}
     />
   );
 }

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

@@ -51,8 +51,26 @@ export interface ChainVolatilities {
   /** Valuation instant the volatilities were solved at, reused for the Greeks. */
   valuationTime: number;
   byStrike: ReadonlyMap<number, number>;
+  /**
+   * Strikes in `byStrike` whose volatility was not solved: with no two-sided
+   * out-of-the-money quote to solve from, it is read off the neighbouring solved
+   * strikes (flat beyond the last of them). Shown marked, never as a solved figure.
+   */
+  filled: ReadonlySet<number>;
 }
 
+/**
+ * How a chain's IV is solved, said under the chain in a report and in the pane's
+ * footer while a strike's IV is filled: marked "~", it is read off the
+ * neighbouring solved strikes, not solved from a quote.
+ */
+export const IV_FILLED_NOTE = "~ IV filled from neighbouring strikes";
+export const IV_FILLED_SHORT = "~ IV filled";
+export const IV_FILLED_DETAIL = "Each strike's IV is solved from the midpoint of its out-of-the-money option. A strike with no two-sided quote there "
+  + "has its IV read off the nearest solved strikes, flat beyond the last one, and its cell leads with ~.";
+/** The report's line on how IV was solved, with what "~" marks when a strike is filled. */
+export const ivSolvedNote = (anyFilled: boolean) => `IV solved from quote mids${anyFilled ? ", ~ filled from neighbouring strikes" : ""}`;
+
 function tightestQuotes(contracts: readonly OptionContract[], expiration: number): Map<number, OptionContract> {
   const quotes = new Map<number, OptionContract>();
   for (const contract of contracts) {
@@ -78,6 +96,7 @@ export function solveChainVolatilities(
 ): ChainVolatilities {
   const valuationTime = optionQuoteValuationTime(chain, now);
   const byStrike = new Map<number, number>();
+  const filled = new Set<number>();
   // A venue that marks every contract (Deribit) states its volatility: the out-of-the-money side's at each strike.
   if ([...chain.calls, ...chain.puts].some((contract) => contract.mark)) {
     for (const [side, contracts] of [["call", chain.calls], ["put", chain.puts]] as const) {
@@ -88,9 +107,9 @@ export function solveChainVolatilities(
         if (outOfTheMoney || !byStrike.has(contract.strike)) byStrike.set(contract.strike, mark.iv);
       }
     }
-    return { valuationTime, byStrike };
+    return { valuationTime, byStrike, filled };
   }
-  if (!positive(spot)) return { valuationTime, byStrike };
+  if (!positive(spot)) return { valuationTime, byStrike, filled };
   const rate = optionChainRate(chain);
   const carry = Number.isFinite(dividendYield) ? dividendYield! : 0;
   const expirations = new Set([...chain.calls, ...chain.puts].map((contract) => contract.expiration));
@@ -115,7 +134,8 @@ export function solveChainVolatilities(
       ? solve("call", calls.get(strike)) : solve("put", puts.get(strike)));
     // Without a two-sided out-of-the-money quote a strike's time value sits inside
     // the tick, and the in-the-money quote is intrinsic plus spread noise. Read its
-    // volatility off the neighbouring solved strikes so delta stays monotonic.
+    // volatility off the neighbouring solved strikes so delta stays monotonic, and
+    // say it was filled: it is no market's volatility.
     strikes.forEach((strike, index) => {
       let volatility = solved[index];
       if (volatility == null) {
@@ -128,10 +148,14 @@ export function solveChainVolatilities(
           ? low + (high - low) * (strike - strikes[below]!) / (strikes[above]! - strikes[below]!)
           : low ?? high;
       }
-      if (volatility != null) byStrike.set(strike, volatility);
+      if (volatility != null) {
+        byStrike.set(strike, volatility);
+        if (solved[index] == null) filled.add(strike);
+        else filled.delete(strike);
+      }
     });
   }
-  return { valuationTime, byStrike };
+  return { valuationTime, byStrike, filled };
 }
 
 function atmImpliedVolatility(volatilities: ChainVolatilities, spot: number | undefined): number | null {

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

@@ -1,4 +1,5 @@
 import { useEffect, useMemo, useRef, useState } from "react";
+import { createTtlCache, type TtlCache } from "../../../data/ttl-cache";
 import type { InstrumentRef } from "../../../market-data/request-types";
 import type { QueryEntry } from "../../../market-data/result-types";
 import { buildOptionsKey, resolveEntryData } from "../../../market-data/selectors";
@@ -15,6 +16,17 @@ const OPTIONS_LIVE_ANALYTICS_INTERVAL_MS = 1_000;
 const LIVE_ANALYTICS_MAX_LOAD = 0.05;
 /** The Treasury curve is daily; a refreshed chain reuses the one it already loaded. */
 const TREASURY_REUSE_MS = 30 * 60_000;
+const TREASURY_CURVE = "treasury";
+
+interface Selection {
+  key: string | null;
+  cache: OptionsEnrichmentCache;
+  curve: TtlCache<YieldPoint[]>;
+}
+
+const newSelection = (key: string | null): Selection => ({
+  key, cache: {}, curve: createTtlCache<YieldPoint[]>({ ttlMs: TREASURY_REUSE_MS }),
+});
 
 interface EnrichmentResult {
   key: string;
@@ -59,9 +71,9 @@ export function useOptionsEnrichment(input: {
   const current = useRef(input);
   current.current = input;
   // Per selection: the adjacent model and the Treasury curve outlive a chain refresh.
-  const store = useRef<{ key: string | null; cache: OptionsEnrichmentCache; curve: { value: YieldPoint[]; at: number } | null }>(
-    { key: null, cache: {}, curve: null });
-  if (store.current.key !== key) store.current = { key, cache: {}, curve: null };
+  const [first] = useState(() => newSelection(key));
+  const store = useRef(first);
+  if (store.current.key !== key) store.current = newSelection(key);
   const [result, setResult] = useState<EnrichmentResult | null>(null);
   const resultRef = useRef(result);
   resultRef.current = result;
@@ -71,7 +83,7 @@ export function useOptionsEnrichment(input: {
     const request = current.current;
     const identity = { key, entryKey, catalogueKey };
     const selection = store.current;
-    const curve = selection.curve && Date.now() - selection.curve.at < TREASURY_REUSE_MS ? selection.curve.value : undefined;
+    const curve = selection.curve.peek(TREASURY_CURVE);
     let projection: OptionsEnrichmentProjection | null = null;
     // A refresh of the same expiry swaps in its analytics complete, never
     // through a partial projection that would blank the strip for a moment.
@@ -93,7 +105,7 @@ export function useOptionsEnrichment(input: {
     }).then((snapshot) => {
       if (controller.signal.aborted) return;
       if (projection && !projection.curveLoading && !projection.treasuryError && projection.curve?.length && !curve) {
-        selection.curve = { value: [...projection.curve], at: Date.now() };
+        selection.curve.set(TREASURY_CURVE, [...projection.curve]);
       }
       setResult({ ...identity, loading: false, carried: false, snapshot, projection, error: null });
     }).catch((error: unknown) => {

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

@@ -163,10 +163,13 @@ export function findNearestStrikeIndex(strikes: number[], targetStrike: number):
   return bestIndex;
 }
 
-export function formatIv(value: number | undefined): string {
+export function formatIv(value: number | undefined, filled = false): string {
   // Providers send 0 for contracts with no implied volatility; "0.0%" would read
   // as a real quote of zero vol.
   if (value == null || !Number.isFinite(value) || value <= 0) return "\u2014";
+  // A filled figure leads with "~": it was read off the neighbouring strikes, not solved from a quote.
+  // Without the decimal it still fits the column at 100% and over.
+  if (filled) return value >= 0.9995 ? `~${Math.round(value * 100)}%` : `~${(value * 100).toFixed(1)}%`;
   return `${(value * 100).toFixed(1)}%`;
 }
 
@@ -305,7 +308,7 @@ function formatOptionContractCell(
     case "openInterest":
       return formatCompact(contract.openInterest, { fixedDecimals: true });
     case "iv":
-      return formatIv(row.impliedVolatility);
+      return formatIv(row.impliedVolatility, row.impliedVolatilityFilled);
     case "delta":
       return formatGreek(greeks?.delta);
     case "gamma":

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

@@ -32,6 +32,8 @@ export interface OptionTableRow {
   put?: OptionContract;
   /** Solved from quote midpoints; the call and put at a strike share it. */
   impliedVolatility?: number;
+  /** `impliedVolatility` was filled from neighbouring strikes, not solved from a quote (see `ChainVolatilities.filled`). */
+  impliedVolatilityFilled?: boolean;
   callGreeks?: OptionValuation;
   putGreeks?: OptionValuation;
   /** Time value as a share of spot per year (see `carry.ts`); null when it cannot be read. */

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

@@ -44,7 +44,7 @@ import type { OptionContract } from "../../../types/financials";
 import { OPTIONS_CALCULATOR_TEMPLATE_ID } from "../options-calculator/model";
 import { buildChainCalcParams, resolveCalcSide } from "./calc-seed";
 import { useOptionsCatalogue } from "./expiry-catalogue";
-import { calculateOptionGreeks, calculateOptionsSummary, solveChainVolatilities, type OptionsSummary } from "./analytics";
+import { calculateOptionGreeks, calculateOptionsSummary, IV_FILLED_DETAIL, IV_FILLED_NOTE, IV_FILLED_SHORT, solveChainVolatilities, type OptionsSummary } from "./analytics";
 import {
   DEFAULT_OPTION_FIELD_IDS,
   buildStrikeList,
@@ -578,6 +578,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
       call,
       put,
       impliedVolatility: volatilities?.byStrike.get(strike),
+      impliedVolatilityFilled: volatilities?.filled.has(strike) ?? false,
       callGreeks: volatilities ? calculateOptionGreeks(call, "call", greeksSpot, dividendYield, volatilities) : undefined,
       putGreeks: volatilities ? calculateOptionGreeks(put, "put", greeksSpot, dividendYield, volatilities) : undefined,
       callExtrinsicPerYear: call && volatilities ? optionCarry(call, "call", greeksSpot, volatilities.valuationTime)?.extrinsicPerYear ?? null : null,
@@ -622,9 +623,21 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     + `${new Date(footerSpot.observedAt).toISOString().slice(11, 16)} UTC` : null,
   strikeChain && !listedOpenInterest.loading ? openInterestAsOf?.date ? `OI ${openInterestAsOf.date.slice(5)}` : "OI undated" : null]
     .filter(Boolean).join(" · ");
-  usePaneFooter("options-basis", () => ({ info: basisText ? [{ id: "greeks-basis",
-    parts: [{ text: basisText, tone: "muted" as const }],
-    variants: [[{ text: shortBasisText, tone: "muted" as const }], []] }] : [] }), [basisText, shortBasisText]);
+  // How IV was solved is said while the chain shows a figure that was not: a strike with no two-sided
+  // out-of-the-money quote has its IV read off the neighbouring strikes, and its cell leads with "~".
+  const ivFilledShown = optionFieldIds.includes("iv") && rows.some((row) => row.impliedVolatilityFilled && row.impliedVolatility != null);
+  // A report of the pane (`gloom fn OMON`) says it too.
+  useRemoteUiNode(ivFilledShown ? {
+    role: "report-notice",
+    label: "IV filled",
+    getMetadata: () => ({ text: IV_FILLED_NOTE, key: "ivFilled", value: true }),
+  } : null);
+  usePaneFooter("options-basis", () => ({ info: [
+    ...(basisText ? [{ id: "greeks-basis", parts: [{ text: basisText, tone: "muted" as const }],
+      variants: [[{ text: shortBasisText, tone: "muted" as const }], []] }] : []),
+    ...(ivFilledShown ? [{ id: "iv-filled", parts: [{ text: IV_FILLED_NOTE, tone: "muted" as const }],
+      title: IV_FILLED_DETAIL, variants: [[{ text: IV_FILLED_SHORT, tone: "muted" as const }]] }] : []),
+  ] }), [basisText, shortBasisText, ivFilledShown]);
   // Figures that summarise the whole expiry move at most once a second, so a
   // busy stream reads as a steady strip rather than flicker.
   // A new expiry, a refreshed snapshot or the underlying price arriving or

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

@@ -42,6 +42,8 @@ export interface OpenInterestPayload {
   tracked: boolean;
   spot: number | null;
   spotAsOf: string | null;
+  /** `close` when spot is a regular session's close at `spotAsOf`: a cash index outside its session. Absent from older servers. */
+  spotBasis?: "close";
   delayed: boolean;
   expiries: ExpiryOpenInterest[];
   expiry: string | null;
@@ -82,6 +84,8 @@ export interface GammaPayload {
   oiDate: string | null;
   spot: number | null;
   spotAsOf: string | null;
+  /** `close` when spot is a regular session's close at `spotAsOf`: a cash index outside its session. Absent from older servers. */
+  spotBasis?: "close";
   delayed: boolean;
   /** The one expiry measured, or null for all of them. */
   expiry: string | null;
@@ -99,7 +103,14 @@ export interface GammaPayload {
   strikes: GammaStrike[];
   /** Each priced expiry's totals, from the same legs as `total`; absent from older servers. */
   byExpiry?: GammaExpiry[];
+  /** When the quotes behind the volatilities were taken: the expiry's own, or the newest priced one's for all. */
   quotesAsOf: string | null;
+  /**
+   * The instant gamma is evaluated at, which time to expiry runs from: now
+   * while the quotes are current, the spot's time with a closed session's
+   * quotes (before the open). Absent from older servers.
+   */
+  gammaAsOf?: string | null;
   warnings: string[];
   /** The venue listing the options, when it is not the US exchanges: Deribit. */
   venue?: string;

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

@@ -18,6 +18,7 @@ import {
   formatCountChange,
   formatDistance,
   formatGamma,
+  formatGammaTimes,
   formatLevel,
   formatPositioningSpot,
   formatPayout,
@@ -44,15 +45,19 @@ const wall = (value: number | null, spot: number | null) =>
   value == null ? "--" : `${formatStrikeLabel(value)}, ${formatDistance(value, spot)} vs spot`;
 
 /**
- * What the report opens with: spot and the quote time gamma was priced at,
- * apart from the open interest session, then the figures the GEX tab shows.
- * Exports keep each figure whole; the text says them as the pane does.
+ * What the report opens with: spot, the instant gamma is evaluated at and
+ * when the quotes behind its volatilities were taken, apart from the open
+ * interest session, then the figures the GEX tab shows. Exports keep each
+ * figure whole; the text says them as the pane does.
  */
 function summary(openInterest: OpenInterestPayload, dealer: GammaPayload | null): { entries: HeadlessPaneEntry[]; textEntries: HeadlessPaneEntry[] } {
   // Gamma is priced at its own read of spot; the figures and their distances use that one.
   const spot = dealer?.spot ?? openInterest.spot;
   const spotAsOf = dealer ? dealer.spotAsOf : openInterest.spotAsOf;
+  const spotBasis = dealer ? dealer.spotBasis : openInterest.spotBasis;
   const venue = openInterest.venue;
+  // Older servers send no gamma time: their quote time stands alone, as it did.
+  const gammaTimes = dealer ? formatGammaTimes(dealer.gammaAsOf, dealer.quotesAsOf) : null;
   // A venue that publishes open interest live (Deribit) dates it to the read, not to a session.
   const oiAsOf = venue && openInterest.oiAsOf ? openInterest.oiAsOf : null;
   const contract = openInterest.contract;
@@ -61,15 +66,20 @@ function summary(openInterest: OpenInterestPayload, dealer: GammaPayload | null)
     ...(venue ? [{ key: "venue", label: "Venue", value: venue }] : []),
     { key: "spot", label: "Spot", value: spot },
     { key: "spotAsOf", label: "Spot as of", value: spotAsOf },
-    ...(dealer ? [{ key: "quotesAsOf", label: "Quotes as of", value: dealer.quotesAsOf }] : []),
+    // An index outside its session: spot is the close, spotAsOf its time.
+    ...(spotBasis ? [{ key: "spotBasis", label: "Spot basis", value: spotBasis }] : []),
+    ...(dealer && gammaTimes ? [{ key: "gammaAsOf", label: "Gamma at", value: dealer.gammaAsOf ?? null },
+      { key: "quotesAsOf", label: "Vols from", value: dealer.quotesAsOf }]
+      : dealer ? [{ key: "quotesAsOf", label: "Quotes as of", value: dealer.quotesAsOf }] : []),
     { key: "oiDate", label: "Open interest as of", value: oiAsOf ?? openInterest.oiDate },
     ...(contract ? [{ key: "contract", label: "Contract", value: contract }] : []),
     ...(settles ? [{ key: "settles", label: "Expiries settle", value: settles }] : []),
   ];
   const textEntries: HeadlessPaneEntry[] = [
     ...(venue ? [{ label: "Venue", value: venue }] : []),
-    { label: "Spot", value: spot, formatted: formatPositioningSpot(spot, spotAsOf, venue) },
-    ...(dealer ? [{ label: "Quotes as of", value: dealer.quotesAsOf, formatted: time(dealer.quotesAsOf) }] : []),
+    { label: "Spot", value: spot, formatted: formatPositioningSpot(spot, spotAsOf, venue, spotBasis) },
+    ...(dealer && gammaTimes ? [{ label: "Gamma at", value: dealer.gammaAsOf ?? null, formatted: gammaTimes }]
+      : dealer ? [{ label: "Quotes as of", value: dealer.quotesAsOf, formatted: time(dealer.quotesAsOf) }] : []),
     { label: "Open interest as of", value: oiAsOf ?? openInterest.oiDate, formatted: oiAsOf ? `${time(oiAsOf)}, live` : openInterest.oiDate ?? "--" },
     ...(contract ? [{ label: "Contract", value: contract, formatted: `${contract.size} ${contract.unit}; OI counts ${contract.unit}` }] : []),
     ...(settles ? [{ label: "Expiries settle", value: settles, formatted: `${settles}, the day each expiry names` }] : []),
@@ -227,13 +237,16 @@ export const optionsPositioningHeadless = (initialTab: PositioningTab): Headless
         previousOiDate: openInterest.previousOiDate,
         spot,
         spotAsOf: openInterest.spotAsOf,
+        ...(openInterest.spotBasis ? { spotBasis: openInterest.spotBasis } : {}),
         delayed: openInterest.delayed,
         ...(openInterest.venue ? { venue: openInterest.venue, oiAsOf: openInterest.oiAsOf ?? null, contract: openInterest.contract ?? null } : {}),
         ...(dealer instanceof Error ? {} : {
-          gamma: { expiry: dealer.expiry ?? ALL_EXPIRIES, spot: dealer.spot, spotAsOf: dealer.spotAsOf, total: dealer.total, band: dealer.band,
+          gamma: { expiry: dealer.expiry ?? ALL_EXPIRIES, spot: dealer.spot, spotAsOf: dealer.spotAsOf,
+            ...(dealer.spotBasis ? { spotBasis: dealer.spotBasis } : {}), total: dealer.total, band: dealer.band,
             bandWithBoxes: dealer.bandWithBoxes ?? null, boxes: dealer.boxes ?? [], flip: dealer.flip,
             callWall: walls?.callWall ?? null, putWall: walls?.putWall ?? null,
-            unit: "dollars of dealer delta per 1% move", assumption: "dealers long calls, short puts", quotesAsOf: dealer.quotesAsOf },
+            unit: "dollars of dealer delta per 1% move", assumption: "dealers long calls, short puts",
+            gammaAsOf: dealer.gammaAsOf ?? null, quotesAsOf: dealer.quotesAsOf },
         }),
         methodology: METHODOLOGY,
       },

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

@@ -65,7 +65,7 @@ export const optionsPositioningModule: PluginModule = {
       id: "options-positioning-gex",
       label: "Dealer Gamma",
       description: "Net dealer gamma by strike, its total, flip level, call and put walls and the range for the dealer assumption.",
-      keywords: ["gex", "gamma", "dealer gamma", "gamma exposure", "gamma flip", "call wall", "put wall"],
+      keywords: ["gex", "gamma", "dealer gamma", "gamma exposure", "gamma flip", "zero gamma", "gamma level", "call wall", "put wall", "0dte"],
       shortcut: "GEX",
     }, "gex"),
   ],

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

@@ -1,7 +1,15 @@
 import { formatCompact, formatCompactAmount } from "../../../utils/format";
 import { formatExpDate, formatStrikeLabel } from "../../../utils/options";
 import { formatUtcTime } from "../../../utils/utc-time";
-import { formatModelSpotPrice, modelSpotLabel, modelSpotStamp, modelSpotStampVariants, observedModelSpot } from "../options/model-spot";
+import {
+  formatModelSpotPrice,
+  formatSpotTime,
+  modelSpotLabel,
+  modelSpotStamp,
+  modelSpotStampVariants,
+  observedModelSpot,
+  type OptionModelSpot,
+} from "../options/model-spot";
 
 export type PositioningTab = "strikes" | "expiries" | "gex";
 export const POSITIONING_TABS: { value: PositioningTab; label: string }[] = [
@@ -100,14 +108,27 @@ export function formatRatio(value: number | null | undefined): string {
 export function formatLevel(value: number | null | undefined): string {
   return value == null || !Number.isFinite(value) ? "--" : formatModelSpotPrice(value);
 }
+/**
+ * The spot of a positioning answer as the options panes stamp theirs: the
+ * regular session's close when the server says so (a cash index outside its
+ * session, which has no extended hours), otherwise the session its time
+ * falls in.
+ */
+function positioningModelSpot(spot: number, at: number, basis?: "close"): OptionModelSpot {
+  return basis === "close"
+    ? { price: spot, observedAt: at, valuationTime: at, basis: "close", session: null }
+    : observedModelSpot(spot, at);
+}
+
 /**
  * The spot Gloom Cloud read the distances and dealer gamma at, stamped as
  * every options pane stamps its spot (`modelSpotStamp`), as a stat cell
- * carries it: `pre-market Wed 21 Oct 09:35 UTC`, its shorter forms, then
- * none, so the band keeps the columns it has in regular hours. Nothing for
- * the regular session's price.
+ * carries it: `pre-market Wed 21 Oct 09:35 UTC`, `close Tue 20 Oct` for an
+ * index outside its session, their shorter forms, then none, so the band
+ * keeps the columns it has in regular hours. Nothing for the regular
+ * session's price.
  */
-export function positioningSpotDetail(spot: number | null | undefined, spotAsOf: string | null | undefined, venue?: string):
+export function positioningSpotDetail(spot: number | null | undefined, spotAsOf: string | null | undefined, venue?: string, basis?: "close"):
   { detail?: string; detailVariants?: string[] } {
   const at = spotAsOf ? Date.parse(spotAsOf) : Number.NaN;
   if (spot == null || !Number.isFinite(at)) return {};
@@ -116,17 +137,62 @@ export function positioningSpotDetail(spot: number | null | undefined, spotAsOf:
     const time = `${new Date(at).toISOString().slice(11, 16)} UTC`;
     return { detail: `index ${time}`, detailVariants: [`index ${time}`, time, ""] };
   }
-  const observed = observedModelSpot(spot, at);
+  const observed = positioningModelSpot(spot, at, basis);
   const stamp = modelSpotStamp(observed);
   return stamp ? { detail: stamp, detailVariants: [...modelSpotStampVariants(observed), ""] } : {};
 }
 
-/** The spot as a report says it: `770.88 pre-market Wed 21 Oct 09:35 UTC`, `770.10 last Wed 21 Oct 14:05 UTC`. */
-export function formatPositioningSpot(spot: number | null | undefined, spotAsOf: string | null | undefined, venue?: string): string {
+/** The spot as a report says it: `770.88 pre-market Wed 21 Oct 09:35 UTC`, `770.10 last Wed 21 Oct 14:05 UTC`, `7,722.60 close Tue 27 Oct`. */
+export function formatPositioningSpot(spot: number | null | undefined, spotAsOf: string | null | undefined, venue?: string, basis?: "close"): string {
   const at = spotAsOf ? Date.parse(spotAsOf) : Number.NaN;
   if (spot == null || !Number.isFinite(spot)) return "--";
   if (venue) return Number.isFinite(at) ? `${formatLevel(spot)} ${venue} index ${formatUtcTime(new Date(at).toISOString())}` : formatLevel(spot);
-  return Number.isFinite(at) ? `${formatLevel(spot)} ${modelSpotLabel(observedModelSpot(spot, at))}` : formatLevel(spot);
+  return Number.isFinite(at) ? `${formatLevel(spot)} ${modelSpotLabel(positioningModelSpot(spot, at, basis))}` : formatLevel(spot);
+}
+
+const instant = (value: string | null | undefined) => {
+  const at = value ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(at) ? at : null;
+};
+/** `Wed 08:34 UTC`. */
+const dayAndTime = (at: number) => formatSpotTime(at).replace(/^(\w{3}) \d{1,2} \w{3} /, "$1 ");
+/** `08:34 UTC`. */
+const timeOnly = (at: number) => `${new Date(at).toISOString().slice(11, 16)} UTC`;
+
+/**
+ * When dealer gamma is evaluated and when the quotes behind its volatilities
+ * were taken, as a report line: `Wed 28 Oct 08:34 UTC, vols from Tue 27 Oct
+ * 20:14 UTC`. Before the open that is the pre-market spot's time with the last
+ * session's volatilities. Null without a gamma time (an older server, which
+ * dates its quotes alone).
+ */
+export function formatGammaTimes(gammaAsOf: string | null | undefined, quotesAsOf: string | null | undefined): string | null {
+  const gamma = instant(gammaAsOf);
+  if (gamma == null) return null;
+  const quotes = instant(quotesAsOf);
+  return quotes == null ? formatSpotTime(gamma) : `${formatSpotTime(gamma)}, vols from ${formatSpotTime(quotes)}`;
+}
+
+/**
+ * The same as a GEX figure: `Gamma at Wed 08:34 UTC`, detail `vols from Tue
+ * 20:14 UTC` (the day left out when it is the gamma's), with shorter forms
+ * that keep the quote time. An older server's answer, with no gamma time,
+ * dates its quotes alone. Null with neither.
+ */
+export function gammaTimesFigure(gammaAsOf: string | null | undefined, quotesAsOf: string | null | undefined):
+  { label: string; value: string; detail?: string; detailVariants?: string[] } | null {
+  const gamma = instant(gammaAsOf);
+  const quotes = instant(quotesAsOf);
+  if (gamma == null) return quotes == null ? null : { label: "Quotes as of", value: dayAndTime(quotes) };
+  if (quotes == null) return { label: "Gamma at", value: dayAndTime(gamma) };
+  const sameDay = new Date(gamma).toISOString().slice(0, 10) === new Date(quotes).toISOString().slice(0, 10);
+  const quoted = sameDay ? timeOnly(quotes) : dayAndTime(quotes);
+  return {
+    label: "Gamma at",
+    value: dayAndTime(gamma),
+    detail: `vols from ${quoted}`,
+    detailVariants: [`vols from ${quoted}`, `vols ${quoted}`, `vols ${quoted.replace(/ UTC$/, "")}`],
+  };
 }
 
 /** Where a level sits against spot: +0.6%. */
@@ -208,6 +274,9 @@ export function chartWindow<T extends { strike: number }>(
 /** One full-width numeric domain the chart reads as time; strikes are never labelled as dates. */
 const COORDINATE_SPAN = 1_000_000_000_000;
 
+/** Where a chart date made by `toDate` sits across the plot, 0 to 1. */
+export const axisRatioOfDate = (date: Date) => date.getTime() / COORDINATE_SPAN;
+
 export interface NumericAxis {
   /** Where x sits across the plot, 0 at the left edge and 1 at the right. */
   ratio: (x: number) => number;