gloomberb 0.16.1 → 0.16.2

package/src/plugins/builtin/holders/report-header.ts

@@ -0,0 +1,95 @@
+import { currencyUnitLabel, resolveCurrencyUnit } from "../../../utils/currency-units";
+import { canonicalExchange, isUsListingExchange, resolveExchangeTimeZone } from "../../../utils/exchanges";
+
+/**
+ * The lines above a holder table in text reports (`holders`, `insider`,
+ * `13f`, `fn HDS`): which listing, in which unit, and how much of the list
+ * is shown. Holder lists come as the source's own top holders, usually
+ * without a total, so the count says that rather than implying a full list.
+ */
+export interface HolderReportFacts {
+  name?: string | null;
+  /** Left out when the report title already names it. */
+  symbol?: string | null;
+  exchange?: string | null;
+  currency?: string | null;
+  /** Left out when the report's closing line already carries it. */
+  asOf?: string | null;
+  /** Rows printed. */
+  shown: number;
+  /** Rows the source returned, before any limit. */
+  reported: number;
+  /** Every holder the source counts, when it says so. */
+  total?: number | null;
+}
+
+/** "Value (GBp)": a money column names its unit. */
+export function moneyColumnHeader(label: string, currency?: string | null): string {
+  const unit = currency?.trim();
+  return unit ? `${label} (${unit})` : label;
+}
+
+function holderCountText(shown: number, reported: number, total?: number | null): string {
+  if (total != null && Number.isFinite(total) && total >= reported) {
+    return `${shown.toLocaleString("en-US")} of ${total.toLocaleString("en-US")} holders`;
+  }
+  if (reported === 0) return "none reported";
+  // Without a total the source's list is its largest holders, cut where it cuts it.
+  return shown < reported ? `${shown} of top ${reported} reported` : `top ${reported} reported`;
+}
+
+/** A venue the app knows by its short name (NasdaqGS is NASDAQ); any other as the source wrote it. */
+function venueLabel(exchange?: string | null): string {
+  const canonical = canonicalExchange(exchange ?? "");
+  return resolveExchangeTimeZone(canonical) ? canonical : (exchange ?? "").trim();
+}
+
+/** What the list is, after the listing is named: its unit, date and how much of it is shown. */
+export function holderListFacts(
+  facts: Pick<HolderReportFacts, "currency" | "asOf" | "shown" | "reported" | "total">,
+): string[] {
+  return [
+    currencyUnitLabel(facts.currency),
+    facts.asOf ? `as of ${facts.asOf}` : "",
+    holderCountText(facts.shown, facts.reported, facts.total),
+  ].filter(Boolean);
+}
+
+export function holdersHeaderLine(facts: HolderReportFacts): string {
+  const name = facts.name?.trim();
+  const symbol = facts.symbol?.trim();
+  const identity = name && symbol && name !== symbol ? `${name} (${symbol})` : name || symbol || "";
+  return [identity, venueLabel(facts.exchange), ...holderListFacts(facts)].filter(Boolean).join(" | ");
+}
+
+/** The one report date every row shares, or null when they differ or none has one. */
+export function sharedReportDate(rows: ReadonlyArray<{ reportDate?: unknown }>): string | null {
+  const dates = new Set(rows.map((row) => (typeof row.reportDate === "string" ? row.reportDate : "")));
+  const [only] = dates;
+  return dates.size === 1 && only ? only : null;
+}
+
+/** How a holder value was reached: reported shares times a current price, not the filing's own value. */
+export function holderValueBasis(reportDate: string | null): string {
+  return `shares reported${reportDate ? ` at ${reportDate}` : ""} x latest price`;
+}
+
+/** A listing outside the US, by its venue, or by a currency other than the dollar. */
+function isNonUsHolderListing(exchange?: string | null, currency?: string | null): boolean {
+  const venue = canonicalExchange(exchange ?? "");
+  if (venue && !isUsListingExchange(venue) && resolveExchangeTimeZone(venue)) return true;
+  const unit = resolveCurrencyUnit(currency).currency;
+  return unit !== "" && unit !== "USD";
+}
+
+/**
+ * Holder lists are institutions' quarterly filings, mostly US 13F. On a
+ * listing outside the US they are not that market's share register, which a
+ * reader would otherwise assume.
+ */
+export function nonUsHolderCaveat(exchange?: string | null, currency?: string | null): string | null {
+  if (!isNonUsHolderListing(exchange, currency)) return null;
+  const canonical = canonicalExchange(exchange ?? "");
+  const venue = resolveExchangeTimeZone(canonical) ? canonical : "local";
+  return `Positions come from institutional filings (mostly US 13F), not the ${venue} share register.`;
+}

