gloomberb 0.18.3 → 0.18.4

package/src/plugins/builtin/company-attention/signals-model.ts

@@ -0,0 +1,229 @@
+import type { DataTableColumn, StatItem } from "../../../components";
+import type { HiringCompanySignals, HiringMovePosting, HiringSignalFlag, HiringSignalGroup, HiringSignalHold, HiringSignalKind, HiringSignalSkip, HiringSignalsBoard, HiringSignalsFilter, HiringWeekSignal } from "../../../api-client/hiring";
+import { formatNumber } from "../../../utils/format";
+import { countOf, freePreviewNote, previewCantFilter } from "../shared/free-preview";
+import { humanLabel } from "../shared/research-cells";
+import type { AttentionRow } from "./model";
+
+/**
+ * HIRE's Expansion and Anomalies tabs (docs/hiring-app-attention.md):
+ * a company's first roles in a country or city, one place or role family far
+ * above its own weeks, and role families it never posted, in the latest
+ * complete week. "Never" goes back to the company's first read: a first is
+ * the first seen since then, never the first ever, and every row says since when.
+ */
+export type SignalsView = "signals" | "postings";
+export const SIGNALS_VIEWS: ReadonlyArray<{ value: SignalsView; label: string }> = [{ value: "signals", label: "Signals" }, { value: "postings", label: "Postings" }];
+export const isSignalsView = (value: string): value is SignalsView => SIGNALS_VIEWS.some((view) => view.value === value);
+export const SIGNAL_GROUPS: readonly HiringSignalGroup[] = ["expansion", "anomalies"];
+export const isSignalGroup = (value: string): value is HiringSignalGroup => (SIGNAL_GROUPS as readonly string[]).includes(value);
+export const SIGNAL_FILTERS: Record<HiringSignalGroup, ReadonlyArray<{ value: HiringSignalsFilter; label: string }>> = {
+  expansion: [{ value: "all", label: "All" }, { value: "new_country", label: "New countries" }, { value: "new_city", label: "New cities" }],
+  anomalies: [{ value: "all", label: "All" }, { value: "location_spike", label: "Place spikes" }, { value: "function_spike", label: "Role family spikes" }, { value: "new_role_type", label: "New role families" }],
+};
+export const isSignalsFilter = (group: HiringSignalGroup, value: string): value is HiringSignalsFilter => SIGNAL_FILTERS[group].some((filter) => filter.value === value);
+
+const KIND_LABELS: Record<HiringSignalKind, string> = {
+  new_country: "New country", new_city: "New city", location_spike: "Place spike", function_spike: "Family spike", new_role_type: "New family",
+};
+/** Shown, ranked last: the count may not keep to its week. */
+const FLAG_LABELS: Record<HiringSignalFlag, string> = { few_reads: "Few reads", one_day_batch: "One-day batch" };
+const HOLD_LABELS: Record<HiringSignalHold, string> = {
+  unmeasured: "Week not measured: the collection changed",
+  short_watch: "Read for under three weeks before it",
+  recounted: "Postings well above its new roles (re-listed roles)",
+};
+const SKIP_LABELS: Record<HiringSignalSkip, string> = {
+  thin_history: "Under 6 weeks of reads or 100 earlier postings",
+  unplaced_history: "Under 90% of earlier postings placed",
+  unplaced_cities: "Under 90% of earlier postings naming a city",
+  unclassified_history: "Under 90% of earlier postings with a role family",
+  reformatted: "Its boards wrote their places anew",
+  posted_before_watch: "Roles dated before its first read",
+  similar_city: "A new city named like a known one",
+  one_day: "A spike mostly posted on one day",
+};
+const kindText = (kind: HiringSignalKind) => KIND_LABELS[kind] ?? humanLabel(kind);
+const flagText = (signal: Pick<HiringWeekSignal, "flags">) => signal.flags.map((flag) => FLAG_LABELS[flag] ?? humanLabel(flag)).join(", ") || null;
+export const holdText = (hold: HiringSignalHold) => HOLD_LABELS[hold] ?? humanLabel(hold);
+const skipText = (skips: readonly HiringSignalSkip[]) => skips.map((skip) => SKIP_LABELS[skip] ?? humanLabel(skip)).join(", ");
+const isFirst = (signal: Pick<HiringWeekSignal, "kind">) => signal.kind === "new_country" || signal.kind === "new_city" || signal.kind === "new_role_type";
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+/** "Oct 12": a week's Monday or a first read's day. */
+function dayLabel(value: string | null | undefined, year = false): string {
+  const match = /^(\d{4})-(\d{2})-(\d{2})/.exec(value ?? "");
+  return match ? `${MONTHS[Number(match[2]) - 1]} ${Number(match[3])}${year ? `, ${match[1]}` : ""}` : "--";
+}
+const pace = (value: number | null | undefined) => value == null ? "--" : `${formatNumber(value, Math.abs(value) >= 10 ? 0 : 1)}x`;
+const count = (value: number | null | undefined) => value == null ? "--" : formatNumber(value, 0);
+const average = (value: number) => formatNumber(value, value < 10 ? 1 : 0);
+const signed = (value: number, decimals = 0) => `${value > 0 ? "+" : ""}${formatNumber(value, decimals)}`;
+const percent = (value: number | null) => value == null ? "--" : `${Math.round(value * 100)}%`;
+
+const PACE_COLUMNS = new Set(["pace", "companyPace"]);
+export const SIGNALS_SIGNED_COLUMNS = new Set(["z"]);
+/** A signals column's number as the pane and the report print it. */
+export function signalsNumber(columnId: string, value: number): string {
+  if (PACE_COLUMNS.has(columnId)) return pace(value);
+  if (columnId === "z") return signed(value, 1);
+  if (columnId === "mean") return average(value);
+  return count(value);
+}
+
+/** How far back "never" goes for this company: "Sep 17, 2026, none of 703 earlier postings (98% placed)". */
+function neverText(signal: HiringWeekSignal): string {
+  const what = signal.dimension === "function" ? "with a role family" : signal.dimension === "city" ? "naming a city" : "placed";
+  return `${dayLabel(signal.history.watchedSince, true)}, none of ${count(signal.history.priorPostings)} earlier postings (${percent(signal.history.priorShare)} ${what})`;
+}
+
+/** A signal's numbers, as its detail lists them with the sentence that says why. */
+export function signalFacts(signal: HiringWeekSignal): Array<{ label: string; value: string }> {
+  const baseline = signal.baseline;
+  return [
+    { label: "Signal", value: kindText(signal.kind) },
+    { label: signal.dimension === "function" ? "Role family" : signal.dimension === "city" ? "City" : "Country", value: signal.label },
+    { label: "New roles", value: `${count(signal.newRoles)} under ${countOf(signal.titles, "title")}, week of ${dayLabel(signal.week, true)}` },
+    ...(isFirst(signal) ? [{ label: "First seen since", value: neverText(signal) }] : []),
+    ...(baseline ? [
+      { label: "Average before", value: `${average(baseline.mean)} a week over ${countOf(baseline.weeks, "measured week")}${baseline.values.length ? `: ${baseline.values.map((row) => count(row.newRoles)).join(", ")}` : ""}` },
+      { label: "Pace", value: `${pace(signal.ratio)} its average${signal.zScore == null ? "" : `, z ${signed(signal.zScore, 1)}`}` },
+      { label: "Company pace", value: `${pace(signal.companyRatio)}, ${signal.dimension === "function" ? "its roles with a role family" : signal.dimension === "city" ? "its roles placed in a city" : "its placed roles"}` },
+    ] : []),
+    ...(signal.flags.length ? [{ label: "Check", value: `${flagText(signal)}${signal.reads != null ? `, ${countOf(signal.reads, "read")} that week` : ""}` }] : []),
+    ...(signal.places.length ? [{ label: signal.dimension === "country" ? "Cities" : "Where", value: signal.places.map((row) => `${row.label} (${count(row.count)})`).join(", ") }] : []),
+    ...(signal.topTitles.length ? [{ label: "Top titles", value: signal.topTitles.map((row) => `${row.title.trim()} (${count(row.count)})`).join(", ") }] : []),
+    { label: "Boards", value: signal.sourceTickers.join(", ") },
+    { label: "First computed", value: signal.firstComputedAt },
+  ];
+}
+
+export interface SignalsRow extends AttentionRow {
+  signal?: HiringWeekSignal;
+  jobPosting?: HiringMovePosting;
+}
+export interface SignalsSection {
+  columns: DataTableColumn[];
+  rows: SignalsRow[];
+  empty: string;
+  locked: number;
+}
+export interface SignalsModel {
+  asOf: string | null;
+  week: string | null;
+  preview: boolean;
+  figures: StatItem[];
+  sections: Partial<Record<SignalsView | "board", SignalsSection>>;
+  /** Why a company's week gives none, for its report. */
+  held: string | null;
+}
+
+const column = (id: string, label: string, width: number, numeric = false, flex = false): DataTableColumn => ({ id, label, width, align: numeric ? "right" : "left", ...(flex ? { flexGrow: 1 } : {}) });
+const CHECK_COLUMN = column("check", "Check", 14);
+const EXPANSION_COLUMNS = [column("symbol", "Ticker", 12), column("name", "Company", 20, false, true), column("kind", "Signal", 12), column("label", "Where", 24),
+  column("newRoles", "New roles", 10, true), column("titles", "Titles", 7, true), column("prior", "Earlier", 9, true), column("since", "Since", 8), column("title", "Top title", 26)];
+const ANOMALY_COLUMNS = [column("symbol", "Ticker", 12), column("name", "Company", 20, false, true), column("kind", "Signal", 13), column("label", "What", 24),
+  column("newRoles", "New roles", 10, true), column("mean", "Avg / week", 11, true), column("pace", "Pace", 7, true), column("z", "Z-score", 9, true), column("companyPace", "Company", 8, true)];
+
+/** The row's place for a flag: a country code, or a city's. */
+const placeCountry = (signal: HiringWeekSignal) => signal.dimension === "function" ? null : signal.country;
+const topTitle = (signal: HiringWeekSignal) => signal.topTitles[0]?.title.trim() ?? signal.postings[0]?.title.trim() ?? null;
+const signalRow = (signal: HiringWeekSignal, withWeek = false): SignalsRow => ({
+  id: `${signal.symbol}:${signal.week}:${signal.kind}:${signal.key}`, symbol: signal.symbol, signal, date: signal.week,
+  values: { ...(withWeek ? { week: signal.week } : {}), symbol: signal.symbol, name: signal.name, kind: kindText(signal.kind), label: signal.label, country: placeCountry(signal),
+    newRoles: signal.newRoles, titles: signal.titles, prior: isFirst(signal) ? signal.history.priorPostings : null, since: isFirst(signal) ? dayLabel(signal.history.watchedSince) : null,
+    title: topTitle(signal), mean: signal.baseline?.mean ?? null, pace: signal.ratio, z: signal.zScore, companyPace: signal.companyRatio, check: flagText(signal) },
+});
+
+const columnsFor = (group: HiringSignalGroup, signals: readonly HiringWeekSignal[]) => {
+  const base = group === "expansion" ? EXPANSION_COLUMNS : ANOMALY_COLUMNS;
+  return signals.some((signal) => signal.flags.length) ? [...base, CHECK_COLUMN] : base;
+};
+
+function boardFigures(board: HiringSignalsBoard): StatItem[] {
+  const { coverage } = board;
+  const counts = (kind: HiringSignalKind) => count(coverage.counts[kind] ?? 0);
+  const held = Object.values(coverage.held).reduce<number>((sum, value) => sum + (value ?? 0), 0);
+  const own = board.group === "expansion"
+    ? [{ label: "New countries", value: counts("new_country") }, { label: "New cities", value: counts("new_city") }]
+    : [{ label: "Place spikes", value: counts("location_spike") }, { label: "Family spikes", value: counts("function_spike") }, { label: "New families", value: counts("new_role_type") }];
+  return board.week ? [
+    ...own,
+    { label: "Measured", value: count(coverage.measured), detail: `week of ${dayLabel(board.week)}`, detailVariants: [`wk ${dayLabel(board.week)}`, ""] },
+    // How far back "never" goes: the first reads of the companies measured.
+    ...(board.group === "expansion" || coverage.watchedFrom ? [{ label: "First seen since", value: dayLabel(coverage.watchedFrom), detail: "first reads", detailVariants: [""] }] : []),
+    { label: "Held", value: count(held), detail: "week not comparable", detailVariants: [""] },
+  ] : [];
+}
+
+export function signalsBoardModel(board: HiringSignalsBoard, filter: HiringSignalsFilter): SignalsModel {
+  const label = board.group === "expansion" ? "No company posted its first roles in a new country or city this week." : "No place or role family stood out from a company's own weeks this week.";
+  return {
+    asOf: board.coverage.computedAt,
+    week: board.week,
+    preview: board.preview,
+    figures: boardFigures(board),
+    held: null,
+    sections: { board: { columns: columnsFor(board.group, board.signals), rows: board.signals.map((signal) => signalRow(signal)), locked: board.preview ? board.locked : 0,
+      empty: !board.week ? "No week has been computed yet." : filter === "all" ? label : "None of this kind this week." } },
+  };
+}
+
+const POSTING_COLUMNS = [column("title", "Role", 32, false, true), column("location", "Location", 24), column("signal", "Signal", 22), column("function", "Role family", 16), column("date", "First seen", 12)];
+const roleFamily = (value: string | null) => value === "data_ai" ? "Data / AI" : value ? humanLabel(value) : null;
+const postingRow = (signal: HiringWeekSignal) => (posting: HiringMovePosting): SignalsRow => ({
+  id: `${signal.kind}:${signal.key}:${posting.id}`, url: posting.url, jobPosting: posting, signal,
+  values: { title: posting.title.trim(), location: posting.location ?? posting.country, country: posting.country, signal: `${kindText(signal.kind)}: ${signal.label}`,
+    function: roleFamily(posting.jobFunction), date: posting.firstSeenAt.slice(0, 10) },
+  details: [{ label: "Posting title", value: posting.title.trim() }, { label: "Location", value: posting.location ?? "--" }, { label: "Country", value: posting.country ?? "Unknown" },
+    { label: "Role family", value: roleFamily(posting.jobFunction) ?? "Unclassified" }, { label: "Signal", value: `${kindText(signal.kind)}: ${signal.label}` },
+    { label: "First seen", value: posting.firstSeenAt }, { label: "Board", value: posting.sourceTicker }],
+});
+
+/** A company's signals of one group: this week's, then earlier weeks', and the postings behind this week's. */
+export function companySignalsModel(data: HiringCompanySignals, group: HiringSignalGroup): SignalsModel {
+  const current = data.signals.filter((signal) => signal.group === group);
+  const earlier = data.history.filter((signal) => signal.group === group);
+  const held = data.held ? holdText(data.held) : null;
+  // A free read counts what it holds back by tab; a server before that, both tabs together.
+  const lockedRows = !data.preview ? 0 : data.locked[group] ?? data.locked.signals + data.locked.history;
+  const figures: StatItem[] = data.week ? [
+    { label: "Signals", value: count(current.length), detail: `week of ${dayLabel(data.week)}`, detailVariants: [`wk ${dayLabel(data.week)}`, ""] },
+    ...(data.preview && lockedRows ? [{ label: "In Pro", value: count(lockedRows), detail: "this week and earlier", detailVariants: [""] }] : []),
+    ...(data.watchedSince ? [{ label: "First seen since", value: dayLabel(data.watchedSince), detail: "its first read", detailVariants: [""] }] : []),
+    ...(held ? [{ label: "No signal", value: held, wide: true }] : data.skipped.length ? [{ label: "Not looked for", value: skipText(data.skipped), wide: true }] : []),
+  ] : [];
+  const empty = held ? `No signal this week: ${held.toLowerCase()}.` : lockedRows ? `This company's ${group === "expansion" ? "expansion" : "anomaly"} signals are in Pro.`
+    : group === "expansion" ? "No first in a new country or city this week." : "Nothing stood out from this company's own weeks this week.";
+  return {
+    asOf: current[0]?.computedAt ?? data.history[0]?.computedAt ?? null,
+    week: data.week,
+    preview: data.preview,
+    figures,
+    held,
+    sections: {
+      // A company's rows have room for the title that leads them.
+      signals: { columns: [column("week", "Week of", 12), ...columnsFor(group, [...current, ...earlier]).filter((entry) => entry.id !== "symbol" && entry.id !== "name" && entry.id !== "title"), column("title", "Top title", 30, false, true)],
+        rows: [...current, ...earlier].map((signal) => signalRow(signal, true)), locked: lockedRows, empty },
+      postings: { columns: POSTING_COLUMNS, rows: current.flatMap((signal) => signal.postings.map(postingRow(signal))), locked: 0,
+        empty: current.length ? "No posting is listed behind this week's signals." : empty },
+    },
+  };
+}
+
+/**
+ * The lock line of a free signals read: what free shows and what Pro adds.
+ * Null when nothing is held back. A free board is the same three whatever
+ * `filter` asked for.
+ */
+export function signalsPreviewNote(data: HiringSignalsBoard | HiringCompanySignals, filter?: HiringSignalsFilter): string | null {
+  if (!data.preview) return null;
+  if ("group" in data) {
+    const shows = `${data.signals.length} of ${count(data.total)} ${data.group === "expansion" ? "expansion" : "anomaly"} signals${filter && filter !== "all" ? `: ${previewCantFilter(["kind"])}` : ""}`;
+    return data.locked > 0 ? freePreviewNote({ shows, adds: `the other ${count(data.locked)} and every posting behind them` }) : null;
+  }
+  const { signals, history } = data.locked;
+  if (signals + history <= 0) return null;
+  const adds = [signals > 0 ? countOf(signals, "signal") : "", history > 0 ? `${countOf(history, "earlier signal")}` : ""].filter(Boolean);
+  return freePreviewNote({ shows: "the signals the free boards show", adds: adds.join(" and ") });
+}

