gloomberb 0.16.3 → 0.16.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.16.3",
+  "version": "0.16.4",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",
@@ -67,6 +67,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",
+    "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",
     "typecheck:opentui": "tsc --project tsconfig.opentui.json",
@@ -79,6 +80,8 @@
     "benchmark:tui:navigation": "bun run scripts/benchmark-tui-navigation.ts",
     "benchmark:tui:compare": "bun run scripts/benchmark-tui-compare.ts",
     "benchmark:tui:memory": "bun run scripts/benchmark-tui-memory.ts",
+    "check:pane-chrome": "bun run scripts/pane-chrome/checks.ts",
+    "benchmark:pane-drag:compare": "bun run scripts/pane-chrome/frame-budget.ts",
     "test:global-upgrade": "bun run scripts/smoke-global-upgrade.ts",
     "release": "./scripts/release.sh"
   },

package/src/api-client/askg.ts

@@ -1,7 +1,10 @@
 import {
   ASKG_PROTOCOL_VERSION,
+  type ASKGCapabilities,
   type ASKGDoneReason,
   type ASKGErrorCode,
+  type ASKGFeedback,
+  type ASKGFeedbackRequest,
   type ASKGSessionStartRequest,
   type ASKGSessionStartResponse,
   type ASKGSseEvent,
@@ -90,10 +93,14 @@ interface ASKGConversationMessage {
   tools: ASKGConversationTool[];
   turnId: string | null;
   createdAt: string;
+  /** On an answer: the person's own rating, null when unrated. */
+  feedback?: ASKGFeedback | null;
 }
 
 export interface ASKGConversationDetail extends ASKGConversationSummary {
   messages: ASKGConversationMessage[];
+  /** `feedback: 1` when this server takes ratings; absent from an older one. */
+  capabilities?: ASKGCapabilities;
 }
 
 export interface ASKGTransport {
@@ -134,6 +141,16 @@ export interface ASKGTransport {
     id: string,
     options?: { signal?: AbortSignal },
   ): Promise<boolean>;
+  /**
+   * Rates one answer and returns the rating as stored. Null when the server
+   * has no answer of this person's under that id, which is also what a
+   * server without the route says.
+   */
+  sendFeedback(
+    turnId: string,
+    request: ASKGFeedbackRequest,
+    options?: { signal?: AbortSignal },
+  ): Promise<ASKGFeedback | null>;
 }
 
 /** One decoded server-sent event frame. */
@@ -662,4 +679,30 @@ export class CloudASKGApi implements ASKGTransport {
       throw classifyASKGRequestError(error);
     }
   }
+
+  async sendFeedback(
+    turnId: string,
+    request: ASKGFeedbackRequest,
+    options: { signal?: AbortSignal } = {},
+  ): Promise<ASKGFeedback | null> {
+    try {
+      const stored = await this.options.request<Partial<ASKGFeedback> | null>(
+        `/askg/turns/${encodeURIComponent(turnId)}/feedback`,
+        {
+          method: "PUT",
+          body: JSON.stringify(request),
+          signal: options.signal,
+        },
+      );
+      // What the server stored, read defensively: the control shows it.
+      return {
+        rating: stored?.rating === "down" ? "down" : stored?.rating === "up" ? "up" : request.rating,
+        reason: stored?.reason ?? null,
+        shared: stored?.shared === true,
+      };
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 404) return null;
+      throw classifyASKGRequestError(error);
+    }
+  }
 }

package/src/api-client/auth.ts

@@ -11,8 +11,10 @@ import type {
   CloudBrowserHandoffResponse,
   CloudPricing,
   CloudVerificationResponse,
+  CreatedMcpKey,
   DeviceAuthStartResponse,
   DeviceAuthTokenResponse,
+  McpKeyScope,
   PersistedAuthUser,
 } from "./types";
 
@@ -269,6 +271,19 @@ export class CloudAuthApi {
     return result.feed;
   }
 
