@gloom-sh/terminal 0.0.0-stage → 0.19.0

package/src/plugins/builtin/company-attention/evidence.ts

@@ -0,0 +1,61 @@
+import type { PaneScreenshotEvidenceHook } from "../../../cli/pane-functions/screenshot-evidence";
+import { useRemoteUiNode } from "../../../remote/semantic-tree";
+import { isRecord } from "../../../utils/guards";
+import { fetchAppRank, fetchAttention, fetchBuilding, fetchMoves, fetchSignals, validateAttention, type AttentionPayload } from "./client";
+import { isBuildingFilter } from "./building-model";
+import { isMovesFilter } from "./moves-model";
+import { isSignalGroup, isSignalsFilter } from "./signals-model";
+import type { AttentionKind } from "./model";
+import type { AppChart, AppRankPayload } from "../../../api-client/app-attention";
+
+interface AttentionEvidence {
+  kind: AttentionKind;
+  version: 1;
+  complete: boolean;
+  plottedValueCount: number;
+  payload: AttentionPayload | AppRankPayload;
+  tab: string;
+  rowIds: string[];
+}
+export function useAttentionEvidence(kind: AttentionKind, payload: AttentionPayload | null, tab: string, rowIds: string[]) {
+  useRemoteUiNode({ role: "chart-data", label: `Rendered ${kind} observations`, getMetadata: () => ({ kind, version: 1, complete: !!payload, ready: !!payload, plottedValueCount: rowIds.length, payload, tab, rowIds }) });
+}
+export function attentionScreenshotEvidence(kind: AttentionKind): PaneScreenshotEvidenceHook<AttentionEvidence> {
+  return {
+    paneId: kind, kind, label: kind,
+    async prepare({ resolved }) {
+      if (kind === "apps" && typeof resolved.options.appId === "string" && resolved.options.appId) {
+        const payload = await fetchAppRank({ store: resolved.options.store === "google-play" ? "google-play" : "app-store", appId: resolved.options.appId, name: resolved.options.appId, country: String(resolved.options.country || "US"), chart: (resolved.options.chart || "free") as AppChart }, Number(resolved.options.days) || 90);
+        return { settings: { appRankSnapshot: payload, appRankName: payload.rankHistory[0]?.name ?? payload.appId }, financials: [] };
+      }
+      const symbol = resolved.createOptions?.symbol ?? resolved.createOptions?.arg;
+      const payload = await fetchAttention(kind, symbol, { country: typeof resolved.options.country === "string" ? resolved.options.country : undefined, chart: resolved.options.chart as "free" | "paid" | undefined, days: Number(resolved.options.days) || 90 });
+      // HIRE's Moves tab reads its own payload.
+      const moves = kind === "hiring" && resolved.options.tab === "moves"
+        ? await fetchMoves(symbol, { filter: typeof resolved.options.moves === "string" && isMovesFilter(resolved.options.moves) ? resolved.options.moves : "moves" }) : null;
+      // So do Expansion and Anomalies.
+      const group = kind === "hiring" && typeof resolved.options.tab === "string" && isSignalGroup(resolved.options.tab) ? resolved.options.tab : null;
+      const signalsKind = typeof resolved.options.kind === "string" ? resolved.options.kind : "all";
+      const signals = group ? await fetchSignals(group, symbol, { filter: isSignalsFilter(group, signalsKind) ? signalsKind : "all" }) : null;
+      // And Building.
+      const dimension = typeof resolved.options.dimension === "string" && isBuildingFilter(resolved.options.dimension) ? resolved.options.dimension : "all";
+      const building = kind === "hiring" && resolved.options.tab === "building" ? await fetchBuilding(symbol, { filter: dimension }) : null;
+      return { settings: { attentionSnapshot: payload, ...(moves ? { movesSnapshot: moves } : {}), ...(group && signals ? { [`${group}Snapshot`]: signals } : {}), ...(building ? { buildingSnapshot: building } : {}) }, financials: symbol ? [[symbol, { annualStatements: [], quarterlyStatements: [], priceHistory: [] }]] : [] };
+    },
+    read(value) {
+      if (!isRecord(value) || value.kind !== kind || value.version !== 1 || value.complete !== true || !isRecord(value.payload)
+        || !["table", "chart", "mix", "peers", "evidence", ...(kind === "hiring" ? ["moves", "expansion", "anomalies", "building"] : [])].includes(String(value.tab)) || !Array.isArray(value.rowIds) || !value.rowIds.every((id) => typeof id === "string") || value.plottedValueCount !== value.rowIds.length) return null;
+      try { if (!(kind === "apps" && Array.isArray(value.payload.rankHistory))) validateAttention(kind, value.payload as unknown as AttentionPayload); return value as unknown as AttentionEvidence; } catch {
+        // Intentional ignore: invalid captured observations are rejected as evidence by returning null.
+        return null;
+      }
+    },
+    mismatches(evidence, { resolved, payload }) {
+      const settings = payload.config.layout.instances.find((entry) => entry.instanceId === payload.paneId)?.settings;
+      const snapshot = settings?.appRankSnapshot ?? settings?.attentionSnapshot;
+      return [...(JSON.stringify(snapshot) !== JSON.stringify(evidence.payload) ? ["Rendered observations differ from the captured evidence."] : []), ...(evidence.tab !== (resolved.options.tab ?? "table") ? ["Rendered tab differs from the requested tab."] : [])];
+    },
+    unavailable(evidence) { return evidence?.complete ? [] : [`${kind} observations`]; },
+    symbols({ payload }) { return payload.financials.map(([symbol]) => symbol); },
+  };
+}

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

