gloomberb 0.11.0 → 0.11.2

package/src/shares/api.ts

@@ -0,0 +1,127 @@
+import { apiClient } from "../api-client";
+import { ApiRequestError } from "../api-client/errors";
+import { parseSharePayload, type SharePayload } from "./payload";
+
+declare const __GLOOMBERB_API_URL__: string | undefined;
+
+const bundledApiOrigin = typeof __GLOOMBERB_API_URL__ === "string" ? __GLOOMBERB_API_URL__ : "";
+export const SHARE_API_ORIGIN = bundledApiOrigin
+  ? typeof location !== "undefined" && bundledApiOrigin === location.origin
+    ? `${bundledApiOrigin}/api`
+    : bundledApiOrigin
+  : "https://api.gloom.sh";
+export const PUBLIC_SHARE_ORIGIN = "https://term.gloom.sh";
+const SHARE_ID = /^[a-f0-9]{32}$/;
+type ShareFetch = (input: string, init?: RequestInit) => Promise<Response>;
+
+export type ShareRecord = SharePayload & {
+  createdAt: string;
+  expiresAt: string;
+  ownedByViewer: boolean;
+};
+
+export interface CreatedShare {
+  id: string;
+  expiresAt: string;
+}
+
+function validDate(value: unknown): value is string {
+  return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+
+async function readJson(response: Response): Promise<unknown> {
+  try { return await response.json(); } catch { throw new Error("The share service returned an invalid response."); }
+}
+
+export async function createShare(payload: SharePayload, fetchImpl?: ShareFetch): Promise<CreatedShare> {
+  const validated = parseSharePayload(payload);
+  if (!validated) throw new Error("Invalid share payload.");
+  let body: unknown;
+  if (fetchImpl) {
+    const response = await fetchImpl(`${SHARE_API_ORIGIN}/shares`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(validated),
+    });
+    if (!response.ok) {
+      if (response.status === 401) throw new Error("Sign in to Gloom Cloud to share.");
+      if (response.status === 403) throw new Error("Verify your Gloom Cloud email to share.");
+      throw new Error("Could not create share.");
+    }
+    body = await readJson(response);
+  } else {
+    try {
+      body = await apiClient.createTerminalShare(validated);
+    } catch (error) {
+      if (error instanceof ApiRequestError && error.status === 401) throw new Error("Sign in to Gloom Cloud to share.");
+      if (error instanceof ApiRequestError && error.status === 403) throw new Error("Verify your Gloom Cloud email to share.");
+      throw error;
+    }
+  }
+  if (!body || typeof body !== "object") throw new Error("The share service returned an invalid response.");
+  const { id, expiresAt } = body as Record<string, unknown>;
+  if (typeof id !== "string" || !SHARE_ID.test(id) || !validDate(expiresAt)) {
+    throw new Error("The share service returned an invalid response.");
+  }
+  return { id, expiresAt };
+}
+
+export async function getShare(
+  id: string,
+  fetchImpl: ShareFetch = fetch,
+  options?: { trackView?: boolean },
+): Promise<ShareRecord | null> {
+  if (!SHARE_ID.test(id)) return null;
+  const purpose = options?.trackView === false ? "?purpose=open" : "";
+  const response = await fetchImpl(`${SHARE_API_ORIGIN}/shares/${encodeURIComponent(id)}${purpose}`, {
+    credentials: "include",
+  });
+  if (response.status === 404) return null;
+  if (!response.ok) throw new Error("Could not load share.");
+  const body = await readJson(response);
+  if (!body || typeof body !== "object") return null;
+  const object = body as Record<string, unknown>;
+  const payload = parseSharePayload({ kind: object.kind, data: object.data });
+  if (!payload || !validDate(object.createdAt) || !validDate(object.expiresAt)) return null;
+  return {
+    ...payload,
+    createdAt: object.createdAt,
+    expiresAt: object.expiresAt,
+    ownedByViewer: object.ownedByViewer === true,
+  };
+}
+
+export async function deleteShare(id: string, fetchImpl: ShareFetch = fetch): Promise<void> {
+  if (!SHARE_ID.test(id)) throw new Error("Invalid share id.");
+  const response = await fetchImpl(`${SHARE_API_ORIGIN}/shares/${encodeURIComponent(id)}`, {
+    method: "DELETE",
+    credentials: "include",
+  });
+  if (response.status !== 204) {
+    throw new Error(response.status === 401 || response.status === 403
+      ? "Only the signed-in owner can delete this share."
+      : "Could not delete share.");
+  }
+}
+
+export function publicShareUrl(id: string, origin = PUBLIC_SHARE_ORIGIN): string {
+  if (!SHARE_ID.test(id)) throw new Error("Invalid share id.");
+  return new URL(`/s/${encodeURIComponent(id)}`, origin).toString();
+}
+
+export function openLiveShareUrl(id: string, origin = PUBLIC_SHARE_ORIGIN): string {
+  if (!SHARE_ID.test(id)) throw new Error("Invalid share id.");
+  return new URL(`/api/shares/${encodeURIComponent(id)}/open`, origin).toString();
+}
+
+export function parseShareId(pathname: string): string | null {
+  const match = /^\/s\/([^/]+)\/?$/.exec(pathname);
+  if (!match) return null;
+  try {
+    const id = decodeURIComponent(match[1] ?? "");
+    return SHARE_ID.test(id) ? id : null;
+  } catch {
+    return null;
+  }
+}

