gloomberb 0.16.5 → 0.16.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.16.5",
+  "version": "0.16.6",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",
@@ -68,6 +68,7 @@
     "plugins:registry:check": "bun run scripts/check-registry-plugins.ts",
     "web:proxy-hosts": "bun run scripts/generate-web-proxy-hosts.ts",
     "map:data": "bun run scripts/generate-world-map-data.ts",
+    "glyphs:terminal": "bun run scripts/generate-terminal-glyphs.ts",
     "macro-releases:update": "bun run scripts/update-macro-releases.ts",
     "web:proxy-hosts:check": "bun run scripts/generate-web-proxy-hosts.ts --check",
     "typecheck": "bun run typecheck:opentui && bun run typecheck:dom && bun run typecheck:cloudflare && bun run typecheck:scripts && bun run typecheck:plugin-tests",

package/src/api-client/central-bank-rates.ts

@@ -29,7 +29,12 @@ export interface CentralBankRow {
   /** When the bank's own site last showed the same level as a lagging BIS observation. */
   confirmedAt?: string | null
   confirmationSourceUrl?: string | null
-  nextMeeting: { date: string; sourceUrl: string; verifiedAt: string } | null
+  /** The bank's next decision from its own published calendar, or China's next 1-year LPR fixing (`kind`). */
+  nextMeeting: { date: string; sourceUrl: string; verifiedAt: string; kind?: "decision" | "fixing" } | null
+  /** Why `nextMeeting` is null; older servers leave it out, and a null meeting then reads as not published. */
+  nextMeetingStatus?: "scheduled" | "not-published" | "not-verified" | "no-policy-rate"
+  /** The BIS series definition and breaks, also in `notes`: history a citation of the latest rate leaves out. */
+  seriesNotes?: string[]
 }
 
 export interface CentralBankRatesPayload {

package/src/api-client/chat.ts

@@ -4,6 +4,7 @@ import {
   normalizeChatDiscordLink,
   normalizeChatMessage,
   normalizeChatMessages,
+  normalizeChatReactions,
   normalizeChatState,
 } from "./normalizers";
 import { CHAT_ATTACHMENTS_FEATURE, type CloudApiSocket } from "./socket";
@@ -14,6 +15,7 @@ import type {
   ChatDiscordLink,
   ChatMessage,
   ChatNotification,
+  ChatReactionsUpdate,
   ChatStateResponse,
 } from "./types";
 import type { CloudApiRequest } from "./request";
@@ -258,6 +260,30 @@ export class CloudChatApi {
     return normalizeChatMessage(message);
   }
 
+  /**
+   * Sets your reaction with one emoji on a message; setting what is already
+   * there changes nothing. Answers the message's reactions as they stand.
+   */
+  async setReaction(
+    channelId: string,
+    messageId: string,
+    emoji: string,
+    reacted: boolean,
+  ): Promise<ChatReactionsUpdate> {
+    const answer = await this.request<{ reactions?: unknown }>(
+      `/chat/channels/${channelId}/messages/${messageId}/reactions`,
+      {
+        method: "PUT",
+        body: JSON.stringify({ emoji, reacted }),
+      },
+    );
+    return { channelId, messageId, reactions: normalizeChatReactions(answer?.reactions) };
+  }
+
+  subscribeReactions(listener: (update: ChatReactionsUpdate) => void): () => void {
+    return this.options.socket.subscribeChatReactions(listener);
+  }
+
   /** Whether this account is tied to a Discord person. Throws a 404 or 501 `ApiRequestError` on a server without Discord sync. */
   async getDiscordLink(): Promise<ChatDiscordLink> {
     return normalizeChatDiscordLink(await this.options.request<unknown>("/chat/discord/link"));

package/src/api-client/credit-boards.ts

@@ -27,6 +27,8 @@ export interface CdxBoardIndex {
   /** In the quote's unit, on one contract across a roll. */
   change1D: number | null;
   change1W: number | null;
+  /** Absent from a server that predates it. */
+  change1M?: number | null;
   /** Oldest first, the on-the-run 5Y contract each day. */
   points: CreditBoardPoint[];
 }

package/src/api-client/data.ts

@@ -5,7 +5,8 @@ import type { CatalystResponse, CatalystDetail, CatalystFilters, CatalystStatus,
 import type { KpisPayload, GuidancePayload, KpiQueryOptions } from "./company-kpis";
 import { companyDisclosurePath } from "./company-kpis";
 import type { PowerBoard, PowerDetail, PowerFilter, PowerHistory } from "./power";
-import type { PerpBoardPayload, PerpHistoryPayload, PerpRankingsPayload, PerpBoardQuery, PerpHistoryQuery, PerpMarketPayload } from "./perps";
+import type { PerpBoardPayload, PerpEquitiesPayload, PerpEquityListing, PerpHistoryPayload, PerpRankingsPayload, PerpBoardQuery, PerpHistoryQuery,
+  PerpMarketPayload } from "./perps";
 import type { ExposureRequest, ExposurePayload, ExposureScenario } from "./exposure";
 import type { SupplyChainPayload, SupplyOptions } from "./supply-chain";
 import { supplyGraphQuery, type GraphOptions, type GraphPayload } from "./supply-chain-graph";
@@ -23,6 +24,7 @@ import {
   type InsolvencyNoticesParams,
 } from "./distress";
 import type { IpoCalendarParams, IpoCalendarPayload } from "./ipo";
+import type { TickerChanges } from "../types/ticker-changes";
 import type { CryptoMarketsPayload } from "./crypto-markets";
 import type { CentralBankRatesPayload } from "./central-bank-rates";
 import type { EstimateRevisionsPayload } from "./estimate-revisions";
@@ -35,6 +37,7 @@ import type { SocialMentionDayPosts, SocialMentionsPayload, SocialMentionsRange
 import type { FuturesContractTermsPayload, FuturesCurveAsOfPayload, FuturesCurvePayload } from "./futures-curve";
 import type { CotBoardPayload, CotContractPayload, CotFamily, CotClass } from "./cot";
 import type { DoeBoardPayload } from "./doe";
+import type { CarbonBoard, CarbonHistory, EuropePowerBoard, EuropePowerHistory } from "./europe-energy";
 import type { GpuBoardPayload, GpuEventsPayload, GpuHistoryPayload, GpuHistoryQuery } from "./gpu";
 import type { CpiBoardPayload } from "./cpi";
 import type { TapeSnapshot } from "./tape";
@@ -110,6 +113,7 @@ import type {
   CloudAnalystResearchPayload,
   CloudShortInterestPayload,
   CloudCdsHistoryResponse,
+  CloudCdsLevelsResponse,
   CloudCdsResponse,
   CloudCongressHousePayload,
   CloudEarningsCallListPayload,
@@ -373,6 +377,17 @@ export class CloudDataApi {
     );
   }
 
+  /** Where the issuer that held a US symbol trades now, or what the symbol's holder was called before. */
+  async getCloudTickerChanges(
+    symbol: string,
+    options: { signal?: AbortSignal } = {},
+  ): Promise<CloudMarketResponse<TickerChanges>> {
+    return this.request<CloudMarketResponse<TickerChanges>>(
+      `/market/ticker-changes?${new URLSearchParams({ symbol: symbol.trim().toUpperCase() })}`,
+      options.signal ? { signal: options.signal } : undefined,
+    );
+  }
+
   async getCloudHistory(
     symbol: string,
     exchange: string,
@@ -518,6 +533,9 @@ export class CloudDataApi {
     const query = exchange === undefined ? "" : `?${new URLSearchParams({ identity: "listing", exchange })}`;
     return this.request(`/cloud/perps/equity/${encodeURIComponent(symbol)}${query}`);
   }
+  async getCloudPerpsEquities(listings: readonly PerpEquityListing[]): Promise<PerpEquitiesPayload> {
+    return this.request("/cloud/perps/equities", { method: "POST", body: JSON.stringify({ listings }) });
+  }
   async getCloudPerpsMarket(marketId: string): Promise<PerpMarketPayload> { return this.request(`/cloud/perps/market?${new URLSearchParams({ marketId })}`); }
 
   async analyzeCloudExposure(request: ExposureRequest): Promise<ExposurePayload> {
@@ -577,6 +595,31 @@ export class CloudDataApi {
     return this.request<PowerDetail>(`/cloud/power/projects/${encodeURIComponent(id)}?${params}`, { signal });
   }
 
+  /** European day-ahead power prices by country, latest day first per market. */
+  async getCloudEuropePower(): Promise<EuropePowerBoard> {
+    return this.request<EuropePowerBoard>("/cloud/europe-energy/power", { signal: AbortSignal.timeout(30_000) });
+  }
+
+  /** One market's daily day-ahead prices from `from` (all of them without one), oldest first. */
+  async getCloudEuropePowerHistory(code: string, from?: string | null): Promise<EuropePowerHistory> {
+    const query = from ? `?${new URLSearchParams({ from })}` : "";
+    return this.request<EuropePowerHistory>(
+      `/cloud/europe-energy/power/${encodeURIComponent(code)}/history${query}`,
+      { signal: AbortSignal.timeout(30_000) },
+    );
+  }
+
+  /** The EU carbon allowance (EUA) auction price as of its latest auction day, with the latest auctions. */
+  async getCloudEuropeCarbon(): Promise<CarbonBoard> {
+    return this.request<CarbonBoard>("/cloud/europe-energy/carbon", { signal: AbortSignal.timeout(30_000) });
+  }
+
+  /** The daily EUA auction price from `from` (every auction day since 2020 without one), oldest first. */
+  async getCloudEuropeCarbonHistory(from?: string | null): Promise<CarbonHistory> {
+    const query = from ? `?${new URLSearchParams({ from })}` : "";
+    return this.request<CarbonHistory>(`/cloud/europe-energy/carbon/history${query}`, { signal: AbortSignal.timeout(30_000) });
+  }
+
   async getCloudGpuBoard(): Promise<GpuBoardPayload> {
     return this.request<GpuBoardPayload>("/cloud/gpu/board");
   }
@@ -735,6 +778,11 @@ export class CloudDataApi {
     return this.request<CloudCdsHistoryResponse>(cloudCdsHistoryPath(params), { signal: AbortSignal.timeout(30_000) });
   }
 
+  /** Every listed issuer's latest 5Y level in one request. */
+  async getCloudCdsLevels(): Promise<CloudCdsLevelsResponse> {
+    return this.request<CloudCdsLevelsResponse>("/cloud/credit/cds/levels", { signal: AbortSignal.timeout(30_000) });
+  }
+
   async getCloudCdxBoard(params: CloudCreditBoardParams = {}): Promise<CdxBoardPayload> {
     return this.request<CdxBoardPayload>(cloudCreditBoardPath("cdx", params), { signal: AbortSignal.timeout(30_000) });
   }

package/src/api-client/europe-energy.ts

@@ -0,0 +1,106 @@
+/** Who publishes the prices; their licence asks for this attribution. */
+interface EuropeEnergySource {
+  name: string;
+  licence: string;
+  url: string;
+}
+
+/** One market's latest day-ahead price and its context, all as of `date`. */
+export interface PowerPriceRow {
+  /** ISO 3166 alpha-2: DE, FR, GB. */
+  code: string;
+  name: string;
+  /** Latest delivery day with a price. */
+  date: string | null;
+  /** EUR/MWh, the day's load-weighted average of the day-ahead auction. */
+  price: number | null;
+  previousDate: string | null;
+  change: number | null;
+  average7: number | null;
+  average30: number | null;
+  yearAgoDate: string | null;
+  yearAgo: number | null;
+  low52w: number | null;
+  high52w: number | null;
+  /** Weekly means over the year to `date`, oldest first. */
+  trail: Array<{ date: string; value: number }>;
+}
+
+export interface EuropePowerBoard {
+  generatedAt: string;
+  status: "available" | "unavailable";
+  market: "day-ahead";
+  unit: "EUR/MWh";
+  source: EuropeEnergySource;
+  /** When the published file was last read, and when its publisher last changed it. */
+  checkedAt: string | null;
+  publishedAt: string | null;
+  gaps: string[];
+  rows: PowerPriceRow[];
+}
+
+export interface EuropePowerHistory {
+  code: string;
+  name: string;
+  market: "day-ahead";
+  unit: "EUR/MWh";
+  source: EuropeEnergySource;
+  /** Oldest first. */
+  points: Array<{ date: string; value: number }>;
+}
+
+/** One EU ETS primary-market auction. Prices in EUR/tCO2, volumes in tCO2. */
+interface CarbonAuction {
+  date: string;
+  auction: string;
+  contract: string;
+  /** successful, cancelled. */
+  status: string;
+  /** EU (common platform), DE, PL, XI (Northern Ireland). */
+  zone: string | null;
+  /** Null when the auction did not clear. */
+  price: number | null;
+  minBid: number | null;
+  maxBid: number | null;
+  meanBid: number | null;
+  medianBid: number | null;
+  volume: number;
+  coverRatio: number | null;
+  bidders: number | null;
+  successfulBidders: number | null;
+  /** An aviation allowance (EUAA) auction, which is not the EUA price. */
+  aviation: boolean;
+}
+
+/** The EUA price as of its latest auction day: the day's cleared auctions, volume-weighted. */
+interface CarbonPriceRow extends Omit<PowerPriceRow, "code"> {
+  code: "EUA";
+  /** tCO2 auctioned that day, and in how many auctions. */
+  volume: number | null;
+  auctions: number | null;
+}
+
+export interface CarbonBoard {
+  generatedAt: string;
+  status: "available" | "unavailable";
+  /** The primary auction clearing price, not a futures settlement. */
+  market: "primary auction";
+  unit: "EUR/tCO2";
+  source: { name: string; url: string };
+  checkedAt: string | null;
+  publishedAt: string | null;
+  gaps: string[];
+  row: CarbonPriceRow;
+  /** Newest first. */
+  auctions: CarbonAuction[];
+}
+
+export interface CarbonHistory {
+  code: "EUA";
+  name: string;
+  market: "primary auction";
+  unit: "EUR/tCO2";
+  source: { name: string; url: string };
+  /** Each auction day's price, oldest first. */
+  points: Array<{ date: string; value: number }>;
+}

package/src/api-client/index.ts

@@ -643,6 +643,8 @@ class GloomApiClient {
   chatAttachmentsSupported = this.chat.attachmentsSupported.bind(this.chat);
   subscribeChatAttachmentSupport = this.chat.subscribeAttachmentSupport.bind(this.chat);
   editMessage = this.chat.editMessage.bind(this.chat);
+  setChatReaction = this.chat.setReaction.bind(this.chat);
+  subscribeChatReactions = this.chat.subscribeReactions.bind(this.chat);
   connectChannel = this.chat.connectChannel.bind(this.chat);
   subscribeChatNotifications = this.chat.subscribeNotifications.bind(this.chat);
   subscribeChatPresence = this.chat.subscribePresence.bind(this.chat);
@@ -738,6 +740,7 @@ class GloomApiClient {
   getCloudShortInterest = this.data.getCloudShortInterest.bind(this.data);
   getCloudAnalystResearch = this.data.getCloudAnalystResearch.bind(this.data);
   getCloudCorporateActions = this.data.getCloudCorporateActions.bind(this.data);
+  getCloudTickerChanges = this.data.getCloudTickerChanges.bind(this.data);
   getCloudHistory = this.data.getCloudHistory.bind(this.data);
   getCloudExchangeRate = this.data.getCloudExchangeRate.bind(this.data);
   getCloudEconomicCalendar = this.data.getCloudEconomicCalendar.bind(this.data);
@@ -796,6 +799,7 @@ class GloomApiClient {
   getCloudPerpsRankings = this.data.getCloudPerpsRankings.bind(this.data);
   getCloudPerpsCompare = this.data.getCloudPerpsCompare.bind(this.data);
   getCloudPerpsEquity = this.data.getCloudPerpsEquity.bind(this.data);
+  getCloudPerpsEquities = this.data.getCloudPerpsEquities.bind(this.data);
   getCloudPerpsMarket = this.data.getCloudPerpsMarket.bind(this.data);
   analyzeCloudExposure = this.data.analyzeCloudExposure.bind(this.data);
   getCloudExposureScenarios = this.data.getCloudExposureScenarios.bind(this.data);
@@ -809,6 +813,10 @@ class GloomApiClient {
   getCloudPowerBoard = this.data.getCloudPowerBoard.bind(this.data);
   getCloudPowerHistory = this.data.getCloudPowerHistory.bind(this.data);
   getCloudPowerProject = this.data.getCloudPowerProject.bind(this.data);
+  getCloudEuropePower = this.data.getCloudEuropePower.bind(this.data);
+  getCloudEuropePowerHistory = this.data.getCloudEuropePowerHistory.bind(this.data);
+  getCloudEuropeCarbon = this.data.getCloudEuropeCarbon.bind(this.data);
+  getCloudEuropeCarbonHistory = this.data.getCloudEuropeCarbonHistory.bind(this.data);
   getCloudGpuBoard = this.data.getCloudGpuBoard.bind(this.data);
   getCloudGpuHistory = this.data.getCloudGpuHistory.bind(this.data);
   getCloudGpuEvents = this.data.getCloudGpuEvents.bind(this.data);
@@ -820,6 +828,7 @@ class GloomApiClient {
   getCloudWorldCurves = this.data.getCloudWorldCurves.bind(this.data);
   getCloudCds = this.data.getCloudCds.bind(this.data);
   getCloudCdsHistory = this.data.getCloudCdsHistory.bind(this.data);
+  getCloudCdsLevels = this.data.getCloudCdsLevels.bind(this.data);
   getCloudCdxBoard = this.data.getCloudCdxBoard.bind(this.data);
   getCloudSovrBoard = this.data.getCloudSovrBoard.bind(this.data);
   getCloudCongressHouse = this.data.getCloudCongressHouse.bind(this.data);

package/src/api-client/market-discovery.ts

@@ -86,7 +86,10 @@ export interface MarketMoversPayload {
 export interface DividendSummary {
   trailingAnnualDividendRate: number | null;
   trailingAnnualDividendYield: number | null;
+  /** The indicated annual rate fundamentals serve: the latest regular distribution annualized. */
   forwardAnnualDividendRate: number | null;
+  /** The ex-date of the distribution that rate annualizes, YYYY-MM-DD. */
+  forwardRateAsOf?: string | null;
   payoutRatio: number | null;
   exDividendDate: number | null;
   dividendDate: number | null;

package/src/api-client/normalizers.ts

@@ -6,6 +6,8 @@ import type {
   ChatMessage,
   ChatMessageOrigin,
   ChatNotification,
+  ChatReaction,
+  ChatReactionUser,
   ChatStateResponse,
   CloudSavedSearch,
   CloudSearchHit,
@@ -98,6 +100,7 @@ export function normalizeChatMessage(message: ChatMessage): ChatMessage {
       : {}),
   };
   if ("attachments" in message) normalized.attachments = normalizeChatAttachments(message.attachments);
+  if ("reactions" in message) normalized.reactions = normalizeChatReactions(message.reactions);
   if (message.origin !== undefined && !CHAT_MESSAGE_ORIGINS.includes(message.origin)) delete normalized.origin;
   if (message.attachmentReview !== "pending" && message.attachmentReview !== "failed") {
     delete normalized.attachmentReview;
@@ -117,6 +120,35 @@ export function normalizeChatDiscordLink(value: unknown): ChatDiscordLink {
   };
 }
 
+/** Reactions as the server sent them, dropping anything malformed. */
+export function normalizeChatReactions(value: unknown): ChatReaction[] {
+  if (!Array.isArray(value)) return [];
+  const reactions: ChatReaction[] = [];
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") continue;
+    const raw = entry as Record<string, unknown>;
+    if (typeof raw.emoji !== "string" || !raw.emoji) continue;
+    const count = typeof raw.count === "number" && Number.isFinite(raw.count) ? Math.max(0, Math.floor(raw.count)) : 0;
+    if (count === 0) continue;
+    const users = Array.isArray(raw.users)
+      ? raw.users.flatMap((user): ChatReactionUser[] => {
+        if (!user || typeof user !== "object") return [];
+        const candidate = user as Record<string, unknown>;
+        if (typeof candidate.id !== "string") return [];
+        const accountType = candidate.accountType;
+        return [{
+          id: candidate.id,
+          username: typeof candidate.username === "string" ? candidate.username : null,
+          displayName: typeof candidate.displayName === "string" ? candidate.displayName : "User",
+          ...(accountType === "human" || accountType === "managed_llm" || accountType === "discord" ? { accountType } : {}),
+        }];
+      })
+      : [];
+    reactions.push({ emoji: raw.emoji, count, me: raw.me === true, users });
+  }
+  return reactions;
+}
+
 export function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }

package/src/api-client/perps.ts

@@ -147,6 +147,14 @@ export interface PerpBoardPayload {
   access: "pro" | "preview"; sources?: unknown[];
 }
 export interface PerpEquityListing { symbol: string; exchange: string }
+/**
+ * The batch lookup a watchlist or portfolio makes: one entry per requested listing, in its order, with the contract
+ * the single equity lookup would list first, or none. `listing` is null when the server cannot read the listing.
+ */
+export interface PerpEquitiesPayload {
+  status: string; asOf: string | null; access: "pro" | "preview"; locked: number;
+  results: { listing: PerpEquityListing | null; market: PerpBoardRow | null }[];
+}
 export interface PerpHistoryPayload {
   status: string; marketId: string; rows: PerpHistoryPoint[]; funding: PerpFunding[]; candles: PerpCandle[];
   /** Absent from servers older than the long/short series: read as empty. */

package/src/api-client/request.ts

@@ -408,8 +408,15 @@ export class CloudApiRequestTransport {
     // Crash reports, usage counts and command-search reports are background
     // traffic: a rate-limited, timed-out or missing one must not show up as a
     // Cloud outage in the connections pane. Nor must the map's probe for geo
-    // layers, which a server without them answers with 404.
-    if (path.startsWith("/telemetry/") || path === "/assist/searches" || path === "/cloud/geo/layers") return request();
+    // layers, which a server without them answers with 404, or a ticker
+    // change lookup: a note beside a quote, never one of the refused market
+    // requests a lookup of many symbols waits out and retries.
+    if (
+      path.startsWith("/telemetry/")
+      || path === "/assist/searches"
+      || path === "/cloud/geo/layers"
+      || path.startsWith("/market/ticker-changes?")
+    ) return request();
     return this.connectionHealth.track(
       GLOOM_CLOUD_HTTP_CONNECTION_ID,
       operation,

package/src/api-client/socket.ts

@@ -3,6 +3,7 @@ import type {
   AuthUser,
   ChatMessage,
   ChatNotification,
+  ChatReactionsUpdate,
   CloudQuotePayload,
   QuoteStreamTarget,
   ScannerFeedEvent,
@@ -12,6 +13,7 @@ import type {
 import {
   normalizeChatMessage,
   normalizeChatNotification,
+  normalizeChatReactions,
   normalizeTeamNotification,
 } from "./normalizers";
 import { debugLog } from "../utils/debug-log";
@@ -41,6 +43,7 @@ const cloudApiLog = debugLog.createLogger("cloud-api");
 type ChannelListener = (message: ChatMessage) => void;
 type ChatNotificationListener = (notification: ChatNotification) => void;
 type ChatPresenceListener = (onlineCount: number) => void;
+type ChatReactionsListener = (update: ChatReactionsUpdate) => void;
 type TeamNotificationListener = (notification: TeamNotification) => void;
 type CloudEventListener = (data: unknown) => void;
 type QuoteListener = (
@@ -106,6 +109,7 @@ export class CloudApiSocket {
   private readonly chatNotificationListeners =
     new Set<ChatNotificationListener>();
   private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
+  private readonly chatReactionsListeners = new Set<ChatReactionsListener>();
   private readonly teamNotificationListeners =
     new Set<TeamNotificationListener>();
   private readonly cloudEventListeners = new Map<
@@ -245,6 +249,14 @@ export class CloudApiSocket {
     };
   }
 
+  /** A message's reactions changed in a channel this socket reads. */
+  subscribeChatReactions(listener: ChatReactionsListener): () => void {
+    this.chatReactionsListeners.add(listener);
+    return () => {
+      this.chatReactionsListeners.delete(listener);
+    };
+  }
+
   subscribeChatPresence(listener: ChatPresenceListener): () => void {
     this.chatPresenceListeners.add(listener);
     return () => {
@@ -500,6 +512,7 @@ export class CloudApiSocket {
     this.connectionListeners.clear();
     this.chatNotificationListeners.clear();
     this.chatPresenceListeners.clear();
+    this.chatReactionsListeners.clear();
     this.teamNotificationListeners.clear();
     this.cloudEventListeners.clear();
     this.quoteSubscriptions.clear();
@@ -575,6 +588,22 @@ export class CloudApiSocket {
       return;
     }
 
+    if (
+      parsed?.type === "chat.reactions" &&
+      typeof parsed.channelId === "string" &&
+      typeof parsed.data?.messageId === "string"
+    ) {
+      const update: ChatReactionsUpdate = {
+        channelId: parsed.channelId,
+        messageId: parsed.data.messageId,
+        reactions: normalizeChatReactions(parsed.data.reactions),
+      };
+      for (const listener of this.chatReactionsListeners) {
+        listener(update);
+      }
+      return;
+    }
+
     if (parsed?.type === "chat.notification" && parsed.data) {
       const notification = normalizeChatNotification(
         parsed.data as ChatNotification,

package/src/api-client/themes.ts

@@ -15,6 +15,12 @@ export interface ThemeSummary {
   worst: { symbol: string; changePercent: number } | null;
   stale: boolean;
 }
+/**
+ * A member's figures. `price`, `changePercent` and the returns are the regular
+ * session's: outside it, its close and that close's move. The extended fields
+ * are the pre-market or after-hours print measured from that close; a server
+ * sends them only when there is one, and older servers never do.
+ */
 export interface ThemeMember extends Record<ThemePeriod | "price", number | null> {
   symbol: string;
   name: string | null;
@@ -22,7 +28,22 @@ export interface ThemeMember extends Record<ThemePeriod | "price", number | null
   present: boolean;
   asOf: Record<ThemePeriod | "price", string | null>;
   stale: boolean;
+  extendedSession?: "PRE" | "POST" | null;
+  extendedPrice?: number | null;
+  extendedChange?: number | null;
+  extendedChangePercent?: number | null;
+}
+interface SnapshotMetadata {
+  /** When the server put the snapshot together, not a trade time. */
+  asOf: string;
+  snapshotId: string;
+  stale: boolean;
+  /** The US market as the server's delayed board reads it. Absent from older servers. */
+  session?: "PRE" | "REGULAR" | "POST" | "CLOSED" | null;
+  /** Outside the regular session, the completed session every figure describes; null while one trades. */
+  regularSessionDate?: string | null;
+  /** When that session closed, in epoch milliseconds (13:00 New York on an early close). */
+  regularSessionClosedAt?: number | null;
 }
-interface SnapshotMetadata { asOf: string; snapshotId: string; stale: boolean }
 export interface ThemesPayload extends SnapshotMetadata { themes: ThemeSummary[] }
 export interface ThemeMembersPayload extends SnapshotMetadata { theme: ThemeSummary; members: ThemeMember[] }

package/src/api-client/types.ts

@@ -49,6 +49,33 @@ export interface ChatAttachment {
   url: string;
 }
 
+/** Someone who reacted, as a reaction lists the first few. */
+export interface ChatReactionUser {
+  id: string;
+  username: string | null;
+  displayName: string;
+  accountType?: ChatAccountType | null;
+}
+
+/**
+ * One emoji on a message: how many reacted, whether you did, and the first
+ * few who did, oldest first. `emoji` is the character, or `:name:` for a
+ * custom Discord server emoji.
+ */
+export interface ChatReaction {
+  emoji: string;
+  count: number;
+  me: boolean;
+  users?: ChatReactionUser[];
+}
+
+/** A message's reactions as they stand after a change, from the `chat.reactions` frame or a reaction request. */
+export interface ChatReactionsUpdate {
+  channelId: string;
+  messageId: string;
+  reactions: ChatReaction[];
+}
+
 export interface ChatMessage {
   id: string;
   channelId: string;
@@ -66,6 +93,12 @@ export interface ChatMessage {
   } | null;
   /** Images in display order. A server that predates them leaves this out. */
   attachments?: ChatAttachment[];
+  /**
+   * Emoji reactions in the order they first appeared. Message lists from a
+   * server that knows reactions always carry it; a live copy of a message
+   * (an edit) leaves it out, and the reactions held stay.
+   */
+  reactions?: ChatReaction[];
   /**
    * Only on the author's copy of a public message whose images are still being
    * checked ("pending") or could not be checked ("failed"). Nobody else has the
@@ -402,6 +435,10 @@ export interface CloudPricePointPayload {
   low?: number;
   close: number;
   volume?: number;
+  /** A coin's daily bar for the UTC day still forming when served; it has no volume yet. */
+  partial?: boolean;
+  /** A coin's daily bar whose prices were rebuilt from hourly bars; a day the source left empty has no volume. */
+  filled?: boolean;
 }
 
 type CloudEconImpact = "high" | "medium" | "low";
@@ -432,6 +469,13 @@ export interface CloudMacroReleaseDaysPayload {
 export interface CloudFredObservationPayload {
   date: string;
   value: number | null;
+  /**
+   * Who published a value FRED does not list yet, such as a Treasury yield
+   * Gloom Cloud read from the Treasury first. Absent on FRED's own values.
+   */
+  publisher?: string;
+  /** When that publisher's value was first read, ISO in UTC. */
+  publishedAt?: string;
 }
 
 export interface CloudFredSeriesInfoPayload {
@@ -538,6 +582,22 @@ export interface CloudCdsHistoryResponse {
   points: CloudCdsHistoryPointPayload[];
 }
 
+/** An issuer's latest 5Y level: the last point of its history over the last month. */
+export interface CloudCdsLevelPayload {
+  /** The reference entity as the history response names it. */
+  issuer: string;
+  spreadBp: number;
+  date: string;
+}
+
+export interface CloudCdsLevelsResponse {
+  source: string;
+  tenor: string;
+  asOf: string | null;
+  /** Every issuer traded in the last month whose 5Y line has a level in it. */
+  levels: CloudCdsLevelPayload[];
+}
+
 interface CloudShortInterestPointPayload {
   settlementDate: string;
   shortPercentFloat?: number | null;
@@ -1098,7 +1158,7 @@ export interface CloudSearchResponse {
   tookMs: number;
 }
 
-export interface CloudSearchDocumentChunk {
+interface CloudSearchDocumentChunk {
   id: string;
   chunkIndex: number;
   body: string;