@gloom-sh/terminal 0.19.0 → 0.19.1

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

@@ -0,0 +1,160 @@
+import { apiClient } from "../../../api-client";
+import type { IpoDeal } from "../../../api-client/ipo";
+import type { HeadlessPaneApiClient } from "../../../types/plugin";
+import { canonicalExchange } from "../../../utils/exchanges";
+import { fetchIpoCalendar } from "./client";
+import {
+  formatIpoAmount,
+  formatIpoPrice,
+  formatIpoReturn,
+  ipoLockupBasis,
+  ipoLockupText,
+  ipoReturnSince,
+  ipoTickerKey,
+  isLockupStory,
+} from "./model";
+
+/** How far back a listing's IPO is looked for: the calendar keeps a year, and a lock-up runs about half of one. */
+const IPO_LOOKBACK_DAYS = 400;
+const LOCKUP_NEWS_LIMIT = 3;
+
+/** A lock-up story filed under a listing: its headline, publisher and day. */
+export interface IpoLockupStory {
+  title: string;
+  source: string;
+  publishedAt: string;
+  url: string;
+}
+
+/** The stories filed under a listing about its lock-up since it listed (an early release, a waiver), newest first. */
+export async function loadIpoLockupNews(
+  client: Pick<HeadlessPaneApiClient, "searchCloudNews">,
+  deal: IpoDeal,
+): Promise<IpoLockupStory[]> {
+  const key = ipoTickerKey(deal);
+  if (!key || !deal.lockup) return [];
+  const response = await client.searchCloudNews("lock-up", 20, undefined, { tickers: [key] });
+  const since = deal.listingDate ?? deal.firstDay?.session ?? "";
+  return response.items
+    .map((item) => ({
+      title: item.headline,
+      source: item.primaryPublisher || item.primarySource,
+      publishedAt: item.lastPublishedAt || item.firstPublishedAt,
+      url: item.primaryUrl,
+    }))
+    .filter((story) => isLockupStory(story.title) && story.publishedAt.slice(0, 10) >= since)
+    .slice(0, LOCKUP_NEWS_LIMIT);
+}
+
+function shiftDays(day: string, days: number): string {
+  return new Date(Date.parse(`${day}T00:00:00Z`) + days * 86_400_000).toISOString().slice(0, 10);
+}
+
+/**
+ * The IPO a listing came to market with in the last year or so, from the
+ * IPO calendar: the deal listed under its symbol on its exchange. Null for a
+ * listing older than that, one the calendar does not have, or one whose
+ * symbol two deals on its exchange share.
+ */
+export async function loadListingIpo(
+  client: Pick<HeadlessPaneApiClient, "getCloudIpoCalendar">,
+  listing: { symbol: string; exchange?: string | null },
+  { signal, now = new Date() }: { signal?: AbortSignal; now?: Date } = {},
+): Promise<IpoDeal | null> {
+  const symbol = listing.symbol.trim().toUpperCase();
+  if (!symbol) return null;
+  const today = now.toISOString().slice(0, 10);
+  const payload = await fetchIpoCalendar(client, signal, { q: symbol, from: shiftDays(today, -IPO_LOOKBACK_DAYS), to: today });
+  const exchange = listing.exchange ? canonicalExchange(listing.exchange) : "";
+  const deals = payload.deals.filter((deal) => (deal.status === "listed" || deal.status === "priced")
+    && deal.symbol?.toUpperCase() === symbol
+    && (!exchange || (deal.exchange != null && canonicalExchange(deal.exchange) === exchange)));
+  return deals.length === 1 ? deals[0]! : null;
+}
+
+/**
+ * A deal's IPO in rows of a report, label and text:
+ * - IPO date  2026-05-07 on NYSE
+ * - Offer     $26 (or "direct listing, no offer price")
+ * - Since IPO +62.7% ($26 to $42.30)
+ * - Lockup    lockup ends ~2026-11-02 (estimate)
+ */
+export function ipoMetricRows(deal: IpoDeal, price: number | null | undefined, now = new Date()): Array<[string, string]> {
+  const day = deal.listingDate ?? deal.firstDay?.session ?? null;
+  const rows: Array<[string, string]> = [];
+  if (day) rows.push(["IPO date", `${day}${deal.venue ? ` on ${deal.venue}` : ""}`]);
+  rows.push(["Offer", formatIpoPrice(deal, { full: true })]);
+  const since = ipoReturnSince(deal, price);
+  if (since) {
+    const from = since.basis === "offer" ? formatIpoAmount(deal, since.from) : `first trade ${formatIpoAmount(deal, since.from)}`;
+    rows.push(["Since IPO", `${formatIpoReturn(since.returnPct)} (${from} to ${formatIpoAmount(deal, price!)})`]);
+  }
+  const lockup = ipoLockupText(deal, now);
+  if (lockup) rows.push(["Lockup", lockup.replace(/^lockup /, "")]);
+  return rows;
+}
+
+/** The lines under those rows: what the lock-up estimate counts from, then the lock-up stories. */
+export function ipoDetailNotes(deal: IpoDeal, news: readonly IpoLockupStory[]): string[] {
+  const basis = ipoLockupBasis(deal);
+  return [
+    ...basis ? [`Lockup estimate: ${basis}; underwriters can release shares early.`] : [],
+    ...news.map((story) => `Lock-up news ${story.publishedAt.slice(0, 10)}: ${story.title} (${story.source})`),
+  ];
+}
+
+/**
+ * A deal's IPO in sentences, for a report's notes:
+ * - "HAWK listed 2026-05-07 on NYSE at a $26 offer price; $42.30 now, +62.7% since the IPO."
+ * - "GYGY listed 2026-07-30 on Nasdaq: direct listing, no offer price; $30.10 now, +33.8% since the first trade at $22.50."
+ * - "HAWK lockup ends ~2026-11-02 (estimate): 180 days from the prospectus dated 2026-05-06; underwriters can release shares early."
+ * - "Lock-up news 2026-08-31: HawkEye 360 Confirms Early Lock-up Release for September 2nd (PR Newswire)"
+ */
+export function ipoDetailSentences(deal: IpoDeal, price: number | null | undefined, news: readonly IpoLockupStory[], now = new Date()): string[] {
+  const name = deal.symbol ?? deal.company;
+  const day = deal.listingDate ?? deal.firstDay?.session ?? null;
+  const listed = deal.status === "listed" ? "listed" : "prices to list";
+  const where = `${day ? ` ${day}` : ""}${deal.venue ? ` on ${deal.venue}` : ""}`;
+  const offer = deal.offerPrice != null ? ` at a ${formatIpoAmount(deal, deal.offerPrice)} offer price`
+    : deal.listingType === "direct" ? `: ${formatIpoPrice(deal, { full: true })}` : "";
+  // The table's Return is the first day's; the sentence says which is which.
+  const firstDay = deal.firstDay?.returnPct != null && deal.offerPrice != null
+    ? `, ${formatIpoReturn(deal.firstDay.returnPct)} on the first day` : "";
+  const since = ipoReturnSince(deal, price);
+  const priceNow = since ? `; ${formatIpoAmount(deal, price!)} now, ${formatIpoReturn(since.returnPct)} since ${
+    since.basis === "offer" ? "the IPO" : `the first trade at ${formatIpoAmount(deal, since.from)}`}` : "";
+  const lockup = ipoLockupText(deal, now);
+  const basis = ipoLockupBasis(deal);
+  return [
+    `${name} ${listed}${where}${offer}${firstDay}${priceNow}.`,
+    ...lockup ? [`${name} ${lockup}${basis ? `: ${basis}` : ""}; underwriters can release shares early.`] : [],
+    ...news.map((story) => `Lock-up news ${story.publishedAt.slice(0, 10)}: ${story.title} (${story.source})`),
+  ];
+}
+
+/** A listing's recent IPO and its lock-up news, as `ticker` reads them beside the rest. */
+export interface TickerIpo {
+  deal: IpoDeal;
+  news: IpoLockupStory[];
+}
+
+/** How long `ticker` waits for the IPO calendar before leaving the section out. */
+const TICKER_IPO_WAIT_MS = 6_000;
+
+/**
+ * A stock's IPO of the last year or so with its lock-up news, for `ticker`;
+ * null for any other listing, and when the calendar does not answer in time.
+ */
+export async function loadTickerIpo(
+  listing: { symbol: string; exchange?: string | null },
+  client: Pick<HeadlessPaneApiClient, "getCloudIpoCalendar" | "searchCloudNews"> = apiClient,
+): Promise<TickerIpo | null> {
+  const signal = AbortSignal.timeout(TICKER_IPO_WAIT_MS);
+  const deal = await loadListingIpo(client, listing, { signal });
+  if (!deal) return null;
+  const news = await loadIpoLockupNews(client, deal).catch(() => {
+    // Intentional ignore: the IPO's rows stand without its lock-up news.
+    return [];
+  });
+  return { deal, news };
+}

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

