gloomberb 0.18.4 → 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,8 +96,21 @@ export function solveChainVolatilities(
 ): ChainVolatilities {
   const valuationTime = optionQuoteValuationTime(chain, now);
   const byStrike = new Map<number, number>();
-  if (!positive(spot)) return { valuationTime, byStrike };
-  const rate = DEFAULT_OPTION_CALC_DRAFT.rate;
+  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) {
+      for (const contract of contracts) {
+        const mark = contract.mark;
+        if (!mark || !positive(mark.iv)) continue;
+        const outOfTheMoney = side === "call" ? contract.strike >= mark.forward : contract.strike < mark.forward;
+        if (outOfTheMoney || !byStrike.has(contract.strike)) byStrike.set(contract.strike, mark.iv);
+      }
+    }
+    return { valuationTime, byStrike, filled };
+  }
+  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));
   for (const expiration of expirations) {
@@ -103,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) {
@@ -116,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 {
@@ -185,7 +221,15 @@ export function calculateOptionsSummary(
   };
 }
 
-/** Greeks at the displayed spot, from the strike's solved volatility (0 when the market prices no time value). */
+/** The rate a chain's premiums are valued at: the venue's own when it states one (Deribit's zero), else the model rate. */
+function optionChainRate(chain: Pick<OptionsChain, "rate">): number {
+  return Number.isFinite(chain.rate) ? chain.rate! : DEFAULT_OPTION_CALC_DRAFT.rate;
+}
+
+/**
+ * Greeks at the displayed spot, from the strike's solved volatility (0 when the market prices no time value).
+ * A contract its venue marks (Deribit) has the venue's greeks, at the expiry's forward.
+ */
 export function calculateOptionGreeks(
   contract: OptionContract | undefined,
   side: OptionSide,
@@ -193,6 +237,10 @@ export function calculateOptionGreeks(
   dividendYield: number | undefined,
   volatilities: ChainVolatilities,
 ): OptionValuation | undefined {
+  if (contract?.mark) {
+    const { price, delta, gamma, theta, vega } = contract.mark;
+    return { price, delta, gamma, thetaPerDay: theta, vegaPerPoint: vega, rhoPerPoint: 0 };
+  }
   const volatility = contract ? volatilities.byStrike.get(contract.strike) : undefined;
   // A side nobody bids has no market to measure sensitivity against.
   if (!contract || optionMid(contract) == null || !positive(spot) || !positive(contract.strike) || volatility == null || !(volatility >= 0)) {

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/model-spot.ts

@@ -154,7 +154,10 @@ export function modelSpotExtendedPrint(
   return `${EXTENDED_SESSION_WORDS[print.session]}${print.mark ? " mid" : ""} ${format(print.price)}`;
 }
 
-/** A price to the cent, or to the tick it was quoted at below a dollar. */
+/**
+ * Spot as every options pane writes it (OMON, OPX, OVDV): grouped, to the
+ * cent, or to the tick it was quoted at below a dollar.
+ */
 export function formatModelSpotPrice(price: number): string {
-  return price.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: price < 1 ? 4 : 2, useGrouping: false });
+  return price.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: price < 1 ? 4 : 2 });
 }

package/src/plugins/builtin/options/strike-window.ts

@@ -1,6 +1,7 @@
 import type { OptionsChain } from "../../../types/financials";
 import { calculateOptionGreeks, solveChainVolatilities } from "./analytics";
