gloomberb 0.16.4 → 0.16.5

package/src/plugins/builtin/gpu/headless.ts

@@ -1,7 +1,11 @@
 import type { GpuObservation } from "../../../api-client/gpu";
-import type { HeadlessPaneDefinition } from "../../../types/plugin";
-import { fetchGpuBoard, fetchGpuEvents, fetchGpuHistory, loadGpuEquityHistory } from "./client";
-import { GPU_TABS, gpuArgument, gpuBasisLabel, gpuChange, gpuEquityRows, gpuEventDate, gpuProvenanceLabel, gpuLabel, gpuRows, gpuSource, gpuTab } from "./model";
+import type { HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/plugin";
+import { formatUtcTime } from "../../../utils/utc-time";
+import { fetchGpuBoard, fetchGpuEvents, fetchGpuHistory, fetchGpuModelPreviews, gpuPreviewModels, loadGpuEquityHistory } from "./client";
+import {
+  GPU_TABS, gpuBasisLabel, gpuChange, gpuChangesLocked, gpuEquityGap, gpuEquityModels, gpuEquityRows, gpuEventDate, gpuFamilies, gpuFamily,
+  gpuLabel, gpuNoMatch, gpuPrice, gpuProvenanceLabel, gpuRows, gpuSource, gpuTab,
+} from "./model";
 import { quoteFreshnessFields } from "../shared/report-freshness";
 import { getRegularSessionDisplay } from "../../../market-data/market/status";
 
@@ -9,69 +13,96 @@ const observationRow = (row: GpuObservation) => ({ gpu: gpuLabel(row), source: g
   price: row.pricePerGpuHr, availability: row.availability, observedAt: row.observedAt, effectiveAt: row.effectiveAt, provenance: row.provenance ?? "live", provenanceLabel: gpuProvenanceLabel(row, true),
   sourceUrl: row.sourceUrl ?? null, evidenceUrl: row.evidenceUrl ?? null });
 const percent = (value: unknown) => gpuChange(typeof value === "number" ? value : null);
+/** Prices to the cent and times to the minute, as the pane draws them; exports keep the full value. */
+const price = (value: unknown) => typeof value === "number" ? gpuPrice(value) : "-";
+const minute = (value: unknown) => typeof value === "string" ? formatUtcTime(value) : "-";
+/** A move the free preview leaves to Pro says so, instead of reading as missing. */
+const change = (value: unknown, row: HeadlessPaneRow) => row.changesLocked === true ? "Pro" : percent(value);
 const columns = [
   { key: "gpu", header: "GPU" }, { key: "source", header: "Source" }, { key: "basis", header: "Basis" },
-  { key: "price", header: "$/GPU-hr", align: "right" as const },
-  { key: "change1d", header: "1D", align: "right" as const, format: percent }, { key: "change7d", header: "7D", align: "right" as const, format: percent },
-  { key: "change30d", header: "30D", align: "right" as const, format: percent }, { key: "availability", header: "Avail" }, { key: "observedAt", header: "As of" },
+  { key: "price", header: "$/GPU-hr", align: "right" as const, format: price },
+  { key: "change1d", header: "1D", align: "right" as const, format: change }, { key: "change7d", header: "7D", align: "right" as const, format: change },
+  { key: "change30d", header: "30D", align: "right" as const, format: change }, { key: "availability", header: "Avail" },
+  { key: "observedAt", header: "As of", format: minute },
 ];
 
 export const gpuHeadless: HeadlessPaneDefinition<"bundle"> = {
-  shape: "bundle", argument: { kind: "free-text", optional: true, placeholder: "GPU", description: "GPU model, such as H100 or B200." },
+  // Observed rental prices; the Equities tab's quotes keep their market line.
+  shape: "bundle", freshness: { dataset: true }, argument: { kind: "free-text", optional: true, placeholder: "GPU", description: "GPU model, such as H100, h-100 or B200." },
   options: [{ key: "tab", type: "enum", values: GPU_TABS.map(({ value }) => ({ value })), defaultValue: "board", description: "Board, sourced history, dated changes or related equities." }],
   discovery: { aliases: ["GPU"], dataRequirements: ["GPU rental price observations"],
     limitations: ["List prices, provider-declared spot and asks are distinct bases",
       "Hyperscaler and Neocloud rows are list indexes: the median of the providers' list prices linked over time, so a provider joining or leaving causes no jump; sample.rawMedian is the raw median of today's providers and can differ slightly",
-      "1D/7D/30D need sufficient observation history; unavailable changes remain null"] },
+      "1D/7D/30D need sufficient observation history; unavailable changes remain null",
+      "Free preview: three board rows, or the latest rows of the GPU asked for; Pro unlocks every provider, the moves and the history"] },
   describe: "GPU rental prices in USD per GPU-hour",
   async load(args, ctx) {
-    const argument = Array.isArray(args.argument) ? args.argument.join(" ") : args.argument;
-    const model = gpuArgument(argument);
+    const argument = (Array.isArray(args.argument) ? args.argument.join(" ") : args.argument) ?? "";
     const tab = gpuTab(args.options.tab);
     const board = await fetchGpuBoard(ctx.apiClient);
+    const families = gpuFamilies(board.rows);
+    const model = argument.trim() ? gpuFamily(argument, families) : "";
+    if (model === null) throw new Error(gpuNoMatch(argument, families));
     const metadata = { asOf: board.asOf, stale: board.stale, complete: board.status === "available" && !board.access?.locked, unit: "USD/GPU-hour", access: board.access,
       methodology: "docs/gpu-rental-prices.md#list-indexes" };
     // Prices observed on providers' pages, not a feed; each board row says whether its source has gone quiet.
     const freshness = { source: "GPU cloud providers", status: "not-a-feed" as const, basis: "observed prices" };
     if (tab === "history") {
       const history = await fetchGpuHistory({ ...(model ? { gpuModel: model } : {}), limit: 10_000 }, ctx.apiClient);
-      return { sections: [{ title: "Dated observations", columns: [...columns.filter((column) => !column.key.startsWith("change")), { key: "provenanceLabel", header: "Record" }], rows: history.points.map(observationRow) }], freshness: { ...freshness, oldest: null }, complete: !history.access?.locked, metadata: { ...metadata, access: history.access ?? board.access }, errors: board.gaps };
+      return { sections: [{ title: "Dated observations", columns: [...columns.filter((column) => !column.key.startsWith("change")), { key: "provenanceLabel", header: "Record" }], rows: history.points.map(observationRow),
+        empty: history.access?.locked ? "Full history is available with Pro." : `No ${model || "GPU"} observations yet.` }],
+      freshness: { ...freshness, oldest: null }, complete: !history.access?.locked, metadata: { ...metadata, access: history.access ?? board.access }, errors: board.gaps };
     }
     if (tab === "changes") {
       const payload = await fetchGpuEvents(model || undefined, ctx.apiClient);
       return { sections: [{ title: "Price, availability and membership changes", columns: [
-        { key: "date", header: "Date" }, { key: "gpu", header: "GPU" }, { key: "source", header: "Source" }, { key: "basis", header: "Basis" },
-        { key: "oldPrice", header: "Old $/GPU-hr" }, { key: "newPrice", header: "New $/GPU-hr" }, { key: "changePct", header: "Change", format: percent }, { key: "kind", header: "Event" }, { key: "provenanceLabel", header: "Record" },
+        { key: "date", header: "Date", format: minute }, { key: "gpu", header: "GPU" }, { key: "source", header: "Source" }, { key: "basis", header: "Basis" },
+        { key: "oldPrice", header: "Old $/GPU-hr", align: "right" as const, format: price }, { key: "newPrice", header: "New $/GPU-hr", align: "right" as const, format: price },
+        { key: "changePct", header: "Change", align: "right" as const, format: percent }, { key: "kind", header: "Event" }, { key: "provenanceLabel", header: "Record" },
         { key: "oldAvailability", header: "Old availability" }, { key: "newAvailability", header: "New availability" },
       ], rows: payload.events.map((event) => ({ date: gpuEventDate(event), observedAt: event.observedAt,
         effectiveAt: event.effectiveAt, origin: event.origin ?? "observed", gpu: gpuLabel(event), source: gpuSource(event), basis: gpuBasisLabel(event.basis),
         oldPrice: event.oldPrice, newPrice: event.newPrice, changePct: event.changePct, kind: event.kind,
         oldMembers: event.oldMembers, newMembers: event.newMembers, provenance: event.provenance ?? "live",
         provenanceLabel: gpuProvenanceLabel(event, true), evidenceUrl: event.evidenceUrl ?? null, sourceUrl: event.sourceUrl ?? null,
-        oldAvailability: event.oldAvailability ?? null, newAvailability: event.newAvailability ?? null })) }], freshness: { ...freshness, oldest: null }, complete: !payload.access?.locked, metadata: { ...metadata, access: payload.access ?? board.access }, errors: board.gaps };
+        oldAvailability: event.oldAvailability ?? null, newAvailability: event.newAvailability ?? null })),
+      empty: payload.access?.locked ? "Full change history is available with Pro." : "No price or availability changes recorded yet." }],
+      freshness: { ...freshness, oldest: null }, complete: !payload.access?.locked, metadata: { ...metadata, access: payload.access ?? board.access }, errors: board.gaps };
     }
