gloomberb 0.11.3 → 0.13.1

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

@@ -25,6 +25,7 @@ import {
 import {
   capabilityPluginState,
   getPaneFunctionCapability,
+  isDataPaneForDomFallback,
   normalizeCapabilityOptions,
 } from "./capabilities";
 
@@ -37,12 +38,13 @@ async function withPaneRuntime<T>(
     registry: PaneFunctionCatalog;
     resolved: ResolvedPaneFunction;
   }) => Promise<T>,
+  settings: { strictHeadlessOptions?: boolean } = {},
 ): Promise<T> {
   const parsed = parsePaneFunctionArgs(args);
   return withMarketData(ctx, async (context) => {
     const registry = await createPaneCatalog(context, ctx.plugins);
     try {
-      const resolved = await resolvePaneFunction(registry, context, parsed);
+      const resolved = await resolvePaneFunction(registry, context, parsed, settings);
       return await run({ parsed, context, registry, resolved });
     } finally {
       registry.destroy();
@@ -73,7 +75,7 @@ export async function runPaneFunction(args: string[], ctx: CliCommandContext) {
       ctx.printResult({ data: report.data }, {
         text: () => report.text,
       });
-    });
+    }, { strictHeadlessOptions: true });
   });
 }
 
@@ -98,20 +100,21 @@ export async function runPaneScreenshot(args: string[], ctx: CliCommandContext)
         outputPath,
         width: parsed.width,
         height: parsed.height,
