gloomberb 0.18.2 → 0.18.4

package/src/plugins/builtin/vol-surface/headless.ts

@@ -1,17 +1,19 @@
 import type { Quote } from "../../../types/financials";
 import type { HeadlessBundleSection, HeadlessPaneDefinition, HeadlessPaneFreshness, HeadlessPaneLoadArgs, HeadlessPaneRow } from "../../../types/plugin";
 import {
-  expirationOptionSeconds, findListedExpiry, OPTION_EXPIRATION_FORMAT, OPTION_EXPIRATION_PLACEHOLDER, readOptionExpiration, unlistedExpiryText,
+  expirationOptionSeconds, expiredExpiryText, findListedExpiry, isLiveOptionExpiry, OPTION_EXPIRATION_FORMAT, OPTION_EXPIRATION_PLACEHOLDER,
+  readOptionExpiration, unlistedExpiryText,
 } from "../../../utils/option-expiry";
 import { DATE_OPTION_EXAMPLES } from "../../../utils/calendar-date";
-import { skewHeader } from "../iv-history/format";
+import { IMPLIED_VOL_WORDS, skewHeader } from "../iv-history/format";
 import { formatStrikeLabel } from "../options/table";
 import { createSurfaceDependencies, loadVolatilitySurface } from "./client";
 import { buildSurfaceGrid, type SurfaceGridOptions, type SurfaceSettings, type SurfaceSnapshot } from "./model";
-import { formatCaptureTime, loadDatedSurface, storedSurfaceDate, type DatedSurfaceSnapshot } from "./stored";
+import { atCapturePrecision, formatCaptureTime, loadDatedSurface, storedSurfaceDate, type DatedSurfaceSnapshot } from "./stored";
+import { listingFateEmpty, loadListingFate } from "../../../tickers/listing-fate";
 import {
   expiryFeedFields, expiryLabel, formatIv, formatPrice, formatVolPoints, HIDDEN_SLOPE_TEXT, HIDDEN_YIELD_TEXT, selectSurfaceExpiry, surfaceForwardRow, surfaceSkewRow,
-  surfaceSmileRows, surfaceTermRows, TERM_SLOPE_MIN_DAYS, type SurfaceForwardRow, type SurfaceSkewRow,
+  surfaceSmileRows, surfaceSpotBasisLabel, surfaceTermRows, TERM_SLOPE_MIN_DAYS, type SurfaceForwardRow, type SurfaceSkewRow,
 } from "./tables";
 
 type SurfaceAxis = NonNullable<SurfaceGridOptions["axis"]>;