package/src/plugins/builtin/holders/table-model.ts

@@ -11,8 +11,15 @@ export const DEFAULT_SORT: SortPreference = {
 export const VIEW_TABS: Array<{ label: string; value: ViewMode }> = [
   { label: "Table", value: "table" },
   { label: "Chart", value: "chart" },
+  { label: "13D/G", value: "13dg" },
 ];
 
+/** `s` steps through the views in tab order. */
+export function nextViewMode(current: ViewMode): ViewMode {
+  const index = VIEW_TABS.findIndex((tab) => tab.value === current);
+  return VIEW_TABS[(index + 1) % VIEW_TABS.length]!.value;
+}
+
 export function buildRows(data: HolderData | null): HolderRow[] {
   return (data?.holders ?? []).map((holder, index) => ({
     ...holder,
@@ -20,23 +27,31 @@ export function buildRows(data: HolderData | null): HolderRow[] {
   }));
 }
 
-export function buildColumns(width: number): HolderColumn[] {
+/** Whether any holder carries the quarter's change; many sources report none. */
+export function hasHolderChanges(rows: readonly HolderRow[]): boolean {
+  return rows.some((row) => row.changeShares != null || row.changePercent != null);
+}
+
+export function buildColumns(width: number, showChange: boolean): HolderColumn[] {
   const valueWidth = 10;
   const sharesWidth = 10;
   const changeWidth = 10;
   const changePercentWidth = 8;
   const heldWidth = 7;
   const dateWidth = 10;
-  const columnCount = 7;
-  const fixedWidth = valueWidth + sharesWidth + changeWidth + changePercentWidth + heldWidth + dateWidth;
+  const columnCount = showChange ? 7 : 5;
+  const fixedWidth = valueWidth + sharesWidth + heldWidth + dateWidth
+    + (showChange ? changeWidth + changePercentWidth : 0);
   const holderWidth = Math.max(16, width - 2 - columnCount - fixedWidth);
 
   return [
     { id: "holder", label: "HOLDER", width: holderWidth, align: "left" },
     { id: "value", label: "MKT VAL", width: valueWidth, align: "right" },
     { id: "shares", label: "AMOUNT", width: sharesWidth, align: "right" },
-    { id: "changeShares", label: "CHG", width: changeWidth, align: "right" },
-    { id: "changePercent", label: "CHG%", width: changePercentWidth, align: "right" },
+    ...(showChange ? [
+      { id: "changeShares", label: "CHG", width: changeWidth, align: "right" },
+      { id: "changePercent", label: "CHG%", width: changePercentWidth, align: "right" },
+    ] satisfies HolderColumn[] : []),
     { id: "percentHeld", label: "HELD", width: heldWidth, align: "right" },
     { id: "reportDate", label: "PERIOD", width: dateWidth, align: "right" },
   ];

package/src/plugins/builtin/holders/thirteenf-match.ts

@@ -1,4 +1,4 @@
-import { listThirteenFForms, searchThirteenFFunds } from "../thirteenf/api";
+import { listThirteenFForms, normalizeCik, searchThirteenFFunds } from "../thirteenf/api";
 import { isoDateToday, isoDateYearsAgo } from "../../../utils/calendar-date";
 import { buildPeriodReports } from "../thirteenf/model";
 import type { HolderRow } from "./types";
@@ -42,6 +42,34 @@ export function bestFundMatch(holderName: string, funds: Array<{ cik: string; na
   return matches.length === 1 ? matches[0] : undefined;
 }
 
+/**
+ * The 13F holder row that is a 13D/13G filer: the row whose matched 13F
+ * manager has the filer's CIK, else the one row whose name is the filer's once
+ * normalised. A parent or subsidiary with a longer name is not the filer, and
+ * two rows with the filer's name leave it unmatched. A manager's CIK can
+ * change (BlackRock's 13G filer did in 2024) while its 13F match keeps the
+ * old one, so an exact name is not overruled by a CIK.
+ */
+export function matchFilerToHolder<Row extends { id: string; name: string }>(
+  filer: { filerCik: string | null; filerName: string },
+  rows: readonly Row[],
+  fundMatches: ReadonlyMap<string, Pick<Holder13FMatch, "cik">> = new Map(),
+): Row | undefined {
+  const cik = filer.filerCik ? normalizeCik(filer.filerCik) : null;
+  const matchedCik = (row: Row) => {
+    const match = fundMatches.get(row.id);
+    return match ? normalizeCik(match.cik) : null;
+  };
+  if (cik) {
+    const byCik = rows.filter((row) => matchedCik(row) === cik);
+    if (byCik.length === 1) return byCik[0];
+  }
+  const name = normalizeName(filer.filerName);
+  if (!name) return undefined;
+  const byName = rows.filter((row) => normalizeName(row.name) === name);
+  return byName.length === 1 ? byName[0] : undefined;
+}
+
 export async function loadHolder13FMatches(
   rows: HolderRow[],
   signal: AbortSignal,

package/src/plugins/builtin/holders/types.ts

@@ -2,7 +2,8 @@ import type { DataTableColumn } from "../../../components";
 import type { HolderRecord } from "../../../types/financials";
 import type { SortDirection } from "../../../utils/sort-values";
 
-export type ViewMode = "table" | "chart";
+/** `13dg`: the Schedule 13D and 13G beneficial owners. */
+export type ViewMode = "table" | "chart" | "13dg";
 export type HolderColumnId = "holder" | "value" | "shares" | "changeShares" | "changePercent" | "percentHeld" | "reportDate";
 export type HolderColumn = DataTableColumn & { id: HolderColumnId };
 

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

@@ -17,6 +17,7 @@ import {
 } from "./model";
 import { relevantInsiderAmendments } from "./amendments";
 import { formatInsiderName } from "./display";
+import { SEC_FILINGS } from "../shared/report-freshness";
 
 const INSIDER_COLUMNS: HeadlessPaneColumn[] = [
   { key: "form", header: "Form" },
@@ -84,6 +85,7 @@ export function createInsiderHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
+    freshness: { ...SEC_FILINGS, basis: "Form 4 filings", observedKey: "filingDate" },
     argument: {
       kind: "ticker",
       placeholder: "ticker",

package/src/plugins/builtin/ipo-calendar/headless.ts

@@ -104,6 +104,7 @@ function projectIpoCalendarHeadless(payload: IpoCalendarPayload, args: HeadlessP
 
 export const ipoCalendarHeadless: HeadlessPaneDefinition<"rows"> = {
   shape: "rows",
+  freshness: { source: "Exchange listings", status: "not-a-feed", basis: "calendar" },
   argument: {
     kind: "free-text",
     placeholder: "company or ticker",

package/src/plugins/builtin/iv-history/headless.ts

@@ -11,6 +11,7 @@ const percent = (value: unknown) => typeof value === "number" ? formatVol(value)
 
 export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "US option underlying" },
+  freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily", observedKey: "date", oldest: null },
   describe: (args) => `HIVG ${args.symbols[0] ?? ""}`,
   discovery: { aliases: ["HIVG"], screenshotReadiness: "live-dom", dataRequirements: ["Cloud stored implied volatility", "Daily price history"],
     limitations: ["History starts February 2024 (OPRA daily trade closes)", "Rank and percentile use trade-close readings only"] },
@@ -57,6 +58,7 @@ export const ivHistoryHeadless: HeadlessPaneDefinition<"bundle"> = {
 
 export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: { status: "not-a-feed", basis: "daily implied volatility", cadence: "daily" },
   argument: { kind: "symbol-list", optional: true, maximum: VCA_LIMIT, description: "US option underlyings; defaults to index and sector ETFs." },
   options: [{ key: "preset", type: "enum", values: [{ value: "etfs" }, { value: "megacaps" }], defaultValue: "etfs", description: "Preset when no symbols are given" }],
   describe: "Volatility rich/cheap",
@@ -86,7 +88,8 @@ export const ivScreenHeadless: HeadlessPaneDefinition<"bundle"> = {
         { key: "ivHv", header: "IV/HV", format: (value: unknown) => typeof value === "number" ? value.toFixed(2) : "--" },
       ], rows: rows.map((row) => ({ ...row })) }],
       complete: !queued.length && !universe.error, unavailableSymbols: queued,
-      errors: [universe.error, ...(queued.length ? [`Queued for backfill: ${queued.join(", ")}`] : [])].filter((value): value is string => !!value),
+      errors: [universe.error].filter((value): value is string => !!value),
+      ...(queued.length ? { notes: [`Queued for backfill: ${queued.join(", ")}.`] } : {}),
       metadata: { asOf: payload.asOf, presets: VCA_PRESETS, methodology: METHODOLOGY },
     };
   },

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

@@ -151,6 +151,7 @@ function companyBundle(symbol: string, state: JobsCompanyState, roleLimit: numbe
  */
 export const jobsHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
+  freshness: { source: "Company careers sites", status: "not-a-feed", basis: "observed job postings" },
   argument: {
     kind: "ticker",
     placeholder: "ticker",

package/src/plugins/builtin/kelly-sizer/index.tsx

@@ -15,6 +15,7 @@ export const positionSizerModule: PluginModule = {
   panes: [
     {
       id: KELLY_PANE_ID,
+      reportFreshness: { source: "Your inputs and Gloom Cloud", status: "not-a-feed", basis: "position sizing" },
       name: "Position Sizer",
       icon: "K",
       component: KellySizerPane,

package/src/plugins/builtin/macro-day/headless.ts

@@ -11,6 +11,8 @@ const share = (value: unknown) => typeof value === "number" ? `${Math.round(valu
 
 export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle", argument: { kind: "ticker", description: "Ticker" },
+  // Dated by the maintained release list as much as by the closes, so no session schedule applies.
+  freshness: { status: "not-a-feed", basis: "release-day study on daily closes" },
   describe: (args) => `MDAY ${args.symbols[0] ?? ""}`,
   discovery: { screenshotReadiness: "live-dom", limitations: [
     "US listings; close-to-close on the release day.",

package/src/plugins/builtin/market-halts/index.tsx

@@ -17,6 +17,7 @@ export const marketHaltsPlugin: GloomPlugin = {
   panes: [
     {
       id: MARKET_HALTS_PANE_ID,
+      reportFreshness: { source: "Nasdaq Trader" },
       name: "Market Halts",
       icon: "H",
       component: MarketHaltsPane,

package/src/plugins/builtin/market-heatmap/data.ts

@@ -6,6 +6,8 @@ export const MARKET_HEATMAP_UNIVERSES = [
   { id: "us-equity", label: "US Stocks" },
   { id: "us-etf", label: "US ETFs" },
 ] as const;
+/** The 500 largest US stocks (an older server answers with its own maximum); ETFs stay flat and need fewer. */
+export const MARKET_HEATMAP_REQUEST_COUNT: Record<MarketHeatmapUniverseId, number> = { "us-equity": 500, "us-etf": 160 };
 export interface MarketHeatmapFetchOptions { count?: number; forceRefresh?: boolean; cache?: boolean; }
 export interface MarketHeatmapSources { client?: Pick<typeof apiClient, "getMarketHeatmap">; }
 const DEFAULT_COUNT = 80;

package/src/plugins/builtin/market-heatmap/headless.ts

@@ -0,0 +1,135 @@
+import type { HeadlessPaneColumn, HeadlessPaneDefinition } from "../../../types/plugin";
+import { formatCompact, formatPercentRaw } from "../../../utils/format";
+import { MARKET_HEATMAP_REQUEST_COUNT, MARKET_HEATMAP_UNIVERSES, fetchMarketHeatmap, type MarketHeatmapUniverseId } from "./data";
+import { heatmapMove, summarizeHeatmapGroups, type HeatmapGroupBy, type HeatmapGroupSummary } from "./model";
+
+/**
+ * A few names always lack a move (foreign listings and new tickers the snapshot
+ * has no change for). They are listed in a notice and in `metadata.noMove`; the
+ * report is incomplete only when so many lack one that the groups mislead.
+ */
+const MIN_MOVE_COVERAGE = 0.9;
+
+const percent = (value: unknown) => typeof value === "number" ? formatPercentRaw(value) : "—";
+const share = (value: unknown) => typeof value === "number" ? `${value.toFixed(1)}%` : "—";
+const dollars = (value: unknown) => typeof value === "number" && value > 0 ? `$${formatCompact(value)}` : "—";
+const member = (symbol: unknown, move: unknown) => typeof symbol === "string" && typeof move === "number"
+  ? `${symbol} ${formatPercentRaw(move)}`
+  : "—";
+
+function columns(universe: MarketHeatmapUniverseId, groupBy: HeatmapGroupBy, flat: boolean): HeadlessPaneColumn[] {
+  return [
+    ...(flat ? [] : groupBy === "industry"
+      ? [{ key: "group", header: "Industry" }, { key: "sector", header: "Sector" }]
+      : [{ key: "group", header: "Sector" }]),
+    { key: "names", header: "Names", align: "right" },
+    { key: "size", header: universe === "us-etf" ? "Net assets" : "Mkt cap", align: "right", format: dollars },
+    ...(flat ? [] : [{ key: "sharePercent", header: "Share", align: "right" as const, format: share }]),
+    { key: "move", header: universe === "us-etf" ? "Move (asset-wtd)" : "Move (cap-wtd)", align: "right", format: percent },
+    { key: "up", header: "Up", align: "right" },
+    { key: "down", header: "Down", align: "right" },
+    { key: "bestSymbol", header: "Best", format: (value, row) => member(value, row.bestMove) },
+    { key: "worstSymbol", header: "Worst", format: (value, row) => member(value, row.worstMove) },
+  ];
+}
+
+function noMoveNotice(symbols: readonly string[], names: number): string {
+  const shown = symbols.slice(0, 8).join(", ");
+  const rest = symbols.length > 8 ? ` and ${symbols.length - 8} more` : "";
+  return `${symbols.length} of ${names} names have no move yet and count toward size only: ${shown}${rest}.`;
+}
+
+function projectRow(summary: HeatmapGroupSummary, groupBy: HeatmapGroupBy, whole = false) {
+  return {
+    group: whole ? "All" : summary.group ?? (summary.sector ? "No industry" : groupBy === "industry" ? "Unclassified" : "No sector"),
+    ...(groupBy === "industry" ? { sector: summary.sector ?? "—" } : {}),
+    names: summary.names,
+    size: summary.size,
+    sharePercent: summary.share * 100,
+    move: summary.move,
+    moved: summary.moved,
+    up: summary.up,
+    down: summary.down,
+    unchanged: summary.unchanged,
+    bestSymbol: summary.best?.symbol ?? null,
+    bestMove: summary.best?.move ?? null,
+    worstSymbol: summary.worst?.symbol ?? null,
+    worstMove: summary.worst?.move ?? null,
+  };
+}
+
+export const marketHeatmapHeadless: HeadlessPaneDefinition<"rows"> = {
+  shape: "rows",
+  description: "The heat map's sectors or industries: each group's size-weighted day move, how many names rose and fell, and its best and worst name, for the 500 largest US stocks or large US ETFs.",
+  argument: { kind: "none" },
+  options: [
+    {
+      key: "universe",
+      description: "Board: the 500 largest US stocks, or large US ETFs (one group, as the ETF map has no sectors).",
+      type: "enum",
+      values: [
+        { value: "us-equity", aliases: ["stocks", "equity", "us"] },
+        { value: "us-etf", aliases: ["etf", "etfs"] },
+      ],
+      defaultValue: "us-equity",
+      settingKey: "universe",
+    },
+    {
+      key: "group",
+      description: "Group the stocks by sector, or by industry within each sector.",
+      type: "enum",
+      values: [{ value: "sector", aliases: ["sectors"] }, { value: "industry", aliases: ["industries"] }],
+      defaultValue: "sector",
+    },
+  ],
+  discovery: {
+    aliases: ["HM", "heatmap"],
+    dataRequirements: ["Gloom Cloud market heatmap snapshot"],
+    limitations: [
+      "The snapshot the pane starts from, refreshed about once a minute; the pane's live-streamed colors are not in the report",
+      "Moves are weighted by market cap (net assets for ETFs), not by the pane's square-root tile area",
+    ],
+  },
+  // A board snapshot refreshed on a schedule, not a feed; the pane streams on top of it, the report does not.
+  freshness: { status: "delayed" },
+  describe: (args) => {
+    const universe = MARKET_HEATMAP_UNIVERSES.find((entry) => entry.id === args.options.universe)?.label ?? "US Stocks";
+    return args.options.universe === "us-etf" ? `Market Heatmap | ${universe}` : `Market Heatmap | ${universe} by ${String(args.options.group)}`;
+  },
+  async load(args, ctx) {
+    const universe: MarketHeatmapUniverseId = args.options.universe === "us-etf" ? "us-etf" : "us-equity";
+    const groupBy: HeatmapGroupBy = args.options.group === "industry" ? "industry" : "sector";
+    const result = await fetchMarketHeatmap(
+      universe,
+      { count: MARKET_HEATMAP_REQUEST_COUNT[universe], forceRefresh: ctx.refresh },
+      { client: ctx.apiClient },
+    );
+    ctx.signal.throwIfAborted();
+    const { grouping, groups, board } = summarizeHeatmapGroups(result.assets, groupBy);
+    const flat = grouping === "flat";
+    const noMove = result.assets.filter((asset) => heatmapMove(asset) == null).map((asset) => asset.symbol);
+    const covered = result.assets.length > 0 && board.moved / board.names >= MIN_MOVE_COVERAGE;
+    return {
+      columns: columns(universe, groupBy, flat),
+      rows: groups.map((summary) => projectRow(summary, groupBy, flat)),
+      complete: !result.stale && covered,
+      unavailableSymbols: covered ? [] : noMove,
+      metadata: {
+        universe,
+        groupBy: flat ? null : groupBy,
+        asOf: new Date(result.fetchedAt).toISOString(),
+        stale: result.stale === true,
+        session: result.session ?? null,
+        regularSessionDate: result.regularSessionDate ?? null,
+        names: result.assets.length,
+        noMove,
+        ...(noMove.length > 0 ? { notices: [noMoveNotice(noMove, result.assets.length)] } : {}),
+        board: projectRow(board, groupBy, true),
+        unit: "move and sharePercent in percent; size in USD",
+        weighting: universe === "us-etf"
+          ? "Each group's move is its names' day moves weighted by net assets, over the names with a move."
+          : "Each group's move is its names' day moves weighted by market cap, over the names with a move.",
+      },
+    };
+  },
+};

package/src/plugins/builtin/market-heatmap/index.tsx

@@ -29,7 +29,7 @@ import { t, tf } from "../../../i18n";
 import { priceColor } from "../../../theme/colors";
 import { clipToDisplayWidth, formatCompact, formatCurrency, formatPercentRaw } from "../../../utils/format";
 import { isPlainKey } from "../../../utils/keyboard";
-import { useAppSelector, usePaneAppConfig, usePaneSettingValue } from "../../../state/app/context";
+import { useAppSelector, usePaneAppConfig, usePaneSettingValue, usePaneStateValue } from "../../../state/app/context";
 import { usePluginTickerActions } from "../../runtime";
 import { useLiveQuoteEntries } from "../../../state/hooks/quote-streaming";
 import { useFxRatesMap, useTickerFinancialsMap } from "../../../market-data/hooks";
@@ -44,18 +44,21 @@ import { resolvePortfolioTotalsCurrency } from "../portfolio-list/metrics";
 import { useThrottledMemo } from "../portfolio-list/use-throttled-memo";
 import { PORTFOLIO_REORDER_THROTTLE_MS } from "../portfolio-list/use-throttled-ticker-order";
 import {
+  MARKET_HEATMAP_REQUEST_COUNT,
   MARKET_HEATMAP_UNIVERSES,
   fetchMarketHeatmap,
   resetMarketHeatmapCache,
   type MarketHeatmapUniverseId,
 } from "./data";
 import {
+  HEATMAP_COLLECTION_KIND_STATE_KEY,
   PORTFOLIO_HEATMAP_TAB,
   buildPortfolioHeatmapAssets,
   fallbackHeatmapCollectionId,
   heatmapCollectionLabel,
   heatmapFollowsCollection,
   heatmapSizeBy,
+  heatmapSizeByApplies,
   heatmapSizeWeight,
   heatmapTabId,
   isRemoteHeatmapUniverse,
@@ -76,6 +79,8 @@ import {
   rankHeatmapQuoteWeights,
   useSettledValue,
 } from "./live";
+import { marketHeatmapHeadless } from "./headless";
+import { heatmapMove, resolveHeatmapGrouping, sizeWeightedMove, type HeatmapGrouping } from "./model";
 import {
   overlayScreenerQuoteEntries,
   resolveScreenerQuoteFeedStatus,
@@ -83,8 +88,6 @@ import {
 
 const NO_ASSETS: HeatmapBoardAsset[] = [];
 const NO_TARGETS: QuoteSubscriptionTarget[] = [];
-/** The 500 largest US stocks (an older server answers with its own maximum); ETFs stay flat and need fewer. */
-const MARKET_HEATMAP_REQUEST_COUNT: Record<MarketHeatmapUniverseId, number> = { "us-equity": 500, "us-etf": 160 };
 const SNAPSHOT_REFRESH_MS = 60_000;
 const LAYOUT_THROTTLE_MS = 5_000;
 /** A size change below this share of a tile's area is not worth moving it. */
@@ -128,34 +131,16 @@ function sizeLabel(asset: HeatmapBoardAsset): string | null {
   return `${label} ${formatMoneyCompact(asset.size, asset.sizeCurrency ?? asset.currency)}`;
 }
 
-/** The move, or null when there is none: no change data is not a flat session. */
-function changeOf(asset: HeatmapBoardAsset): number | null {
-  return asset.hasChange && typeof asset.changePercent === "number" && Number.isFinite(asset.changePercent)
-    ? asset.changePercent
-    : null;
+/** Marks a pre-market or after-hours move, which is measured from the regular close. */
+function sessionMark(asset: HeatmapBoardAsset): string | null {
+  if (asset.extendedSession === "PRE") return "PM";
+  if (asset.extendedSession === "POST") return "AH";
+  return null;
 }
 
-type HeatmapGrouping = "sector-industry" | "sector" | "flat";
-
-/**
- * Sector and industry blocks when the board knows its sectors. A board where
- * most of the value has none (ETFs, or a snapshot whose classification
- * failed) lays out flat rather than as one big unlabeled block.
- */
-function resolveGrouping(assets: readonly HeatmapBoardAsset[], industries: boolean): HeatmapGrouping {
-  let total = 0;
-  let classified = 0;
-  const sectors = new Set<string>();
-  for (const asset of assets) {
-    const weight = asset.weight ?? asset.size ?? 0;
-    total += weight;
-    if (asset.sector) {
-      classified += weight;
-      sectors.add(asset.sector);
-    }
-  }
-  if (sectors.size < 2 || classified < total / 2) return "flat";
-  return industries ? "sector-industry" : "sector";
+function formatMove(asset: HeatmapBoardAsset, change: number | null): string {
+  const mark = sessionMark(asset);
+  return change == null ? "—" : mark ? `${formatPercentRaw(change)} ${mark}` : formatPercentRaw(change);
 }
 
 /**
@@ -191,7 +176,7 @@ const paintItemCache = new WeakMap<HeatmapBoardAsset, MetricTreemapItem<HeatmapB
 function paintItem(asset: HeatmapBoardAsset): MetricTreemapItem<HeatmapBoardAsset> {
   const cached = paintItemCache.get(asset);
   if (cached) return cached;
-  const change = changeOf(asset);
+  const change = heatmapMove(asset);
   const details = [
     asset.price > 0 ? formatCurrency(asset.price, asset.currency) : null,
     sizeLabel(asset),
@@ -205,8 +190,9 @@ function paintItem(asset: HeatmapBoardAsset): MetricTreemapItem<HeatmapBoardAsse
     weight: asset.weight ?? asset.size ?? 0,
     colorValue: change,
     primaryText: formatHeatTileMove(change),
+    primaryTextSuffix: sessionMark(asset),
     tooltip: [
-      [asset.symbol, name, change == null ? "—" : formatPercentRaw(change)].filter(Boolean).join(" · "),
+      [asset.symbol, name, formatMove(asset, change)].filter(Boolean).join(" · "),
       ...(details.length > 0 ? [details.join(" · ")] : []),
     ],
     data: asset,
@@ -224,18 +210,10 @@ function otherSummary(items: readonly MetricTreemapItem<HeatmapBoardAsset>[]): s
 }
 
 function otherTooltip(items: readonly MetricTreemapItem<HeatmapBoardAsset>[]): string[] {
-  let weight = 0;
-  let weightedMove = 0;
-  for (const item of items) {
-    const change = changeOf(item.data);
-    const size = item.data.size ?? 0;
-    if (change == null || !(size > 0)) continue;
-    weight += size;
-    weightedMove += change * size;
-  }
+  const move = sizeWeightedMove(items.map((item) => item.data));
   return [
     tf("Other · {count} smaller names", { count: items.length }),
-    ...(weight > 0 ? [`${formatPercentRaw(weightedMove / weight)} ${t("cap-weighted")}`] : []),
+    ...(move != null ? [`${formatPercentRaw(move)} ${t("cap-weighted")}`] : []),
   ];
 }
 
@@ -262,6 +240,7 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
   const linkedPortfolio = useLinkedHeatmapCollection();
   const collectionId = linkedPortfolio.collectionId ?? fallbackHeatmapCollectionId(config);
   const collectionKind = getCollectionTypeFromConfig(config, collectionId);
+  const [, publishCollectionKind] = usePaneStateValue<string>(HEATMAP_COLLECTION_KIND_STATE_KEY, "");
   const portfolioLabel = heatmapCollectionLabel(config, collectionId);
   const universeTabs = useMemo(() => [
     ...MARKET_HEATMAP_UNIVERSES.map((universe) => ({ label: universe.label, value: universe.id })),
@@ -367,7 +346,7 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
     liveStreaming,
   });
   const resolvedAssets = useMemo(
-    () => overlayScreenerQuoteEntries(boardAssets, liveQuoteEntries),
+    () => overlayScreenerQuoteEntries(boardAssets, liveQuoteEntries, { extendedSessions: true }),
     [boardAssets, liveQuoteEntries],
   );
   const feedStatus = useMemo(
@@ -381,7 +360,7 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
   // Sizes follow live prices at most every LAYOUT_THROTTLE_MS and only past
   // LAYOUT_TOLERANCE; a new snapshot relays out at once. Ticks only recolour.
   const grouping = useMemo(
-    () => resolveGrouping(boardAssets, activeUniverse === "us-equity"),
+    () => resolveHeatmapGrouping(boardAssets, activeUniverse === "us-equity"),
     [activeUniverse, boardAssets],
   );
   const layoutAssets = useThrottledMemo(
@@ -456,6 +435,11 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
     setSelectedSymbol(null);
   }, [collectionId, linkPortfolio, setActiveUniverse]);
 
+  // The header shows the square-root control only where it changes the board.
+  useEffect(() => {
+    publishCollectionKind(collectionKind ?? "");
+  }, [collectionKind, publishCollectionKind]);
+
   // The financials map only reads the cache; this fills it for the list on screen.
   useEffect(() => {
     if (!portfolioTab) return;
@@ -610,11 +594,12 @@ function MarketHeatmapPane({ focused, width, height }: PaneProps) {
         parts: [
           { text: selectedAsset.symbol, tone: "label" as const },
           {
-            text: changeOf(selectedAsset) == null ? "—" : formatPercentRaw(changeOf(selectedAsset)!),
+            text: heatmapMove(selectedAsset) == null ? "—" : formatPercentRaw(heatmapMove(selectedAsset)!),
             tone: "value" as const,
-            color: changeOf(selectedAsset) == null ? undefined : priceColor(changeOf(selectedAsset)!),
+            color: heatmapMove(selectedAsset) == null ? undefined : priceColor(heatmapMove(selectedAsset)!),
             bold: true,
           },
+          ...(sessionMark(selectedAsset) ? [{ text: sessionMark(selectedAsset)!, tone: "muted" as const }] : []),
           ...(selectedAsset.price > 0
             ? [{ text: formatCurrency(selectedAsset.price, selectedAsset.currency), tone: "value" as const }]
             : []),
@@ -696,12 +681,20 @@ export const marketHeatmapPlugin: GloomPlugin = {
       name: "Market Heatmap",
       icon: "H",
       component: MarketHeatmapPane,
+      headless: marketHeatmapHeadless,
       defaultPosition: "right",
       defaultMode: "floating",
       defaultFloatingSize: { width: 110, height: 36 },
       quickSettings: [
         LIVE_STREAMING_QUICK_SETTING,
-        { type: "toggle", key: SIZE_BY_SETTING_KEY, icon: "sqrt", onValue: SQRT_SIZE_VALUE, label: "Size by square root of market cap" },
+        {
+          type: "toggle",
+          key: SIZE_BY_SETTING_KEY,
+          icon: "sqrt",
+          onValue: SQRT_SIZE_VALUE,
+          label: "Size by square root of market cap",
+          visible: (context) => heatmapSizeByApplies(context.settings.universe, context.paneState[HEATMAP_COLLECTION_KIND_STATE_KEY]),
+        },
       ],
       settings: (context) => withLiveStreamingSetting({
         title: "Market Heatmap Settings",