@@ -0,0 +1,172 @@
+import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/plugin";
+import type { DataTableColumn } from "../../../components";
+import type { AppAttentionPayload, AppChart } from "../../../api-client/app-attention";
+import type { HiringBoard, HiringPayload } from "../../../api-client/hiring";
+import { fetchAppRank, fetchAttention, fetchBuilding, fetchMoves, fetchSignals, type BuildingPayload, type SignalsPayload } from "./client";
+import { BUILDING_FILTERS, BUILDING_VIEWS, buildingBoardModel, buildingNumber, buildingPreviewNote, companyBuildingModel, isBuildingFilter, type BuildingSection } from "./building-model";
+import { appsModel, appsPreviewNote, attentionNumber, attentionSectionTitle, attentionTabs, hiringModel, hiringPreviewNote, remoteText, type AttentionKind } from "./model";
+import { companyMovesModel, isMovesFilter, movesBoardModel, movesNumber, movesPreviewNote, MOVES_FILTERS, MOVES_VIEWS, type MovesSection } from "./moves-model";
+import type { HiringMovesFilter, HiringSignalGroup } from "../../../api-client/hiring";
+import { companySignalsModel, holdText, isSignalsFilter, signalsBoardModel, signalsNumber, signalsPreviewNote, SIGNAL_FILTERS, SIGNAL_GROUPS, SIGNALS_VIEWS, type SignalsSection } from "./signals-model";
+import { REPORT_PAGE, REPORT_ROWS } from "../shared/headless-options";
+
+/**
+ * Numbers print as the pane draws them: shares to a tenth, ratings and
+ * z-scores to a hundredth, counts whole, and a remote share with the roles it
+ * is measured on. Exports keep the full value.
+ */
+function reportColumn(column: DataTableColumn): HeadlessPaneColumn {
+  if (column.align !== "right") return { key: column.id, header: column.label, align: column.align };
+  const format = (value: unknown) => typeof value === "number" ? attentionNumber(column.id, value) : value == null ? "-" : String(value);
+  return { key: column.id, header: column.label, align: column.align, format,
+    ...(column.id === "remote" ? { textFormat: (value: unknown, row: HeadlessPaneRow) => typeof value === "number"
+      ? remoteText(value, typeof row.remoteKnown === "number" ? row.remoteKnown : null) ?? "-" : "-" } : {}) };
+}
+
+/** A moves view as a report section: paces as `3.4x`, scores signed, and on the board each move's why. */
+function movesSection(title: string, section: MovesSection, why: boolean) {
+  return {
+    title, empty: section.empty, ...(section.locked ? { locked: true } : {}),
+    columns: [...section.columns.map((column): HeadlessPaneColumn => column.align !== "right" ? { key: column.id, header: column.label, align: column.align }
+      : { key: column.id, header: column.label, align: column.align, format: (value: unknown) => typeof value === "number" ? movesNumber(column.id, value) : value == null ? "-" : String(value) }),
+    ...(why ? [{ key: "why", header: "Why", align: "left" as const }] : [])],
+    rows: section.rows.map((row) => ({ ...row.values, ...(row.move ? { why: row.move.why } : {}), ...(row.url ? { sourceUrl: row.url } : {}) })),
+  };
+}
+
+/** A signals view as a report section: paces as `3.4x`, and each signal's why. */
+function signalsSection(title: string, section: SignalsSection) {
+  return {
+    title, empty: section.empty, ...(section.locked ? { locked: true } : {}),
+    columns: [...section.columns.map((column): HeadlessPaneColumn => column.align !== "right" ? { key: column.id, header: column.label, align: column.align }
+      : { key: column.id, header: column.label, align: column.align, format: (value: unknown) => typeof value === "number" ? signalsNumber(column.id, value) : value == null ? "-" : String(value) }),
+    ...(section.rows.some((row) => row.signal && !row.jobPosting) ? [{ key: "why", header: "Why", align: "left" as const }] : [])],
+    rows: section.rows.map((row) => ({ ...row.values, ...(row.signal && !row.jobPosting ? { why: row.signal.why } : {}), ...(row.url ? { sourceUrl: row.url } : {}) })),
+  };
+}
+/** A building view as a report section: shares as percents, changes in points, and each shift's why. */
+function buildingSection(title: string, section: BuildingSection) {
+  const why = section.rows.some((row) => row.shift && !row.jobPosting && !row.mix);
+  return {
+    title, empty: section.empty, ...(section.locked ? { locked: true } : {}),
+    columns: [...section.columns.map((column): HeadlessPaneColumn => column.align !== "right" ? { key: column.id, header: column.label, align: column.align }
+      : { key: column.id, header: column.label, align: column.align, format: (value: unknown) => typeof value === "number" ? buildingNumber(column.id, value) : value == null ? "-" : String(value) }),
+    ...(why ? [{ key: "why", header: "Why", align: "left" as const }] : [])],
+    rows: section.rows.map((row) => ({ ...row.values, ...(why && row.shift && !row.jobPosting ? { why: row.shift.why } : {}), ...(row.url ? { sourceUrl: row.url } : {}) })),
+  };
+}
+/** The Building board, or a company's mix by family and theme, its shifts and the postings behind them. */
+function buildingSections(data: BuildingPayload, filter: string): ReturnType<typeof buildingSection>[] {
+  if ("filter" in data) return [buildingSection("Building", buildingBoardModel(data, isBuildingFilter(filter) ? filter : "all").sections.board!)];
+  const model = companyBuildingModel(data);
+  return ([["families", "Building: role families"], ["themes", "Building: themes"], ["shifts", "Building: shifts"], ["postings", "Building postings"]] as const)
+    .filter(([id]) => id !== "postings" || model.sections.postings!.rows.length).map(([id, title]) => buildingSection(title, model.sections[id]!));
+}
+const SIGNAL_TITLES: Record<HiringSignalGroup, string> = { expansion: "Expansion", anomalies: "Anomalies" };
+/** A board's two groups, or a company's signals of both, as report sections. */
+function signalsSections(reads: Array<{ group: HiringSignalGroup; data: SignalsPayload }>, kind: string): ReturnType<typeof signalsSection>[] {
+  return reads.flatMap(({ group, data }) => {
+    if ("group" in data) return [signalsSection(SIGNAL_TITLES[group], signalsBoardModel(data, isSignalsFilter(group, kind) ? kind : "all").sections.board!)];
+    const model = companySignalsModel(data, group);
+    return [signalsSection(SIGNAL_TITLES[group], model.sections.signals!),
+      ...(model.sections.postings!.rows.length ? [signalsSection(`${SIGNAL_TITLES[group]} postings`, model.sections.postings!)] : [])];
+  });
+}
+
+export function attentionHeadless(kind: AttentionKind): HeadlessPaneDefinition<"bundle"> {
+  return {
+    shape: "bundle",
+    freshness: kind === "hiring"
+      ? { source: "Company careers sites", status: "not-a-feed", basis: "observed job postings", dataset: true }
+      : { source: "App Store and Google Play charts", status: "not-a-feed", basis: "observed chart ranks", dataset: true },
+    argument: { kind: "ticker", optional: true, placeholder: "ticker", description: "Company ticker, including exchange for non-US listings. Omit for the global board." },
+    options: [
+      { key: "limit", shot: REPORT_ROWS, type: "string", defaultValue: "100", description: "Rows per REST page, up to 200 for hiring and 500 for apps." },
+      { key: "offset", shot: REPORT_PAGE, type: "string", defaultValue: "0", description: "Continuation offset from the prior report metadata." },
+      { key: "tab", type: "enum", settingKey: "tab", values: [...["table", "chart", "mix", "peers", "evidence"], ...(kind === "hiring" ? ["moves", "expansion", "anomalies", "building"] : [])].map((value) => ({ value })), defaultValue: "table",
+        description: kind === "hiring" ? "Table, dated history, role mix, peers, source evidence, moves against the company's own weeks and peers, first roles in a new country or city, place and role-family spikes, or the role families and themes whose share of new roles rose." : "Table, dated history, geographic or role mix, peers, or source evidence." },
+      ...(kind === "hiring" ? [
+        { key: "moves", type: "enum" as const, settingKey: "movesFilter", values: MOVES_FILTERS.map(({ value }) => ({ value })), defaultValue: "moves", description: "Which hiring moves the board lists: own moves, one direction, or every measured company." },
+        { key: "view", type: "enum" as const, settingKey: "movesView", values: MOVES_VIEWS.map(({ value }) => ({ value })), defaultValue: "weeks", description: "A company's Moves tab: its weeks, the role families or titles behind the move, or the postings first seen or closed that week." },
+        { key: "kind", type: "enum" as const, settingKey: "signalsKind", values: [...new Set(SIGNAL_GROUPS.flatMap((group) => SIGNAL_FILTERS[group].map(({ value }) => value)))].map((value) => ({ value })), defaultValue: "all",
+          description: "Which signals the Expansion or Anomalies board lists: new countries or cities, place or role-family spikes, or new role families." },
+        { key: "signalsView", aliases: ["signals-view"], type: "enum" as const, settingKey: "signalsView", values: SIGNALS_VIEWS.map(({ value }) => ({ value })), defaultValue: "signals",
+          description: "A company's Expansion or Anomalies tab: its signals, or the postings behind this week's." },
+        { key: "dimension", type: "enum" as const, settingKey: "buildingDimension", values: BUILDING_FILTERS.map(({ value }) => ({ value })), defaultValue: "all",
+          description: "Which shifts the Building board lists: role families, themes, or both." },
+        { key: "buildingView", aliases: ["building-view"], type: "enum" as const, settingKey: "buildingView", values: BUILDING_VIEWS.map(({ value }) => ({ value })), defaultValue: "families",
+          description: "A company's Building tab: its mix by role family or by theme, its shifts, or the postings behind this week's." },
+      ] : []),
+      ...(kind === "apps" ? [
+        { key: "appId", aliases: ["app-id"], type: "string" as const, settingKey: "appId", description: "Open one app's exact country/chart rank history instead of a company." },
+        { key: "store", type: "enum" as const, settingKey: "store", values: [{ value: "app-store" }, { value: "google-play" }], defaultValue: "app-store", description: "Store for an individual app history." },
+        { key: "country", type: "string" as const, settingKey: "country", description: "Country ISO code; omit for every covered country." },
+        { key: "chart", type: "enum" as const, settingKey: "chart", values: ["free", "paid", "unranked"].map((value) => ({ value })), description: "Chart basis. Unranked observations have no chart rank." },
+        { key: "days", type: "string" as const, settingKey: "days", defaultValue: "90", description: "Calendar history window, 7 to 730 days." },
+      ] : []),
+    ],
+    discovery: { aliases: [kind === "hiring" ? "HIRE" : "APPS"], dataRequirements: ["Gloom Cloud account"], limitations: kind === "hiring"
+      ? ["Pro: full weekly history and evidence; free preview.", "Observed requisitions, not headcount or confirmed office openings.", "History begins with retained captures; incomplete snapshots cannot imply hiring freezes."]
+      : ["Pro: full chart history and evidence; free preview.", "Public top charts are an observed subset, not downloads or revenue.", "Grossing feeds are unavailable; written reviews are distinct from ratings.", "Mappings use evidenced ownership; unmapped apps stay visible."] },
+    describe: (args) => `${kind === "hiring" ? "Hiring momentum" : "App attention"}${args.symbols[0] ? ` | ${args.symbols[0]}` : ""}`,
+    async load(args, ctx) {
+      if (kind === "apps" && typeof args.options.appId === "string" && args.options.appId) {
+        const store = args.options.store === "google-play" ? "google-play" : "app-store";
+        const rank = await fetchAppRank({ store, appId: args.options.appId, name: args.options.appId, country: String(args.options.country || (store === "google-play" ? "GLOBAL" : "US")).toUpperCase(), chart: (args.options.chart || (store === "google-play" ? "unranked" : "free")) as AppChart }, Number(args.options.days) || 90, Number(args.options.offset) || 0, ctx.signal, ctx.apiClient, Number(args.options.limit) || 100);
+        return { complete: rank.access === "pro" && rank.page.nextOffset === null, sections: [{ title: "App rank history", rows: rank.rankHistory }], metadata: { nextOffset: rank.page.nextOffset, preview: rank.access === "preview", lockedRows: rank.locked, provenance: rank } };
+      }
+      const movesFilter: HiringMovesFilter = typeof args.options.moves === "string" && isMovesFilter(args.options.moves) ? args.options.moves : "moves";
+      // Moves are their own read; a server without them leaves the rest of the report as it was.
+      const failed = (error: unknown) => error instanceof Error ? error : new Error(String(error));
+      const movesRead = kind === "hiring" ? fetchMoves(args.symbols[0], { filter: movesFilter }, ctx.apiClient, ctx.signal).catch(failed) : null;
+      // So are Expansion and Anomalies: a company's both groups in one read, the board one read each.
+      const signalsKind = typeof args.options.kind === "string" ? args.options.kind : "all";
+      const signalsRead = kind !== "hiring" ? null : Promise.all((args.symbols[0] ? ["expansion" as const] : SIGNAL_GROUPS).map((group) =>
+        fetchSignals(group, args.symbols[0], { filter: isSignalsFilter(group, signalsKind) ? signalsKind : "all" }, ctx.apiClient, ctx.signal))).catch(failed);
+      // And Building.
+      const dimension = typeof args.options.dimension === "string" && isBuildingFilter(args.options.dimension) ? args.options.dimension : "all";
+      const buildingRead = kind === "hiring" ? fetchBuilding(args.symbols[0], { filter: dimension }, ctx.apiClient, ctx.signal).catch(failed) : null;
+      const data = await fetchAttention(kind, args.symbols[0], { limit: Number(args.options.limit) || 100, offset: Number(args.options.offset) || 0, ...(typeof args.options.country === "string" ? { country: args.options.country } : {}), ...(typeof args.options.chart === "string" ? { chart: args.options.chart as AppChart } : {}), days: Number(args.options.days) || 90 }, ctx.apiClient);
+      const filtered = typeof args.options.country === "string" && !!args.options.country || typeof args.options.chart === "string" && !!args.options.chart;
+      const model = kind === "hiring" ? hiringModel(data as HiringPayload | HiringBoard) : appsModel(data as AppAttentionPayload, undefined, filtered);
+      const offset = Number(args.options.offset) || 0;
+      // The free preview ignores the offset, so it has no next page to point at.
+      const nextOffset = kind === "hiring" && "total" in data ? !data.preview && offset + data.companies.length < data.total ? offset + data.companies.length : null : (data as AppAttentionPayload).page?.nextOffset ?? null;
+      const lock = kind === "hiring" ? hiringPreviewNote(data as HiringPayload | HiringBoard) : appsPreviewNote(data as AppAttentionPayload);
+      const movesData = movesRead ? await movesRead : null;
+      const movesModel = movesData && !(movesData instanceof Error) ? "moves" in movesData ? movesBoardModel(movesData, movesFilter) : companyMovesModel(movesData) : null;
+      const movesLock = movesData && !(movesData instanceof Error) ? movesPreviewNote(movesData, movesFilter) : null;
+      const signalsData = signalsRead ? await signalsRead : null;
+      const signalsReads = !signalsData || signalsData instanceof Error ? [] : args.symbols[0] ? SIGNAL_GROUPS.map((group) => ({ group, data: signalsData[0]! })) : signalsData.map((data, index) => ({ group: SIGNAL_GROUPS[index]!, data }));
+      const signalsLocks = !signalsData || signalsData instanceof Error ? [] : signalsData.map((data) => signalsPreviewNote(data, "group" in data && isSignalsFilter(data.group, signalsKind) ? signalsKind : undefined));
+      const buildingData = buildingRead ? await buildingRead : null;
+      const buildingLock = buildingData && !(buildingData instanceof Error) ? buildingPreviewNote(buildingData, dimension) : null;
+      const buildingHeld = buildingData && !(buildingData instanceof Error) && !("filter" in buildingData) ? companyBuildingModel(buildingData).held : null;
+      // A company's move says why in one sentence; the board's rows each carry theirs.
+      const why = movesModel?.latest?.why;
+      const company = args.symbols[0] ? signalsReads[0]?.data : undefined;
+      const held = company && !("group" in company) && company.held ? holdText(company.held) : null;
+      const notes = [...model.notices, ...(nextOffset !== null ? [`Additional observations available with --offset ${nextOffset}.`] : []),
+        ...(movesData instanceof Error ? [movesData.message] : []), ...(why ? [why] : []),
+        ...(signalsData instanceof Error ? [signalsData.message] : []), ...(held ? [`No expansion or anomaly signal this week: ${held.toLowerCase()}.`] : []),
+        ...(buildingData instanceof Error ? [buildingData.message] : []), ...(buildingHeld ? [`No mix to compare this week: ${buildingHeld.toLowerCase()}.`] : [])];
+      const movesSections = !movesModel ? [] : (args.symbols[0] ? ([["weeks", "Hiring moves"], ["drivers", "Move drivers"], ["added", "Postings first seen"]] as const) : ([["board", "Hiring moves"]] as const))
+        .map(([id, title]) => movesSection(title, movesModel.sections[id]!, id === "board"));
+      return {
+        complete: !model.preview && !model.partial && nextOffset === null,
+        ...(lock || movesLock || buildingLock || signalsLocks.some(Boolean) ? { errors: [lock, movesLock, ...signalsLocks, buildingLock].filter((line): line is string => !!line) } : {}),
+        ...(notes.length ? { notes } : {}),
+        // A ticker no observed app is mapped to says so once, not under each empty view.
+        ...(model.unmapped ? { empty: model.unmapped } : {}),
+        // The views the pane has tabs for, each headed by what its rows are.
+        sections: attentionTabs(kind, args.symbols[0]).map((tab) => {
+          const section = model.sections[tab];
+          return { title: attentionSectionTitle(kind, tab, args.symbols[0]),
+            columns: section.columns.map(reportColumn), empty: section.empty, ...(section.locked ? { locked: true } : {}),
+            rows: section.rows.map((row) => ({ ...row.values, ...(row.url ? { sourceUrl: row.url } : {}), ...(row.details ? { evidence: row.details } : {}) })) };
+        }).concat(movesSections, signalsSections(signalsReads, signalsKind), buildingData && !(buildingData instanceof Error) ? buildingSections(buildingData, dimension) : []),
+        metadata: { nextOffset, asOf: model.asOf, preview: model.preview, lockedRows: model.locked, unit: model.chart.unit, provenance: data },
+      };
+    },
+  };
+}

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

