gloomberb 0.12.0 → 0.13.2

package/src/cli/pane-functions/dom.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test";
+import type { ResolvedPaneFunction } from "./resolver";
+import type { PaneScreenshotResult } from "./screenshot";
+import { buildDomPaneReportFromRender } from "./dom";
+
+test("marks rendered reports as truncated when a visible cell contains an ellipsis", () => {
+  const resolved = {
+    token: "INS",
+    label: "Insider",
+    capability: { id: "insider-pane" },
+    options: {},
+  } as unknown as ResolvedPaneFunction;
+  const screenshot = {
+    symbols: ["AVGO"],
+    render: {
+      visibleText: "NVIDIA Corporati…",
+      rows: [{
+        tableIndex: 0,
+        rowIndex: 0,
+        selected: false,
+        cells: [{ columnLabel: "Issuer", text: "NVIDIA Corporati…" }],
+      }],
+      truncated: false,
+      truncationReasons: [],
+      loadingStateDetected: false,
+      errorStateDetected: false,
+      errorStateMarkers: [],
+      emptyStateDetected: false,
+      emptyStateMarkers: [],
+    },
+  } as unknown as PaneScreenshotResult;
+
+  const report = buildDomPaneReportFromRender(resolved, screenshot);
+  expect(report.data).toMatchObject({
+    kind: "rendered-view",
+    rowCount: 1,
+    truncated: true,
+    complete: false,
+    limitation: expect.stringContaining("visible"),
+  });
+});

package/src/cli/pane-functions/dom.ts