package/src/shares/chart-snapshot.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test";
+import type { ResolvedSeries } from "../time-series/types";
+import { buildChartShareData } from "./chart-snapshot";
+
+function series(pointCount: number): ResolvedSeries {
+  return {
+    id: "price",
+    label: "AAPL",
+    color: "#fff",
+    unit: "USD",
+    unitGroup: "currency:USD",
+    nativeFrequency: "daily",
+    dataShape: "scalar",
+    style: "line",
+    transform: "raw",
+    axis: "left",
+    panelId: "main",
+    interpolation: "none",
+    points: Array.from({ length: pointCount }, (_, index) => ({
+      date: new Date(Date.UTC(2025, 0, index + 1)),
+      observedAt: new Date(Date.UTC(2025, 0, index + 1)),
+      value: index,
+    })),
+  };
+}
+
+describe("chart share snapshots", () => {
+  test("keeps endpoints while bounding shared chart points", () => {
+    const shared = buildChartShareData([series(1_000)]);
+    expect(shared?.series[0]?.points).toHaveLength(500);
+    expect(shared?.series[0]?.points[0]?.y).toBe(0);
+    expect(shared?.series[0]?.points.at(-1)?.y).toBe(999);
+  });
+})

package/src/shares/chart-snapshot.ts

@@ -0,0 +1,28 @@
+import type { ResolvedSeries } from "../time-series/types";
+import type { ChartShareData } from "./payload";
+
+const MAX_POINTS = 500;
+
+function sample<T>(values: T[], limit: number): T[] {
+  if (values.length <= limit) return values;
+  return Array.from({ length: limit }, (_, index) => (
+    values[Math.round(index * (values.length - 1) / (limit - 1))]!
+  ));
+}
+
+export function buildChartShareData(series: ResolvedSeries[]): ChartShareData | null {
+  const sharedSeries = series.flatMap((entry) => {
+    const points = entry.points.flatMap((point) => {
+      const y = point.value ?? point.close;
+      return typeof y === "number" && Number.isFinite(y)
+        ? [{ x: point.date.toISOString(), y }]
+        : [];
+    });
+    return points.length > 0 ? [{ name: entry.label, points: sample(points, MAX_POINTS) }] : [];
+  });
+  if (sharedSeries.length === 0) return null;
+  return {
+    title: sharedSeries.map((entry) => entry.name).join(" / "),
+    series: sharedSeries,
+  };
+}

package/src/shares/location.test.ts

@@ -0,0 +1,19 @@
+import { afterEach, expect, test } from "bun:test";
+import { isPaneShareHandoff, paneShareIdFromSearch } from "./location";
+
+const originalWindow = (globalThis as { window?: unknown }).window;
+
+afterEach(() => {
+  if (originalWindow === undefined) delete (globalThis as { window?: unknown }).window;
+  else (globalThis as { window?: unknown }).window = originalWindow;
+});
+
+test("pane share handoff tolerates renderer globals without browser location", () => {
+  (globalThis as { window?: unknown }).window = {};
+  expect(isPaneShareHandoff()).toBe(false);
+
+  const id = "0123456789abcdef0123456789abcdef";
+  (globalThis as { window?: unknown }).window = { location: { search: `?share=${id}` } };
+  expect(isPaneShareHandoff()).toBe(true);
+  expect(paneShareIdFromSearch(`?share=${id}`)).toBe(id);
+});

package/src/shares/location.ts