@@ -0,0 +1,35 @@
+import type { PluginModule } from "../plugin-module";
+import type { PaneTemplateDef } from "../../../types/plugin";
+import { appRankCache, attentionCache, buildingCache, movesCache, signalsCache } from "./client";
+import { attentionHeadless } from "./headless";
+import { AppsPane, HiringPane } from "./pane";
+import { COMPANY_ATTENTION_SERIES } from "./series";
+
+const definitions = [
+  { id: "hiring", prefix: "HIRE", label: "Hiring Momentum", component: HiringPane, description: "Pro hiring momentum: observed weekly open roles, additions, removals, role and location mix, peer comparisons, hiring moves against each company's own weeks and peers, first roles in a new country or city, place and role-family spikes, and primary posting evidence.", keywords: ["hiring", "workforce", "roles", "recruitment", "surge", "freeze"] },
+  { id: "apps", prefix: "APPS", label: "App Attention", component: AppsPane, description: "Pro app attention: public global app ranks, rank velocity, rating drift, company ownership and source evidence.", keywords: ["apps", "app attention", "mobile", "rank", "ratings", "developer"] },
+] as const;
+const templates: PaneTemplateDef[] = definitions.map((def) => ({
+  id: `${def.id}-pane`, paneId: def.id, label: def.label, description: def.description, keywords: [...def.keywords],
+  shortcut: { prefix: def.prefix, argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
+  headless: attentionHeadless(def.id),
+  createInstance: (_context, options) => {
+    const symbol = (options?.symbol ?? options?.arg ?? "").trim().toUpperCase();
+    return { instanceId: `${def.id}:${symbol ? encodeURIComponent(symbol).replace(/%/g, "~") : "board"}`, title: symbol ? `${def.prefix} ${symbol}` : def.label, ...(symbol ? { binding: { kind: "fixed" as const, symbol } } : {}), placement: "floating" };
+  },
+}));
+export const companyAttentionModule: PluginModule = {
+  series: COMPANY_ATTENTION_SERIES,
+  setup(ctx) {
+    attentionCache.attach(ctx.persistence);
+    movesCache.attach(ctx.persistence);
+    signalsCache.attach(ctx.persistence);
+    buildingCache.attach(ctx.persistence);
+    appRankCache.attach(ctx.persistence);
+    ctx.registerTickerResearchTab({ id: "hiring-momentum", name: "Hiring momentum", order: 38, component: HiringPane, instruments: ["equity"] });
+    ctx.registerTickerResearchTab({ id: "app-attention", name: "Apps", order: 39, component: AppsPane, instruments: ["equity"] });
+  },
+  dispose() { attentionCache.reset(); movesCache.reset(); signalsCache.reset(); buildingCache.reset(); appRankCache.reset(); },
+  panes: definitions.map((def) => ({ id: def.id, name: def.label, icon: def.prefix[0]!, component: def.component, defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 130, height: 32 }, tickerFollower: true, instruments: ["equity"], tableExport: true, headless: attentionHeadless(def.id) })),
+  paneTemplates: templates,
+};

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

