gloomberb 0.16.4 → 0.16.6

package/src/cli/pane-functions/freshness.ts

@@ -8,7 +8,7 @@ import type {
   HeadlessSeriesResult,
   HeadlessSnapshotResult,
 } from "../../types/plugin";
-import { parseReportTime, type ReportTime } from "../../utils/utc-time";
+import { localTimeSuffix, parseReportTime, type ReportTime } from "../../utils/utc-time";
 import { isRecord } from "../../utils/guards";
 import { latestRegularSessionClose } from "../../market-data/market/freshness";
 import { reportMarketSession, type ReportMarket, type SessionObservation } from "./market-session";
@@ -27,6 +27,8 @@ export interface ReportFreshness {
   asOf: string | null;
   /** Oldest observation, when it is more than a day older than `asOf`. */
   oldest?: string;
+  /** With a declared `citeOldest`: the oldest observation whenever it is older than `asOf`. Exports cite it. */
+  oldestObservation?: string;
   status: ReportFreshnessStatus;
   /** How far the data is held back; the most of its rows when they differ... */
   delayMinutes?: number;
@@ -40,14 +42,54 @@ export interface ReportFreshness {
   /** ...and what the rest are. */
   feed?: "live" | "delayed";
   basis?: string;
+  /** Set when the dates are the start of a period: the status line then reads `Sep 2026 (monthly)`. */
+  periodicity?: "monthly" | "quarterly" | "annual";
   /** The local date of the session close `asOf` is, when the newest observation is its venue's latest close. */
   asOfClose?: string;
+  /**
+   * Whose trading day the dated as-of (`asOfClose`, or a date-only `asOf`) is,
+   * when one market's calendar dates it: `US`, or a venue code such as `ASX`.
+   */
+  tradingDayMarket?: string;
   /** Where the venues of a quote report stand now, from their session calendars. */
   market?: ReportMarket;
+  /**
+   * For a dataset (declared `dataset`, with no quote among its rows): whole UTC
+   * days from the last day its newest observation covers to when this report
+   * was built. A capture's status line then reads `observed Sun 4 Oct · lag 6d`.
+   */
+  lagDays?: number;
+  /**
+   * What the newest observation is, for a dataset that names it (`last
+   * trade`): every line then reads `Source: DTCC · last trade 2026-10-09 · lag 2 days`.
+   */
+  observation?: string;
+  /**
+   * Each source's own newest observation, in the order declared, when the data
+   * comes from several sources polled apart: `asOf` is the newest of them.
+   */
+  sources?: ReportSourceAsOf[];
+  /**
+   * Whole minutes from the oldest of `sources` (or, declared `oldestAge`, the
+   * oldest observation) to when this report was built: `oldest 9 min`.
+   */
+  oldestAgeMinutes?: number;
+  /** What the figures are, said after the status: `funding = current estimate, pays 08:00 UTC`. */
+  note?: string;
+  /** Who published the figures, when the data names them. */
+  publisher?: string;
+  /** When the publisher released the data, an ISO instant in UTC or an ISO date, when the data states it. */
+  publishedAt?: string;
   /** When this report was built. */
   retrievedAt: string;
 }
 
+/** One source's newest observation: an ISO instant in UTC. */
+interface ReportSourceAsOf {
+  source: string;
+  asOf: string;
+}
+
 const DEFAULT_REPORT_SOURCE = "Gloom Cloud";
 
 /** Top-level row and metadata keys that say when a value was observed. */
@@ -159,12 +201,12 @@ function collect(
   definition: Pick<HeadlessPaneDefinition, "shape">,
   result: HeadlessPaneResult,
   now: number,
-  { observedKey, ignoreStaleFlags }: Pick<HeadlessPaneFreshness, "observedKey" | "ignoreStaleFlags">,
+  { observedKey, ignoreStaleFlags, observations: declaredObservations }: Pick<HeadlessPaneFreshness, "observedKey" | "ignoreStaleFlags" | "observations">,
 ): { signals: FeedSignals; observations: Observations } {
   const signals = emptySignals();
   const observations: Observations = { units: [], extra: [] };
   const rowKeys = observedKey ? [observedKey] : OBSERVATION_KEYS;
-  for (const row of resultRecords(definition, result)) {
+  for (const row of declaredObservations ?? resultRecords(definition, result)) {
     if (!isRecord(row)) continue;
     readFeedSignals(row, signals);
     const time = observedTime(row, now, rowKeys)
@@ -173,7 +215,7 @@ function collect(
     readSession(row, time, signals);
     if (time) observations.units.push(time);
   }
-  if (definition.shape === "series") {
+  if (definition.shape === "series" && !declaredObservations) {
     for (const series of (result as HeadlessSeriesResult).series) {
       const record = series as unknown as Record<string, unknown>;
       readFeedSignals(record, signals);
@@ -190,6 +232,8 @@ function collect(
     const time = observedKey ? null : observedTime(result.metadata, now)
       ?? (observations.units.length ? null : observedTime(result.metadata, now, UPDATE_KEYS));
     if (time) observations.extra.push(time);
+    // A board whose figures follow one venue's sessions (HM's) names it as a quote row does.
+    readSession(result.metadata, time, signals);
   }
   if (definition.shape === "snapshot" && !observedKey) {
     const time = parseReportTime((result as HeadlessSnapshotResult).asOf);
@@ -230,13 +274,17 @@ function worstFeedStatus(statuses: Array<"live" | "delayed" | "stale">): "live"
   ), null);
 }
 
-/** Completed US sessions after the day of `newest`, counted back from `now`, up to `limit`. */
-function sessionsAfter(newest: ReportTime, now: number, limit: number): number {
+/**
+ * Completed sessions after the day of `newest`, counted back from `now`, up to
+ * `limit`: the US's, or `exchange`'s when the app knows its sessions.
+ */
+function sessionsAfter(newest: ReportTime, now: number, limit: number, exchange?: string): number {
   const newestDate = new Date(newest.time).toISOString().slice(0, 10);
+  const venue = exchange && latestRegularSessionClose(exchange, now) ? exchange : "NYSE";
   let count = 0;
   let cursor = now;
   while (count < limit) {
-    const close = latestRegularSessionClose("NYSE", cursor);
+    const close = latestRegularSessionClose(venue, cursor);
     if (!close || close.date <= newestDate) break;
     count += 1;
     cursor = close.close - 1;
@@ -250,7 +298,26 @@ function overdue(declared: HeadlessPaneFreshness, asOf: ReportTime | null, now:
   if (nextExpected != null && now > nextExpected.time + RELEASE_GRACE_MS) return true;
   if (!asOf) return false;
   if (declared.maxAgeMinutes != null && now - asOf.time > declared.maxAgeMinutes * 60_000) return true;
-  return declared.cadence === "daily" && sessionsAfter(asOf, now, 2) > 1;
+  return declared.cadence === "daily" && sessionsAfter(asOf, now, 2, declared.cadenceExchange) > 1;
+}
+
+/**
+ * Whole UTC days from the last day an observation covers to `now`: its own
+ * day, or the last day of the month, quarter or year a periodic date starts.
+ * September's figure read on 10 Oct lags 10 days, not 39.
+ */
+function datasetLagDays(observed: ReportTime, periodicity: ReportFreshness["periodicity"], now: number): number {
+  const day = new Date(observed.time);
+  const year = day.getUTCFullYear();
+  const month = day.getUTCMonth();
+  const through = !periodicity ? Date.UTC(year, month, day.getUTCDate())
+    // Day 0 of the month after the period is its last day.
+    : periodicity === "monthly" ? Date.UTC(year, month + 1, 0)
+      : periodicity === "quarterly" ? Date.UTC(year, month - (month % 3) + 3, 0)
+        : Date.UTC(year, 12, 0);
+  const today = new Date(now);
+  const todayStart = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
+  return Math.max(0, Math.round((todayStart - through) / DAY_MS));
 }
 
 interface FreshnessInputs {
@@ -260,13 +327,29 @@ interface FreshnessInputs {
   now: number;
 }
 
+/** The declared sources that name themselves and carry a time, in the order declared. */
+function declaredSources(declared: HeadlessPaneFreshness, now: number): Array<{ source: string; time: ReportTime }> {
+  return (declared.sources ?? []).flatMap(({ source, asOf }) => {
+    const name = source.trim();
+    const time = observedTime({ asOf }, now, ["asOf"]);
+    return name && time && !time.dateOnly ? [{ source: name, time }] : [];
+  });
+}
+
 function resolveFreshness({ declared, signals, observations, now }: FreshnessInputs): ReportFreshness {
-  const declaredAsOf = observedTime({ asOf: declared.asOf }, now, ["asOf"]);
+  const sources = declaredSources(declared, now);
+  // Sources date the data by their own observations, as a declared as-of does.
+  const declaredAsOf = observedTime({ asOf: declared.asOf }, now, ["asOf"]) ?? newest(sources.map(({ time }) => time));
   const asOf = declaredAsOf ?? newest([...observations.units, ...observations.extra]);
+  // The oldest source, not the newest, says how far behind the view can be.
+  const agedFrom = sources.length ? oldest(sources.map(({ time }) => time))
+    : declared.oldestAge ? oldest(observations.units) ?? asOf : null;
+  const oldestAgeMinutes = agedFrom && !agedFrom.dateOnly ? Math.max(0, Math.floor((now - agedFrom.time) / 60_000)) : null;
   // A loader that dates its data itself also says how old the oldest part is, or nothing;
   // `oldest: null` says the rows are a history, whose first entry is not stale data.
   const oldestTime = declared.oldest != null ? parseReportTime(declared.oldest)
     : declaredAsOf || declared.oldest === null ? null : oldest(observations.units);
+  const oldestUnit = declared.citeOldest ? oldest(observations.units) : null;
   const late = overdue(declared, asOf, now);
 
   let status: ReportFreshnessStatus;
@@ -320,22 +403,44 @@ function resolveFreshness({ declared, signals, observations, now }: FreshnessInp
       }
     }
   }
-  const { market, closeDate } = reportMarketSession(signals.sessions, now);
+  const { market, closeDate, closeMarket } = reportMarketSession(signals.sessions, now);
   // The close wording dates the newest observation, so only when that is what `asOf` is.
   const asOfClose = closeDate && asOf && !declaredAsOf ? closeDate : null;
-
+  const tradingDayMarket = asOfClose ? closeMarket
+    : asOf?.dateOnly ? declared.tradingDayMarket?.trim() || null : null;
+  const periodicity = declared.periodicity && asOf?.dateOnly ? declared.periodicity : undefined;
+  // Rows that are quotes (a feed, a venue's session) keep the market line, even on a dataset's pane.
+  const quoted = signals.live || signals.delayed || signals.sessions.length > 0;
+  // A dataset disseminated with a delay (DTCC's swap tape) lags its newest observation all the same.
+  const lagDays = declared.dataset && asOf && !quoted && (status === "not-a-feed" || status === "stale" || status === "delayed")
+    ? datasetLagDays(asOf, periodicity, now) : null;
+  const observation = lagDays != null ? declared.observation?.trim() : undefined;
+
+  const note = declared.note?.trim();
+  const publisher = declared.publisher?.trim();
+  const publishedAt = parseReportTime(declared.publishedAt);
   return {
-    source: declared.source?.trim() || DEFAULT_REPORT_SOURCE,
+    source: declared.source?.trim() || (sources.length ? [...new Set(sources.map(({ source }) => source))].join(", ") : DEFAULT_REPORT_SOURCE),
     asOf: asOf ? isoTime(asOf) : null,
     ...(asOf && oldestTime && asOf.time - oldestTime.time > OLDEST_GAP_MS ? { oldest: isoTime(oldestTime) } : {}),
+    ...(asOf && oldestUnit && oldestUnit.time < asOf.time ? { oldestObservation: isoTime(oldestUnit) } : {}),
     status,
     ...(delayMinutes != null && delayMinutes > 0 ? { delayMinutes } : {}),
     ...(minDelayMinutes != null && minDelayMinutes > 0 ? { minDelayMinutes } : {}),
     ...(status === "stale" && staleAt ? { ageMinutes: Math.max(0, Math.floor((now - staleAt.time) / 60_000)) } : {}),
     ...(partial ?? {}),
     ...(status === "not-a-feed" && declared.basis ? { basis: declared.basis } : {}),
+    ...(periodicity ? { periodicity } : {}),
     ...(asOfClose ? { asOfClose } : {}),
+    ...(tradingDayMarket ? { tradingDayMarket } : {}),
     ...(market ? { market } : {}),
+    ...(lagDays != null ? { lagDays } : {}),
+    ...(observation ? { observation } : {}),
+    ...(sources.length ? { sources: sources.map(({ source, time }) => ({ source, asOf: isoTime(time) })) } : {}),
+    ...(oldestAgeMinutes != null ? { oldestAgeMinutes } : {}),
+    ...(note ? { note } : {}),
+    ...(publisher ? { publisher } : {}),
+    ...(publishedAt ? { publishedAt: isoTime(publishedAt) } : {}),
     retrievedAt: new Date(now).toISOString(),
   };
 }
@@ -401,20 +506,52 @@ const DAY_MS = 24 * 60 * 60_000;
 /** A reopen further ahead than this reads with its date, not just its weekday. */
 const WEEKDAY_ONLY_MS = 6 * DAY_MS;
 
-/** `Fri 9 Oct` for a `YYYY-MM-DD` date, with the year when it is not the year of `now`. */
-function dayText(date: string, now: number): string {
+/**
+ * `Fri 9 Oct 2026` for a `YYYY-MM-DD` date. Always with its year: a report
+ * read later, or pasted somewhere, still says which day it means.
+ */
+function dayText(date: string): string {
+  const day = new Date(`${date.slice(0, 10)}T00:00:00Z`);
+  if (!Number.isFinite(day.getTime())) return date;
+  return `${WEEKDAYS[day.getUTCDay()]} ${day.getUTCDate()} ${MONTHS[day.getUTCMonth()]} ${day.getUTCFullYear()}`;
+}
+
+/**
+ * `US trading day Fri 9 Oct 2026`: a date names whose day it is when one
+ * market's calendar dates it, so a reader a day ahead of New York does not take
+ * the US Friday for their own. Never shifted to the reader's zone.
+ */
+function tradingDayText(date: string, market: string | undefined): string {
+  return market ? `${market} trading day ${dayText(date)}` : dayText(date);
+}
+
+/** `Sep 2026`, `Q2 2026` or `2026` for the period a date starts. */
+function periodText(date: string, periodicity: NonNullable<ReportFreshness["periodicity"]>): string {
   const day = new Date(`${date.slice(0, 10)}T00:00:00Z`);
   if (!Number.isFinite(day.getTime())) return date;
-  const year = day.getUTCFullYear() === new Date(now).getUTCFullYear() ? "" : ` ${day.getUTCFullYear()}`;
-  return `${WEEKDAYS[day.getUTCDay()]} ${day.getUTCDate()} ${MONTHS[day.getUTCMonth()]}${year}`;
+  const year = day.getUTCFullYear();
+  const month = day.getUTCMonth();
+  return periodicity === "monthly" ? `${MONTHS[month]} ${year}`
+    : periodicity === "quarterly" ? `Q${Math.floor(month / 3) + 1} ${year}`
+      : `${year}`;
 }
 
-/** `Fri 9 Oct 23:59 UTC`, or `Fri 9 Oct` for a date. */
-function timeText(value: string, now: number): string {
+/** The period a FRED series frequency ("Monthly", "Quarterly") publishes in; null for daily and weekly series, whose dates are days. */
+export function periodicityOf(frequency: string | null | undefined): ReportFreshness["periodicity"] | null {
+  const word = frequency?.trim().toLowerCase() ?? "";
+  return word.startsWith("monthly") ? "monthly" : word.startsWith("quarterly") ? "quarterly" : word.startsWith("annual") ? "annual" : null;
+}
+
+/**
+ * `Fri 9 Oct 2026 23:59 UTC`, or `Fri 9 Oct 2026` for a date. With `local`, the
+ * reader's own time follows when they set a zone: `(Sat 10 Oct 08:59 Asia/Tokyo)`.
+ */
+function timeText(value: string, local: boolean): string {
   const time = parseReportTime(value);
   if (!time) return value;
   const iso = new Date(time.time).toISOString();
-  return time.dateOnly ? dayText(iso, now) : `${dayText(iso, now)} ${iso.slice(11, 16)} UTC`;
+  if (time.dateOnly) return dayText(iso);
+  return `${dayText(iso)} ${iso.slice(11, 16)} UTC${local ? localTimeSuffix(time.time) : ""}`;
 }
 
 /**
@@ -449,6 +586,16 @@ function ageText(minutes: number): string {
   return `${Math.floor(hours / 24)} days`;
 }
 
+/**
+ * How many rows are stale when only some are: `2 of 16 stale`, or `2 stale`
+ * when `short`. Null when the report does not count them. One wording for a
+ * report's status line, a capture's and the status a capture prints.
+ */
+export function staleRowsText(freshness: Pick<ReportFreshness, "staleCount" | "observationCount">, short = false): string | null {
+  if (freshness.staleCount == null || freshness.observationCount == null) return null;
+  return `${short ? freshness.staleCount : `${freshness.staleCount} of ${freshness.observationCount}`} stale`;
+}
+
 /** `short` counts stale rows without their total (`2 stale`), for a narrow capture. */
 function statusText(freshness: ReportFreshness, short = false): string {
   switch (freshness.status) {
@@ -457,12 +604,13 @@ function statusText(freshness: ReportFreshness, short = false): string {
     case "delayed":
       return delayedText(freshness);
     case "stale": {
-      if (freshness.staleCount != null && freshness.observationCount != null) {
+      const stale = staleRowsText(freshness, short);
+      if (stale) {
         const rest = freshness.feed === "live" ? "live" : freshness.feed === "delayed" ? delayedText(freshness) : null;
-        const count = short ? `${freshness.staleCount}` : `${freshness.staleCount} of ${freshness.observationCount}`;
-        return `${rest ? `${rest}, ` : ""}${count} stale`;
+        return `${rest ? `${rest}, ` : ""}${stale}`;
       }
-      return freshness.ageMinutes != null ? `stale (${ageText(freshness.ageMinutes)} old)` : "stale";
+      // A line that says how old its oldest observation is does not say it twice.
+      return freshness.ageMinutes != null && freshness.oldestAgeMinutes == null ? `stale (${ageText(freshness.ageMinutes)} old)` : "stale";
     }
     case "not-a-feed":
       return freshness.basis ? `not a live feed (${freshness.basis})` : "not a live feed";
@@ -475,32 +623,66 @@ function statusText(freshness: ReportFreshness, short = false): string {
   }
 }
 
+/** Whether an ISO instant falls on the UTC day the report was built. */
+function onRetrievalDay(iso: string, retrievedAt: string): boolean {
+  return iso.slice(0, 10) === retrievedAt.slice(0, 10);
+}
+
 /**
  * The dated as-of: a session close, a UTC time, a date, or when the report was
- * retrieved; with the oldest observation unless `short`.
+ * retrieved; with the oldest observation unless `short`, or when the line says
+ * how old the oldest is instead. `undated` leaves the day off a time of the
+ * day the report was built, as a pane footer reads today.
+ */
+function asOfText(freshness: ReportFreshness, short: boolean, local: boolean, undated = false): string {
+  if (!freshness.asOf) return `retrieved ${timeText(freshness.retrievedAt, local)}`;
+  const market = freshness.tradingDayMarket;
+  const period = freshness.periodicity;
+  const time = parseReportTime(freshness.asOf);
+  const asOf = period ? `${periodText(freshness.asOf, period)} (${period})`
+    : freshness.asOfClose
+      ? `${tradingDayText(freshness.asOfClose, market)} close`
+      : time?.dateOnly ? tradingDayText(freshness.asOf, market)
+        : undated && time && onRetrievalDay(new Date(time.time).toISOString(), freshness.retrievedAt)
+          ? `${new Date(time.time).toISOString().slice(11, 16)} UTC` : timeText(freshness.asOf, local);
+  const oldest = freshness.oldest && (period ? periodText(freshness.oldest, period) : dayText(freshness.oldest));
+  return oldest && !short && freshness.oldestAgeMinutes == null ? `${asOf} (oldest ${oldest})` : asOf;
+}
+
+/**
+ * Each source's own as-of, the zone named once at the end:
+ * `Sun 11 Oct 2026 · Binance 02:15 · Bybit 02:24 UTC`. The day leads, the newest source's,
+ * and a source observed on another day carries its own (`Binance Sat 10 Oct
+ * 23:58`). `undated` leaves the leading day off when it is the day the report
+ * was built.
  */
-function asOfText(freshness: ReportFreshness, now: number, short = false): string {
-  if (!freshness.asOf) return `retrieved ${timeText(freshness.retrievedAt, now)}`;
-  const asOf = freshness.asOfClose ? `${dayText(freshness.asOfClose, now)} close` : timeText(freshness.asOf, now);
-  return freshness.oldest && !short ? `${asOf} (oldest ${dayText(freshness.oldest, now)})` : asOf;
+function sourcesAsOfParts(freshness: ReportFreshness, sources: readonly ReportSourceAsOf[], undated: boolean): string[] {
+  const times = sources.map(({ source, asOf }) => ({ source, iso: new Date(Date.parse(asOf)).toISOString() }));
+  const day = times.reduce((latest, { iso }) => (iso > latest ? iso : latest), "").slice(0, 10);
+  const parts = times.map(({ source, iso }) => {
+    const date = iso.slice(0, 10) === day ? "" : `${dayText(iso).replace(/ \d{4}$/, "")} `;
+    return `${source} ${date}${iso.slice(11, 16)}`;
+  });
+  parts[parts.length - 1] += " UTC";
+  return undated && onRetrievalDay(day, freshness.retrievedAt) ? parts : [dayText(day), ...parts];
 }
 
 /**
  * When the first venue opens again: its UTC time when that is later the same
  * UTC day, else its weekday at the venue (`Mon`), with the date a week out.
  */
-function reopenText(market: ReportMarket, now: number): string | null {
+function reopenText(market: ReportMarket, now: number, local: boolean): string | null {
   if (!market.reopensAt || !market.reopensOn) return null;
   const at = Date.parse(market.reopensAt);
   if (!Number.isFinite(at)) return null;
   const iso = new Date(at).toISOString();
-  if (iso.slice(0, 10) === new Date(now).toISOString().slice(0, 10)) return `${iso.slice(11, 16)} UTC`;
-  return at - now > WEEKDAY_ONLY_MS ? dayText(market.reopensOn, now) : WEEKDAYS[new Date(`${market.reopensOn}T00:00:00Z`).getUTCDay()]!;
+  if (iso.slice(0, 10) === new Date(now).toISOString().slice(0, 10)) return `${iso.slice(11, 16)} UTC${local ? localTimeSuffix(at) : ""}`;
+  return at - now > WEEKDAY_ONLY_MS ? dayText(market.reopensOn) : WEEKDAYS[new Date(`${market.reopensOn}T00:00:00Z`).getUTCDay()]!;
 }
 
 /** `markets closed until Mon`; `short` is the compact form a narrow capture falls back to (`reopens Mon`). */
-function marketText(market: ReportMarket, now: number, short = false): string {
-  const reopen = reopenText(market, now);
+function marketText(market: ReportMarket, now: number, short: boolean, local: boolean): string {
+  const reopen = reopenText(market, now, local);
   switch (market.state) {
     case "open":
       return short ? "open" : "markets open";
@@ -525,18 +707,31 @@ interface StatusLineDetail {
   status?: "short";
   /** `reopens Mon` for `markets closed until Mon`; `none` leaves the market out. */
   market?: "short" | "none";
+  /** Leave out the reader's local time beside UTC times. */
+  local?: "none";
+  /** Leave the day off a time of the day the report was built. */
+  date?: "none";
+  /** Leave out what the figures are (`funding = current estimate`). */
+  note?: "none";
 }
 
 /**
- * The parts of a report's status line: the dated as-of, how current the data
- * is (`15 min delayed`, `live`), and where its markets stand, when known.
+ * The parts of a report's status line: the dated as-of (each source's, when
+ * it names several), how old the oldest observation is when it says, how
+ * current the data is (`15 min delayed`, `live`), where its markets stand,
+ * and what the figures are, when known.
  */
 function statusLineParts(freshness: ReportFreshness, detail: StatusLineDetail = {}): string[] {
   const now = Date.parse(freshness.retrievedAt);
+  const local = detail.local !== "none";
+  const undated = detail.date === "none";
   return [
-    asOfText(freshness, now, detail.asOf === "short"),
+    ...(freshness.sources?.length ? sourcesAsOfParts(freshness, freshness.sources, undated)
+      : [asOfText(freshness, detail.asOf === "short", local, undated)]),
+    ...(freshness.oldestAgeMinutes != null ? [`oldest ${ageText(freshness.oldestAgeMinutes)}`] : []),
     statusText(freshness, detail.status === "short"),
-    ...(freshness.market && detail.market !== "none" ? [marketText(freshness.market, now, detail.market === "short")] : []),
+    ...(freshness.market && detail.market !== "none" ? [marketText(freshness.market, now, detail.market === "short", local)] : []),
+    ...(freshness.note && detail.note !== "none" ? [freshness.note] : []),
   ];
 }
 
@@ -544,36 +739,185 @@ function capitalize(text: string): string {
   return text ? `${text[0]!.toUpperCase()}${text.slice(1)}` : text;
 }
 
+/** `Sun 4 Oct`, with the year only when it is not the year of the capture, which the lag counts from. */
+function observedDayText(date: string, retrievedAt: string): string {
+  const text = dayText(date);
+  return date.slice(0, 4) === retrievedAt.slice(0, 4) ? text.replace(/ \d{4}$/, "") : text;
+}
+
+interface DatasetLineDetail {
+  /** Leave out the source. */
+  source?: "none";
+  /** Leave out the oldest observation. */
+  oldest?: "none";
+  /** Count stale rows without their total. */
+  status?: "short";
+}
+
+/** `lag 2 days`, `lag 1 day`. */
+function lagText(days: number): string {
+  return `lag ${days} ${days === 1 ? "day" : "days"}`;
+}
+
+/**
+ * A dataset's status line: its source, the newest observation's date (the
+ * period, for monthly to annual data) and how many days it lags, then which
+ * rows are stale, if any. No market part: a dataset has no session. A
+ * dataset that names its observation reads as its rows do, by ISO date:
+ * `Source: DTCC · last trade 2026-10-09 · lag 2 days`.
+ */
+function datasetLineParts(freshness: ReportFreshness, asOf: string, lagDays: number, detail: DatasetLineDetail = {}): string[] {
+  if (freshness.observation) {
+    return [
+      ...(detail.source === "none" ? [] : [`Source: ${freshness.source}`]),
+      `${freshness.observation} ${asOf.slice(0, 10)}`,
+      lagText(lagDays),
+      ...(freshness.status === "stale" ? ["stale"] : []),
+    ];
+  }
+  const period = freshness.periodicity;
+  const dated = (date: string) => (period ? periodText(date, period) : observedDayText(date, freshness.retrievedAt));
+  const oldest = freshness.oldest && detail.oldest !== "none" ? ` (oldest ${dated(freshness.oldest)})` : "";
+  const stale = freshness.status !== "stale" ? null : staleRowsText(freshness, detail.status === "short") ?? "stale";
+  return [
+    ...(detail.source === "none" ? [] : [`Source: ${freshness.source}`]),
+    `observed ${dated(asOf)}${period ? ` (${period})` : ""}${oldest}`,
+    `lag ${lagDays}d`,
+    ...(stale ? [stale] : []),
+  ];
+}
+
 /**
- * The plain status line of a report or capture, without its source:
- * `Fri 9 Oct close · 15 min delayed · markets closed until Mon`.
+ * The plain status line of a capture: the longest of `statusLineVariants`,
+ * `Fri 9 Oct close · 15 min delayed · markets closed until Mon` for quotes.
  */
 export function formatStatusLine(freshness: ReportFreshness): string {
-  return capitalize(statusLineParts(freshness).join(" · "));
+  return statusLineVariants(freshness)[0]!;
+}
+
+/** Whether the status line dates the data by its newest observation and lag (a dataset's), not by a market session. */
+function datesObservation(freshness: ReportFreshness): freshness is ReportFreshness & { asOf: string; lagDays: number } {
+  return freshness.lagDays != null && !!freshness.asOf;
+}
+
+/**
+ * The status line a pane's footer shows, the one its report and capture end
+ * with: without the reader's local time, and without the day when the data is
+ * from the day it is read.
+ */
+export function paneStatusLine(freshness: ReportFreshness): string {
+  return paneStatusLineVariants(freshness)[0]!;
+}
+
+/**
+ * `paneStatusLine` from longest to shortest, for a footer to show the first
+ * that fits beside its keys: the market part shortens, the stale total goes,
+ * then what the figures are.
+ */
+export function paneStatusLineVariants(freshness: ReportFreshness): string[] {
+  // A dataset's line has no market or local time to leave out: it reads as its report and capture do.
+  if (datesObservation(freshness)) return statusLineVariants(freshness);
+  const pane: StatusLineDetail = { local: "none", date: "none" };
+  const details: StatusLineDetail[] = [pane, { ...pane, market: "short" }, { ...pane, market: "short", status: "short" }, { ...pane, market: "short", status: "short", note: "none" }];
+  return [...new Set(details.map((detail) => capitalize(statusLineParts(freshness, detail).join(" · "))))];
 }
 
 /**
  * The status line from longest to shortest, for a capture to take the first
- * that fits its width. The date and the delay stay to the last; the market
- * part shortens, then the oldest observation and the stale total go, then
- * the market part.
+ * that fits its width. Quotes and other reports leave out their source: the
+ * date and the delay stay to the last; the market part shortens, then the
+ * reader's local time, the oldest observation and the stale total go, then
+ * the market part. With `source`, the line starts as `fn` ends,
+ * `Source: CFTC · Tue 6 Oct 2026 · not a live feed (weekly report)`, shortens
+ * the same way and gives up its source last. A dataset reads
+ * `Source: Gloom Cloud · observed Sun 4 Oct · lag 6d` and gives up its oldest
+ * observation, the stale total, then its source.
  */
-export function statusLineVariants(freshness: ReportFreshness): string[] {
+export function statusLineVariants(freshness: ReportFreshness, { source = false }: { source?: boolean } = {}): string[] {
+  if (datesObservation(freshness)) {
+    const { asOf, lagDays } = freshness;
+    const datasetDetails: DatasetLineDetail[] = [
+      {},
+      { oldest: "none" },
+      { oldest: "none", status: "short" },
+      { source: "none", oldest: "none", status: "short" },
+    ];
+    return [...new Set(datasetDetails.map((detail) => capitalize(datasetLineParts(freshness, asOf, lagDays, detail).join(" · "))))];
+  }
   const details: StatusLineDetail[] = [
     {},
     { market: "short" },
-    { asOf: "short", market: "short" },
-    { asOf: "short", status: "short", market: "short" },
-    { asOf: "short", status: "short", market: "none" },
+    { market: "short", local: "none" },
+    { asOf: "short", market: "short", local: "none" },
+    { asOf: "short", status: "short", market: "short", local: "none" },
+    { asOf: "short", status: "short", market: "none", local: "none" },
   ];
-  return [...new Set(details.map((detail) => capitalize(statusLineParts(freshness, detail).join(" · "))))];
+  // A line that dates each source keeps every source's time and their age to
+  // the last: its day goes first, then what the figures are.
+  const shortest = details.at(-1)!;
+  const variants: StatusLineDetail[] = freshness.sources?.length
+    ? [{}, ...details.map((detail) => ({ ...detail, date: "none" as const })), { ...shortest, date: "none", note: "none" }]
+    : freshness.note ? [...details, { ...shortest, note: "none" }] : details;
+  const lines = [...new Set(variants.map((detail) => capitalize(statusLineParts(freshness, detail).join(" · "))))];
+  // A line that dates each source names them already.
+  if (!source || freshness.sources?.length) return lines;
+  const sourced = [...new Set(variants.map((detail) => [`Source: ${freshness.source}`, ...statusLineParts(freshness, detail)].join(" · ")))];
+  const floor = sourced.at(-1)!.length;
+  return [...sourced, ...lines.filter((line) => line.length < floor)];
+}
+
+/** A capture's status line: the facts it states (its `freshness` in JSON) and its text, longest first. */
+export interface CaptureStatusLine {
+  freshness: ReportFreshness;
+  variants: string[];
+  /**
+   * What the line dates: `data` when it comes from the pane's own report or
+   * the view the pane dates itself, so the pane's own `as of` text says it
+   * twice; `quotes` for the quotes on screen, which may not be what the pane's
+   * `as of` dates; null when it dates nothing it can name.
+   */
+  dates: "data" | "quotes" | null;
+}
+
+/**
+ * What a capture's status line says about its data, from the first that applies:
+ * - a dataset's report (CHOKE's transits, HIRE's postings): its source, newest observation and lag;
+ * - a pane that dates its own view (PERP's venues, FXC's rates, the news wire's delay): what it publishes;
+ * - quotes on screen, when the pane does not say what its data is: their session, delay and market;
+ * - the pane's report, when it says how current its data is: the line `fn` ends with, source first;
+ * - otherwise what the rendered view carries, which may be nothing.
+ */
+export function captureStatusLine({ report, selfDated, quoted, rendered }: {
+  /** The pane's own report, loaded for the capture: what `fn` would say. */
+  report?: ReportFreshness;
+  /** Whether the rendered pane published how current its view is. */
+  selfDated: boolean;
+  /** The quotes the capture shows, read when the pane does not say what its data is. */
+  quoted?: ReportFreshness;
+  rendered: () => ReportFreshness;
+}): CaptureStatusLine {
+  const plain = (freshness: ReportFreshness, dates: CaptureStatusLine["dates"]): CaptureStatusLine => ({ freshness, variants: statusLineVariants(freshness), dates });
+  const dated = (freshness: ReportFreshness) => (freshness.asOf ? "data" as const : null);
+  if (report && datesObservation(report)) return plain(report, "data");
+  if (selfDated) {
+    const view = rendered();
+    return plain(view, dated(view));
+  }
+  if (quoted) return plain(quoted, "quotes");
+  if (report && report.status !== "unreported") return { freshness: report, variants: statusLineVariants(report, { source: true }), dates: dated(report) };
+  return plain(rendered(), null);
 }
 
 /**
  * The one line every text report ends with, its source then its status line:
  * `Source: Gloom Cloud · Fri 9 Oct close · 15 min delayed · markets closed until Mon`.
  * Without a dated observation it says when the report was retrieved instead.
+ * A line that dates each of its sources names them there, so it is the status
+ * line alone: `Sun 11 Oct 2026 · Binance 02:15 · Bybit 02:24 UTC · oldest 9 min · delayed`.
  */
 export function formatFreshnessLine(freshness: ReportFreshness): string {
-  return [`Source: ${freshness.source}`, ...statusLineParts(freshness)].join(" · ");
+  // A dataset that names its observation ends `fn` as its pane and capture do.
+  if (freshness.observation && datesObservation(freshness)) return statusLineVariants(freshness)[0]!;
+  const parts = statusLineParts(freshness);
+  return (freshness.sources?.length ? parts : [`Source: ${freshness.source}`, ...parts]).join(" · ");
 }