@@ -0,0 +1,199 @@
+import type { DesktopPaneShotRenderedRow } from "../desktop-pane-shot";
+import { renderSection, renderTable } from "../../utils/cli-output";
+import type { MarketContext } from "../types";
+import type { PaneFunctionReport } from "./report";
+import type { ResolvedPaneFunction } from "./resolver";
+import { collectShotSymbols } from "./data";
+import { renderDesktopShot, type PaneScreenshotResult } from "./screenshot";
+
+const DOM_REPORT_WIDTH = 1280;
+const DOM_REPORT_HEIGHT = 720;
+const DOM_LIMITATION =
+  "Only values visible in the rendered pane are returned; clipped or off-screen data may be omitted.";
+
+function rowsContainEllipsis(rows: DesktopPaneShotRenderedRow[]): boolean {
+  return rows.some((row) => row.cells.some((cell) => /\u2026|\.\.\./.test(cell.text)));
+}
+
+export function isDomReportTruncated(
+  render: Pick<PaneScreenshotResult["render"], "rows" | "truncated">,
+): boolean {
+  return render.truncated || rowsContainEllipsis(render.rows);
+}
+
+function renderDomTables(rows: DesktopPaneShotRenderedRow[]): string[] {
+  const byTable = new Map<number, DesktopPaneShotRenderedRow[]>();
+  for (const row of rows) {
+    const tableRows = byTable.get(row.tableIndex) ?? [];
+    tableRows.push(row);
+    byTable.set(row.tableIndex, tableRows);
+  }
+
+  return [...byTable.entries()].flatMap(([tableIndex, tableRows], index) => {
+    const columnCount = Math.max(0, ...tableRows.map((row) => row.cells.length));
+    const columns = Array.from({ length: columnCount }, (_, columnIndex) => ({
+      header: tableRows.find((row) => row.cells[columnIndex])?.cells[columnIndex]?.columnLabel
+        ?? `Column ${columnIndex + 1}`,
+    }));
+    const output = renderTable(
+      columns,
+      tableRows.map((row) => columns.map((_column, columnIndex) => row.cells[columnIndex]?.text ?? "")),
+    );
+    return [
+      ...(index > 0 ? [""] : []),
+      ...(byTable.size > 1 ? [renderSection(`Rendered table ${tableIndex + 1}`)] : []),
+      output,
+    ];
+  });
+}
+
+function renderedFailureReason(
+  result: PaneScreenshotResult,
+  rows: DesktopPaneShotRenderedRow[],
+): string | null {
+  if (result.render.loadingStateDetected) return "The rendered pane was still loading.";
+  if (result.render.errorStateDetected) {
+    const marker = result.render.errorStateMarkers[0];
+    return marker ? `The rendered pane reported: ${marker}` : "The rendered pane reported an error.";
+  }
+  if (result.render.emptyStateDetected) {
+    const marker = result.render.emptyStateMarkers[0];
+    return marker ? `The rendered pane reported: ${marker}` : "The rendered pane reported an empty state.";
+  }
+  if (rows.length === 0) return "The rendered pane exposed no structured rows or visible text.";
+  return null;
+}
+
+function reportRows(result: PaneScreenshotResult): DesktopPaneShotRenderedRow[] {
+  if (result.render.rows.length > 0) return result.render.rows;
+  if (
+    result.render.loadingStateDetected
+    || result.render.errorStateDetected
+    || result.render.emptyStateDetected
+    || !result.render.visibleText
+  ) {
+    return [];
+  }
+  return [{
+    tableIndex: 0,
+    rowIndex: 0,
+    selected: false,
+    cells: [{ columnLabel: "Rendered view", text: result.render.visibleText }],
+  }];
+}
+
+export function buildDomPaneReportFromRender(
+  resolved: ResolvedPaneFunction,
+  result: PaneScreenshotResult,
+): PaneFunctionReport {
+  const rows = reportRows(result);
+  const hasStructuredRows = result.render.rows.length > 0;
+  const truncated = isDomReportTruncated({ ...result.render, rows });
+  const truncationReasons = [...result.render.truncationReasons];
+  if (rowsContainEllipsis(rows) && !truncationReasons.includes("one or more cells are visibly clipped")) {
+    truncationReasons.push("one or more cells are visibly clipped");
+  }
+  const failureReason = renderedFailureReason(result, rows);
+  const unavailableSymbols = failureReason && result.symbols.length > 0 ? result.symbols : [];
+  const textLines = [resolved.label, ""];
+  if (hasStructuredRows) {
+    textLines.push(...renderDomTables(rows));
+  } else if (result.render.visibleText) {
+    textLines.push(result.render.visibleText);
+  } else {
+    textLines.push(failureReason ?? "No rendered values were available.");
+  }
+  if (failureReason && rows.length > 0) textLines.push("", failureReason);
+
+  return {
+    data: {
+      kind: "rendered-view",
+      target: resolved.token,
+      capabilityId: resolved.capability.id,
+      symbols: result.symbols,
+      options: resolved.options,
+      rowCount: rows.length,
+      empty: rows.length === 0,
+      complete: failureReason === null && !truncated,
+      unavailableSymbols,
+      rows,
+      visibleText: result.render.visibleText,
+      truncated,
+      truncationReasons,
+      limitation: DOM_LIMITATION,
+      ...(failureReason ? { reason: failureReason } : {}),
+    },
+    text: textLines.join("\n").trimEnd(),
+  };
+}
+
+export function appendDomReportFooter(
+  text: string,
+  elapsedMs: number,
+  truncated: boolean,
+): string {
+  const clipping = truncated ? "The rendered view is clipped." : "The rendered view may be clipped.";
+  return [
+    text,
+    "",
+    `Rendered view: values come from the visible pane. ${clipping} Render time: ${elapsedMs} ms.`,
+  ].join("\n");
+}
+
+function failedDomReport(
+  resolved: ResolvedPaneFunction,
+  rawArg: string,
+  error: unknown,
+): PaneFunctionReport {
+  const message = (error instanceof Error ? error.message : String(error))
+    .split("\n")[0]!
+    .replace(/^Error:\s*/, "")
+    .trim();
+  const reason = `The rendered view could not be read: ${message || "unknown renderer error"}`;
+  const symbols = collectShotSymbols(resolved, rawArg);
+  return {
+    data: {
+      kind: "rendered-view",
+      target: resolved.token,
+      capabilityId: resolved.capability.id,
+      symbols,
+      options: resolved.options,
+      rowCount: 0,
+      empty: true,
+      complete: false,
+      unavailableSymbols: symbols,
+      rows: [],
+      visibleText: "",
+      truncated: false,
+      truncationReasons: [],
+      limitation: DOM_LIMITATION,
+      reason,
+    },
+    text: [resolved.label, "", reason].join("\n"),
+  };
+}
+
+export async function buildDomFunctionReport(
+  resolved: ResolvedPaneFunction,
+  context: MarketContext,
+  rawArg: string,
+): Promise<PaneFunctionReport> {
+  try {
+    const result = await renderDesktopShot({
+      resolved,
+      context,
+      rawArg,
+      outputPath: "",
+      width: DOM_REPORT_WIDTH,
+      height: DOM_REPORT_HEIGHT,
+      theme: null,
+      scale: 1,
+      watermark: null,
+      options: {},
+      captureImage: false,
+    });
+    return buildDomPaneReportFromRender(resolved, result);
+  } catch (error) {
+    return failedDomReport(resolved, rawArg, error);
+  }
+}

