gloomberb 0.18.2 → 0.18.3

package/src/plugins/builtin/sectors/client.ts

@@ -1,5 +1,6 @@
 import type { DataProvider } from "../../../types/data-provider";
 import type { PricePoint, Quote } from "../../../types/financials";
+import { logFailure } from "../../../utils/log-failure";
 import type { SectorDef } from "./sector-data";
 import { getCompletedRegularSessionDisplay, getRegularSessionDisplay } from "../../../market-data/market/status";
 import {
@@ -26,7 +27,7 @@ export async function loadSectorRows(
   if (provider.getQuotesBatch) {
     const results = await provider.getQuotesBatch(
       sectors.map((sector) => ({ symbol: sector.etf, exchange: "" })),
-    ).catch(() => []);
+    ).catch(logFailure("sectors", "Sector quote batch failed", []));
     for (const result of results) quotes.set(result.target.symbol, result.quote ?? null);
   }
   // A partial batch must not silently replace a live quote with yesterday's
@@ -41,7 +42,7 @@ export async function loadSectorRows(
 
   const histories = new Map(await Promise.all(sectors.map(async (sector) => [
     sector.etf,
-    await provider.getPriceHistory(sector.etf, "", "1Y").catch(() => []),
+    await provider.getPriceHistory(sector.etf, "", "1Y").catch(logFailure("sectors", "Sector price history failed", [])),
   ] as const)));
   // The quotes as sent carry any pre-market or after-hours print, for its own column.
   const sentQuotes = new Map(quotes);
@@ -94,7 +95,7 @@ export async function loadSectorRows(
       start.setUTCDate(start.getUTCDate() - 7);
       const end = new Date(`${asOfDate}T00:00:00Z`);
       end.setUTCDate(end.getUTCDate() + 1);
-      const extended = await provider.getDetailedPriceHistory(sector.etf, "", start, end, "1d").catch(() => []);
+      const extended = await provider.getDetailedPriceHistory(sector.etf, "", start, end, "1d").catch(logFailure("sectors", "Sector extended price history failed", []));
       if (extended.length > 0) {
         history = [...history, ...extended];
         histories.set(sector.etf, history);

package/src/plugins/builtin/shared/cloud-resource.ts

@@ -31,18 +31,31 @@ export function cachedCloudResource<T>(
   }
 }
 
+const isAbort = (error: unknown) => !!error && typeof error === "object" && (error as { name?: unknown }).name === "AbortError";
+
 /**
  * Loads through the cache, falling back to the cached copy when a refresh
  * fails. A refused session still throws, so the pane shows its sign-in wall
  * instead of data the account can no longer see.
+ *
+ * Callers of one key share the request in flight, which runs on the first
+ * caller's `signal`. When that caller goes away (a tab left while it loads,
+ * for one that reads the same data), the shared request aborts; a caller
+ * whose own `signal` is still live asks again instead of showing that
+ * cancellation as its failure.
  */
 export async function loadCloudResource<T>(
   cache: CloudCache<T>,
   key: string,
   fetch: () => Promise<T>,
-  { force = false, validate = (payload: T) => payload }: { force?: boolean; validate?: (payload: T) => T } = {},
+  { force = false, validate = (payload: T) => payload, signal }: { force?: boolean; validate?: (payload: T) => T; signal?: AbortSignal } = {},
 ): Promise<CloudResource<T>> {
-  const result = await cache.load(key, fetch, { force });
+  const cancelledByOther = (error: unknown) => !!signal && !signal.aborted && isAbort(error);
+  let result = await cache.load(key, fetch, { force }).catch((error: unknown) => {
+    if (cancelledByOther(error)) return null;
+    throw error;
+  });
+  if (!result || cancelledByOther(result.error)) result = await cache.load(key, fetch, { force });
   if (isAccessDenied(result.error)) throw result.error;
   return { payload: validate(result.data), stale: result.stale, refreshError: result.refreshError ?? null };
 }

package/src/plugins/builtin/shared/research-trading.tsx

@@ -25,6 +25,8 @@ export interface ResearchTrading extends ResearchTradeProjection {
   /** Opens the ticket; without a side it keeps its draft, and Buy or Sell is chosen in it. */
   open(side?: "BUY" | "SELL"): void;
   close(): void;
+  /** A press on the chart takes the keyboard back from the ticket, even a field typing in it. */
+  focusChart?(): void;
   /** This ticker's working orders and latest fills, for Overview; absent without a trading profile. */
   orders?(width: number): ReactNode;
   publish(projection: ResearchTradeProjection): void;

package/src/plugins/builtin/shared/series-list-detail.tsx

@@ -141,8 +141,9 @@ export function SeriesListDetail<Row, Column extends DataTableColumn, R extends
   isNavigable,
   renderSectionHeader,
   emptyStateTitle,
+  status,
   renderDetail,
-}: Pick<DataTableViewProps<Row, Column>, "renderCell" | "isNavigable" | "renderSectionHeader" | "emptyStateTitle"> & {
+}: Pick<DataTableViewProps<Row, Column>, "renderCell" | "isNavigable" | "renderSectionHeader" | "emptyStateTitle" | "status"> & {
   list: ReturnType<typeof useSeriesList<unknown, R>>;
   width: number;
   height: number;
@@ -206,6 +207,7 @@ export function SeriesListDetail<Row, Column extends DataTableColumn, R extends
               renderCell={renderCell}
               renderSectionHeader={renderSectionHeader}
               emptyStateTitle={emptyStateTitle}
+              status={status}
             />
           </Box>
         </Box>

package/src/plugins/builtin/shared/volatility/options.ts

@@ -192,10 +192,11 @@ export function expectedMove(
     sigmaPercent: sigma != null && Number.isFinite(sigma) ? sigma / spot * 100 : null, strike: atm?.strike ?? null };
 }
 
-/** 25-delta and 90/110 skew in decimal annualized IV; OVDV reads them on each expiry's fitted smile. */
+/** 25-delta and 90/110 skew in decimal annualized IV; OVDV reads them on each expiry's fitted smile, from its forward. */
 export interface SkewMetrics {
   put25: number | null;
   call25: number | null;
+  /** IV at the forward (ATMF): the butterfly and the term slope are measured from it. */
   atm: number | null;
   putCallSkew: number | null;
   riskReversal: number | null;

package/src/plugins/builtin/social-mentions/client.ts

@@ -1,3 +1,4 @@
+import { unavailableText } from "../../../components/ui/status";
 import { apiClient } from "../../../api-client";
 import { ApiRequestError, isAccessDenied } from "../../../api-client/errors";
 import type { SocialMentionDayPosts, SocialMentionPost, SocialMentionsPayload, SocialMentionsRange } from "../../../api-client/social-mentions";
@@ -56,7 +57,7 @@ export async function fetchSocialMentions(symbol: string, range: SocialMentionsR
   client: Pick<typeof apiClient, "getCloudSocialMentions"> = apiClient): Promise<SocialMentionsPayload> {
   try { return validateSocialMentions(await client.getCloudSocialMentions(symbol, range), symbol, range); }
   catch (error) {
-    if (error instanceof ApiRequestError && error.status === 404) throw new Error("Social mentions are not available yet");
+    if (error instanceof ApiRequestError && error.status === 404) throw new Error(unavailableText("social mentions"));
     throw error;
   }
 }

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

@@ -3,7 +3,7 @@ import { getSharedMarketDataCoordinator, MarketDataCoordinator, resolveEntryValu
 import type { InstrumentRef, OptionsRequest } from "../../../market-data/request-types";
 import type { QueryEntry } from "../../../market-data/result-types";
 import type { DataProvider } from "../../../types/data-provider";
-import type { OptionsChain } from "../../../types/financials";
+import type { OptionsChain, Quote } from "../../../types/financials";
 import { daysToExpiryFrom } from "../shared/volatility";
 import type { YieldPoint } from "../yield-curve/treasury-data";
 import {
@@ -13,6 +13,7 @@ import {
 import { abortable, abortError } from "../../../utils/async-deadline";
 import { errorMessage } from "../../../utils/errors";
 import { findListedExpiry, unlistedExpiryText } from "../../../utils/option-expiry";
+import { optionModelSpot } from "../options/model-spot";
 
 const DEFAULT_SURFACE_EXPIRY_LIMIT = 18;
 const SURFACE_LOAD_CONCURRENCY = 4;
@@ -91,6 +92,14 @@ export interface SurfaceLoadRequest {
   instrument: InstrumentRef;
   spot: number;
   spotAsOf?: string | number | null;
+  /**
+   * The underlying's quote, to read the spot from as OMON reads it
+   * (`optionModelSpot`): a chain from a closed session is priced at that
+   * session's official close, which the quote carries, so the same chain
+   * gives the same surface whatever trades before the next open. Without
+   * it, or without a chain to date, `spot` is used as given.
+   */
+  quote?: Quote | null;
   settings?: Partial<SurfaceSettings>;
   limit?: number;
   /** Listed expiries required by a selection, added to the representative sample. */
@@ -134,6 +143,9 @@ export async function loadVolatilitySurface(
   let catalogueExpiration: number | null = null;
   let treasuryError: string | null = null;
   let finished = false;
+  let spot = request.spot;
+  let spotAsOf = request.spotAsOf ?? null;
+  let spotBasis: SurfaceSnapshot["spotBasis"] = null;
   const checkAbort = () => { if (request.signal?.aborted) throw abortError(CANCELLED); };
   const snapshot = (): SurfaceSnapshot => {
     const failures: SurfaceFailure[] = [];
@@ -152,7 +164,7 @@ export async function loadVolatilitySurface(
       }
       const cached = models.get(expiration);
       if (cached?.entry === entry && cached.curve === curve) return cached.value;
-      const value = buildSurfaceExpiry({ chain, expiration, spot: request.spot, curve, settings, now,
+      const value = buildSurfaceExpiry({ chain, expiration, spot, curve, settings, now,
         source: entry.source, stale: !!entry.error || (entry.staleAt != null && entry.staleAt <= now), error });
       models.set(expiration, { entry, curve, value });
       return value;
@@ -166,7 +178,7 @@ export async function loadVolatilitySurface(
       : failures.length > 0 ? (ready ? "partial" : "error") : "ready";
     const dates = [...new Set(expiries.flatMap((expiry) => expiry.rateAsOf))];
     return {
-      symbol, spot: request.spot, spotAsOf: request.spotAsOf ?? null, phase, settings, catalogue: [...catalogue],
+      symbol, spot, spotAsOf, ...spotBasis ? { spotBasis } : {}, phase, settings, catalogue: [...catalogue],
       requested: selected.length, loaded, failed, expiries, failures,
       warnings: [...new Set([...expiries.flatMap((expiry) => expiry.warnings), ...surfaceCalendarWarnings(expiries)])],
       rateAsOf: dates.length === 1 ? dates[0]! : null, fetchedAt: now,
@@ -190,6 +202,14 @@ export async function loadVolatilitySurface(
       { forceRefresh: request.expiries ? false : request.forceRefresh }), request.signal, CANCELLED);
     checkAbort();
     const chain = resolveEntryValue(initial);
+    // Every expiry is valued at one spot, read against the catalogue chain's time before any expiry is fitted.
+    const modelSpot = request.quote ? optionModelSpot(request.quote, chain, now, request.instrument.exchange) : null;
+    if (modelSpot) {
+      spot = modelSpot.price;
+      spotAsOf = modelSpot.observedAt;
+      spotBasis = { basis: modelSpot.basis, session: modelSpot.session,
+        sessionDate: modelSpot.basis === "close" ? request.quote!.regularCloseSessionDate ?? null : null };
+    }
     const initialContracts = chain ? [...chain.calls, ...chain.puts] : [];
     const representedExpiry = initialContracts[0]?.expiration;
     if (representedExpiry != null && initialContracts.every((contract) => contract.expiration === representedExpiry)

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

@@ -4,14 +4,15 @@ import {
   expirationOptionSeconds, findListedExpiry, 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 +27,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 +133,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 +156,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 +165,35 @@ 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)));
     }
+    const available = snapshot.expiries.some((expiry) => expiry.fit);
+    const loadErrors = snapshot.failures.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 +214,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 };
   });
 }
 

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/renderers/dom/desktop/controls.tsx

@@ -670,7 +670,7 @@ export function WebPageStackView({
   return (
     <Box flexDirection="column" flexGrow={1} flexShrink={1} flexBasis={0} minWidth={0} minHeight={0} overflow="hidden">
       {!headerAttached && (
-        <div className="gloom-stack-bar" data-gloom-role="page-stack-header">
+        <div className="gloom-stack-bar" data-gloom-role="page-stack-header" data-gloom-top-surface="">
           <button
             type="button"
             className="gloom-stack-back"

package/src/renderers/dom/desktop/query-bar.tsx

@@ -290,6 +290,8 @@ export function WebQueryBar({ search, items, view, onClearAll, meta, leading, op
       ref={rootRef}
       className="gloom-qb"
       data-gloom-role="query-bar"
+      // The active title-bar tab above takes this band's colour (top-surface.ts).
+      data-gloom-top-surface=""
       // A search with nothing beside it may take the room the filters would.
       data-search-only={search && items.length === 0 && !view ? "true" : undefined}
     >