-import { findNearestStrikeIndex, formatStrikeLabel } from "./table";
+import { formatStrikeLabel } from "../../../utils/options";
+import { findNearestStrikeIndex } from "./table";
 
 /**
  * Which strikes of an expiry the chain lists. Every strike by default, as

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

@@ -4,6 +4,7 @@ import type { OptionContract, OptionsChain } from "../../../types/financials";
 import { blendHex, colors } from "../../../theme/colors";
 import { blendForContrast, blendForSeparation, contrastRatio } from "../../../theme/color-utils";
 import { formatCompact } from "../../../utils/format";
+import { formatStrikeLabel } from "../../../utils/options";
 import { formatOptionPrice, optionQuoteSide, optionSpread } from "./market-reference";
 import { formatCarryPercent, formatCostOfSpot } from "./carry";
 import type {
@@ -162,17 +163,13 @@ export function findNearestStrikeIndex(strikes: number[], targetStrike: number):
   return bestIndex;
 }
 
-export function formatStrikeLabel(strike: number): string {
-  // 15 significant digits keep every listed decimal but drop binary noise from
-  // computed strikes such as spot * 0.9.
-  return Number.isFinite(strike)
-    ? strike.toLocaleString("en-US", { maximumSignificantDigits: 15 }) : "—";
-}
-
-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)}%`;
 }
 
@@ -311,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

@@ -6,12 +6,15 @@ import { isPlainKey } from "../../../utils/keyboard";
 import { formatCompact, formatPercentRaw } from "../../../utils/format";
 import { formatMarketPrice, formatSignedMarketPrice, liveQuoteFormatOptions } from "../../../market-data/market/format";
 import { getRegularSessionDisplay } from "../../../market-data/market/status";
-import { chainOptionContract, formatExpDate, optionContractName, resolveOptionsTarget } from "../../../utils/options";
+import { chainOptionContract, formatExpDate, formatStrikeLabel, optionContractName, resolveOptionsTarget } from "../../../utils/options";
 import {
-  expiryIsoDate, findListedExpiry, formatDaysToExpiry, daysToExpiry, isLiveOptionExpiry, missingExpiryMessage, missingExpiryText, readOptionExpiration,
+  expiryIsoDate, findListedExpiry, formatDaysToExpiry, daysToExpiry, isLiveOptionExpiry, missingExpiryMessage, missingExpiryText, optionExpiryVenue,
+  readOptionExpiration,
 } from "../../../utils/option-expiry";
 import { canonicalTickerKey } from "../../../utils/exchanges";
-import { isOptionsUnavailableError, listedOptionsAlternative, optionsUnavailableTitle } from "../../../market-data/options-alternatives";
+import {
+  COIN_OPTIONS_HINT, isCoinWithoutOptions, isOptionsUnavailableError, listedOptionsAlternative, optionsUnavailableTitle,
+} from "../../../market-data/options-alternatives";
 import { useChartQueries, useOptionsQuery, useResolvedEntryValue, useTickerFinancials } from "../../../market-data/hooks";
 import {
   Button,
@@ -41,14 +44,13 @@ 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,
   createOptionColumns,
   findNearestStrikeIndex,
   formatIv,
-  formatStrikeLabel,
   optionColumnColor,
   renderOptionCell,
   resolveDefaultStrikeTarget,
@@ -272,7 +274,9 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   // A listing can still carry a date whose last session has closed. The chain
   // never opens there, nor on a saved date that has since passed: it takes the nearest live one.
   const now = Date.now();
-  const liveExpiration = (expiration: number) => isLiveOptionExpiry(expiration, now, effectiveExchange);
+  // Expiries close on the listing's clock: a coin's options (Deribit) settle at 08:00 UTC on any day.
+  const expiryVenue = optionExpiryVenue(effectiveTicker, effectiveExchange);
+  const liveExpiration = (expiration: number) => isLiveOptionExpiry(expiration, now, expiryVenue);
   const listedExpirations = initialChain?.expirationDates ?? [];
   const openingExpirations = listedExpirations.some(liveExpiration) ? listedExpirations.filter(liveExpiration) : listedExpirations;
   const initialExpiration = openingExpirations.length === 0 ? undefined : openingExpirations.reduce((best, expiration) => (
@@ -322,9 +326,9 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     const listed = selectedExpirationMissing
       ? [...availableExpirations, selectedExpiration!].sort((left, right) => left - right) : availableExpirations;
     // A date whose last session has closed has no contracts left to show; the strip leaves it out, unless every date has.
-    const current = (expiration: number) => isLiveOptionExpiry(expiration, Date.now(), effectiveExchange);
+    const current = (expiration: number) => isLiveOptionExpiry(expiration, Date.now(), expiryVenue);
     return listed.some(current) ? listed.filter((expiration) => expiration === selectedExpiration || current(expiration)) : listed;
-  }, [availableExpirations, effectiveExchange, selectedExpiration, selectedExpirationMissing]);
+  }, [availableExpirations, expiryVenue, selectedExpiration, selectedExpirationMissing]);
   // Keep the date strip stable while a mouse press focuses this pane. A new
   // tab list asks the web host to reveal the active tab and can move the date
   // being clicked before mouse-up, cancelling selection of an offscreen expiry.
@@ -444,7 +448,7 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
   const chainAsOfMs = asOfChain?.asOf ? Date.parse(asOfChain.asOf) : Number.NaN;
   const expiryAsOfMs = Number.isFinite(chainAsOfMs) ? chainAsOfMs : Date.now();
   const expiryDate = selectedExpiration == null ? "" : expiryIsoDate(selectedExpiration);
-  const expiryDays = selectedExpiration == null ? "" : formatDaysToExpiry(selectedExpiration, expiryAsOfMs, effectiveExchange);
+  const expiryDays = selectedExpiration == null ? "" : formatDaysToExpiry(selectedExpiration, expiryAsOfMs, expiryVenue);
   useRemoteUiNode(expiryDate && chain && !expirationUnavailable ? {
     role: "report-notice",
     label: "Expiry",
@@ -574,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,
@@ -618,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
@@ -904,6 +921,19 @@ export function OptionsView({ width, height, focused, nestedInTabs = false, ivRa
     return <EmptyState title="Select a ticker." />;
   }
   if (loading && !chain) return <Spinner label="Loading options chain..." />;
+  if (error && !chain && isOptionsUnavailableError(error) && isCoinWithoutOptions(effectiveTicker)) {
+    // A coin other than BTC and ETH: the coins that have options, and a bitcoin-linked fund's.
+    return (
+      <EmptyState
+        title={optionsUnavailableTitle(effectiveTicker)}
+        hint={COIN_OPTIONS_HINT}
+        actions={<>
+          <Button label="BTC-USD options" onPress={() => createPaneFromTemplate("options-pane", { symbol: "BTC-USD" })} />
+          <Button label="IBIT options" onPress={() => createPaneFromTemplate("options-pane", { symbol: "IBIT" })} />
+        </>}
+      />
+    );
+  }
   if (error && !chain && isOptionsUnavailableError(error)) {
     // A future or commodity with no chain of its own: the listed fund whose options stand in, and OSA on it.
     const alternative = listedOptionsAlternative(effectiveTicker);

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

@@ -12,6 +12,8 @@ export interface ExpiryOpenInterest {
   /** Change since `previousOiDate`; null without a stored session to compare with. */
   callChange: number | null;
   putChange: number | null;