@@ -0,0 +1,11 @@
+const SHARE_ID = /^[a-f0-9]{32}$/;
+
+export function paneShareIdFromSearch(search: string): string | null {
+  const id = new URLSearchParams(search).get("share")?.trim() ?? "";
+  return SHARE_ID.test(id) ? id : null;
+}
+
+export function isPaneShareHandoff(): boolean {
+  const location = (globalThis as { window?: { location?: { search?: unknown } } }).window?.location;
+  return typeof location?.search === "string" && paneShareIdFromSearch(location.search) !== null;
+}

package/src/shares/pane.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+import type { LayoutMarketplacePayload } from "../layout-marketplace/payload";
+import type { PaneDef, PaneTemplateDef } from "../types/plugin";
+import { buildPaneSharePayload, openPaneShare } from "./pane";
+
+const paneDef: PaneDef = {
+  id: "ticker-news",
+  name: "Ticker News",
+  component: () => null,
+  defaultPosition: "right",
+};
+
+function registry(template?: PaneTemplateDef, pane: PaneDef = paneDef) {
+  const opened: unknown[] = [];
+  const portable: LayoutMarketplacePayload[] = [];
+  return {
+    opened,
+    portable,
+    panes: new Map([[pane.id, pane]]),
+    paneTemplates: new Map(template ? [[template.id, template]] : []),
+    createPaneFromTemplateAsyncFn: async (templateId: string, options: unknown) => {
+      opened.push([templateId, options]);
+    },
+    openPortablePaneShareAsyncFn: async (layout: LayoutMarketplacePayload) => {
+      portable.push(layout);
+    },
+  } as any;
+}
+
+describe("public pane shares", () => {
+  test("publishes registered panes through the generic portable projection", async () => {
+    const pluginRegistry = registry({
+      id: "ticker-news-pane",
+      paneId: "ticker-news",
+      label: "Ticker News",
+      description: "Current news for a ticker.",
+    });
+    const payload = buildPaneSharePayload(pluginRegistry, {
+      instanceId: "news:private-local-id",
+      paneId: "ticker-news",
+      title: "AAPL News",
+      binding: { kind: "fixed", symbol: "AAPL" },
+      params: { query: "earnings" },
+      settings: { dense: true, sessionToken: "secret" },
+    }, {
+      pluginState: { news: { selectedTab: "latest", accessToken: "secret" } },
+    });
+
+    expect(payload).toMatchObject({
+      kind: "pane",
+      data: {
+        version: 2,
+        title: "AAPL News",
+        description: "Current news for a ticker.",
+        layout: {
+          schemaVersion: 2,
+          layout: {
+            instances: [{
+              instanceId: "p1",
+              paneId: "ticker-news",
+              binding: { kind: "fixed", symbol: "AAPL" },
+              params: { query: "earnings" },
+              settings: { dense: true },
+            }],
+          },
+          paneState: {
+            p1: { pluginState: { news: { selectedTab: "latest" } } },
+          },
+        },
+      },
+    });
+    expect(JSON.stringify(payload)).not.toContain("private-local-id");
+    expect(JSON.stringify(payload)).not.toContain("secret");
+
+    await openPaneShare(pluginRegistry, payload!.data);
+    expect(pluginRegistry.portable).toEqual([payload!.data.version === 2 ? payload!.data.layout : null]);
+  });
+
+  test("opens legacy adapter shares for existing links", async () => {
+    const template: PaneTemplateDef = {
+      id: "ticker-news-pane",
+      paneId: "ticker-news",
+      label: "Ticker News",
+      description: "Current news for a ticker.",
+      publicShare: {
+        serialize: () => null,
+        restore: (data) => typeof data.symbol === "string" ? { symbol: data.symbol } : null,
+      },
+    };
+    const pluginRegistry = registry(template);
+
+    await openPaneShare(pluginRegistry, {
+      version: 1,
+      templateId: template.id,
+      title: "AAPL News",
+      data: { symbol: "AAPL" },
+    });
+
+    expect(pluginRegistry.opened).toEqual([["ticker-news-pane", { symbol: "AAPL" }]]);
+  });
+
+  test("does not share unregistered panes", () => {
+    const pluginRegistry = registry();
+    pluginRegistry.panes.clear();
+    expect(buildPaneSharePayload(pluginRegistry, {
+      instanceId: "missing:main",
+      paneId: "missing",
+    })).toBeNull();
+  });
+});

package/src/shares/pane.ts

