gloomberb 0.18.4 → 0.19.0

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

@@ -1,21 +1,28 @@
 import type { HeadlessPaneDefinition, HeadlessPaneEntry } from "../../../types/plugin";
+import { formatStrikeLabel } from "../../../utils/options";
 import { expirationOptionSeconds, expiryIsoDate, OPTION_EXPIRATION_FORMAT, OPTION_EXPIRATION_PLACEHOLDER } from "../../../utils/option-expiry";
 import { formatUtcTime } from "../../../utils/utc-time";
 import { loadGamma, loadOpenInterest, positioningSymbol, type GammaPayload, type OpenInterestPayload } from "./client";
 import { listingFateReport, loadListingFate } from "../../../tickers/listing-fate";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
+import { coinOptionsAlias, coinWithoutOptionsRefusal } from "../../../market-data/options-alternatives";
 import {
   ALL_EXPIRIES,
   expiryLabel,
+  expiryWithTimeLabel,
+  formatContracts,
+  isCoinContract,
+  settlementTime,
+  wallsByExpiry,
   formatCount,
   formatCountChange,
   formatDistance,
   formatGamma,
+  formatGammaTimes,
   formatLevel,
   formatPositioningSpot,
   formatPayout,
   formatRatio,
-  formatStrike,
   GAMMA_UNIT,
   gammaWalls,
   netGammaByExpiry,
@@ -25,8 +32,9 @@ import {
 
 const METHODOLOGY = "https://gloom.sh/docs/options-positioning";
 const UNIT_TEXT = "$ of dealer delta per 1% move";
-const strike = (value: unknown) => typeof value === "number" ? formatStrike(value) : "--";
+const strike = (value: unknown) => typeof value === "number" ? formatStrikeLabel(value) : "--";
 const count = (value: unknown) => formatCount(typeof value === "number" ? value : null);
+const coinCount = (value: unknown) => formatContracts(typeof value === "number" ? value : null, true);
 const change = (value: unknown) => formatCountChange(typeof value === "number" ? value : null);
 const gamma = (value: unknown) => formatGamma(typeof value === "number" ? value : null);
 const failure = (error: unknown) => error instanceof Error ? error : new Error(String(error));
@@ -34,27 +42,47 @@ const time = (value: string | null) => value ? formatUtcTime(value) : "--";
 const level = (value: number | null, spot: number | null, none = "--") =>
   value == null ? none : `${formatLevel(value)}, ${formatDistance(value, spot)} vs spot`;
 const wall = (value: number | null, spot: number | null) =>
-  value == null ? "--" : `${formatStrike(value)}, ${formatDistance(value, spot)} vs spot`;
+  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;
+  const settles = settlementTime(openInterest.expiries[0]?.expiresAt);
   const entries: HeadlessPaneEntry[] = [
+    ...(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 }] : []),
-    { key: "oiDate", label: "Open interest as of", value: openInterest.oiDate },
+    // 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[] = [
-    { label: "Spot", value: spot, formatted: formatPositioningSpot(spot, spotAsOf) },
-    ...(dealer ? [{ label: "Quotes as of", value: dealer.quotesAsOf, formatted: time(dealer.quotesAsOf) }] : []),
-    { label: "Open interest as of", value: openInterest.oiDate, formatted: openInterest.oiDate ?? "--" },
+    ...(venue ? [{ label: "Venue", value: venue }] : []),
+    { 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` }] : []),
   ];
   if (!dealer?.total) return { entries, textEntries };
   const { callWall, putWall } = gammaWalls(dealer.strikes);
@@ -86,8 +114,10 @@ function summary(openInterest: OpenInterestPayload, dealer: GammaPayload | null)
 export const optionsPositioningHeadless = (initialTab: PositioningTab): HeadlessPaneDefinition<"bundle"> => ({
   shape: "bundle",
   freshness: { status: "not-a-feed", basis: "daily open interest", cadence: "daily" },
-  argument: { kind: "ticker", optional: true, description: "US option underlying, or SPX; SPY when omitted" },
+  argument: { kind: "ticker", optional: true, description: "US option underlying, BTC-USD or ETH-USD, or SPX; SPY when omitted" },
   usListingsOnly: "Options data",
+  symbolAlias: coinOptionsAlias(initialTab === "gex" ? "GEX" : "OPX"),
+  refuseSymbol: coinWithoutOptionsRefusal(initialTab === "gex" ? "GEX" : "OPX"),
   describe: (args) => `${initialTab === "gex" ? "GEX" : "OPX"} ${args.symbols[0] ?? "SPY"}`,
   discovery: {
     aliases: initialTab === "gex" ? ["GEX"] : ["OPX", "MAXPAIN"],
@@ -97,6 +127,7 @@ export const optionsPositioningHeadless = (initialTab: PositioningTab): Headless
       "Open interest is about two sessions old; the Expiries heading names its date.",
       "Dealer gamma assumes dealers are long every call and short every put.",
       "NDX and RUT index options are not covered; use QQQ and IWM.",
+      "BTC-USD and ETH-USD are Deribit's options: open interest is live and counted in coins, and expiries settle at 08:00 UTC.",
     ],
   },
   options: [
@@ -135,34 +166,52 @@ export const optionsPositioningHeadless = (initialTab: PositioningTab): Headless
       : listingFateReport(await loadListingFate(await resolveHeadlessInstrument(ctx, symbol), ctx.marketData), { served: false }, loadErrors);
     const errors = fate?.errors ?? loadErrors;
     const changes = openInterest.previousOiDate != null;
+    const coin = isCoinContract(openInterest.contract);
+    const contracts = coin ? coinCount : count;
+    const unit = coin ? ` (${openInterest.contract!.unit})` : "";
+    // Each expiry's walls, from the all-expiries gamma; absent from older servers.
+    const expiryWalls = allExpiries instanceof Error ? null : wallsByExpiry(allExpiries);
+    const settles = openInterest.expiries.some((row) => settlementTime(row.expiresAt));
+    const oiStamp = openInterest.venue && openInterest.oiAsOf ? `${time(openInterest.oiAsOf)}, live` : openInterest.oiDate ?? "--";
     const gammaShown = dealer instanceof Error || !dealer.total ? null : dealer;
     const scope = dealer instanceof Error ? null : dealer.expiry ? expiryLabel(dealer.expiry) : "all expiries";
     const walls = gammaShown ? gammaWalls(gammaShown.strikes) : null;
     return {
       // Open interest is counted once a day and arrives about two sessions late, dated in the heading and the summary;
       // spot and the quotes have their own times in the summary.
-      freshness: { asOf: openInterest.oiDate },
+      // A venue's live book (Deribit's) is a feed: read a minute ago, or held back 15 minutes for delayed access.
+      freshness: openInterest.venue && openInterest.oiAsOf
+        ? { asOf: openInterest.oiAsOf, status: openInterest.delayed ? "delayed" as const : "live" as const,
+          ...(openInterest.delayed ? { delayMinutes: 15 } : {}) }
+        : { asOf: openInterest.oiDate },
       sections: [
         { title: scope ? `Summary · ${scope}` : "Summary", ...summary(openInterest, dealer instanceof Error ? null : dealer) },
-        { title: `Expiries · OI as of ${openInterest.oiDate ?? "--"}`, columns: [
-          { key: "date", header: "Expiry" }, { key: "days", header: "Days" },
-          { key: "callOI", header: "Call OI", format: count }, { key: "putOI", header: "Put OI", format: count },
+        { title: `Expiries · OI as of ${oiStamp}`, columns: [
+          { key: "date", header: "Expiry" },
+          // Deribit's expiries settle at 08:00 UTC on the day they name.
+          ...(settles ? [{ key: "settles", header: "Settles" }] : []),
+          { key: "days", header: "Days" },
+          { key: "callOI", header: `Call OI${unit}`, format: contracts }, { key: "putOI", header: `Put OI${unit}`, format: contracts },
           { key: "putCallRatio", header: "P/C", format: (value: unknown) => formatRatio(value as number | null) },
           ...(changes ? [{ key: "change", header: "OI chg", format: change }] : []),
           { key: "maxPain", header: "Max pain", format: strike },
           { key: "distance", header: "Vs spot" },
+          ...(expiryWalls ? [{ key: "callWall", header: "Call wall", format: strike }, { key: "putWall", header: "Put wall", format: strike }] : []),
           ...(gammaColumn ? [{ key: "netGamma", header: "Net GEX $", format: gamma, unitKey: "netGammaUnit" }] : []),
         ], rows: openInterest.expiries.map((row) => ({
           ...row,
+          ...(settles ? { settles: settlementTime(row.expiresAt) } : {}),
           change: row.callChange == null ? null : row.callChange + (row.putChange ?? 0),
           distance: formatDistance(row.maxPain, spot),
+          ...(expiryWalls ? { callWall: expiryWalls.get(row.date)?.callWall ?? null, putWall: expiryWalls.get(row.date)?.putWall ?? null } : {}),
           ...(gammaColumn ? { netGamma: expiryGamma?.get(row.date) ?? null, netGammaUnit: GAMMA_UNIT } : {}),
         })) },
-        { title: `Strikes · ${openInterest.expiry ? expiryLabel(openInterest.expiry) : "--"}`, columns: [
+        { title: `Strikes · ${openInterest.expiry
+          ? expiryWithTimeLabel(openInterest.expiries.find((row) => row.date === openInterest.expiry) ?? { date: openInterest.expiry }) : "--"}`, columns: [
           { key: "strike", header: "Strike", format: strike },
-          { key: "callOI", header: "Call OI", format: count },
+          { key: "callOI", header: `Call OI${unit}`, format: contracts },
           ...(changes ? [{ key: "callChange", header: "Call chg", format: change }] : []),
-          { key: "putOI", header: "Put OI", format: count },
+          { key: "putOI", header: `Put OI${unit}`, format: contracts },
           ...(changes ? [{ key: "putChange", header: "Put chg", format: change }] : []),
           { key: "payout", header: "Payout $", format: (value: unknown) => formatPayout(value as number | null) },
         ], rows: openInterest.strikes.map((row) => ({ ...row })) },
@@ -188,12 +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

@@ -56,16 +56,16 @@ export const optionsPositioningModule: PluginModule = {
     positioningTemplate({
       id: "options-positioning-pane",
       label: "Options Positioning",
-      description: "Open interest by strike and expiry, max pain, and dealer gamma (GEX).",
-      keywords: ["opx", "open interest", "max pain", "put call", "expiry", "options"],
+      description: "Open interest by strike and expiry, max pain, walls and dealer gamma (GEX); BTC-USD and ETH-USD from Deribit.",
+      keywords: ["opx", "open interest", "max pain", "put call", "expiry", "options", "deribit", "bitcoin options", "ether options", "crypto options"],
       shortcut: "OPX",
       shortcutAliases: ["MAXPAIN"],
-    }, "strikes", "Options open interest by strike and expiry, max pain, and dealer gamma (GEX) for a US underlying."),
+    }, "strikes", "Options open interest by strike and expiry, max pain, and dealer gamma (GEX) for a US underlying, or Deribit's BTC-USD and ETH-USD options."),
     positioningTemplate({
       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,6 +1,15 @@
 import { formatCompact, formatCompactAmount } from "../../../utils/format";
-import { formatExpDate } from "../../../utils/options";
-import { modelSpotLabel, modelSpotStamp, modelSpotStampVariants, observedModelSpot } from "../options/model-spot";
+import { formatExpDate, formatStrikeLabel } from "../../../utils/options";
+import { formatUtcTime } from "../../../utils/utc-time";
+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 }[] = [
@@ -46,13 +55,44 @@ export function netGammaByExpiry(
   return new Map(payload.byExpiry.map((row) => [row.expiry, row.net]));
 }
 
+/**
+ * Each expiry's call and put walls, from an all-expiries gamma answer: the
+ * strikes of that expiry with the most call and put gamma. Null when the
+ * answer is for one expiry or the server is older than the fields.
+ */
+export function wallsByExpiry(
+  payload: { expiry: string | null; byExpiry?: readonly { expiry: string; callWall?: number | null; putWall?: number | null }[] } | null | undefined,
+): Map<string, { callWall: number | null; putWall: number | null }> | null {
+  if (!payload || payload.expiry != null || !payload.byExpiry?.some((row) => "callWall" in row)) return null;
+  return new Map(payload.byExpiry.map((row) => [row.expiry, { callWall: row.callWall ?? null, putWall: row.putWall ?? null }]));
+}
+
 const dateSeconds = (date: string) => Date.parse(`${date}T00:00:00Z`) / 1000;
 /** Oct 16 '26, as OMON names its expiries. */
 export const expiryLabel = (date: string) => formatExpDate(dateSeconds(date));
 
-export function formatStrike(value: number): string {
-  return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(3)));
+/** `08:00 UTC`: the time an expiry settles, when the venue states one apart from its day (Deribit); null otherwise. */
+export function settlementTime(expiresAt: string | null | undefined): string | null {
+  const at = expiresAt ? Date.parse(expiresAt) : Number.NaN;
+  if (!Number.isFinite(at) || at % 86_400_000 === 0) return null;
+  return `${new Date(at).toISOString().slice(11, 16)} UTC`;
+}
+
+/** `Oct 30 '26 08:00 UTC` for an expiry with a settlement time, `Oct 30 '26` for one without. */
+export function expiryWithTimeLabel(row: { date: string; expiresAt?: string }): string {
+  const time = settlementTime(row.expiresAt);
+  return time ? `${expiryLabel(row.date)} ${time}` : expiryLabel(row.date);
+}
+
+/** Whether open interest counts contracts on a coin (1 BTC each), whose counts run to tenths. */
+export const isCoinContract = (contract: { unit: string } | null | undefined) => !!contract && contract.unit !== "shares";
+
+/** A count of contracts: whole for a US listing's, to tenths for a coin's (Deribit's 0.1 BTC step). */
+export function formatContracts(value: number | null | undefined, coin: boolean): string {
+  if (!coin) return formatCount(value);
+  return value == null || !Number.isFinite(value) ? "--" : value.toLocaleString("en-US", { maximumFractionDigits: 1 });
 }
+
 export function formatCount(value: number | null | undefined): string {
   return value == null || !Number.isFinite(value) ? "--" : Math.round(value).toLocaleString("en-US");
 }
@@ -64,30 +104,95 @@ export function formatCountChange(value: number | null | undefined): string {
 export function formatRatio(value: number | null | undefined): string {
   return value == null || !Number.isFinite(value) ? "--" : value.toFixed(2);
 }
+/** A price level (spot, the gamma flip) written as OMON and OVDV write spot. */
 export function formatLevel(value: number | null | undefined): string {
-  return value == null || !Number.isFinite(value) ? "--" : value.toFixed(2);
+  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):
+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 {};
-  const observed = observedModelSpot(spot, at);
+  // A coin trades around the clock: its spot is the venue's index at a time, with no session.
+  if (venue) {
+    const time = `${new Date(at).toISOString().slice(11, 16)} UTC`;
+    return { detail: `index ${time}`, detailVariants: [`index ${time}`, time, ""] };
+  }
+  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): 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 "--";
-  return Number.isFinite(at) ? `${formatLevel(spot)} ${modelSpotLabel(observedModelSpot(spot, at))}` : formatLevel(spot);
+  if (venue) return Number.isFinite(at) ? `${formatLevel(spot)} ${venue} index ${formatUtcTime(new Date(at).toISOString())}` : 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%. */
@@ -169,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;
@@ -200,7 +308,7 @@ export function strikeAxis(strikes: readonly number[]): NumericAxis {
       const step = niceStep(span, Math.floor(plotWidth / 8));
       const ticks: Array<{ label: string; ratio: number }> = [];
       for (let value = Math.ceil(min / step) * step; value <= max + 1e-9; value += step) {
-        ticks.push({ label: formatStrike(Number(value.toFixed(6))), ratio: ratio(value) });
+        ticks.push({ label: formatStrikeLabel(Number(value.toFixed(6))), ratio: ratio(value) });
       }
       return ticks;
     },