+        theme: parsed.theme,
+        scale: parsed.scale,
+        watermark: parsed.watermark,
         options: parsed.options,
       });
       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(", ")}`]
             : []),
@@ -176,6 +179,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.");
+  });
+});

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

@@ -0,0 +1,334 @@
+import type { DataProvider } from "../../types/data-provider";
+import type { PricePoint } from "../../types/financials";
+import type { TimeRange } from "../../time-series/range";
+import {
+  getPresetResolution,
+  isIntradayResolution,
+  type ManualChartResolution,
+} from "../../time-series/resolution";
+import { resolveExchangeTimeZone } from "../../utils/exchanges";
+import { getPricePointTimestamp } from "../../utils/price-history";
+import { zonedWallClockToUtcMs } from "../../utils/zoned-date-time";
+
+export type ShotIntradayRangePreset = "1D" | "1W";
+
+export interface ShotIntradayRequest {
+  rangePreset: ShotIntradayRangePreset;
+  resolution: ManualChartResolution;
+  session: string | null;
+}
+
+export interface ShotIntradayWindow {
+  points: PricePoint[];
+  sessionDates: string[];
+  start: Date | null;
+  end: Date | null;
+}
+
+const DATE_ONLY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const HISTORICAL_RETRY_DELAY_MS = 61 * 60_000;
+const DAY_MS = 24 * 60 * 60_000;
+
+function sessionDateFormatter(timeZone: string): Intl.DateTimeFormat {
+  return new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  });
+}
+
+function sessionDate(timestamp: number, timeZone: string): string {
+  const parts = new Map(
+    sessionDateFormatter(timeZone)
+      .formatToParts(new Date(timestamp))
+      .filter((part) => part.type !== "literal")
+      .map((part) => [part.type, part.value]),
+  );
+  return `${parts.get("year")}-${parts.get("month")}-${parts.get("day")}`;
+}
+
+export function parseShotSessionDate(value: string): {
+  year: number;
+  month: number;
+  day: number;
+} {
+  const match = DATE_ONLY_PATTERN.exec(value.trim());
+  if (!match) throw new Error(`Invalid --session value "${value}". Use YYYY-MM-DD.`);
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const candidate = new Date(Date.UTC(year, month - 1, day));
+  if (
+    candidate.getUTCFullYear() !== year
+    || candidate.getUTCMonth() !== month - 1
+    || candidate.getUTCDate() !== day
+  ) {
+    throw new Error(`Invalid --session value "${value}". Use a real calendar date.`);
+  }
+  return { year, month, day };
+}
+
+export function shotSessionUtcBounds(value: string, timeZone: string): {
+  start: Date;
+  end: Date;
+} {
+  const parsed = parseShotSessionDate(value);
+  const next = new Date(Date.UTC(parsed.year, parsed.month - 1, parsed.day + 1));
+  return {
+    start: new Date(zonedWallClockToUtcMs(
+      timeZone,
+      parsed.year,
+      parsed.month,
+      parsed.day,
+      0,
+      0,
+      0,
+    )),
+    end: new Date(zonedWallClockToUtcMs(
+      timeZone,
+      next.getUTCFullYear(),
+      next.getUTCMonth() + 1,
+      next.getUTCDate(),
+      0,
+      0,
+      0,
+    )),
+  };
+}
+
+function normalizedPoints(points: readonly PricePoint[]): PricePoint[] {
+  const byTimestamp = new Map<number, PricePoint>();
+  for (const point of points) {
+    const timestamp = getPricePointTimestamp(point);
+    if (!Number.isFinite(timestamp) || !Number.isFinite(point.close) || point.close <= 0) continue;
+    byTimestamp.set(timestamp, {
+      ...point,
+      date: point.date instanceof Date ? point.date : new Date(timestamp),
+    });
+  }
+  return [...byTimestamp.values()].sort(
+    (left, right) => getPricePointTimestamp(left) - getPricePointTimestamp(right),
+  );
+}
+
+export function resolveShotIntradaySessionWindow(
+  points: readonly PricePoint[],
+  options: {
+    rangePreset: ShotIntradayRangePreset;
+    session?: string | null;
+    timeZone?: string | null;
+  },
+): ShotIntradayWindow {
+  const timeZone = options.timeZone || "UTC";
+  const normalized = normalizedPoints(points);
+  const bySession = new Map<string, PricePoint[]>();
+  for (const point of normalized) {
+    const date = sessionDate(getPricePointTimestamp(point), timeZone);
+    const sessionPoints = bySession.get(date) ?? [];
+    sessionPoints.push(point);
+    bySession.set(date, sessionPoints);
+  }
+
+  const requestedSession = options.session?.trim() || null;
+  if (requestedSession) parseShotSessionDate(requestedSession);
+  const availableSessions = [...bySession.keys()].sort();
+  const selectedSessions = requestedSession
+    ? availableSessions.filter((date) => date === requestedSession)
+    : options.rangePreset === "1D"
+      ? availableSessions.slice(-1)
+      : availableSessions.slice(-5);
+  const selected = selectedSessions.flatMap((date) => bySession.get(date) ?? []);
+  const startTime = selected.length > 0 ? getPricePointTimestamp(selected[0]!) : Number.NaN;
+  const endTime = selected.length > 0 ? getPricePointTimestamp(selected.at(-1)!) : Number.NaN;
+  return {
+    points: selected,
+    sessionDates: selectedSessions,
+    start: Number.isFinite(startTime) ? new Date(startTime) : null,
+    end: Number.isFinite(endTime) ? new Date(endTime) : null,
+  };
+}
+
+export function hasIntradayBars(window: ShotIntradayWindow, timeZone = "UTC"): boolean {
+  if (window.points.length < 2) return false;
+  const pointsBySession = new Map<string, number[]>();
+  for (const point of window.points) {
+    const timestamp = getPricePointTimestamp(point);
+    const date = sessionDate(timestamp, timeZone);
+    const timestamps = pointsBySession.get(date) ?? [];
+    timestamps.push(timestamp);
+    pointsBySession.set(date, timestamps);
+  }
+  return [...pointsBySession.values()].some((timestamps) => (
+    timestamps.length >= 2
+    && timestamps.some((timestamp, index) => index > 0 && timestamp - timestamps[index - 1]! < DAY_MS)
+  ));
+}
+
+export function resolveShotIntradayRequest(options: {
+  rangePreset?: unknown;
+  chartResolution?: unknown;
+  session?: unknown;
+}): ShotIntradayRequest {
+  const session = typeof options.session === "string" && options.session.trim()
+    ? options.session.trim()
+    : null;
+  if (session) parseShotSessionDate(session);
+  const rangePreset = session
+    ? "1D"
+    : options.rangePreset === "1W" ? "1W" : "1D";
+  const requestedResolution = typeof options.chartResolution === "string"
+    ? options.chartResolution
+    : "auto";
+  const resolution = requestedResolution === "auto"
+    ? getPresetResolution(rangePreset)
+    : requestedResolution as ManualChartResolution;
+  if (!isIntradayResolution(resolution)) {
+    throw new Error(`GIP requires an intraday chart resolution, got "${requestedResolution}".`);
+  }
+  return { rangePreset, resolution, session };
+}
+
+function unavailableReason(symbol: string, request: ShotIntradayRequest, kind: "empty" | "not-intraday"): string {
+  const window = request.session
+    ? `session ${request.session}`
+    : request.rangePreset === "1W" ? "the latest five sessions" : "the latest session";
+  return kind === "not-intraday"
+    ? `The market-data provider did not return intraday bars for ${symbol} for ${window}.`
+    : `No intraday price history is available for ${symbol} for ${window}.`;
+}
+
+async function loadTrailingHistory(
+  provider: DataProvider,
+  symbol: string,
+  exchange: string,
+  request: ShotIntradayRequest,
+): Promise<PricePoint[]> {
+  if (!provider.getPriceHistoryForResolution) return [];
+  const fetchRange: TimeRange = request.rangePreset === "1W" && request.resolution !== "1m"
+    ? "1M"
+    : "1W";
+  try {
+    return await provider.getPriceHistoryForResolution(
+      symbol,
+      exchange,
+      fetchRange,
+      request.resolution,
+    );
+  } catch {
+    return [];
+  }
+}
+
+async function loadHistoricalFallback(
+  provider: DataProvider,
+  symbol: string,
+  exchange: string,
+  request: ShotIntradayRequest,
+  now: Date,
+): Promise<PricePoint[]> {
+  if (!provider.getDetailedPriceHistory) return [];
+  if (request.session) {
+    const timeZone = resolveExchangeTimeZone(exchange) ?? "UTC";
+    const bounds = shotSessionUtcBounds(request.session, timeZone);
+    return provider.getDetailedPriceHistory(
+      symbol,
+      exchange,
+      bounds.start,
+      bounds.end,
+      request.resolution,
+    ).catch(() => []);
+  }
+  const end = new Date(now.getTime() - HISTORICAL_RETRY_DELAY_MS);
+  const lookbackDays = request.rangePreset === "1W" ? 35 : 8;
+  const start = new Date(end.getTime() - lookbackDays * DAY_MS);
+  return provider.getDetailedPriceHistory(
+    symbol,
+    exchange,
+    start,
+    end,
+    request.resolution,
+  ).catch(() => []);
+}
+
+export async function loadShotIntradayWindow(options: {
+  provider: DataProvider;
+  symbol: string;
+  exchange: string;
+  request: ShotIntradayRequest;
+  now?: Date;
+}): Promise<ShotIntradayWindow & { unavailableReason: string | null }> {
+  const timeZone = resolveExchangeTimeZone(options.exchange) ?? "UTC";
+  let raw = options.request.session
+    ? await loadHistoricalFallback(
+        options.provider,
+        options.symbol,
+        options.exchange,
+        options.request,
+        options.now ?? new Date(),
+      )
+    : await loadTrailingHistory(
+        options.provider,
+        options.symbol,
+        options.exchange,
+        options.request,
+      );
+  let window = resolveShotIntradaySessionWindow(raw, {
+    rangePreset: options.request.rangePreset,
+    session: options.request.session,
+    timeZone,
+  });
+  let sawNonIntradayData = window.points.length > 0 && !hasIntradayBars(window, timeZone);
+
+  if (!hasIntradayBars(window, timeZone)) {
+    raw = options.request.session
+      ? await loadTrailingHistory(
+          options.provider,
+          options.symbol,
+          options.exchange,
+          options.request,
+        )
+      : await loadHistoricalFallback(
+          options.provider,
+          options.symbol,
+          options.exchange,
+          options.request,
+          options.now ?? new Date(),
+        );
+    window = resolveShotIntradaySessionWindow(raw, {
+      rangePreset: options.request.rangePreset,
+      session: options.request.session,
+      timeZone,
+    });
+    sawNonIntradayData ||= window.points.length > 0 && !hasIntradayBars(window, timeZone);
+  }
+
+  if (window.points.length === 0) {
+    const requestedWindow = options.request.session
+      ? shotSessionUtcBounds(options.request.session, timeZone)
+      : null;
+    return {
+      ...window,
+      start: requestedWindow?.start ?? window.start,
+      end: requestedWindow?.end ?? window.end,
+      unavailableReason: unavailableReason(
+        options.symbol,
+        options.request,
+        sawNonIntradayData ? "not-intraday" : "empty",
+      ),
+    };
+  }
+  if (!hasIntradayBars(window, timeZone)) {
+    const requestedWindow = options.request.session
+      ? shotSessionUtcBounds(options.request.session, timeZone)
+      : null;
+    return {
+      points: [],
+      sessionDates: window.sessionDates,
+      start: requestedWindow?.start ?? null,
+      end: requestedWindow?.end ?? null,
+      unavailableReason: unavailableReason(options.symbol, options.request, "not-intraday"),
+    };
+  }
+  return { ...window, unavailableReason: null };
+}