gloomberb 0.7.4 → 0.8.0

package/src/utils/api-client.ts

@@ -1,1379 +0,0 @@
-import type {
-  AnalystResearchData,
-  CompanyProfile,
-  CorporateActionsData,
-  Fundamentals,
-  HolderData,
-  HolderRecord,
-  OptionsChain,
-  PricePoint,
-  Quote,
-  TickerFinancials,
-} from "../types/financials";
-import type { InstrumentSearchResult } from "../types/instrument";
-import { debugLog } from "./debug-log";
-import { canonicalExchange, normalizeSymbol, publicTickerKey } from "./exchanges";
-import { httpFetch } from "./http-transport";
-import { normalizeTimestamp } from "./timestamp";
-
-const DEFAULT_API_URL = "https://api.gloom.sh";
-const SESSION_COOKIE_NAMES = ["__Secure-gloomberb.session_token", "gloomberb.session_token"] as const;
-const QUOTE_SUBSCRIPTION_FLUSH_MS = 25;
-const cloudApiLog = debugLog.createLogger("cloud-api");
-const HARD_SESSION_INVALID_PATTERNS = [
-  /\b(user|account)\b.*\b(not found|deleted|removed|disabled|deactivated|suspended)\b/i,
-  /\b(user|account)\b.*\bdoes(?:\s+not|n't)\s+exist\b/i,
-  /\b(no|unknown|missing)\s+(user|account)\b/i,
-];
-
-type CloudApiResponse = Pick<Response, "ok" | "status" | "headers" | "text">;
-type CloudApiFetchTransport = (url: string, init?: RequestInit) => Promise<CloudApiResponse>;
-
-let cloudApiFetchTransport: CloudApiFetchTransport = httpFetch;
-
-export function setCloudApiFetchTransport(transport: CloudApiFetchTransport | null): void {
-  cloudApiFetchTransport = transport ?? httpFetch;
-}
-
-function getCloudApiBaseUrl(): string {
-  if (typeof process === "undefined") {
-    return DEFAULT_API_URL;
-  }
-  return process.env.GLOOMBERB_API_URL ?? DEFAULT_API_URL;
-}
-
-export interface ChatMessage {
-  id: string;
-  channelId: string;
-  content: string;
-  replyToId: string | null;
-  createdAt: string;
-  user: { id: string; username: string; displayName: string };
-  replyTo?: { content: string; user: { id?: string; username: string } } | null;
-  clientStatus?: "sending" | "failed";
-  clientError?: string | null;
-}
-
-export interface ChatChannel {
-  id: string;
-  name: string;
-  created_at: string;
-}
-
-export interface ChatChannelState {
-  channelId: string;
-  notificationsEnabled: boolean;
-  lastReadMessageId: string | null;
-  unreadCount: number;
-}
-
-export interface ChatNotification {
-  id: string;
-  type: "reply" | "mention" | "channel";
-  channelId: string;
-  messageId: string;
-  createdAt: string;
-  message: ChatMessage;
-}
-
-export interface ChatStateResponse {
-  channels: ChatChannel[];
-  onlineCount: number;
-  channelStates: ChatChannelState[];
-  notifications: ChatNotification[];
-}
-
-export interface AuthUser {
-  id: string;
-  name: string;
-  email: string;
-  username: string | null;
-  emailVerified: boolean;
-  image: string | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export type PersistedAuthUser = Pick<AuthUser, "id" | "emailVerified"> & Partial<AuthUser>;
-
-export interface CloudQuotePayload extends Quote {
-  providerId: "gloomberb-cloud";
-  dataSource: "live" | "delayed";
-}
-
-export interface CloudOptionsChainPayload extends OptionsChain {
-  providerId: "gloomberb-cloud";
-}
-
-export interface CloudCompanyProfile extends CompanyProfile {}
-
-export interface CloudFundamentals extends Fundamentals {}
-
-export interface CloudHolderPayload extends HolderRecord {
-  providerId: "gloomberb-cloud";
-  ownerType: "institution";
-}
-
-export interface CloudHoldersPayload extends HolderData {
-  providerId: "gloomberb-cloud";
-  holders: CloudHolderPayload[];
-}
-
-export interface CloudAnalystResearchPayload extends AnalystResearchData {
-  providerId: "gloomberb-cloud";
-}
-
-export interface CloudCorporateActionsPayload extends CorporateActionsData {
-  providerId: "gloomberb-cloud";
-}
-
-export interface CloudPricePointPayload {
-  date: string;
-  open?: number;
-  high?: number;
-  low?: number;
-  close: number;
-  volume?: number;
-}
-
-export type CloudEconImpact = "high" | "medium" | "low";
-
-export interface CloudEconEventPayload {
-  id: string;
-  date: string;
-  time: string;
-  country: string;
-  event: string;
-  actual: string | null;
-  forecast: string | null;
-  prior: string | null;
-  impact: CloudEconImpact;
-}
-
-export interface CloudFredObservationPayload {
-  date: string;
-  value: number | null;
-}
-
-export interface CloudFredSeriesInfoPayload {
-  id: string;
-  title: string;
-  units: string;
-  frequency: string;
-  seasonalAdjustment: string;
-  source: string;
-  notes: string;
-}
-
-export interface CloudFredSeriesPayload {
-  observations: CloudFredObservationPayload[];
-  info: CloudFredSeriesInfoPayload | null;
-}
-
-export interface CloudYieldPointPayload {
-  maturity: string;
-  maturityYears: number;
-  yield: number | null;
-}
-
-export interface CloudNewsEntityPayload {
-  id: string;
-  entityType: string;
-  name: string;
-  symbol: string | null;
-  exchange: string | null;
-  canonicalTicker: string | null;
-  role: string | null;
-  confidence: number | null;
-}
-
-export interface CloudNewsTickerLinkPayload {
-  symbol: string;
-  exchange: string;
-  canonicalTicker: string;
-  relationType: string;
-  displayTier: "primary" | "related";
-  confidence: number;
-  relevanceScore: number;
-  impactScore?: number;
-  sentiment?: "positive" | "neutral" | "negative" | null;
-}
-
-export interface CloudNewsStoryItemPayload {
-  id: string;
-  sourceKey: string;
-  sourceName: string;
-  title: string;
-  summary?: string;
-  url: string;
-  publishedAt: string;
-  hasArticleText?: boolean;
-}
-
-export interface CloudNewsPayload {
-  id: string;
-  headline: string;
-  summary: string;
-  topic?: string;
-  topics?: string[];
-  category: string;
-  sentiment: "positive" | "neutral" | "negative";
-  sectors: string[];
-  scope?: string;
-  firstPublishedAt: string;
-  lastPublishedAt: string;
-  firstSeenAt: string;
-  lastSeenAt: string;
-  primaryUrl: string;
-  primarySource: string;
-  scores?: {
-    importance?: number;
-    urgency?: number;
-    marketImpact?: number;
-    novelty?: number;
-    confidence?: number;
-  };
-  flags?: {
-    breaking?: boolean;
-    developing?: boolean;
-    stale?: boolean;
-  };
-  variantCount: number;
-  sourceCount: number;
-  sources: string[];
-  entities: CloudNewsEntityPayload[];
-  tickerLinks: CloudNewsTickerLinkPayload[];
-  items?: CloudNewsStoryItemPayload[];
-}
-
-export interface CloudNewsListResponse {
-  items: CloudNewsPayload[];
-  nextCursor: string | null;
-}
-
-export interface CloudTweetUserPayload {
-  id: string;
-  userName: string;
-  name: string;
-}
-
-export interface CloudTweetMetricsPayload {
-  retweets: number | null;
-  replies: number | null;
-  likes: number | null;
-  quotes: number | null;
-  views: number | null;
-  bookmarks: number | null;
-}
-
-export interface CloudTweetMediaPayload {
-  type?: string;
-  url?: string;
-  mediaUrl?: string;
-  media_url?: string;
-  media_url_https?: string;
-  previewImageUrl?: string;
-  preview_image_url?: string;
-}
-
-export interface CloudTweetPayload {
-  id: string;
-  url: string;
-  text: string;
-  createdAt: string;
-  lang: string;
-  isReply: boolean;
-  author: CloudTweetUserPayload;
-  metrics: CloudTweetMetricsPayload;
-  media?: CloudTweetMediaPayload[];
-  photos?: CloudTweetMediaPayload[];
-  images?: CloudTweetMediaPayload[];
-}
-
-export type CloudTweetQueryType = "Latest" | "Top";
-
-export interface CloudTweetSearchResponse {
-  ticker?: string;
-  cashtag?: string;
-  query: string;
-  queryType: CloudTweetQueryType;
-  since: string;
-  until: string;
-  limit: number;
-  hours: number;
-  includeReplies?: boolean;
-  cached: boolean;
-  cacheTtlMs: number;
-  asOf: string;
-  tweets: CloudTweetPayload[];
-}
-
-export type CloudMarketStatus =
-  | "success"
-  | "partial"
-  | "empty"
-  | "unsupported"
-  | "retryable_error"
-  | "fatal_error";
-
-export interface CloudMarketResponse<T> {
-  status: CloudMarketStatus;
-  data: T | null;
-  reasonCode?: string;
-  asOf?: string;
-  staleAt?: string;
-  stale?: boolean;
-  currency?: string;
-  providerMeta?: {
-    provider?: string;
-    upstream?: string;
-    status?: CloudMarketStatus;
-    reasonCode?: string;
-    normalizedSymbol?: string;
-    normalizedExchange?: string;
-    stale?: boolean;
-    fallbackReason?: string;
-    requestedResolution?: string;
-    servedResolution?: string;
-    latencyMs?: number;
-    range?: string;
-    granularity?: string;
-    timezone?: string;
-    currency?: string;
-    barCount?: number;
-  };
-}
-
-export interface CloudMarketBatchTarget {
-  symbol: string;
-  exchange?: string;
-}
-
-export interface CloudMarketBatchItem<T> {
-  symbol: string;
-  exchange: string;
-  status: CloudMarketStatus;
-  data: T | null;
-  reasonCode?: string;
-}
-
-export interface CloudMarketBatchPayload<T> {
-  items: Array<CloudMarketBatchItem<T>>;
-}
-
-export interface CloudVerificationResponse {
-  sent: boolean;
-  email?: string;
-  alreadyVerified?: boolean;
-}
-
-export interface QuoteStreamTarget {
-  symbol: string;
-  exchange?: string;
-  surface?: "portfolio" | "watchlist" | "detail" | "monitor" | "inline" | "screener" | "unknown";
-  visible?: boolean;
-  selected?: boolean;
-  weight?: number;
-}
-
-function marketKey(symbol: string, exchange?: string): string {
-  const normalizedSymbolValue = normalizeSymbol(symbol);
-  const normalizedExchangeValue = canonicalExchange(exchange);
-  return normalizedExchangeValue ? `${normalizedSymbolValue}:${normalizedExchangeValue}` : normalizedSymbolValue;
-}
-
-function normalizeChatMessage(message: ChatMessage): ChatMessage {
-  return {
-    ...message,
-    createdAt: normalizeTimestamp(message.createdAt),
-  };
-}
-
-function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
-  return messages.map((message) => normalizeChatMessage(message));
-}
-
-function normalizeChatNotification(notification: ChatNotification): ChatNotification {
-  return {
-    ...notification,
-    createdAt: normalizeTimestamp(notification.createdAt),
-    message: normalizeChatMessage(notification.message),
-  };
-}
-
-function normalizeChatState(response: ChatStateResponse): ChatStateResponse {
-  return {
-    ...response,
-    notifications: response.notifications.map(normalizeChatNotification),
-  };
-}
-
-function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
-  return {
-    ...tweet,
-    createdAt: normalizeTimestamp(tweet.createdAt),
-  };
-}
-
-function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): CloudTweetSearchResponse {
-  return {
-    ...response,
-    since: normalizeTimestamp(response.since),
-    until: normalizeTimestamp(response.until),
-    asOf: normalizeTimestamp(response.asOf),
-    tweets: response.tweets.map(normalizeTweet),
-  };
-}
-
-type ChannelListener = (message: ChatMessage) => void;
-type ChatNotificationListener = (notification: ChatNotification) => void;
-type ChatPresenceListener = (onlineCount: number) => void;
-type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
-type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
-
-class ApiRequestError extends Error {
-  constructor(message: string, readonly status?: number) {
-    super(message);
-    this.name = "ApiRequestError";
-  }
-}
-
-function parseApiErrorMessage(body: string): string {
-  try {
-    const parsed = JSON.parse(body) as Record<string, unknown>;
-    const parts = [parsed.message, parsed.error, parsed.code, parsed.reason]
-      .filter((value): value is string => typeof value === "string" && value.trim().length > 0);
-    return parts.join(" ") || body;
-  } catch {
-    return body;
-  }
-}
-
-function isHardSessionInvalidMessage(message: string): boolean {
-  const normalized = message.replace(/[_-]+/g, " ");
-  return HARD_SESSION_INVALID_PATTERNS.some((pattern) => pattern.test(normalized));
-}
-
-class GloomApiClient {
-  private sessionToken: string | null = null;
-  private sessionCookieName: SessionCookieName | null = null;
-  private websocketToken: string | null = null;
-  private currentUser: AuthUser | null = null;
-  private readonly baseUrl: string;
-
-  private ws: WebSocket | null = null;
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-  private reconnectDelayMs = 1000;
-
-  private readonly channelListeners = new Map<string, Set<ChannelListener>>();
-  private readonly chatNotificationListeners = new Set<ChatNotificationListener>();
-  private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
-  private readonly quoteListeners = new Map<string, Set<QuoteListener>>();
-  private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
-  private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
-  private readonly pendingQuoteUnsubscribes = new Map<string, QuoteStreamTarget>();
-  private quoteSubscriptionFlushTimer: ReturnType<typeof setTimeout> | null = null;
-
-  constructor() {
-    this.baseUrl = getCloudApiBaseUrl();
-  }
-
-  getSessionToken(): string | null {
-    return this.sessionToken;
-  }
-
-  getWebSocketToken(): string | null {
-    return this.websocketToken;
-  }
-
-  setSessionToken(token: string | null): void {
-    if (this.sessionToken !== token) {
-      this.sessionCookieName = null;
-    }
-    this.sessionToken = token;
-    if (!token) {
-      this.websocketToken = null;
-      this.currentUser = null;
-      this.teardownSocket();
-    }
-  }
-
-  setWebSocketToken(token: string | null): void {
-    this.websocketToken = token;
-    if (!token) {
-      this.teardownSocket();
-    }
-  }
-
-  getCurrentUser(): AuthUser | null {
-    return this.currentUser;
-  }
-
-  restoreCachedUser(user: PersistedAuthUser | null): void {
-    if (!this.sessionToken || !user?.id) {
-      this.setCurrentUser(null);
-      return;
-    }
-    this.setCurrentUser({
-      id: user.id,
-      name: typeof user.name === "string" && user.name.length > 0
-        ? user.name
-        : user.username ?? "User",
-      email: typeof user.email === "string" ? user.email : "",
-      username: typeof user.username === "string" ? user.username : null,
-      emailVerified: user.emailVerified === true,
-      image: typeof user.image === "string" ? user.image : null,
-      createdAt: typeof user.createdAt === "string" ? user.createdAt : "",
-      updatedAt: typeof user.updatedAt === "string" ? user.updatedAt : "",
-    });
-  }
-
-  isVerified(): boolean {
-    return !!this.sessionToken && !!this.currentUser?.emailVerified;
-  }
-
-  private setCurrentUser(user: AuthUser | null): void {
-    this.currentUser = user;
-    if (!this.shouldKeepSocketOpen()) {
-      this.teardownSocket();
-      return;
-    }
-    this.ensureSocket();
-  }
-
-  private requireCapturedSession(message: string): void {
-    if (this.sessionToken) return;
-    this.websocketToken = null;
-    this.setCurrentUser(null);
-    throw new Error(message);
-  }
-
-  private extractSessionCookie(res: CloudApiResponse): void {
-    const setCookie = res.headers.getSetCookie?.() ?? [];
-    const fallbackHeader = res.headers.get("set-cookie");
-    if (fallbackHeader) {
-      setCookie.push(fallbackHeader);
-    }
-    for (const cookie of setCookie) {
-      for (const cookieName of SESSION_COOKIE_NAMES) {
-        const escapedCookieName = cookieName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const match = cookie.match(new RegExp(`${escapedCookieName}=([^;]+)`));
-        if (!match) continue;
-        this.sessionToken = match[1] ?? null;
-        this.sessionCookieName = cookieName;
-        return;
-      }
-    }
-  }
-
-  private buildSessionCookieHeader(): string | null {
-    if (!this.sessionToken) return null;
-    const cookieNames = this.sessionCookieName ? [this.sessionCookieName] : SESSION_COOKIE_NAMES;
-    return cookieNames.map((cookieName) => `${cookieName}=${this.sessionToken}`).join("; ");
-  }
-
-  private setSessionCookieHeader(headers: Headers): void {
-    const cookieHeader = this.buildSessionCookieHeader();
-    if (cookieHeader) {
-      headers.set("Cookie", cookieHeader);
-    }
-  }
-
-  private async request<T>(path: string, options?: RequestInit): Promise<T> {
-    const headers = new Headers(options?.headers);
-    if (!headers.has("Content-Type") && options?.method && options.method !== "GET") {
-      headers.set("Content-Type", "application/json");
-    }
-    this.setSessionCookieHeader(headers);
-    headers.set("Origin", this.baseUrl);
-
-    const res = await cloudApiFetchTransport(`${this.baseUrl}${path}`, {
-      ...options,
-      headers,
-      credentials: "include",
-    });
-
-    this.extractSessionCookie(res);
-
-    if (!res.ok) {
-      const body = await res.text();
-      const msg = parseApiErrorMessage(body);
-      throw new ApiRequestError(msg, res.status);
-    }
-
-    const text = await res.text();
-    if (!text) return undefined as T;
-    const parsed = JSON.parse(text) as T & { token?: string };
-    if (typeof parsed?.token === "string" && parsed.token.length > 0) {
-      this.websocketToken = parsed.token;
-    }
-    return parsed as T;
-  }
-
-  private getWebSocketBaseUrl(): string {
-    const wsProtocol = this.baseUrl.startsWith("https") ? "wss" : "ws";
-    return this.baseUrl.replace(/^https?/, wsProtocol);
-  }
-
-  private getSocketAuthToken(): string | null {
-    return this.websocketToken || this.sessionToken;
-  }
-
-  private shouldKeepSocketOpen(): boolean {
-    if (this.quoteTargets.size > 0) return true;
-    return !!this.getSocketAuthToken()
-      && !!this.currentUser?.emailVerified
-      && this.channelListeners.size > 0;
-  }
-
-  private ensureSocket(): void {
-    if (!this.shouldKeepSocketOpen() || this.ws || this.reconnectTimer) return;
-
-    const socketToken = this.getSocketAuthToken();
-    const usingWebSocketToken = !!this.websocketToken;
-    const url = socketToken
-      ? `${this.getWebSocketBaseUrl()}/cloud/ws?token=${encodeURIComponent(socketToken)}`
-      : `${this.getWebSocketBaseUrl()}/cloud/ws`;
-    cloudApiLog.info("open websocket", {
-      hasToken: !!socketToken,
-      tokenSource: usingWebSocketToken ? "websocket" : "session",
-      quoteTargets: this.quoteTargets.size,
-      channelTargets: this.channelListeners.size,
-    });
-    const ws = new WebSocket(url);
-    this.ws = ws;
-
-    ws.onopen = () => {
-      if (this.ws !== ws) return;
-      cloudApiLog.info("websocket open");
-      this.reconnectDelayMs = 1000;
-      this.flushSubscriptions();
-    };
-
-    ws.onmessage = (event) => {
-      void this.handleSocketMessage(String(event.data));
-    };
-
-    ws.onclose = (event) => {
-      const activeSocket = this.ws === ws;
-      if (this.ws === ws) {
-        this.ws = null;
-      }
-      const closeEvent = event as CloseEvent | undefined;
-      cloudApiLog.warn("websocket closed", {
-        quoteTargets: this.quoteTargets.size,
-        channelTargets: this.channelListeners.size,
-        code: closeEvent?.code,
-        reason: closeEvent?.reason,
-        tokenSource: usingWebSocketToken ? "websocket" : "session",
-      });
-      if (activeSocket && usingWebSocketToken && this.sessionToken) {
-        this.websocketToken = null;
-        this.reconnectDelayMs = 1000;
-        cloudApiLog.warn("cleared websocket token after socket close; falling back to session token");
-      }
-      if (!this.shouldKeepSocketOpen()) return;
-      this.scheduleReconnect();
-    };
-
-    ws.onerror = () => {
-      // reconnect is handled by onclose
-    };
-  }
-
-  private teardownSocket(): void {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    const ws = this.ws;
-    this.ws = null;
-    if (ws) {
-      cloudApiLog.info("teardown websocket");
-    }
-    try {
-      ws?.close();
-    } catch {
-      // ignore closed sockets
-    }
-  }
-
-  private scheduleReconnect(): void {
-    if (this.reconnectTimer || !this.shouldKeepSocketOpen()) return;
-    const delay = this.reconnectDelayMs;
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.reconnectDelayMs = Math.min(this.reconnectDelayMs * 2, 10_000);
-      this.ensureSocket();
-    }, delay);
-  }
-
-  private sendSocketMessage(payload: unknown): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
-    if (payload && typeof payload === "object" && "type" in (payload as Record<string, unknown>)) {
-      const type = (payload as Record<string, unknown>).type;
-      if (
-        type === "market.subscribe"
-        || type === "market.unsubscribe"
-        || type === "chat.subscribe"
-        || type === "chat.unsubscribe"
-      ) {
-        cloudApiLog.info("send websocket message", payload);
-      }
-    }
-    this.ws.send(JSON.stringify(payload));
-  }
-
-  private flushSubscriptions(): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
-
-    for (const channelId of this.channelListeners.keys()) {
-      this.sendSocketMessage({ type: "chat.subscribe", channelId });
-    }
-
-    if (this.quoteTargets.size > 0) {
-      this.sendSocketMessage({
-        type: "market.subscribe",
-        symbols: [...this.quoteTargets.values()].map((target) => this.serializeQuoteStreamTarget(target)),
-      });
-    }
-  }
-
-  private scheduleQuoteSubscriptionFlush(): void {
-    if (this.quoteSubscriptionFlushTimer) return;
-    this.quoteSubscriptionFlushTimer = setTimeout(() => {
-      this.quoteSubscriptionFlushTimer = null;
-      this.flushQueuedQuoteSubscriptions();
-    }, QUOTE_SUBSCRIPTION_FLUSH_MS);
-  }
-
-  private queueQuoteSubscribes(targets: QuoteStreamTarget[]): void {
-    for (const target of targets) {
-      const key = marketKey(target.symbol, target.exchange);
-      this.pendingQuoteUnsubscribes.delete(key);
-      this.pendingQuoteSubscribes.set(key, target);
-    }
-    this.scheduleQuoteSubscriptionFlush();
-  }
-
-  private queueQuoteUnsubscribes(targets: QuoteStreamTarget[]): void {
-    for (const target of targets) {
-      const key = marketKey(target.symbol, target.exchange);
-      if (this.pendingQuoteSubscribes.delete(key)) continue;
-      this.pendingQuoteUnsubscribes.set(key, target);
-    }
-    this.scheduleQuoteSubscriptionFlush();
-  }
-
-  private flushQueuedQuoteSubscriptions(): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) {
-      this.pendingQuoteSubscribes.clear();
-      this.pendingQuoteUnsubscribes.clear();
-      return;
-    }
-    const subscribes = [...this.pendingQuoteSubscribes.values()];
-    const unsubscribes = [...this.pendingQuoteUnsubscribes.values()];
-    this.pendingQuoteSubscribes.clear();
-    this.pendingQuoteUnsubscribes.clear();
-    if (subscribes.length > 0) {
-      this.sendSocketMessage({
-        type: "market.subscribe",
-        symbols: subscribes.map((target) => this.serializeQuoteStreamTarget(target)),
-      });
-    }
-    if (unsubscribes.length > 0) {
-      this.sendSocketMessage({
-        type: "market.unsubscribe",
-        symbols: unsubscribes.map((target) => this.serializeQuoteStreamTarget(target)),
-      });
-    }
-  }
-
-  private serializeQuoteStreamTarget(target: QuoteStreamTarget): QuoteStreamTarget {
-    return {
-      symbol: target.symbol,
-      exchange: target.exchange ?? "",
-      ...(target.surface ? { surface: target.surface } : {}),
-      ...(target.visible ? { visible: true } : {}),
-      ...(target.selected ? { selected: true } : {}),
-      ...(Number.isFinite(target.weight) ? { weight: target.weight } : {}),
-    };
-  }
-
-  private async handleSocketMessage(raw: string): Promise<void> {
-    let parsed: any;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return;
-    }
-
-    if (parsed?.type === "ready" && parsed.user) {
-      cloudApiLog.info("websocket ready", { emailVerified: parsed.user.emailVerified === true });
-      this.currentUser = {
-        ...(this.currentUser ?? {}),
-        ...parsed.user,
-      };
-      return;
-    }
-
-    if (parsed?.type === "auth.unverified") {
-      cloudApiLog.warn("websocket marked unverified");
-      if (this.websocketToken && this.sessionToken) {
-        this.websocketToken = null;
-        this.reconnectDelayMs = 1000;
-        cloudApiLog.warn("cleared websocket token after auth rejection; falling back to session token");
-        this.teardownSocket();
-        this.scheduleReconnect();
-        return;
-      }
-      if (this.currentUser) {
-        this.currentUser = { ...this.currentUser, emailVerified: false };
-      }
-      if (this.quoteTargets.size > 0) {
-        return;
-      }
-      this.teardownSocket();
-      return;
-    }
-
-    if (parsed?.type === "chat.message" && typeof parsed.channelId === "string" && parsed.data) {
-      const message = normalizeChatMessage(parsed.data as ChatMessage);
-      for (const listener of this.channelListeners.get(parsed.channelId) ?? []) {
-        listener(message);
-      }
-      return;
-    }
-
-    if (parsed?.type === "chat.notification" && parsed.data) {
-      const notification = normalizeChatNotification(parsed.data as ChatNotification);
-      for (const listener of this.chatNotificationListeners) {
-        listener(notification);
-      }
-      return;
-    }
-
-    if (parsed?.type === "chat.presence" && typeof parsed.onlineCount === "number") {
-      for (const listener of this.chatPresenceListeners) {
-        listener(parsed.onlineCount);
-      }
-      return;
-    }
-
-    if (parsed?.type === "market.quote" && parsed.quote && typeof parsed.symbol === "string") {
-      const key = marketKey(parsed.symbol, parsed.exchange);
-      const target = this.quoteTargets.get(key) ?? {
-        symbol: normalizeSymbol(parsed.symbol),
-        exchange: canonicalExchange(parsed.exchange),
-      };
-      for (const listener of this.quoteListeners.get(key) ?? []) {
-        listener(target, parsed.quote as CloudQuotePayload);
-      }
-    }
-  }
-
-  async ensureVerifiedSession(): Promise<AuthUser | null> {
-    if (!this.sessionToken) return null;
-    if (!this.currentUser) {
-      await this.getSession();
-    }
-    return this.currentUser?.emailVerified ? this.currentUser : null;
-  }
-
-  async signUp(email: string, username: string, name: string, password: string): Promise<AuthUser> {
-    const result = await this.request<{ user: AuthUser }>("/auth/sign-up/email", {
-      method: "POST",
-      body: JSON.stringify({ email, username, name, password }),
-    });
-    this.requireCapturedSession(
-      "Account created, but Gloomberb could not save the login session. Please try logging in again.",
-    );
-    this.setCurrentUser(result.user);
-    return result.user;
-  }
-
-  async signIn(email: string, password: string): Promise<AuthUser> {
-    const result = await this.request<{ user: AuthUser }>("/auth/sign-in/email", {
-      method: "POST",
-      body: JSON.stringify({ email, password }),
-    });
-    this.requireCapturedSession(
-      "Logged in, but Gloomberb could not save the login session. Please try again.",
-    );
-    this.setCurrentUser(result.user);
-    return result.user;
-  }
-
-  async signOut(): Promise<void> {
-    try {
-      await this.request("/auth/sign-out", { method: "POST" });
-    } finally {
-      this.setSessionToken(null);
-    }
-  }
-
-  async getSession(): Promise<AuthUser | null> {
-    try {
-      const result = await this.request<{ user: AuthUser }>("/auth/get-session", {
-        method: "GET",
-      });
-      const user = result?.user ?? null;
-      this.setCurrentUser(user);
-      return user;
-    } catch (error) {
-      if (error instanceof ApiRequestError && isHardSessionInvalidMessage(error.message)) {
-        this.setSessionToken(null);
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  async sendVerification(): Promise<CloudVerificationResponse> {
-    return this.request<CloudVerificationResponse>("/cloud/auth/send-verification", {
-      method: "POST",
-      body: JSON.stringify({}),
-    });
-  }
-
-  async getChannels(): Promise<ChatChannel[]> {
-    return this.request<ChatChannel[]>("/chat/channels");
-  }
-
-  async getChatPresence(): Promise<{ onlineCount: number }> {
-    return this.request<{ onlineCount: number }>("/chat/presence");
-  }
-
-  async getChatState(): Promise<ChatStateResponse> {
-    const state = await this.request<ChatStateResponse>("/chat/state");
-    return normalizeChatState(state);
-  }
-
-  async updateChatChannelState(
-    channelId: string,
-    body: { notificationsEnabled?: boolean; readThroughMessageId?: string },
-  ): Promise<ChatChannelState> {
-    return this.request<ChatChannelState>(`/chat/channels/${channelId}/state`, {
-      method: "PATCH",
-      body: JSON.stringify(body),
-    });
-  }
-
-  async markChatNotificationsDelivered(notificationIds: string[]): Promise<{ delivered: number }> {
-    return this.request<{ delivered: number }>("/chat/notifications/delivered", {
-      method: "POST",
-      body: JSON.stringify({ notificationIds }),
-    });
-  }
-
-  async getMessages(
-    channelId: string,
-    opts?: { after?: string; before?: string; limit?: number },
-  ): Promise<ChatMessage[]> {
-    const params = new URLSearchParams();
-    if (opts?.after) params.set("after", opts.after);
-    if (opts?.before) params.set("before", opts.before);
-    if (opts?.limit) params.set("limit", String(opts.limit));
-    const qs = params.toString();
-    const messages = await this.request<ChatMessage[]>(`/chat/channels/${channelId}/messages${qs ? `?${qs}` : ""}`);
-    return normalizeChatMessages(messages);
-  }
-
-  async sendMessage(channelId: string, content: string, replyToId?: string, clientMessageId?: string): Promise<ChatMessage> {
-    const message = await this.request<ChatMessage>(`/chat/channels/${channelId}/messages`, {
-      method: "POST",
-      body: JSON.stringify({ content, replyToId, clientMessageId }),
-    });
-    return normalizeChatMessage(message);
-  }
-
-  connectChannel(
-    channelId: string,
-    onMessage: (msg: ChatMessage) => void,
-    onError?: (err: string) => void,
-  ): { send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>; close: () => void } {
-    if (!channelId) {
-      return {
-        send: async () => {
-          throw new Error("Channel id is required");
-        },
-        close: () => {},
-      };
-    }
-
-    const listeners = this.channelListeners.get(channelId) ?? new Set<ChannelListener>();
-    const firstListener = listeners.size === 0;
-    listeners.add(onMessage);
-    this.channelListeners.set(channelId, listeners);
-    this.ensureSocket();
-    if (firstListener) {
-      this.sendSocketMessage({ type: "chat.subscribe", channelId });
-    }
-
-    return {
-      send: async (content: string, replyToId?: string, clientMessageId?: string) => {
-        try {
-          const message = await this.sendMessage(channelId, content, replyToId, clientMessageId);
-          onMessage(message);
-          return message;
-        } catch (error) {
-          onError?.(error instanceof Error ? error.message : String(error));
-          throw error;
-        }
-      },
-      close: () => {
-        const current = this.channelListeners.get(channelId);
-        if (!current) return;
-        current.delete(onMessage);
-        if (current.size === 0) {
-          this.channelListeners.delete(channelId);
-          this.sendSocketMessage({ type: "chat.unsubscribe", channelId });
-        }
-        if (!this.shouldKeepSocketOpen()) {
-          this.teardownSocket();
-        }
-      },
-    };
-  }
-
-  subscribeChatNotifications(listener: ChatNotificationListener): () => void {
-    this.chatNotificationListeners.add(listener);
-    return () => {
-      this.chatNotificationListeners.delete(listener);
-    };
-  }
-
-  subscribeChatPresence(listener: ChatPresenceListener): () => void {
-    this.chatPresenceListeners.add(listener);
-    return () => {
-      this.chatPresenceListeners.delete(listener);
-    };
-  }
-
-  subscribeQuotes(
-    targets: QuoteStreamTarget[],
-    onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
-  ): () => void {
-    const uniqueTargets = [...new Map(
-      targets
-        .filter((target) => typeof target.symbol === "string" && target.symbol.trim().length > 0)
-        .map((target) => {
-          const normalized = {
-            symbol: normalizeSymbol(target.symbol),
-            exchange: canonicalExchange(target.exchange),
-            surface: target.surface,
-            visible: target.visible,
-            selected: target.selected,
-            weight: target.weight,
-          } satisfies QuoteStreamTarget;
-          return [marketKey(normalized.symbol, normalized.exchange), normalized] as const;
-        }),
-    ).values()];
-
-    const newSubscriptions: QuoteStreamTarget[] = [];
-    const updatedSubscriptions: QuoteStreamTarget[] = [];
-    for (const target of uniqueTargets) {
-      const key = marketKey(target.symbol, target.exchange);
-      const listeners = this.quoteListeners.get(key) ?? new Set<QuoteListener>();
-      if (listeners.size === 0) {
-        newSubscriptions.push(target);
-      } else {
-        const existing = this.quoteTargets.get(key);
-        if (JSON.stringify(this.serializeQuoteStreamTarget(existing ?? target)) !== JSON.stringify(this.serializeQuoteStreamTarget(target))) {
-          updatedSubscriptions.push(target);
-        }
-      }
-      listeners.add(onQuote);
-      this.quoteListeners.set(key, listeners);
-      this.quoteTargets.set(key, target);
-    }
-
-    this.ensureSocket();
-    const subscriptionsToSend = [...newSubscriptions, ...updatedSubscriptions];
-    if (subscriptionsToSend.length > 0) {
-      cloudApiLog.info("register quote listeners", {
-        count: subscriptionsToSend.length,
-        symbols: subscriptionsToSend.map((target) => marketKey(target.symbol, target.exchange)),
-      });
-      this.queueQuoteSubscribes(subscriptionsToSend);
-    }
-
-    return () => {
-      const removedTargets: QuoteStreamTarget[] = [];
-
-      for (const target of uniqueTargets) {
-        const key = marketKey(target.symbol, target.exchange);
-        const listeners = this.quoteListeners.get(key);
-        if (!listeners) continue;
-        listeners.delete(onQuote);
-        if (listeners.size === 0) {
-          this.quoteListeners.delete(key);
-          const storedTarget = this.quoteTargets.get(key);
-          if (storedTarget) {
-            removedTargets.push(storedTarget);
-          }
-          this.quoteTargets.delete(key);
-        }
-      }
-
-      if (removedTargets.length > 0) {
-        cloudApiLog.info("remove quote listeners", {
-          count: removedTargets.length,
-          symbols: removedTargets.map((target) => marketKey(target.symbol, target.exchange)),
-        });
-        this.queueQuoteUnsubscribes(removedTargets);
-      }
-
-      if (!this.shouldKeepSocketOpen()) {
-        this.teardownSocket();
-      }
-    };
-  }
-
-  dispose(): void {
-    cloudApiLog.info("dispose api client", {
-      quoteTargets: this.quoteTargets.size,
-      channelTargets: this.channelListeners.size,
-    });
-    this.channelListeners.clear();
-    this.chatNotificationListeners.clear();
-    this.chatPresenceListeners.clear();
-    this.quoteListeners.clear();
-    this.quoteTargets.clear();
-    this.pendingQuoteSubscribes.clear();
-    this.pendingQuoteUnsubscribes.clear();
-    if (this.quoteSubscriptionFlushTimer) {
-      clearTimeout(this.quoteSubscriptionFlushTimer);
-      this.quoteSubscriptionFlushTimer = null;
-    }
-    this.reconnectDelayMs = 1000;
-    this.teardownSocket();
-  }
-
-  async searchInstruments(query: string, limit = 10): Promise<InstrumentSearchResult[]> {
-    const params = new URLSearchParams({
-      q: query,
-      limit: String(limit),
-    });
-    const response = await this.request<CloudMarketResponse<InstrumentSearchResult[]>>(`/market/search?${params.toString()}`);
-    return response.data ?? [];
-  }
-
-  async getCloudQuote(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudQuotePayload>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<CloudQuotePayload>>(`/market/quote?${params.toString()}`);
-  }
-
-  async getCloudQuotesBatch(
-    targets: CloudMarketBatchTarget[],
-    mode: "cache-first" | "refresh" = "cache-first",
-  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<CloudQuotePayload>>> {
-    return this.request<CloudMarketResponse<CloudMarketBatchPayload<CloudQuotePayload>>>("/market/quotes/batch", {
-      method: "POST",
-      body: JSON.stringify({ targets, mode }),
-    });
-  }
-
-  async getCloudOptionsChain(
-    symbol: string,
-    exchange?: string,
-    expirationDate?: number,
-  ): Promise<CloudMarketResponse<CloudOptionsChainPayload>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    if (expirationDate != null) params.set("expirationDate", String(expirationDate));
-    return this.request<CloudMarketResponse<CloudOptionsChainPayload>>(`/market/options?${params.toString()}`);
-  }
-
-  async getCloudProfile(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCompanyProfile>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<CloudCompanyProfile>>(`/market/profile?${params.toString()}`);
-  }
-
-  async getCloudFundamentals(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudFundamentals>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<CloudFundamentals>>(`/market/fundamentals?${params.toString()}`);
-  }
-
-  async getCloudFinancials(symbol: string, exchange?: string): Promise<CloudMarketResponse<TickerFinancials>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<TickerFinancials>>(`/market/financials?${params.toString()}`);
-  }
-
-  async getCloudFinancialsBatch(
-    targets: CloudMarketBatchTarget[],
-    mode: "cache-first" | "refresh" = "cache-first",
-  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<TickerFinancials>>> {
-    return this.request<CloudMarketResponse<CloudMarketBatchPayload<TickerFinancials>>>("/market/financials/batch", {
-      method: "POST",
-      body: JSON.stringify({ targets, mode }),
-    });
-  }
-
-  async getCloudHolders(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudHoldersPayload>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<CloudHoldersPayload>>(`/market/holders?${params.toString()}`);
-  }
-
-  async getCloudAnalystResearch(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudAnalystResearchPayload>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<CloudAnalystResearchPayload>>(`/market/analyst?${params.toString()}`);
-  }
-
-  async getCloudCorporateActions(symbol: string, exchange?: string): Promise<CloudMarketResponse<CloudCorporateActionsPayload>> {
-    const params = new URLSearchParams({ symbol });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<CloudCorporateActionsPayload>>(`/market/corporate-actions?${params.toString()}`);
-  }
-
-  async getCloudStatements(
-    symbol: string,
-    exchange?: string,
-    period: "annual" | "quarterly" | "both" = "both",
-  ): Promise<CloudMarketResponse<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>> {
-    const params = new URLSearchParams({ symbol, period });
-    if (exchange) params.set("exchange", exchange);
-    return this.request<CloudMarketResponse<Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">>>(`/market/statements?${params.toString()}`);
-  }
-
-  async getCloudHistory(
-    symbol: string,
-    exchange: string,
-    params: {
-      interval?: string;
-      outputsize?: number;
-      startDate?: string;
-      endDate?: string;
-      rangeKey?: string;
-    } = {},
-  ): Promise<CloudMarketResponse<CloudPricePointPayload[]>> {
-    const search = new URLSearchParams({ symbol, exchange });
-    if (params.interval) search.set("interval", params.interval);
-    if (params.outputsize != null) search.set("outputsize", String(params.outputsize));
-    if (params.startDate) search.set("startDate", params.startDate);
-    if (params.endDate) search.set("endDate", params.endDate);
-    if (params.rangeKey) search.set("rangeKey", params.rangeKey);
-    return this.request<CloudMarketResponse<CloudPricePointPayload[]>>(`/market/history?${search.toString()}`);
-  }
-
-  async getCloudExchangeRate(fromCurrency: string): Promise<CloudMarketResponse<{ rate: number }>> {
-    const params = new URLSearchParams({ fromCurrency });
-    return this.request<CloudMarketResponse<{ rate: number }>>(`/market/exchange-rate?${params.toString()}`);
-  }
-
-  async getCloudEconomicCalendar(): Promise<CloudEconEventPayload[]> {
-    return this.request<CloudEconEventPayload[]>("/cloud/econ/calendar");
-  }
-
-  async getCloudFredSeries(
-    seriesId: string,
-    params: {
-      startDate?: string;
-      endDate?: string;
-      limit?: number;
-      sortOrder?: "asc" | "desc";
-    } = {},
-  ): Promise<CloudFredSeriesPayload> {
-    const search = new URLSearchParams();
-    if (params.startDate) search.set("startDate", params.startDate);
-    if (params.endDate) search.set("endDate", params.endDate);
-    if (params.limit != null) search.set("limit", String(params.limit));
-    if (params.sortOrder) search.set("sortOrder", params.sortOrder);
-    const qs = search.toString();
-    return this.request<CloudFredSeriesPayload>(`/cloud/econ/series/${encodeURIComponent(seriesId)}${qs ? `?${qs}` : ""}`);
-  }
-
-  async getCloudYieldCurve(): Promise<CloudYieldPointPayload[]> {
-    return this.request<CloudYieldPointPayload[]>("/cloud/econ/yield-curve");
-  }
-
-  async getCloudNews(params: {
-    feed?: "latest" | "top" | "breaking" | "ticker" | "sector" | "topic";
-    ticker?: string;
-    exchange?: string;
-    tickerTier?: "primary" | "related" | "any";
-    tickerRelations?: string[];
-    limit?: number;
-    topics?: string[];
-    categories?: string[];
-    sectors?: string[];
-    sources?: string[];
-    excludeSources?: string[];
-    sentiment?: "positive" | "neutral" | "negative";
-    minImportance?: number;
-    minUrgency?: number;
-    breaking?: boolean;
-    since?: Date;
-    until?: Date;
-    cursor?: string;
-  } = {}): Promise<CloudNewsListResponse> {
-    const search = new URLSearchParams();
-    if (params.feed) search.set("feed", params.feed);
-    if (params.ticker) {
-      const tickerFilter = params.exchange
-        ? publicTickerKey(params.ticker, params.exchange)
-        : normalizeSymbol(params.ticker);
-      search.set("tickers", tickerFilter);
-    }
-    if (params.tickerTier) search.set("tickerTier", params.tickerTier);
-    if (params.tickerRelations?.length) search.set("tickerRelations", params.tickerRelations.join(","));
-    if (params.limit != null) search.set("limit", String(params.limit));
-    if (params.topics?.length) search.set("topics", params.topics.join(","));
-    if (params.categories?.length) {
-      search.set("categories", params.categories.join(","));
-    }
-    if (params.sectors?.length) search.set("sectors", params.sectors.join(","));
-    if (params.sources?.length) search.set("sources", params.sources.join(","));
-    if (params.excludeSources?.length) search.set("excludeSources", params.excludeSources.join(","));
-    if (params.sentiment) search.set("sentiment", params.sentiment);
-    if (params.minImportance != null) search.set("minImportance", String(params.minImportance));
-    if (params.minUrgency != null) search.set("minUrgency", String(params.minUrgency));
-    if (params.breaking != null) search.set("breaking", String(params.breaking));
-    if (params.since) search.set("since", params.since.toISOString());
-    if (params.until) search.set("until", params.until.toISOString());
-    if (params.cursor) search.set("cursor", params.cursor);
-    const query = search.toString();
-    return this.request<CloudNewsListResponse>(`/news${query ? `?${query}` : ""}`);
-  }
-
-  async getCloudNewsStory(storyId: string): Promise<CloudNewsPayload> {
-    return this.request<CloudNewsPayload>(`/news/${encodeURIComponent(storyId)}`);
-  }
-
-  async getCloudTickerTweets(params: {
-    ticker: string;
-    limit?: number;
-    hours?: number;
-    includeReplies?: boolean;
-  }): Promise<CloudTweetSearchResponse> {
-    const search = new URLSearchParams({ ticker: params.ticker });
-    if (params.limit != null) search.set("limit", String(params.limit));
-    if (params.hours != null) search.set("hours", String(params.hours));
-    if (params.includeReplies != null) search.set("includeReplies", String(params.includeReplies));
-    const response = await this.request<CloudTweetSearchResponse>(`/news/tweets?${search.toString()}`);
-    return normalizeTweetSearchResponse(response);
-  }
-
-  async searchCloudTweets(params: {
-    query: string;
-    queryType?: CloudTweetQueryType;
-    limit?: number;
-    hours?: number;
-  }): Promise<CloudTweetSearchResponse> {
-    const search = new URLSearchParams({ query: params.query });
-    if (params.queryType) search.set("queryType", params.queryType);
-    if (params.limit != null) search.set("limit", String(params.limit));
-    if (params.hours != null) search.set("hours", String(params.hours));
-    const response = await this.request<CloudTweetSearchResponse>(`/news/tweets/search?${search.toString()}`);
-    return normalizeTweetSearchResponse(response);
-  }
-}
-
-export const apiClient = new GloomApiClient();
-export type { PricePoint };