gloomberb 0.12.0 → 0.13.1

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

@@ -11,6 +11,7 @@ const DEFAULT_SHOT_DEVICE_SCALE_FACTOR = 2;
 import {
   renderDesktopPaneScreenshot,
   type DesktopPaneShotApiProxy,
+  type DesktopPaneShotIntradayHistory,
   type DesktopPaneShotPayload,
   type DesktopPaneShotRenderResult,
 } from "../desktop-pane-shot";
@@ -65,6 +66,10 @@ import {
   isFinancialAnalysisFunction,
   withShotPriceHistory,
 } from "./data";
+import {
+  loadShotIntradayWindow,
+  resolveShotIntradayRequest,
+} from "./intraday-shot";
 
 const DESKTOP_CELL_WIDTH_PX = 8;
 const DESKTOP_CELL_HEIGHT_PX = 18;
@@ -289,6 +294,8 @@ export interface PaneScreenshotPriceSeriesEvidence {
   pointCount: number;
   first: PaneScreenshotChartPointEvidence;
   last: PaneScreenshotChartPointEvidence;
+  resolution?: string;
+  sessionDates?: string[];
 }
 
 export interface PaneScreenshotFundamentalSeriesEvidence {
@@ -362,6 +369,7 @@ export interface PaneScreenshotResult {
   unavailableSymbols: string[];
   semanticMismatch: boolean;
   usable: boolean;
+  unusableReason: string | null;
   dataEvidence: PaneScreenshotDataEvidence | null;
   outputPath: string;
   render: DesktopPaneShotRenderResult & {
@@ -379,7 +387,7 @@ export function defaultScreenshotPath(resolved: ResolvedPaneFunction, rawArg: st
   return resolve(process.cwd(), `gloomberb-${suffix}.png`);
 }
 
-async function buildDesktopShotPayload(
+export async function buildDesktopShotPayload(
   resolved: ResolvedPaneFunction,
   context: MarketContext,
   rawArg: string,
@@ -414,9 +422,10 @@ async function buildDesktopShotPayload(
   const paneState = stripDesktopShotCredentials<Record<string, PaneRuntimeState>>({
     [resolved.instance.instanceId]: initialPaneState,
   });
+  let shotInstance = stripDesktopShotCredentials<typeof resolved.instance>(resolved.instance);
   const layout = {
     dockRoot: null,
-    instances: [resolved.instance],
+    instances: [shotInstance],
     floating: [{
       instanceId: resolved.instance.instanceId,
       x: 0,
@@ -444,6 +453,7 @@ async function buildDesktopShotPayload(
 
   const tickers: TickerRecord[] = [];
   const financials: Array<[string, TickerFinancials]> = [];
+  const intradayHistories: DesktopPaneShotIntradayHistory[] = [];
   const optionsChains: Array<[string, OptionsChain]> = [];
   const [fredSeries, capabilitySeries, valuationSeries, statSeries] = await Promise.all([
     collectShotFredSeries(resolved),
@@ -452,16 +462,64 @@ async function buildDesktopShotPayload(
     collectShotStatSeries(resolved),
   ]);
   const includeOptionsChains = resolved.pane.id === OPTIONS_PANE_ID || resolved.template?.paneId === OPTIONS_PANE_ID;
+  const shotNow = new Date();
   for (const symbol of collectShotSymbols(resolved, rawArg)) {
     const entry = await fetchTickerFinancials(context, symbol);
     const requestedRange = shotPriceHistoryRange(resolved);
     let data = entry.financials;
-    if (requestedRange) {
-      const exchange = entry.instrument.exchange
-        ?? entry.tickerFile?.metadata.exchange
-        ?? data.quote?.listingExchangeName
-        ?? data.quote?.exchangeName
-        ?? "";
+    const exchange = entry.instrument.exchange
+      ?? entry.tickerFile?.metadata.exchange
+      ?? data.quote?.listingExchangeName
+      ?? data.quote?.exchangeName
+      ?? "";
+    if (resolved.capability.id === "intraday-price-chart") {
+      const request = resolveShotIntradayRequest(resolved.options);
+      const intraday = await loadShotIntradayWindow({
+        provider: context.dataProvider,
+        symbol: entry.instrument.symbol,
+        exchange,
+        request,
+        now: shotNow,
+      });
+      data = { ...data, priceHistory: intraday.points };
+      intradayHistories.push({
+        symbol: entry.instrument.symbol,
+        exchange,
+        rangePreset: request.rangePreset,
+        resolution: request.resolution,
+        requestedSession: request.session,
+        sessionDates: intraday.sessionDates,
+        points: intraday.points,
+        start: intraday.start?.toISOString() ?? null,
+        end: intraday.end?.toISOString() ?? null,
+        unavailableReason: intraday.unavailableReason,
+      });
+      const presetStart = subtractTimeRange(shotNow, request.rangePreset);
+      const needsExplicitWindow = request.session !== null
+        || (intraday.start !== null && intraday.start.getTime() < presetStart.getTime())
+        || (intraday.end !== null && intraday.end.getTime() > shotNow.getTime());
+      if (needsExplicitWindow && intraday.start && intraday.end) {
+        const chartSpec = parseChartSpec(shotInstance.settings?.chartSpec);
+        if (chartSpec) {
+          shotInstance = {
+            ...shotInstance,
+            settings: {
+              ...shotInstance.settings,
+              chartSpec: {
+                ...chartSpec,
+                viewport: {
+                  ...chartSpec.viewport,
+                  dateWindow: {
+                    start: intraday.start.toISOString(),
+                    end: intraday.end.toISOString(),
+                  },
+                },
+              },
+            },
+          };
+        }
+      }
+    } else if (requestedRange) {
       try {
         const priceHistory = await context.dataProvider.getPriceHistory(entry.instrument.symbol, exchange, requestedRange);
         data = { ...data, priceHistory: clipPriceHistoryToRange(priceHistory, requestedRange) };
@@ -472,15 +530,13 @@ async function buildDesktopShotPayload(
     tickers.push(entry.tickerFile ?? createFallbackTicker(symbol, data, context));
     financials.push([symbol, data]);
     if (includeOptionsChains && context.dataProvider.getOptionsChain) {
-      const exchange = entry.instrument.exchange
-        ?? entry.tickerFile?.metadata.exchange
-        ?? data.quote?.listingExchangeName
-        ?? data.quote?.exchangeName
-        ?? "";
       const chain = await context.dataProvider.getOptionsChain(entry.instrument.symbol, exchange);
       optionsChains.push([symbol, chain]);
     }
   }
+  layout.instances[0] = shotInstance;
+  config.layout.instances[0] = shotInstance;
+  if (config.layouts[0]) config.layouts[0].layout.instances[0] = shotInstance;
 
   return {
     config,
@@ -493,6 +549,7 @@ async function buildDesktopShotPayload(
     watermark,
     tickers,
     financials,
+    intradayHistories,
     optionsChains,
     fredSeries,
     valuationSeries,
@@ -525,7 +582,7 @@ export function shotPriceHistoryRange(resolved: ResolvedPaneFunction): TimeRange
     case "return-correlation":
       return (resolved.options.rangePreset ?? "1Y") as TimeRange;
     case "intraday-price-chart":
-      return "1D";
+      return (resolved.options.rangePreset ?? "1D") as TimeRange;
     case "historical-prices":
     case "security-relationship":
       return (resolved.options.range ?? "1Y") as TimeRange;
@@ -545,6 +602,7 @@ export async function renderDesktopShot({
   scale,
   watermark,
   options,
+  captureImage = true,
 }: {
   resolved: ResolvedPaneFunction;
   context: MarketContext;
@@ -556,8 +614,9 @@ export async function renderDesktopShot({
   scale?: number;
   watermark?: string | null;
   options: Record<string, string | true>;
+  captureImage?: boolean;
 }): Promise<PaneScreenshotResult> {
-  await mkdir(dirname(outputPath), { recursive: true });
+  if (captureImage) await mkdir(dirname(outputPath), { recursive: true });
   const apiProxy = resolveDesktopShotApiProxy(context);
   const previousSessionToken = apiClient.getSessionToken();
   let payload: DesktopPaneShotPayload;
@@ -575,7 +634,7 @@ export async function renderDesktopShot({
       scale ?? 1,
       watermark ?? null,
     );
-    render = await renderDesktopPaneScreenshot(payload, outputPath, apiProxy);
+    render = await renderDesktopPaneScreenshot(payload, outputPath, apiProxy, { captureImage });
   } finally {
     apiClient.setSessionToken(previousSessionToken);
   }
@@ -598,9 +657,10 @@ export async function renderDesktopShot({
   );
   const expectedChart = shotExpectedChart(resolved, payload);
   const dataEvidence = shotDataEvidenceFor(resolved, payload);
-  const chartEvidenceMismatches = expectedChart
-    ? chartEvidenceMismatchesFor(render.semanticUi, expectedChart)
-    : [];
+  const chartEvidenceMismatches = [
+    ...(expectedChart ? chartEvidenceMismatchesFor(render.semanticUi, expectedChart) : []),
+    ...intradayChartEvidenceMismatchesFor(resolved, payload, render.semanticUi),
+  ];
   const semanticMismatch = missingExpectedText.length > 0
     || missingExpectedSelections.length > 0
     || chartEvidenceMismatches.length > 0;
@@ -619,6 +679,9 @@ export async function renderDesktopShot({
     requiresStructuredDataEvidence: requiresStructuredDataEvidence(resolved),
     hasStructuredDataEvidence: dataEvidence !== null,
   });
+  const unusableReason = usable
+    ? null
+    : shotUnusableReasonFor(resolved, payload, render, unavailableSymbols, semanticMismatch);
   return {
     kind: "pane-screenshot",
     target: resolved.token,
@@ -637,6 +700,7 @@ export async function renderDesktopShot({
     unavailableSymbols,
     semanticMismatch,
     usable,
+    unusableReason,
     dataEvidence,
     outputPath,
     render: {
@@ -652,8 +716,37 @@ export async function renderDesktopShot({
 }
 
 function requiresStructuredDataEvidence(resolved: ResolvedPaneFunction): boolean {
-  return ["price-chart", "price-comparison", "fundamental-series", "financial-statements"]
-    .includes(resolved.capability.id);
+  return [
+    "price-chart",
+    "intraday-price-chart",
+    "price-comparison",
+    "fundamental-series",
+    "financial-statements",
+  ].includes(resolved.capability.id);
+}
+
+export function shotUnusableReasonFor(
+  resolved: ResolvedPaneFunction,
+  payload: DesktopPaneShotPayload,
+  render: Pick<DesktopPaneShotRenderResult, "loadingStateDetected" | "errorStateDetected" | "emptyStateDetected">,
+  unavailableSymbols: string[],
+  semanticMismatch: boolean,
+): string {
+  if (resolved.capability.id === "intraday-price-chart") {
+    const intraday = payload.intradayHistories[0];
+    if (intraday?.unavailableReason) return intraday.unavailableReason;
+    if (intraday && intraday.points.length > 0) {
+      return `Intraday bars were loaded for ${intraday.symbol}, but the chart did not render them.`;
+    }
+    const symbol = payload.financials[0]?.[0] ?? resolved.createOptions?.symbol ?? "the ticker";
+    return `No intraday price history is available for ${symbol} for the requested session window.`;
+  }
+  if (render.loadingStateDetected) return "The pane was still loading when the screenshot was captured.";
+  if (render.errorStateDetected) return "The pane rendered an error state.";
+  if (render.emptyStateDetected) return "The pane rendered an empty state.";
+  if (unavailableSymbols.length > 0) return `Data is unavailable for ${unavailableSymbols.join(", ")}.`;
+  if (semanticMismatch) return "The rendered content did not match the requested capability.";
+  return "The pane did not produce verifiable screenshot evidence.";
 }
 
 const STATEMENT_EVIDENCE_KEYS: Record<string, ReadonlySet<string>> = {
@@ -685,6 +778,23 @@ export function shotDataEvidenceFor(
   resolved: ResolvedPaneFunction,
   payload: DesktopPaneShotPayload,
 ): PaneScreenshotDataEvidence | null {
+  if (resolved.capability.id === "intraday-price-chart") {
+    const intraday = payload.intradayHistories[0];
+    if (!intraday || intraday.points.length === 0) return null;
+    const evidence = chartSeriesEvidence(intraday.symbol, intraday.points);
+    if (!evidence.first || !evidence.last) return null;
+    return {
+      kind: "price-series",
+      symbol: intraday.symbol,
+      range: intraday.rangePreset,
+      pointCount: evidence.pointCount,
+      first: evidence.first,
+      last: evidence.last,
+      resolution: intraday.resolution,
+      sessionDates: intraday.sessionDates,
+    };
+  }
+
   if (resolved.capability.id === "price-chart") {
     const range = String(resolved.options.rangePreset ?? "5Y") as TimeRange;
     const [symbol, financials] = payload.financials[0] ?? [];
@@ -1140,6 +1250,48 @@ export function chartEvidenceMismatchesFor(
   return mismatches;
 }
 
+export function intradayChartEvidenceMismatchesFor(
+  resolved: ResolvedPaneFunction,
+  payload: DesktopPaneShotPayload,
+  semanticUi: RemoteUiNodeSnapshot[],
+): string[] {
+  if (resolved.capability.id !== "intraday-price-chart") return [];
+  const intraday = payload.intradayHistories[0];
+  if (!intraday || intraday.points.length === 0) return [];
+  const metadata = semanticUi.find((node) => (
+    node.role === "chart-data" && node.metadata?.kind === "chart-composer"
+  ))?.metadata;
+  if (!metadata) return ["rendered intraday chart-data semantic evidence is missing"];
+  const baseSeries = Array.isArray(metadata.baseSeries) ? metadata.baseSeries : [];
+  const actual = baseSeries[0];
+  if (!isRecord(actual)) return ["rendered intraday base series is missing"];
+
+  const expected = chartSeriesEvidence(intraday.symbol, intraday.points);
+  const mismatches: string[] = [];
+  if (actual.pointCount !== expected.pointCount) {
+    mismatches.push("rendered intraday point count does not match");
+  }
+  if (metadata.projectedPointCount !== expected.pointCount) {
+    mismatches.push("rendered intraday projection point count does not match");
+  }
+  const pointMatches = (
+    actualPoint: unknown,
+    expectedPoint: PaneScreenshotChartPointEvidence | null,
+  ): boolean => {
+    if (!isRecord(actualPoint) || !expectedPoint) return false;
+    return actualPoint.date === expectedPoint.date
+      && typeof actualPoint.value === "number"
+      && closeEnough(actualPoint.value, expectedPoint.close);
+  };
+  if (!pointMatches(actual.first, expected.first)) {
+    mismatches.push("rendered intraday first bar does not match");
+  }
+  if (!pointMatches(actual.last, expected.last)) {
+    mismatches.push("rendered intraday last bar does not match");
+  }
+  return mismatches;
+}
+
 export function shotUnavailableSymbols(
   resolved: ResolvedPaneFunction,
   payload: DesktopPaneShotPayload,
@@ -1162,6 +1314,16 @@ export function shotUnavailableSymbols(
       return [];
     });
   }
+  if (resolved.capability.id === "intraday-price-chart") {
+    const symbol = payload.intradayHistories[0]?.symbol ?? payload.financials[0]?.[0];
+    const metadata = semanticUi.find((node) => (
+      node.role === "chart-data" && node.metadata?.kind === "chart-composer"
+    ))?.metadata;
+    const renderedPoints = typeof metadata?.projectedPointCount === "number"
+      ? metadata.projectedPointCount
+      : 0;
+    return symbol && renderedPoints <= 0 ? [symbol] : [];
+  }
   const graphKind = shotGraphKind(resolved);
   if (graphKind) {
     const metric = resolved.options.metric as GraphMetricKey;
@@ -1174,7 +1336,7 @@ export function shotUnavailableSymbols(
       ).length === 0 ? [symbol] : []
     ));
   }
-  if (["price-chart", "intraday-price-chart", "historical-prices"].includes(resolved.capability.id)) {
+  if (["price-chart", "historical-prices"].includes(resolved.capability.id)) {
     return payload.financials.flatMap(([symbol, financials]) => financials.priceHistory.length > 0 ? [] : [symbol]);
   }
   if (["price-comparison", "return-correlation", "security-relationship"].includes(resolved.capability.id)) {
@@ -1211,6 +1373,14 @@ export function shotSemanticRowCount(
       count + (isRecord(entry) && typeof entry.pointCount === "number" ? Math.max(0, entry.pointCount) : 0)
     ), 0);
   }
+  if (resolved.capability.id === "intraday-price-chart") {
+    const metadata = semanticUi.find((node) => (
+      node.role === "chart-data" && node.metadata?.kind === "chart-composer"
+    ))?.metadata;
+    return typeof metadata?.projectedPointCount === "number"
+      ? Math.max(0, metadata.projectedPointCount)
+      : 0;
+  }
   const graphKind = shotGraphKind(resolved);
   if (graphKind) {
     const metric = resolved.options.metric as GraphMetricKey;
@@ -1223,7 +1393,7 @@ export function shotSemanticRowCount(
       ).length
     ), 0);
   }
-  if (["price-chart", "intraday-price-chart", "historical-prices"].includes(resolved.capability.id)) {
+  if (["price-chart", "historical-prices"].includes(resolved.capability.id)) {
     return payload.financials[0]?.[1].priceHistory.length ?? 0;
   }
   if (["price-comparison", "return-correlation", "security-relationship"].includes(resolved.capability.id)) {

package/src/cli/restore-plugins.ts

@@ -11,24 +11,31 @@ const log = debugLog.createLogger("plugin-seed");
  * Runs before the plugin catalog is read so a restored plugin is available in
  * the same session, and stays quiet on failure: an offline launch should start
  * normally and try again next time, not block on a network request.
+ *
+ * Returns the seeded ids so a caller that already holds the config in memory
+ * can adopt them. The desktop loads its config before restoring, and without
+ * this it would keep an object whose `seededPlugins` is one launch stale and
+ * overwrite the record on the next save.
  */
-export async function restoreExtractedPlugins(): Promise<void> {
+export async function restoreExtractedPlugins(): Promise<string[] | null> {
   try {
     const config = await loadCliConfigIfAvailable();
     // No data directory yet means a first run: there is nothing to restore.
-    if (!config) return;
+    if (!config) return null;
     const { installPlugin } = await import("./commands/plugins");
     const result = await seedExtractedPlugins(config, installPlugin);
 
     const seeded = [...new Set(result.seeded)].sort();
     const existing = [...new Set(config.seededPlugins ?? [])].sort();
-    if (seeded.join() === existing.join()) return;
+    if (seeded.join() === existing.join()) return seeded;
 
     await saveConfig({ ...config, seededPlugins: seeded });
     if (result.installed.length > 0) {
       log.info(`Restored ${result.installed.join(", ")} into ~/.gloomberb/plugins`);
     }
+    return seeded;
   } catch (error) {
     log.error(`Plugin restore skipped: ${error}`);
+    return null;
   }
 }

package/src/components/chart/composite/composite-chart.test.tsx

@@ -31,6 +31,7 @@ import {
   buildCompositeNavigationFrame,
   zoomCompositeViewport,
 } from "./interactions";
+import { COMPOSITE_RIGHT_OFFSET_RATIO } from "./time-scale";
 import { getThemeColors, syncTheme } from "../../../theme/colors";
 import { ThemeProvider } from "../../../theme/theme-context";
 import { DEFAULT_THEME } from "../../../theme/themes";
@@ -304,6 +305,70 @@ describe("CompositeChart", () => {
     expect(testSetup.captureCharFrame()).toContain("ACME Price $110 +10.65%");
   });
 
+  test("holds a lower panel's rows while its series has no observations in view", async () => {
+    const price: ResolvedSeries = {
+      ...series("price", "main", "left", "USD", []),
+      points: [
+        point("2025-01-01", 100),
+        point("2025-01-02", 103),
+        point("2025-01-03", 101),
+        point("2025-01-04", 104),
+        point("2025-01-05", 102),
+      ],
+    };
+    const volume: ResolvedSeries = {
+      ...series("volume", "volume", "left", "shares", []),
+      label: "Volume",
+      unitGroup: "volume",
+      style: "columns",
+      points: [point("2025-01-01", 4_000), point("2025-01-02", 6_000)],
+    };
+    const panels = [{ id: "main", height: 3 }, { id: "volume", height: 1 }];
+    const renderChart = async (
+      volumeSeries: ResolvedSeries,
+      viewport?: { start: Date; end: Date },
+    ) => {
+      testSetup = await testRender(
+        <CompositeChart
+          width={78}
+          height={18}
+          series={[price, volumeSeries]}
+          panels={panels}
+          viewport={viewport}
+        />,
+        { width: 80, height: 20 },
+      );
+      await act(async () => {
+        await testSetup!.renderOnce();
+        await testSetup!.renderOnce();
+      });
+      const frame = testSetup!.captureCharFrame();
+      await act(async () => testSetup!.renderer.destroy());
+      testSetup = undefined;
+      return frame;
+    };
+    // The lowest price-axis label sits on the boundary between the two panels,
+    // so it moves down the moment the lower panel gives up its rows.
+    const priceAxisFloor = (frame: string) => frame
+      .split("\n")
+      .reduce((row, line, index) => line.includes("$") ? index : row, -1);
+
+    const loaded = await renderChart(volume);
+    // Panned to a window the upper panel covers and the lower panel has no bars in.
+    const panned = await renderChart(volume, {
+      start: new Date("2025-01-03T00:00:00.000Z"),
+      end: new Date("2025-01-05T00:00:00.000Z"),
+    });
+    // The same chart before the lower panel's data has loaded at all.
+    const loading = await renderChart({ ...volume, points: [] });
+
+    expect(priceAxisFloor(loaded)).toBeGreaterThan(0);
+    expect(priceAxisFloor(panned)).toBe(priceAxisFloor(loaded));
+    expect(priceAxisFloor(loading)).toBe(priceAxisFloor(loaded));
+    // A panel with loaded history keeps its axis while the window holds no bars.
+    expect(panned).toMatch(/\dK/);
+  });
+
   test("lays out mixed panels with one shared legend and time axis", async () => {
     testSetup = await testRender(
       <CompositeChart
@@ -1429,7 +1494,9 @@ describe("CompositeChart", () => {
       frame,
       viewport,
       1 + 4 * 0.04,
-      pointerX / Math.max(plotWidth - 1, 1),
+      // The pointer reads in plot space, which is wider than the viewport by
+      // the reserved right offset.
+      pointerX / Math.max(plotWidth - 1, 1) * (1 + COMPOSITE_RIGHT_OFFSET_RATIO),
     );
 
     await act(async () => {