@@ -26,8 +28,8 @@ export function surfaceCoordinateLabel(axis: SurfaceAxis, coordinate: number, in
 
 /** The Skew view's sign conventions and units, one line each. */
 const SKEW_NOTES = [
-  "RR is 25D call IV minus 25D put IV, BF the average 25D wing IV minus ATM IV, 90/110 the IV at 90% of spot minus the IV at 110%; all in vol points.",
-  `Slope is the ATM IV change per year to the next listed expiry, in vol points; left out under ${TERM_SLOPE_MIN_DAYS} days to expiry, where it annualises a few hours of noise.`,
+  "RR is 25D call IV minus 25D put IV, BF the average 25D wing IV minus the IV at the forward, 90/110 the IV at 90% of the forward minus the IV at 110%; all in vol points.",
+  `Slope is the change per year in the IV at the forward to the next listed expiry, in vol points; left out under ${TERM_SLOPE_MIN_DAYS} days to expiry, where it annualises a few hours of noise.`,
 ];
 
 /**
@@ -132,6 +134,7 @@ function forwardsSection(snapshot: SurfaceSnapshot): HeadlessBundleSection {
 export const volSurfaceHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Underlying ticker" },
   usListingsOnly: "Options data",
+  discovery: { suggestFor: IMPLIED_VOL_WORDS },
   describe: (args) => `OVDV ${args.symbols[0] ?? ""}`,
   options: [
     { key: "tab", type: "enum", values: SURFACE_TABS.map((value) => ({ value })),
@@ -154,6 +157,7 @@ export const volSurfaceHeadless: HeadlessPaneDefinition<"bundle"> = {
     const date = typeof args.options.date === "string" && args.options.date ? storedSurfaceDate(args.options.date) : null;
     let snapshot: DatedSurfaceSnapshot;
     let quote: Quote | null = null;
+    let instrument: { symbol: string; exchange?: string } = { symbol };
     if (date) {
       // A stored close needs no current price: it carries the spot it was fitted at.
       snapshot = await loadDatedSurface(symbol, date, { signal: ctx.signal, api: ctx.apiClient });
@@ -162,21 +166,43 @@ export const volSurfaceHeadless: HeadlessPaneDefinition<"bundle"> = {
         snapshot = { ...snapshot, failures: [...snapshot.failures, { expiration: requested, message: unlistedExpiryText(requested, snapshot.catalogue) }] };
       }
     } else {
-      const instrument = await ctx.resolveInstrument?.(symbol) ?? { symbol };
-      quote = await ctx.marketData.getQuote(symbol, instrument.exchange);
+      const resolved = await ctx.resolveInstrument?.(symbol) ?? { symbol };
+      instrument = resolved;
+      quote = await ctx.marketData.getQuote(symbol, resolved.exchange);
       if (!(quote.price > 0) || !Number.isFinite(quote.price) || quote.stale) {
-        return { sections: [], complete: false, unavailableSymbols: [symbol], errors: ["A current underlying price is required"] };
+        // A listing that stopped trading has no current price: what became of it is why (TWTR).
+        const fate = await loadListingFate(resolved, ctx.marketData, { quote });
+        return { sections: [], complete: false, unavailableSymbols: [symbol],
+          ...listingFateEmpty(fate, ["A current underlying price is required"]) };
       }
-      snapshot = await loadVolatilitySurface({ instrument, spot: quote.price, spotAsOf: quote.lastUpdated,
+      // At a stored close's precision, so the live report and a --date one export the same digits. A chain
+      // from a closed session is priced at that session's close, as OMON prices it.
+      snapshot = atCapturePrecision(await loadVolatilitySurface({ instrument, spot: quote.price, spotAsOf: quote.lastUpdated, quote,
         settings: { ivSource: args.options.ivSource as SurfaceSettings["ivSource"], priceSide: args.options.priceSide as SurfaceSettings["priceSide"] },
         limit: Number(args.options.limit), signal: ctx.signal,
         requiredExpiries: requested == null ? [] : [requested],
-      }, createSurfaceDependencies(ctx.marketData, ctx.apiClient));
+      }, createSurfaceDependencies(ctx.marketData, ctx.apiClient)));
+      // An expired --expiration names the flag that asks for the nearest live one.
+      const now = Date.now();
+      if (requested != null && !isLiveOptionExpiry(requested, now, instrument.exchange)) {
+        const message = expiredExpiryText(requested, snapshot.catalogue, now, { exchange: instrument.exchange, flag: "expiration" });
+        snapshot = { ...snapshot, failures: snapshot.failures.map((failure) => failure.expiration === requested ? { ...failure, message } : failure) };
+      }
     }
+    const available = snapshot.expiries.some((expiry) => expiry.fit);
+    // An expiry that failed as the whole surface did (no connection) is not listed again under its own date.
+    const surfaceWide = new Set(snapshot.failures.filter((failure) => failure.expiration == null).map((failure) => failure.message));
+    const loadErrors = snapshot.failures.filter((failure) => failure.expiration == null || !surfaceWide.has(failure.message))
+      .map((failure) => failure.expiration == null ? failure.message : `${expiryLabel(failure.expiration)}: ${failure.message}`);
+    // A symbol with no option chain at all says what became of it when something did (FB is a fund now,
+    // Meta trades as META) in place of the chain's own error; a chain without clean quotes is the symbol's own.
+    const fate = !snapshot.stored && !available && snapshot.catalogue.length === 0
+      ? listingFateEmpty(await loadListingFate(instrument, ctx.marketData, { quote }), loadErrors) : null;
+    // The spot a chain from a closed session was priced at, and its session.
+    const spotBasis = available ? surfaceSpotBasisLabel(snapshot) : null;
     const stored = snapshot.stored ?? null;
     const axis = args.options.axis as SurfaceAxis;
     const tab = (SURFACE_TABS as readonly string[]).includes(String(args.options.tab)) ? args.options.tab as SurfaceTab : "surface";
-    const available = snapshot.expiries.some((expiry) => expiry.fit);
     const expiryWarnings = snapshot.expiries.flatMap((expiry) => expiry.warnings.map((warning) =>
       ({ expiry: expiryLabel(expiry.expiration), warning })));
     const perExpiry = new Set(expiryWarnings.map((row) => row.warning));
@@ -197,9 +223,11 @@ export const volSurfaceHeadless: HeadlessPaneDefinition<"bundle"> = {
       ],
       complete: available && snapshot.failures.length === 0 && snapshot.expiries.every((expiry) => expiry.state === "ready"),
       unavailableSymbols: available ? [] : [symbol],
-      errors: [...snapshot.failures.map((failure) => failure.expiration == null ? failure.message
-        : `${expiryLabel(failure.expiration)}: ${failure.message}`), ...smile?.errors ?? []],
-      ...(stored || tab === "skew" ? { notes: [...stored ? storedNotes(snapshot, args.options) : [], ...tab === "skew" ? SKEW_NOTES : []] } : {}),
+      errors: [...fate?.errors ?? loadErrors, ...smile?.errors ?? []],
+      ...(fate?.empty ? { empty: fate.empty } : {}),
+      ...(stored || spotBasis || tab === "skew" ? { notes: [
+        ...stored ? storedNotes(snapshot, args.options) : spotBasis ? [`Spot ${formatPrice(snapshot.spot)}, ${spotBasis}.`] : [],
+        ...tab === "skew" ? SKEW_NOTES : []] } : {}),
       // A stored close is dated by its session, whichever view prints it.
       ...(stored ? { freshness: { status: "not-a-feed" as const, basis: "stored close capture", asOf: stored.sessionDate } }
         : smile?.freshness ? { freshness: smile.freshness } : {}),

package/src/plugins/builtin/vol-surface/model.ts

@@ -99,10 +99,23 @@ export interface SurfaceFailure {
   reasonCode?: string;
 }
 
+/**
+ * What a surface's spot is (`optionModelSpot`): the official close of the
+ * session the chain was quoted in (`close`, that session's New York date),
+ * or the latest price (`last`, with the extended session it printed in).
+ */
+interface SurfaceSpotBasis {
+  basis: "close" | "last";
+  session: "pre-market" | "after hours" | "overnight" | null;
+  sessionDate: string | null;
+}
+
 export interface SurfaceSnapshot {
   symbol: string;
   spot: number;
   spotAsOf?: string | number | null;
+  /** Absent when the caller gave a bare spot, as a stored close does. */
+  spotBasis?: SurfaceSpotBasis | null;
   phase: "loading" | "partial" | "ready" | "error";
   settings: SurfaceSettings;
   catalogue: number[];
@@ -401,11 +414,16 @@ export function buildSurfaceExpiry(input: BuildSurfaceExpiryInput): SurfaceExpir
 }
 
 /**
- * A fitted expiry's skew in decimal IV: RR is the 25-delta call minus put, BF
- * their average minus ATM, 90/110 the IV at 90% of spot minus 110%. The
- * 25-delta strikes are found on the fit inside the quoted strikes, as the
- * Table's delta columns find them, so a fit that cannot price a far wing it
- * was never quoted at does not blank a quoted expiry's skew.
+ * A fitted expiry's skew in decimal IV, measured from its forward: `atm` is
+ * the IV at the forward (ATMF), RR the 25-delta call minus put, BF their
+ * average minus ATMF, 90/110 the IV at 90% of the forward minus 110%. The
+ * spot only enters through the 25-delta strikes' spot delta, whose carry is
+ * the parity forward's, so a pre-market print against the close's chain does
+ * not move a fly, and a long-dated fly is not dragged below zero by the skew
+ * between spot and a forward several percent above it. The 25-delta strikes
+ * are found on the fit inside the quoted strikes, as the Table's delta
+ * columns find them, so a fit that cannot price a far wing it was never
+ * quoted at does not blank a quoted expiry's skew.
  */
 export function surfaceExpirySkew(expiry: SurfaceExpiry, spot: number): SkewMetrics {
   const smile = (strike: number) => evaluateSurfaceSmile(expiry, strike);
@@ -413,8 +431,9 @@ export function surfaceExpirySkew(expiry: SurfaceExpiry, spot: number): SkewMetr
     const strike = deltaStrike(expiry, spot, delta);
     return strike == null ? null : smile(strike);
   };
-  const put25 = at(-0.25), call25 = at(0.25), atm = expiry.atmIV;
-  const low = smile(spot * 0.9), high = smile(spot * 1.1);
+  const forward = expiry.forward;
+  const put25 = at(-0.25), call25 = at(0.25), atm = positive(forward) ? smile(forward) : null;
+  const low = positive(forward) ? smile(forward * 0.9) : null, high = positive(forward) ? smile(forward * 1.1) : null;
   const both = put25 != null && call25 != null;
   return { atm, put25, call25, putCallSkew: both ? put25 - call25 : null, riskReversal: both ? call25 - put25 : null,
     butterfly: both && atm != null ? (put25 + call25) / 2 - atm : null,
@@ -433,12 +452,13 @@ export function surfaceCalendarWarnings(expiries: readonly SurfaceExpiry[]): str
   return count > 0 ? [`${count} calendar arbitrage ${count === 1 ? "warning" : "warnings"}`] : [];
 }
 
+/** The ATM-forward IV change per year to the next expiry that has one: spot plays no part in it. */
 export function withSurfaceTermSlopes(expiries: readonly SurfaceExpiry[]): SurfaceExpiry[] {
   const sorted = [...expiries].sort((a, b) => a.years - b.years);
   return sorted.map((expiry, index) => {
-    const next = sorted.slice(index + 1).find((item) => item.atmIV != null);
-    return { ...expiry, termSlope: expiry.atmIV != null && next?.atmIV != null
-      ? volatilityTermSlope({ years: expiry.years, volatility: expiry.atmIV }, { years: next.years, volatility: next.atmIV }) : null };
+    const next = sorted.slice(index + 1).find((item) => item.skew.atm != null);
+    return { ...expiry, termSlope: expiry.skew.atm != null && next?.skew.atm != null
+      ? volatilityTermSlope({ years: expiry.years, volatility: expiry.skew.atm }, { years: next.years, volatility: next.skew.atm }) : null };
   });
 }
 
@@ -593,8 +613,10 @@ export function buildSurfaceGrid(snapshot: SurfaceSnapshot, options: SurfaceGrid
           : axis === "strike" ? coordinate : deltaNeutralStrike(targetForward, tenor.years, (k) => at(k)?.volatility ?? null);
         if (strike === null) return unavailable();
         if (axis === "delta" && coordinate !== 0) {
-          let low = Math.min(...available.map((expiry) => expiry.points[0]!.logMoneyness));
-          let high = Math.max(...available.map((expiry) => expiry.points.at(-1)!.logMoneyness));
+          // The quoted strikes against each expiry's forward as it is now, the one its smile is read on: a report's
+          // forward is rounded after the points were placed, and the stored log-moneyness would land past the quotes.
+          let low = Math.min(...available.map((expiry) => logForwardMoneyness(expiry.points[0]!.strike, expiry.forward!)!));
+          let high = Math.max(...available.map((expiry) => logForwardMoneyness(expiry.points.at(-1)!.strike, expiry.forward!)!));
           const delta = (k: number) => {
             const value = at(k);
             return value == null ? null : optionDelta({ spot: snapshot.spot, years: tenor.years,

package/src/plugins/builtin/vol-surface/pane.tsx

@@ -39,7 +39,7 @@ import { VolatilitySurface } from "./surface";
 import { SmileChart, TermChart } from "./charts";
 import { surfaceCoordinateLabel } from "./headless";
 import { expiryLabel, formatIv, formatPrice, formatVolPoints, HIDDEN_SLOPE_TEXT, HIDDEN_YIELD_TEXT, selectSurfaceExpiry, surfaceForwardRow,
-  surfaceSkewRow } from "./tables";
+  surfaceSkewRow, surfaceSpotBasisLabel } from "./tables";
 import { findListedExpiry, unlistedExpiryText } from "../../../utils/option-expiry";
 
 const TABS = [
@@ -95,17 +95,19 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   const spotAvailable = !!quote && quote.price > 0 && Number.isFinite(quote.price) && !quote.stale;
   const spotAsOfRef = useRef(quote?.lastUpdated ?? null);
   spotAsOfRef.current = quote?.lastUpdated ?? null;
-  const spotRef = useRef(quote?.price ?? 0);
-  spotRef.current = quote?.price ?? 0;
+  const quoteRef = useRef(quote ?? null);
+  quoteRef.current = quote ?? null;
   const requestKey = JSON.stringify([target?.cacheKey, symbol, axis, tenors, ivSource, priceSide, spread, age, limit, spotAvailable, requestedExpiration]);
   // Every load reads the spot at the moment it starts; a reload in session
   // therefore uses the current stream price, not the one from the first load.
+  // A chain from a closed session is priced at that session's close, which
+  // the quote carries, so a pre-market print does not move it.
   const surfaceRequest = useCallback((force: boolean, signal: AbortSignal): SurfaceLoadRequest => {
     const instrument = target?.instrument;
     return {
       instrument: { symbol: target?.effectiveTicker ?? symbol!, exchange: target?.effectiveExchange ?? "",
         brokerId: instrument?.brokerId, brokerInstanceId: instrument?.brokerInstanceId, instrument },
-      spot: spotRef.current, spotAsOf: spotAsOfRef.current, limit, forceRefresh: force, signal,
+      spot: quoteRef.current?.price ?? 0, spotAsOf: spotAsOfRef.current, quote: quoteRef.current, limit, forceRefresh: force, signal,
       requiredExpiries: expirationRef.current == null ? [] : [expirationRef.current],
       settings: { ...DEFAULT_SURFACE_SETTINGS, ivSource, priceSide, maxRelativeSpread: Number(spread), maxStaleSessions: Number(age) },
     };
@@ -153,6 +155,14 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   const underlying = (target?.effectiveTicker ?? symbol ?? "").toUpperCase();
   const datesLoader = useCallback(async () => (await loadSurfaceDates(underlying)).dates, [underlying]);
   const dates = useAsyncResource(underlying ? datesLoader : null);
+  // A symbol with no current price, or no option chain at all, says what became of it when something
+  // did, as `quote` says it: TWTR stopped trading, FB is a fund now and Meta trades as META.
+  const noChain = !historyDate && !!quote && (!spotAvailable
+    || (!!resource.data && !resource.loading && resource.data.catalogue.length === 0));
+  const fateExchange = target?.effectiveExchange ?? "";
+  const fateLoader = useCallback(async () => (await getSharedMarketDataCoordinator()
+    ?.loadListingFate({ symbol: underlying, exchange: fateExchange }))?.note ?? null, [underlying, fateExchange]);
+  const fateNote = useAsyncResource(underlying && noChain ? fateLoader : null).data ?? null;
   const ivRank = useIvRank(underlying || null);
   useEffect(() => () => controller.current?.abort(), [request]);
   const incremental = partial?.key === requestKey ? partial.snapshot : null;
@@ -229,6 +239,11 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   const nearestRow = (years: number | undefined) => years == null || !denseGrid?.tenors.length ? -1
     : denseGrid.tenors.reduce((best, value, index) => Math.abs(value - years) < Math.abs(denseGrid.tenors[best]! - years) ? index : best, 0);
   const selectedExpiry = snapshot ? selectSurfaceExpiry(snapshot, expiration) : null;
+  // Another date loads under the query bar, which keeps the last surface's expiries until it answers.
+  const lastShown = useRef<{ underlying: string; snapshot: DatedSurfaceSnapshot } | null>(null);
+  if (snapshot) lastShown.current = { underlying, snapshot };
+  const barSnapshot = snapshot ?? (lastShown.current?.underlying === underlying ? lastShown.current.snapshot : null);
+  const barExpiry = barSnapshot ? selectSurfaceExpiry(barSnapshot, expiration) : null;
   const openChain = useCallback(() => {
     if (!snapshot) return;
     const selected = pinned ?? selectedExpiry?.expiration;
@@ -334,7 +349,7 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   for (const entry of snapshot?.expiries ?? []) {
     for (const warning of entry.warnings) expiryWarnings.set(warning, [...expiryWarnings.get(warning) ?? [], entry.expiration]);
   }
-  const notices = [...(snapshot?.warnings ?? []).filter((warning) => !expiryWarnings.has(warning)), ...failures,
+  const notices = fateNote ? [] : [...(snapshot?.warnings ?? []).filter((warning) => !expiryWarnings.has(warning)), ...failures,
     ...(activeTab === "surface" && sheet?.omitted.length ? [`3D sheet omits ${sheet.omitted.map((entry) => expiryLabel(entry.expiration)).join(", ")}: smile fit fell back to interpolation (shown in Table)`] : []),
     ...[...expiryWarnings].map(([warning, expirations]) => `${expirations.length > 1 && expirations.length === snapshot?.expiries.length
       ? "All expiries" : expirations.map(expiryLabel).join(", ")}: ${warning}`),
@@ -345,6 +360,7 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
       && !snapshot.failures.some((failure) => failure.expiration === pinned)
       ? [`${expiryLabel(pinned)}: ${unlistedExpiryText(pinned, snapshot.catalogue)}`] : []),
     ...(active.error ? [active.error] : [])];
+  const spotBasis = snapshot && !snapshot.stored ? surfaceSpotBasisLabel(snapshot) : null;
   // What the quotes are and when they were observed; a reload moves the time.
   const freshness = !snapshot ? null : snapshot.stored ? `stored close ${snapshot.stored.sessionDate}`
     : surfaceFreshnessLabel(snapshot, CLOUD_QUOTE_DELAY_MINUTES);
@@ -447,24 +463,28 @@ export function VolSurfacePane({ focused, width, height }: PaneProps) {
   useEffect(() => setTableOnScreen(tableShown), [tableShown]);
   return <Box flexDirection="column" width={width} overflow="hidden" {...(nativePaneChrome ? FILL_REST : { height })}>
     {tabStrip}
-    {!symbol ? <EmptyState title="Choose an underlying ticker." /> : <PaneStatusBody loading={active.loading && !snapshot}
-      error={!snapshot ? active.error : null} empty={!snapshot && !active.loading} subject="volatility surface">
-      <QueryBar width={width}
+    {!symbol ? <EmptyState title="Choose an underlying ticker." /> : <>
+      {barSnapshot ? <QueryBar width={width}
         filters={[
-          { id: "expiry", label: "Expiry", value: String(pinned ?? selectedExpiry?.expiration ?? ""),
-            options: snapshot?.catalogue.map((value) => ({ value: String(value), label: expiryLabel(value) })) ?? [],
+          { id: "expiry", label: "Expiry", value: String(pinned ?? barExpiry?.expiration ?? ""),
+            options: barSnapshot.catalogue.map((value) => ({ value: String(value), label: expiryLabel(value) })),
             onChange: (value: string) => setExpiration(Number(value)) },
           ...(storedDates.length ? [{ id: "date", label: "Date", value: shownDate ?? "", defaultValue: "",
             options: [{ value: "", label: "Live" }, ...storedDates.map((date) => ({ value: date, label: date }))],
             onChange: (value: string) => setHistoryDate(value || null) }] : []),
         ]}
-        meta={snapshot?.stored
+        meta={!snapshot ? undefined : snapshot.stored
           ? `Stored close · spot ${formatPrice(snapshot.spot)} · captured ${formatCaptureTime(snapshot.stored.capturedAt)} New York`
-          : [`Spot ${formatPrice(snapshot?.spot)}${quote?.currency ? ` ${quote.currency}` : ""}`, selectedExpiry?.asOf?.slice(0, 10)].filter(Boolean).join(" · ")} />
+          : [`Spot ${formatPrice(snapshot.spot)}${quote?.currency ? ` ${quote.currency}` : ""}`,
+            // The close a closed session's chain is priced at dates the chain too.
+            spotBasis, snapshot.spotBasis?.basis === "close" ? null : selectedExpiry?.asOf?.slice(0, 10)].filter(Boolean).join(" · ")} /> : null}
+      <PaneStatusBody loading={active.loading && !snapshot && !fateNote}
+      error={!snapshot && !fateNote ? active.error : null} empty={!!fateNote || !snapshot && !active.loading}
+      emptyTitle={fateNote ?? undefined} subject="volatility surface">
       <StatGrid items={ivStats} width={width} />
       {/* The terminal sizes the view in the rows under the bar and figures; the desktop fills what is left. */}
       {nativePaneChrome ? <Box flexDirection="column" overflow="hidden" {...FILL_REST}>{content}</Box> : content}
-    </PaneStatusBody>}
+    </PaneStatusBody></>}
   </Box>;
 }
 

package/src/plugins/builtin/vol-surface/stored.ts

@@ -3,7 +3,10 @@ import { logForwardMoneyness, type ExpectedMove, type SkewMetrics, type SmileFit
 import { ivSymbol, loadStoredSurface, loadSurfaceDates, type ImpliedVolatilityApi, type StoredSurfacePayload } from "../iv-history/client";
 import { ApiRequestError } from "../../../api-client/errors";
 import { CLOUD_QUOTE_DELAY_MINUTES } from "../../../api-client/plan-rules";
-import { evaluateSurfaceSmile, normalizeSurfaceSettings, type SurfaceExpiry, type SurfaceFilterCounts, type SurfaceSnapshot } from "./model";
+import {
+  evaluateSurfaceSmile, normalizeSurfaceSettings, surfaceExpirySkew, withSurfaceTermSlopes,
+  type SurfaceExpiry, type SurfaceFilterCounts, type SurfaceSnapshot,
+} from "./model";
 import { isFiniteNumber } from "../../../utils/guards";
 import { dateOptionError, readCalendarDate } from "../../../utils/calendar-date";
 
@@ -63,6 +66,10 @@ function storedExpiry(entry: StoredExpiry, spot: number, capturedAt: number, sou
   }
   expiry.points.sort((a, b) => a.strike - b.strike);
   for (const point of expiry.points) point.fitResidual = point.volatility - (evaluateSurfaceSmile(expiry, point.strike) ?? point.volatility);
+  // The skew is read off the stored fit as the live surface reads it, not taken as stored: a capture
+  // that searched the far wings for its 25-delta strikes left a quoted monthly blank, and an older one
+  // measured its fly from the spot.
+  if (expiry.fit) expiry.skew = surfaceExpirySkew(expiry, spot);
   return expiry;
 }
 
@@ -120,13 +127,37 @@ export async function loadDatedSurface(symbol: string, date: string, options: {
   throw new Error(storedSurfaceMiss(bare, date, dates.value.dates));
 }
 
+/** A figure to the decimals a stored close keeps it at. */
+const toDecimals = (value: number | null, digits: number) => value == null || !Number.isFinite(value) ? null : Number(value.toFixed(digits));
+
+/**
+ * A live surface at the precision a stored close keeps its figures (the
+ * platform's compact capture: years to 8 decimals, forwards and mids to 4,
+ * rates, yields, IVs and the term slope to 6), so a report of the live chain
+ * and one of a stored close (`--date`) export the same digits. The fit and
+ * the skew are kept whole, as a capture keeps them; residuals are measured
+ * again from the rounded IVs, as a stored close measures them.
+ */
+export function atCapturePrecision(snapshot: SurfaceSnapshot): SurfaceSnapshot {
+  return { ...snapshot, expiries: snapshot.expiries.map((expiry) => {
+    const rounded: SurfaceExpiry = { ...expiry, years: toDecimals(expiry.years, 8) ?? expiry.years, rate: toDecimals(expiry.rate, 6),
+      forward: toDecimals(expiry.forward, 4), dividendYield: toDecimals(expiry.dividendYield, 6), atmIV: toDecimals(expiry.atmIV, 6),
+      termSlope: toDecimals(expiry.termSlope, 6),
+      points: expiry.points.map((point) => ({ ...point, volatility: toDecimals(point.volatility, 6) ?? point.volatility, mid: toDecimals(point.mid, 4) ?? point.mid })) };
+    for (const point of rounded.points) {
+      if (point.fitResidual != null) point.fitResidual = point.volatility - (evaluateSurfaceSmile(rounded, point.strike) ?? point.volatility);
+    }
+    return rounded;
+  }) };
+}
+
 /** A stored close surface in the shape the live OVDV views render: mid quotes, recomputed IV. */
 export function storedSurfaceSnapshot(payload: StoredSurfacePayload): DatedSurfaceSnapshot {
   const surface = payload.surface as unknown as StoredSurface;
   if (!surface || surface.version !== 1 || !Array.isArray(surface.expiries)) throw new Error("Unsupported stored surface format");
   const capturedAt = Date.parse(payload.capturedAt);
-  const expiries = surface.expiries.map((entry) => storedExpiry(entry, payload.spot, capturedAt, surface.source))
-    .filter((entry) => entry.points.length > 0).sort((a, b) => a.expiration - b.expiration);
+  const expiries = withSurfaceTermSlopes(surface.expiries.map((entry) => storedExpiry(entry, payload.spot, capturedAt, surface.source))
+    .filter((entry) => entry.points.length > 0));
   const rateDates = expiries.flatMap((entry) => entry.rateAsOf).sort();
   return {
     symbol: payload.symbol, spot: payload.spot, spotAsOf: surface.spotAsOf ?? payload.capturedAt, phase: "ready",

package/src/plugins/builtin/vol-surface/tables.ts

@@ -1,10 +1,24 @@
 import { findListedExpiry } from "../../../utils/option-expiry";
 import { evaluateSurfaceSmile, type SurfaceExpiry, type SurfaceSnapshot } from "./model";
+import { modelSpotStamp } from "../options/model-spot";
 
 export const formatIv = (value: number | null | undefined) => value == null || !Number.isFinite(value) ? "--" : `${(value * 100).toFixed(2)}%`;
 export const formatPrice = (value: number | null | undefined) => value == null || !Number.isFinite(value) ? "--" : value.toFixed(2);
 export const expiryLabel = (expiration: number) => new Date(expiration * 1000).toISOString().slice(0, 10);
 
+/**
+ * The shared stamp for the spot a surface was fitted at (`modelSpotStamp`):
+ * `close Mon 19 Oct` for the official close of the session a closed chain was
+ * quoted in, `pre-market Tue 20 Oct 12:21 UTC` for an extended-session print.
+ * Null for the regular session's price or a bare spot.
+ */
+export function surfaceSpotBasisLabel(snapshot: Pick<SurfaceSnapshot, "spotBasis" | "spotAsOf">): string | null {
+  const basis = snapshot.spotBasis;
+  if (!basis) return null;
+  const observedAt = typeof snapshot.spotAsOf === "number" ? snapshot.spotAsOf : Date.parse(String(snapshot.spotAsOf));
+  return modelSpotStamp({ basis: basis.basis, session: basis.session, observedAt });
+}
+
 /** A one-day front expiry is the noisiest smile on the board; the default selection is the first at least four weeks out. */
 const DEFAULT_EXPIRY_MIN_DAYS = 28;
 /** Annualising a few days of parity carry produces meaningless yields. */

package/src/plugins/builtin/volatility/model.ts

@@ -1,3 +1,4 @@
+import { PERIOD_BASE_MAX_GAP_DAYS, periodBaseDay } from "../../../market-data/market/period-return";
 import type { CloudFredObservationPayload, CloudFredSeriesInfoPayload } from "../../../api-client";
 import type { PricePoint } from "../../../types/financials";
 import { VOLATILITY_CURVE_INDICES, VOLATILITY_INDICES } from "../shared/volatility-indices";
@@ -354,21 +355,15 @@ export interface VolatilityCurveLookback {
   values: Partial<Record<string, number>>;
 }
 
-/** A week back is seven calendar days; a month back is the same day of the previous month, or its last day. */
+/** A week back is seven calendar days; a month back is the same day of the previous month, or its last day (periodBaseDay). */
 export function volatilityLookbackDate(date: string, id: VolatilityLookbackId): string {
-  if (id === "1W") return new Date(Date.parse(date) - 7 * DAY_MS).toISOString().slice(0, 10);
-  const target = new Date(`${date}T00:00:00.000Z`);
-  const day = target.getUTCDate();
-  target.setUTCDate(1);
-  target.setUTCMonth(target.getUTCMonth() - 1);
-  target.setUTCDate(Math.min(day, new Date(Date.UTC(target.getUTCFullYear(), target.getUTCMonth() + 1, 0)).getUTCDate()));
-  return target.toISOString().slice(0, 10);
+  return periodBaseDay(date, id);
 }
 
 /**
  * The curve a week and a month before its date, read from the same daily
  * histories and aligned the same way: the last date on or before the look-back
- * where the 30D and 3M both closed, else where two tenors did, within ten days.
+ * where the 30D and 3M both closed, else where two tenors did, within a market closure of it (PERIOD_BASE_MAX_GAP_DAYS).
  * A tenor without a close on that date is a gap, never a neighbouring day.
  */
 export function volatilityCurveLookbacks(data: Pick<VolatilityData, "curve" | "board" | "fred">): VolatilityCurveLookback[] {
@@ -382,7 +377,7 @@ export function volatilityCurveLookbacks(data: Pick<VolatilityData, "curve" | "b
   }));
   return (["1W", "1M"] as const).map((id) => {
     const target = volatilityLookbackDate(curve.date!, id);
-    const floor = new Date(Date.parse(target) - 10 * DAY_MS).toISOString().slice(0, 10);
+    const floor = new Date(Date.parse(target) - PERIOD_BASE_MAX_GAP_DAYS * DAY_MS).toISOString().slice(0, 10);
     const counts = new Map<string, number>();
     for (const history of histories.values()) for (const day of history.keys()) {
       if (day >= floor && day <= target) counts.set(day, (counts.get(day) ?? 0) + 1);

package/src/plugins/builtin/world-venue-map/basemap-layer.tsx

@@ -1,3 +1,4 @@
+import { logFailure } from "../../../utils/log-failure";
 /**
  * The land under the desktop and web map: a quiet fill, 1 px coastlines and
  * fainter borders, at 1:50m for the world and 1:10m for the tiles in view once
@@ -67,7 +68,7 @@ function useWorldPaths(): BasemapPaths | null {
     let current = true;
     loadWorldBasemap().then((loaded) => {
       if (current) setPaths(loaded);
-    }, () => {});
+    }, logFailure("world-venue-map.basemap", "Load world basemap failed"));
     return () => {
       current = false;
     };
@@ -83,7 +84,7 @@ function useDetailTiles(active: boolean, view: GeoBox): { tiles: DetailTile[]; l
     let current = true;
     loadDetailIndex().then((tiles) => {
       if (current) setIndex(tiles);
-    }, () => {});
+    }, logFailure("world-venue-map.basemap", "Load detail tile index failed"));
     return () => {
       current = false;
     };
@@ -105,7 +106,7 @@ function useDetailTiles(active: boolean, view: GeoBox): { tiles: DetailTile[]; l
           while (next.size > TILE_CACHE_SIZE) next.delete(next.keys().next().value!);
           return next;
         });
-      }, () => {});
+      }, logFailure("world-venue-map.basemap", "Load detail tile failed"));
     }
     return () => {
       current = false;

package/src/plugins/builtin/world-venue-map/basemap.ts

@@ -221,7 +221,9 @@ export function loadDetailTile(tile: DetailTile): Promise<BasemapPaths> {
   const pending = tile.load()
     .then((chunk) => {
       const decoded = decodeQueue.then(nextTask).then(() => basemapPaths(chunk, tile.box));
-      decodeQueue = decoded.catch(() => {});
+      decodeQueue = decoded.catch(() => {
+        // Intentional ignore: keep the decode queue usable; the returned decoded promise still rejects to the tile caller.
+      });
       return decoded;
     })
     .catch((error: unknown) => {

package/src/plugins/builtin/world-venue-map/chokepoint-chart.ts

@@ -0,0 +1,40 @@
+import type { GeoRequest } from "../../../api-client/geo";
+import { SERIES_COLORS } from "../../../theme/series-colors";
+import type { PaneTemplateInstanceConfig } from "../../../types/plugin";
+import { buildCustomChartPreset } from "../chart-composer/presets";
+import { formatGeoSeriesExpression } from "../chart-composer/series-expression";
+import { chokepointSeriesFor, chokepointSeriesIds, chokepointShortName, KEY_CHOKEPOINTS, unknownChokepointMessage } from "./geo-series";
+
+const CHOKE_SERIES_LIMIT = 6;
+
+/**
+ * CHOKE's chart: the key straits' daily transits together, or the one the
+ * argument names. Text that names no strait (a ticker) is told which do, as
+ * COT and PSD tell an unknown market or crop, rather than charting nothing.
+ */
+export async function createChokepointInstance(request: GeoRequest, arg?: string): Promise<PaneTemplateInstanceConfig> {
+  const typed = arg?.trim();
+  const named = typed ? await chokepointSeriesFor(request, typed) : null;
+  if (typed && !named) throw new Error(unknownChokepointMessage(typed));
+  const ids = named
+    ? [named]
+    // Without the series index, CHOKE still asks for the key straits by name.
+    : await chokepointSeriesIds(request).then((found) => (found.length ? found : KEY_CHOKEPOINTS)).catch(() => KEY_CHOKEPOINTS);
+  const charted = ids.slice(0, CHOKE_SERIES_LIMIT);
+  const base = buildCustomChartPreset(charted.map(formatGeoSeriesExpression).join(", "));
+  // Daily transits read best over a year, each strait in its own colour. Six together
+  // take short names so the legend shows each whole; one strait keeps the index's full name.
+  const spec = {
+    ...base,
+    viewport: { ...base.viewport, range: "1Y" as const },
+    series: base.series.map((series, index) => {
+      const label = named ? undefined : chokepointShortName(charted[index] ?? "");
+      return { ...series, color: series.color ?? SERIES_COLORS[index % SERIES_COLORS.length]!, ...(label ? { label } : {}) };
+    }),
+  };
+  return {
+    title: named ? `G ${named} transits` : "G Chokepoint transits",
+    placement: "floating",
+    settings: { chartSpec: spec },
+  };
+}

package/src/plugins/builtin/world-venue-map/evidence.ts

@@ -1,5 +1,5 @@
 /**
- * What `gloomberb shot MAP <layers>` certifies: the layers the map drew and
+ * What `gloom shot MAP <layers>` certifies: the layers the map drew and
  * what each held, so a capture taken before the features arrived is refused.
  */
 import type { PaneScreenshotEvidenceHook } from "../../../cli/pane-functions/screenshot-evidence";