+  /** The instant it settles, when the venue states one: 08:00 UTC for Deribit's BTC and ETH options. */
+  expiresAt?: string;
 }
 
 export interface StrikeOpenInterest {
@@ -24,6 +26,12 @@ export interface StrikeOpenInterest {
   payout: number | null;
 }
 
+/** What one contract is: 1 BTC for Deribit's options, 100 shares for a US listing's (absent from US payloads). */
+interface PositioningContract {
+  size: number;
+  unit: string;
+}
+
 export interface OpenInterestPayload {
   version: 1;
   symbol: string;
@@ -34,11 +42,19 @@ 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;
   strikes: StrikeOpenInterest[];
   warnings: string[];
+  /** When the counts were read, for a venue that publishes them live (Deribit); `oiDate` is then that UTC day. */
+  oiAsOf?: string | null;
+  /** The venue listing the options, when it is not the US exchanges: Deribit. */
+  venue?: string;
+  /** Open interest counts contracts of this size; absent means 100 shares. */
+  contract?: PositioningContract;
 }
 
 export interface GammaStrike {
@@ -56,6 +72,9 @@ interface GammaExpiry {
   /** Short, as a positive number. */
   puts: number;
   net: number;
+  /** The expiry's strikes with the most call and put gamma; absent from older servers. */
+  callWall?: number | null;
+  putWall?: number | null;
 }
 
 export interface GammaPayload {
@@ -65,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;
@@ -82,8 +103,17 @@ 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;
 }
 
 export type OptionsPositioningApi = Pick<typeof apiClient, "optionsPositioning">;