@@ -0,0 +1,54 @@
+import {
+  publishableMarketplacePane,
+} from "../layout-marketplace/payload";
+import type { PluginRegistry } from "../plugins/registry";
+import type { PaneInstanceConfig } from "../types/config";
+import { parseSharePayload, type PaneShareData, type SharePayload } from "./payload";
+
+export function buildPaneSharePayload(
+  pluginRegistry: PluginRegistry,
+  pane: PaneInstanceConfig,
+  paneState: Record<string, unknown> = {},
+  resolvedTicker?: string | null,
+): Extract<SharePayload, { kind: "pane" }> | null {
+  const def = pluginRegistry.panes.get(pane.paneId);
+  if (!def) return null;
+  try {
+    const layout = publishableMarketplacePane(
+      pane,
+      paneState,
+      pluginRegistry.panes,
+      resolvedTicker,
+    );
+    const instance = layout.layout.instances[0]!;
+    const description = [...pluginRegistry.paneTemplates.values()]
+      .find((template) => template.paneId === pane.paneId)?.description;
+    const payload = parseSharePayload({
+      kind: "pane",
+      data: {
+        version: 2,
+        title: instance.title ?? def.name,
+        ...(description ? { description } : {}),
+        layout,
+      },
+    });
+    return payload?.kind === "pane" ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function openPaneShare(
+  pluginRegistry: PluginRegistry,
+  share: PaneShareData,
+): Promise<void> {
+  if (share.version === 2) {
+    await pluginRegistry.openPortablePaneShareAsyncFn(share.layout);
+    return;
+  }
+  const template = pluginRegistry.paneTemplates.get(share.templateId);
+  if (!template?.publicShare) throw new Error("This shared pane is unavailable in this version of Gloomberb.");
+  const options = template.publicShare.restore(share.data);
+  if (!options) throw new Error("This shared pane contains invalid settings.");
+  await pluginRegistry.createPaneFromTemplateAsyncFn(template.id, options);
+}

package/src/shares/payload.ts

@@ -0,0 +1,177 @@
+import {
+  parseMarketplaceLayoutPayload,
+  type LayoutMarketplacePayload,
+} from "../layout-marketplace/payload";
+import { safeExternalUrl } from "../utils/external-url";
+
+export const MAX_SHARE_BYTES = 128 * 1024;
+const MAX_TITLE_LENGTH = 200;
+const MAX_TEXT_LENGTH = 50_000;
+const MAX_TABLE_COLUMNS = 20;
+const MAX_TABLE_ROWS = 200;
+const MAX_CHART_SERIES = 20;
+const MAX_CHART_POINTS = 500;
+const MAX_PANE_DESCRIPTION_LENGTH = 500;
+const MAX_PANE_DATA_DEPTH = 8;
+const MAX_PANE_OBJECT_KEYS = 64;
+const MAX_PANE_ARRAY_ITEMS = 5_000;
+const MAX_PANE_STRING_LENGTH = 4_096;
+const PANE_TEMPLATE_ID = /^[a-z0-9][a-z0-9._:-]{0,119}$/;
+
+type CellValue = string | number | boolean | null;
+export type ShareJsonValue = CellValue | ShareJsonValue[] | { [key: string]: ShareJsonValue };
+
+export interface TableShareData {
+  title: string;
+  columns: Array<{ key: string; label: string }>;
+  rows: Array<Record<string, CellValue>>;
+  sourceUrl?: string;
+}
+
+export interface ChartShareData {
+  title: string;
+  series: Array<{
+    name: string;
+    points: Array<{ x: string | number; y: number }>;
+  }>;
+  sourceUrl?: string;
+}
+
+export interface ArticleShareData {
+  title: string;
+  text: string;
+  sourceUrl?: string;
+}
+
+export interface LegacyPaneShareData {
+  version: 1;
+  templateId: string;
+  title: string;
+  description?: string;
+  data: Record<string, ShareJsonValue>;
+}
+
+export interface PortablePaneShareData {
+  version: 2;
+  title: string;
+  description?: string;
+  layout: LayoutMarketplacePayload;
+}
+
+export type PaneShareData = LegacyPaneShareData | PortablePaneShareData;
+
+export type SharePayload =
+  | { kind: "table"; data: TableShareData }
+  | { kind: "chart"; data: ChartShareData }
+  | { kind: "article"; data: ArticleShareData }
+  | { kind: "pane"; data: PaneShareData };
+
+function record(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function shortString(value: unknown, max = MAX_TITLE_LENGTH): value is string {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+
+function safeOptionalUrl(value: unknown): value is string | undefined {
+  return value === undefined || (typeof value === "string" && safeExternalUrl(value) !== null);
+}
+
+function isCell(value: unknown): value is CellValue {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+
+function isTableData(value: unknown): value is TableShareData {
+  if (!record(value) || !shortString(value.title) || !safeOptionalUrl(value.sourceUrl)) return false;
+  if (!Array.isArray(value.columns) || value.columns.length === 0 || value.columns.length > MAX_TABLE_COLUMNS) return false;
+  const keys = new Set<string>();
+  for (const column of value.columns) {
+    if (!record(column) || !shortString(column.key, 80) || !shortString(column.label, 120) || keys.has(column.key)) return false;
+    keys.add(column.key);
+  }
+  return Array.isArray(value.rows)
+    && value.rows.length <= MAX_TABLE_ROWS
+    && value.rows.every((row) => record(row)
+      && Object.keys(row).every((key) => keys.has(key))
+      && Object.values(row).every(isCell));
+}
+
+function isChartData(value: unknown): value is ChartShareData {
+  if (!record(value) || !shortString(value.title) || !safeOptionalUrl(value.sourceUrl)) return false;
+  return Array.isArray(value.series)
+    && value.series.length > 0
+    && value.series.length <= MAX_CHART_SERIES
+    && value.series.every((series) => record(series)
+      && shortString(series.name, 120)
+      && Array.isArray(series.points)
+      && series.points.length > 0
+      && series.points.length <= MAX_CHART_POINTS
+      && series.points.every((point) => record(point)
+        && ((typeof point.x === "string" && point.x.length <= 100) || (typeof point.x === "number" && Number.isFinite(point.x)))
+        && typeof point.y === "number"
+        && Number.isFinite(point.y)));
+}
+
+function isArticleData(value: unknown): value is ArticleShareData {
+  return record(value)
+    && shortString(value.title)
+    && typeof value.text === "string"
+    && value.text.length <= MAX_TEXT_LENGTH
+    && safeOptionalUrl(value.sourceUrl);
+}
+
+function boundedJson(value: unknown, depth = 0): value is ShareJsonValue {
+  if (value === null || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return value.length <= MAX_PANE_STRING_LENGTH;
+  if (depth >= MAX_PANE_DATA_DEPTH) return false;
+  if (Array.isArray(value)) {
+    return value.length <= MAX_PANE_ARRAY_ITEMS && value.every((entry) => boundedJson(entry, depth + 1));
+  }
+  if (!record(value)) return false;
+  const entries = Object.entries(value);
+  return entries.length <= MAX_PANE_OBJECT_KEYS && entries.every(([, entry]) => boundedJson(entry, depth + 1));
+}
+
+function parsePaneData(value: unknown): PaneShareData | null {
+  if (!record(value) || !shortString(value.title)) return null;
+  if (
+    value.version === 1
+    && Object.keys(value).every((key) => ["version", "templateId", "title", "description", "data"].includes(key))
+    && typeof value.templateId === "string"
+    && PANE_TEMPLATE_ID.test(value.templateId)
+    && (value.description === undefined || shortString(value.description, MAX_PANE_DESCRIPTION_LENGTH))
+    && record(value.data)
+    && boundedJson(value.data)
+  ) return value as unknown as LegacyPaneShareData;
+  if (
+    value.version !== 2
+    || !Object.keys(value).every((key) => ["version", "title", "description", "layout"].includes(key))
+    || (value.description !== undefined && !shortString(value.description, MAX_PANE_DESCRIPTION_LENGTH))
+  ) return null;
+  const layout = parseMarketplaceLayoutPayload(value.layout);
+  return layout?.schemaVersion === 2 && layout.layout.instances.length === 1
+    ? {
+        version: 2,
+        title: value.title,
+        ...(value.description === undefined ? {} : { description: value.description }),
+        layout,
+      }
+    : null;
+}
+
+export function parseSharePayload(value: unknown): SharePayload | null {
+  if (!record(value) || !shortString(value.kind, 20) || !("data" in value)) return null;
+  let json: string;
+  try { json = JSON.stringify(value); } catch { return null; }
+  if (new TextEncoder().encode(json).byteLength > MAX_SHARE_BYTES) return null;
+  if (value.kind === "table" && isTableData(value.data)) return value as unknown as SharePayload;
+  if (value.kind === "chart" && isChartData(value.data)) return value as unknown as SharePayload;
+  if (value.kind === "article" && isArticleData(value.data)) return value as unknown as SharePayload;
+  if (value.kind === "pane") {
+    const data = parsePaneData(value.data);
+    if (data) return { kind: "pane", data };
+  }
+  return null;
+}

package/src/sources/gloomberb-cloud/index.test.ts

@@ -18,6 +18,7 @@ const verifiedUser: AuthUser = {
 const originalEnsureVerifiedSession = apiClient.ensureVerifiedSession.bind(apiClient);
 const originalGetCloudHistory = apiClient.getCloudHistory.bind(apiClient);
 const originalGetCloudQuote = apiClient.getCloudQuote.bind(apiClient);
+const originalGetCloudExchangeRate = apiClient.getCloudExchangeRate.bind(apiClient);
 const originalGetCloudHolders = apiClient.getCloudHolders.bind(apiClient);
 const originalGetCloudAnalystResearch = apiClient.getCloudAnalystResearch.bind(apiClient);
 const originalGetCloudCorporateActions = apiClient.getCloudCorporateActions.bind(apiClient);
@@ -88,6 +89,7 @@ afterEach(() => {
   apiClient.ensureVerifiedSession = originalEnsureVerifiedSession;
   apiClient.getCloudHistory = originalGetCloudHistory;
   apiClient.getCloudQuote = originalGetCloudQuote;
+  apiClient.getCloudExchangeRate = originalGetCloudExchangeRate;
   apiClient.getCloudHolders = originalGetCloudHolders;
   apiClient.getCloudAnalystResearch = originalGetCloudAnalystResearch;
   apiClient.getCloudCorporateActions = originalGetCloudCorporateActions;
@@ -98,7 +100,65 @@ afterEach(() => {
 });
 
 describe("GloomberbCloudProvider", () => {
-  test("fetches detailed intraday chart history with Twelve Data intervals", async () => {
+  test("uses public delayed market routes anonymously but keeps research protected", async () => {
+    let sessionChecks = 0;
+    apiClient.ensureVerifiedSession = async () => {
+      sessionChecks += 1;
+      return null;
+    };
+    apiClient.getCloudQuote = async () => ({
+      status: "success",
+      data: {
+        symbol: "AAPL",
+        providerId: "gloomberb-cloud",
+        price: 200,
+        currency: "USD",
+        change: 1,
+        changePercent: 0.5,
+        lastUpdated: Date.now(),
+        dataSource: "delayed",
+      },
+    });
+    apiClient.getCloudHistory = async () => ({
+      status: "success",
+      providerMeta: { provider: "yahoo" },
+      data: [{ date: "2026-08-21", close: 200 }],
+    });
+    apiClient.getCloudOptionsChain = async () => ({
+      status: "success",
+      data: {
+        providerId: "gloomberb-cloud",
+        underlyingSymbol: "AAPL",
+        expirationDates: [1_800_000_000],
+        calls: [],
+        puts: [],
+        dataSource: "delayed",
+        feed: "yahoo",
+        delayMinutes: 15,
+        realtimeEligible: false,
+        asOf: "2026-08-21T20:00:00.000Z",
+      },
+    });
+    apiClient.getCloudExchangeRate = async () => ({
+      status: "success",
+      data: { rate: 1.25 },
+    });
+
+    const provider = new GloomberbCloudProvider();
+    expect(await provider.canProvide()).toBe(true);
+    expect((await provider.getQuote("AAPL", "NASDAQ")).price).toBe(200);
+    expect(await provider.getPriceHistory("AAPL", "NASDAQ", "1M")).toHaveLength(1);
+    expect((await provider.getOptionsChain("AAPL", "NASDAQ")).feed).toBe("yahoo");
+    expect(await provider.getExchangeRate("GBP")).toBe(1.25);
+    expect(sessionChecks).toBe(0);
+
+    await expect(provider.getAnalystResearch("AAPL", "NASDAQ")).rejects.toThrow(
+      "requires signup and email verification",
+    );
+    expect(sessionChecks).toBe(1);
+  });
+
+  test("fetches detailed intraday chart history with cloud intervals", async () => {
     apiClient.ensureVerifiedSession = async () => verifiedUser;
 
     const requestArgs: { current: { symbol: string; exchange: string; params: Record<string, string | number | undefined> } | null } = { current: null };