gloomberb 0.6.1 → 0.7.1

package/src/renderers/opentui/chart-surface.tsx

@@ -0,0 +1,179 @@
+import { createElement, forwardRef, useCallback, useEffect, useMemo, useRef, useState, type ForwardedRef, type ReactNode } from "react";
+import {
+  computeBitmapSize,
+  intersectCellRects,
+  type CellRect,
+  type NativeChartBitmap,
+} from "../../components/chart/native/chart-rasterizer";
+import { getCachedKittySupport, ensureKittySupport } from "../../components/chart/native/kitty-support";
+import { getNativeSurfaceManager } from "../../components/chart/native/surface-manager";
+import {
+  getRenderableCellRect,
+  resolveNativeSurfaceVisibleRect,
+  type NativeSurfaceRenderableNode,
+} from "../../components/chart/native/surface-visibility";
+import { useOptionalPaneInstanceId } from "../../state/app-context";
+import { useNativeRenderer, type BoxRenderable, type ChartSurfaceProps } from "../../ui";
+
+interface NativeRenderableNode extends BoxRenderable, NativeSurfaceRenderableNode {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  parent: NativeRenderableNode | null;
+  onLifecyclePass: (() => void) | null;
+}
+
+interface SurfaceTarget {
+  rect: CellRect;
+  visibleRect: CellRect | null;
+  bitmapKey: string;
+}
+
+let nextChartSurfaceId = 1;
+
+function assignRef(ref: ForwardedRef<unknown>, value: unknown) {
+  if (typeof ref === "function") {
+    ref(value);
+    return;
+  }
+  if (ref) {
+    (ref as { current: unknown }).current = value;
+  }
+}
+
+function sameRect(left: CellRect | null, right: CellRect | null): boolean {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  return left.x === right.x
+    && left.y === right.y
+    && left.width === right.width
+    && left.height === right.height;
+}
+
+function sameTarget(left: SurfaceTarget | null, right: SurfaceTarget | null): boolean {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  return left.bitmapKey === right.bitmapKey
+    && sameRect(left.rect, right.rect)
+    && sameRect(left.visibleRect, right.visibleRect);
+}
+
+function hashBitmap(bitmap: NativeChartBitmap): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < bitmap.pixels.length; index += 1) {
+    hash ^= bitmap.pixels[index]!;
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16);
+}
+
+function bitmapKey(bitmap: NativeChartBitmap): string {
+  return `${bitmap.width}x${bitmap.height}:${hashBitmap(bitmap)}`;
+}
+
+export const OpenTuiChartSurface = forwardRef<unknown, ChartSurfaceProps>(function OpenTuiChartSurface(
+  { children, bitmap, bitmaps, crosshair: _crosshair, ...props },
+  forwardedRef,
+) {
+  const renderer = useNativeRenderer();
+  const paneId = useOptionalPaneInstanceId();
+  const nativeSurfaceManager = useMemo(() => getNativeSurfaceManager(renderer), [renderer]);
+  const surfaceId = useRef(`opentui-chart:${nextChartSurfaceId++}`).current;
+  const renderableRef = useRef<NativeRenderableNode | null>(null);
+  const [kittySupport, setKittySupport] = useState<boolean | null>(() => getCachedKittySupport(renderer));
+  const [target, setTarget] = useState<SurfaceTarget | null>(null);
+  const nativeBitmap = (bitmaps?.[0] ?? bitmap ?? null) as NativeChartBitmap | null;
+  const nativeBitmapKey = useMemo(() => (nativeBitmap ? bitmapKey(nativeBitmap) : null), [nativeBitmap]);
+
+  const setRenderableRef = useCallback((node: unknown) => {
+    renderableRef.current = node as NativeRenderableNode | null;
+    assignRef(forwardedRef, node);
+  }, [forwardedRef]);
+
+  useEffect(() => {
+    let cancelled = false;
+    setKittySupport(getCachedKittySupport(renderer));
+    ensureKittySupport(renderer).then((supported) => {
+      if (!cancelled) setKittySupport(supported);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [renderer]);
+
+  useEffect(() => {
+    const renderable = renderableRef.current;
+    if (!renderable || !nativeBitmap || !nativeBitmapKey || kittySupport !== true) {
+      setTarget(null);
+      return;
+    }
+
+    let mountTimer: Timer | null = null;
+    const previousLifecyclePass = renderable.onLifecyclePass;
+    const syncTarget = () => {
+      const rect = getRenderableCellRect(renderable);
+      if (!renderer.resolution || renderer.terminalWidth <= 0 || renderer.terminalHeight <= 0) {
+        setTarget((current) => (current === null ? current : null));
+        return;
+      }
+
+      const visibleRect = resolveNativeSurfaceVisibleRect(renderable, renderer.terminalWidth, renderer.terminalHeight);
+      const clippedVisibleRect = visibleRect ? intersectCellRects(rect, visibleRect) : null;
+      const expectedSize = computeBitmapSize(rect, renderer.resolution, renderer.terminalWidth, renderer.terminalHeight);
+      const nextTarget: SurfaceTarget = {
+        rect,
+        visibleRect: clippedVisibleRect,
+        bitmapKey: `${nativeBitmapKey}:${expectedSize.pixelWidth}x${expectedSize.pixelHeight}`,
+      };
+      setTarget((current) => (sameTarget(current, nextTarget) ? current : nextTarget));
+    };
+    const lifecyclePass = () => {
+      previousLifecyclePass?.();
+      syncTarget();
+    };
+
+    renderable.onLifecyclePass = lifecyclePass;
+    renderer.registerLifecyclePass(renderable);
+    syncTarget();
+    mountTimer = setTimeout(() => {
+      syncTarget();
+      renderer.requestRender();
+    }, 0);
+
+    return () => {
+      if (mountTimer) clearTimeout(mountTimer);
+      if (renderable.onLifecyclePass === lifecyclePass) {
+        renderable.onLifecyclePass = previousLifecyclePass;
+      }
+      renderer.unregisterLifecyclePass(renderable);
+      setTarget(null);
+    };
+  }, [kittySupport, nativeBitmap, nativeBitmapKey, renderer]);
+
+  useEffect(() => {
+    return () => {
+      nativeSurfaceManager.removeSurface(surfaceId);
+    };
+  }, [nativeSurfaceManager, surfaceId]);
+
+  useEffect(() => {
+    if (kittySupport !== true || !target?.visibleRect || !nativeBitmap) {
+      nativeSurfaceManager.removeSurface(surfaceId);
+      return;
+    }
+
+    nativeSurfaceManager.upsertSurface({
+      id: surfaceId,
+      paneId: paneId ?? "__global__",
+      rect: target.rect,
+      visibleRect: target.visibleRect,
+      bitmap: nativeBitmap,
+      bitmapKey: target.bitmapKey,
+    });
+    renderer.requestRender();
+  }, [kittySupport, nativeBitmap, nativeSurfaceManager, paneId, renderer, surfaceId, target]);
+
+  const showFallback = kittySupport !== true || !target || !nativeBitmap;
+  return createElement("box" as any, { ...props, ref: setRenderableRef }, showFallback ? children as ReactNode : null);
+});

package/src/renderers/opentui/input-host.tsx

@@ -15,7 +15,7 @@ export function OpenTuiInputHostProvider({ children }: { children: ReactNode })
   const shortcutsRef = useRef<ShortcutEntry[]>([]);
   const dispatchShortcut = (event: KeyEventLike) => {
     const shortcuts = shortcutsRef.current;
-    for (const phase of ["normal", "after"] as const) {
+    for (const phase of ["before", "normal", "after"] as const) {
       if (phase === "after" && (event.defaultPrevented || event.propagationStopped)) return;
       for (const entry of shortcuts) {
         if (entry.phase !== phase || !entry.enabledRef.current) continue;

package/src/renderers/opentui/start.tsx

@@ -34,38 +34,56 @@ export async function startOpenTuiApp(): Promise<void> {
       cliLaunchRequest = dispatchResult.request;
     }
   }
-  startMainThreadMonitor("opentui");
+  const stopMainThreadMonitor = startMainThreadMonitor("opentui");
 
-  let dataDir = await getDataDir();
-  if (!dataDir) {
-    dataDir = join(process.env.HOME || "~", ".gloomberb");
-  }
+  let host: Awaited<ReturnType<typeof createOpenTuiHost>> | null = null;
+  let exitTimer: ReturnType<typeof setTimeout> | null = null;
+  const finishProcessExit = () => {
+    stopMainThreadMonitor();
+    if (exitTimer) return;
+    exitTimer = setTimeout(() => {
+      process.exit(process.exitCode ?? 0);
+    }, 0);
+  };
+  try {
+    let dataDir = await getDataDir();
+    if (!dataDir) {
+      dataDir = join(process.env.HOME || "~", ".gloomberb");
+    }
 
-  if (!existsSync(dataDir)) {
-    mkdirSync(dataDir, { recursive: true });
-  }
+    if (!existsSync(dataDir)) {
+      mkdirSync(dataDir, { recursive: true });
+    }
 
-  const config = await measurePerfAsync("startup.opentui.init-data-dir", () => initDataDir(dataDir));
-  const host = await measurePerfAsync("startup.opentui.create-host", () => createOpenTuiHost());
+    const config = await measurePerfAsync("startup.opentui.init-data-dir", () => initDataDir(dataDir));
+    host = await measurePerfAsync("startup.opentui.create-host", () => createOpenTuiHost());
+    host.renderer.once("destroy", finishProcessExit);
 
-  host.render(
-    <UiHostProvider ui={openTuiUiHost} renderer={host.rendererHost} nativeRenderer={host.nativeRenderer}>
-      <OpenTuiInputHostProvider>
-        <ToastHostProvider host={openTuiToastHost}>
-          <OpenTuiDialogHostProvider
-            size="medium"
-            dialogOptions={{ style: { backgroundColor: colors.bg, borderColor: colors.borderFocused, borderStyle: "single", paddingX: 2, paddingY: 1 } }}
-            backdropColor="#000000"
-            backdropOpacity={0.8}
-          >
-            <App
-              config={config}
-              externalPlugins={externalPlugins}
-              cliLaunchRequest={cliLaunchRequest}
-            />
-          </OpenTuiDialogHostProvider>
-        </ToastHostProvider>
-      </OpenTuiInputHostProvider>
-    </UiHostProvider>,
-  );
+    host.render(
+      <UiHostProvider ui={openTuiUiHost} renderer={host.rendererHost} nativeRenderer={host.nativeRenderer}>
+        <OpenTuiInputHostProvider>
+          <ToastHostProvider host={openTuiToastHost}>
+            <OpenTuiDialogHostProvider
+              size="medium"
+              dialogOptions={{ style: { backgroundColor: colors.bg, borderColor: colors.borderFocused, borderStyle: "single", paddingX: 2, paddingY: 1 } }}
+              backdropColor="#000000"
+              backdropOpacity={0.8}
+            >
+              <App
+                config={config}
+                externalPlugins={externalPlugins}
+                cliLaunchRequest={cliLaunchRequest}
+              />
+            </OpenTuiDialogHostProvider>
+          </ToastHostProvider>
+        </OpenTuiInputHostProvider>
+      </UiHostProvider>,
+    );
+  } catch (error) {
+    if (exitTimer) clearTimeout(exitTimer);
+    stopMainThreadMonitor();
+    host?.renderer.off("destroy", finishProcessExit);
+    host?.destroy();
+    throw error;
+  }
 }

package/src/renderers/opentui/test-utils.tsx

@@ -1,4 +1,5 @@
 import { useMemo, type ReactNode } from "react";
+import { DialogProvider } from "@opentui-ui/dialog/react";
 import { testRender as openTuiTestRender } from "@opentui/react/test-utils";
 import { createRoot as openTuiCreateRoot, useRenderer } from "@opentui/react";
 import { UiHostProvider, type NativeRendererHost, type RendererHost } from "../../ui";
@@ -8,6 +9,22 @@ import { openTuiUiHost } from "./ui-host";
 import { OpenTuiDialogHostProvider } from "./dialog-host";
 import { openTuiToastHost } from "./toast-host";
 
+export function TestDialogProvider({ children }: { children: ReactNode }) {
+  return (
+    <DialogProvider
+      dialogOptions={{
+        style: {
+          backgroundColor: "#000000",
+          borderColor: "#ffffff",
+          borderStyle: "single",
+        },
+      }}
+    >
+      {children}
+    </DialogProvider>
+  );
+}
+
 function createTestNativeRendererHost(renderer: any): NativeRendererHost {
   if (typeof renderer.write !== "function") {
     renderer.write = (data: string | Uint8Array) => {

package/src/renderers/opentui/ui-host.tsx

@@ -4,6 +4,7 @@ import "opentui-spinner/react";
 import { TextAttributes, type UiHost, type TextProps } from "../../ui/host";
 import { renderAsciiText } from "../../ui/ascii-font";
 import { OpenTuiImageSurface } from "./image-surface";
+import { OpenTuiChartSurface } from "./chart-surface";
 
 function mapTextAttributes(appAttributes: number | undefined, props?: TextProps): number | undefined {
   const flags = typeof appAttributes === "number" ? appAttributes : 0;
@@ -43,7 +44,9 @@ function mapTextContent(content: unknown): unknown {
 
 export const openTuiUiHost: UiHost = {
   kind: "opentui",
-  capabilities: {},
+  capabilities: {
+    nativeCharts: true,
+  },
   Box: ({ children, ...props }) => <box {...props}>{children}</box>,
   Text: ({ children, ...props }) => {
     const textProps = stripTextProps(props);
@@ -66,7 +69,7 @@ export const openTuiUiHost: UiHost = {
   ScrollBox: ({ children, ...props }) => <scrollbox {...props}>{children}</scrollbox>,
   Input: ({ children, ...props }) => createElement("input" as any, props, children),
   Textarea: ({ children, ...props }) => createElement("textarea" as any, props, children),
-  ChartSurface: ({ children, bitmap: _bitmap, bitmaps: _bitmaps, crosshair: _crosshair, ...props }) => <box {...props}>{children}</box>,
+  ChartSurface: OpenTuiChartSurface,
   ImageSurface: OpenTuiImageSurface,
   SpinnerMark: ({ children, ...props }) => createElement("spinner" as any, props, children),
   AsciiText: ({ text, font = "tiny", color, fg, bg, backgroundColor, selectable = false, ...props }) => {

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

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { createGloomberbCloudCapabilities, GloomberbCloudProvider } from "./gloomberb-cloud";
 import type { NewsCapability } from "../capabilities";
-import { apiClient, type AuthUser } from "../utils/api-client";
+import { apiClient, type AuthUser, type CloudNewsPayload } from "../utils/api-client";
 
 const verifiedUser: AuthUser = {
   id: "user-1",
@@ -21,8 +21,56 @@ const originalGetCloudHolders = apiClient.getCloudHolders.bind(apiClient);
 const originalGetCloudAnalystResearch = apiClient.getCloudAnalystResearch.bind(apiClient);
 const originalGetCloudCorporateActions = apiClient.getCloudCorporateActions.bind(apiClient);
 const originalGetCloudNews = apiClient.getCloudNews.bind(apiClient);
+const originalGetCloudNewsStory = apiClient.getCloudNewsStory.bind(apiClient);
 const originalSubscribeQuotes = apiClient.subscribeQuotes.bind(apiClient);
 
+function makeCloudNewsPayload(overrides: Partial<CloudNewsPayload> = {}): CloudNewsPayload {
+  return {
+    id: "story-1",
+    headline: "Apple raises guidance",
+    summary: "Apple lifted its outlook after stronger iPhone demand.",
+    topic: "guidance",
+    topics: ["guidance"],
+    category: "guidance",
+    sentiment: "positive",
+    sectors: ["information_technology"],
+    firstPublishedAt: "2026-04-01T10:00:00.000Z",
+    lastPublishedAt: "2026-04-01T10:05:00.000Z",
+    firstSeenAt: "2026-04-01T10:00:10.000Z",
+    lastSeenAt: "2026-04-01T10:05:10.000Z",
+    primaryUrl: "https://example.com/aapl-guidance",
+    primarySource: "example-wire",
+    scores: {
+      importance: 91,
+      urgency: 74,
+      marketImpact: 88,
+      novelty: 86,
+      confidence: 95,
+    },
+    flags: {
+      breaking: true,
+      developing: false,
+      stale: false,
+    },
+    variantCount: 1,
+    sourceCount: 1,
+    sources: ["example-wire"],
+    entities: [],
+    tickerLinks: [{
+      symbol: "AAPL",
+      exchange: "XNAS",
+      canonicalTicker: "AAPL:XNAS",
+      relationType: "direct",
+      displayTier: "primary",
+      confidence: 0.98,
+      relevanceScore: 95,
+      impactScore: 93,
+      sentiment: "positive",
+    }],
+    ...overrides,
+  };
+}
+
 afterEach(() => {
   apiClient.ensureVerifiedSession = originalEnsureVerifiedSession;
   apiClient.getCloudHistory = originalGetCloudHistory;
@@ -31,6 +79,7 @@ afterEach(() => {
   apiClient.getCloudAnalystResearch = originalGetCloudAnalystResearch;
   apiClient.getCloudCorporateActions = originalGetCloudCorporateActions;
   apiClient.getCloudNews = originalGetCloudNews;
+  apiClient.getCloudNewsStory = originalGetCloudNewsStory;
   apiClient.subscribeQuotes = originalSubscribeQuotes;
 });
 
@@ -496,4 +545,40 @@ describe("GloomberbCloudProvider", () => {
       confidence: 93,
     });
   });
+
+  test("fetches story detail with ordered source items", async () => {
+    let requestedStoryId = "";
+    apiClient.getCloudNewsStory = async (storyId) => {
+      requestedStoryId = storyId;
+      return makeCloudNewsPayload({
+        id: storyId,
+        items: [{
+          id: "item-2",
+          sourceKey: "wire-b",
+          sourceName: "Wire B",
+          title: "Follow-up",
+          summary: "More details emerged.",
+          url: "https://example.com/follow-up",
+          publishedAt: "2026-04-01T10:05:00.000Z",
+          hasArticleText: true,
+        }, {
+          id: "item-1",
+          sourceKey: "wire-a",
+          sourceName: "Wire A",
+          title: "Original",
+          summary: "The first report.",
+          url: "https://example.com/original",
+          publishedAt: "2026-04-01T10:00:00.000Z",
+          hasArticleText: false,
+        }],
+      });
+    };
+
+    const source = createGloomberbCloudCapabilities().find((capability) => capability.kind === "news") as NewsCapability;
+    const story = await source.provider.fetchNewsStory?.("story-1");
+
+    expect(requestedStoryId).toBe("story-1");
+    expect(story?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
+    expect(story?.items?.[0]?.publishedAt).toEqual(new Date("2026-04-01T10:05:00.000Z"));
+  });
 });

package/src/sources/gloomberb-cloud.ts

@@ -5,15 +5,24 @@ import {
   type ManualChartResolution,
 } from "../components/chart/chart-resolution";
 import { assetDataProvider, newsProvider, type PluginCapability } from "../capabilities";
-import type { AssetDataProvider, MarketDataRequestContext, NewsItem, QuoteSubscriptionTarget, SearchRequestContext, SecFilingItem } from "../types/data-provider";
+import type {
+  AssetDataProvider,
+  CachedFinancialsTarget,
+  MarketDataRequestContext,
+  NewsItem,
+  QuoteBatchResult,
+  QuoteSubscriptionTarget,
+  SearchRequestContext,
+  SecFilingItem,
+  TickerFinancialsBatchResult,
+} from "../types/data-provider";
 import type { AnalystResearchData, CorporateActionsData, HolderData, OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { InstrumentSearchResult } from "../types/instrument";
 import {
   apiClient,
   type CloudAnalystResearchPayload,
-  type CloudCompanyProfile,
   type CloudCorporateActionsPayload,
-  type CloudFundamentals,
+  type CloudMarketBatchItem,
   type CloudHoldersPayload,
   type CloudMarketResponse,
   type CloudNewsPayload,
@@ -103,6 +112,34 @@ function mapPricePoint(point: CloudPricePointPayload, divisor = 1): PricePoint {
   };
 }
 
+function mapCloudFinancials(financials: TickerFinancials): TickerFinancials {
+  const quote = financials.quote ? mapQuote(financials.quote as CloudQuotePayload) : undefined;
+  const divisor = quote ? resolveCurrencyUnit(quote.currency).divisor : 1;
+  return {
+    quote,
+    quoteContributions: financials.quoteContributions,
+    profile: financials.profile,
+    fundamentals: financials.fundamentals,
+    annualStatements: financials.annualStatements ?? [],
+    quarterlyStatements: financials.quarterlyStatements ?? [],
+    priceHistory: (financials.priceHistory ?? []).map((point) =>
+      point.date instanceof Date
+        ? point
+        : mapPricePoint(point as unknown as CloudPricePointPayload, divisor)
+    ),
+  };
+}
+
+function mapBatchError<T>(
+  item: CloudMarketBatchItem<T>,
+  fallbackMessage: string,
+): Error {
+  if (isEmptyCloudStatus(item.status)) {
+    return createProviderMiss(item.reasonCode ?? fallbackMessage);
+  }
+  return new Error(item.reasonCode ?? fallbackMessage);
+}
+
 function normalizeStringArray(value: unknown): string[] {
   return Array.isArray(value)
     ? value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
@@ -358,27 +395,45 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async getTickerFinancials(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<TickerFinancials> {
     await requireVerifiedSession();
     return withCloudFallback(async () => {
-      const [quoteResponse, profileResponse, fundamentalsResponse, statementsResponse] = await Promise.all([
-        apiClient.getCloudQuote(ticker, exchange),
-        apiClient.getCloudProfile(ticker, exchange),
-        apiClient.getCloudFundamentals(ticker, exchange),
-        apiClient.getCloudStatements(ticker, exchange, "both"),
-      ]);
-      const quote = mapQuote(unwrapRequiredCloudResponse(quoteResponse, `Cloud quote is unavailable for ${ticker}`));
-      const profile = unwrapOptionalCloudResponse(profileResponse) as CloudCompanyProfile | null;
-      const fundamentals = unwrapOptionalCloudResponse(fundamentalsResponse) as CloudFundamentals | null;
-      const statements = unwrapOptionalCloudResponse(statementsResponse);
-      return {
-        quote,
-        profile: profile ?? undefined,
-        fundamentals: fundamentals ?? undefined,
-        annualStatements: statements?.annualStatements ?? [],
-        quarterlyStatements: statements?.quarterlyStatements ?? [],
-        priceHistory: [],
-      };
+      const response = await apiClient.getCloudFinancials(ticker, exchange);
+      return mapCloudFinancials(unwrapRequiredCloudResponse(response, `Cloud financials are unavailable for ${ticker}`));
     }, `Cloud financials are unavailable for ${ticker}`);
   }
 
+  async getTickerFinancialsBatch(
+    targets: CachedFinancialsTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<TickerFinancialsBatchResult[]> {
+    await requireVerifiedSession();
+    return withCloudFallback(async () => {
+      const response = await apiClient.getCloudFinancialsBatch(
+        targets.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange,
+        })),
+        options.forceRefresh ? "refresh" : "cache-first",
+      );
+      const payload = unwrapRequiredCloudResponse(response, "Cloud financials are unavailable");
+      return payload.items.map((item, index) => {
+        const target = targets[index] ?? {
+          symbol: item.symbol,
+          exchange: item.exchange,
+        };
+        if ((item.status === "success" || item.status === "partial") && item.data) {
+          return {
+            target,
+            financials: mapCloudFinancials(item.data),
+          };
+        }
+        return {
+          target,
+          financials: null,
+          error: mapBatchError(item, `Cloud financials are unavailable for ${target.symbol}`),
+        };
+      });
+    }, "Cloud financials are unavailable");
+  }
+
   async getQuote(ticker: string, exchange = "", _context?: MarketDataRequestContext): Promise<Quote> {
     await requireVerifiedSession();
     return withCloudFallback(
@@ -390,6 +445,40 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     );
   }
 
+  async getQuotesBatch(
+    targets: QuoteSubscriptionTarget[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QuoteBatchResult[]> {
+    await requireVerifiedSession();
+    return withCloudFallback(async () => {
+      const response = await apiClient.getCloudQuotesBatch(
+        targets.map((target) => ({
+          symbol: target.symbol,
+          exchange: target.exchange,
+        })),
+        options.forceRefresh ? "refresh" : "cache-first",
+      );
+      const payload = unwrapRequiredCloudResponse(response, "Cloud quotes are unavailable");
+      return payload.items.map((item, index) => {
+        const target = targets[index] ?? {
+          symbol: item.symbol,
+          exchange: item.exchange,
+        };
+        if ((item.status === "success" || item.status === "partial") && item.data) {
+          return {
+            target,
+            quote: mapQuote(item.data),
+          };
+        }
+        return {
+          target,
+          quote: null,
+          error: mapBatchError(item, `Cloud quotes are unavailable for ${target.symbol}`),
+        };
+      });
+    }, "Cloud quotes are unavailable");
+  }
+
   async getExchangeRate(fromCurrency: string): Promise<number> {
     await requireVerifiedSession();
     const response = await apiClient.getCloudExchangeRate(fromCurrency);
@@ -575,6 +664,13 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           );
           return response.items.map((item) => mapCloudNewsArticle(item, query.ticker));
         },
+        async fetchNewsStory(storyId: string): Promise<NewsArticle | null> {
+          const story = await withCloudFallback(
+            () => apiClient.getCloudNewsStory(storyId),
+            "Cloud news story is unavailable",
+          );
+          return mapCloudNewsArticle(story);
+        },
       },
     }),
   ];