package/src/plugins/builtin/company-attention/signals.tsx

@@ -0,0 +1,160 @@
+import { useCallback, useMemo, useRef, type ReactNode } from "react";
+import { isAccessDenied } from "../../../api-client/errors";
+import type { HiringSignalGroup, HiringSignalsFilter, HiringWeekSignal } from "../../../api-client/hiring";
+import { ChartTableHeader, DataTableView, PageStackView, PaneFooterScope, PaneLinkMenu, QueryBar, usePagedRows, usePaneStatusFooter, useTableLoadMore, withCountryFlag, type PaneHint } from "../../../components";
+import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { DetailReader, type DetailFact } from "../../../components/reader/detail-reader";
+import { useAsyncResource, useAutoRefresh, usePaneSettingValue, usePluginAppActions, usePluginPaneState } from "../../../public/react";
+import { useThemeColors } from "../../../theme/theme-context";
+import { Text, useRendererHost, useUiCapabilities, type ScrollBoxRenderable } from "../../../ui";
+import { CLOUD_PLAN_KEY, useCloudUpgradeAction } from "../shared/cloud-upgrade";
+import { Blurred, LockedOverlay, UpgradeLabel } from "../shared/locked-rows";
+import { useOpenDescription } from "../shared/open-description";
+import { listingCell, missingCell, signedColor, toneColor, withoutQuietColumns } from "../shared/research-cells";
+import { cachedSignals, fetchSignals, loadSignals, validateSignals, type SignalsPayload } from "./client";
+import { sortAttentionRows } from "./model";
+import { companySignalsModel, isSignalsFilter, isSignalsView, signalFacts, signalsBoardModel, signalsNumber, SIGNAL_FILTERS, SIGNALS_SIGNED_COLUMNS, SIGNALS_VIEWS, type SignalsRow } from "./signals-model";
+
+const rowId = (row: SignalsRow) => row.id;
+const locked = (row: SignalsRow) => row.id.startsWith("locked:");
+/** A board with no first, or a company with no spike, leaves those columns out. */
+const QUIET_COLUMNS: Record<string, readonly string[]> = { prior: [""], since: [""], mean: [""], pace: [""], z: [""], companyPace: [""], title: [""] };
+/** Postings a signal's detail links to, so the sentence after them stays in view; the Postings view lists them all. */
+const DETAIL_POSTINGS = 3;
+
+export interface HiringSignalsViewProps {
+  group: HiringSignalGroup;
+  symbol?: string;
+  width: number;
+  height: number;
+  focused: boolean;
+  /** Plan and session, so a cached read is never shown to the wrong account. */
+  accessKey: string;
+  /** The board opens a company on the same tab, as Moves does. */
+  company?: { open: string | null; onOpen: (symbol: string | null) => void; render: (symbol: string, width: number, height: number) => ReactNode };
+}
+
+/**
+ * HIRE's Expansion and Anomalies tabs. Alone, the latest week's signals of
+ * the group: Enter opens the company, `e` says why. On a ticker, the
+ * company's own signals of the group, this week's and earlier, and the
+ * postings behind this week's, each linking to the employer's page.
+ */
+export function HiringSignalsView({ group, symbol, width, height, focused, accessKey, company }: HiringSignalsViewProps) {
+  const colors = useThemeColors();
+  const desktop = !!useUiCapabilities().nativePaneChrome;
+  const host = useRendererHost();
+  const { createPaneFromTemplate } = usePluginAppActions();
+  const openDescription = useOpenDescription();
+  const upgrade = useCloudUpgradeAction("hire");
+  const scope = `hiring:${group}:${symbol ?? "board"}`;
+  const [openingFilter] = usePaneSettingValue<string>("signalsKind", "all");
+  const [storedFilter, setFilter] = usePluginPaneState<string>(`hiring:${group}:filter`, openingFilter);
+  const filter: HiringSignalsFilter = isSignalsFilter(group, storedFilter) ? storedFilter : "all";
+  const [openingView] = usePaneSettingValue<string>("signalsView", "signals");
+  const [storedView, setView] = usePluginPaneState<string>(`${scope}:view`, openingView);
+  const view = isSignalsView(storedView) ? storedView : "signals";
+  const [snapshotSetting] = usePaneSettingValue<SignalsPayload | null>(`${group}Snapshot`, null);
+  // A `gloom shot` hands the payload in; a company opened from a board snapshot still loads its own.
+  const snapshot = useMemo(() => {
+    try {
+      const payload = snapshotSetting ? validateSignals(snapshotSetting) : null;
+      return payload && ("group" in payload ? !symbol && payload.group === group : payload.symbol.toUpperCase() === symbol?.toUpperCase()) ? payload : null;
+    } catch { return null; }
+  }, [snapshotSetting, symbol, group]);
+  const loader = useCallback((force: boolean) => snapshot ? Promise.resolve({ payload: snapshot, stale: false, refreshError: null }) : loadSignals(group, symbol, accessKey, filter, force), [snapshot, group, symbol, accessKey, filter]);
+  const resource = useAsyncResource(loader, { initialData: () => cachedSignals(group, symbol, accessKey, filter), clearOnError: isAccessDenied, keepPreviousData: true });
+  const data = resource.data?.payload;
+  const model = useMemo(() => !data ? null : "group" in data ? signalsBoardModel(data, filter) : companySignalsModel(data, group), [data, filter, group]);
+  const sectionId = symbol ? view : "board";
+  const section = model?.sections[sectionId];
+  const pageLoader = useCallback(async ({ offset, signal }: { offset: number; signal: AbortSignal; force: boolean }) => {
+    const payload = offset === 0 && data ? data : await fetchSignals(group, undefined, { filter, offset, limit: 100 }, undefined, signal);
+    if (!("group" in payload)) return { rows: [], hasMore: false, nextOffset: null };
+    const next = !payload.preview && offset + payload.signals.length < payload.total ? offset + payload.signals.length : null;
+    return { rows: signalsBoardModel(payload, filter).sections.board!.rows, hasMore: !snapshot && next !== null, nextOffset: next };
+  }, [data, group, filter, snapshot]);
+  const paged = usePagedRows(data && !symbol ? pageLoader : null, { getId: rowId });
+  const sectionRows = !symbol && paged.status !== "idle" ? paged.rows : section?.rows ?? [];
+  // The board keeps the server's order (unflagged first, the largest rises first) until a header is clicked.
+  const [sort, setSort] = usePluginPaneState<{ column: string; direction: "asc" | "desc" } | null>(`${scope}:${sectionId}:sort`, null);
+  const lockedRows = Math.min(3, section?.locked ?? 0);
+  const upgradeText = symbol ? "Upgrade for all signals" : `Upgrade for all ${group === "expansion" ? "expansion" : "anomaly"} signals`;
+  const rows = useMemo(() => [...(sort ? sortAttentionRows(sectionRows, sort.column, sort.direction) : sectionRows) as SignalsRow[],
+    ...Array.from({ length: lockedRows }, (_, index): SignalsRow => ({ id: `locked:${index}`, values: {} }))], [sectionRows, sort, lockedRows]);
+  const dataRows = useMemo(() => rows.filter((row) => !locked(row)), [rows]);
+  const columns = useMemo(() => !section ? [] : withoutQuietColumns(section.columns, dataRows, (row, id) => row.values[id] ?? "", QUIET_COLUMNS), [section, dataRows]);
+  const [selectedId, setSelected] = usePluginPaneState<string | null>(`${scope}:${sectionId}:selected`, null);
+  const openCompany = company?.open ?? null;
+  const [openRowId, setOpenRow] = usePluginPaneState<string | null>(`${scope}:open`, null);
+  const selected = rows.find((row) => row.id === selectedId) ?? rows[0] ?? null;
+  const opened = dataRows.find((row) => row.id === openRowId) ?? null;
+  const detailOpen = !!openCompany || !!opened;
+  const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+  const scrollMore = useTableLoadMore(scrollRef, paged.hasMore && !detailOpen, paged.loadMore);
+  useAutoRefresh(resource.updatedAt, resource.load);
+  usePaneRefreshKey(() => { void resource.reload(); paged.reload(); }, { focused: focused && !detailOpen });
+
+  const subject = selected?.symbol ?? symbol;
+  // A signal opens its first posting; a posting row its own.
+  const sourceRow = opened ?? selected;
+  const source = sourceRow?.jobPosting?.url ?? sourceRow?.signal?.postings[0]?.url ?? null;
+  const hints: PaneHint[] = [
+    ...(source ? [{ id: "source", key: "o", label: "pen source", onPress: () => void host.openExternal(source) }] : []),
+    // On a company Enter already opens a signal or a posting.
+    ...(!symbol && selected?.signal && !opened ? [{ id: "evidence", key: "e", label: "vidence", title: "Why it fired", onPress: () => setOpenRow(selected.id) }] : []),
+    ...(subject && !opened ? [
+      { id: "description", key: "d", label: "es", onPress: () => openDescription(subject) },
+      { id: "financials", key: "f", label: "a", onPress: () => createPaneFromTemplate("financial-analysis-pane", { symbol: subject }) },
+      { id: "chart", key: "g", label: "raph", onPress: () => createPaneFromTemplate("chart-composer-pane", { arg: subject }) },
+      { id: "related", key: "a", label: "pps", title: "App attention", onPress: () => createPaneFromTemplate("apps-pane", { symbol: subject }) },
+    ] : []),
+    ...(model?.preview ? [{ id: "upgrade", key: CLOUD_PLAN_KEY, label: "upgrade", title: "Upgrade to Pro", onPress: upgrade }] : []),
+  ];
+  usePaneStatusFooter({ registrationId: `${scope}:status`, enabled: !openCompany, loading: resource.loading || paged.loadingMore, error: data ? resource.error ?? paged.moreError?.message ?? paged.error?.message : null, stale: resource.data?.stale,
+    info: [...(model?.asOf ? [{ id: "observed", asOf: true, parts: [{ text: `as of ${model.asOf.slice(0, 10)}`, tone: "muted" as const }] }] : []), ...(model?.preview ? [{ id: "preview", parts: [{ text: "Pro preview", tone: "warning" as const }] }] : [])], hints });
+
+  const query = <QueryBar width={width} filters={symbol
+    ? [{ id: "view", label: "View", value: view, options: SIGNALS_VIEWS.map((entry) => ({ ...entry })), onChange: (value: string) => { setView(value); setOpenRow(null); } }]
+    : [{ id: "kind", label: "Show", value: filter, defaultValue: "all", options: SIGNAL_FILTERS[group].map((entry) => ({ ...entry })), onChange: (value: string) => { setFilter(value); setOpenRow(null); } }]} />;
+  const signalDetail = (signal: HiringWeekSignal): DetailFact[] => [
+    ...signalFacts(signal),
+    // The postings behind it, each opening the employer's page.
+    ...signal.postings.slice(0, DETAIL_POSTINGS).map((posting, index): DetailFact => ({ label: index === 0 ? "Postings" : "", value: `${posting.title.trim()}${posting.location ? `, ${posting.location}` : ""}`,
+      ...(posting.url ? { link: { label: "Open posting", onOpen: () => void host.openExternal(posting.url!) } } : {}) })),
+    ...(signal.postings.length > DETAIL_POSTINGS ? [{ label: "", value: `${signal.postings.length - DETAIL_POSTINGS} more in ${symbol ? "the" : "the company's"} Postings view` }] : []),
+  ];
+  const detailTitle = openCompany ?? (opened?.jobPosting ? opened.jobPosting.title.trim() : opened?.signal ? `${opened.signal.symbol} · ${opened.signal.label}` : undefined);
+  const detail = openCompany && company ? <PaneFooterScope active>{company.render(openCompany, width, height - 1)}</PaneFooterScope>
+    : opened ? <PaneLinkMenu><DetailReader resetScrollKey={opened.id} width={width}
+      facts={opened.jobPosting ? opened.details ?? [] : opened.signal ? signalDetail(opened.signal) : []} body={opened.jobPosting ? null : opened.signal?.why ?? null} note={opened.jobPosting?.url ?? null} /></PaneLinkMenu> : null;
+  return <PageStackView focused={focused} detailOpen={detailOpen} onBack={() => { company?.onOpen(null); setOpenRow(null); }} detailTitle={detailTitle} detailContent={detail}
+    rootContent={<DataTableView columns={columns} items={model && section ? rows : []} rootWidth={width} rootHeight={height} focused={focused && !detailOpen} scrollRef={scrollRef} onBodyScrollActivity={scrollMore}
+      status={!data ? { loading: resource.loading, error: resource.error, subject: "hiring signals" } : undefined}
+      rootBefore={<ChartTableHeader width={width} height={height} tableRows={rows.length} tableColumns={columns} query={query} figures={model?.figures} />}
+      selection={{ kind: "id", selectedId: selected?.id ?? null, getId: rowId, onChange: setSelected }} getItemKey={rowId}
+      sortColumnId={sort?.column ?? null} sortDirection={sort?.direction ?? "desc"} onHeaderClick={(column) => setSort((old) => ({ column, direction: old?.column === column && old.direction === "desc" ? "asc" : "desc" }))}
+      onActivate={(row) => locked(row) ? void upgrade() : !symbol && row.symbol && company ? company.onOpen(row.symbol) : row.signal || row.jobPosting ? setOpenRow(row.id) : undefined}
+      renderCell={(row, column, _index, state) => {
+        if (locked(row)) {
+          if (!desktop && column.id === columns[0]?.id && row.id === "locked:0") return { text: upgradeText, content: <UpgradeLabel text={upgradeText} onPress={upgrade} role="attention-upgrade" /> };
+          return desktop ? { text: "", content: <Blurred><Text fg={colors.textDim}>Hidden</Text></Blurred> } : { text: "░░░░", color: colors.textDim };
+        }
+        const value = row.values[column.id];
+        if (value == null || value === "") return missingCell(colors);
+        if (column.id === "symbol" && typeof value === "string") return listingCell(value, colors, state.selected);
+        // A first is news; a flagged spike is shown, ranked last.
+        if (column.id === "kind" && typeof value === "string") {
+          const tone = row.signal?.flags.length ? "muted" : "positive";
+          return { text: value, color: toneColor(tone, colors), keepColorWhenSelected: tone !== "muted" };
+        }
+        if (column.id === "check" && typeof value === "string") return { text: value, value, color: toneColor("warning", colors), keepColorWhenSelected: true };
+        if (typeof value === "number") {
+          return { text: signalsNumber(column.id, value), value, color: SIGNALS_SIGNED_COLUMNS.has(column.id) ? signedColor(value, colors) : column.id === "mean" || column.id === "prior" ? colors.textDim : colors.text };
+        }
+        if ((column.id === "label" || column.id === "location") && row.values.country) return withCountryFlag({ text: value, value, color: column.id === "label" ? colors.textBright : colors.text }, String(row.values.country), desktop);
+        return { text: value, value, color: column.id === "name" || column.id === "title" || column.id === "label" ? colors.textBright : column.id === "date" || column.id === "week" || column.id === "since" ? colors.textDim : colors.text };
+      }} selectedTextOverridesCellColor showHorizontalScrollbar resetScrollKey={`${scope}:${sectionId}:${filter}`}
+      emptyStateTitle={section?.empty ?? ""} bodyAfter={lockedRows && desktop ? <LockedOverlay rows={lockedRows} text={upgradeText} onPress={upgrade} role="attention-upgrade" /> : undefined} />}
+  />;
+}