+  /**
+   * Creates an MCP key for an agent, the same call as Cloud settings, Agents.
+   * Needs Pro (402 otherwise) and fails with 409 at the per-account limit. The
+   * token in the answer is never returned again, so callers show it once and
+   * keep it out of logs and storage.
+   */
+  async createMcpKey(input: { name: string; scope: McpKeyScope }): Promise<CreatedMcpKey> {
+    return this.options.request<CreatedMcpKey>("/account/mcp/keys", {
+      method: "POST",
+      body: JSON.stringify({ name: input.name, scope: input.scope }),
+    });
+  }
+
   /** A new calendar feed link; the old one stops working. */
   async rotateCalendarFeed(): Promise<CalendarFeed> {
     const result = await this.options.request<{ feed: CalendarFeed }>(

package/src/api-client/beneficial-owners.ts

@@ -85,6 +85,10 @@ export interface BeneficialOwnersPayload {
 
 export interface CloudBeneficialOwnersParams {
   ticker: string;
+  /** The listing's venue. Sent only for a venue outside the US, with `name`. */
+  exchange?: string;
+  /** The listing's company name, from its ticker or its own quote. */
+  name?: string;
   form?: BeneficialOwnersForm;
   history?: boolean;
   limit?: number;

package/src/api-client/chat.ts

@@ -1,6 +1,7 @@
 import {
   normalizeChatAttachments,
   normalizeChatChannel,
+  normalizeChatDiscordLink,
   normalizeChatMessage,
   normalizeChatMessages,
   normalizeChatState,
@@ -10,6 +11,7 @@ import type {
   ChatAttachment,
   ChatChannel,
   ChatChannelState,
+  ChatDiscordLink,
   ChatMessage,
   ChatNotification,
   ChatStateResponse,
@@ -256,6 +258,23 @@ export class CloudChatApi {
     return normalizeChatMessage(message);
   }
 
+  /** 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"));
+  }
+
+  async unlinkDiscord(): Promise<void> {
+    await this.options.request<unknown>("/chat/discord/link", { method: "DELETE" });
+  }
+
+  /** Turns the mirroring of your own public messages to Discord on or off. */
+  async setDiscordMirror(enabled: boolean): Promise<void> {
+    await this.options.request<unknown>("/chat/discord/mirror", {
+      method: "PUT",
+      body: JSON.stringify({ enabled }),
+    });
+  }
+
   connectChannel(
     channelId: string,
     onMessage: (msg: ChatMessage) => void,

package/src/api-client/company-kpis.ts

@@ -1,3 +1,5 @@
+import { listingAbroad, type IssuerListingParams } from "./paths";
+
 type QuoteMatchMode = "exact" | "whitespace" | "nfkc_whitespace";
 
 type KpiBasis = "reported" | "adjusted" | "constant_currency" | "organic"
@@ -147,7 +149,17 @@ export interface KpiQueryOptions {
   /** Point-in-time publication cutoff; excludes later restatements and actuals. */
   asOf?: string
 }
-export function companyDisclosurePath(section: "kpis" | "guidance", symbol: string, options: KpiQueryOptions): string {
+/**
+ * A US listing or a bare symbol asks for the symbol as before. A listing abroad
+ * asks for its bare symbol with its venue and company, so it never reads the
+ * disclosures of a US company that has the same symbol.
+ */
+export function companyDisclosurePath(section: "kpis" | "guidance", symbol: string, options: KpiQueryOptions, listing: IssuerListingParams = {}): string {
   const query = new URLSearchParams(Object.entries(options).filter((entry): entry is [string, string] => entry[1] != null));
-  return `/cloud/company-${section}/${encodeURIComponent(symbol)}?${query}`;
+  const abroad = listingAbroad(symbol, listing.exchange, listing.name);
+  if (abroad) {
+    query.set("exchange", abroad.exchange);
+    if (abroad.name) query.set("name", abroad.name);
+  }
+  return `/cloud/company-${section}/${encodeURIComponent(abroad?.symbol ?? symbol)}?${query}`;
 }

package/src/api-client/data.ts

@@ -65,11 +65,14 @@ import {
   cloudJobsPath,
   cloudJobsPostingsPath,
   type CloudJobsPostingsParams,
+  type IssuerListingParams,
   cloudProxyStatementPath,
+  cloudDebtMaturitiesPath,
   cloudFilingEventsPath,
   cloudRiskReportPath,
   cloudRiskReportsPath,
   cloudProxyStatementsPath,
+  cloudRevenueBreakdownPath,
   cloudExchangeRatePath,
   cloudSec13FPath,
   cloudSecBeneficialOwnersPath,
@@ -120,8 +123,10 @@ import type {
   CloudRiskReportPayload,
   CloudCorporateActionsPayload,
   CloudEconEventPayload,
+  CloudMacroReleaseDaysPayload,
   CloudEquityDiagnosticMode,
   CloudEquityDiagnosticResult,
+  CloudFredSeriesCatalogPayload,
   CloudFredSeriesPayload,
   CloudShillerPayload,
   CloudFinancialsPayload,
@@ -414,6 +419,10 @@ export class CloudDataApi {
     return this.request<CloudEconEventPayload[]>("/cloud/econ/calendar");
   }
 
+  async getCloudMacroReleaseDays(): Promise<CloudMacroReleaseDaysPayload> {
+    return this.request<CloudMacroReleaseDaysPayload>("/cloud/econ/release-days");
+  }
+
   async getCloudFredSeries(
     seriesId: string,
     params: CloudFredSeriesParams = {},
@@ -425,6 +434,11 @@ export class CloudDataApi {
     );
   }
 
+  /** Every series `getCloudFredSeries` serves. A server older than the list answers 404. */
+  async getCloudFredSeriesCatalog(): Promise<CloudFredSeriesCatalogPayload> {
+    return this.request<CloudFredSeriesCatalogPayload>("/cloud/econ/series");
+  }
+
   async getCloudShiller(): Promise<CloudShillerPayload> {
     return this.request<CloudShillerPayload>(cloudShillerPath());
   }
@@ -483,12 +497,13 @@ export class CloudDataApi {
     return this.request<CatalystStatus>("/cloud/catalysts/status");
   }
 
-  async getCloudCompanyKpis(symbol: string, options: KpiQueryOptions = {}): Promise<KpisPayload> {
-    return this.request<KpisPayload>(companyDisclosurePath("kpis", symbol, options));
+  /** `listing` names a listing abroad's venue and company; a US listing needs neither. */
+  async getCloudCompanyKpis(symbol: string, options: KpiQueryOptions = {}, listing: IssuerListingParams = {}): Promise<KpisPayload> {
+    return this.request<KpisPayload>(companyDisclosurePath("kpis", symbol, options, listing));
   }
 
-  async getCloudCompanyGuidance(symbol: string, options: KpiQueryOptions = {}): Promise<GuidancePayload> {
-    return this.request<GuidancePayload>(companyDisclosurePath("guidance", symbol, options));
+  async getCloudCompanyGuidance(symbol: string, options: KpiQueryOptions = {}, listing: IssuerListingParams = {}): Promise<GuidancePayload> {
+    return this.request<GuidancePayload>(companyDisclosurePath("guidance", symbol, options, listing));
   }
   async getCloudPerpsBoard(query: PerpBoardQuery = {}): Promise<PerpBoardPayload> {
     return this.request(`/cloud/perps/board?${new URLSearchParams(Object.entries(query).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)]))}`);
@@ -619,14 +634,12 @@ export class CloudDataApi {
     return this.request<MoneyMarketsPayload>("/cloud/econ/money-markets", { signal: AbortSignal.timeout(45_000) });
   }
 
-  async getCloudDebtMaturities(symbol: string): Promise<DebtMaturitiesPayload> {
-    const params = new URLSearchParams({ symbol });
-    return this.request<DebtMaturitiesPayload>(`/cloud/debt-maturities?${params}`, { signal: AbortSignal.timeout(45_000) });
+  async getCloudDebtMaturities(symbol: string, listing?: IssuerListingParams): Promise<DebtMaturitiesPayload> {
+    return this.request<DebtMaturitiesPayload>(cloudDebtMaturitiesPath(symbol, listing), { signal: AbortSignal.timeout(45_000) });
   }
 
-  async getCloudRevenueBreakdown(symbol: string, view?: RevenueBreakdownView): Promise<RevenueBreakdownPayload> {
-    const params = new URLSearchParams({ symbol, ...(view ? { view } : {}) });
-    return this.request<RevenueBreakdownPayload>(`/cloud/revenue-breakdown?${params}`, { signal: AbortSignal.timeout(30_000) });
+  async getCloudRevenueBreakdown(symbol: string, view?: RevenueBreakdownView, listing?: IssuerListingParams): Promise<RevenueBreakdownPayload> {
+    return this.request<RevenueBreakdownPayload>(cloudRevenueBreakdownPath(symbol, view, listing), { signal: AbortSignal.timeout(30_000) });
   }
 
   async getCloudMnaDeals(params: MnaDealsParams = {}, options?: { signal?: AbortSignal }): Promise<MnaDealsPayload> {
@@ -756,44 +769,49 @@ export class CloudDataApi {
     );
   }
 
+  // A listing outside the US also sends its venue and company (listingAbroad).
   async getProxyStatements(
     ticker: string,
+    listing?: IssuerListingParams,
   ): Promise<CloudProxyStatementListPayload> {
     return this.request<CloudProxyStatementListPayload>(
-      cloudProxyStatementsPath(ticker),
+      cloudProxyStatementsPath(ticker, listing),
     );
   }
 
   async getProxyStatement(
     ticker: string,
     year: number,
+    listing?: IssuerListingParams,
   ): Promise<CloudProxyStatementPayload> {
     return this.request<CloudProxyStatementPayload>(
-      cloudProxyStatementPath(ticker, year),
+      cloudProxyStatementPath(ticker, year, listing),
     );
   }
 
   async getFilingEvents(
     ticker: string,
     limit?: number,
+    listing?: IssuerListingParams,
   ): Promise<{ ticker: string; events: CloudFilingEventPayload[] }> {
     return this.request<{ ticker: string; events: CloudFilingEventPayload[] }>(
-      cloudFilingEventsPath(ticker, limit),
+      cloudFilingEventsPath(ticker, limit, listing),
     );
   }
 
-  async getRiskReports(ticker: string): Promise<CloudRiskReportListPayload> {
+  async getRiskReports(ticker: string, listing?: IssuerListingParams): Promise<CloudRiskReportListPayload> {
     return this.request<CloudRiskReportListPayload>(
-      cloudRiskReportsPath(ticker),
+      cloudRiskReportsPath(ticker, listing),
     );
   }
 
   async getRiskReport(
     ticker: string,
     year: number,
+    listing?: IssuerListingParams,
   ): Promise<CloudRiskReportPayload> {
     return this.request<CloudRiskReportPayload>(
-      cloudRiskReportPath(ticker, year),
+      cloudRiskReportPath(ticker, year, listing),
     );
   }
 

package/src/api-client/index.ts

@@ -425,6 +425,8 @@ class GloomApiClient {
   async recordExperimentExposure(payload: {
     eventId: string; surface: "web" | "desktop" | "tui" | "cli"; anonymousId?: string;
     attribution?: Record<string, string>; experiment: string; variant?: string;
+    /** Where the experiment showed, by a content-free id like an upgrade placement. */
+    placement?: string;
   }, signal?: AbortSignal): Promise<import("./web-experiments").ExperimentAnswer> {
     return this.request("/activity/research", {
       method: "POST",
@@ -441,6 +443,7 @@ class GloomApiClient {
   getCalendarFeed = this.auth.getCalendarFeed.bind(this.auth);
   ensureCalendarFeed = this.auth.ensureCalendarFeed.bind(this.auth);
   rotateCalendarFeed = this.auth.rotateCalendarFeed.bind(this.auth);
+  createMcpKey = this.auth.createMcpKey.bind(this.auth);
 
   async getSyncSnapshot(): Promise<CloudSyncSnapshotResponse> {
     return this.request<CloudSyncSnapshotResponse>("/sync/snapshot", { method: "GET" });
@@ -643,6 +646,9 @@ class GloomApiClient {
   connectChannel = this.chat.connectChannel.bind(this.chat);
   subscribeChatNotifications = this.chat.subscribeNotifications.bind(this.chat);
   subscribeChatPresence = this.chat.subscribePresence.bind(this.chat);
+  getChatDiscordLink = this.chat.getDiscordLink.bind(this.chat);
+  unlinkChatDiscord = this.chat.unlinkDiscord.bind(this.chat);
+  setChatDiscordMirror = this.chat.setDiscordMirror.bind(this.chat);
   subscribeQuotes = this.socket.subscribeQuotes.bind(this.socket);
 
   listTeams = this.teams.listTeams.bind(this.teams);
@@ -668,6 +674,10 @@ class GloomApiClient {
   subscribeTeamUpdates = this.teams.subscribeTeamUpdates.bind(this.teams);
   subscribeTeamNotifications = this.teams.subscribeTeamNotifications.bind(this.teams);
   subscribeCloudEvent = this.teams.subscribeCloudEvent.bind(this.teams);
+  /** The Cloud socket's own lifecycle and frames, for protocols layered on it (the terminal relay). */
+  subscribeSocketConnection = this.socket.subscribeConnection.bind(this.socket);
+  sendSocketFrame = this.socket.sendFrame.bind(this.socket);
+  socketServerOffers = this.socket.serverOffers.bind(this.socket);
   listCloudNotes = this.notes.listNotes.bind(this.notes);
   getCloudNote = this.notes.getNote.bind(this.notes);
   putCloudNote = this.notes.putNote.bind(this.notes);
@@ -731,10 +741,12 @@ class GloomApiClient {
   getCloudHistory = this.data.getCloudHistory.bind(this.data);
   getCloudExchangeRate = this.data.getCloudExchangeRate.bind(this.data);
   getCloudEconomicCalendar = this.data.getCloudEconomicCalendar.bind(this.data);
+  getCloudMacroReleaseDays = this.data.getCloudMacroReleaseDays.bind(this.data);
   getCloudEquityDiagnostic = this.data.getCloudEquityDiagnostic.bind(this.data);
   getCloudEarningsCalendar = this.data.getCloudEarningsCalendar.bind(this.data);
   getCloudEarningsHistory = this.data.getCloudEarningsHistory.bind(this.data);
   getCloudFredSeries = this.data.getCloudFredSeries.bind(this.data);
+  getCloudFredSeriesCatalog = this.data.getCloudFredSeriesCatalog.bind(this.data);
   getCloudCryptoMarkets = this.data.getCloudCryptoMarkets.bind(this.data);
   getCloudCentralBankRates = this.data.getCloudCentralBankRates.bind(this.data);
   getMobileAlertHistory = this.data.getMobileAlertHistory.bind(this.data);

package/src/api-client/normalizers.ts

@@ -1,7 +1,10 @@
 import type {
+  ChatAccountType,
   ChatAttachment,
   ChatChannel,
+  ChatDiscordLink,
   ChatMessage,
+  ChatMessageOrigin,
   ChatNotification,
   ChatStateResponse,
   CloudSavedSearch,
@@ -74,9 +77,20 @@ export function normalizeChatAttachments(value: unknown): ChatAttachment[] {
   });
 }
 
+const CHAT_ACCOUNT_TYPES: readonly string[] = ["human", "managed_llm", "discord"] satisfies ChatAccountType[];
+const CHAT_MESSAGE_ORIGINS: readonly string[] = ["app", "discord"] satisfies ChatMessageOrigin[];
+
+/** A value a newer server adds that this client does not know reads as absent: a human, a message from the app. */
+function chatUserWithKnownAccountType(user: ChatMessage["user"]): ChatMessage["user"] {
+  if (!user || user.accountType === undefined || CHAT_ACCOUNT_TYPES.includes(user.accountType)) return user;
+  const { accountType: _unknown, ...known } = user;
+  return known;
+}
+
 export function normalizeChatMessage(message: ChatMessage): ChatMessage {
   const normalized: ChatMessage = {
     ...message,
+    user: chatUserWithKnownAccountType(message.user),
     content: typeof message.content === "string" ? message.content : "",
     createdAt: normalizeTimestamp(message.createdAt),
     ...(message.editedAt
@@ -84,12 +98,25 @@ export function normalizeChatMessage(message: ChatMessage): ChatMessage {
       : {}),
   };
   if ("attachments" in message) normalized.attachments = normalizeChatAttachments(message.attachments);
+  if (message.origin !== undefined && !CHAT_MESSAGE_ORIGINS.includes(message.origin)) delete normalized.origin;
   if (message.attachmentReview !== "pending" && message.attachmentReview !== "failed") {
     delete normalized.attachmentReview;
   }
   return normalized;
 }
 
+/** The link answer of a server that knows Discord: mirroring is on and linking available unless it says otherwise. */
+export function normalizeChatDiscordLink(value: unknown): ChatDiscordLink {
+  const raw = value && typeof value === "object" ? value as Record<string, unknown> : {};
+  const username = typeof raw.discordUsername === "string" ? raw.discordUsername.trim() : "";
+  return {
+    linked: raw.linked === true,
+    ...(username ? { discordUsername: username } : {}),
+    mirror: raw.mirror !== false,
+    available: raw.available !== false,
+  };
+}
+
 export function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }

package/src/api-client/paths.ts

@@ -7,6 +7,7 @@ import { isUsListingExchange, normalizeSymbol, parsePublicTickerKey, publicTicke
 import { nonUsSecListingVenue } from "../utils/sec";
 import type { HistoryRetention } from "../sources/history-retention";
 import type { CloudBeneficialOwnersParams } from "./beneficial-owners";
+import type { RevenueBreakdownView } from "./revenue-breakdown";
 
 export type CloudHistoryParams = {
   interval?: string;
@@ -58,7 +59,15 @@ export type CloudCongressHouseParams = {
   minAmount?: number;
 };
 
-export type CloudEarningsCallsParams = {
+/** The listing an issuer lookup is for, so a listing abroad never reads a US namesake. */
+export type IssuerListingParams = {
+  /** The listing's venue. Sent only for a venue outside the US, with `name`. */
+  exchange?: string;
+  /** The listing's company name, from its ticker or its own quote. */
+  name?: string;
+};
+
+export type CloudEarningsCallsParams = IssuerListingParams & {
   ticker?: string;
   limit?: number;
   offset?: number;
@@ -305,11 +314,42 @@ export function cloudJobsMoversPath(limit?: number, offset?: number): string {
   return appendQuery("/cloud/jobs", search);
 }
 
+/** A listing outside the US, as an issuer lookup names it: its bare symbol, venue and company. */
+export interface ListingAbroad {
+  symbol: string;
+  exchange: string;
+  name?: string;
+}
+
+/**
+ * The listing abroad a ticker names, from its key or the given venue: AI in
+ * Paris is Air Liquide, AI in New York is C3.ai. Null for a US listing, a
+ * routing destination or a symbol with no venue, which keep their US lookup.
+ */
+export function listingAbroad(ticker: string, exchange?: string, name?: string | null): ListingAbroad | null {
+  const venue = nonUsSecListingVenue(ticker, exchange);
+  if (!venue) return null;
+  const company = name?.trim();
+  return { symbol: parsePublicTickerKey(ticker).symbol, exchange: venue, ...(company ? { name: company } : {}) };
+}
+
+/** Sets a listing abroad's venue and company on an issuer lookup. */
+function setListingAbroad(search: URLSearchParams, listing: ListingAbroad | null): void {
+  if (!listing) return;
+  search.set("exchange", listing.exchange);
+  if (listing.name) search.set("name", listing.name);
+}
+
+/** A US listing or a bare symbol looks up its US ticker as before; a listing abroad names its venue and company. */
 export function cloudEarningsCallsPath(
   params: CloudEarningsCallsParams = {},
 ): string {
   const search = new URLSearchParams();
-  if (params.ticker) search.set("ticker", normalizeIssuerResearchTicker(params.ticker));
+  if (params.ticker) {
+    const abroad = listingAbroad(params.ticker, params.exchange, params.name);
+    search.set("ticker", abroad?.symbol ?? normalizeIssuerResearchTicker(params.ticker));
+    setListingAbroad(search, abroad);
+  }
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
   if (params.includePending) search.set("includePending", "true");
@@ -320,33 +360,60 @@ export function cloudEarningsTranscriptPath(id: string): string {
   return `/cloud/transcripts/${encodeURIComponent(id)}`;
 }
 
+/**
+ * An issuer read's path: a US listing or a bare symbol keeps its US ticker
+ * and sends nothing else; a listing abroad sends its bare symbol with its
+ * venue and company (listingAbroad).
+ */
+function issuerPath(base: string, ticker: string, listing: IssuerListingParams = {}, suffix = ""): string {
+  const abroad = listingAbroad(ticker, listing.exchange, listing.name);
+  const search = new URLSearchParams();
+  setListingAbroad(search, abroad);
+  return appendQuery(`${base}/${encodeURIComponent(abroad?.symbol ?? normalizeIssuerResearchTicker(ticker))}${suffix}`, search);
+}
+
 /**
  * RISK, EXEC and EK are Pro: these reads need a verified Pro account. The same
  * risk factors and pay are open under /public for the gloom.sh pages.
  */
-export function cloudProxyStatementsPath(ticker: string): string {
-  return `/cloud/proxies/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`;
+export function cloudProxyStatementsPath(ticker: string, listing?: IssuerListingParams): string {
+  return issuerPath("/cloud/proxies", ticker, listing);
 }
 
-export function cloudFilingEventsPath(ticker: string, limit?: number): string {
+export function cloudFilingEventsPath(ticker: string, limit?: number, listing: IssuerListingParams = {}): string {
+  const abroad = listingAbroad(ticker, listing.exchange, listing.name);
   const search = new URLSearchParams();
+  setListingAbroad(search, abroad);
   if (limit != null) search.set("limit", String(limit));
-  return appendQuery(
-    `/cloud/events/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`,
-    search,
-  );
+  return appendQuery(`/cloud/events/${encodeURIComponent(abroad?.symbol ?? normalizeIssuerResearchTicker(ticker))}`, search);
+}
+
+export function cloudRiskReportsPath(ticker: string, listing?: IssuerListingParams): string {
+  return issuerPath("/cloud/risks", ticker, listing);
 }
 
-export function cloudRiskReportsPath(ticker: string): string {
-  return `/cloud/risks/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}`;
+export function cloudRiskReportPath(ticker: string, year: number, listing?: IssuerListingParams): string {
+  return issuerPath("/cloud/risks", ticker, listing, `/${year}`);
 }
 
-export function cloudRiskReportPath(ticker: string, year: number): string {
-  return `/cloud/risks/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/${year}`;
+export function cloudProxyStatementPath(ticker: string, year: number, listing?: IssuerListingParams): string {
+  return issuerPath("/cloud/proxies", ticker, listing, `/${year}`);
 }
 
-export function cloudProxyStatementPath(ticker: string, year: number): string {
-  return `/cloud/proxies/${encodeURIComponent(normalizeIssuerResearchTicker(ticker))}/${year}`;
+/** The principal maturity schedule; a US symbol goes as given, as it always has. */
+export function cloudDebtMaturitiesPath(symbol: string, listing: IssuerListingParams = {}): string {
+  const abroad = listingAbroad(symbol, listing.exchange, listing.name);
+  const search = new URLSearchParams({ symbol: abroad?.symbol ?? symbol });
+  setListingAbroad(search, abroad);
+  return appendQuery("/cloud/debt-maturities", search);
+}
+
+export function cloudRevenueBreakdownPath(symbol: string, view?: RevenueBreakdownView, listing: IssuerListingParams = {}): string {
+  const abroad = listingAbroad(symbol, listing.exchange, listing.name);
+  const search = new URLSearchParams({ symbol: abroad?.symbol ?? symbol });
+  setListingAbroad(search, abroad);
+  if (view) search.set("view", view);
+  return appendQuery("/cloud/revenue-breakdown", search);
 }
 
 /**
@@ -355,23 +422,21 @@ export function cloudProxyStatementPath(ticker: string, year: number): string {
  * its symbol can be another company's US ticker.
  */
 export function cloudSecFilingsPath(params: CloudSecFilingsParams): string {
-  const venue = nonUsSecListingVenue(params.ticker, params.exchange);
+  const abroad = listingAbroad(params.ticker, params.exchange, params.name);
   const search = new URLSearchParams({
-    ticker: venue ? parsePublicTickerKey(params.ticker).symbol : normalizeIssuerResearchTicker(params.ticker),
+    ticker: abroad?.symbol ?? normalizeIssuerResearchTicker(params.ticker),
   });
   if (params.limit != null) search.set("limit", String(params.limit));
   if (params.offset != null) search.set("offset", String(params.offset));
-  if (venue) {
-    search.set("exchange", venue);
-    const name = params.name?.trim();
-    if (name) search.set("name", name);
-  }
+  setListingAbroad(search, abroad);
   return appendQuery("/cloud/sec/filings", search);
 }
 
 /** Schedule 13D and 13G reports about the issuer behind `ticker`. */
 export function cloudSecBeneficialOwnersPath(params: CloudBeneficialOwnersParams): string {
-  const search = new URLSearchParams({ ticker: normalizeIssuerResearchTicker(params.ticker) });
+  const abroad = listingAbroad(params.ticker, params.exchange, params.name);
+  const search = new URLSearchParams({ ticker: abroad?.symbol ?? normalizeIssuerResearchTicker(params.ticker) });
+  setListingAbroad(search, abroad);
   if (params.form) search.set("form", params.form);
   if (params.history) search.set("history", "1");
   if (params.limit != null) search.set("limit", String(params.limit));

package/src/api-client/request.ts

@@ -16,7 +16,8 @@ import {
 } from "../core/connection-health";
 import { SESSION_COOKIE_NAMES } from "./session-cookie";
 
-const DEFAULT_API_URL = "https://api.gloom.sh";
+/** The public Gloom Cloud API, which the web app's same-origin `/api` path forwards to. */
+export const DEFAULT_API_URL = "https://api.gloom.sh";
 const DEFAULT_MARKET_REQUEST_TIMEOUT_MS = 10_000;
 const DEFAULT_RESEARCH_REQUEST_TIMEOUT_MS = 45_000;
 // Research may fill missing sections after a primary read; quote/history reads remain latency bounded.