+    const selected = tab === "equities" ? model || "H100" : model;
+    const previews = await fetchGpuModelPreviews(gpuPreviewModels(board, tab === "equities" ? gpuEquityModels(selected) : [selected]), ctx.apiClient);
+    const rows = [...board.rows, ...previews];
+    const previewed = [...new Set(previews.map((row) => row.gpuModel))];
+    const notes = previewed.length ? [`${previewed.join(" and ")} ${previewed.length > 1 ? "are" : "is"} not on the free board: ${previewed.length > 1 ? "their" : "its"} latest free rows stand in. Pro adds every provider and the 1D, 7D and 30D moves.`]
+      : board.access?.locked && !model && tab === "board" ? ["The free board shows three rows; name a GPU (GPU H100) for its latest free rows, or upgrade to Pro for every GPU."] : [];
     if (tab === "equities") {
-      const related = gpuEquityRows(board.rows, model || "H100");
+      const related = gpuEquityRows(rows, selected, !!board.access?.locked);
       const histories = await loadGpuEquityHistory(ctx.marketData);
-      const rows = await Promise.all(related.map(async (row) => {
+      const equities = await Promise.all(related.map(async (row) => {
         const quote = await ctx.marketData.getQuote(row.symbol, row.exchange).catch(() => null);
         const history = histories.find((entry) => entry.symbol === row.symbol);
         // The regular session's last and move, as the pane's board shows them.
         const headline = getRegularSessionDisplay(quote);
+        const reference = row.reference;
         return { symbol: row.symbol, role: row.role, price: headline?.price ?? null, change1d: headline?.changePercent ?? null,
           change5d: history?.value ?? null, fiveDayAsOf: history?.asOf ?? null, quoteAsOf: quote?.lastUpdated ? new Date(quote.lastUpdated).toISOString() : null,
           ...quoteFreshnessFields(quote),
-          gpu: row.reference ? gpuLabel(row.reference) : row.gpuModel, gpuSource: row.reference ? gpuSource(row.reference) : null, gpuChange7d: row.reference?.change7d ?? null };
+          gpu: reference ? gpuLabel(reference) : row.gpuModel, gpuSource: reference ? gpuSource(reference) : null, gpuPrice: reference?.pricePerGpuHr ?? null,
+          gpuChange7d: reference?.change7d ?? null, gpuLocked: row.gap === "pro" || (!!reference && gpuChangesLocked(reference)), gpuGap: gpuEquityGap(row) };
       }));
+      const locked = (value: unknown, row: HeadlessPaneRow, show: (value: unknown) => string) => value == null && row.gpuLocked === true ? "Pro" : show(value);
       return { sections: [{ title: "Related equities", columns: [
-        { key: "symbol", header: "Ticker" }, { key: "role", header: "Related through" }, { key: "price", header: "Last $" },
-        { key: "change1d", header: "1D", format: percent }, { key: "change5d", header: "5D", format: percent },
-        { key: "gpu", header: "GPU" }, { key: "gpuSource", header: "GPU list series" }, { key: "gpuChange7d", header: "GPU 7D", format: percent },
-      ], rows }], complete: !board.access?.locked, metadata, errors: [...board.gaps, ...histories.flatMap((entry) => entry.error ? [entry.error] : [])],
-      unavailableSymbols: rows.filter((row) => row.price == null || row.change5d == null).map((row) => row.symbol) };
+        { key: "symbol", header: "Ticker" }, { key: "role", header: "Related through" }, { key: "price", header: "Last $", align: "right" as const, format: price },
+        { key: "change1d", header: "1D", align: "right" as const, format: percent }, { key: "change5d", header: "5D", align: "right" as const, format: percent },
+        { key: "gpu", header: "GPU" }, { key: "gpuSource", header: "GPU list series", format: (value: unknown, row: HeadlessPaneRow) => typeof value === "string" ? value : String(row.gpuGap ?? "-") },
+        { key: "gpuPrice", header: "$/GPU-hr", align: "right" as const, format: (value: unknown, row: HeadlessPaneRow) => locked(value, row, price) },
+        { key: "gpuChange7d", header: "GPU 7D", align: "right" as const, format: (value: unknown, row: HeadlessPaneRow) => locked(value, row, percent) },
+      ], rows: equities }], complete: !board.access?.locked, metadata, notes, errors: [...board.gaps, ...histories.flatMap((entry) => entry.error ? [entry.error] : [])],
+      unavailableSymbols: equities.filter((row) => row.price == null || row.change5d == null).map((row) => row.symbol) };
     }