package/src/plugins/builtin/company-kpis/headless.ts

@@ -1,5 +1,6 @@
 import type { DataTableColumn } from "../../../components";
 import { DATE_OPTION_EXAMPLES, isoDateOption } from "../../../utils/calendar-date";
+import { optionFlag } from "../../../cli/pane-functions/capabilities";
 import type { HeadlessBundleSection, HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { withoutQuietColumns } from "../shared/research-cells";
 import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
@@ -88,7 +89,7 @@ export function companyHeadless(mode: CompanyMode): HeadlessPaneDefinition<"bund
       { key: "basis", type: "enum", values: [{ value: "reported" }, { value: "adjusted" }, { value: "constant_currency" }, { value: "organic" }], description: "Accounting basis filter (Pro)." },
       { key: "from", type: "string", placeholder: "date", description: `First calendar period end, as ${DATE_OPTION_EXAMPLES} (Pro).`, normalize: (value) => isoDateOption(value, "from") },
       { key: "to", type: "string", placeholder: "date", description: `Last calendar period end, as ${DATE_OPTION_EXAMPLES} (Pro).`, normalize: (value) => isoDateOption(value, "to") },
-      { key: "asOf", type: "string", placeholder: "date", description: `Point-in-time publication cutoff, as ${DATE_OPTION_EXAMPLES} (Pro).`, normalize: (value) => isoDateOption(value, "asOf") },
+      { key: "asOf", type: "string", placeholder: "date", description: `Point-in-time publication cutoff, as ${DATE_OPTION_EXAMPLES} (Pro).`, normalize: (value) => isoDateOption(value, "as-of") },
     ],
     describe: (args) => `${mode === "kpis" ? "Company KPIs" : "Company guidance"} | ${args.symbols[0]}`,
     async load(args, ctx) {
@@ -106,7 +107,7 @@ export function companyHeadless(mode: CompanyMode): HeadlessPaneDefinition<"bund
       const latest = ("series" in data ? data.series.map((series) => series.latest) : data.guidance).filter(keep);
       const ignored = data.access === "preview" ? PRO_FILTERS.filter((key) => typeof args.options[key] === "string" && args.options[key] !== "") : [];
       const notes = [ageNote(data, latest, mode),
-        ignored.length ? `The free preview is fixed: ${ignored.map((key) => `--${key}`).join(", ")} ${ignored.length > 1 ? "need" : "needs"} Gloom Pro.` : null].filter((note): note is string => !!note);
+        ignored.length ? `The free preview is fixed: ${ignored.map(optionFlag).join(", ")} ${ignored.length > 1 ? "need" : "needs"} Gloom Pro.` : null].filter((note): note is string => !!note);
       return { complete: !data.truncated, errors: data.truncated ? [data.access === "preview" ? companyPreviewNote(data, mode === "guidance") : "Response limit reached; narrow the metric or date range"] : [],
         ...(notes.length ? { notes } : {}),
         sections: "series" in data ? [

package/src/plugins/builtin/company-kpis/model.ts

@@ -45,8 +45,8 @@ export function scopeWords(dimensions: Record<string, string>, which: "parts" |
 /** The labels that tell a row's series apart: the server's `seriesLabels`, else (a server before them) its stored labels. */
 export const seriesLabels = (row: Pick<CompanyRow, "dimensions" | "seriesLabels">) => row.seriesLabels ?? row.dimensions;
 /**
- * What tells a series apart from the metric's other series, in plain words
- * (GLO-1046): its parts, a basis other than reported, then its qualifiers.
+ * What tells a series apart from the metric's other series, in plain words:
+ * its parts, a basis other than reported, then its qualifiers.
  * "Data Center", "Adjusted · diluted", "International · Constant currency".
  */
 export function seriesDetail(row: Pick<CompanyRow, "basis" | "dimensions" | "seriesLabels">): string {

package/src/plugins/builtin/company-kpis/pane.tsx

@@ -107,7 +107,7 @@ function CompanyView({ symbol, exchange, name, mode, width, height, focused }: P
   const [selectedId, setSelected] = usePluginPaneState<string | null>(`company:selected:${tab}`, null);
   const [openId, setOpen] = usePluginPaneState<string | null>("company:open", null);
   const [sourceId, setSource] = usePluginPaneState<string | null>("company:source", null);
-  // The desktop lists KPIs by metric, each series named in plain words (GLO-1046); the terminal keeps its frames.
+  // The desktop lists KPIs by metric, each series named in plain words; the terminal keeps its frames.
   const [sort, setSort] = usePluginPaneState<{ column: string; direction: "asc" | "desc" }>("company:sort",
     desktop && mode === "kpis" ? { column: "metric", direction: "asc" } : { column: "period", direction: "desc" });
   const detailScrollRef = useRef<ScrollBoxRenderable | null>(null);

package/src/plugins/builtin/composite-plugins.ts

@@ -9,6 +9,7 @@ import { exposureModule } from "./exposure";
 import { supplyChainModule } from "./supply-chain";
 import { awardsModule } from "./awards";
 import { cryptoBoardModule } from "./crypto-board";
+import { cryptoEtfFlowsModule } from "./crypto-etf-flows";
 import { portfolioAnalyticsModule } from "./analytics";
 import { brokerTradingModule } from "./broker-trading";
 import { brokerManagerModule } from "./broker-manager";
@@ -221,7 +222,7 @@ export const futuresCommoditiesPlugin = composeBuiltinPlugin({
 
 export const cryptoPlugin = composeBuiltinPlugin({
   ...cryptoPluginMeta,
-  modules: [cryptoBoardModule, perpsModule],
+  modules: [cryptoBoardModule, cryptoEtfFlowsModule, perpsModule],
 });
 
 export const altDataPlugin = composeBuiltinPlugin({

package/src/plugins/builtin/congress-trades/headless.ts

@@ -161,7 +161,7 @@ export function createCongressHeadless(
     // A ticker's pane lists its trades only. The filters are the pane's filter bar, kept apart for a ticker's pane.
     shotState: (args, _load, given) => {
       if (args.symbols.length && args.options.tab !== "trades") {
-        throw new Error(`The Congress pane for one ticker lists its trades only. Drop --tab ${args.options.tab} or ${args.symbols[0]} from shot, or run the report: gloomberb fn CG ${args.symbols[0]} --tab ${args.options.tab}`);
+        throw new Error(`The Congress pane for one ticker lists its trades only. Drop --tab ${args.options.tab} or ${args.symbols[0]} from shot, or run the report: gloom fn CG ${args.symbols[0]} --tab ${args.options.tab}`);
       }
       const filters = shotFilters(args.options, given);
       return filters ? { pluginState: { "gloomberb-cloud": { [`${args.symbols.length ? "congressTicker." : ""}filters`]: filters } } } : {};

package/src/plugins/builtin/connections/index.ts

@@ -36,6 +36,7 @@ export const connectionsModule: PluginModule = {
     personalData: "account",
     icon: "C",
     component: ConnectionsPane,
+    reportFreshness: { status: "not-a-feed", basis: "connection health" },
     defaultPosition: "right",
     defaultMode: "floating",
     defaultFloatingSize: { width: 80, height: 24 },

package/src/plugins/builtin/correlation/headless-schema.ts

@@ -33,7 +33,8 @@ export const paneSchemas = {
     },
   },
   "relationship-graph-pane": {
-    argument: { kind: "tickers", maximum: 2 },
+    // The gold/silver ratio is the pair a metals desk asks for first.
+    argument: { kind: "tickers", maximum: 2, examples: ["GC=F SI=F", "AMD NVDA"] },
     options: [
       {
         key: "range",
@@ -64,7 +65,7 @@ export const paneSchemas = {
     ],
     discovery: {
       id: "security-relationship",
-      aliases: ["relationship", "ratio", "beta", "regression", "rolling correlation"],
+      aliases: ["relationship", "ratio", "beta", "regression", "rolling correlation", "gold silver ratio", "gold/silver ratio", "pair ratio"],
       limitations: ["A single ticker is compared with SPY."],
       screenshotReadiness: "partial",
     },

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

@@ -113,17 +113,19 @@ export const relationshipHeadless: HeadlessPaneDefinition<"series"> = {
     if (analysis.integrity?.right.length) unavailableSymbols.push(symbols[1]!);
     if (!unavailableSymbols.length && !analysis.returns.length) unavailableSymbols.push(...symbols);
     const correlations = new Map(analysis.correlationPoints.map(({ date, close }) => [date.getTime(), close]));
+    const regression = `${symbols[0]} on ${symbols[1]}`;
     return {
       symbols,
       series: [
         { id: "ratio", label: `${symbols[0]}/${symbols[1]}`, points: analysis.ratioPoints.map(({ date, close }) => ({ date: date.toISOString(), value: close })) },
-        { id: "correlation", label: `Rolling correlation (${correlationWindow})`, points: analysis.returns.slice(correlationWindow - 1).map(({ date }) => ({ date: date.toISOString(), value: correlations.get(date.getTime()) ?? null })) },
+        { id: "correlation", label: `Rolling correlation (${correlationWindow})`, textDecimals: 3, points: analysis.returns.slice(correlationWindow - 1).map(({ date }) => ({ date: date.toISOString(), value: correlations.get(date.getTime()) ?? null })) },
       ],
       stats: [
         { key: "latestRatio", label: "Latest ratio", value: analysis.latestRatio, formatted: formatSignificant(analysis.latestRatio ?? undefined) },
         { key: "latestCorrelation", label: `Rolling correlation (${correlationWindow})`, value: analysis.latestCorrelation, formatted: formatNumber(analysis.latestCorrelation ?? undefined, 3) },
         ...(["beta", "alpha", "rSquared"] as const).map((key) => ({
-          key, label: { beta: "Beta", alpha: "Alpha", rSquared: "R squared" }[key],
+          // The first ticker's daily returns are regressed on the second's, so a beta says which way round it reads.
+          key, label: { beta: `${regression}: beta`, alpha: `${regression}: alpha`, rSquared: "R squared" }[key],
           value: analysis.stats?.[key] ?? null,
           // Alpha is the regression intercept on daily percent returns.
           formatted: key === "alpha" && analysis.stats ? `${formatNumber(analysis.stats.alpha, 3)}%` : formatNumber(analysis.stats?.[key], 3),
@@ -141,7 +143,7 @@ export const relationshipHeadless: HeadlessPaneDefinition<"series"> = {
         lastDate: analysis.aligned.at(-1)?.dateKey ?? null,
         ...(analysis.integrity ? { integrity: analysis.integrity } : {}),
         latestRatio: analysis.latestRatio, latestCorrelation: analysis.latestCorrelation,
-        regression: analysis.stats, alignedPriceCount: analysis.aligned.length, returnCount: analysis.returns.length,
+        regression: analysis.stats && { dependent: symbols[0], independent: symbols[1], ...analysis.stats }, alignedPriceCount: analysis.aligned.length, returnCount: analysis.returns.length,
       },
     };
   },

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

@@ -1,8 +1,9 @@
-import type { CotClass, CotClassSummary } from "../../../api-client/cot";
+import type { CotClass, CotClassSummary, CotContractPayload, CotHistoryPoint } from "../../../api-client/cot";
 import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchCotBoard, fetchCotContract } from "./client";
-import { COT_MAJOR_CODES, COT_SCOPES, cotClass, cotContractCode, cotInteger, cotMarketName, cotScope, cotUnknownMarketMessage } from "./model";
+import { COT_MAJOR_CODES, COT_SCOPES, cotClass, cotContractCode, cotContractUnitText, cotInteger, cotMarketName, cotScope, cotUnknownMarketMessage } from "./model";
 import { COMMODITIES_VIEW_STATE } from "../commodities-energy/view-state";
+import { REPORT_ROWS } from "../shared/headless-options";
 
 const camelClass = (id: CotClass) => id.replace(/-(\w)/g, (_match, letter: string) => letter.toUpperCase());
 const rounded = (value: number | null, digits: number) => value == null ? null : Number(value.toFixed(digits));
@@ -17,6 +18,22 @@ function cotPositionRow(row: CotClassSummary) {
     netPercentOfOpenInterest: rounded(row.netPercentOfOpenInterest, 1), weeklyChange: row.weeklyChange, previousReportDate: row.previousReportDate,
     oneYearPercentile: rounded(row.percentile1Y.value, 0), threeYearPercentile: rounded(row.percentile3Y.value, 0) };
 }
+/**
+ * A market's title line: its name, the report date (the Tuesday the positions
+ * are of) and what one contract is, so a net of +207,879 reads in ounces too.
+ */
+function cotContractTitle(data: CotContractPayload, code: string): string {
+  const units = cotContractUnitText(data.contract?.contractUnits);
+  return [data.contract ? cotMarketName(data.contract.marketName) : code, data.asOf ? `report date ${data.asOf}` : null, units]
+    .filter(Boolean).join("  ·  ");
+}
+
+/** The weekly reports newest first, the newest `limit` of them when given. */
+function cotWeeklyRows(history: readonly CotHistoryPoint[], limit: number | null): CotHistoryPoint[] {
+  const newest = [...history].reverse();
+  return limit == null ? newest : newest.slice(0, limit);
+}
+
 const POSITION_COLUMNS: HeadlessPaneColumn[] = [
   { key: "net", header: "Net", align: "right", format: signed },
   { key: "weeklyChange", header: "1W Δ", align: "right", format: signed },
@@ -34,7 +51,10 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
     { key: "traderClass", type: "enum", values: ["noncommercial", "commercial", "producer", "swap", "managed-money", "other-reportable", "nonreportable"].map((value) => ({ value })), description: "Trader class for the extremes board; defaults by report family.",
       pluginState: { pluginId: COMMODITIES_VIEW_STATE.cot, key: "class" } },
     { key: "scope", type: "enum", values: COT_SCOPES.map(({ value }) => ({ value })), defaultValue: "major", description: "Markets on the extremes board, as in the pane.",
-      pluginState: { pluginId: COMMODITIES_VIEW_STATE.cot, key: "scope" } }],
+      pluginState: { pluginId: COMMODITIES_VIEW_STATE.cot, key: "scope" } },
+    // Weekly reports come newest first, so --tail asks for the same newest n as --limit.
+    { key: "limit", type: "integer", aliases: ["tail", "weeks", "rows"], minimum: 1, maximum: 2000, shot: REPORT_ROWS,
+      description: "Newest weekly reports a market lists; every one by default." }],
   discovery: { aliases: ["COT", "CFTC"], dataRequirements: ["Gloom Cloud CFTC history"], limitations: ["Futures-only positions aggregate all maturities.", "Legacy and disaggregated classes differ.", "Observation date is not publication date.", "Some markets have short or suppressed histories."] },
   describe: "CFTC positioning",
   async load(args, ctx) {
@@ -44,14 +64,16 @@ export const cotHeadless: HeadlessPaneDefinition<"bundle"> = {
       if (!code) throw new Error(cotUnknownMarketMessage(args.argument));
       const data = await fetchCotContract(code, family, ctx.apiClient);
       const classes = data.positions.map((row) => row.id);
-      return { sections: [{ title: data.contract ? cotMarketName(data.contract.marketName) : code,
+      const limit = args.options.limit == null ? null : Number(args.options.limit);
+      const weeks = cotWeeklyRows(data.history, limit);
+      return { sections: [{ title: cotContractTitle(data, code),
         columns: [{ key: "class", header: "Class" }, { key: "long", header: "Long", align: "right", format: count },
           { key: "short", header: "Short", align: "right", format: count }, ...POSITION_COLUMNS],
         rows: data.positions.map((row) => ({ class: row.label, ...cotPositionRow(row) })) },
-      { title: "Weekly positions",
+      { title: weeks.length < data.history.length ? `Weekly positions  ·  newest ${weeks.length} of ${data.history.length}` : "Weekly positions",
         columns: [{ key: "reportDate", header: "Report date" }, { key: "openInterest", header: "Open interest", align: "right", format: count },
           ...classes.map((id) => ({ key: `${camelClass(id)}Net`, header: `${data.positions.find((row) => row.id === id)?.label ?? id} net`, align: "right" as const, format: signed }))],
-        rows: data.history.map((row) => ({ reportDate: row.reportDate, openInterest: row.openInterest,
+        rows: weeks.map((row) => ({ reportDate: row.reportDate, openInterest: row.openInterest,
           ...Object.fromEntries(row.positions.map((position) => [`${camelClass(position.id)}Net`, position.net])) })) }],
       errors: data.gaps, metadata: { ...data, complete: data.status === "available" } };
     }