gloomberb 0.19.0 → 0.19.2

package/src/plugins/builtin/help/table-cells.tsx

@@ -31,10 +31,21 @@ export function badgeColumnWidth(
   return Math.max(min, Math.min(max, widest));
 }
 
+/**
+ * The chips of a group that fit a column whole, in order. A chip that would be
+ * cut ("Ctrl+Hor") is left out instead, so what shows is always a real key; the
+ * first chip stays whatever the width.
+ */
+export function wholeBadges(labels: readonly string[], width: number): readonly string[] {
+  let count = Math.min(1, labels.length);
+  while (count < labels.length && badgeGroupWidth(labels.slice(0, count + 1)) <= width) count += 1;
+  return labels.slice(0, count);
+}
+
 export function badgeCell(
   labels: readonly string[],
   width: number,
-  options: { tone?: "neutral" | "accent"; emptyLabel?: string; emptyColor?: string } = {},
+  options: { tone?: "neutral" | "accent"; emptyLabel?: string; emptyColor?: string; wholeOnly?: boolean } = {},
 ): DataTableCell {
   if (labels.length === 0) {
     return options.emptyLabel
@@ -45,7 +56,7 @@ export function badgeCell(
     text: labels.join(" "),
     content: (
       <Box flexDirection="row" gap={BADGE_GAP} width={width} height={1} overflow="hidden">
-        {labels.map((label, index) => (
+        {(options.wholeOnly ? wholeBadges(labels, width) : labels).map((label, index) => (
           <Badge key={`${label}:${index}`} label={label} variant="solid" tone={options.tone ?? "neutral"} />
         ))}
       </Box>

package/src/plugins/builtin/holders/beneficial-client.ts

@@ -11,6 +11,7 @@ import { listingAbroad, type IssuerListingParams } from "../../../api-client/pat
 import { createPluginCache } from "../../../data/plugin-cache";
 import { secListingKey } from "../../../utils/sec";
 import { finiteOrNull, recordOrNull } from "../../../utils/guards";
+import { readCompanyFrom } from "../../../types/company-from";
 import { cachedCloudResource, loadCloudResource, type CloudResource } from "../shared/cloud-resource";
 import { CLOUD_SESSION_REQUIRED } from "../shared/research-cloud-session";
 
@@ -110,8 +111,11 @@ function normalizeBeneficialOwnersPayload(value: unknown, ticker: string): Benef
   if (!raw || !Array.isArray(raw.owners)) throw new Error("The server returned an invalid 13D/13G list");
   const coverage = recordOrNull(raw.coverage);
   const nextOffset = finiteOrNull(raw.nextOffset);
+  const companyFrom = readCompanyFrom(raw.companyFrom);
+  const { companyFrom: _unread, ...rest } = raw;
   return {
-    ...raw,
+    ...rest,
+    ...(companyFrom ? { companyFrom } : {}),
     ticker: text(raw.ticker) ?? ticker,
     cik: cikOrNull(raw.cik) ?? "",
     companyName: text(raw.companyName) ?? "",

package/src/plugins/builtin/holders/beneficial-view.tsx

@@ -9,7 +9,9 @@ import {
   type DataTableCell,
   type DataTableKeyEvent,
 } from "../../../components";
+import { useCompanyDataFooter } from "../../../components/layout/pane/status-footer";
 import { handleRefreshKey, loadingErrorFooterInfo } from "../../../components/data-table/table-pane";
+import { STALE_SEGMENT } from "../../../components/layout/pane/status-footer";
 import type { IssuerListingParams } from "../../../api-client/paths";
 import { useAsyncResource } from "../../../react/async-resource";
 import { useAutoRefresh } from "../../../react/auto-refresh";
@@ -42,8 +44,6 @@ import {
 import type { Holder13FMatch } from "./thirteenf-match";
 import type { HolderRow } from "./types";
 
-const STALE_SEGMENT = { id: "stale", parts: [{ text: "stale", tone: "warning" as const }] };
-
 /**
  * A table line: a filer's row, or the line beneath it giving the same shares
  * against today's count when the report's base is no longer today's.
@@ -233,6 +233,8 @@ export function BeneficialOwnersView({
     focused,
     title: "13D/13G coverage",
   });
+  // A foreign line's owners are its company's, read from the home line.
+  useCompanyDataFooter(payload?.companyFrom);
   usePaneFooter("holders-13dg", () => ({
     info: [
       ...(payload?.asOf ? [{ id: "as-of", parts: [{ text: `as of ${payload.asOf.slice(0, 10)}`, tone: "muted" as const }] }] : []),

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

@@ -7,7 +7,7 @@ import { loadHolderSnapshot } from "./client";
 import { holderValueCurrency } from "./format";
 import { logFailure } from "../../../utils/log-failure";
 import type { HolderData } from "../../../types/financials";
-import { SEC_FILINGS } from "../shared/report-freshness";
+import { SEC_FILING_ROWS, SEC_FILINGS } from "../shared/report-freshness";
 import type { BeneficialOwnersPayload } from "../../../api-client/beneficial-owners";
 import { fetchBeneficialOwners, type BeneficialOwnersRequest } from "./beneficial-client";
 import { resolveHeadlessInstrument, resolveHeadlessIssuerListing } from "../shared/headless-market-data";
@@ -34,6 +34,7 @@ import {
 } from "./report-rows";
 import { REPORT_ROWS } from "../shared/headless-options";
 import { fundHoldersAnswer } from "./fund-holders";
+import { companyDataNotes } from "../../../types/company-from";
 import {
   HOLDER_ROWS_MAX,
   indexedHoldersPartialNote,
@@ -197,7 +198,7 @@ export function createHoldersHeadless(
           rows: limited,
           // Reports that could not be read this time are missing from the rows.
           complete: beneficialListComplete(payload),
-          freshness: { ...SEC_FILINGS, basis: "13D/13G filings", observedKey: "filingDate" },
+          freshness: { ...SEC_FILING_ROWS, basis: "13D/13G filings" },
           metadata: {
             symbol: payload.ticker || symbol,
             name: payload.companyName || null,
@@ -212,6 +213,7 @@ export function createHoldersHeadless(
               [payload.companyName || symbol, ...beneficialListFacts(payload, form, rows.length, history)].join(" · "),
               ...(legend ? [legend] : []),
               ...beneficialCoverageNotices(payload.coverage),
+              ...companyDataNotes(payload.companyFrom),
             ],
             returned: limited.length,
             total: rows.length,

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

@@ -12,6 +12,7 @@ import {
   type DataTableKeyEvent,
   type PageRequest,
 } from "../../../components";
+import { useCompanyDataFooter } from "../../../components/layout/pane/status-footer";
 import { handleRefreshKey, loadingErrorFooterInfo } from "../../../components/data-table/table-pane";
 import { useAsyncResource } from "../../../react/async-resource";
 import { useShortcut } from "../../../react/input";
@@ -321,6 +322,8 @@ export function HoldersView({ focused, width, height }: { focused: boolean; widt
     }
   }, [currency, fundMatches, marketCap]);
 
+  // Holders read from the company's home line say whose; the SEC index's rows are the listing's own.
+  useCompanyDataFooter(indexed ? null : listData?.companyFrom, viewMode !== "13dg");
   // The 13D/G tab registers its own footer.
   usePaneFooter("holders", () => {
     if (viewMode === "13dg") return null;

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

@@ -25,6 +25,7 @@ import {
 import { HOLDER_ROWS_MAX } from "./index-holders";
 import { buildRows, DEFAULT_SORT, sortRows } from "./table-model";
 import type { HolderColumnId, SortPreference } from "./types";
+import { companyDataNotes } from "../../../types/company-from";
 
 /**
  * A holder as `holders` and `fn HDS` report it; the keys are the JSON
@@ -231,7 +232,9 @@ export function holderReportNotices({
       ? `The source lists its ${reported} largest holders; fn 13F ${requested} lists all ${total.toLocaleString("en-US")}.`
       : null;
   return {
-    notices: [header, basis, cut, positionsBasis, holderShareBasisNote(data, shown), unvaluedHoldersNote(shown, sort)]
+    notices: [header, basis, cut, positionsBasis, holderShareBasisNote(data, shown), unvaluedHoldersNote(shown, sort),
+      // The SEC index's rows are the listing's own; the source's, its company's home line's when it says so.
+      ...(indexed ? [] : companyDataNotes(data.companyFrom))]
       .filter((line): line is string => !!line),
     valueBasis,
     positionsBasis,

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

@@ -20,7 +20,7 @@ import {
 } from "./model";
 import { isAmendedInsiderFiling, relevantInsiderAmendments } from "./amendments";
 import { formatInsiderName } from "./display";
-import { SEC_FILINGS } from "../shared/report-freshness";
+import { SEC_FILING_ROWS } from "../shared/report-freshness";
 import { resolveHeadlessInstrument, resolveHeadlessIssuerListing } from "../shared/headless-market-data";
 import { noSecReportsNotice } from "../../../utils/sec";
 import { parsePublicTickerKey } from "../../../utils/exchanges";
@@ -329,7 +329,7 @@ export function createInsiderHeadless(
 ): HeadlessPaneDefinition<"rows"> {
   return {
     shape: "rows",
-    freshness: { ...SEC_FILINGS, basis: "Form 4 filings", observedKey: "filingDate" },
+    freshness: { ...SEC_FILING_ROWS, basis: "Form 4 filings" },
     argument: {
       kind: "ticker",
       optional: true,

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

@@ -1,5 +1,5 @@
 import { apiClient } from "../../../api-client";
-import type { IpoCalendarParams, IpoCalendarPayload, IpoDeal, IpoSourceHealth } from "../../../api-client/ipo";
+import type { IpoCalendarParams, IpoCalendarPayload, IpoDeal, IpoLockup, IpoSourceHealth } from "../../../api-client/ipo";
 import type { HeadlessPaneApiClient } from "../../../types/plugin";
 import { createPluginCache } from "../../../data/plugin-cache";
 import { cachedCloudResource, loadCloudResource, unavailableOnServer, type CloudResource } from "../shared/cloud-resource";
@@ -45,6 +45,21 @@ function validDeal(deal: IpoDeal): boolean {
     && validFirstDay(deal.firstDay);
 }
 
+function validLockup(value: unknown): value is IpoLockup {
+  const lockup = value as IpoLockup | null;
+  return !!lockup && typeof lockup === "object" && typeof lockup.endsOn === "string" && dayOrNull(lockup.endsOn)
+    && typeof lockup.days === "number" && Number.isFinite(lockup.days) && lockup.days > 0
+    && (lockup.basis === "prospectus" || lockup.basis === "typical")
+    && dayOrNull(lockup.prospectusDate ?? null) && textOrNull(lockup.prospectusUrl ?? null);
+}
+
+/** A lock-up estimate the client cannot read is left off its deal; the deal stays. */
+function withReadableLockup(deal: IpoDeal): IpoDeal {
+  if (deal.lockup == null || validLockup(deal.lockup)) return deal;
+  const { lockup: _unreadable, ...rest } = deal;
+  return rest;
+}
+
 function validSource(source: IpoSourceHealth): boolean {
   return !!source && text(source.id) && Array.isArray(source.mics) && source.mics.every(text)
     && typeof source.ok === "boolean" && textOrNull(source.asOf);
@@ -61,7 +76,8 @@ export function validateIpoCalendar(data: IpoCalendarPayload): IpoCalendarPayloa
   }
   return {
     asOf: data.asOf,
-    deals: data.deals.filter(validDeal).map((deal) => (REGIONS.has(deal.region) ? deal : { ...deal, region: "other" })),
+    deals: data.deals.filter(validDeal).map(withReadableLockup)
+      .map((deal) => (REGIONS.has(deal.region) ? deal : { ...deal, region: "other" })),
     sources: data.sources.filter(validSource),
   };
 }

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

@@ -9,11 +9,13 @@ import { fetchIpoCalendar } from "./client";
 import {
   calendarDate,
   filterIpoDeals,
+  formatIpoLockupEnd,
   formatIpoPrice,
   formatIpoReturn,
   formatIpoSize,
   IPO_STATUSES,
   ipoBoardStatus,
+  ipoKeyword,
   isIpoTab,
   marketsBehind,
   marketsBehindText,
@@ -21,7 +23,10 @@ import {
   DEFAULT_IPO_SORT,
   type IpoTab,
 } from "./model";
+import { ipoDetailSentences, loadIpoLockupNews, type IpoLockupStory } from "./listing-ipo";
 import { REPORT_FILTER, REPORT_ROWS } from "../shared/headless-options";
+import { DATE_OPTION_EXAMPLES, isoDateOption } from "../../../utils/calendar-date";
+import { logFailure } from "../../../utils/log-failure";
 
 const COLUMNS: HeadlessPaneColumn[] = [
   { key: "ticker", header: "Ticker" },
@@ -33,6 +38,8 @@ const COLUMNS: HeadlessPaneColumn[] = [
   { key: "price", header: "Price", align: "right" },
   { key: "offerSizeUsd", header: "Size", align: "right", format: (value) => formatIpoSize(value as number | null) },
   { key: "firstDayReturn", header: "Return", align: "right", format: (value) => formatIpoReturn(value as number | null) },
+  // A US IPO's estimated lock-up end: "~2026-11-02".
+  { key: "lockupEnds", header: "Lockup ends", format: (value) => formatIpoLockupEnd(typeof value === "string" ? value : null) },
 ];
 
 type StatusOption = IpoStatus | "all";
@@ -68,7 +75,7 @@ function toRow(deal: IpoDeal, now: Date) {
     status: ipoBoardStatus(deal, now),
     listingType: deal.listingType,
     currency: deal.currency,
-    price: formatIpoPrice(deal),
+    price: formatIpoPrice(deal, { full: true }),
     priceLow: deal.priceLow,
     priceHigh: deal.priceHigh,
     offerPrice: deal.offerPrice,
@@ -78,26 +85,60 @@ function toRow(deal: IpoDeal, now: Date) {
     firstDayClose: deal.firstDay?.close ?? null,
     firstDayReturn: deal.firstDay?.returnPct ?? null,
     filedDate: deal.filedDate,
+    lockupEnds: deal.lockup?.endsOn ?? null,
+    lockupBasis: deal.lockup?.basis ?? null,
+    prospectusDate: deal.lockup?.prospectusDate ?? null,
   };
 }
 
-function projectIpoCalendarHeadless(payload: IpoCalendarPayload, args: HeadlessPaneLoadArgs): HeadlessRowsResult {
+/** One deal found: its IPO in words, as `ticker` gives it, with its price now and its lock-up news. */
+interface IpoDealDetail {
+  price: number | null;
+  news: IpoLockupStory[];
+}
+
+/** Lock-up estimates soonest first, then the ones that have ended, latest first. */
+function byLockupEnd(deals: readonly IpoDeal[], now: Date): IpoDeal[] {
+  const today = now.toISOString().slice(0, 10);
+  const rank = (deal: IpoDeal) => (deal.lockup!.endsOn >= today ? 0 : 1);
+  return [...deals].sort((a, b) => rank(a) - rank(b)
+    || (rank(a) === 0 ? a.lockup!.endsOn.localeCompare(b.lockup!.endsOn) : b.lockup!.endsOn.localeCompare(a.lockup!.endsOn))
+    || a.id.localeCompare(b.id));
+}
+
+/** The most rows `--limit` lists. */
+const MAX_ROWS = 500;
+
+const SPAC_NOTE = "A SPAC's merger with its target (de-SPAC) is no IPO, so the calendar lists the SPACs' own IPOs.";
+
+export function projectIpoCalendarHeadless(
+  payload: IpoCalendarPayload,
+  args: HeadlessPaneLoadArgs,
+  detail: IpoDealDetail | null = null,
+  now = new Date(),
+): HeadlessRowsResult {
   const query = typeof args.argument === "string" ? args.argument.trim() : "";
   const region = regionOption(args);
   const status = statusOption(args);
   const limit = Number(args.options.limit ?? 50);
-  const now = new Date();
-  const matching = sortIpoDeals(
-    filterIpoDeals(payload.deals, region, query, now).filter((deal) => status === "all" || deal.status === status),
-    DEFAULT_IPO_SORT,
-    now,
-  );
+  const keyword = ipoKeyword(query);
+  const found = filterIpoDeals(payload.deals, region, query, now).filter((deal) => status === "all" || deal.status === status);
+  const matching = keyword === "lockup" ? byLockupEnd(found, now) : sortIpoDeals(found, DEFAULT_IPO_SORT, now);
   const rows = matching.slice(0, limit).map((deal) => toRow(deal, now));
   const behind = marketsBehindText(marketsBehind(payload.sources, region, payload.deals));
+  const single = matching.length === 1 && query && !keyword ? matching[0]! : null;
+  const notes = [
+    ...rows.length < matching.length
+      ? [`Showing ${rows.length} of ${matching.length} deals; --limit ${Math.min(matching.length, MAX_ROWS)} lists ${matching.length <= MAX_ROWS ? "them all" : "more"}.`]
+      : [],
+    ...single ? ipoDetailSentences(single, detail?.price ?? null, detail?.news ?? [], now) : [],
+    ...keyword === "spac" || keyword === "de-spac" ? [SPAC_NOTE] : [],
+  ];
   return {
     columns: COLUMNS,
     rows,
     ...(behind ? { errors: [behind] } : {}),
+    ...(notes.length ? { notes } : {}),
     metadata: {
       asOf: payload.asOf,
       total: matching.length,
@@ -149,7 +190,15 @@ export const ipoCalendarHeadless: HeadlessPaneDefinition<"rows"> = {
       type: "integer",
       defaultValue: 50,
       minimum: 1,
-      maximum: 500,
+      maximum: MAX_ROWS,
+    },
+    {
+      key: "from",
+      type: "string",
+      placeholder: "date",
+      description: `First listing date, as ${DATE_OPTION_EXAMPLES}; the calendar keeps a year of listings.`,
+      example: "--from 2025-11-01",
+      normalize: (value) => isoDateOption(value, "from"),
     },
   ],
   columns: COLUMNS,
@@ -164,7 +213,22 @@ export const ipoCalendarHeadless: HeadlessPaneDefinition<"rows"> = {
   async load(args, ctx) {
     // The default window has no filed or withdrawn deals, so a stage is asked for by name.
     const status = statusOption(args);
-    const params = status === "all" ? {} : { status };
-    return projectIpoCalendarHeadless(await fetchIpoCalendar(ctx.apiClient, ctx.signal, params), args);
+    const from = typeof args.options.from === "string" && args.options.from ? args.options.from : undefined;
+    const params = { ...(status === "all" ? {} : { status }), ...(from ? { from } : {}) };
+    const payload = await fetchIpoCalendar(ctx.apiClient, ctx.signal, params);
+    const projected = projectIpoCalendarHeadless(payload, args);
+    // One deal found: its price now and its lock-up news, which never fail the report.
+    const query = typeof args.argument === "string" ? args.argument.trim() : "";
+    const matched = projected.rows.length === 1 && query && !ipoKeyword(query)
+      ? payload.deals.find((deal) => deal.id === projected.rows[0]!.id) : undefined;
+    if (!matched?.symbol) return projected;
+    const [price, news] = await Promise.all([
+      matched.status === "listed"
+        ? ctx.marketData.getQuote(matched.symbol, matched.exchange ?? undefined).then((quote) => quote.price ?? null,
+          logFailure("plugins.ipo-calendar", "Load the price of an IPO failed", null))
+        : Promise.resolve(null),
+      loadIpoLockupNews(ctx.apiClient, matched).catch(logFailure("plugins.ipo-calendar", "Load an IPO's lock-up news failed", [] as IpoLockupStory[])),
+    ]);
+    return projectIpoCalendarHeadless(payload, args, { price, news });
   },
 };

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);
+}