@@ -161,16 +161,36 @@ const REGION_WORDS: Partial<Record<IpoRegion, readonly string[]>> = {
   apac: ["apac", "asia", "asia-pacific"],
 };
 
+/**
+ * Words that name a kind of deal rather than one: `lockup` (`lock-up`,
+ * `lock up`, `lockups`) lists the deals with a lock-up estimate, `spac` the
+ * SPACs' own IPOs, and `de-spac` (`despac`) those too: a SPAC's merger with
+ * its target is no IPO, so the calendar has none of its own.
+ */
+export type IpoKeyword = "lockup" | "spac" | "de-spac";
+
+export function ipoKeyword(query: string): IpoKeyword | null {
+  const word = query.trim().toLowerCase().replace(/[\s_-]+/g, "");
+  if (/^lockups?$/.test(word)) return "lockup";
+  if (/^spacs?$/.test(word)) return "spac";
+  if (/^despacs?$/.test(word)) return "de-spac";
+  return null;
+}
+
 /**
  * Company in either script, symbol, venue, country code or name, and the
  * status the board shows. The word `pending` is no status of its own: it is
  * every deal not priced yet, offering and overdue ones included.
  * A region's name (`europe`, `asia`) lists the region's deals, on whichever tab is open.
+ * A kind of deal (`lockup`, `spac`, `de-spac`, see ipoKeyword) lists that kind.
  */
 function matchesIpoQuery(deal: IpoDeal, query: string, now: Date): boolean {
   const needle = query.trim().toLowerCase();
   if (!needle) return true;
   if (needle === "pending") return NOT_PRICED_STATUSES.includes(deal.status);
+  const keyword = ipoKeyword(needle);
+  if (keyword === "lockup") return !!deal.lockup;
+  if (keyword) return deal.listingType === "spac";
   if (REGION_WORDS[deal.region]?.includes(needle.replace(/\s+/g, "-"))) return true;
   return [
     deal.company, deal.companyLocal, deal.symbol, deal.venue, deal.mic, deal.exchange,
@@ -343,9 +363,17 @@ function amount(value: number): string {
   return value.toLocaleString("en-US", { minimumFractionDigits: whole ? 0 : 2, maximumFractionDigits: 2 });
 }
 
-/** "$18", "HK$26.20-28.50", "240-260p", "CHF 45": the offer price once set, else the range. */
-export function formatIpoPrice(deal: IpoDeal): string {
+/** What a direct listing with no price reads in a column; a report's row says why in full. */
+const DIRECT_LISTING_PRICE = "direct listing";
+const DIRECT_LISTING_NO_PRICE = "direct listing, no offer price";
+
+/**
+ * "$18", "HK$26.20-28.50", "240-260p", "CHF 45": the offer price once set, else the range.
+ * A direct listing sells no shares at a price: "direct listing" (`full`: "direct listing, no offer price").
+ */
+export function formatIpoPrice(deal: IpoDeal, { full = false }: { full?: boolean } = {}): string {
   const low = deal.offerPrice ?? deal.priceLow ?? deal.priceHigh;
+  if (low == null && deal.listingType === "direct") return full ? DIRECT_LISTING_NO_PRICE : DIRECT_LISTING_PRICE;
   if (low == null) return MISSING;
   const high = deal.offerPrice == null && deal.priceLow != null && deal.priceHigh != null && deal.priceHigh !== deal.priceLow
     ? deal.priceHigh
@@ -387,3 +415,71 @@ export function formatIpoDate(value: string | null, now = new Date()): string {
     ? `${month} ${date.getUTCDate()}`
     : `${month} ${date.getUTCFullYear()}`;
 }
+
+/** "~2026-11-02": when a deal's lock-up is estimated to end; "—" without an estimate. */
+export function formatIpoLockupEnd(endsOn: string | null | undefined): string {
+  return endsOn ? `~${endsOn}` : MISSING;
+}
+
+/** Today in UTC, YYYY-MM-DD. */
+function utcToday(now: Date): string {
+  return now.toISOString().slice(0, 10);
+}
+
+/**
+ * "lockup ends ~2026-11-02 (estimate)", "lockup ended ~2026-07-28 (estimate)":
+ * a deal's lock-up estimate in words; null without one.
+ */
+export function ipoLockupText(deal: Pick<IpoDeal, "lockup">, now = new Date()): string | null {
+  if (!deal.lockup) return null;
+  const verb = deal.lockup.endsOn < utcToday(now) ? "ended" : "ends";
+  return `lockup ${verb} ~${deal.lockup.endsOn} (estimate)`;
+}
+
+/**
+ * What the estimate counts from, as the server made it. The period is the
+ * prospectus's own (`prospectus`) or the typical 180 days; it counts from
+ * the prospectus date when one was read, else from the first session:
+ * - "180 days from the prospectus dated 2026-05-06"
+ * - "90 days from the first session on 2026-05-07, the period the prospectus states"
+ * - "the typical 180 days from the prospectus dated 2026-05-06"
+ * - "the typical 180 days from the first session on 2026-05-07; the prospectus has not been read"
+ */
+export function ipoLockupBasis(deal: Pick<IpoDeal, "lockup" | "listingDate">): string | null {
+  const lockup = deal.lockup;
+  if (!lockup) return null;
+  const stated = lockup.basis === "prospectus";
+  const from = lockup.prospectusDate
+    ? `from the prospectus dated ${lockup.prospectusDate}`
+    : `from the first session${deal.listingDate ? ` on ${deal.listingDate}` : ""}`;
+  if (stated) return `${lockup.days} days ${from}${lockup.prospectusDate ? "" : ", the period the prospectus states"}`;
+  // A prospectus read with no period it states (or none of a lock-up's length) is still read.
+  const read = lockup.prospectusDate != null || lockup.prospectusUrl != null;
+  return `the typical ${lockup.days} days ${from}${read ? "" : "; the prospectus has not been read"}`;
+}
+
+/** A price in the deal's own currency: "$26", "HK$7.20". */
+export function formatIpoAmount(deal: Pick<IpoDeal, "currency">, value: number): string {
+  return formatIpoPrice({ offerPrice: value, priceLow: null, priceHigh: null, currency: deal.currency, listingType: "ipo" } as IpoDeal);
+}
+
+/**
+ * What a listed deal's price has done since it listed: from the offer price,
+ * else (a direct listing) from its first trade. Null without a price now or a
+ * price to measure from.
+ */
+export function ipoReturnSince(deal: IpoDeal, price: number | null | undefined): { from: number; basis: "offer" | "first trade"; returnPct: number } | null {
+  if (price == null || !Number.isFinite(price) || price <= 0) return null;
+  const offer = deal.offerPrice;
+  if (offer != null && offer > 0) return { from: offer, basis: "offer", returnPct: price / offer - 1 };
+  const open = deal.firstDay?.open;
+  if (deal.listingType === "direct" && open != null && open > 0) return { from: open, basis: "first trade", returnPct: price / open - 1 };
+  return null;
+}
+
+/** The lock-up stories worth listing beside a deal: on or after its listing, about its lock-up. */
+const LOCKUP_WORDS = /\block[\s-]?ups?\b/i;
+
+export function isLockupStory(title: string): boolean {
+  return LOCKUP_WORDS.test(title);
+}

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

@@ -1,7 +1,7 @@
 import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { loadMacroDayEarnings, loadMacroDayHistory, loadMacroReleases, macroDayEarningsNotice } from "./client";
-import { macroDayEventLabel, macroDayStats, matchesSurprise, projectMacroDays, type MacroDayStats } from "./model";
+import { formatMacroDayMove, macroDayEventLabel, macroDayStats, matchesSurprise, projectMacroDays, type MacroDayStats } from "./model";
 import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_RELEASE_SOURCES, MACRO_SURPRISE_LABELS, MACRO_SURPRISES, staleMacroReleasesNotice,
   type MacroEventKind, type MacroSurprise } from "./releases";
 
@@ -39,6 +39,12 @@ export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
       releases: releases.releases, coveredThrough: releases.coveredThrough, earnings: earnings.reports });
     const notes = [staleMacroReleasesNotice(releases), macroDayEarningsNotice(earnings)].filter((note): note is string => !!note);
     const row = (label: string, stats: MacroDayStats) => ({ label, ...stats });
+    // A yield index (^TNX) moves by its level: its columns are headed bp and read the change in the yield.
+    const yieldMoves = model.basis === "yield";
+    const bp = (signed: boolean) => (value: unknown) => typeof value === "number" ? formatMacroDayMove(value, "yield", { signed, unit: false }) : "--";
+    const move = yieldMoves ? bp(true) : percent;
+    const absMove = yieldMoves ? bp(false) : percent;
+    const header = (label: string) => yieldMoves ? `${label} bp` : label;
     const release = String(args.options.release ?? "all");
     const surprise = String(args.options.surprise ?? "all") as MacroSurprise | "all";
     const events = model.events.filter((event) => (release === "all" || event.kind === release) && matchesSurprise(event, surprise));
@@ -48,14 +54,14 @@ export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
     return {
       sections: [
         { title: "By release", columns: [{ key: "label", header: "Day" }, { key: "count", header: "Days" },
-          { key: "meanAbs", header: "Avg |move|", format: percent }, { key: "multiple", header: "vs normal", format: multiple },
-          { key: "mean", header: "Avg move", format: percent }, { key: "hitRate", header: "Up", format: share }],
+          { key: "meanAbs", header: header("Avg |move|"), format: absMove }, { key: "multiple", header: "vs normal", format: multiple },
+          { key: "mean", header: header("Avg move"), format: move }, { key: "hitRate", header: "Up", format: share }],
         rows: [...model.kinds.map((kind) => row(MACRO_EVENT_LABELS[kind], model.byKind[kind])), ...selected,
           row(model.kinds.includes("ipca") ? "Any US release" : "Any release", model.allEvents), ...(model.earnings.count ? [row("Earnings", model.earnings)] : []), row("Normal day", model.normal)] },
         { title: "Release days", columns: [{ key: "date", header: "Date" }, { key: "event", header: "Release" },
           { key: "actual", header: "Actual" }, { key: "forecast", header: "Forecast" }, { key: "prior", header: "Prior" },
           { key: "surprise", header: "Surprise" },
-          { key: "session", header: "Session" }, { key: "move", header: "Move", format: percent }, { key: "multiple", header: "vs normal", format: multiple }],
+          { key: "session", header: "Session" }, { key: "move", header: header("Move"), format: move }, { key: "multiple", header: "vs normal", format: multiple }],
         rows: events.map(({ figures, ...event }) => ({ ...event, event: macroDayEventLabel(event), actual: figures?.actual ?? null,
           forecast: figures?.forecast ?? null, prior: figures?.prior ?? null, surprise: figures?.surprise ?? null,
           ...(figures ? { headline: figures.event } : {}) })) },
@@ -64,7 +70,8 @@ export const macroDayHeadless: HeadlessPaneDefinition<"bundle"> = {
       unavailableSymbols: model.events.length ? [] : [instrument.symbol],
       errors: history.error ? [history.error] : [],
       ...(notes.length ? { notes } : {}),
-      metadata: { unit: "decimal return, close to close on the release day", start: model.start, asOf: model.asOf,
+      metadata: { unit: yieldMoves ? "change in the yield in percentage points, close to close on the release day"
+        : "decimal return, close to close on the release day", start: model.start, asOf: model.asOf,
         releasesThrough: releases.coveredThrough, releaseSources: Object.values(MACRO_RELEASE_SOURCES),
         stale: history.stale || earnings.stale, fetchedAt: history.fetchedAt, methodology: "docs/research-data.md#macro-day-reaction" },
     };

package/src/plugins/builtin/macro-day/index.tsx

@@ -16,7 +16,7 @@ export const macroDayModule: PluginModule = {
   paneTemplates: [{ ...createTickerSurfacePaneTemplate({
     id: "macro-day-pane", paneId: "macro-day", label: "Macro-Day Reaction",
     description: "How a name moves on CPI, jobs, FOMC and Brazil IPCA days against a normal day: average move, direction, hit rate, and every release day with its actual, forecast and prior.",
-    keywords: ["mday", "macro day", "cpi day", "fomc day", "jobs day", "nfp", "payrolls", "event study", "release reaction", "ipca",
+    keywords: ["mday", "macro day", "cpi day", "fomc day", "jobs day", "jobs report", "nfp", "payrolls", "nonfarm", "event study", "release reaction", "ipca",
       "hot cpi", "cpi surprise", "release surprise"],
     shortcut: "MDAY", publicShare: true,
   }), headless: macroDayHeadless }],

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

@@ -1,6 +1,8 @@
 import type { EarningsTiming } from "../../../api-client/earnings";
 import type { PricePoint } from "../../../types/financials";
 import { zonedDateTimeParts } from "../../../utils/zoned-date-time";
+import { toBasisPoints } from "../../../utils/basis-points";
+import { isYieldIndexSymbol } from "../../../tickers/index-roots";
 import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, US_MACRO_EVENT_KINDS, type MacroEventKind, type MacroRelease, type MacroReleaseFigures,
   type MacroSurprise } from "./releases";
 
@@ -17,6 +19,35 @@ export interface MacroDayEarningsReport {
   reactionSession?: string | null;
 }
 
+/**
+ * How a day's move is measured: a price's return, or for a yield (^TNX, whose
+ * level is the yield in percent) the change in that yield, in percentage
+ * points, which the pane and the report read in basis points.
+ */
+export type MacroDayMoveBasis = "return" | "yield";
+
+/** A Treasury yield index moves by its level: 5.24 to 5.28 is +4bp, not +0.76%. */
+const macroDayMoveBasis = (symbol: string): MacroDayMoveBasis => isYieldIndexSymbol(symbol) ? "yield" : "return";
+
+/**
+ * A move as it reads: a return in percent (`+0.76%`), a yield's change in
+ * basis points (`+4.0bp`, or `+4.0` under a column headed bp). One that
+ * rounds to zero is unsigned.
+ */
+export function formatMacroDayMove(value: number | null | undefined, basis: MacroDayMoveBasis,
+  { signed = true, unit = true }: { signed?: boolean; unit?: boolean } = {}): string {
+  if (value == null) return "--";
+  if (basis === "yield") {
+    const bp = toBasisPoints(value, 1);
+    return `${signed && bp > 0 ? "+" : ""}${bp.toFixed(1)}${unit ? "bp" : ""}`;
+  }
+  const fixed = (value * 100).toFixed(2);
+  return /[1-9]/.test(fixed) ? `${signed && value > 0 ? "+" : ""}${fixed}%` : "0.00%";
+}
+
+/** The decimals a move shows in hundredths (percent of a return, basis points of a yield), for its sign and colour. */
+export const macroDayMoveDecimals = (basis: MacroDayMoveBasis) => basis === "yield" ? 1 : 2;
+
 export interface MacroDayEvent {
   kind: MacroEventKind;
   /** Release day, New York date. */
@@ -25,7 +56,7 @@ export interface MacroDayEvent {
   session: string;
   /** The session is also the reaction session of the ticker's own earnings report: the move is the report's, not the release's. */
   earnings: boolean;
-  /** Close before the release to the session's close. */
+  /** Close before the release to the session's close: a return, or a yield's change in percentage points (`basis`). */
   move: number;
   /** |move| over the normal day's average |move|. */
   multiple: number | null;
@@ -45,6 +76,7 @@ export interface MacroDayStats {
 
 export interface MacroDayModel {
   symbol: string;
+  basis: MacroDayMoveBasis;
   /** Newest first. */
   events: MacroDayEvent[];
   /** The kinds the list carries: the US releases, and IPCA when Gloom Cloud lists its days. */
@@ -140,17 +172,19 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   earnings?: readonly MacroDayEarningsReport[];
 }): MacroDayModel {
   const { coveredThrough } = options;
+  const basis = macroDayMoveBasis(options.symbol);
   const byDate = new Map<string, number>();
   for (const point of history) {
     const time = new Date(point.date).getTime();
-    if (!Number.isFinite(time) || !Number.isFinite(point.close) || point.close <= 0) continue;
+    // A yield can sit at zero or below it; a price cannot.
+    if (!Number.isFinite(time) || !Number.isFinite(point.close) || (basis === "return" && point.close <= 0)) continue;
     byDate.set(sessionDate(time), point.close);
   }
   const sessions = [...byDate.keys()].sort();
   const last = sessions.at(-1) ?? null;
   const empty = (): MacroDayStats => stats([], null);
   const kinds = MACRO_EVENT_KINDS.filter((kind) => US_KINDS.has(kind) || options.releases.some((release) => release.kind === kind));
-  if (!last) return { symbol: options.symbol, events: [], kinds, byKind: { cpi: empty(), jobs: empty(), fomc: empty(), ipca: empty() },
+  if (!last) return { symbol: options.symbol, basis, events: [], kinds, byKind: { cpi: empty(), jobs: empty(), fomc: empty(), ipca: empty() },
     allEvents: empty(), earnings: empty(), normal: empty(), start: null, asOf: null };
 
   // Sessions after the published lists end may be unlisted release days, so they are left out of both sides.
@@ -166,7 +200,7 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   for (let index = 1; index < sessions.length; index++) {
     const date = sessions[index]!, previous = sessions[index - 1]!;
     if (date <= start || date > end || dayNumber(date) - dayNumber(previous) > MAX_SESSION_GAP_DAYS) continue;
-    moves.set(date, byDate.get(date)! / byDate.get(previous)! - 1);
+    moves.set(date, basis === "yield" ? byDate.get(date)! - byDate.get(previous)! : byDate.get(date)! / byDate.get(previous)! - 1);
   }
 
   const reactionSessions = new Set<string>();
@@ -191,7 +225,7 @@ export function projectMacroDays(history: readonly PricePoint[], options: {
   const byKind = Object.fromEntries(MACRO_EVENT_KINDS.map((kind) =>
     [kind, stats(events.filter((event) => event.kind === kind && !event.earnings).map((event) => event.move), normalAbs)])) as Record<MacroEventKind, MacroDayStats>;
   const sessionMoves = (flagged: boolean) => [...reactionSessions].filter((session) => reacted.has(session) === flagged).map((session) => moves.get(session)!);
-  return { symbol: options.symbol, events, kinds, byKind, allEvents: stats(sessionMoves(false), normalAbs), earnings: stats(sessionMoves(true), normalAbs),
+  return { symbol: options.symbol, basis, events, kinds, byKind, allEvents: stats(sessionMoves(false), normalAbs), earnings: stats(sessionMoves(true), normalAbs),
     normal, start, asOf: end };
 }
 

package/src/plugins/builtin/macro-day/pane.tsx

@@ -13,7 +13,10 @@ import { useThemeColors } from "../../../theme/theme-context";
 import type { PaneProps } from "../../../types/plugin";
 import { Box } from "../../../ui";
 import { loadMacroDayEarnings, loadMacroDayHistory, loadMacroReleases, macroDayEarningsNotice } from "./client";
-import { macroDayEventLabel, macroDayStats, matchesSurprise, projectMacroDays, type MacroDayEvent, type MacroDayModel } from "./model";
+import {
+  formatMacroDayMove, macroDayEventLabel, macroDayMoveDecimals, macroDayStats, matchesSurprise, projectMacroDays, type MacroDayEvent,
+  type MacroDayModel, type MacroDayMoveBasis,
+} from "./model";
 import { MACRO_EVENT_KINDS, MACRO_EVENT_LABELS, MACRO_SURPRISE_LABELS, MACRO_SURPRISES, staleMacroReleasesNotice, type MacroEventKind,
   type MacroSurprise } from "./releases";
 
@@ -21,17 +24,13 @@ export const LOOKBACK_OPTIONS = [{ value: "1", label: "1Y" }, { value: "2", labe
 const RELEASE_OPTIONS = [{ value: "all", label: "All" }, ...MACRO_EVENT_KINDS.map((kind) => ({ value: kind, label: MACRO_EVENT_LABELS[kind] }))];
 const SURPRISE_OPTIONS = [{ value: "all", label: "All" }, ...MACRO_SURPRISES.map((surprise) => ({ value: surprise, label: MACRO_SURPRISE_LABELS[surprise] }))];
 
-function pct(value: number | null | undefined, signed = true): string {
-  if (value == null) return "--";
-  const fixed = (value * 100).toFixed(2);
-  return /[1-9]/.test(fixed) ? `${signed && value > 0 ? "+" : ""}${fixed}%` : "0.00%";
-}
 const times = (value: number | null | undefined) => value == null ? "--" : `${value.toFixed(1)}x`;
 
 const EARNINGS_MARK = "earnings";
 const DATE: DataTableColumn = { id: "date", label: "Date", width: 19, align: "left" };
-const MOVE: DataTableColumn[] = [
-  { id: "move", label: "Move", width: 9, align: "right" },
+/** The move and its multiple of a normal day's; a yield's move is in basis points, and its header says so. */
+const moveColumns = (basis: MacroDayMoveBasis): DataTableColumn[] => [
+  { id: "move", label: basis === "yield" ? "Move bp" : "Move", width: 9, align: "right" },
   { id: "multiple", label: "vs Normal", width: 10, align: "right" },
 ];
 /** What each release came out with, under the labels the economic calendar gives them. */
@@ -48,23 +47,25 @@ function figureColumns(rows: readonly MacroDayEvent[]): DataTableColumn[] {
  * With every release listed, the release's name, widened to take the earnings marker where a row has one. With one
  * selected, a column only for the marker: every row would repeat the name.
  */
-export function columnsFor(release: string, rows: readonly MacroDayEvent[]): DataTableColumn[] {
+export function columnsFor(release: string, rows: readonly MacroDayEvent[], basis: MacroDayMoveBasis = "return"): DataTableColumn[] {
   const marked = rows.some((event) => event.earnings);
-  const values = [...figureColumns(rows), ...MOVE];
+  const values = [...figureColumns(rows), ...moveColumns(basis)];
   if (release === "all") return [DATE, { id: "release", label: "Release", width: marked ? 15 : 8, align: "left" }, ...values];
   return marked ? [DATE, { id: "release", label: "Note", width: EARNINGS_MARK.length, align: "left" }, ...values] : [DATE, ...values];
 }
 
-/** By the sign the two-decimal text shows: an average that rounds to 0.00% is neither up nor down. */
-export const moveTone = (value: number | null) => value == null || !/[1-9]/.test((value * 100).toFixed(2)) ? undefined
-  : value > 0 ? "positive" as const : "negative" as const;
+/** By the sign the text shows: an average that rounds to 0.00% (or 0.0bp) is neither up nor down. */
+export const moveTone = (value: number | null, basis: MacroDayMoveBasis = "return") =>
+  value == null || !/[1-9]/.test((value * 100).toFixed(macroDayMoveDecimals(basis))) ? undefined
+    : value > 0 ? "positive" as const : "negative" as const;
 
 /** The figures over the days a surprise filter keeps: the same four as one release's. */
 function surpriseFigures(model: MacroDayModel, rows: readonly MacroDayEvent[]): StatItem[] {
   const stats = macroDayStats(rows, model.normal.meanAbs);
+  const pct = (value: number | null, signed = true) => formatMacroDayMove(value, model.basis, { signed });
   return [
     { id: "abs", label: "Avg |move|", value: pct(stats.meanAbs, false), detail: stats.count ? `${times(stats.multiple)} normal` : undefined },
-    { id: "mean", label: "Avg move", value: pct(stats.mean), tone: moveTone(stats.mean) },
+    { id: "mean", label: "Avg move", value: pct(stats.mean), tone: moveTone(stats.mean, model.basis) },
     { id: "up", label: "Up", value: stats.hitRate == null ? "--" : `${Math.round(stats.hitRate * 100)}%`,
       detail: stats.count ? `${Math.round(stats.hitRate! * stats.count)} of ${stats.count}` : undefined },
     { id: "normal", label: "Normal day", value: pct(model.normal.meanAbs, false), detail: "avg |move|" },
@@ -72,6 +73,7 @@ function surpriseFigures(model: MacroDayModel, rows: readonly MacroDayEvent[]):
 }
 
 function figures(model: MacroDayModel, release: string): StatItem[] {
+  const pct = (value: number | null, signed = true) => formatMacroDayMove(value, model.basis, { signed });
   const normal: StatItem = { id: "normal", label: "Normal day", value: pct(model.normal.meanAbs, false), detail: "avg |move|" };
   if (release === "all") {
     return [...model.kinds.map((kind): StatItem => {
@@ -84,7 +86,7 @@ function figures(model: MacroDayModel, release: string): StatItem[] {
   const stats = model.byKind[release as MacroEventKind];
   return [
     { id: "abs", label: "Avg |move|", value: pct(stats.meanAbs, false), detail: stats.count ? `${times(stats.multiple)} normal` : undefined },
-    { id: "mean", label: "Avg move", value: pct(stats.mean), tone: moveTone(stats.mean) },
+    { id: "mean", label: "Avg move", value: pct(stats.mean), tone: moveTone(stats.mean, model.basis) },
     { id: "up", label: "Up", value: stats.hitRate == null ? "--" : `${Math.round(stats.hitRate * 100)}%`,
       detail: stats.count ? `${Math.round(stats.hitRate! * stats.count)} of ${stats.count}` : undefined },
     normal,
@@ -123,7 +125,7 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
     && matchesSurprise(event, surprise)) : [], [model, release, surprise]);
   const stats = useMemo(() => !model?.events.length ? [] : surprise === "all" ? figures(model, release) : surpriseFigures(model, rows),
     [model, release, surprise, rows]);
-  const columns = useMemo(() => columnsFor(release, rows), [release, rows]);
+  const columns = useMemo(() => columnsFor(release, rows, model?.basis), [model?.basis, release, rows]);
 
   usePaneNoticeFooter({ registrationId: "macro-day-notices", focused,
     notices: [...new Set([identityError, history.error, history.data?.error, releasesNotice, earningsNotice].filter((value): value is string => !!value))] });
@@ -141,9 +143,14 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
       : event.figures?.surprise === "cool" ? colors.negative : undefined };
     if (column.id === "forecast") return { text: event.figures?.forecast ?? "" };
     if (column.id === "prior") return { text: event.figures?.prior ?? "" };
-    if (column.id === "move") return { text: pct(event.move), value: event.move * 100, color: shownPriceColor(event.move * 100, 2, colors) };
+    if (column.id === "move") {
+      const basis = model?.basis ?? "return";
+      // Under a column headed bp, a yield's move is the number alone.
+      return { text: formatMacroDayMove(event.move, basis, { unit: false }), value: event.move * 100,
+        color: shownPriceColor(event.move * 100, macroDayMoveDecimals(basis), colors) };
+    }
     return { text: times(event.multiple), value: event.multiple };
-  }, [colors, release]);
+  }, [colors, model?.basis, release]);
 
   const contentHeight = Math.max(4, height - 1 - statGridRows(stats, width));
   const key = (event: MacroDayEvent) => `${event.kind}:${event.date}`;
@@ -162,7 +169,8 @@ export function MacroDayPane({ width, height, focused }: PaneProps) {
           getItemKey={key} emptyStateTitle={surprise === "all" ? "No release days." : `No ${MACRO_SURPRISE_LABELS[surprise].toLowerCase()} prints.`} sortColumnId={null} sortDirection="desc" selectedTextOverridesCellColor
           selection={{ kind: "id", selectedId: selectedRow, getId: key, onChange: (id) => setSelectedRow(id) }}
           getExportMetadata={() => [["symbol", model.symbol], ["from", model.start ?? ""], ["to", model.asOf ?? ""],
-            ["units", "percent, close to close on the release day"]]}
+            ["units", model.basis === "yield" ? "percentage points of yield, close to close on the release day"
+              : "percent, close to close on the release day"]]}
           renderCell={renderCell} />
       </> : null}
     </PaneStatusBody>}

package/src/plugins/builtin/market-movers/client.ts

@@ -6,6 +6,7 @@ import type {
 } from "../../../api-client/market-movers";
 import type { DataProvider } from "../../../types/data-provider";
 import { logFailure } from "../../../utils/log-failure";
+import { savedCopyMark } from "../../../data/saved-copies";
 import {
   CATEGORY_MAP,
   moverRegularSession,
@@ -113,6 +114,7 @@ export async function loadMarketMoverTab(
     const trending = await dependencies.fetchTrending(LIST_ROWS, fetchOptions);
     const hydrated = await hydrateTrending(trending.data, provider);
     return {
+      ...savedCopyMark(trending),
       tab,
       ...hydrated,
       source: "gloom",

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

@@ -15,6 +15,7 @@ import { EXTENDED_SESSION_LABELS, type ExtendedSession } from "../../../market-d
 import type { HeadlessPaneColumn } from "../../../types/headless";
 import { isSessionTab, resolveSide } from "./session";
 import { hasPartialFloat, minFloatShares, normalizeMinFloat, PARTIAL_FLOAT_NOTE } from "./min-float";
+import { savedCopyMark } from "../../../data/saved-copies";
 
 const rowPrice = (value: unknown, row: Record<string, unknown>) => formatMoverPrice(typeof value === "number" ? value : null, typeof row.currency === "string" ? row.currency : "", moverReferencePrice(row as unknown as MarketMoverRow));
 
@@ -197,7 +198,8 @@ export function createMarketMoversHeadless(
         rows,
         ...(quoteError ? { complete: false, unavailableSymbols: result.unavailableSymbols, errors: [quoteError] } : {}),
         ...(notes.length > 0 ? { notes } : {}),
-        metadata: { list: tab, source: result.source, stale: result.stale, rankedBy, minFloat: floatFiltered ? minFloat : null },
+        // A list served from a saved copy ends with when it was saved.
+        metadata: { ...savedCopyMark(result), list: tab, source: result.source, stale: result.stale, rankedBy, minFloat: floatFiltered ? minFloat : null },
         // A Pro account's Gainers, Losers and Most Active are the real-time lists.
         ...(result.source === "cloud" ? { freshness: { status: "live" as const } } : {}),
       };