gloomberb 0.18.1 → 0.18.2

package/src/plugins/builtin/primary-dealers/model.ts

@@ -4,147 +4,214 @@ import { formatNumber } from "../../../utils/format";
 
 export const PRIMARY_DEALERS_PANE_ID = "primary-dealers";
 
-/** Aggregate totals only. Tenor and CUSIP buckets stay off the wire. */
-const SERIES_CAP = 12;
-
-/**
- * The current release names settlement fails PDFTD (deliver) and PDFTR
- * (receive). PDFAIL and PDFAS are included when a break still publishes them.
- */
-const FAIL_PREFIXES = ["PDFAIL", "PDFAS", "PDFTD", "PDFTR"] as const;
-
 export type DealerTab = "positions" | "fails";
 
-export interface CatalogEntry {
-  seriesBreak: string;
-  keyid: string;
-  description: string;
+/** One observation of a series. */
+export interface SeriesPoint {
+  asOf: string;
+  value: number;
 }
 
-export interface SeriesSelection {
-  seriesBreak: string;
-  positions: CatalogEntry[];
-  fails: CatalogEntry[];
+/** What the "latest" read holds per series: its newest observation. */
+export type LatestBySeries = ReadonlyMap<string, SeriesPoint>;
+
+/** A row of the board: one series, or the sum of several that the release does not total. */
+interface RowDef {
+  id: string;
+  label: string;
+  tab: DealerTab;
+  /** 1 for a breakdown of the total above it. */
+  depth: 0 | 1;
+  /** The levels the row sums, in the release's series ids. */
+  keys: readonly string[];
 }
 
 export interface DealerRow {
-  keyid: string;
+  id: string;
   label: string;
   tab: DealerTab;
+  depth: 0 | 1;
+  /** The total a breakdown row belongs to; null for a total. */
+  parent: string | null;
+  /** The release's series behind the row; its history is their sum. */
+  keys: readonly string[];
   asOf: string | null;
   latest: number | null;
   previous: number | null;
   change: number | null;
 }
 
-function seriesBreakYear(seriesBreak: string): number {
-  const match = /(\d{4})$/.exec(seriesBreak);
-  return match ? Number(match[1]) : 0;
-}
+const total = (id: string, label: string, ...keys: string[]): RowDef => ({ id, label, tab: "positions", depth: 0, keys });
+const part = (id: string, label: string, ...keys: string[]): RowDef => ({ id, label, tab: "positions", depth: 1, keys });
 
-function newestSeriesBreak(entries: readonly CatalogEntry[]): string | null {
-  let best: string | null = null;
-  let bestYear = -1;
-  for (const entry of entries) {
-    const year = seriesBreakYear(entry.seriesBreak);
-    if (best == null || year > bestYear || (year === bestYear && entry.seriesBreak > best)) {
-      best = entry.seriesBreak;
-      bestYear = year;
-    }
-  }
-  return best;
-}
+/**
+ * The positions the board shows, in reading order: a total, then what it is
+ * made of. Every total is the exact sum of its breakdown in each week of the
+ * release (the Fed's own description of the Treasury total says it leaves TIPS
+ * out, and its numbers include them), so the breakdown always adds up.
+ */
+const POSITION_ROWS: readonly RowDef[] = [
+  total("treasuries", "Treasuries", "PDPOSGST-TOT"),
+  part("bills", "Bills", "PDPOSGS-B"),
+  part("coupons-0-2", "Coupons 0-2y", "PDPOSGSC-L2"),
+  part("coupons-2-3", "Coupons 2-3y", "PDPOSGSC-G2L3"),
+  part("coupons-3-6", "Coupons 3-6y", "PDPOSGSC-G3L6"),
+  part("coupons-6-7", "Coupons 6-7y", "PDPOSGSC-G6L7"),
+  part("coupons-7-11", "Coupons 7-11y", "PDPOSGSC-G7L11"),
+  part("coupons-11-21", "Coupons 11-21y", "PDPOSGSC-G11L21"),
+  part("coupons-21", "Coupons 21y+", "PDPOSGSC-G21"),
+  part("tips", "TIPS", "PDPOSTIPS-L2", "PDPOSTIPS-G2", "PDPOSTIPS-G6L11", "PDPOSTIPS-G11"),
+  part("frn", "FRN", "PDPOSGS-BFRN"),
+  total("agency", "Agency & GSE", "PDPOSFGS-TOT"),
+  part("agency-coupons", "Agency coupons", "PDPOSFGS-C"),
+  part("discount-notes", "Discount notes", "PDPOSFGS-DN"),
+  total("mbs", "MBS", "PDPOSMBS-TOT"),
+  part("tba", "TBA", "PDPOSMBSFGS-TBA"),
+  part("pools", "Specified pools", "PDPOSMBSFGS-ST"),
+  part("agency-resi", "Other agency MBS", "PDPOSMBSFGS-OR"),
+  part("agency-cmbs", "Agency CMBS", "PDPOSMBSFGS-C"),
+  part("nonagency-resi", "Non-agency residential", "PDPOSMBSNA-R"),
+  part("nonagency-cmbs", "Non-agency CMBS", "PDPOSMBSNA-O"),
+  total("corporates", "Corporates", "PDPOSCS-TOT"),
+  part("ig", "IG bonds", "PDPOSCSBND-L13", "PDPOSCSBND-G13", "PDPOSCSBND-G5L10", "PDPOSCSBND-G10"),
+  part("hy", "HY bonds", "PDPOSCSBND-BELL13", "PDPOSCSBND-BELG13", "PDPOSCSBND-BELG5L10", "PDPOSCSBND-BELG10"),
+  part("cp", "Commercial paper", "PDPOSCSCP"),
+  total("munis", "Munis", "PDPOSSMGO-TOT"),
+  total("abs", "ABS", "PDPOSABS-TOT"),
+];
 
-function isWeeklyChange(entry: CatalogEntry): boolean {
-  return /change from previous/i.test(entry.description) || /C$/i.test(entry.keyid);
-}
+/**
+ * Settlement fails: deliver, then receive, for each asset, as the release
+ * names them (PDFTD and PDFTR). Corporate and agency-debt fails stay off: they
+ * are a different order of size and not what the tab is read for.
+ */
+const FAIL_ASSETS = [
+  ["USTET", "Treasuries ex-TIPS"],
+  ["UST", "TIPS"],
+  ["FGM", "Agency MBS"],
+  ["OM", "Other MBS"],
+] as const;
 
-function describesTreasury(description: string): boolean {
-  return /\bTREASURY\b/i.test(description);
-}
+const FAIL_ROWS: readonly RowDef[] = FAIL_ASSETS.flatMap(([asset, label]) => [
+  { id: `PDFTD-${asset}`, label: `${label}, fails to deliver`, tab: "fails" as const, depth: 0 as const, keys: [`PDFTD-${asset}`] },
+  { id: `PDFTR-${asset}`, label: `${label}, fails to receive`, tab: "fails" as const, depth: 0 as const, keys: [`PDFTR-${asset}`] },
+]);
 
-function describesMbs(description: string): boolean {
-  const text = description.replace(/excluding mbs/gi, "");
-  return /\bMBS\b/i.test(text) || /mortgage/i.test(text);
-}
+/** Every series a board needs, with the series that holds each one's change from the week before. */
+export const changeSeriesId = (key: string): string => `${key}C`;
 
-function isAggregateTotal(entry: CatalogEntry): boolean {
-  if (isWeeklyChange(entry)) return false;
-  return entry.keyid.toUpperCase().endsWith("-TOT") || /^\s*total\b/i.test(entry.description);
+/** Sums with the float noise of fractional $mn figures rounded away. */
+function sum(values: readonly number[]): number {
+  return Math.round(values.reduce((all, value) => all + value, 0) * 1e6) / 1e6;
 }
 
-function isExcludedAsset(entry: CatalogEntry): boolean {
-  const id = entry.keyid.toUpperCase();
-  if (id.endsWith("-CS") || id.endsWith("-CSC") || id.endsWith("-FGEM") || id.endsWith("-FGEMC")) return true;
-  const text = entry.description.toUpperCase();
-  if (/\bCORPORATE\b|\bMUNICIPAL\b|\bASSET-BACKED\b|\bEQUITIES\b|\bEQUITY\b/.test(text)) return true;
-  return /EXCLUDING MBS/.test(text) && !/\bTREASURY\b/.test(text);
+function parentLabels(defs: readonly RowDef[]): Map<string, string | null> {
+  const parents = new Map<string, string | null>();
+  let current: string | null = null;
+  for (const def of defs) {
+    if (def.depth === 0) current = def.label;
+    parents.set(def.id, def.depth === 0 ? null : current);
+  }
+  return parents;
 }
 
-function isPositionAggregate(entry: CatalogEntry): boolean {
-  if (!entry.keyid.toUpperCase().startsWith("PDPOS")) return false;
-  if (!isAggregateTotal(entry)) return false;
-  return describesTreasury(entry.description) || describesMbs(entry.description);
+/**
+ * The board from the latest observation of every series. A row needs every
+ * series behind it, all from the same week (a sum with a part missing or from
+ * another week would be a different number), and is left out otherwise. Its
+ * change is the sum of the series' own published changes, equal to this week
+ * minus last week, and is empty when one of them is suppressed or from another
+ * week.
+ */
+export function buildDealerRows(latest: LatestBySeries): DealerRow[] {
+  const defs = [...POSITION_ROWS, ...FAIL_ROWS];
+  const parents = parentLabels(defs);
+  const rows: DealerRow[] = [];
+  for (const def of defs) {
+    const levels = def.keys.map((key) => latest.get(key));
+    const asOf = levels[0]?.asOf;
+    if (!asOf || levels.some((point) => point?.asOf !== asOf)) continue;
+    const changes = def.keys.map((key) => latest.get(changeSeriesId(key)));
+    const level = sum(levels.map((point) => point!.value));
+    const change = changes.every((point) => point?.asOf === asOf) ? sum(changes.map((point) => point!.value)) : null;
+    rows.push({
+      id: def.id,
+      label: def.label,
+      tab: def.tab,
+      depth: def.depth,
+      parent: parents.get(def.id) ?? null,
+      keys: def.keys,
+      asOf,
+      latest: level,
+      previous: change != null ? sum([level, -change]) : null,
+      change,
+    });
+  }
+  return rows;
 }
 
-function isFailKey(keyid: string): boolean {
-  const id = keyid.toUpperCase();
-  return FAIL_PREFIXES.some((prefix) => id.startsWith(prefix));
+export function boardAsOf(rows: readonly DealerRow[]): string | null {
+  let best: string | null = null;
+  for (const row of rows) {
+    if (row.asOf && (best == null || row.asOf > best)) best = row.asOf;
+  }
+  return best;
 }
 
-function isFailAggregate(entry: CatalogEntry): boolean {
-  if (!isFailKey(entry.keyid) || isWeeklyChange(entry) || isExcludedAsset(entry)) return false;
-  const id = entry.keyid.toUpperCase();
-  const named = describesTreasury(entry.description) || describesMbs(entry.description)
-    || id.includes("TIPS") || /(?:USTET|UST|FGM|OM)$/.test(id);
-  if (!named) return false;
-  if (isAggregateTotal(entry)) return true;
-  return /^(?:PDFAIL|PDFAS|PDFTD|PDFTR)-[A-Z0-9]+$/.test(id);
+/**
+ * The newest series break: the one the release is published in now. Breaks
+ * restate the series, so keys are only meaningful inside one.
+ */
+export function newestSeriesBreak(breaks: ReadonlyArray<{ seriesBreak: string; startDate: string }>): string | null {
+  let best: { seriesBreak: string; startDate: string } | null = null;
+  for (const entry of breaks) {
+    if (best == null || entry.startDate > best.startDate) best = entry;
+  }
+  return best?.seriesBreak ?? null;
 }
 
-function assetRank(entry: CatalogEntry): number {
-  const id = entry.keyid.toUpperCase();
-  if (id.includes("USTET") || id.includes("GST")) return 0;
-  if (id.includes("TIPS") || /-(?:UST)$/.test(id)) return 1;
-  if (id.includes("MBS") || id.endsWith("-FGM")) return 2;
-  if (id.endsWith("-OM")) return 3;
-  return 4;
+/** The dates every series has, with the sum of their values: a week a series is missing is not a week of the sum. */
+export function sumSeries(series: ReadonlyArray<readonly SeriesPoint[]>): SeriesPoint[] {
+  if (series.length === 0) return [];
+  const totals = new Map<string, { value: number; count: number }>();
+  for (const points of series) {
+    for (const point of points) {
+      const entry = totals.get(point.asOf);
+      if (entry) {
+        entry.value += point.value;
+        entry.count += 1;
+      } else {
+        totals.set(point.asOf, { value: point.value, count: 1 });
+      }
+    }
+  }
+  return [...totals.entries()]
+    .filter(([, entry]) => entry.count === series.length)
+    .map(([asOf, entry]) => ({ asOf, value: sum([entry.value]) }))
+    .sort((a, b) => (a.asOf < b.asOf ? -1 : a.asOf > b.asOf ? 1 : 0));
 }
 
-function byReadOrder(a: CatalogEntry, b: CatalogEntry): number {
-  const side = (entry: CatalogEntry) => entry.keyid.toUpperCase().startsWith("PDFTR") ? 1 : 0;
-  return assetRank(a) - assetRank(b) || side(a) - side(b) || a.keyid.localeCompare(b.keyid);
-}
+/** The chart's ranges; the release's current series start in July 2024, so a long one is all of it. */
+export const DEALER_RANGES = [
+  { value: "6M", label: "6M", hint: "1", days: 183 },
+  { value: "1Y", label: "1Y", hint: "2", days: 366 },
+  { value: "ALL", label: "All", hint: "3", days: null },
+] as const;
 
-export function selectSeries(entries: readonly CatalogEntry[]): SeriesSelection {
-  const seriesBreak = newestSeriesBreak(entries);
-  const current = seriesBreak ? entries.filter((entry) => entry.seriesBreak === seriesBreak) : [];
-  const positions = current.filter(isPositionAggregate).sort(byReadOrder).slice(0, SERIES_CAP);
-  const fails = current.filter(isFailAggregate).sort(byReadOrder).slice(0, Math.max(0, SERIES_CAP - positions.length));
-  return { seriesBreak: seriesBreak ?? "", positions, fails };
-}
+export type DealerRange = typeof DEALER_RANGES[number]["value"];
+export const DEFAULT_DEALER_RANGE: DealerRange = "1Y";
 
-function fallbackLabel(description: string, keyid: string): string {
-  let text = description.replace(/^\s*total\s*-\s*/i, "").trim();
-  const cut = text.search(/\s+-\s+|\s*:\s*/);
-  if (cut > 0) text = text.slice(0, cut).trim();
-  text = text.replace(/\s+/g, " ");
-  if (!text) return keyid;
-  return text.length <= 48 ? text : `${text.slice(0, 47).trimEnd()}…`;
+export function dealerRange(value: unknown): DealerRange {
+  return DEALER_RANGES.find((range) => range.value === value)?.value ?? DEFAULT_DEALER_RANGE;
 }
 
-function positionLabel(entry: CatalogEntry): string {
-  const id = entry.keyid.toUpperCase();
-  const asset = id.includes("USTET") || id.includes("GST") ? "Treasuries ex-TIPS"
-    : id.includes("TIPS") || /-(?:UST)$/.test(id) ? "TIPS"
-    : id.includes("MBS") || id.endsWith("-FGM") ? "Agency MBS"
-    : id.endsWith("-OM") ? "Other MBS"
-    : null;
-  if (!asset) return fallbackLabel(entry.description, entry.keyid);
-  if (id.startsWith("PDFTD")) return `${asset}, fails to deliver`;
-  if (id.startsWith("PDFTR")) return `${asset}, fails to receive`;
-  if (id.startsWith("PDFAIL") || id.startsWith("PDFAS")) return `${asset} fails`;
-  return asset;
+/** The points of the last `range`, counted back from the newest observation. */
+export function pointsInRange(points: readonly SeriesPoint[], range: DealerRange): SeriesPoint[] {
+  const days = DEALER_RANGES.find((entry) => entry.value === range)?.days ?? null;
+  const last = points.at(-1);
+  if (days == null || !last) return [...points];
+  const cutoff = Date.parse(`${last.asOf}T00:00:00Z`) - days * 86_400_000;
+  return points.filter((point) => Date.parse(`${point.asOf}T00:00:00Z`) >= cutoff);
 }
 
 export function formatLevel(value: number | null): string {
@@ -161,30 +228,13 @@ export function formatChange(value: number | null): string {
   return value > 0 ? `+${text}` : `-${text}`;
 }
 
-export function toDealerRow(
-  entry: CatalogEntry,
-  parsed: { keyid: string; latest: { asOf: string; value: number } | null; previous: { asOf: string; value: number } | null },
-  tab: DealerTab,
-): DealerRow {
-  const latest = parsed.latest?.value ?? null;
-  const previous = parsed.previous?.value ?? null;
-  return {
-    keyid: parsed.keyid || entry.keyid,
-    label: positionLabel(entry),
-    tab,
-    asOf: parsed.latest?.asOf ?? null,
-    latest,
-    previous,
-    change: latest != null && previous != null ? latest - previous : null,
-  };
-}
-
-export function boardAsOf(rows: readonly DealerRow[]): string | null {
-  let best: string | null = null;
-  for (const row of rows) {
-    if (row.asOf && (best == null || row.asOf > best)) best = row.asOf;
-  }
-  return best;
+/**
+ * The row's name, a breakdown set in under its total. The indent is no-break
+ * spaces: table cells do not wrap, and on the desktop that also folds ordinary
+ * leading spaces away.
+ */
+export function dealerRowLabel(row: Pick<DealerRow, "label" | "depth">): string {
+  return `${"\u00a0\u00a0".repeat(row.depth)}${row.label}`;
 }
 
 type DealerColumnId = "position" | "asOf" | "latest" | "previous" | "change";

package/src/plugins/builtin/primary-dealers/pane.tsx

@@ -1,24 +1,40 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import {
+  ChartTableHeader,
   DataTableView,
   PaneStatusBody,
+  QueryBar,
+  usePaneNoticeFooter,
   usePaneStatusFooter,
   usePaneTabs,
+  type ChartTableChart,
   type DataTableCell,
+  type DataTableKeyEvent,
 } from "../../../components";
+import { spanAxisFormatter } from "../../../components/chart-table";
+import { useChartViewReset } from "../../../components/chart/core/view-reset";
+import { scalarPoint, staticSeries } from "../../../components/chart/static/series";
 import { handleRefreshKey, usePaneRefreshKey } from "../../../components/data-table/table-pane";
 import { useAsyncResource } from "../../../react/async-resource";
 import { colors } from "../../../theme/colors";
 import type { PaneProps } from "../../../types/plugin";
 import { Box, TextAttributes } from "../../../ui";
+import { formatNumber } from "../../../utils/format";
+import { isPlainKeyboardEvent } from "../../../utils/keyboard";
 import { usePluginPaneState } from "../../runtime";
-import { fetchPrimaryDealers } from "./client";
+import { cachedDealerHistory, fetchPrimaryDealers, hasDealerHistory, loadDealerHistory } from "./client";
 import {
+  DEALER_RANGES,
+  DEFAULT_DEALER_RANGE,
   PRIMARY_DEALERS_PANE_ID,
   buildDealerColumns,
+  dealerRange,
+  dealerRowLabel,
   formatChange,
   formatLevel,
+  pointsInRange,
   type DealerColumn,
+  type DealerRange,
   type DealerRow,
   type DealerTab,
 } from "./model";
@@ -28,19 +44,49 @@ const TABS = [
   { label: "Fails", value: "fails" },
 ];
 const EMPTY_ROWS: DealerRow[] = [];
+const RANGE_OPTIONS = DEALER_RANGES.map(({ value, label, hint }) => ({ value, label, hint }));
+/** How long the selection rests before its history is read, so holding a key down the board reads one row, not all it passes. */
+const CHART_SETTLE_MS = 150;
+/** Ticks in the table's own figures (whole $mn), with decimals only where the plotted range is narrow. */
+const formatLevelAxis = spanAxisFormatter((value, digits) => formatNumber(value, digits));
 
 function changeColor(value: number | null): string {
   if (value == null || value === 0) return colors.textMuted;
   return value > 0 ? colors.positive : colors.negative;
 }
 
+/** The row the chart follows: the selection once it rests, or at once when its history is already in hand. */
+function useChartRow(rows: readonly DealerRow[], selected: DealerRow | null, known: boolean): DealerRow | null {
+  const [restedId, setRestedId] = useState<string | null>(null);
+  const selectedId = selected?.id ?? null;
+  useEffect(() => {
+    if (selectedId === restedId) return;
+    if (selectedId == null || restedId == null || known || !rows.some((row) => row.id === restedId)) {
+      setRestedId(selectedId);
+      return;
+    }
+    const timer = setTimeout(() => setRestedId(selectedId), CHART_SETTLE_MS);
+    return () => clearTimeout(timer);
+  }, [known, restedId, rows, selectedId]);
+  if (known) return selected;
+  return rows.find((row) => row.id === restedId) ?? selected;
+}
+
 export function PrimaryDealersPane({ focused, width, height }: PaneProps) {
   const request = useCallback(() => fetchPrimaryDealers(), []);
   const { data, loading, error, load } = useAsyncResource(request);
   const [storedTab, setTab] = usePluginPaneState<string>("tab", "positions");
   const tab: DealerTab = storedTab === "fails" ? "fails" : "positions";
-  const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [positionId, setPositionId] = usePluginPaneState<string | null>("selected:positions", null);
+  const [failId, setFailId] = usePluginPaneState<string | null>("selected:fails", null);
+  const [storedRange, setStoredRange] = usePluginPaneState<string>("range", DEFAULT_DEALER_RANGE);
+  const range = dealerRange(storedRange);
+  const resetChartView = useChartViewReset();
   const rows = tab === "fails" ? data?.fails ?? EMPTY_ROWS : data?.positions ?? EMPTY_ROWS;
+  const selectedId = tab === "fails" ? failId : positionId;
+  const setSelectedId = tab === "fails" ? setFailId : setPositionId;
+  const selected = rows.find((row) => row.id === selectedId) ?? rows[0] ?? null;
+  const seriesBreak = data?.seriesBreak ?? null;
   const asOf = useMemo(() => {
     let best: string | null = null;
     for (const row of rows) {
@@ -54,15 +100,57 @@ export function PrimaryDealersPane({ focused, width, height }: PaneProps) {
     [asOf],
   );
 
-  useEffect(() => {
-    if (selectedId && rows.some((row) => row.keyid === selectedId)) return;
-    setSelectedId(rows[0]?.keyid ?? null);
-  }, [rows, selectedId]);
+  // The chart follows the selected row. Its history is read for that row alone.
+  const known = !!selected && !!seriesBreak && hasDealerHistory(seriesBreak, selected);
+  const chartRow = useChartRow(rows, selected, known);
+  const loadHistory = useMemo(
+    () => chartRow && seriesBreak ? (force: boolean) => loadDealerHistory(seriesBreak, chartRow, force) : null,
+    [chartRow, seriesBreak],
+  );
+  const historyResource = useAsyncResource(loadHistory, { keepPreviousData: true });
+  const history = useMemo(
+    () => (chartRow && seriesBreak ? cachedDealerHistory(seriesBreak, chartRow) : null) ?? historyResource.data,
+    [chartRow, historyResource.data, seriesBreak],
+  );
+  // While another row's history loads the chart keeps the last one drawn, unless that row is not on this tab.
+  const historyRow = history ? rows.find((row) => row.id === history.rowId) ?? null : null;
+  const series = useMemo(() => history && historyRow
+    ? [staticSeries(
+      pointsInRange(history.points, range).map((point) => scalarPoint(new Date(`${point.asOf}T00:00:00Z`), point.value)),
+      { id: historyRow.id, label: `${historyRow.label} $mn`, color: colors.positive, calendarSpaced: true },
+    )]
+    : [], [history, historyRow, range]);
+  const historyFailed = history?.rowId !== chartRow?.id && !!historyResource.error;
+  const chart: ChartTableChart | null = selected && !historyFailed ? {
+    series,
+    formatValue: formatLevel,
+    formatAxisValue: formatLevelAxis,
+    remoteKind: "primary-dealer-history",
+    loading: !historyRow,
+    empty: `No history for ${selected.label}`,
+  } : null;
 
-  const refresh = useCallback(() => { void load(); }, [load]);
+  const { reload: reloadHistory } = historyResource;
+  const refresh = useCallback(() => {
+    void load();
+    void reloadHistory();
+  }, [load, reloadHistory]);
   const selectTab = useCallback((value: string) => setTab(value === "fails" ? "fails" : "positions"), [setTab]);
+  const selectRange = useCallback((value: DealerRange) => setStoredRange(value), [setStoredRange]);
   usePaneRefreshKey(refresh, { focused });
 
+  // The number keys pick the range, as the bar's hints say; picking the one showing sends the chart back to it.
+  const handleKeyDown = useCallback((event: DataTableKeyEvent) => {
+    if (handleRefreshKey(event, refresh, { stopPropagation: true })) return true;
+    if (!isPlainKeyboardEvent(event)) return false;
+    const picked = DEALER_RANGES.find((option) => option.hint === event.name);
+    if (!picked) return false;
+    event.preventDefault?.();
+    if (picked.value === range) resetChartView();
+    else selectRange(picked.value);
+    return true;
+  }, [range, refresh, resetChartView, selectRange]);
+
   const { strip: tabs, rows: tabRows } = usePaneTabs({
     tabs: TABS,
     activeValue: tab,
@@ -78,6 +166,11 @@ export function PrimaryDealersPane({ focused, width, height }: PaneProps) {
     error,
     info: footerInfo,
   });
+  usePaneNoticeFooter({
+    registrationId: `${PRIMARY_DEALERS_PANE_ID}:history`,
+    focused,
+    notices: historyFailed && selected ? [`History for ${selected.label} is unavailable: ${historyResource.error}`] : [],
+  });
 
   const renderCell = useCallback((
     row: DealerRow,
@@ -88,10 +181,12 @@ export function PrimaryDealersPane({ focused, width, height }: PaneProps) {
     const selectedColor = rowState.selected ? colors.selectedText : undefined;
     switch (column.id) {
       case "position":
+        // A breakdown reads under its total, in plain weight.
         return {
-          text: row.label,
-          color: selectedColor ?? colors.textBright,
-          attributes: TextAttributes.BOLD,
+          text: dealerRowLabel(row),
+          value: row.label,
+          color: selectedColor ?? (row.depth === 0 ? colors.textBright : colors.text),
+          attributes: row.depth === 0 ? TextAttributes.BOLD : undefined,
         };
       case "asOf":
         return { text: row.asOf ?? "—", color: selectedColor ?? colors.textMuted };
@@ -122,26 +217,51 @@ export function PrimaryDealersPane({ focused, width, height }: PaneProps) {
     );
   }
 
+  const rootHeight = Math.max(1, height - tabRows);
   return (
     <Box flexDirection="column" width={width} height={height}>
       {tabs}
       <DataTableView<DealerRow, DealerColumn>
         focused={focused}
         rootWidth={width}
-        rootHeight={Math.max(1, height - tabRows)}
+        rootHeight={rootHeight}
+        rootBefore={selected ? (
+          <ChartTableHeader
+            width={width}
+            height={rootHeight}
+            tableRows={rows.length}
+            tableColumns={columns}
+            query={(
+              <QueryBar
+                width={width}
+                filters={[{
+                  id: "range",
+                  label: "Range",
+                  inline: true,
+                  chartRange: true,
+                  value: range,
+                  options: RANGE_OPTIONS,
+                  onChange: (value: string) => selectRange(dealerRange(value)),
+                }]}
+              />
+            )}
+            chart={chart}
+          />
+        ) : undefined}
         selection={{
           kind: "id",
-          selectedId,
-          getId: (row) => row.keyid,
+          selectedId: selected?.id ?? null,
+          getId: (row) => row.id,
           onChange: (id) => setSelectedId(id),
         }}
-        onRootKeyDown={(event) => handleRefreshKey(event, refresh, { stopPropagation: true })}
+        onRootKeyDown={handleKeyDown}
         columns={columns}
         items={rows}
         sortColumnId={null}
         sortDirection="asc"
-        getItemKey={(row) => row.keyid}
+        getItemKey={(row) => row.id}
         renderCell={renderCell}
+        resetScrollKey={tab}
         emptyStateTitle={tab === "fails" ? "No fails in this release." : "No positions in this release."}
       />
     </Box>

package/src/plugins/builtin/research/analyst-model.ts

@@ -5,6 +5,7 @@ import { formatRelativeTime } from "../../../utils/datetime-format";
 import { displayWidth, formatCurrency, formatNumber } from "../../../utils/format";
 import { compareSortValues, type SortDirection } from "../../../utils/sort-values";
 import { loadingErrorFooterInfo } from "../../../components/data-table/table-pane";
+import { delayedFooterSegment } from "../../../components/layout/pane/footer/model";
 import { regularSessionValuationPrice } from "../../../market-data/quotes/regular-session-valuation";
 
 function compactPeriod(period: string): string {
@@ -369,14 +370,17 @@ export function buildAnalystStatusSegments(
 
   // The upside is only as good as the price it was measured against.
   if (reference.price != null) {
+    // A delayed price is the footer's clock beside it; a real-time one says so in words.
+    const delay = reference.freshness?.endsWith(" delayed") ? reference.freshness.slice(0, -" delayed".length) : null;
     segments.push({
       id: "analyst-reference-price",
       parts: [
         { text: "upside vs", tone: "label" },
         { text: price(reference.price) },
-        ...(reference.freshness ? [{ text: reference.freshness, tone: "muted" as const }] : []),
+        ...(reference.freshness && !delay ? [{ text: reference.freshness, tone: "muted" as const }] : []),
       ],
     });
+    if (delay) segments.push(delayedFooterSegment({ id: "analyst-reference-delay", detail: `Price ${reference.freshness}`, delay }));
   }
 
   if (!data.stale && data.fetchedAt) {