package/src/cli/pane-functions/index.test.ts

@@ -10,6 +10,7 @@ const {
   filterPaneCatalogEntries,
   renderPaneCatalogReport,
   getPaneFunctionCapability,
+  isDataPaneForDomFallback,
   normalizeCapabilityOptions,
   capabilityPluginState,
 } = paneFunctionTestInternals;
@@ -208,13 +209,23 @@ describe("pane function CLI args", () => {
     });
   });
 
-  test("enables live DOM screenshots without claiming report support for unmapped panes", () => {
+  test("maps data panes to rendered reports and keeps interactive panes unsupported", () => {
     expect(capabilityFor("new-api-pane")).toMatchObject({
-      id: "unverified-pane",
+      id: "new-api-pane",
       botSafe: false,
+      outputKind: "rendered-view",
+      reportReadiness: "live-dom",
+      screenshotReadiness: "live-dom",
+    });
+
+    const helpPane = { ...dummyPane, id: "help" };
+    expect(getPaneFunctionCapability(undefined, helpPane)).toMatchObject({
+      id: "help",
       reportReadiness: "unsupported",
       screenshotReadiness: "live-dom",
     });
+    expect(isDataPaneForDomFallback(dummyPane)).toBe(true);
+    expect(isDataPaneForDomFallback(helpPane)).toBe(false);
   });
 
   test("rejects financial statement options on a price comparison", () => {

package/src/cli/pane-functions/index.ts

@@ -25,8 +25,10 @@ import {
 import {
   capabilityPluginState,
   getPaneFunctionCapability,
+  isDataPaneForDomFallback,
   normalizeCapabilityOptions,
 } from "./capabilities";
+import { withPersistedCloudSession } from "./cloud-session";
 
 async function withPaneRuntime<T>(
   ctx: CliCommandContext,
@@ -62,7 +64,10 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
           + `Use "gloomberb catalog ${resolved.token}" to inspect readiness.`,
         );
       }
-      const report = await buildFunctionReport(resolved, context, parsed.arg);
+      const report = await withPersistedCloudSession(
+        context,
+        () => buildFunctionReport(resolved, context, parsed.arg),
+      );
       if (parsed.requireBotSafe && (report.data.empty || !report.data.complete)) {
         const unavailable = report.data.unavailableSymbols.length > 0
           ? ` Missing data for ${report.data.unavailableSymbols.join(", ")}.`
@@ -106,16 +111,14 @@ export async function runPaneScreenshot(args: string[], ctx: CliCommandContext)
       });
       if (parsed.requireBotSafe && !result.usable) {
         throw new Error(
-          `${resolved.token} did not produce a usable bot-safe screenshot: `
-          + `${result.empty ? "empty render" : ""}${result.empty && !result.complete ? ", " : ""}`
-          + `${!result.complete ? `missing data for ${result.unavailableSymbols.join(", ")}` : ""}`
-          + `${result.semanticMismatch ? `${(result.empty || !result.complete) ? ", " : ""}rendered content did not match the requested capability` : ""}`,
+          `${resolved.token} did not produce a usable bot-safe screenshot: ${result.unusableReason ?? "unknown reason"}`,
         );
       }
       ctx.printResult({ data: result }, {
         text: (data) => [
           `Saved screenshot to ${data.outputPath}`,
           `Result: ${data.rowCount} semantic rows; empty=${data.empty}; complete=${data.complete}; mismatch=${data.semanticMismatch}; usable=${data.usable}`,
+          ...(data.unusableReason ? [`Unusable reason: ${data.unusableReason}`] : []),
           ...(data.unavailableSymbols.length > 0
             ? [`Unavailable symbols: ${data.unavailableSymbols.join(", ")}`]
             : []),
@@ -180,6 +183,7 @@ export const paneFunctionTestInternals = {
   filterPaneCatalogEntries,
   renderPaneCatalogReport,
   getPaneFunctionCapability,
+  isDataPaneForDomFallback,
   normalizeCapabilityOptions,
   capabilityPluginState,
 };

package/src/cli/pane-functions/intraday-shot.test.ts

@@ -0,0 +1,307 @@
+import { describe, expect, test } from "bun:test";
+import { CHART_COMPOSER_PANE_ID, createDefaultConfig } from "../../types/config";
+import type { DataProvider } from "../../types/data-provider";
+import type { PricePoint, TickerFinancials } from "../../types/financials";
+import {
+  buildIntradayPriceChartPreset,
+  buildPriceChartPreset,
+} from "../../plugins/builtin/chart-composer/presets";
+import type { MarketContext } from "../types";
+import {
+  buildDesktopShotPayload,
+  intradayChartEvidenceMismatchesFor,
+  shotUnusableReasonFor,
+} from "./screenshot";
+import type { ResolvedPaneFunction } from "./resolver";
+import {
+  resolveShotIntradaySessionWindow,
+  resolveShotIntradayRequest,
+} from "./intraday-shot";
+
+function sessionBars(date: string, base: number): PricePoint[] {
+  return [
+    {
+      date: new Date(`${date}T13:30:00.000Z`),
+      open: base,
+      high: base + 1,
+      low: base - 1,
+      close: base + 0.25,
+      volume: 100,
+    },
+    {
+      date: new Date(`${date}T13:35:00.000Z`),
+      open: base + 0.25,
+      high: base + 1.25,
+      low: base,
+      close: base + 0.5,
+      volume: 200,
+    },
+  ];
+}
+
+function financials(priceHistory: PricePoint[] = []): TickerFinancials {
+  return {
+    quote: {
+      symbol: "AAPL",
+      price: 108,
+      currency: "USD",
+      change: 1,
+      changePercent: 1,
+      lastUpdated: Date.parse("2026-09-03T20:00:00.000Z"),
+      listingExchangeName: "NASDAQ",
+    },
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory,
+  };
+}
+
+function contextWithProvider(provider: DataProvider): MarketContext {
+  return {
+    config: createDefaultConfig("/tmp/gloomberb-shot-test"),
+    dataDir: "/tmp/gloomberb-shot-test",
+    persistence: {
+      pluginState: { get: () => null },
+    },
+    store: {
+      loadTicker: async () => ({
+        metadata: {
+          ticker: "AAPL",
+          exchange: "NASDAQ",
+          currency: "USD",
+          name: "Apple",
+          portfolios: [],
+          watchlists: [],
+          positions: [],
+          custom: {},
+          tags: [],
+        },
+      }),
+    },
+    dataProvider: provider,
+  } as unknown as MarketContext;
+}
+
+function resolvedChart(
+  capabilityId: "intraday-price-chart" | "price-chart",
+  spec: ReturnType<typeof buildIntradayPriceChartPreset>,
+  options: Record<string, string>,
+): ResolvedPaneFunction {
+  return {
+    pane: { id: CHART_COMPOSER_PANE_ID },
+    capability: { id: capabilityId, options: [] },
+    options,
+    instance: {
+      instanceId: `${capabilityId}:test`,
+      paneId: CHART_COMPOSER_PANE_ID,
+      title: "AAPL",
+      binding: { kind: "fixed", symbol: "AAPL" },
+      settings: { chartSpec: spec },
+    },
+    createOptions: { symbol: "AAPL" },
+  } as unknown as ResolvedPaneFunction;
+}
+
+async function payloadFor(
+  resolved: ResolvedPaneFunction,
+  provider: DataProvider,
+) {
+  return buildDesktopShotPayload(
+    resolved,
+    contextWithProvider(provider),
+    "AAPL",
+    {},
+    1200,
+    675,
+    "tokyo",
+    1.5,
+    null,
+  );
+}
+
+describe("GIP session windows", () => {
+  const history = [
+    ...sessionBars("2026-08-27", 100),
+    ...sessionBars("2026-08-28", 101),
+    ...sessionBars("2026-08-31", 102),
+    ...sessionBars("2026-09-01", 103),
+    ...sessionBars("2026-09-02", 104),
+    ...sessionBars("2026-09-03", 105),
+  ];
+
+  test("resolves the latest session, latest five sessions, and an explicit session", () => {
+    const latest = resolveShotIntradaySessionWindow(history, {
+      rangePreset: "1D",
+      timeZone: "America/New_York",
+    });
+    expect(latest.sessionDates).toEqual(["2026-09-03"]);
+    expect(latest.points).toHaveLength(2);
+
+    const week = resolveShotIntradaySessionWindow(history, {
+      rangePreset: "1W",
+      timeZone: "America/New_York",
+    });
+    expect(week.sessionDates).toEqual([
+      "2026-08-28",
+      "2026-08-31",
+      "2026-09-01",
+      "2026-09-02",
+      "2026-09-03",
+    ]);
+    expect(week.points).toHaveLength(10);
+
+    const explicit = resolveShotIntradaySessionWindow(history, {
+      rangePreset: "1W",
+      session: "2026-09-01",
+      timeZone: "America/New_York",
+    });
+    expect(explicit.sessionDates).toEqual(["2026-09-01"]);
+    expect(explicit.points.map((point) => point.close)).toEqual([103.25, 103.5]);
+  });
+
+  test("maps Auto to the preset interval and validates explicit dates", () => {
+    expect(resolveShotIntradayRequest({ rangePreset: "1D", chartResolution: "auto" }))
+      .toEqual({ rangePreset: "1D", resolution: "1m", session: null });
+    expect(resolveShotIntradayRequest({ rangePreset: "1W", chartResolution: "auto" }))
+      .toEqual({ rangePreset: "1W", resolution: "5m", session: null });
+    expect(resolveShotIntradayRequest({
+      rangePreset: "1W",
+      chartResolution: "15m",
+      session: "2026-09-02",
+    })).toEqual({ rangePreset: "1D", resolution: "15m", session: "2026-09-02" });
+    expect(() => resolveShotIntradayRequest({ session: "2026-02-30" }))
+      .toThrow("real calendar date");
+  });
+});
+
+describe("GIP screenshot payload", () => {
+  test("injects resolution-aware intraday bars for GIP", async () => {
+    const calls: Array<{ range: string; resolution: string }> = [];
+    const history = [
+      ...sessionBars("2026-09-02", 100),
+      ...sessionBars("2026-09-03", 105),
+    ];
+    const provider = {
+      id: "test",
+      name: "Test",
+      getTickerFinancials: async () => financials([
+        { date: new Date("2026-09-03T00:00:00.000Z"), close: 105 },
+      ]),
+      getPriceHistory: async () => [],
+      getPriceHistoryForResolution: async (_symbol, _exchange, range, resolution) => {
+        calls.push({ range, resolution });
+        return history;
+      },
+      getDetailedPriceHistory: async () => [],
+    } as DataProvider;
+    const spec = buildIntradayPriceChartPreset("AAPL");
+    spec.viewport.resolution = "auto";
+    const payload = await payloadFor(
+      resolvedChart("intraday-price-chart", spec, {
+        rangePreset: "1D",
+        chartResolution: "auto",
+      }),
+      provider,
+    );
+
+    expect(calls).toEqual([{ range: "1W", resolution: "1m" }]);
+    expect(payload.intradayHistories).toHaveLength(1);
+    expect(payload.intradayHistories[0]).toMatchObject({
+      symbol: "AAPL",
+      exchange: "NASDAQ",
+      rangePreset: "1D",
+      resolution: "1m",
+      requestedSession: null,
+      sessionDates: ["2026-09-03"],
+      unavailableReason: null,
+    });
+    expect(payload.intradayHistories[0]?.points).toHaveLength(2);
+    expect(payload.financials[0]?.[1].priceHistory).toHaveLength(2);
+
+    const renderedEvidence = [{
+      role: "chart-data",
+      metadata: {
+        kind: "chart-composer",
+        projectedPointCount: 2,
+        baseSeries: [{
+          pointCount: 2,
+          first: { date: "2026-09-03T13:30:00.000Z", value: 105.25 },
+          last: { date: "2026-09-03T13:35:00.000Z", value: 105.5 },
+        }],
+      },
+    }];
+    const resolved = resolvedChart("intraday-price-chart", spec, {
+      rangePreset: "1D",
+      chartResolution: "auto",
+    });
+    expect(intradayChartEvidenceMismatchesFor(resolved, payload, renderedEvidence as never))
+      .toEqual([]);
+    renderedEvidence[0]!.metadata.baseSeries[0]!.pointCount = 1;
+    expect(intradayChartEvidenceMismatchesFor(resolved, payload, renderedEvidence as never))
+      .toContain("rendered intraday point count does not match");
+  });
+
+  test("keeps GP on daily history without an intraday payload", async () => {
+    let intradayCalls = 0;
+    const daily = [
+      { date: new Date("2026-09-02T00:00:00.000Z"), close: 100 },
+      { date: new Date("2026-09-03T00:00:00.000Z"), close: 105 },
+    ];
+    const provider = {
+      id: "test",
+      name: "Test",
+      getTickerFinancials: async () => financials(),
+      getPriceHistory: async () => daily,
+      getPriceHistoryForResolution: async () => {
+        intradayCalls += 1;
+        return [];
+      },
+    } as DataProvider;
+    const payload = await payloadFor(
+      resolvedChart("price-chart", buildPriceChartPreset("AAPL"), { rangePreset: "3M" }),
+      provider,
+    );
+
+    expect(intradayCalls).toBe(0);
+    expect(payload.intradayHistories).toEqual([]);
+    expect(payload.financials[0]?.[1].priceHistory).toEqual(daily);
+  });
+
+  test("records an explicit unusable reason when no intraday bars exist", async () => {
+    const provider = {
+      id: "test",
+      name: "Test",
+      getTickerFinancials: async () => financials([
+        { date: new Date("2026-09-03T00:00:00.000Z"), close: 105 },
+      ]),
+      getPriceHistory: async () => [],
+      getPriceHistoryForResolution: async () => [],
+      getDetailedPriceHistory: async () => [],
+    } as DataProvider;
+    const spec = buildIntradayPriceChartPreset("AAPL");
+    spec.viewport.resolution = "auto";
+    const resolved = resolvedChart("intraday-price-chart", spec, {
+      rangePreset: "1D",
+      chartResolution: "auto",
+      session: "2020-01-02",
+    });
+    const payload = await payloadFor(resolved, provider);
+
+    expect(payload.intradayHistories[0]?.points).toEqual([]);
+    expect(payload.intradayHistories[0]?.start).toBe("2020-01-02T05:00:00.000Z");
+    expect(payload.intradayHistories[0]?.end).toBe("2020-01-03T05:00:00.000Z");
+    expect(payload.intradayHistories[0]?.unavailableReason)
+      .toBe("No intraday price history is available for AAPL for session 2020-01-02.");
+    expect(shotUnusableReasonFor(
+      resolved,
+      payload,
+      {
+        loadingStateDetected: false,
+        errorStateDetected: false,
+        emptyStateDetected: true,
+      },
+      ["AAPL"],
+      false,
+    )).toBe("No intraday price history is available for AAPL for session 2020-01-02.");
+  });
+});