@gloom-sh/terminal 0.18.5 → 0.19.1

package/src/plugins/builtin/reverse-dcf/model.ts

@@ -1,6 +1,8 @@
 import { unavailableText } from "../../../components/ui/status";
 import { atRegularSessionPrice } from "../../../market-data/quotes/regular-session-valuation";
 import type { Fundamentals, TickerFinancials } from "../../../types/financials";
+import { fiscalPeriodLabel, fiscalYearEndMonth } from "../../../utils/fiscal-period";
+import { formatCompactCurrency } from "../../../utils/format";
 import { enterpriseValueCheck, enterpriseValueLabel, enterpriseValueNotMeaningful, enterpriseValueReconciliationNote,
   enterpriseValueWithdrawn, reportedEnterpriseValue } from "../../../utils/fundamentals";
 
@@ -50,8 +52,10 @@ export interface ReverseDcfModel {
   fcfMarginBasis: FcfMarginBasis;
   /** Year-ten revenue at `fcfMargin`: trailing free cash flow grown at the implied rate for ten years, over the margin. */
   impliedRevenue: number | null;
-  /** Annual FCF growth between the latest annual statement and one up to five years earlier, when both are positive. */
-  pastGrowth: { rate: number; years: number } | null;
+  /** Annual FCF growth between the latest annual statement and one up to five years earlier, when both are positive. `period` names the two years: FY2021–FY2025. */
+  pastGrowth: { rate: number; years: number; period: string } | null;
+  /** The latest annual statement's free cash flow, which the past growth ends at, and the year it is of (FY2025). */
+  fiscalYearFcf: { value: number; label: string } | null;
   /** Implied growth for each discount rate (rows) at each terminal growth (columns). */
   sensitivity: { discountRate: number; implied: (ImpliedGrowth | null)[] }[];
   error: string | null;
@@ -82,15 +86,65 @@ export function solveImpliedGrowth(enterpriseValue: number, fcf: number, discoun
   return { kind: "rate", value: (low + high) / 2 };
 }
 
-function pastFcfGrowth(financials: TickerFinancials): ReverseDcfModel["pastGrowth"] {
-  const annual = financials.annualStatements
+/** The latest annual statements with a free cash flow, oldest first, as many as the past growth looks back over. */
+function annualFreeCashFlows(financials: TickerFinancials) {
+  return financials.annualStatements
     .filter((row) => typeof row.freeCashFlow === "number" && Number.isFinite(row.freeCashFlow))
     .sort((a, b) => a.date.localeCompare(b.date))
     .slice(-6);
+}
+
+/** The two years a past growth spans, as issuers name them: `FY2021–FY2025`; period end dates where a year is off the fiscal calendar. */
+function fiscalSpan(financials: TickerFinancials, from: string, to: string): string {
+  const month = fiscalYearEndMonth(financials.annualStatements);
+  const [start, end] = [from, to].map((date) => fiscalPeriodLabel(date, "annual", month)) as [string, string];
+  return start.startsWith("FY") && end.startsWith("FY") ? `${start}–${end}` : `${from.slice(0, 10)} to ${to.slice(0, 10)}`;
+}
+
+function pastFcfGrowth(financials: TickerFinancials): ReverseDcfModel["pastGrowth"] {
+  const annual = annualFreeCashFlows(financials);
   const first = annual[0], last = annual.at(-1);
   if (!first || !last || first === last || !(first.freeCashFlow! > 0) || !(last.freeCashFlow! > 0)) return null;
   const years = Math.round((Date.parse(last.date) - Date.parse(first.date)) / (365.25 * 86_400_000));
-  return years > 0 ? { rate: (last.freeCashFlow! / first.freeCashFlow!) ** (1 / years) - 1, years } : null;
+  return years > 0
+    ? { rate: (last.freeCashFlow! / first.freeCashFlow!) ** (1 / years) - 1, years, period: fiscalSpan(financials, first.date, last.date) }
+    : null;
+}
+
+function latestFiscalYearFcf(financials: TickerFinancials): ReverseDcfModel["fiscalYearFcf"] {
+  const last = annualFreeCashFlows(financials).at(-1);
+  return last ? { value: last.freeCashFlow!, label: fiscalPeriodLabel(last.date, "annual", fiscalYearEndMonth(financials.annualStatements)) } : null;
+}
+
+/** How far above the latest fiscal year's free cash flow the trailing twelve months' must be to say the two bases differ. */
+const TTM_BASE_RATIO = 1.5;
+
+/**
+ * How a trailing free cash flow more than 1.5 times the latest fiscal year's
+ * differs from it (`2.7x` FY2025's `5.3B USD`): the growth priced in starts
+ * from the trailing figure, the past growth ends at the year's. Null when they
+ * are near each other, the year's is not positive, or the model has no growth
+ * to say.
+ */
+export function ttmBaseGap(model: Pick<ReverseDcfModel, "freeCashFlow" | "fiscalYearFcf" | "currency" | "error">): { multiple: string; year: string; fcf: string } | null {
+  const { freeCashFlow, fiscalYearFcf } = model;
+  if (model.error || freeCashFlow == null || !fiscalYearFcf || !(fiscalYearFcf.value > 0) || !(freeCashFlow > fiscalYearFcf.value * TTM_BASE_RATIO)) return null;
+  return {
+    multiple: `${(freeCashFlow / fiscalYearFcf.value).toFixed(1)}x`,
+    year: fiscalYearFcf.label,
+    fcf: formatCompactCurrency(fiscalYearFcf.value, model.currency ?? undefined),
+  };
+}
+
+/** "The TTM base differs from FY2025: TTM FCF is 2.7x that year's 5.3B USD.", the one line a report adds when `ttmBaseGap` finds a gap. */
+export function ttmBaseNote(model: Parameters<typeof ttmBaseGap>[0]): string | null {
+  const gap = ttmBaseGap(model);
+  return gap ? `The TTM base differs from ${gap.year}: TTM FCF is ${gap.multiple} that year's ${gap.fcf}.` : null;
+}
+
+/** What the past growth rate is over, after the rate: `a year, FY2021–FY2025`. */
+export function pastGrowthBasis(growth: NonNullable<ReverseDcfModel["pastGrowth"]>): string {
+  return `a year, ${growth.period}`;
 }
 
 /**
@@ -145,7 +199,8 @@ export function projectReverseDcf(
   const empty: ReverseDcfModel = { symbol: options.symbol, currency, discountRate: options.discountRate, terminalGrowth: TERMINAL_GROWTH,
     enterpriseValue, computedEnterpriseValue: check?.computed ?? null, enterpriseValueNote: check ? enterpriseValueReconciliationNote(fundamentals) ?? null : null,
     freeCashFlow, fcfYield: null, implied: null, fcfMargin, fcfMarginBasis, impliedRevenue: null,
-    pastGrowth: financials ? pastFcfGrowth(financials) : null, sensitivity: [], error: null };
+    pastGrowth: financials ? pastFcfGrowth(financials) : null, fiscalYearFcf: financials ? latestFiscalYearFcf(financials) : null,
+    sensitivity: [], error: null };
   const valueCurrency = fundamentals?.marketCapCurrency;
   // ADRs and cross-listings can report cash flows in one currency and trade in another.
   if (currency && valueCurrency && currency !== valueCurrency) {

package/src/plugins/builtin/reverse-dcf/pane.tsx

@@ -10,8 +10,8 @@ import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
 import { formatCompact, formatCompactCurrency } from "../../../utils/format";
 import { loadReverseDcfInputs } from "./client";
-import { describeFcfMargin, DISCOUNT_RATES, FORECAST_YEARS, formatFcfMargin, projectReverseDcf, TERMINAL_GROWTH, TERMINAL_GROWTHS,
-  type ImpliedGrowth, type ReverseDcfModel } from "./model";
+import { describeFcfMargin, DISCOUNT_RATES, FORECAST_YEARS, formatFcfMargin, pastGrowthBasis, projectReverseDcf, TERMINAL_GROWTH, TERMINAL_GROWTHS,
+  ttmBaseGap, type ImpliedGrowth, type ReverseDcfModel } from "./model";
 
 export const DISCOUNT_OPTIONS = DISCOUNT_RATES.map((rate) => ({ value: String(Math.round(rate * 100)), label: `${Math.round(rate * 100)}%` }));
 /** The margin setting that follows the company's own trailing margin, the pane's default. */
@@ -91,15 +91,18 @@ export function ReverseDcfPane({ width, height, focused }: PaneProps) {
     const currency = model.currency ?? undefined;
     const implied = model.implied?.kind === "rate" ? model.implied.value : null;
     const past = model.pastGrowth;
+    const gap = ttmBaseGap(model);
     return [
       { id: "implied", label: "Priced-in growth", value: impliedText(model.implied),
         tone: implied == null || !past ? undefined : implied > past.rate ? "negative" : "positive",
         detail: `a year for ${FORECAST_YEARS}y, then ${pct(TERMINAL_GROWTH, false)}` },
       { id: "revenue", label: `Revenue, yr ${FORECAST_YEARS}`, value: formatCompactCurrency(model.impliedRevenue ?? undefined, currency),
         detail: `at ${describeFcfMargin(model.fcfMargin, model.fcfMarginBasis)}` },
-      { id: "past", label: "Past FCF growth", value: past ? pct(past.rate) : "--", detail: past ? `per year over ${past.years}y` : undefined },
+      { id: "past", label: "Past FCF growth", value: past ? pct(past.rate) : "--", detail: past ? pastGrowthBasis(past) : undefined },
       { id: "yield", label: "FCF yield", value: pct(model.fcfYield, false) },
-      { id: "fcf", label: "FCF", value: formatCompactCurrency(model.freeCashFlow ?? undefined, currency) },
+      // A trailing figure far above the fiscal year the past growth ends at says so beside itself.
+      { id: "fcf", label: "FCF", value: formatCompactCurrency(model.freeCashFlow ?? undefined, currency),
+        detail: gap ? `TTM base, ${gap.multiple} ${gap.year}'s ${gap.fcf}` : undefined },
       { id: "ev", label: "EV", value: formatCompactCurrency(model.enterpriseValue ?? undefined, currency),
         // More than 5% from market cap + debt - cash: the provider's, with the computed figure where it fits.
         detail: model.computedEnterpriseValue != null ? `provider vs ${formatCompact(model.computedEnterpriseValue)}` : undefined },

package/src/plugins/builtin/risk-factors/data.ts

@@ -5,6 +5,7 @@ import {
 } from "../../../api-client";
 import { ApiRequestError, isPermanentClientError } from "../../../api-client/errors";
 import { listingAbroad, type IssuerListingParams } from "../../../api-client/paths";
+import { servedFromSavedCopy } from "../../../data/saved-copies";
 import type { HeadlessPaneApiClient, PluginPersistence } from "../../../types/plugin";
 import { secListingKey } from "../../../utils/sec";
 
@@ -78,13 +79,14 @@ function loadCached<T extends object>(
     }
     const fallback = store?.getResource<T>(kind, key, { ...options, allowExpired: true });
     if (!fallback) throw error;
-    return {
+    // A command that shows it ends with when the copy was saved, not with the failure.
+    return servedFromSavedCopy({
       ...fallback.value,
       fetchedAt: fallback.fetchedAt,
       stale: true,
       refreshError: (error instanceof Error ? error.message : String(error)).trim() || "Request failed",
       errorStatus: error instanceof ApiRequestError ? error.status : undefined,
-    };
+    }, fallback.fetchedAt);
   }).finally(() => { if (active.get(key) === request) active.delete(key); });
   active.set(key, request);
   return request.promise;

package/src/plugins/builtin/risk-factors/headless.ts

@@ -1,4 +1,5 @@
 import type { HeadlessBundleSection, HeadlessPaneDefinition } from "../../../types/plugin";
+import { savedCopyMark, unansweredRefreshError } from "../../../data/saved-copies";
 import { loadRiskReportWithClient, loadRiskReportsWithClient, type RiskReportsResult } from "./data";
 import { SEC_FILINGS } from "../shared/report-freshness";
 import { resolveHeadlessIssuerListing } from "../shared/headless-market-data";
@@ -39,7 +40,8 @@ export const riskFactorsHeadless: HeadlessPaneDefinition<"bundle"> = {
     }
     const report = await loadRiskReportWithClient(context.apiClient, ticker, year, { force, listing });
     const sections: HeadlessBundleSection[] = [
-      { title: "Filing", entries: [
+      // A report served from a saved copy dates the report by when it was saved (the list does in the metadata).
+      { title: "Filing", ...savedCopyMark(report), entries: [
         { label: "Ticker", value: report.ticker },
         { label: "Filing year", value: report.reportYear },
         { label: "Filed", value: report.filedAt },
@@ -62,12 +64,13 @@ export const riskFactorsHeadless: HeadlessPaneDefinition<"bundle"> = {
       { key: "group", header: "Group" }, { key: "heading", header: "Heading" },
       { key: "excerpt", header: "Prior source excerpt" }, { key: "note", header: "Analysis" },
     ], rows: report.diff.removed.map((risk, index) => ({ ...risk, note: report.notes.removed.find((note) => note.index === index)?.text ?? null })) });
-    const errors = [list?.refreshError, report.refreshError].filter((error): error is string => !!error);
+    const errors = [unansweredRefreshError(list), unansweredRefreshError(report)].filter((error): error is string => !!error);
     return {
       sections,
       errors: errors.length ? errors : undefined,
       ...(list?.stale || report.stale ? { complete: false } : {}),
       metadata: {
+        ...savedCopyMark(list),
         ticker: report.ticker, requestedYear: selection, reportYear: report.reportYear,
         filedAt: report.filedAt, updatedAt: report.updatedAt, docUrl: report.docUrl,
         reportFetchedAt: report.fetchedAt, reportStale: report.stale,

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

@@ -0,0 +1,28 @@
+import type { PluginModule } from "../plugin-module";
+import { RoadmapPane } from "./pane";
+
+export const roadmapModule: PluginModule = {
+  panes: [
+    {
+      id: "roadmap",
+      name: "Roadmap",
+      icon: "R",
+      component: RoadmapPane,
+      reportFreshness: { status: "not-a-feed", basis: "curated list" },
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: { width: 100, height: 30 },
+    },
+  ],
+
+  paneTemplates: [
+    {
+      id: "roadmap-pane",
+      paneId: "roadmap",
+      label: "Roadmap",
+      description: "What is being built, what is planned and what shipped. Pro members vote on what comes next.",
+      keywords: ["roadmap", "planned", "building", "shipped", "upcoming", "features", "vote", "votes", "request"],
+      shortcut: { prefix: "ROADMAP", aliases: ["RMAP"] },
+    },
+  ],
+};

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

@@ -0,0 +1,67 @@
+import type { RoadmapItem, RoadmapPayload, RoadmapStatus, RoadmapVote } from "../../../api-client/roadmap";
+import type { TableSection } from "../../../components";
+
+export const ROADMAP_STATUS_LABELS: Record<RoadmapStatus, string> = {
+  building: "Building",
+  planned: "Planned",
+  shipped: "Shipped",
+};
+
+const SECTION_ORDER: readonly RoadmapStatus[] = ["building", "planned", "shipped"];
+
+/** Building, then Planned, then Shipped, each in the order the service sent; an empty group is left out. */
+export function roadmapSections(items: readonly RoadmapItem[]): TableSection<RoadmapItem>[] {
+  return SECTION_ORDER.map((status) => ({
+    label: ROADMAP_STATUS_LABELS[status],
+    key: status,
+    items: items.filter((item) => item.status === status),
+  }));
+}
+
+/** Votes are taken on what is not shipped yet; a shipped item's count is final. */
+export function isVotable(item: RoadmapItem): boolean {
+  return item.status !== "shipped";
+}
+
+/**
+ * The items with this session's own votes on top: the count and mark a vote
+ * changed, held until the next read of the list replaces them.
+ */
+export function withLocalVotes(
+  payload: RoadmapPayload | null,
+  local: Readonly<Record<string, RoadmapVote>>,
+): RoadmapItem[] {
+  if (!payload) return [];
+  return payload.items.map((item) => {
+    const vote = local[item.id];
+    return vote ? { ...item, votes: vote.votes, voted: vote.voted } : item;
+  });
+}
+
+/** What the row shows while a vote is on its way: the mark flipped and the count moved by one. */
+export function optimisticVote(item: RoadmapItem, voted: boolean): RoadmapVote {
+  const step = voted === item.voted ? 0 : voted ? 1 : -1;
+  return { id: item.id, votes: Math.max(0, item.votes + step), voted };
+}
+
+/** The votes cell: the count, with a check before it when this account voted. */
+export function votesText(item: RoadmapItem): string {
+  return item.voted ? `✓ ${item.votes}` : String(item.votes);
+}
+
+/** What one vote that failed is called on its row, and the reason the detail gives. */
+export interface VoteFailure {
+  status: string;
+  reason: string;
+}
+
+export function voteFailure(error: unknown, voted: boolean): VoteFailure {
+  const status = typeof error === "object" && error && "status" in error ? (error as { status?: unknown }).status : undefined;
+  const action = voted ? "The vote" : "Taking the vote back";
+  if (status === 401) return { status: "sign in", reason: `${action} did not go through: sign in again to vote.` };
+  if (status === 402 || status === 403) return { status: "Pro only", reason: `${action} did not go through: voting is for verified Pro members.` };
+  if (status === 404) return { status: "removed", reason: "This item is no longer on the roadmap." };
+  if (status === 409) return { status: "closed", reason: "This item shipped, so its votes are final." };
+  const message = error instanceof Error && error.message.trim() ? error.message.trim() : "the request failed";
+  return { status: "failed", reason: `${action} did not go through: ${message.replace(/\.$/, "")}.` };
+}

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

@@ -0,0 +1,244 @@
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, type RefObject } from "react";
+import { apiClient } from "../../../api-client";
+import { usePlanAccess } from "../../../api-client/plan-access";
+import type { RoadmapItem, RoadmapVote } from "../../../api-client/roadmap";
+import {
+  buildSectionedRows,
+  DataTableStackView,
+  EMPTY_TABLE_CELL,
+  isSectionedItemRow,
+  renderSectionedRowHeader,
+  usePaneStatusFooter,
+  useRowNotes,
+  type DataTableCell,
+  type DataTableColumn,
+  type PaneFooterSegment,
+  type PaneHint,
+  type SectionedRow,
+} from "../../../components";
+import { usePaneRefreshKey } from "../../../components/data-table/table-pane";
+import { DetailReader, type DetailFact } from "../../../components/reader/detail-reader";
+import { useAsyncResource, usePluginPaneState } from "../../../public/react";
+import { useThemeColors } from "../../../theme/theme-context";
+import type { PaneProps } from "../../../types/plugin";
+import { Box, TextAttributes, type ScrollBoxRenderable } from "../../../ui";
+import { formatShortDate } from "../../../utils/datetime-format";
+import {
+  isVotable,
+  optimisticVote,
+  ROADMAP_STATUS_LABELS,
+  roadmapSections,
+  voteFailure,
+  votesText,
+  withLocalVotes,
+  type VoteFailure,
+} from "./model";
+
+/** The roadmap calls the pane makes; tests hand it their own. */
+export type RoadmapClient = Pick<typeof apiClient, "getRoadmap" | "setRoadmapVote">;
+export const RoadmapClientContext = createContext<RoadmapClient | null>(null);
+
+type Row = SectionedRow<RoadmapItem>;
+type ColumnId = "title" | "blurb" | "votes" | "shipped";
+type Column = DataTableColumn & { id: ColumnId };
+
+const rowKey = (row: Row) => row.key;
+const itemKey = (item: RoadmapItem) => item.id;
+const voteSignature = (item: RoadmapItem) => `${item.votes}:${item.voted}`;
+
+/** Said once, quietly, to everyone who cannot vote: no upgrade pitch. */
+const PRO_VOTES_SEGMENT: PaneFooterSegment = { id: "pro-votes", parts: [{ text: "Pro members vote", tone: "muted" }] };
+const NO_SEGMENTS: PaneFooterSegment[] = [];
+
+function shippedDate(item: RoadmapItem): string {
+  return item.shippedAt ? formatShortDate(item.shippedAt, { fallback: "" }) : "";
+}
+
+/** `votesCell` is what the votes cell says: the count, or a vote's failure on that row. */
+function buildColumns(items: readonly RoadmapItem[], width: number, votesCell: (item: RoadmapItem) => string): Column[] {
+  const longest = Math.max(8, ...items.map((item) => item.title.length));
+  const narrow = width < 64;
+  const columns: Column[] = narrow
+    ? [{ id: "title", label: "Feature", width: Math.min(longest, 24), flexGrow: 1, align: "left" }]
+    : [
+      { id: "title", label: "Feature", width: Math.min(longest, width >= 120 ? 36 : 26), align: "left" },
+      { id: "blurb", label: "Summary", width: 16, flexGrow: 1, align: "left" },
+    ];
+  columns.push({ id: "votes", label: "Votes", width: Math.max(5, ...items.map((item) => votesCell(item).length)), align: "right" });
+  if (!narrow && items.some((item) => item.shippedAt)) {
+    columns.push({ id: "shipped", label: "Shipped", width: 12, align: "left" });
+  }
+  return columns;
+}
+
+function RoadmapDetail({ item, failure, width, scrollRef }: {
+  item: RoadmapItem;
+  failure: VoteFailure | null;
+  width: number;
+  scrollRef: RefObject<ScrollBoxRenderable | null>;
+}) {
+  const colors = useThemeColors();
+  // The stack title names the item; the facts and the blurb follow.
+  const facts: DetailFact[] = [
+    { label: "Status", value: ROADMAP_STATUS_LABELS[item.status] },
+    { label: "Votes", value: item.voted ? `${item.votes}, yours included` : String(item.votes) },
+    ...(item.shippedAt ? [{ label: "Shipped", value: shippedDate(item) }] : []),
+    ...(failure ? [{ label: "Vote", value: failure.reason, color: colors.negative }] : []),
+  ];
+  return (
+    <DetailReader
+      ref={scrollRef}
+      resetScrollKey={item.id}
+      width={width}
+      facts={facts}
+      body={item.blurb || null}
+      bodyFormat="text"
+    />
+  );
+}
+
+export function RoadmapPane({ focused, width, height }: PaneProps) {
+  const colors = useThemeColors();
+  const client = useContext(RoadmapClientContext) ?? apiClient;
+  const access = usePlanAccess();
+  // A sign-in, a sign-out or a new plan asks again: the votes and the right to
+  // cast one are the account's. The new loader starts from no list, so the
+  // last account's marks and vote hint go at once, not when (or if) the new
+  // read lands. A refresh of the same session keeps its list.
+  const sessionKey = JSON.stringify([apiClient.getCurrentUser()?.id ?? null, access.emailVerified, access.hasProAccess]);
+  const loader = useCallback((_force: boolean) => client.getRoadmap(), [client, sessionKey]);
+  const resource = useAsyncResource(loader);
+  const sessionRef = useRef(sessionKey);
+  sessionRef.current = sessionKey;
+  const payload = resource.data;
+  const canVote = payload?.canVote === true;
+
+  // This session's votes, over the list until the next read replaces it.
+  const [localVotes, setLocalVotes] = useState<Record<string, RoadmapVote>>({});
+  useEffect(() => setLocalVotes({}), [resource.updatedAt]);
+  const items = useMemo(() => withLocalVotes(payload, localVotes), [payload, localVotes]);
+  const rows = useMemo(() => buildSectionedRows(roadmapSections(items), itemKey), [items]);
+  const { noteFor, setNote, clearNotes } = useRowNotes<RoadmapItem, VoteFailure>(items, { key: itemKey, signature: voteSignature });
+  // Another account's votes and refusals are not this one's.
+  useEffect(() => {
+    setLocalVotes({});
+    clearNotes();
+  }, [sessionKey, clearNotes]);
+
+  const [selectedId, setSelectedId] = usePluginPaneState<string | null>("selectedItemId", null);
+  const [openId, setOpenId] = usePluginPaneState<string | null>("openItemId", null);
+  const selected = items.find((item) => item.id === selectedId) ?? rows.find(isSectionedItemRow)?.item ?? null;
+  const open = openId ? items.find((item) => item.id === openId) ?? null : null;
+  useEffect(() => {
+    // An item that left the roadmap closes once the list that dropped it is in.
+    if (openId && payload && !open) setOpenId(null);
+  }, [open, openId, payload]);
+  const detailScrollRef = useRef<ScrollBoxRenderable>(null);
+
+  const inFlight = useRef(new Set<string>());
+  const reload = resource.reload;
+  const toggleVote = useCallback(async (item: RoadmapItem) => {
+    if (!canVote || !isVotable(item) || inFlight.current.has(item.id)) return;
+    const voted = !item.voted;
+    const session = sessionRef.current;
+    inFlight.current.add(item.id);
+    setNote(item.id, null);
+    setLocalVotes((current) => ({ ...current, [item.id]: optimisticVote(item, voted) }));
+    try {
+      const answer = await client.setRoadmapVote(item.id, voted);
+      // An answer for the account that just left changes nothing on screen.
+      if (sessionRef.current !== session) return;
+      setLocalVotes((current) => ({ ...current, [item.id]: answer }));
+    } catch (error) {
+      if (sessionRef.current !== session) return;
+      setLocalVotes((current) => ({ ...current, [item.id]: { id: item.id, votes: item.votes, voted: item.voted } }));
+      setNote(item.id, voteFailure(error, voted));
+    } finally {
+      inFlight.current.delete(item.id);
+    }
+  }, [canVote, client, setNote]);
+
+  usePaneRefreshKey(() => void reload(), { focused });
+
+  const target = open ?? selected;
+  const hints = useMemo<PaneHint[]>(() => (
+    canVote && target && isVotable(target)
+      ? [{ id: "vote", key: "v", label: target.voted ? " unvote" : "ote", title: target.voted ? "Take vote back" : "Vote", onPress: () => void toggleVote(target) }]
+      : []
+  ), [canVote, target, toggleVote]);
+  usePaneStatusFooter({
+    registrationId: "roadmap",
+    // A failed refresh keeps the list; the failure goes in the footer.
+    loading: resource.loading && !!payload,
+    error: payload ? resource.error : null,
+    info: !canVote && items.length > 0 ? [PRO_VOTES_SEGMENT] : NO_SEGMENTS,
+    hints,
+  });
+
+  const columns = useMemo(
+    () => buildColumns(items, width, (item) => noteFor(item)?.status ?? votesText(item)),
+    [items, noteFor, width],
+  );
+  const renderCell = useCallback((row: Row, column: Column): DataTableCell => {
+    if (!isSectionedItemRow(row)) return EMPTY_TABLE_CELL;
+    const item = row.item;
+    switch (column.id) {
+      case "title":
+        return { text: item.title, color: colors.textBright };
+      case "blurb":
+        return { text: item.blurb, color: colors.textDim };
+      case "votes": {
+        const failure = noteFor(item);
+        if (failure) return { text: failure.status, color: colors.negative };
+        return {
+          text: votesText(item),
+          value: item.votes,
+          color: item.voted ? colors.positive : isVotable(item) ? colors.text : colors.textDim,
+          ...(item.voted ? { attributes: TextAttributes.BOLD } : {}),
+        };
+      }
+      case "shipped":
+        return { text: shippedDate(item), color: colors.textDim };
+    }
+  }, [colors, noteFor]);
+
+  return (
+    <DataTableStackView<Row, Column>
+      focused={focused}
+      detailOpen={!!open}
+      onBack={() => setOpenId(null)}
+      detailTitle={open?.title}
+      detailContent={open ? (
+        <RoadmapDetail item={open} failure={noteFor(open)} width={width} scrollRef={detailScrollRef} />
+      ) : <Box flexGrow={1} />}
+      detailScrollRef={detailScrollRef}
+      rootWidth={width}
+      rootHeight={height}
+      // A refresh keeps the list on screen; only a first read waits or fails in the body.
+      status={payload ? undefined : {
+        loading: resource.loading,
+        error: resource.error,
+        subject: "Roadmap",
+        retry: { onRetry: reload, pending: resource.loading },
+      }}
+      emptyStateTitle="Nothing on the roadmap yet."
+      columns={columns}
+      items={rows}
+      getItemKey={rowKey}
+      isNavigable={isSectionedItemRow}
+      renderSectionHeader={renderSectionedRowHeader}
+      selection={{
+        kind: "id",
+        selectedId: selected?.id ?? null,
+        getId: rowKey,
+        onChange: (id) => setSelectedId(String(id)),
+      }}
+      onActivate={(row) => { if (isSectionedItemRow(row)) setOpenId(row.item.id); }}
+      sortColumnId={null}
+      sortDirection="asc"
+      renderCell={renderCell}
+      selectedTextOverridesCellColor
+      showHorizontalScrollbar={false}
+    />
+  );
+}

package/src/plugins/builtin/scanner/flow-model.ts

@@ -81,6 +81,22 @@ function printRoot(underlying: string): string {
   return underlying.toUpperCase().replace(/\d+$/, "");
 }
 
+/**
+ * Whose prints the pane shows: one name (`FLOW NVDA`), which takes the place
+ * of the universe filter, or the market, narrowed to the user's own tickers
+ * when the universe filter says so.
+ */
+export interface FlowScope {
+  symbol?: string | null;
+  watchlist: ReadonlySet<string>;
+}
+
+/** The listed symbol a `FLOW <ticker>` pane is about, as the pane setting or report argument names it. */
+export function flowScopeSymbol(value: unknown): string | null {
+  const symbol = typeof value === "string" ? value.trim().toUpperCase() : "";
+  return symbol || null;
+}
+
 /**
  * The shared feed is published once for everyone, so every user preference is a
  * local predicate over the same events. Never push these upstream.
@@ -88,13 +104,14 @@ function printRoot(underlying: string): string {
 export function filterFlowEvents(
   events: readonly ScannerFlowEvent[] | undefined,
   filters: FlowFilters,
-  watchlist: ReadonlySet<string>,
+  scope: FlowScope,
   now = Date.now(),
 ): ScannerFlowEvent[] {
   const minPremium = Number(filters.minPremium);
   const minVolOi = filters.volOi === "off" ? null : Number(filters.volOi);
   const maxExpiryDays = filters.expiry === "all" ? null : Number(filters.expiry);
-  const roots = filters.universe === "watchlist" ? new Set([...watchlist].map(flowOptionRoot)) : null;
+  const roots = scope.symbol ? new Set([flowOptionRoot(scope.symbol)])
+    : filters.universe === "watchlist" ? new Set([...scope.watchlist].map(flowOptionRoot)) : null;
 
   return (events ?? []).filter((event) => {
     if (!(event.premium >= minPremium)) return false;
@@ -121,7 +138,15 @@ export function flowEmptyState(
   received: number,
   visible: number,
   status: ScannerStatus | undefined,
+  symbol: string | null = null,
 ): { title: string; hint: string } {
+  // One name's prints are mostly recorded ones, and a quiet name has none at all.
+  if (symbol) {
+    return {
+      title: `No ${symbol} prints under these filters.`,
+      hint: "Flow is recorded for the most active names, the day's movers and names with a flow alert.",
+    };
+  }
   if (received > visible) {
     return {
       title: `${received - visible} ${received - visible === 1 ? "print" : "prints"} hidden by filters.`,
@@ -219,22 +244,43 @@ export function mergeFlowRows(
 /** The pane's filters as a query for recorded prints, so each page is rows it will show. */
 export function flowHistoryQuery(
   filters: FlowFilters,
-  watchlist: ReadonlySet<string>,
+  scope: FlowScope,
   before?: { at: number; id: string },
   limit = FLOW_HISTORY_PAGE,
 ): ScannerFlowHistoryQuery {
   return {
     ...(before ? { before } : {}),
     limit,
+    ...flowFilterQuery(filters),
+    ...(scope.symbol ? { symbols: [scope.symbol.toUpperCase()] }
+      : filters.universe === "watchlist" ? { symbols: [...scope.watchlist].map((symbol) => symbol.toUpperCase()).sort() } : {}),
+  };
+}
+
+function flowFilterQuery(filters: FlowFilters): Omit<ScannerFlowHistoryQuery, "before" | "limit" | "symbols"> {
+  return {
     minPremium: Number(filters.minPremium),
     ...(filters.side === "calls" ? { right: "C" as const } : filters.side === "puts" ? { right: "P" as const } : {}),
     ...(filters.kind === "sweeps" ? { kind: "sweep" as const } : filters.kind === "blocks" ? { kind: "block" as const } : {}),
     ...(filters.volOi === "off" ? {} : { minVolOi: Number(filters.volOi) }),
     ...(filters.expiry === "all" ? {} : { maxExpiryDays: Number(filters.expiry) }),
-    ...(filters.universe === "watchlist" ? { symbols: [...watchlist].map((symbol) => symbol.toUpperCase()).sort() } : {}),
   };
 }
 
+/**
+ * The session summary's query as the Cloud route reads it: the same filters as
+ * the recorded prints, with one name as `symbol`, which also asks for its strikes.
+ */
+export function flowSessionSearch(filters: FlowFilters, scope: FlowScope): string {
+  const params = new URLSearchParams(flowHistorySearch({
+    ...flowFilterQuery(filters),
+    ...(!scope.symbol && filters.universe === "watchlist"
+      ? { symbols: [...scope.watchlist].map((symbol) => symbol.toUpperCase()).sort() } : {}),
+  }));
+  if (scope.symbol) params.set("symbol", scope.symbol.toUpperCase());
+  return params.toString();
+}
+
 function localDay(at: number): string {
   const date = new Date(at);
   return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;