@@ -0,0 +1,270 @@
+import type { DataTableColumn, StatItem } from "../../../components";
+import { scalarPoint, staticSeries } from "../../../components/chart/static/series";
+import type { HiringBoard, HiringPayload, HiringSummary } from "../../../api-client/hiring";
+import type { AppAttentionPayload, AppCompany } from "../../../api-client/app-attention";
+import { humanLabel } from "../shared/research-cells";
+import { formatNumber } from "../../../utils/format";
+import { countOf, freePreviewNote } from "../shared/free-preview";
+import { countryName, postingPlace, postingTitle } from "../shared/job-posting";
+import { formatShortDate } from "../../../utils/datetime-format";
+
+export type AttentionKind = "hiring" | "apps";
+export type AttentionTab = "table" | "chart" | "mix" | "peers" | "evidence";
+export interface AttentionRow {
+  id: string;
+  values: Record<string, string | number | null>;
+  symbol?: string;
+  date?: string;
+  url?: string | null;
+  /** What the row's detail reads: facts in words, only those the row has (no dashes, ids, revisions or confidences). */
+  details?: AttentionFact[];
+  /** Links the detail offers by name (an ownership filing, a ratings page), never as a bare address. */
+  links?: Array<{ label: string; url: string }>;
+  /** A posting whose page the detail reads: its title, place, date, pay, hours and description. */
+  posting?: { ticker: string; externalId: string };
+  app?: AppFocus;
+}
+interface AttentionFact { label: string; value: string }
+export interface AppFocus { store: "app-store" | "google-play"; appId: string; name: string; country: string; chart: "free" | "paid" | "grossing" | "unranked" }
+interface AttentionSection {
+  columns: DataTableColumn[];
+  rows: AttentionRow[];
+  empty: string;
+  /** The free preview holds this view's rows back: a report says so once, on its Pro line, not under the view. */
+  locked?: boolean;
+}
+export interface AttentionModel {
+  asOf: string | null;
+  preview: boolean;
+  locked: number;
+  /** Caveats about the capture, such as incomplete coverage; they never fail a report. */
+  notices: string[];
+  /** The latest capture is incomplete or stale, so a report of it is not the whole picture even on Pro. */
+  partial: boolean;
+  figures: StatItem[];
+  sections: Record<AttentionTab, AttentionSection>;
+  /**
+   * Why every view is empty, when one reason covers them all: a ticker no observed app is mapped to. A report says
+   * it once in place of each view's own empty line.
+   */
+  unmapped?: string;
+  /** `since`: the first capture, so a chart still collecting says when it began. */
+  chart: { label: string; unit: string; points: Array<{ date: string; value: number | null }>; since?: string | null };
+}
+/** The views a report has: a company's hiring and every apps report all five, the hiring board only its table. */
+export function attentionTabs(kind: AttentionKind, symbol: string | null | undefined): AttentionTab[] {
+  return kind === "apps" || symbol ? ["table", "chart", "mix", "peers", "evidence"] : ["table"];
+}
+
+/**
+ * A pane tab: a report view, or HIRE's moves, expansion, anomalies and
+ * building, which have their own reads (moves-model.ts, signals-model.ts,
+ * building-model.ts).
+ */
+export type AttentionPaneTab = AttentionTab | "moves" | "expansion" | "anomalies" | "building";
+const HIRING_READ_TABS = ["moves", "expansion", "anomalies", "building"] as const;
+export function attentionPaneTabs(kind: AttentionKind, symbol: string | null | undefined): AttentionPaneTab[] {
+  return kind === "hiring" ? [...attentionTabs(kind, symbol), ...HIRING_READ_TABS] : attentionTabs(kind, symbol);
+}
+
+/**
+ * A view's heading where the report prints it in full, as `fn HIRE` does:
+ * what its rows are (Open roles, Hiring trend), where the pane's tab says it
+ * in a word. The mix is the grouping the model chose.
+ */
+export function attentionSectionTitle(kind: AttentionKind, tab: AttentionTab, symbol: string | null | undefined, mix?: string): string {
+  if (kind === "hiring") {
+    return { table: symbol ? "Open roles" : "Companies hiring", chart: "Hiring trend", mix: HIRING_MIX_TITLES[mix ?? "functions"] ?? "Role family",
+      peers: "Peers", evidence: "Posting evidence" }[tab];
+  }
+  return { table: "App ranks", chart: "Attention trend", mix: mix === "spreads" ? "Rank spreads" : "Countries",
+    peers: symbol ? "Peers" : "Companies", evidence: "Chart evidence" }[tab];
+}
+
+const HIRING_MIX_TITLES: Record<string, string> = { functions: "Role family", seniority: "Seniority", countries: "Countries", locations: "Locations", signals: "Signals" };
+
+export const count = (value: number | null | undefined) => value == null ? "--" : value.toLocaleString("en-US", { maximumFractionDigits: 0 });
+/** Decimals per column: percentages and scores to one place, ratings and z-scores to two, counts and remote shares whole. */
+const DECIMALS: Record<string, number> = { score: 1, remote: 0, share: 1, confidence: 0, velocity: 2, rating: 2, drift: 2, z: 2, change: 1 };
+export const SIGNED_COLUMNS = new Set(["net", "change", "velocity", "drift", "growth"]);
+/** A column's number as the pane and the text report print it. */
+export const attentionNumber = (columnId: string, value: number) =>
+  `${SIGNED_COLUMNS.has(columnId) && value > 0 ? "+" : ""}${formatNumber(value, DECIMALS[columnId] ?? 0)}`;
+/**
+ * A remote share with the roles it is measured on. Most postings never state a
+ * work mode, so the share counts only those that do: 100% of 5 is not 100% of
+ * a company's 300 roles. A capture that did not count them says "of known".
+ */
+export function remoteText(percentRemote: number | null | undefined, known: number | null | undefined): string | null {
+  if (percentRemote == null) return null;
+  return `${formatNumber(percentRemote, 0)}% of ${known == null ? "" : `${formatNumber(known, 0)} `}known`;
+}
+const signed = (value: number | null | undefined, decimals = 0) => value == null ? "--" : `${value > 0 ? "+" : ""}${value.toLocaleString("en-US", { maximumFractionDigits: decimals })}`;
+/** A date in words ("Oct 22, 2026"), for a capture's ISO timestamp. */
+const day = (value: string | null | undefined) => value ? formatShortDate(value.slice(0, 10), { utc: true, fallback: "" }) || null : null;
+/** The facts that have a value, in order. */
+const facts = (entries: Array<[string, string | number | null | undefined]>): AttentionFact[] =>
+  entries.flatMap(([label, value]) => value == null || value === "" ? [] : [{ label, value: String(value) }]);
+const CAPTURES: Record<string, string> = { complete: "Complete", partial: "Partial", unknown: "Coverage not known" };
+const column = (id: string, label: string, width: number, numeric = false, flex = false): DataTableColumn => ({ id, label, width, align: numeric ? "right" : "left", ...(flex ? { flexGrow: 1 } : {}) });
+const roleFamily = (value: string | null) => value === "data_ai" || value === "data ai" ? "Data / AI" : value ? humanLabel(value) : null;
+const COMPANY_COLUMNS = [column("symbol", "Ticker", 12), column("name", "Company", 24, false, true), column("open", "Open roles", 12, true), column("net", "Net / week", 12, true), column("remote", "Remote %", 17, true), column("z", "Z-score", 10, true), column("signal", "Signal", 12), column("date", "As of", 12)];
+const HISTORY_COLUMNS = [column("date", "Week", 12), column("open", "Open roles", 12, true), column("added", "Added", 9, true), column("removed", "Removed", 9, true), column("net", "Net", 9, true), column("change", "Change %", 11, true), column("remote", "Remote %", 17, true), column("coverage", "Capture", 13, false, true)];
+/** `remoteKnown` rides along for the remote cell; it is not a column of its own. */
+const companyRow = (row: HiringSummary): AttentionRow => ({ id: row.symbol, symbol: row.symbol, values: { symbol: row.symbol, name: row.name, open: row.latest?.openCount ?? null, net: row.latest?.netChange ?? null, remote: row.latest?.remoteShare == null ? null : row.latest.remoteShare * 100, remoteKnown: row.latest?.remoteKnown ?? null, z: row.zScore, signal: humanLabel(row.signal ?? row.status), date: row.latest?.observedAt.slice(0, 10) ?? null } });
+
+/** The weeks of history a free preview holds back; the board has none to hold. */
+const hiringHistoryLocked = (data: HiringBoard | HiringPayload) => !data.preview ? 0 : typeof data.locked === "number" ? data.locked : data.locked.history;
+
+/** "a, b and c". */
+const joinList = (items: readonly string[]) => items.length < 2 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+const grouped = (value: number) => value.toLocaleString("en-US");
+
+/**
+ * The lock line of a free HIRE preview: how many of its rows free shows, what
+ * Pro adds and when its weekly history starts. Null when the preview holds
+ * nothing back (a company with no captures has nothing to unlock).
+ */
+export function hiringPreviewNote(data: HiringBoard | HiringPayload): string | null {
+  if (!data.preview) return null;
+  if ("companies" in data) {
+    if (data.locked <= 0) return null;
+    return freePreviewNote({ shows: `${data.companies.length} of ${grouped(data.total)} companies`, adds: `the other ${grouped(data.locked)}` });
+  }
+  const { evidence, history, peers } = data.locked;
+  if (evidence + history + peers <= 0) return null;
+  const roles = data.evidence.length;
+  return freePreviewNote({
+    shows: evidence > 0 ? `${roles} of ${grouped(roles + evidence)} open roles` : countOf(roles, "open role"),
+    adds: joinList([evidence > 0 ? `the other ${grouped(evidence)} roles` : "", history > 0 ? `${grouped(history)} ${history === 1 ? "week" : "weeks"} of history` : "", peers > 0 ? `${grouped(peers)} more peers` : ""].filter(Boolean)),
+    historyFrom: history > 0 ? data.coverage.firstObservedAt : null,
+  });
+}
+
+/**
+ * The lock line of a free APPS preview: how many app ranks free shows, what
+ * Pro adds and when its daily history starts. Null when nothing is held back.
+ */
+export function appsPreviewNote(data: AppAttentionPayload): string | null {
+  if (data.access !== "preview") return null;
+  const { apps, history } = data.locked;
+  if (apps + history <= 0) return null;
+  const ranks = data.apps.length;
+  const days = data.history.length;
+  return freePreviewNote({
+    shows: `${apps > 0 ? `${ranks} of ${grouped(ranks + apps)} app ranks` : countOf(ranks, "app rank")}${days ? " and the latest day of history" : ""}`,
+    adds: joinList([apps > 0 ? `the other ${grouped(apps)} ranks` : "", history > 0 ? `${grouped(history)} earlier ${history === 1 ? "day" : "days"} of history` : ""].filter(Boolean)),
+    historyFrom: history > 0 ? data.summary.firstObservedAt : null,
+  });
+}
+
+export function hiringModel(data: HiringBoard | HiringPayload, mix = "functions"): AttentionModel {
+  const detail = "series" in data ? data : null;
+  const companies = "companies" in data ? data.companies : [data];
+  const history = detail?.series ?? [];
+  const latest = detail?.latest;
+  const mixKey = ["functions", "seniority", "countries", "locations", "signals"].includes(mix) ? mix as "functions" | "seniority" | "countries" | "locations" | "signals" : "functions";
+  const rows = mixKey === "signals" ? (detail?.signals ?? []).map((row, i): AttentionRow => ({ id: `${row.type}:${i}`, url: row.evidenceUrls[0], values: { label: row.label, count: row.value, share: row.confidence * 100, date: row.asOf.slice(0, 10) }, details: facts([["As of", day(row.asOf)], ["Location", row.location]]) }))
+    : (detail?.[mixKey] ?? []).map((row): AttentionRow => ({ id: row.id, values: { label: mixKey === "functions" ? roleFamily(row.label) : mixKey === "seniority" ? humanLabel(row.label) : row.label, count: row.count, share: row.share * 100 } }));
+  const model: AttentionModel = {
+    asOf: latest?.observedAt ?? data.generatedAt,
+    preview: data.preview,
+    locked: typeof data.locked === "number" ? data.locked : Object.values(data.locked).reduce((a, b) => a + b, 0),
+    // How counts compare is methodology (docs/hiring-app-attention.md); the footer keeps only what is wrong with this capture.
+    notices: detail ? [...(latest?.completeness !== "complete" ? ["The latest capture has incomplete or unknown coverage."] : []), ...(detail.status === "stale" ? ["The latest hiring capture is stale."] : [])] : [],
+    partial: !!detail && (latest?.completeness !== "complete" || detail.status === "stale"),
+    // A figure the first capture cannot give yet (a weekly change, a z-score) is left out, not shown as a dash.
+    figures: latest ? [
+      { label: "Open roles", value: count(latest.openCount) },
+      ...(latest.netChange != null ? [{ label: "Net / week", value: signed(latest.netChange), tone: latest.netChange === 0 ? "muted" as const : latest.netChange > 0 ? "positive" as const : "negative" as const }] : []),
+      ...(latest.remoteShare != null ? [{ label: "Remote", value: `${formatNumber(latest.remoteShare * 100, 0)}%`,
+        detail: latest.remoteKnown == null ? "of known work modes" : `of ${count(latest.remoteKnown)} known` }] : []),
+      ...(detail?.zScore != null ? [{ label: "Z-score", value: detail.zScore.toFixed(2), detail: detail.signal ? `hiring ${detail.signal}` : undefined,
+        tone: detail.signal === "surge" ? "positive" as const : detail.signal === "freeze" ? "negative" as const : undefined }] : []),
+    ] : [],
+    sections: {
+      table: { columns: COMPANY_COLUMNS, rows: companies.map(companyRow), empty: "Hiring observations are not available yet." },
+      chart: { columns: HISTORY_COLUMNS, rows: [...history].reverse().map((row): AttentionRow => ({ id: row.week, date: row.week, values: { date: row.week, open: row.openCount, added: row.added, removed: row.removed, net: row.netChange, change: row.changePct, remote: row.remoteShare == null ? null : row.remoteShare * 100, remoteKnown: row.remoteKnown, coverage: row.completeness }, details: facts([["Captured", day(row.observedAt)], ["Coverage", CAPTURES[row.completeness] ?? null], ["Open roles", count(row.openCount)], ["Standing roles", row.evergreenCount ? count(row.evergreenCount) : null]]) })), empty: hiringHistoryLocked(data) ? "Weekly history is part of Gloom Pro." : "History is accumulating from the first capture.", ...(hiringHistoryLocked(data) ? { locked: true } : {}) },
+      mix: { columns: [column("label", mixKey === "signals" ? "Signal" : "Group", 28, false, true), column("count", mixKey === "signals" ? "Value" : "Roles", 12, true), column("share", mixKey === "signals" ? "Confidence %" : "Share %", mixKey === "signals" ? 14 : 30, true), ...(mixKey === "signals" ? [column("date", "Observed", 12)] : [])], rows, empty: "No classified observations for this group yet." },
+      peers: { columns: COMPANY_COLUMNS, rows: (detail?.peers ?? []).map(companyRow), empty: "No comparable mapped peers yet." },
+      evidence: { columns: [column("title", "Role", 32, false, true), column("location", "Location", 24), column("function", "Function", 18), column("seniority", "Seniority", 13), column("date", "Observed", 12), column("confidence", "Confidence %", 13, true)], rows: (detail?.evidence ?? []).map((row): AttentionRow => ({ id: `${row.snapshotId}:${row.id}`, url: row.url ?? row.sourceUrl, values: { title: postingTitle(row.title, row.id), location: row.location, function: roleFamily(row.jobFunction), seniority: row.seniority ? humanLabel(row.seniority) : null, date: row.observedAt.slice(0, 10), confidence: row.confidence * 100 }, details: facts([["Place", postingPlace(row)], ["Role family", roleFamily(row.jobFunction)], ["Seniority", row.seniority ? humanLabel(row.seniority) : null], ["Seen", day(row.observedAt)]]),
+        posting: { ticker: row.sourceTicker, externalId: row.id } })), empty: "No primary posting evidence is available yet." },
+    },
+    chart: { label: "Open roles", unit: "roles", points: history.map((point) => ({ date: point.week, value: point.openCount })), since: detail?.coverage.firstObservedAt ?? null },
+  };
+  if (detail) {
+    model.sections.table = { ...model.sections.evidence, columns: model.sections.evidence.columns.filter((entry) => entry.id !== "confidence"), empty: "No current role evidence has been captured yet." };
+  }
+  return model;
+}
+
+export function attentionSeries(model: Pick<AttentionModel, "chart">, color: string) {
+  // One or two captures are observations, not an established trend.
+  if (model.chart.points.filter((point) => point.value !== null).length < 3) return [];
+  const cadence = model.chart.unit === "roles" ? 7 * 86_400_000 : 86_400_000;
+  const points = [...model.chart.points].sort((a, b) => a.date.localeCompare(b.date)).flatMap((point, i, all) => {
+    const time = Date.parse(point.date), previous = i ? Date.parse(all[i - 1]!.date) : null;
+    const gap = previous !== null && time - previous > cadence * 1.5;
+    return [...(gap ? [scalarPoint(new Date(previous + cadence), null)] : []), scalarPoint(new Date(time), point.value)];
+  });
+  return [{ ...staticSeries(points, { id: "company-attention", label: model.chart.label, color, calendarSpaced: true }), unit: model.chart.unit, unitGroup: model.chart.unit }];
+}
+
+export function sortAttentionRows(rows: AttentionRow[], columnId: string, direction: "asc" | "desc") {
+  return [...rows].sort((a, b) => {
+    const left = a.values[columnId], right = b.values[columnId];
+    if (left == null) return right == null ? a.id.localeCompare(b.id) : 1;
+    if (right == null) return -1;
+    const result = typeof left === "number" && typeof right === "number" ? left - right : String(left).localeCompare(String(right));
+    return (direction === "asc" ? result : -result) || a.id.localeCompare(b.id);
+  });
+}
+
+const APP_COLUMNS = [column("name", "App", 27, false, true), column("symbol", "Ticker", 12), column("country", "Country", 9), column("chart", "Chart", 10), column("rank", "Rank", 7, true), column("change", "7D places", 12, true), column("rating", "Rating / 5", 12, true), column("ratings", "Ratings", 12, true), column("drift", "7D rating", 12, true), column("growth", "7D ratings", 12, true)];
+const APP_COMPANIES = [column("symbol", "Ticker", 12), column("name", "Company", 24, false, true), column("score", "Score / 100", 13, true), column("velocity", "Places / day", 14, true), column("apps", "Apps", 8, true), column("countries", "Countries", 11, true), column("drift", "7D rating", 12, true), column("growth", "7D ratings", 12, true)];
+const appCompanyRow = (row: AppCompany): AttentionRow => ({ id: row.symbol, symbol: row.symbol, values: { symbol: row.symbol, name: row.name, score: row.attentionScore, velocity: row.rankVelocity7d, apps: row.appCount, countries: row.countryCount, drift: row.ratingChange7d, growth: row.ratingCountGrowth7d } });
+/**
+ * Why a company's app report is empty when no observed app is mapped to its ticker at all: the charts are captured,
+ * none of their apps belongs to it, and no filter narrowed them. The free preview shows the first rows of what Pro
+ * sees, so an empty preview is never the free cap. Null when the report has rows, a filter is set, or nothing has
+ * been captured yet.
+ */
+function appsUnmappedReason(data: AppAttentionPayload, filtered: boolean): string | null {
+  if (!data.symbol || filtered || data.apps.length || (data.page?.total ?? 0) > 0 || data.summary.appCount > 0) return null;
+  // Rows held back for Pro are apps it maps, so a capped preview is never read as none.
+  if (!Object.values(data.locked).every((count) => !count)) return null;
+  if (!data.coverage.sources.some((source) => source.captures > 0)) return null;
+  return `${data.symbol} has no mapped apps in the observed App Store and Google Play charts.`;
+}
+
+/** `filtered`: a country or chart narrows the rows, so an empty table is about the filter, not the company. */
+export function appsModel(data: AppAttentionPayload, mix = "countries", filtered = false): AttentionModel {
+  const unmapped = appsUnmappedReason(data, filtered);
+  const evidence = data.evidence.map((row): AttentionRow => ({ id: `${row.revisionId}:${row.appId}`, url: row.sourceUrl, values: { name: row.name, country: row.country, chart: row.chart, rank: row.rank, observed: row.observedAt.slice(0, 10), confidence: row.confidence * 100 }, details: facts([["Chart", `${countryName(row.country) ?? row.country} · ${humanLabel(row.chart)}`], ["Rank", row.rank == null ? null : count(row.rank)], ["Rating", row.rating == null ? null : `${row.rating.toFixed(2)} / 5`], ["Ratings", row.ratingCount == null ? null : count(row.ratingCount)], ["Written reviews", row.reviewCount == null ? null : count(row.reviewCount)], ["Seen", day(row.observedAt)], ["Updated in store", day(row.sourceUpdatedAt)]]),
+    links: [...(row.mappingSourceUrl ? [{ label: "Ownership", url: row.mappingSourceUrl }] : []), ...(row.ratingSourceUrl ? [{ label: "Ratings", url: row.ratingSourceUrl }] : [])] }));
+  return {
+    asOf: data.summary.lastObservedAt,
+    preview: data.access === "preview",
+    locked: Object.values(data.locked).reduce((a, b) => a + b, 0),
+    notices: [...data.coverage.limitations, ...(data.apps.some((row) => row.stale) ? ["Some app observations are stale."] : [])],
+    partial: data.apps.some((row) => row.stale),
+    ...(unmapped ? { unmapped } : {}),
+    // Seven-day figures appear once a week of captures can give them.
+    figures: [
+      { label: "Attention score", value: data.summary.attentionScore?.toFixed(1) ?? "--", detail: "/ 100" },
+      ...(data.summary.rankVelocity7d != null ? [{ label: "Rank velocity", value: signed(data.summary.rankVelocity7d, 2), detail: "places / day" }]
+        : [{ label: "Apps", value: count(data.summary.appCount), detail: `${count(data.summary.countryCount)} countries` }]),
+      ...(data.summary.ratingChange7d != null ? [{ label: "Rating drift", value: signed(data.summary.ratingChange7d, 2), detail: "7D / 5" }] : []),
+      ...(data.summary.ratingCountGrowth7d != null ? [{ label: "Ratings added", value: signed(data.summary.ratingCountGrowth7d), detail: "7D" }] : []),
+    ],
+    sections: {
+      table: { columns: APP_COLUMNS, rows: data.apps.map((row): AttentionRow => ({ id: `${row.sourceId}:${row.appId}`, app: { store: row.store, appId: row.appId, name: row.name, country: row.country, chart: row.chart }, symbol: row.symbol ?? undefined, url: row.appUrl, values: { name: row.name, symbol: row.symbol, country: row.country, chart: row.chart, rank: row.rank, change: row.rankChange7d, rating: row.rating, ratings: row.ratingCount, drift: row.ratingChange7d, growth: row.ratingCountGrowth7d }, details: facts([["Developer", row.developer], ["Company", row.symbol], ["Genres", row.genres.join(", ")], ["Seen", day(row.observedAt)], ["Ratings seen", day(row.ratingObservedAt)]]) })), empty: unmapped ?? "No app observations match these filters yet." },
+      chart: { columns: [column("date", "Date", 12), column("score", "Score / 100", 14, true), column("change", "Change", 10, true), column("apps", "Apps", 9, true), column("countries", "Countries", 12, true), column("rating", "Rating / 5", 12, true), column("ratings", "Ratings", 13, true)], rows: data.history.map((point, i, all): AttentionRow => ({ id: point.date, date: point.date, values: { date: point.date, score: point.attentionScore, change: point.attentionScore != null && all[i - 1]?.attentionScore != null ? point.attentionScore - all[i - 1]!.attentionScore! : null, apps: point.appCount, countries: point.countryCount, rating: point.rating, ratings: point.ratingCount } })).reverse(), empty: data.access === "preview" && data.locked.history > 0 ? "Daily history is part of Gloom Pro." : "History is accumulating from the first capture.", ...(data.access === "preview" && data.locked.history > 0 ? { locked: true } : {}) },
+      mix: mix === "spreads" ? { columns: [column("name", "App", 28, false, true), column("chart", "Chart", 10), column("best", "Best country", 15), column("bestRank", "Best rank", 11, true), column("worst", "Worst country", 15), column("worstRank", "Worst rank", 12, true), column("spread", "Rank spread", 13, true)], rows: data.spreads.map((row): AttentionRow => ({ id: `${row.appId}:${row.chart}:${row.category}`, values: { name: row.name, chart: row.chart, best: row.bestCountry, bestRank: row.bestRank, worst: row.worstCountry, worstRank: row.worstRank, spread: row.spread } })), empty: "Comparable country observations are accumulating." }
+        : { columns: [column("country", "Country", 16, false, true), column("apps", "Apps", 9, true), column("ranked", "Ranked apps", 13, true), column("score", "Score / 100", 14, true), column("velocity", "Places / day", 15, true), column("date", "Observed", 12)], rows: data.countries.map((row): AttentionRow => ({ id: row.country, values: { country: row.country, apps: row.appCount, ranked: row.rankedApps, score: row.attentionScore, velocity: row.rankVelocity7d, date: row.observedAt.slice(0, 10) } })), empty: "Country observations are not available yet." },
+      peers: { columns: APP_COMPANIES, rows: (data.symbol ? data.peers : data.companies).map(appCompanyRow), empty: "No comparable mapped companies yet." },
+      evidence: { columns: [column("name", "App", 27, false, true), column("country", "Country", 10), column("chart", "Chart", 10), column("rank", "Rank", 8, true), column("observed", "Observed", 12), column("confidence", "Confidence %", 14, true)], rows: evidence, empty: "No primary chart evidence is available yet." },
+    },
+    chart: { label: "Attention score", unit: "/100", points: data.history.map((point) => ({ date: point.date, value: point.attentionScore })) },
+  };
+}