-    const rows = gpuRows(board.rows, model).map((row) => ({ ...observationRow(row), change1d: row.change1d, change7d: row.change7d,
-      change30d: row.change30d, stale: row.stale, sample: row.stats ?? null }));
-    return { sections: [{ title: "GPU rental prices", columns, rows }], freshness, complete: !board.access?.locked, metadata, errors: board.gaps };
+    const boardRows = gpuRows(rows, model).map((row) => ({ ...observationRow(row), change1d: row.change1d, change7d: row.change7d,
+      change30d: row.change30d, stale: row.stale, sample: row.stats ?? null, ...(gpuChangesLocked(row) ? { changesLocked: true } : {}) }));
+    return { sections: [{ title: "GPU rental prices", columns, rows: boardRows, empty: `No ${model ? `${model} ` : ""}rental prices have been observed yet.` }],
+      freshness, complete: !board.access?.locked, metadata, notes, errors: board.gaps };
   },
 };

package/src/plugins/builtin/gpu/history.tsx

@@ -92,8 +92,8 @@ function HistoryDetail({ row, peers, width, height, refreshVersion }: {
   </PaneStatusBody>;
 }
 
-export function GpuHistory({ rows, model, setModel, selectedId, onSelect, reloadBoard, width, height, focused }: {
-  rows: GpuBoardRow[]; model: string; setModel: (value: string) => void; selectedId: string; onSelect: (id: string) => void;
+export function GpuHistory({ rows, models: boardModels, model, setModel, selectedId, onSelect, reloadBoard, width, height, focused }: {
+  rows: GpuBoardRow[]; models: readonly string[]; model: string; setModel: (value: string) => void; selectedId: string; onSelect: (id: string) => void;
   reloadBoard: () => void; width: number; height: number; focused: boolean;
 }) {
   const colors = useThemeColors();
@@ -106,7 +106,7 @@ export function GpuHistory({ rows, model, setModel, selectedId, onSelect, reload
     notices: [references.error, references.data?.refreshError].filter((value): value is string => !!value) });
   const allRows = useMemo(() => [...rows, ...gpuReferenceRows(references.data?.payload.points ?? [])], [rows, references.data]);
   // History always reads one model: the one picked on the board, else the selected series\' model.
-  const models = useMemo(() => [...new Set(allRows.map((row) => row.gpuModel))].sort(), [allRows]);
+  const models = useMemo(() => [...new Set([...boardModels, ...allRows.map((row) => row.gpuModel)])].sort(), [boardModels, allRows]);
   const activeModel = model || allRows.find((row) => row.id === selectedId)?.gpuModel || (models.includes("H100") ? "H100" : models[0] ?? GPU_MODELS[0]!);
   const sections = useMemo(() => gpuBoardSections(allRows, activeModel).filter((section) => basis === "all" || section.basis === basis), [allRows, activeModel, basis]);
   const ordered = useMemo(() => sections.flatMap((section) => section.rows), [sections]);

package/src/plugins/builtin/gpu/index.tsx

@@ -3,6 +3,7 @@ import { gpuBoardCache, gpuEventsCache, gpuHistoryCache } from "./client";
 import { gpuHeadless } from "./headless";
 import { GPU_MODELS, gpuArgument } from "./model";
 import { GpuPane } from "./pane";
+import { GPU_SERIES } from "./series";
 
 export const gpuModule: PluginModule = {
   panes: [{ id: "gpu", name: "GPU Rental Prices", icon: "G", component: GpuPane, defaultPosition: "right", defaultMode: "floating",
@@ -13,6 +14,7 @@ export const gpuModule: PluginModule = {
     shortcut: { prefix: "GPU", argKind: "text", argPlaceholder: "GPU", argOptional: true,
       argOptions: () => GPU_MODELS.map((value) => ({ value, label: value })) }, headless: gpuHeadless,
     createInstance: (_context, options) => ({ placement: "floating", params: { gpuModel: gpuArgument(options?.arg) } }) }],
+  series: GPU_SERIES,
   setup(ctx) { for (const cache of [gpuBoardCache, gpuHistoryCache, gpuEventsCache]) cache.attach(ctx.persistence); },
   dispose() { for (const cache of [gpuBoardCache, gpuHistoryCache, gpuEventsCache]) cache.reset(); },
 };

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

@@ -10,6 +10,43 @@ export type GpuTab = typeof GPU_TABS[number]["value"];
 export const gpuTab = (value: unknown): GpuTab => GPU_TABS.find((tab) => tab.value === value)?.value ?? "board";
 export const GPU_MODELS = ["H100", "H200", "B200", "B300", "GB200", "GB300", "A100", "MI300X", "MI355X", "L40S", "RTX PRO 6000"];
 export const gpuArgument = (value: string | null | undefined) => (value ?? "").trim().toUpperCase().replace(/\s+/g, " ");
+const gpuModelRank = (name: string) => GPU_MODELS.indexOf(name) < 0 ? 99 : GPU_MODELS.indexOf(name);
+/** Board order: the GPUs people rent most first, the rest by name. */
+const gpuModelOrder = (a: string, b: string) => gpuModelRank(a) - gpuModelRank(b) || a.localeCompare(b);
+
+/** Every GPU name a reader can ask for: the ones on this board and the ones the full board carries. */
+export const gpuFamilies = (rows: readonly Pick<GpuObservation, "gpuModel">[]) =>
+  [...new Set([...GPU_MODELS, ...rows.map((row) => row.gpuModel)])].sort(gpuModelOrder);
+
+/** A GPU name as typed, for comparison: case, spaces, dashes and underscores do not matter. */
+const gpuKey = (value: string) => value.toLowerCase().replace(/[\s_-]+/g, "");
+
+/**
+ * The GPU a typed name means, so "h100", "H-100" and "H100 80GB SXM" all
+ * read H100. A whole name wins over a longer one it begins ("A10" is not
+ * A100), and the most leading words that name a GPU win over fewer ("RTX PRO
+ * 6000"). Otherwise the first GPU, in board order, whose name begins with
+ * what was typed ("B2" is B200), or that begins it ("H100SXM"). Null when
+ * nothing matches.
+ */
+export function gpuFamily(query: string, families: readonly string[]): string | null {
+  const words = query.trim().split(/[\s_-]+/).filter(Boolean);
+  if (!words.length) return null;
+  const ordered = [...new Set(families)].sort(gpuModelOrder);
+  for (let count = words.length; count > 0; count -= 1) {
+    const key = gpuKey(words.slice(0, count).join(""));
+    const exact = ordered.find((family) => gpuKey(family) === key);
+    if (exact) return exact;
+  }
+  const key = gpuKey(query);
+  return ordered.find((family) => gpuKey(family).startsWith(key))
+    ?? [...ordered].sort((a, b) => gpuKey(b).length - gpuKey(a).length).find((family) => key.startsWith(gpuKey(family)))
+    ?? null;
+}
+
+/** The sentence for a name that matches no GPU, naming the ones that do. */
+export const gpuNoMatch = (query: string, families: readonly string[]) =>
+  `No GPU matches "${query.trim()}". GPUs: ${families.join(", ")}.`;
 export const gpuBasisLabel = (basis: GpuBasis, compact = false): string => compact
   ? ({ list: "List", spot: "Spot", ask: "Ask", reserved: "Rsvd", index: "Locked", reference: "Reference" })[basis]
   : ({ list: "List price", spot: "Provider-declared spot", ask: "Ask", reserved: "Reserved", index: "Index (licensed)", reference: "Reference" })[basis];
@@ -60,13 +97,31 @@ export function gpuTime(value: string | null | undefined, compact = false): stri
   return compact ? `${day} ${time}` : `${day}, ${date.getUTCFullYear()} ${time} UTC`;
 }
 
-export function gpuRows(rows: readonly GpuBoardRow[], model = "", basis = "all"): GpuBoardRow[] {
+export function gpuRows<T extends GpuBoardRow>(rows: readonly T[], model = "", basis = "all"): T[] {
   const rank = (row: GpuBoardRow) => row.providerClass === "aggregate" ? 0 : row.basis === "list" ? 1 : row.basis === "spot" ? 2 : row.basis === "reserved" ? 3 : 4;
-  return rows.filter((row) => (!model || row.gpuModel === model) && (basis === "all" || row.basis === basis)).sort((a, b) => {
-    const modelRank = (name: string) => GPU_MODELS.indexOf(name) < 0 ? 99 : GPU_MODELS.indexOf(name);
-    return modelRank(a.gpuModel) - modelRank(b.gpuModel) || a.gpuModel.localeCompare(b.gpuModel) || rank(a) - rank(b)
-      || gpuSource(a).localeCompare(gpuSource(b)) || (b.memoryGb ?? 0) - (a.memoryGb ?? 0) || (a.formFactor ?? "").localeCompare(b.formFactor ?? "");
-  });
+  return rows.filter((row) => (!model || row.gpuModel === model) && (basis === "all" || row.basis === basis)).sort((a, b) =>
+    gpuModelOrder(a.gpuModel, b.gpuModel) || rank(a) - rank(b)
+      || gpuSource(a).localeCompare(gpuSource(b)) || (b.memoryGb ?? 0) - (a.memoryGb ?? 0) || (a.formFactor ?? "").localeCompare(b.formFactor ?? ""));
+}
+
+/** A row the free board leaves out, read from the free preview of its GPU: the latest price, with its moves left to Pro. */
+export type GpuPreviewRow = GpuBoardRow & { changesLocked: true };
+export const gpuChangesLocked = (row: GpuBoardRow): row is GpuPreviewRow => (row as Partial<GpuPreviewRow>).changesLocked === true;
+
+/**
+ * The free board carries three rows of one GPU. For another GPU, the latest
+ * rows its free history preview serves stand in, one per series; reference
+ * indexes stay out, as they do on the board.
+ */
+export function gpuPreviewRows(points: readonly GpuObservation[]): GpuPreviewRow[] {
+  const latest = new Map<string, GpuObservation>();
+  for (const point of points) {
+    if (point.basis === "reference" || point.provenance === "reference" || point.basis === "index") continue;
+    const id = `${point.source}:${point.skuKey}`;
+    if (!latest.has(id) || point.observedAt > latest.get(id)!.observedAt) latest.set(id, point);
+  }
+  return [...latest].map(([id, point]) => ({ ...point, id, label: gpuLabel(point), sourceLabel: gpuSource(point),
+    change1d: null, change7d: null, change30d: null, stale: false, lastError: null, changesLocked: true }));
 }
 
 /** The bases in board order. The licensed index never reaches the board. */
@@ -105,9 +160,8 @@ export interface GpuBoardSection { id: string; label: string; basis: GpuBasis; g
  * sections by basis alone; every model names the model in each heading.
  */
 export function gpuBoardSections(rows: readonly GpuBoardRow[], model = ""): GpuBoardSection[] {
-  const modelRank = (name: string) => GPU_MODELS.indexOf(name) < 0 ? 99 : GPU_MODELS.indexOf(name);
   const ordered = rows.filter((row) => (!model || row.gpuModel === model) && row.basis !== "index").sort((a, b) =>
-    modelRank(a.gpuModel) - modelRank(b.gpuModel) || a.gpuModel.localeCompare(b.gpuModel) || basisRank(a.basis) - basisRank(b.basis)
+    gpuModelOrder(a.gpuModel, b.gpuModel) || basisRank(a.basis) - basisRank(b.basis)
     || Number(gpuHeadline(b)) - Number(gpuHeadline(a)) || gpuSource(a).localeCompare(gpuSource(b))
     || (b.memoryGb ?? 0) - (a.memoryGb ?? 0) || (a.formFactor ?? "").localeCompare(b.formFactor ?? ""));
   const sections: GpuBoardSection[] = [];
@@ -321,18 +375,49 @@ export const GPU_EQUITY_GROUPS = [
   { label: "Neoclouds", roles: ["Neocloud"] }, { label: "Hosts and builders", roles: ["Host", "Server builder"] },
 ] as const;
 
-export function gpuEquityRows(rows: readonly GpuBoardRow[], selectedModel: string) {
+const equityModel = (symbol: string, selectedModel: string) => symbol === "AMD" && !selectedModel.startsWith("MI") ? "MI300X"
+  : symbol === "NVDA" && selectedModel.startsWith("MI") ? "H100" : selectedModel;
+
+/** The GPUs the Equities tab reads for one selected GPU: AMD reads its own chip, NVIDIA reads H100 beside an AMD chip. */
+export const gpuEquityModels = (selectedModel: string) => [...new Set(GPU_EQUITIES.map(({ symbol }) => equityModel(symbol, selectedModel)))];
+
+/**
+ * Each share beside the list series that ties it to GPU rents. A share with
+ * no series says why: `pro` when the free board leaves its series out,
+ * `unlisted` when the board has no such series at all.
+ */
+export function gpuEquityRows(rows: readonly GpuBoardRow[], selectedModel: string, locked = false) {
   return GPU_EQUITIES.map((equity) => {
-    const model = equity.symbol === "AMD" && !selectedModel.startsWith("MI") ? "MI300X"
-      : equity.symbol === "NVDA" && selectedModel.startsWith("MI") ? "H100" : selectedModel;
+    const model = equityModel(equity.symbol, selectedModel);
     const candidates = gpuRows(rows, model, "list");
-    const aggregates = candidates.filter((row) => row.providerClass === "aggregate").sort((a, b) =>
-      Number(b.formFactor === "SXM") - Number(a.formFactor === "SXM") || (b.stats?.n ?? 0) - (a.stats?.n ?? 0) || (b.memoryGb ?? 0) - (a.memoryGb ?? 0));
-    const reference = "provider" in equity ? candidates.find((row) => gpuSource(row) === equity.provider)
-      : aggregates.find((row) => row.provider.startsWith("Neocloud")) ?? aggregates[0];
-    return { ...equity, gpuModel: model, reference: reference ?? null };
+    const reference = ("provider" in equity ? candidates.find((row) => gpuSource(row) === equity.provider) : gpuListIndex(candidates, model)) ?? null;
+    const gap: "pro" | "unlisted" | null = reference ? null : locked ? "pro" : "unlisted";
+    return { ...equity, gpuModel: model, reference, gap };
   });
 }
+export type GpuEquityRow = ReturnType<typeof gpuEquityRows>[number];
+
+/**
+ * A GPU's list index: of its main variant (SXM first, then the most
+ * providers, then the most memory), the neocloud index, else the hyperscaler
+ * one. The series a share reads in Equities, and the catalog's GPU list indexes.
+ */
+export function gpuListIndex<T extends GpuBoardRow>(rows: readonly T[], model: string): T | null {
+  const indexes = gpuRows(rows, model, "list").filter((row) => row.providerClass === "aggregate").sort((a, b) =>
+    Number(b.formFactor === "SXM") - Number(a.formFactor === "SXM") || (b.stats?.n ?? 0) - (a.stats?.n ?? 0) || (b.memoryGb ?? 0) - (a.memoryGb ?? 0));
+  return indexes.find((row) => row.provider.startsWith("Neocloud")) ?? indexes[0] ?? null;
+}
+
+/** The series a share would read, named when it has none: "AWS H100 list", "H100 list index". */
+const gpuEquitySeries = (row: Pick<GpuEquityRow, "gpuModel"> & { provider?: string }) =>
+  row.provider ? `${row.provider} ${row.gpuModel} list` : `${row.gpuModel} list index`;
+
+/**
+ * The series column of a share with no series: the one Pro unlocks (its price
+ * and move cells read Pro), or the one the board does not list.
+ */
+export const gpuEquityGap = (row: GpuEquityRow) => row.gap === "pro" ? gpuEquitySeries(row)
+  : row.gap === "unlisted" ? `No ${gpuEquitySeries(row)}` : null;
 
 export function equityFiveDayReturn(history: readonly PricePoint[]): { value: number | null; asOf: string | null } {
   const dates = new Map<string, { time: number; close: number }>();

package/src/plugins/builtin/gpu/pane.tsx

@@ -3,7 +3,7 @@ import { isAccessDenied } from "../../../api-client/errors";
 import { SignInWall } from "../cloud/auth-actions";
 import { CLOUD_PLAN_KEY, useCloudUpgradeAction } from "../shared/cloud-upgrade";
 import { isCloudSessionRequired, useResearchCloudSession } from "../shared/research-cloud-session";
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import { PaneStatusBody, usePaneFooter, usePaneNoticeFooter, usePaneStatusFooter, usePaneTabs } from "../../../components";
 import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginAppActions, usePluginPaneState } from "../../../public/react";
@@ -11,11 +11,11 @@ import { usePaneInstance } from "../../../state/app/context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
 import { GpuBoard } from "./board";
-import { getCachedGpuBoard, gpuCacheScope, GPU_NOT_AVAILABLE, loadGpuBoard } from "./client";
+import { getCachedGpuBoard, gpuCacheScope, GPU_NOT_AVAILABLE, gpuPreviewModels, loadGpuBoard, loadGpuModelPreviews } from "./client";
 import { GpuChanges } from "./changes";
 import { GpuEquities } from "./equities";
 import { GpuHistory } from "./history";
-import { GPU_TABS, gpuTab, gpuTime } from "./model";
+import { GPU_TABS, gpuEquityModels, gpuFamilies, gpuFamily, gpuNoMatch, gpuTab, gpuTime } from "./model";
 
 export function GpuPane(props: PaneProps) {
   usePlanAccess();
@@ -34,12 +34,28 @@ function GpuView({ width, height, focused }: PaneProps) {
   const resource = useAsyncResource(loadGpuBoard, { initialData: getCachedGpuBoard, clearOnError: isAccessDenied });
   const data = resource.data?.payload;
   const { createPaneFromTemplate } = usePluginAppActions();
+  const locked = !!data?.access?.locked;
+  const families = useMemo(() => gpuFamilies(data?.rows ?? []), [data]);
+  // What was typed ("h-100", "H100 80GB SXM") reads as the GPU it names; a name that matches none stays as typed and says so.
+  const activeModel = model ? gpuFamily(model, families) ?? model : "";
+  const unknownModel = !!model && !families.includes(activeModel);
+  // The free board is one GPU's three rows; another GPU's free preview stands in for the rows it leaves out.
+  const previewKey = useMemo(() => data && !unknownModel ? gpuPreviewModels(data, tab === "equities" ? gpuEquityModels(activeModel || "H100")
+    : tab === "changes" ? [] : tab === "history" ? [activeModel || "H100"] : [activeModel]).join("\n") : "", [data, unknownModel, tab, activeModel]);
+  const previewLoader = useCallback((force: boolean) => loadGpuModelPreviews(previewKey.split("\n"), force), [previewKey]);
+  const preview = useAsyncResource(previewKey ? previewLoader : null);
+  const rows = useMemo(() => data ? [...data.rows, ...(previewKey ? preview.data ?? [] : [])] : [], [data, previewKey, preview.data]);
+  const models = useMemo(() => locked ? [...families].sort() : [...new Set(rows.map((row) => row.gpuModel))].sort(), [locked, families, rows]);
+  // A failed preview is the footer's error; the body does not repeat it.
+  const emptyTitle = unknownModel ? gpuNoMatch(model, families)
+    : preview.error ? `No ${activeModel} rental prices to show.` : `No ${activeModel} rental prices have been observed yet.`;
   useAutoRefresh(resource.updatedAt, resource.load);
-  usePaneRefreshKey(() => void resource.reload(), { focused: focused && (tab === "board" || !data) });
+  useAutoRefresh(preview.updatedAt, preview.load);
+  usePaneRefreshKey(() => { void resource.reload(); void preview.reload(); }, { focused: focused && (tab === "board" || !data) });
   const signIn = !data && (session.needsVerification || isCloudSessionRequired(resource.error));
   const notAvailable = !data && resource.error === GPU_NOT_AVAILABLE;
-  usePaneStatusFooter({ registrationId: "gpu", loading: resource.loading, error: notAvailable || signIn ? null : resource.error,
-    stale: !!data && (data.stale || resource.data?.stale), info: data?.asOf ? [{ id: "asof", parts: [{ text: `as of ${gpuTime(data.asOf)}`, tone: "muted" }] }] : [] });
+  usePaneStatusFooter({ registrationId: "gpu", loading: resource.loading || preview.loading, error: notAvailable || signIn ? null : resource.error ?? preview.error,
+    stale: !!data && (data.stale || resource.data?.stale), info: data?.asOf ? [{ id: "asof", asOf: true, parts: [{ text: `as of ${gpuTime(data.asOf)}`, tone: "muted" }] }] : [] });
   usePaneNoticeFooter({ registrationId: "gpu:notices", focused,
     notices: [...(data?.gaps ?? []), ...(resource.data?.refreshError ? [resource.data.refreshError] : [])] });
   usePaneFooter("gpu:actions", () => ({ info: data?.access?.preview ? [{ id: "preview", parts: [{ text: "Free preview", tone: "muted" }] }] : [],
@@ -47,17 +63,17 @@ function GpuView({ width, height, focused }: PaneProps) {
     onPress: () => createPaneFromTemplate("buildout-pane") }] }), [createPaneFromTemplate, data?.access, upgrade]);
   const { strip, rows: tabRows } = usePaneTabs(data ? { tabs: [...GPU_TABS], activeValue: tab, onSelect: setTab, focused, dense: true } : null);
   const body = { width, height: Math.max(3, height - tabRows), focused };
-  const reloadBoard = useCallback(() => { void resource.reload(); }, [resource.reload]);
+  const reloadBoard = useCallback(() => { void resource.reload(); void preview.reload(); }, [resource.reload, preview.reload]);
   if (signIn) return <SignInWall placement="gpu" width={width} height={height} action="browse GPU rental prices" needsVerification={session.needsVerification} />;
   return <Box width={width} height={height} flexDirection="column">
     {strip}
-    <PaneStatusBody loading={resource.loading && !data} error={!data && !notAvailable ? resource.error : null}
+    <PaneStatusBody loading={(resource.loading && !data) || (!!previewKey && preview.loading && !preview.data)} error={!data && !notAvailable ? resource.error : null}
       empty={notAvailable} emptyTitle={GPU_NOT_AVAILABLE} subject="GPU rental prices">
-      {data ? tab === "board" ? <GpuBoard rows={data.rows} asOf={data.asOf} model={model} setModel={setModel} selectedId={selectedId}
+      {data ? tab === "board" ? <GpuBoard rows={rows} models={models} asOf={data.asOf} model={activeModel} setModel={setModel} selectedId={selectedId} emptyTitle={emptyTitle}
         select={(row, open) => { setSelectedId(row.id); if (open) setTab("history"); }} {...body} />
-        : tab === "history" ? <GpuHistory rows={data.rows} model={model} setModel={setModel} selectedId={selectedId} onSelect={setSelectedId} reloadBoard={reloadBoard} {...body} />
-          : tab === "changes" ? <GpuChanges board={data.rows} model={model} setModel={setModel} reloadBoard={reloadBoard} {...body} />
-            : <GpuEquities board={data.rows} model={model} setModel={setModel} reloadBoard={reloadBoard} {...body} /> : null}
+        : tab === "history" ? <GpuHistory rows={rows} models={models} model={unknownModel ? "" : activeModel} setModel={setModel} selectedId={selectedId} onSelect={setSelectedId} reloadBoard={reloadBoard} {...body} />
+          : tab === "changes" ? <GpuChanges models={models} model={unknownModel ? "" : activeModel} setModel={setModel} reloadBoard={reloadBoard} {...body} />
+            : <GpuEquities board={rows} models={models} locked={locked} model={unknownModel ? "" : activeModel} setModel={setModel} reloadBoard={reloadBoard} {...body} /> : null}
     </PaneStatusBody>
   </Box>;
 }

package/src/plugins/builtin/gpu/series.ts

@@ -0,0 +1,38 @@
+import type { SeriesDefinition } from "../../../series/types";
+import { cachedSeriesWarning } from "../shared/series-warning";
+import { loadGpuBoard, loadGpuHistory } from "./client";
+import { GPU_MODELS, gpuListIndex } from "./model";
+
+/** What the GPU pane says when the free preview leaves history out. */
+const GPU_PRO_ONLY = "Full history is available with Pro.";
+
+/**
+ * Each GPU's list index, the one the GPU pane's Equities tab reads shares
+ * against. The per-provider listings stay on the board and its History tab:
+ * the server lists them, and they come and go.
+ */
+export const GPU_SERIES: readonly SeriesDefinition[] = GPU_MODELS.map((model): SeriesDefinition => ({
+  id: `gpu:${model.toLowerCase().replaceAll(" ", "-")}-list-index`,
+  name: `${model} rental list index`,
+  unit: "USD/GPU-hour",
+  frequency: "intraday",
+  group: "Alternative data",
+  tags: ["GPU", "rental", "compute", "cloud", "list price", model],
+  description: `Median list price to rent one ${model} from neocloud providers (hyperscalers where none list it), chained so a change of providers causes no jump, as GPU charts it. Needs Pro.`,
+  style: "step",
+  load: async () => {
+    const board = await loadGpuBoard();
+    if (board.payload.access?.locked) throw new Error(GPU_PRO_ONLY);
+    const index = gpuListIndex(board.payload.rows, model);
+    if (!index) throw new Error(`No ${model} list index is listed yet.`);
+    const history = await loadGpuHistory(index.id);
+    if (history.payload.access?.locked) throw new Error(GPU_PRO_ONLY);
+    const warning = cachedSeriesWarning(history);
+    return {
+      points: history.payload.points
+        .filter((point) => `${point.source}:${point.skuKey}` === index.id)
+        .map((point) => ({ date: point.observedAt, value: point.pricePerGpuHr })),
+      ...(warning ? { warning } : {}),
+    };
+  },
+}));

package/src/plugins/builtin/help/function-card.tsx

@@ -2,8 +2,10 @@
  * The help card for one function, opened by `HELP <fn>` in the command bar
  * and F1 on a focused pane: what it answers, how to type it, the keys that
  * matter in its pane, how fresh its data is on each plan, its Bloomberg
- * equivalent and its docs entry. Enter or the link opens the docs; Esc, the
- * close button or a click outside closes it.
+ * equivalent and its docs entry. Enter reads the entry in DOCS, inside the
+ * app; the link beside it is the same entry on gloom.sh, in the browser. A
+ * popped-out window cannot open a pane, so there Enter opens the link. Esc,
+ * the close button or a click outside closes it.
  *
  * `useFunctionHelpHost` is mounted with the app's global shortcuts for the
  * life of the window and owns the dialog; `requestFunctionHelp` lets the
@@ -13,7 +15,9 @@ import { useEffect, useRef, type ReactNode } from "react";
 import { usePlanAccess } from "../../../api-client/plan-access";
 import { functionDocsUrl, type FunctionFreshness, type FunctionHelpKey } from "../../../cli/pane-functions/function-help";
 import { requestFeedbackDialog } from "../../../components/feedback-dialog";
+import { Button } from "../../../components/ui/button";
 import { ExternalLink } from "../../../components/ui/external-link";
+import { DOCS_PANE_TEMPLATE_ID } from "../../../docs/content";
 import { DialogFrame } from "../../../components/ui/frame";
 import { ShortcutHint } from "../../../components/ui/shortcut-hint";
 import { t } from "../../../i18n";
@@ -21,10 +25,12 @@ import { useViewport } from "../../../react/input";
 import { useThemeColors } from "../../../theme/theme-context";
 import { Box, Text, TextAttributes, useRendererHost } from "../../../ui";
 import { useDialog, useDialogKeyboard, type AlertContext } from "../../../ui/dialog";
+import { getSharedRegistry } from "../../registry";
 import type { HelpFunction } from "./function-index";
 
 export type FunctionHelpRequest =
-  | { kind: "function"; fn: HelpFunction }
+  /** `inAppDocs: false` where DOCS cannot open (a popped-out window). */
+  | { kind: "function"; fn: HelpFunction; inAppDocs?: boolean }
   /** `HELP HELP`: the feedback dialog, which is how people reach us. */
   | { kind: "support" };
 
@@ -103,9 +109,10 @@ function FreshnessRows({ data, pro }: { data: FunctionFreshness; pro: boolean })
   );
 }
 
-function FunctionHelpCard({ fn, dismiss, dialogId, width, compact = false }: AlertContext & {
+function FunctionHelpCard({ fn, dismiss, dialogId, width, compact = false, inAppDocs = true }: AlertContext & {
   fn: HelpFunction;
   width: number;
+  inAppDocs?: boolean;
   /** A short terminal: no blank row between the summary and the rows. */
   compact?: boolean;
 }) {
@@ -117,6 +124,10 @@ function FunctionHelpCard({ fn, dismiss, dialogId, width, compact = false }: Ale
     void rendererHost.openExternal(url);
     dismiss();
   };
+  const readInApp = () => {
+    getSharedRegistry()?.createPaneFromTemplate(DOCS_PANE_TEMPLATE_ID, { arg: fn.code });
+    dismiss();
+  };
 
   useDialogKeyboard((event) => {
     if (event.ctrl || event.alt || event.meta || event.super) return;
@@ -124,7 +135,8 @@ function FunctionHelpCard({ fn, dismiss, dialogId, width, compact = false }: Ale
     if (name !== "enter" && name !== "return") return;
     event.preventDefault();
     event.stopPropagation();
-    openDocs();
+    if (inAppDocs) readInApp();
+    else openDocs();
   }, { scope: dialogId });
 
   const help = fn.help;
@@ -153,6 +165,11 @@ function FunctionHelpCard({ fn, dismiss, dialogId, width, compact = false }: Ale
             </CardRow>
           )}
           <CardRow label="Docs">
+            {inAppDocs && (
+              <Box flexDirection="row">
+                <Button label="Read in Docs" shortcut="Enter" compact onPress={readInApp} stopPropagation />
+              </Box>
+            )}
             <ExternalLink url={docsUrl} label={docsUrl.replace(/^https:\/\//, "")} onOpen={openDocs} />
           </CardRow>
         </Box>
@@ -189,7 +206,9 @@ export function useFunctionHelpHost({ closeCommandBar }: { closeCommandBar: () =
         closeOnClickOutside: true,
         // The terminal host defaults to 60 columns; the desktop sizes to the content.
         style: { width: width + TERMINAL_DIALOG_CHROME, ...(compact ? { paddingY: 0 } : {}) },
-        content: (context: AlertContext) => <FunctionHelpCard {...context} fn={request.fn} width={width} compact={compact} />,
+        content: (context: AlertContext) => (
+          <FunctionHelpCard {...context} fn={request.fn} width={width} compact={compact} inAppDocs={request.inAppDocs !== false} />
+        ),
       }).catch(() => {}).finally(() => {
         openRef.current = false;
       });