gloomberb 0.16.2 → 0.16.4

package/src/plugins/builtin/shared/headless-market-data.ts

@@ -1,12 +1,44 @@
+import type { IssuerListingParams } from "../../../api-client/paths";
+import type { DataProvider } from "../../../types/data-provider";
 import type { HeadlessPaneContext } from "../../../types/headless";
 import type { TimeRange } from "../../../time-series/range";
 import { clipPriceHistoryToRange } from "../../../time-series/history-window";
-import { parsePublicTickerKey } from "../../../utils/exchanges";
+import { canonicalExchange, parsePublicTickerKey } from "../../../utils/exchanges";
+import { nonUsSecListingVenue } from "../../../utils/sec";
 
 export async function resolveHeadlessInstrument(ctx: HeadlessPaneContext, symbol: string) {
   return ctx.resolveInstrument ? ctx.resolveInstrument(symbol) : parsePublicTickerKey(symbol);
 }
 
+/**
+ * The venue and company an issuer lookup names for a listing abroad: the
+ * venue from the key or the saved listing, the company from the listing's own
+ * quote. A US listing or a symbol with no venue names neither.
+ */
+export async function resolveIssuerListing(
+  key: string,
+  exchange: string | undefined,
+  marketData: Pick<DataProvider, "getQuote">,
+): Promise<IssuerListingParams> {
+  const venue = nonUsSecListingVenue(key, exchange);
+  if (!venue) return {};
+  try {
+    const quote = await marketData.getQuote(parsePublicTickerKey(key).symbol, venue);
+    const quoteVenue = canonicalExchange(quote.listingExchangeName || quote.exchangeName);
+    // A quote that prices another venue names another listing's company.
+    const name = !quoteVenue || quoteVenue === venue ? quote.name?.trim() : undefined;
+    return name ? { exchange: venue, name } : { exchange: venue };
+  } catch {
+    return { exchange: venue };
+  }
+}
+
+/** `resolveIssuerListing` for a report's ticker, with the venue of the saved listing when the key has none. */
+export async function resolveHeadlessIssuerListing(ctx: HeadlessPaneContext, key: string): Promise<IssuerListingParams> {
+  const { exchange } = await resolveHeadlessInstrument(ctx, key);
+  return resolveIssuerListing(key, exchange, ctx.marketData);
+}
+
 export async function loadHeadlessFinancials(ctx: HeadlessPaneContext, key: string) {
   const { symbol, exchange } = await resolveHeadlessInstrument(ctx, key);
   return ctx.marketData.getTickerFinancials(symbol, exchange ?? "");

package/src/plugins/builtin/shared/members-menu.tsx

@@ -0,0 +1,260 @@
+import { ChoiceDialog, TextPromptDialog, usePaneMenuItems } from "../../../components";
+import { createFormCollectionActions } from "../../../components/form-modal/deps";
+import { t, tf } from "../../../i18n";
+import { usePluginAppActions } from "../../../public/react";
+import { useAppDispatch, useAppGetState, useAppSelector } from "../../../state/app/context";
+import { formatTickerListInput, MAX_TICKER_LIST_SIZE } from "../../../tickers/list";
+import type { TickerMetadata, TickerRecord } from "../../../types/ticker";
+import { useOptionalDialog, type PromptContext } from "../../../ui/dialog";
+import { canonicalExchange, publicTickerKey } from "../../../utils/exchanges";
+import { slugifyName } from "../../../utils/slugify";
+import { getSharedRegistry } from "../../registry";
+import { MAX_CORRELATION_TICKERS } from "../correlation/settings";
+import { ROTATION_LIMIT } from "../relative-rotation/model";
+import { SHORT_WATCH_LIMIT } from "../short-interest/watch-model";
+
+/** One US-listed member of a theme or fund, in the order its list shows it. */
+export interface MemberListing {
+  symbol: string;
+  name?: string | null;
+  exchange?: string | null;
+}
+
+/** The members a pane shows, and what to call them. */
+export interface MemberList {
+  /** Names the members in dialog titles: a theme's name or a fund's ticker. */
+  title: string;
+  /** The name the save dialog suggests. */
+  watchlistName: string;
+  members: readonly MemberListing[];
+  /** A search narrowing the list: what was typed and how many members the whole list has. */
+  search?: { query: string; total: number } | null;
+}
+
+interface MemberDestination {
+  templateId: string;
+  label: string;
+  /** The most symbols the destination takes; more would be refused or cut off there. */
+  limit: number;
+  minimum: number;
+}
+
+/**
+ * Functions that take a list of tickers through `options.symbols`. CORR and
+ * RIPL resolve the list the way the command bar does, which takes ten
+ * tickers; RIPL's own setting takes more, but not through a new pane.
+ */
+export const MEMBER_DESTINATIONS: readonly MemberDestination[] = [
+  { templateId: "relative-rotation-rrg", label: "Relative Rotation (RRG)", limit: ROTATION_LIMIT, minimum: 1 },
+  { templateId: "correlation-pane", label: "Correlation Matrix (CORR)", limit: MAX_CORRELATION_TICKERS, minimum: 2 },
+  { templateId: "short-watch-pane", label: "Short Squeeze Watch (SIW)", limit: SHORT_WATCH_LIMIT, minimum: 1 },
+  { templateId: "earnings-ripple-pane", label: "Earnings Ripple (RIPL)", limit: MAX_TICKER_LIST_SIZE, minimum: 1 },
+];
+
+/**
+ * A watchlist is a list to read and follow; a whole Russell 2000 stays in
+ * MEMB. Larger lists save their first 100 as listed.
+ */
+export const MEMBER_WATCHLIST_LIMIT = 100;
+
+/**
+ * Distinct members in list order, as `SYMBOL:EXCHANGE` when the list names the
+ * listing: CORR and RIPL resolve each one, and a bare CCJ also matches Xetra.
+ */
+export function memberSymbols(members: readonly MemberListing[]): string[] {
+  const seen = new Set<string>();
+  return members.flatMap((member) => {
+    const symbol = member.symbol.trim().toUpperCase();
+    if (!symbol || seen.has(symbol)) return [];
+    seen.add(symbol);
+    const exchange = member.exchange?.trim().toUpperCase();
+    return [exchange ? `${symbol}:${exchange}` : symbol];
+  });
+}
+
+/**
+ * What each destination would open: the first `limit` symbols as listed, or
+ * disabled below its minimum. A disabled row cannot be selected, so its reason
+ * sits beside the label rather than in the description under the list.
+ */
+export function memberDestinationChoices(symbols: readonly string[], destinations: readonly MemberDestination[]) {
+  return destinations.map((destination) => {
+    const taken = symbols.slice(0, destination.limit);
+    const tooFew = taken.length < destination.minimum;
+    return {
+      id: destination.templateId,
+      label: destination.label,
+      symbols: taken,
+      disabled: tooFew,
+      detail: tooFew ? tf("needs {count}", { count: destination.minimum }) : undefined,
+      description: tooFew ? undefined
+        : taken.length < symbols.length ? tf("First {count} of {total} as listed", { count: taken.length, total: symbols.length })
+        : tf("All {count}", { count: taken.length }),
+    };
+  });
+}
+
+/**
+ * The dialog text for `count` distinct members. A search says what it matched
+ * and how many members the whole list has, so a saved or opened subset never
+ * reads as the whole fund.
+ */
+function memberListText(list: Pick<MemberList, "title" | "search">, count: number) {
+  const query = list.search?.query.trim();
+  const search = query ? { query, total: list.search!.total } : null;
+  const saved = Math.min(count, MEMBER_WATCHLIST_LIMIT);
+  return {
+    openTitle: search ? tf("Open {title} members matching \"{query}\" in", { title: list.title, query: search.query })
+      : tf("Open {title} members in", { title: list.title }),
+    saveBody: count > MEMBER_WATCHLIST_LIMIT
+      ? search ? tf("The first {count} of the {matching} members matching \"{query}\", as listed.", { count: saved, matching: count, query: search.query })
+        : tf("The first {count} of {total} members, as listed.", { count: saved, total: count })
+      : search ? tf("{count} of {total} members match \"{query}\".", { count, total: search.total, query: search.query })
+      : tf("All {count} members.", { count }),
+  };
+}
+
+/** The requested name, numbered when a watchlist already has that name or id. */
+export function uniqueWatchlistName(requested: string, watchlists: readonly { id: string; name: string }[]): string {
+  const base = requested.trim();
+  const taken = (name: string) => watchlists.some((list) =>
+    list.name.toLowerCase() === name.toLowerCase() || list.id === slugifyName(name, "watchlist"));
+  let name = base;
+  for (let suffix = 2; taken(name); suffix += 1) name = `${base} ${suffix}`;
+  return name;
+}
+
+/**
+ * Tickers to create on the watchlist and existing ones to add to it, first
+ * `MEMBER_WATCHLIST_LIMIT` members as listed. A saved record of the same
+ * symbol on another venue (CCJ on Xetra) stays as it is: the member's listing
+ * gets its own `SYMBOL:EXCHANGE` record, the way search opens a second listing.
+ */
+export function planMemberWatchlist(
+  tickers: ReadonlyMap<string, TickerRecord>,
+  watchlistId: string,
+  members: readonly MemberListing[],
+): { create: TickerMetadata[]; update: TickerRecord[]; count: number } {
+  const seen = new Set<string>();
+  const create: TickerMetadata[] = [];
+  const update: TickerRecord[] = [];
+  for (const member of members) {
+    const symbol = member.symbol.trim().toUpperCase();
+    if (!symbol || seen.has(symbol)) continue;
+    if (seen.size >= MEMBER_WATCHLIST_LIMIT) break;
+    seen.add(symbol);
+    const exchange = member.exchange?.trim() ?? "";
+    let key = symbol;
+    let existing = tickers.get(symbol);
+    if (existing && exchange && existing.metadata.exchange
+      && canonicalExchange(existing.metadata.exchange) !== canonicalExchange(exchange)) {
+      key = publicTickerKey(symbol, exchange);
+      existing = tickers.get(key);
+    }
+    if (existing) {
+      if (!existing.metadata.watchlists.includes(watchlistId)) {
+        update.push({ ...existing, metadata: { ...existing.metadata, watchlists: [...existing.metadata.watchlists, watchlistId] } });
+      }
+      continue;
+    }
+    // Theme and fund members are US listings quoted in dollars. The sector is
+    // left to the ticker's profile, so a list never mixes two sector schemes.
+    create.push({ ticker: key, name: member.name || symbol, exchange, currency: "USD",
+      portfolios: [], watchlists: [watchlistId], positions: [], custom: {}, tags: [] });
+  }
+  return { create, update, count: seen.size };
+}
+
+/**
+ * Pane menu entries for a list of members (a theme's, a fund's): open them in
+ * RRG, CORR, SIW or RIPL, or save them as a watchlist. Functions of disabled
+ * plugins are left out; each destination gets as many as it takes.
+ */
+export function useMembersMenu(registrationId: string, list: MemberList | null) {
+  const dialog = useOptionalDialog();
+  const { createPaneFromTemplate, notify } = usePluginAppActions();
+  const dispatch = useAppDispatch();
+  const getState = useAppGetState();
+  const disabledPlugins = useAppSelector((state) => state.config.disabledPlugins);
+  usePaneMenuItems(registrationId, () => {
+    const registry = getSharedRegistry();
+    const symbols = list ? memberSymbols(list.members) : [];
+    if (!list || !symbols.length || !dialog || !registry) return null;
+    const destinations = MEMBER_DESTINATIONS.filter((destination) => (
+      registry.paneTemplates.has(destination.templateId)
+      && !registry.getDisabledPaneTemplateOwner?.(destination.templateId, disabledPlugins)
+    ));
+    const choices = memberDestinationChoices(symbols, destinations);
+    const text = memberListText(list, symbols.length);
+    const openIn = () => {
+      void dialog.prompt<string>({
+        closeOnClickOutside: true,
+        content: (context: PromptContext<string>) => <ChoiceDialog {...context} title={text.openTitle}
+          choices={choices.map(({ id, label, description, detail, disabled }) => ({ id, label: t(label), description, detail, disabled }))} />,
+      }).then((templateId) => {
+        const choice = choices.find((item) => item.id === templateId && !item.disabled);
+        // CORR and RIPL resolve `arg` like the command bar; RRG and SIW read `symbols`.
+        if (choice) createPaneFromTemplate(choice.id, { symbols: choice.symbols, arg: formatTickerListInput(choice.symbols) });
+      }).catch(() => {});
+    };
+    const saveAsWatchlist = async (requested: string) => {
+      // The writes hold the app for about a second with a hundred names; let the dialog close on screen first.
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      const name = uniqueWatchlistName(requested, getState().config.watchlists);
+      await createFormCollectionActions({ dataProvider: registry.marketData, dispatch, getState, pluginRegistry: registry,
+        tickerRepository: registry.tickerRepository }, (body, options) => {
+        if (options?.type === "error") notify({ body, type: "error" });
+      }).createWatchlist(name);
+      const watchlist = getState().config.watchlists.find((entry) => entry.name === name);
+      if (!watchlist) throw new Error(t("The watchlist was not created."));
+      const plan = planMemberWatchlist(getState().tickers, watchlist.id, list.members);
+      // One ticker that fails to save leaves the others on the list; the toast says how many made it.
+      let failed = 0;
+      const created: TickerRecord[] = [];
+      const saved: TickerRecord[] = [];
+      for (const metadata of plan.create) {
+        try {
+          const ticker = await registry.tickerRepository.createTicker(metadata);
+          created.push(ticker);
+          saved.push(ticker);
+        } catch {
+          failed += 1;
+        }
+      }
+      for (const ticker of plan.update) {
+        try {
+          await registry.tickerRepository.saveTicker(ticker);
+          saved.push(ticker);
+        } catch {
+          failed += 1;
+        }
+      }
+      // One state update for the whole list: an update per ticker redraws every pane a hundred times.
+      if (saved.length) {
+        const tickers = new Map(getState().tickers);
+        for (const ticker of saved) tickers.set(ticker.metadata.ticker, ticker);
+        dispatch({ type: "SET_TICKERS", tickers });
+      }
+      for (const ticker of created) registry.events.emit("ticker:added", { symbol: ticker.metadata.ticker, ticker });
+      notify(failed
+        ? { type: "error", body: tf("Saved {saved} of {count} members to {name}. {failed} could not be added.", { saved: plan.count - failed, count: plan.count, name, failed }) }
+        : { type: "success", body: tf("Saved {count} members to {name}.", { count: plan.count, name }) });
+    };
+    return [
+      ...(choices.length ? [{ id: "members-open-in", label: t("Open Members In…"), onSelect: openIn }] : []),
+      { id: "members-save-watchlist", label: t("Save as Watchlist…"), onSelect: () => {
+        // 54 columns fill the dialog; the prompt's default field is wider and runs past its frame.
+        void dialog.prompt<string>({
+          closeOnClickOutside: true,
+          content: (context: PromptContext<string>) => <TextPromptDialog {...context} title={t("Save as Watchlist")}
+            body={[text.saveBody]} label={t("Name")} initialValue={list.watchlistName} confirmLabel={t("Save")} width={54} />,
+        }).then((name) => {
+          if (!name?.trim()) return;
+          saveAsWatchlist(name).catch((error: unknown) => {
+            notify({ type: "error", body: error instanceof Error ? error.message : t("The watchlist was not saved.") });
+          });
+        }).catch(() => {});
+      } },
+    ];
+  }, [createPaneFromTemplate, dialog, disabledPlugins, dispatch, getState, list, notify]);
+}

package/src/plugins/builtin/shared/report-freshness.ts

@@ -1,6 +1,9 @@
 import type { HeadlessPaneFreshness } from "../../../types/headless";
 import type { Quote } from "../../../types/financials";
 import { isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
+import { delayedFeedLagMs } from "../../../market-data/market/freshness";
+import { apiClient } from "../../../api-client";
+import { CLOUD_NEWS_DELAY_HOURS, hasProAccess } from "../../../api-client/plan-rules";
 
 /**
  * Freshness declarations shared by built-in reports. Each `fn` report ends
@@ -41,17 +44,62 @@ export const REFERENCE_DATA: HeadlessPaneFreshness = { status: "not-a-feed", bas
 /** Company fundamentals, estimates and calendars: reported figures, not a feed. */
 export const REPORTED_DATA: HeadlessPaneFreshness = { status: "not-a-feed", basis: "reported data" };
 
+/** Gloom Cloud's delayed quotes run behind each venue by a lag the app knows (`delayedFeedLagMs`). */
+const CLOUD_QUOTE_PROVIDER_ID = "gloomberb-cloud";
+
+interface QuoteFreshnessFields {
+  dataSource?: "live" | "delayed";
+  stale?: boolean;
+  /** How far a delayed Gloom Cloud quote runs behind its venue's trades. */
+  delayMinutes?: number;
+  /** The venue whose sessions the quote follows, so the report can say whether its market is open. */
+  sessionExchange?: string;
+  marketState?: Quote["marketState"];
+}
+
 /**
  * The standard freshness fields of one quote, spread into a report row so the
- * report can say whether that row is live, delayed or stale for its session.
+ * report can say whether that row is live, delayed (and by how much) or stale
+ * for its session, and where its market stands.
  */
 export function quoteFreshnessFields(
   quote: Quote | null | undefined,
   now = Date.now(),
-): { dataSource?: "live" | "delayed"; stale?: boolean } {
+): QuoteFreshnessFields {
   if (!quote) return {};
+  const exchange = quote.listingExchangeName || quote.exchangeName;
+  const delayed = quote.dataSource === "delayed" && quote.providerId === CLOUD_QUOTE_PROVIDER_ID;
   return {
     ...(quote.dataSource === "live" || quote.dataSource === "delayed" ? { dataSource: quote.dataSource } : {}),
     stale: isQuoteStaleForCurrentSession(quote, now),
+    ...(delayed ? { delayMinutes: delayedFeedLagMs(exchange) / 60_000 } : {}),
+    ...(exchange ? { sessionExchange: exchange } : {}),
+    ...(quote.marketState ? { marketState: quote.marketState } : {}),
   };
 }
+
+/**
+ * Whether the Gloom Cloud session a report reads with has real-time access:
+ * no session reads as a free account; a session is asked for its plan. Null
+ * when the plan cannot be read, so the report does not guess a delay.
+ */
+export async function cloudRealtimeAccess(): Promise<boolean | null> {
+  if (!apiClient.isSignedIn()) return false;
+  try {
+    return hasProAccess(apiClient.getCurrentUser() ?? await apiClient.getSession());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Gloom Cloud news stories, dated by the newest: held back
+ * `CLOUD_NEWS_DELAY_HOURS` without real-time access, the live wire with it.
+ * The list is a history, so its last story is not stale data.
+ */
+export function cloudNewsFreshness(realtime: boolean | null): HeadlessPaneFreshness {
+  const stories: HeadlessPaneFreshness = { observedKey: "publishedAt", oldest: null };
+  if (realtime === true) return { ...stories, status: "live" };
+  if (realtime === false) return { ...stories, status: "delayed", delayMinutes: CLOUD_NEWS_DELAY_HOURS * 60 };
+  return { ...stories, status: "not-a-feed", basis: "published stories" };
+}

package/src/plugins/builtin/shared/ticker-request.ts

@@ -1,5 +1,7 @@
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import { ApiRequestError } from "../../../api-client/errors";
+import { listingAbroad, type IssuerListingParams } from "../../../api-client/paths";
+import type { TickerRecord } from "../../../types/ticker";
 import { useAsyncResource } from "../../../react/async-resource";
 import { usePaneTickerIdentity } from "../../../state/hooks/pane-ticker";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
@@ -22,6 +24,28 @@ export function listingIdentity(key: string | null | undefined, savedExchange =
   return { symbol: parsed.symbol.toUpperCase(), exchange: parsed.exchange ?? savedExchange };
 }
 
+/**
+ * The venue and company an SEC issuer read names for the pane's listing, from
+ * the pane's ticker as the SEC filings pane reads it: the key's venue, else the
+ * saved one, and the company the listing was saved as (listingAbroad). Nothing
+ * for a US listing or a symbol with no venue. A name that is only the symbol
+ * is left out, so the server falls back to the name on a quote it holds.
+ */
+function issuerListing(ticker: TickerRecord | null | undefined): IssuerListingParams {
+  if (!ticker) return {};
+  const key = ticker.metadata.ticker.trim().toUpperCase();
+  const name = ticker.metadata.name?.trim();
+  const known = !!name && ![key, parsePublicTickerKey(key).symbol].includes(name.toUpperCase());
+  const abroad = listingAbroad(key, ticker.metadata.exchange, known ? name : undefined);
+  return { exchange: abroad?.exchange, name: abroad?.name };
+}
+
+/** `issuerListing` as a stable value, for loader dependencies. */
+export function useIssuerListing(ticker: TickerRecord | null | undefined): IssuerListingParams {
+  const { exchange, name } = issuerListing(ticker);
+  return useMemo(() => ({ exchange, name }), [exchange, name]);
+}
+
 /**
  * The pane's symbol for research panes that load their own data. Identity only:
  * it does not observe the quote, so a price tick does not re-render the pane.

package/src/plugins/builtin/shared/use-quote-board.ts

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { DataTableCell, DataTableVisibleRange, PaneFooterSegment } from "../../../components";
 import { useQuoteEntries } from "../../../market-data/hooks";
-import { marketStateColor, marketStateLabel } from "../../../market-data/market/status";
+import { getRegularSessionDisplay, marketStateColor, marketStateLabel } from "../../../market-data/market/status";
 import type { InstrumentRef } from "../../../market-data/request-types";
 import type { QueryEntry } from "../../../market-data/result-types";
 import { buildQuoteKey, resolveEntryData } from "../../../market-data/selectors";
@@ -466,12 +466,31 @@ export type QuoteBoardCellKind = "status" | "price" | "change" | "changePercent"
 export interface QuoteBoardCellFormat {
   /** Spell out the session instead of a colored dot. */
   sessionText?: boolean;
-  /** Called with a finite price. */
+  /** Called with the quote at its headline: a finite price. */
   formatPrice: (quote: Quote) => string;
-  /** Called with a finite change; the text carries its sign. */
+  /** Called with the quote at its headline: a finite change; the text carries its sign. */
   formatChange: (quote: Quote) => string;
 }
 
+/** Each quote's figures as the board shows them, cached so a held quote keeps one object. */
+const boardHeadlines = new WeakMap<Quote, Quote>();
+
+/**
+ * The quote with its regular session's price and move (getRegularSessionDisplay),
+ * as `ticker` reads it: after the close its close and move, never an extended
+ * print, which a board of these columns has nowhere to show.
+ */
+export function boardHeadlineQuote(quote: Quote): Quote {
+  const cached = boardHeadlines.get(quote);
+  if (cached) return cached;
+  const display = getRegularSessionDisplay(quote);
+  const headline = !display || (display.price === quote.price && display.change === quote.change && display.changePercent === quote.changePercent)
+    ? quote
+    : { ...quote, price: display.price, change: display.change ?? Number.NaN, changePercent: display.changePercent ?? Number.NaN };
+  boardHeadlines.set(quote, headline);
+  return headline;
+}
+
 /** A row is loading while it has no quote yet, so none of its cells shows a no-data dash. */
 export function isBoardRowLoading(state: BoardQuoteState | undefined): boolean {
   return !state?.quote && (state?.loading ?? true);
@@ -482,7 +501,7 @@ export function renderQuoteBoardCell(
   state: BoardQuoteState | undefined,
   format: QuoteBoardCellFormat,
 ): DataTableCell {
-  const quote = state?.quote;
+  const quote = state?.quote ? boardHeadlineQuote(state.quote) : state?.quote;
   // One row must not mix a loading marker with a no-data marker.
   if (isBoardRowLoading(state)) return { text: kind === "status" ? "" : "…", color: colors.textDim };
 
@@ -517,7 +536,8 @@ export function renderQuoteBoardCell(
     case "time":
       return {
         text: formatQuoteTime(quote?.lastUpdated),
-        value: quote?.lastUpdated ? new Date(quote.lastUpdated).toISOString().replace(".000Z", "Z") : null,
+        // A Date, so the export writes it whole and a rendered-view report dates the board by its quotes.
+        value: quote?.lastUpdated ? new Date(quote.lastUpdated) : null,
         color: colors.textDim,
       };
   }

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

@@ -189,6 +189,7 @@ 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. */
 export interface SkewMetrics {
   put25: number | null;
   call25: number | null;
@@ -199,52 +200,6 @@ export interface SkewMetrics {
   moneynessSkew: number | null;
 }
 
-/** Smile accepts absolute strike. All differences are in decimal annualized IV. */
-export function smileSkew(input: Omit<VolatilityInputs, "volatility">, smile: (strike: number) => number | null): SkewMetrics {
-  if (!validInputs({ ...input, volatility: 1 })) {
-    return { atm: null, put25: null, call25: null, putCallSkew: null,
-      riskReversal: null, butterfly: null, moneynessSkew: null };
-  }
-  const atm = smile(input.spot);
-  const deltaVol = (side: OptionSide, target: number): number | null => {
-    if (!positive(input.spot) || !positive(input.years)) return null;
-    const center = Math.log(input.spot);
-    let radius = 1;
-    let low = center - radius;
-    let high = center + radius;
-    const at = (logStrike: number) => {
-      const strike = Math.exp(logStrike);
-      const volatility = smile(strike);
-      return volatility == null ? null : optionDelta({ ...input, volatility }, strike, side);
-    };
-    let a = at(low), b = at(high);
-    // Wide or strongly carried smiles can put a wing beyond twenty times spot.
-    // Expand until a root is bracketed; a missing smile observation stays missing.
-    for (let i = 0; i < 10 && a != null && b != null && (a < target || b > target); i += 1) {
-      radius *= 2;
-      low = center - radius;
-      high = center + radius;
-      a = at(low);
-      b = at(high);
-    }
-    if (a == null || b == null || a < target || b > target) return null;
-    for (let i = 0; i < 80; i += 1) {
-      const mid = (low + high) / 2;
-      const delta = at(mid);
-      if (delta == null) return null;
-      if (delta > target) low = mid; else high = mid;
-    }
-    return smile(Math.exp((low + high) / 2));
-  };
-  const put25 = deltaVol("put", -0.25), call25 = deltaVol("call", 0.25);
-  const low = smile(input.spot * 0.9), high = smile(input.spot * 1.1);
-  const both = put25 != null && call25 != null;
-  return { atm, put25, call25, putCallSkew: both ? put25 - call25 : null,
-    riskReversal: both ? call25 - put25 : null,
-    butterfly: both && atm != null ? (call25 + put25) / 2 - atm : null,
-    moneynessSkew: low != null && high != null ? low - high : null };
-}
-
 /** Decimal IV change per year between two tenors. */
 export function volatilityTermSlope(front: { years: number; volatility: number }, back: { years: number; volatility: number }): number | null {
   return positive(front.years) && back.years > front.years && Number.isFinite(back.years)

package/src/plugins/builtin/short-interest/index.tsx

@@ -9,7 +9,9 @@ import { shortInterestHeadless } from "./headless";
 import { ShortInterestResearchTab, ShortInterestSurface } from "./surface";
 import { shortWatchHeadless } from "./watch-headless";
 import { SHORT_WATCH_SCOPE_OPTIONS, ShortWatchPane } from "./watch-pane";
+import { withCommandTab } from "../shared/command-tab";
 import { followsWithoutFinraOverride, shortVolumeSettings } from "../short-volume";
+import { shortVolumeHeadless } from "../short-volume/headless";
 import { isKnownNonUsListing } from "../../../utils/sec";
 
 
@@ -22,7 +24,7 @@ export const shortInterestModule: PluginModule = {
       id: SHORT_INTEREST_CONNECTION_ID,
       name: "Gloom Short Interest",
       kind: "api",
-      ownerId: "ticker-research",
+      ownerId: "ownership",
       detail: "api.gloom.sh",
       priority: 300,
     });
@@ -75,17 +77,30 @@ export const shortInterestModule: PluginModule = {
 
   paneTemplates: [
     {
-      ...createTickerSurfacePaneTemplate({
+      ...withCommandTab(createTickerSurfacePaneTemplate({
         id: "short-interest-pane",
         paneId: "short-interest",
         label: "Short Interest",
         // The current snapshot only carries the current and prior settlement dates.
-        description: "Bi-monthly short interest settlements from FINRA with days to cover and average daily volume.",
+        description: "Bi-monthly short interest settlements from FINRA with days to cover and average daily volume. Daily volume is the other tab.",
         keywords: ["short", "interest", "si", "shorts", "borrow", "days", "cover"],
         shortcut: "SI",
-      }),
+      }), "interest"),
       headless: shortInterestHeadless,
     },
+    {
+      // The same pane on Daily volume. The template id stays, so an older share still restores.
+      ...withCommandTab(createTickerSurfacePaneTemplate({
+        id: "short-volume-pane",
+        paneId: "short-interest",
+        label: "Daily Short Volume",
+        description: "The short interest pane on Daily volume: FINRA daily off-exchange short-volume ratios, historical percentile and reported share quantities.",
+        keywords: ["daily", "short", "volume", "finra", "siv"],
+        shortcut: "SIV",
+        publicShare: true,
+      }), "volume"),
+      headless: shortVolumeHeadless,
+    },
     {
       id: "short-watch-pane",
       paneId: "short-watch",

package/src/plugins/builtin/short-interest/surface.tsx

@@ -1,8 +1,8 @@
 import { useEffect, useState } from "react";
 import { Box } from "../../../ui";
 import { PaneFooterScope, usePaneFooter, usePaneTabs } from "../../../components";
-import { usePluginPaneState } from "../../../public/react";
 import type { PaneProps } from "../../../types/plugin";
+import { useCommandTab } from "../shared/command-tab";
 import { ShortVolumePane } from "../short-volume/pane";
 import { ShortInterestView } from "./pane";
 
@@ -11,14 +11,14 @@ export function ShortInterestSurface({ nested = false, ...props }: Pick<PaneProp
   /** Inside Ticker Research, whose own tab strip keeps h/l and the arrows. */
   nested?: boolean;
 }) {
-  const [tab, setTab] = usePluginPaneState("short-interest:tab", "interest");
-  const [mounted, setMounted] = useState(() => new Set([tab]));
+  const [tab, setTab] = useCommandTab("short-interest", "short-interest:tab", ["interest", "volume"], "interest");
+  const [mounted, setMounted] = useState<Set<string>>(() => new Set([tab]));
   useEffect(() => { setMounted((current) => current.has(tab) ? current : new Set([...current, tab])); }, [tab]);
   // Nested in Ticker Research the title bar belongs to the research tabs, so
   // the desktop switches views from the query bar and the terminal strip
   // leaves h/l to the research tabs.
   const { strip: tabStrip, rows: tabRows } = usePaneTabs({
-    tabs: TABS, activeValue: tab, onSelect: setTab, focused: props.focused, keyboardNavigation: !nested, dense: true, queryBarWidth: props.width,
+    tabs: TABS, activeValue: tab, onSelect: (value) => setTab(value === "volume" ? "volume" : "interest"), focused: props.focused, keyboardNavigation: !nested, dense: true, queryBarWidth: props.width,
   });
   // The strip answers h/l only where it is the pane's own strip; `v` switches
   // views everywhere, including under Ticker Research's strip.

package/src/plugins/builtin/short-volume/index.tsx

@@ -1,9 +1,6 @@
 import type { PaneInstanceConfig } from "../../../types/config";
 import type { PluginModule } from "../plugin-module";
-import { createTickerSurfacePaneTemplate } from "../shared/ticker-surface";
 import { shortVolumeCache } from "./client";
-import { shortVolumeHeadless } from "./headless";
-import { ShortVolumePane } from "./pane";
 
 export const shortVolumeSettings = [
   { key: "shortVolumeScope", label: "Reporting scope", type: "select" as const,
@@ -14,14 +11,8 @@ export const shortVolumeSettings = [
 export const followsWithoutFinraOverride = (pane: PaneInstanceConfig) => (
   typeof pane.settings?.finraSymbol !== "string" || !pane.settings.finraSymbol.trim()
 );
+/** The daily-volume cache. `SIV` opens the short interest pane, so this module has no pane of its own. */
 export const shortVolumeModule: PluginModule = {
-  panes: [{ id: "short-volume", name: "Daily Short Volume", icon: "S", component: ShortVolumePane,
-    defaultPosition: "right", tickerFollower: followsWithoutFinraOverride, defaultMode: "floating", defaultFloatingSize: { width: 92, height: 28 },
-    tableExport: true, headless: shortVolumeHeadless, settings: { title: "Daily Short Volume", fields: shortVolumeSettings } }],
-  paneTemplates: [{ ...createTickerSurfacePaneTemplate({ id: "short-volume-pane", paneId: "short-volume", label: "Daily Short Volume",
-    description: "FINRA daily off-exchange short-volume ratios, historical percentile and reported share quantities.",
-    shortcut: "SIV", keywords: ["daily", "short", "volume", "finra", "siv"], publicShare: true,
-  }), headless: shortVolumeHeadless }],
   setup(ctx) { shortVolumeCache.attach(ctx.persistence); },
   dispose() { shortVolumeCache.reset(); },
 };