gloomberb 0.18.4 → 0.19.0

package/src/news/aggregator.ts

@@ -1,7 +1,7 @@
 import { logFailure } from "../utils/log-failure";
 import type { NewsCapability } from "../capabilities";
 import type { ConnectionHealthRegistry } from "../core/connection-health";
-import type { NewsArticle, NewsQuery, NewsQueryState } from "./types";
+import type { NewsAccess, NewsArticle, NewsQuery, NewsQueryState } from "./types";
 import { isAppVisible, subscribeAppVisibility } from "../state/app/activity";
 import {
   DEFAULT_GLOBAL_QUERY,
@@ -28,6 +28,18 @@ export interface NewsServiceOptions {
   connectionHealth?: ConnectionHealthRegistry;
   /** Defaults to the app's visibility; injectable for tests. */
   visibility?: { isVisible(): boolean; subscribe(listener: () => void): () => void };
+  /**
+   * The session the sources read news with. Its key changes when what the
+   * service answers changes: a session restored at launch, a sign-in or
+   * sign-out, an upgrade. Every open query is then read again and its stories
+   * replaced, so a feed read without the session is not left on screen.
+   */
+  session?: NewsSessionSignal;
+}
+
+export interface NewsSessionSignal {
+  key(): string;
+  subscribe(listener: () => void): () => void;
 }
 
 export type NewsQueryListener = (state: NewsQueryState) => void;
@@ -50,17 +62,30 @@ interface SourceFetchResult {
   failedSourceIds: string[];
   errors: string[];
   nextCursor: string | null;
+  access: NewsAccess | null;
 }
 
 interface NewsQueryEntry {
   query: NewsQuery;
   state: NewsQueryState;
   inFlight: Promise<NewsQueryState> | null;
+  /** The session generation the read in flight went out under. */
+  inFlightGeneration: number;
   loadMoreInFlight: Promise<void> | null;
+  loadMoreGeneration: number;
+  /** The session generation the stories on screen were read under. */
+  generation: number;
   refs: number;
   lastAccessedAt: number;
 }
 
+/** Held back beats live: one source the service held back is enough to say the list is not the live wire. */
+function combineNewsAccess(values: ReadonlyArray<NewsAccess | null | undefined>): NewsAccess | null {
+  if (values.includes("delayed")) return "delayed";
+  if (values.includes("realtime")) return "realtime";
+  return null;
+}
+
 function newsCapabilityPriority(source: NewsCapability): number {
   return source.priority ?? 1000;
 }
@@ -85,6 +110,12 @@ export class NewsService {
   private readonly visibility: NonNullable<NewsServiceOptions["visibility"]>;
   private lastPollAt = 0;
   private unsubscribeVisibility: (() => void) | null = null;
+  private readonly session?: NewsSessionSignal;
+  private sessionKey: string | null = null;
+  /** Bumped when the session changes; a read from an older generation is dropped. */
+  private sessionGeneration = 0;
+  private sessionRefetchQueued = false;
+  private unsubscribeSession: (() => void) | null = null;
 
   constructor(options: NewsServiceOptions = {}) {
     const pollInterval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
@@ -94,6 +125,7 @@ export class NewsService {
     this.now = options.now ?? Date.now;
     this.connectionHealth = options.connectionHealth;
     this.visibility = options.visibility ?? { isVisible: isAppVisible, subscribe: subscribeAppVisibility };
+    this.session = options.session;
   }
 
   register(source: NewsCapability): () => void {
@@ -125,6 +157,10 @@ export class NewsService {
       this.clearPollTimer();
       this.scheduleNextPoll();
     });
+    if (this.session) {
+      this.sessionKey = this.session.key();
+      this.unsubscribeSession = this.session.subscribe(() => this.handleSessionChange());
+    }
     this.scheduleNextPoll();
   }
 
@@ -132,9 +168,46 @@ export class NewsService {
     this.polling = false;
     this.unsubscribeVisibility?.();
     this.unsubscribeVisibility = null;
+    this.unsubscribeSession?.();
+    this.unsubscribeSession = null;
     this.clearPollTimer();
   }
 
+  /**
+   * A new session answers with other news: the live wire once a Pro session
+   * is in place, the held-back one after signing out. Reads still out under
+   * the old session are dropped, open queries are read again and replace
+   * their stories rather than merge into them, and closed ones are forgotten.
+   * A token and its user arrive as separate changes, so the reads wait for
+   * the end of the tick and go out once.
+   */
+  private handleSessionChange(): void {
+    if (!this.session) return;
+    const key = this.session.key();
+    if (key === this.sessionKey) return;
+    this.sessionKey = key;
+    this.sessionGeneration++;
+    if (this.sessionRefetchQueued) return;
+    this.sessionRefetchQueued = true;
+    queueMicrotask(() => {
+      this.sessionRefetchQueued = false;
+      if (!this.polling) return;
+      let dropped = false;
+      for (const [queryKey, entry] of this.queries) {
+        if (entry.refs > 0) continue;
+        this.queries.delete(queryKey);
+        dropped = true;
+      }
+      if (dropped) {
+        this.rebuildArticlePool();
+        this.notify();
+      }
+      for (const entry of this.queries.values()) {
+        void this.refreshQuery(entry.query, true);
+      }
+    });
+  }
+
   private pollInFlight = false;
 
   private clearPollTimer(): void {
@@ -226,6 +299,7 @@ export class NewsService {
       return;
     }
 
+    const generation = this.sessionGeneration;
     const request = (async () => {
       entry.state = { ...entry.state, loadingMore: true };
       this.notify();
@@ -234,6 +308,12 @@ export class NewsService {
           ...normalized,
           cursor: entry.state.nextCursor ?? undefined,
         });
+        // An older page from another session must not join the list the new session read.
+        if (generation !== this.sessionGeneration || entry.generation !== generation) {
+          entry.state = { ...entry.state, loadingMore: false };
+          this.notify();
+          return;
+        }
         entry.state = {
           ...entry.state,
           loadingMore: false,
@@ -253,6 +333,7 @@ export class NewsService {
       }
     })();
     entry.loadMoreInFlight = request;
+    entry.loadMoreGeneration = generation;
     await request;
   }
 
@@ -318,7 +399,9 @@ export class NewsService {
     showLoading: boolean,
   ): Promise<NewsQueryState> {
     const entry = this.getOrCreateQueryEntry(query);
-    if (entry.inFlight) return entry.inFlight;
+    const generation = this.sessionGeneration;
+    // A read that went out under an older session answers for that session: a new one goes out beside it.
+    if (entry.inFlight && entry.inFlightGeneration === generation) return entry.inFlight;
 
     const current = entry.state;
     if (showLoading) {
@@ -333,14 +416,17 @@ export class NewsService {
     const promise = (async () => {
       try {
         const result = await this.fetchFromSources(query);
+        if (generation !== this.sessionGeneration) return this.currentRead(entry);
         if (result.sourceIds.length === 0 && result.failedSourceIds.length > 0) {
           throw new Error("News sources unavailable.");
         }
-        if (entry.loadMoreInFlight) return entry.state;
+        if (entry.loadMoreInFlight && entry.loadMoreGeneration === generation) return entry.state;
         const incoming = filterNewsArticlesForQuery(dedupeNewsArticles(result.articles), query);
+        // Stories read under another session are another feed (held back, or live): the new read replaces them.
+        const sameSession = entry.generation === generation;
         // The stories a coin's fallback found are not the pair's own: once stories are filed under it, they replace them.
-        const existing = incoming.length > 0 && entry.state.articles.length > 0
-          && (incoming[0]!.searchedFor ?? null) !== (entry.state.articles[0]!.searchedFor ?? null)
+        const existing = !sameSession || (incoming.length > 0 && entry.state.articles.length > 0
+          && (incoming[0]!.searchedFor ?? null) !== (entry.state.articles[0]!.searchedFor ?? null))
           ? []
           : entry.state.articles;
         const incomingIds = new Set(incoming.map((article) => article.id));
@@ -363,13 +449,17 @@ export class NewsService {
           sourceIds: result.sourceIds,
           nextCursor: hasOlderPages ? entry.state.nextCursor : result.nextCursor,
           loadingMore: entry.state.loadingMore,
+          // A page that does not say keeps what this session's earlier answer said.
+          access: result.access ?? (sameSession ? entry.state.access ?? null : null),
         };
         entry.state = state;
+        entry.generation = generation;
         entry.lastAccessedAt = this.now();
         this.rebuildArticlePool();
         this.notify();
         return state;
       } catch (error) {
+        if (generation !== this.sessionGeneration) return this.currentRead(entry);
         const state: NewsQueryState = {
           ...current,
           phase: "error",
@@ -380,15 +470,21 @@ export class NewsService {
         this.notify();
         return state;
       } finally {
-        entry.inFlight = null;
+        if (entry.inFlightGeneration === generation) entry.inFlight = null;
         this.pruneInactiveQueries();
       }
     })();
 
     entry.inFlight = promise;
+    entry.inFlightGeneration = generation;
     return promise;
   }
 
+  /** What a dropped read answers its caller: the current session's read when one is out, else the state as it is. */
+  private currentRead(entry: NewsQueryEntry): Promise<NewsQueryState> | NewsQueryState {
+    return entry.inFlight && entry.inFlightGeneration === this.sessionGeneration ? entry.inFlight : entry.state;
+  }
+
   private getOrCreateQueryEntry(query: NewsQuery): NewsQueryEntry {
     const key = buildNewsQueryKey(query);
     const now = this.now();
@@ -402,7 +498,10 @@ export class NewsService {
       query,
       state: createIdleNewsQueryState(),
       inFlight: null,
+      inFlightGeneration: this.sessionGeneration,
       loadMoreInFlight: null,
+      loadMoreGeneration: this.sessionGeneration,
+      generation: this.sessionGeneration,
       refs: 0,
       lastAccessedAt: now,
     };
@@ -451,7 +550,7 @@ export class NewsService {
   private async readSourcePage(
     source: NewsCapability,
     query: NewsQuery,
-  ): Promise<{ articles: NewsArticle[]; nextCursor: string | null; error?: string | null }> {
+  ): Promise<{ articles: NewsArticle[]; nextCursor: string | null; error?: string | null; access?: NewsAccess | null }> {
     if (source.provider.fetchNewsPage) {
       const page = await this.trackSourceRequest(
         source,
@@ -462,6 +561,7 @@ export class NewsService {
         articles: page.articles.map((article) => markDetailCapableArticle(source, article)),
         nextCursor: page.nextCursor ?? null,
         error: page.error,
+        access: page.access,
       };
     }
     const articles = (await this.trackSourceRequest(
@@ -484,6 +584,7 @@ export class NewsService {
           failedSourceIds,
           errors: page.error ? [page.error] : [],
           nextCursor: page.nextCursor,
+          access: page.access ?? null,
         };
         if (page.articles.length > 0) return result;
         firstEmpty ??= result;
@@ -491,7 +592,7 @@ export class NewsService {
         failedSourceIds.push(newsCapabilitySourceId(source));
       }
     }
-    return firstEmpty ?? { articles: [], sourceIds: [], failedSourceIds, errors: [], nextCursor: null };
+    return firstEmpty ?? { articles: [], sourceIds: [], failedSourceIds, errors: [], nextCursor: null, access: null };
   }
 
   private async fetchMergedNews(query: NewsQuery, sources: NewsCapability[]): Promise<SourceFetchResult> {
@@ -505,6 +606,7 @@ export class NewsService {
     const errors: string[] = [];
     const sourceIds: string[] = [];
     const failedSourceIds: string[] = [];
+    const access: Array<NewsAccess | null | undefined> = [];
     let nextCursor: string | null = null;
     settled.forEach((result, index) => {
       if (result.status !== "fulfilled") {
@@ -515,9 +617,10 @@ export class NewsService {
       articles.push(...result.value.page.articles);
       if (result.value.page.error) errors.push(result.value.page.error);
       sourceIds.push(newsCapabilitySourceId(result.value.source));
+      access.push(result.value.page.access);
       nextCursor ??= result.value.page.nextCursor;
     });
-    return { articles, sourceIds, failedSourceIds, errors, nextCursor };
+    return { articles, sourceIds, failedSourceIds, errors, nextCursor, access: combineNewsAccess(access) };
   }
 
   private trackSourceRequest<T>(
@@ -550,6 +653,7 @@ export class NewsService {
         sourceIds: [...new Set([...entry.state.sourceIds, newsCapabilitySourceId(source)])],
         nextCursor: entry.state.nextCursor,
         loadingMore: false,
+        access: entry.state.access ?? null,
       };
       changed = true;
     }

package/src/news/cloud-session.ts

@@ -0,0 +1,21 @@
+import { apiClient } from "../api-client";
+import { hasProAccess } from "../api-client/plan-rules";
+import type { NewsSessionSignal } from "./aggregator";
+
+/**
+ * What decides which news Gloom Cloud answers with: whether requests carry a
+ * session, whose it is, and whether that account has real-time news. Changes
+ * when the session is restored at launch, on sign-in and sign-out, and when
+ * the plan changes.
+ */
+export const cloudNewsSession: NewsSessionSignal = {
+  key() {
+    const user = apiClient.getCurrentUser();
+    return [
+      apiClient.hasSessionCredential() ? "session" : "none",
+      user?.id ?? "",
+      hasProAccess(user) ? "realtime" : "delayed",
+    ].join(":");
+  },
+  subscribe: (listener) => apiClient.subscribeCurrentUser(listener),
+};

package/src/news/hooks.ts

@@ -22,6 +22,7 @@ const IDLE_NEWS_QUERY_STATE: NewsQueryState = {
   sourceIds: [],
   nextCursor: null,
   loadingMore: false,
+  access: null,
 };
 
 export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryState {

package/src/news/news-model.ts

@@ -92,6 +92,7 @@ export function createIdleNewsQueryState(): NewsQueryState {
     sourceIds: [],
     nextCursor: null,
     loadingMore: false,
+    access: null,
   };
 }
 

package/src/news/types.ts

@@ -81,11 +81,20 @@ export interface NewsQuery {
 
 type NewsQueryPhase = "idle" | "loading" | "ready" | "refreshing" | "error";
 
+/**
+ * Which news a source answered with: the live wire, or the one held back for
+ * an account without real-time news. Read from the answer itself, never from
+ * the plan the app remembers.
+ */
+export type NewsAccess = "realtime" | "delayed";
+
 export interface NewsPage {
   /** Active source failure, including a partial failure with usable articles. */
   error?: string | null;
   articles: NewsArticle[];
   nextCursor?: string | null;
+  /** Which news the source answered with; null or absent when the answer does not say. */
+  access?: NewsAccess | null;
 }
 
 export interface NewsQueryState {
@@ -96,4 +105,6 @@ export interface NewsQueryState {
   sourceIds: string[];
   nextCursor: string | null;
   loadingMore: boolean;
+  /** Which news the stories are, from the last answer; null or absent when it did not say. */
+  access?: NewsAccess | null;
 }

package/src/notifications/notification-log.ts

@@ -6,22 +6,24 @@ export const NOTIFICATION_LOG_LIMIT = 300;
 
 /**
  * The notices worth finding again after their toast is gone: a price alert or
- * a catalyst that fired, a high-impact economic print, and a team card. Chat
+ * a catalyst that fired, a high-impact economic print, a team card, and new
+ * matches of a live scan with its alerts on. Chat
  * keeps its own unread state on the account, and plain info, success and
  * error toasts are not logged.
  */
-export type MissedNoticeKind = "price" | "catalyst" | "econ" | "team";
+export type MissedNoticeKind = "price" | "catalyst" | "econ" | "team" | "scan";
 
 const KIND_PREFIXES: ReadonlyArray<readonly [MissedNoticeKind, string]> = [
   ["price", "price:"],
   ["catalyst", "catalyst:"],
   ["econ", "econ:"],
   ["team", "team:"],
+  ["scan", "scan:"],
 ];
 
 export interface NotificationLogEntry {
   id: string;
-  /** `price:<alertId>`, `catalyst:<eventId>`, `econ:<eventId>` or `team:<cardId>`. A later notice with the same ref updates this row. */
+  /** `price:<alertId>`, `catalyst:<eventId>`, `econ:<eventId>`, `team:<cardId>` or `scan:<paneId>`. A later notice with the same ref updates this row. */
   refId: string;
   title?: string;
   body: string;
@@ -137,7 +139,7 @@ export function unreadNotificationLogCount(log: readonly NotificationLogEntry[]
 
 /**
  * Records a notice whose `refId` names a price alert, a catalyst, an economic
- * release or a team card; anything else returns null and is not kept. The same ref replaces its
+ * release, a team card or a live scan; anything else returns null and is not kept. The same ref replaces its
  * row: a price alert that fires again is new and unread again.
  */
 export function appendNotificationLog(

package/src/plugins/builtin/alerts/alert-engine.ts

@@ -1,4 +1,7 @@
+import { metricDescription, readAlertMetric, validMetricRule } from "./metric-model";
 import type { AlertCondition, AlertRule } from "./types";
+import { alertListing } from "./format";
+import { canonicalExchange } from "../../../utils/exchanges";
 import { logFailure } from "../../../utils/log-failure";
 
 export type { AlertRule };
@@ -32,16 +35,21 @@ export function editAlert(
   targetPrice: number,
 ): AlertRule {
   const nextSymbol = symbol.trim().toUpperCase();
+  const sameListing = nextSymbol === alert.symbol.trim().toUpperCase();
   return {
     id: alert.id,
     symbol: nextSymbol,
-    exchange: nextSymbol === alert.symbol.trim().toUpperCase() ? alert.exchange : undefined,
+    exchange: sameListing ? alert.exchange : undefined,
+    // The listing's currency and venue stay with it; a new symbol learns its own at its first check.
+    ...(sameListing && alert.lastQuoteCurrency ? { lastQuoteCurrency: alert.lastQuoteCurrency } : {}),
+    ...(sameListing && alert.lastQuoteExchange ? { lastQuoteExchange: alert.lastQuoteExchange } : {}),
     condition,
     targetPrice,
     createdAt: alert.createdAt,
     armedAt: Date.now(),
     status: "active",
     message: alert.message,
+    ...(alert.metric ? { metric: alert.metric } : {}),
   };
 }
 
@@ -49,8 +57,21 @@ export function rearmAlert(alert: AlertRule): AlertRule {
   return editAlert(alert, alert.symbol, alert.condition, alert.targetPrice);
 }
 
+/**
+ * Whether two level alerts are one rule: the same measure, condition and
+ * target on the same listing, whether it was named with its exchange or read
+ * from the symbol alone. A second add of one names the first and adds nothing.
+ */
+export function sameLevelRule(a: AlertRule, b: AlertRule): boolean {
+  const venue = (alert: AlertRule) => canonicalExchange(alert.exchange ?? "");
+  return a.symbol.toUpperCase() === b.symbol.toUpperCase()
+    && (venue(a) === venue(b) || alertListing(a) === alertListing(b))
+    && a.condition === b.condition && a.targetPrice === b.targetPrice
+    && JSON.stringify(readAlertMetric(a.metric)) === JSON.stringify(readAlertMetric(b.metric));
+}
+
 export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
-  if (alert.status !== "active") return false;
+  if (alert.metric || alert.status !== "active") return false;
 
   switch (alert.condition) {
     case "above":
@@ -69,6 +90,7 @@ export function evaluateAlert(alert: AlertRule, currentPrice: number): boolean {
 }
 
 export function formatAlertDescription(alert: AlertRule): string {
+  if (alert.metric) return metricDescription(alert);
   const prefix = alert.condition === "above" ? ">"
     : alert.condition === "below" ? "<" : "↕";
   return `${alert.symbol} ${prefix} ${alert.targetPrice}`;
@@ -94,6 +116,7 @@ function readAlerts(json: unknown): { alerts: AlertRule[]; error: string | null
       a != null && typeof a.id === "string" && !!a.id && typeof a.symbol === "string" && !!a.symbol
       && typeof a.condition === "string" && !!a.condition && typeof a.targetPrice === "number"
       && (a.exchange == null || typeof a.exchange === "string")
+      && (a.metric == null || (readAlertMetric(a.metric) != null && validMetricRule(a)))
     ));
     return {
       alerts,

package/src/plugins/builtin/alerts/alert-log.ts

@@ -0,0 +1,33 @@
+import { metricDescription } from "./metric-model";
+import { eventAlertTarget, type EventAlertRule } from "./events";
+import { alertChangeEntry, appendFiredAlert, readFiredAlerts, type AlertLogAction, type FiredAlert } from "./fired-log";
+import { alertListing } from "./format";
+import { isResearchAlertKind, readResearchRule } from "./research-rules";
+import { readScheduledRule, scheduledEventName } from "./scheduled";
+import type { AlertRule } from "./types";
+
+/**
+ * A rule as the alert log names it: its kind, the rule in words (`EWG:ARCA
+ * below 40`, as a fired price alert reads) and the symbol it follows.
+ */
+export function alertLogRule(rule: AlertRule | EventAlertRule) {
+  if ("symbol" in rule) {
+    return {
+      kind: rule.metric?.kind ?? "price", ruleId: rule.id,
+      rule: rule.metric ? metricDescription(rule) : `${alertListing(rule)} ${rule.condition} ${rule.targetPrice}`,
+      symbol: rule.symbol, ...rule.exchange ? { exchange: rule.exchange } : {},
+    };
+  }
+  const scheduled = readScheduledRule(rule);
+  const symbol = scheduled?.target.kind === "earnings" ? scheduled.target.symbol
+    : isResearchAlertKind(rule.kind) ? readResearchRule(rule.kind, rule.value)?.symbol : undefined;
+  return {
+    kind: rule.kind, ruleId: rule.id, rule: scheduled ? scheduledEventName(scheduled.target) : eventAlertTarget(rule),
+    ...symbol ? { symbol } : {},
+  };
+}
+
+/** The saved log with one change more: what the pane's `usePluginState(FIRED_LOG_KEY)` setter takes. */
+export function withAlertChange(saved: unknown, action: AlertLogAction, rule: AlertRule | EventAlertRule, at = Date.now()): FiredAlert[] {
+  return appendFiredAlert(readFiredAlerts(saved), alertChangeEntry(action, alertLogRule(rule), at));
+}

package/src/plugins/builtin/alerts/calendar-events.ts

@@ -5,6 +5,7 @@
 // two cases of the same alert, whose dates come from their own calendars.
 import { dateKey, eventCountry, matchesCountry, type CountryFilter } from "../econ/calendar-model";
 import { isAllDayEvent, hasNoReleaseTime, type EconEvent, type EconImpact } from "../econ/types";
+import { RENAMED_RELEASES } from "../shared/macro-releases";
 import { MACRO_EVENT_NAMES } from "./research-builder";
 import type { MacroAlertEvent } from "./research-rules";
 
@@ -52,6 +53,39 @@ export function calendarNameWords(name: string): string[] {
 
 const nameKey = (name: string) => calendarNameWords(name).join(" ");
 
+/** A release series' former name a typed name used, read as its current one. */
+export interface ReleaseRename {
+  former: string;
+  current: string;
+  since: string;
+}
+
+/**
+ * A name's words with a renamed series' former name put as its current one
+ * (`caixin pmi` as `ratingdog pmi`), and the rename; null for a name that
+ * carries none.
+ */
+function withCurrentName(words: readonly string[]): { words: string[]; rename: ReleaseRename } | null {
+  for (const { former, current, since } of RENAMED_RELEASES) {
+    for (const name of former) {
+      const old = calendarNameWords(name);
+      for (let at = 0; at + old.length <= words.length; at += 1) {
+        if (!old.every((word, index) => words[at + index] === word)) continue;
+        return {
+          words: [...words.slice(0, at), ...calendarNameWords(current), ...words.slice(at + old.length)],
+          rename: { former: name, current, since },
+        };
+      }
+    }
+  }
+  return null;
+}
+
+/** "Caixin releases were renamed RatingDog from the August 2025 survey." */
+export function releaseRenameNote({ former, current, since }: ReleaseRename): string {
+  return `${former} releases were renamed ${current} from ${since}.`;
+}
+
 /** The UTC day the calendar lists a row under. */
 const utcDay = (time: number) => new Date(time).toISOString().slice(0, 10);
 
@@ -121,13 +155,17 @@ function calendarChoices(events: readonly EconEvent[], now: number): RankedChoic
 }
 
 /** What a typed release names in the calendar. */
-export type CalendarEventMatch =
+export type CalendarEventMatch = (
   /** One release, the best of those the words name, and the others they name in the same country. */
   | { kind: "match"; choice: CalendarEventChoice; others: CalendarEventChoice[] }
   /** The words name releases in several countries: the best of each. */
   | { kind: "countries"; choices: CalendarEventChoice[] }
   /** Nothing the words name; the nearest names, best first. */
-  | { kind: "none"; suggestions: CalendarEventChoice[] };
+  | { kind: "none"; suggestions: CalendarEventChoice[] }
+) & {
+  /** The former name the words used, read as the series' current one (`Caixin PMI` as RatingDog's). */
+  renamed?: ReleaseRename;
+};
 
 /** Character pairs of a name, for how near a slip is to it. */
 function pairs(text: string): Map<string, number> {
@@ -186,7 +224,8 @@ function oneSlipApart(left: string, right: string): boolean {
  * then the closest name and the soonest date, so `NBS PMI` is the headline
  * NBS Manufacturing PMI and an old name listed only in the past never beats
  * the live one. Several countries ask which; no match offers the nearest
- * names.
+ * names. A series' former name reads as its current one (`Caixin PMI` is
+ * RatingDog's), and the match says so.
  */
 export function matchCalendarEvent(
   query: string,
@@ -194,7 +233,18 @@ export function matchCalendarEvent(
   events: readonly EconEvent[],
   now: number,
 ): CalendarEventMatch {
-  const words = calendarNameWords(query);
+  const typedWords = calendarNameWords(query);
+  const current = withCurrentName(typedWords);
+  const match = matchCalendarWords(current?.words ?? typedWords, country, events, now);
+  return current ? { ...match, renamed: current.rename } : match;
+}
+
+function matchCalendarWords(
+  words: readonly string[],
+  country: CountryFilter | null,
+  events: readonly EconEvent[],
+  now: number,
+): CalendarEventMatch {
   const choices = calendarChoices(country ? events.filter((event) => matchesCountry(event, country)) : events, now);
   const exact = choices.filter((choice) => choice.words.join(" ") === words.join(" "));
   const naming = (typed: readonly string[], loose: boolean) => typed.length === 0 ? [] : choices.filter((choice) =>
@@ -266,9 +316,10 @@ function renamedBy(words: readonly string[], other: readonly string[]): number |
  */
 function releaseRows(target: CalendarReleaseTarget, events: readonly EconEvent[]): EconEvent[] {
   const words = calendarNameWords(target.event);
-  const key = words.join(" ");
+  // An alert kept under a series' former name follows the rows under its current one.
+  const keys = new Set([words.join(" "), withCurrentName(words)?.words.join(" ")]);
   const own = events.filter((event) => eventCountry(event) === target.country);
-  const named = own.filter((event) => nameKey(event.event) === key);
+  const named = own.filter((event) => keys.has(nameKey(event.event)));
   if (!target.publisher) return named;
   const namedDays = new Set(named.map((event) => dateKey(event.date)));
   const renamed = own.flatMap((event) => {