gloomberb 0.13.2 → 0.14.0

package/src/time-series/sec-eps-research.test.ts

@@ -0,0 +1,55 @@
+import { expect, test } from "bun:test";
+import { parseCompanyFactsFinancialStatements } from "../sources/sec-edgar";
+import { mergeFinancialStatementRows } from "../utils/financial-statements";
+import { extractFundamentalSeries } from "./fundamentals";
+import { graphRowsForFinancials } from "./reporting";
+
+const old = { form: "10-K", accn: "0000320193-19-000119", filed: "2019-10-31" };
+const next = { form: "10-K", accn: "0000320193-20-000096", filed: "2020-10-30" };
+const oldPeriod = { start: "2016-09-25", end: "2017-09-30" };
+const comparison = { start: "2017-10-01", end: "2018-09-29" };
+const payload = { facts: { "us-gaap": {
+  StockholdersEquityNoteStockSplitConversionRatio1: { units: { pure: [{ ...next, end: "2020-08-28", val: 4 }] } },
+  EarningsPerShareDiluted: { units: { "USD/shares": [
+    { ...old, ...oldPeriod, val: 9.21 }, { ...old, ...comparison, val: 11.91 }, { ...next, ...comparison, val: 2.98 },
+  ] } },
+  NetIncomeLoss: { units: { USD: [
+    { ...old, ...oldPeriod, val: 48_351_000_000 },
+    { ...old, ...comparison, val: 59_531_000_000 }, { ...next, ...comparison, val: 59_531_000_000 },
+  ] } },
+} } };
+
+test("SEC split correction survives cached statement merging, graph growth and JSON export", () => {
+  const projected = parseCompanyFactsFinancialStatements(payload);
+  const annualStatements = mergeFinancialStatementRows(projected.annualStatements, [
+    { date: "2017-09-30", currency: "USD", eps: 9.21, netIncome: 48_351_000_000 },
+  ]);
+  expect(annualStatements[0]).toMatchObject({ eps: 2.3025, netIncome: 48_351_000_000, fieldAvailability: { eps: "2020-10-30", netIncome: "2019-10-31" }, dateEvidence: { filed: "2019-10-31" } });
+  const refreshed = mergeFinancialStatementRows([{ date: "2017-09-30", currency: "USD", eps: 9.21 }], projected.annualStatements);
+  expect(refreshed[0]).toMatchObject({ eps: 2.3025, epsBasis: { factor: 4 }, fieldAvailability: { eps: "2020-10-30" } });
+  const unrelated = mergeFinancialStatementRows([{ date: "2017-09-30", currency: "USD", eps: 10 }], projected.annualStatements)[0]!;
+  expect(unrelated.eps).toBe(10);
+  expect(unrelated.epsBasis).toBeUndefined();
+  const financials = { annualStatements, quarterlyStatements: [], priceHistory: [] };
+  const series = extractFundamentalSeries(financials, { kind: "security", instrument: { symbol: "AAPL" }, fieldId: "fundamental.eps", period: "annual", timestampMode: "period-end" });
+  const exported = JSON.parse(JSON.stringify(series));
+  expect(exported[0]).toMatchObject({ value: 2.3025, observedAt: "2017-09-30T00:00:00.000Z", availableAt: "2020-10-30T00:00:00.000Z", provenance: { quality: "derived", secEpsBasis: { originalValue: 9.21, factor: 4 } } });
+  expect(graphRowsForFinancials(financials, "fundamental", "eps", "annual", "AAPL")[1]!.growth).toBeCloseTo(2.98 / 2.3025 - 1, 10);
+});
+
+test("unresolved EPS cannot return through cached fallback, inferred P/E or a multi-year growth gap", () => {
+  const row = { ...parseCompanyFactsFinancialStatements(payload).annualStatements[0]!, eps: undefined };
+  row.epsBasis = { ...row.epsBasis!, status: "unresolved", factor: undefined };
+  const merged = mergeFinancialStatementRows([row], [{ date: row.date, currency: "USD", eps: 9.21, dilutedShares: 5_251_692_000 }]);
+  expect(merged[0]!.eps).toBeUndefined();
+  const financials = { annualStatements: [
+    { date: "2016-09-24", currency: "USD", eps: 2 }, ...merged,
+    { date: "2018-09-29", currency: "USD", eps: 3 },
+  ], quarterlyStatements: [], priceHistory: [{ date: new Date("2019-10-31"), close: 50 }],
+  quote: { symbol: "AAPL", price: 50, currency: "USD", change: 0, changePercent: 0, lastUpdated: Date.parse("2019-10-31") } };
+  const eps = graphRowsForFinancials(financials, "fundamental", "eps", "annual", "AAPL");
+  expect(eps.map((point) => point.date)).toEqual(["2016-09-24", "2018-09-29"]);
+  expect(eps[1]!.growth).toBeNull();
+  const pe = extractFundamentalSeries({ ...financials, annualStatements: merged }, { kind: "security", instrument: { symbol: "AAPL" }, fieldId: "valuation.trailingPE", period: "annual", timestampMode: "period-end" });
+  expect(pe).toEqual([]);
+});

package/src/time-series/session-history-domain.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, test } from "bun:test";
+import type { PricePoint, Quote } from "../types/financials";
+import { createDefaultConfig } from "../types/config";
+import { createTestDataProvider } from "../test-support/data-provider";
+import { createSnapshotDataProvider } from "../market-data/snapshot-provider";
+import { chartHeadless, loadChartPaneModel, type ChartPaneModel } from "../plugins/builtin/chart-composer/headless";
+import { buildIntradayPriceChartPreset } from "../plugins/builtin/chart-composer/presets";
+import { loadIntradayWindow, resolveIntradaySessionWindow } from "./session-history";
+
+// Synthetic domain boundary, not a replay of a published exchange tape. CME
+// permits negative CL prices: cmegroup.com/notices/clearing/2020/04/Chadv20-160.html
+function bars(values: number[], date = "2020-04-20"): PricePoint[] {
+  return values.map((close, minute) => ({
+    date: new Date(`${date}T18:${String(minute).padStart(2, "0")}:00Z`),
+    open: close, high: close + 0.1, low: close - 0.1, close, volume: 100 + minute,
+  }));
+}
+
+function quote(instrumentType?: string, symbol = "CL=F"): Quote {
+  return { symbol, listingExchangeName: "NYMEX", instrumentType, price: 999, currency: "USD", change: 0, changePercent: 0, lastUpdated: Date.now() };
+}
+
+const request = { rangePreset: "1D", resolution: "1m", session: "2020-04-20" } as const;
+
+async function modelFor(points: PricePoint[], reportedQuote: Quote | Error, log = false) {
+  let quoteCalls = 0;
+  const provider = createTestDataProvider({
+    async getQuote() { quoteCalls++; if (reportedQuote instanceof Error) throw reportedQuote; return reportedQuote; },
+    getPriceHistoryForResolution: async () => points,
+    getDetailedPriceHistory: async () => points,
+  });
+  const spec = buildIntradayPriceChartPreset("CL=F:NYMEX");
+  if (log) spec.panels[0]!.scale = "log";
+  const model = await chartHeadless("graph-intraday-price-pane").load({
+    rawArgument: "CL=F:NYMEX", argument: "CL=F:NYMEX", symbols: ["CL=F:NYMEX"], options: { session: request.session },
+  }, {
+    marketData: provider, apiClient: {} as never,
+    config: createDefaultConfig("/tmp/gloom-session-domain-test"),
+    signal: new AbortController().signal, settings: { chartSpec: spec },
+  }) as ChartPaneModel;
+  return { model, quoteCalls };
+}
+
+describe("intraday price domains", () => {
+  test("GIP preserves futures price, OHLC and volume through zero/negative prices without appending the metadata quote", async () => {
+    const points = bars([17.73, 0, -37.63, 1.5]);
+    const { model, quoteCalls } = await modelFor(points, quote("FUTURE"));
+    const price = model.chart.series[0]!;
+    expect(price.points.map(({ value }) => value)).toEqual([17.73, 0, -37.63, 1.5]);
+    expect(price.points.map(({ open, high, low, close, volume }) => ({ open, high, low, close, volume })))
+      .toEqual(points.map(({ open, high, low, close, volume }) => ({ open, high, low, close, volume })));
+    expect(model.chart.series[1]?.points.map(({ value }) => value)).toEqual([100, 101, 102, 103]);
+    expect(model.chart.series[1]?.unit).toBe("contracts");
+    expect(model.errors).toEqual([]);
+    expect(model.unavailableSymbols).toEqual([]);
+    expect(quoteCalls).toBe(1);
+  });
+
+  test("a nonpositive-only latest futures session is retained instead of falling back to an older positive session", async () => {
+    const points = [...bars([10, 11], "2020-04-19"), ...bars([0, -37.63])];
+    const provider = createTestDataProvider({ getQuote: async () => quote("FUT"), getPriceHistoryForResolution: async () => points });
+    const loaded = await loadIntradayWindow({ provider, symbol: "CL=F", exchange: "NYMEX", request: { ...request, session: null } });
+    expect(loaded.points.map(({ close }) => close)).toEqual([0, -37.63]);
+    expect(loaded.sessionDates).toEqual(["2020-04-20"]);
+    expect(loaded.unavailableReason).toBeNull();
+  });
+
+  test("unverified, equity and option domains fail visibly and retain rejected observations in generic JSON metadata", async () => {
+    for (const reported of [quote(), quote("EQUITY"), quote("ETF"), quote("OPTION"), quote("FUTURE", "OTHER"), new Error("metadata unavailable")]) {
+      const points = bars([17.73, 0, -37.63, 1.5]);
+      const { model } = await modelFor(points, reported);
+      expect(model.chart.series.every(({ points }) => points.length === 0)).toBe(true);
+      expect(model.complete).toBe(false);
+      expect(model.unavailableSymbols).toEqual(["CL=F:NYMEX"]);
+      expect(model.errors?.join(" ")).toContain("nonpositive");
+      const failure = model.snapshot.intradayHistories[0]!.priceDomainFailure!;
+      expect(failure.sourcePoints.map(({ close }) => close)).toEqual([0, -37.63]);
+      expect(failure.sourcePoints.map(({ date }) => date)).toEqual(points.slice(1, 3).map(({ date }) => date.toISOString()));
+      expect(model.metadata?.intradayPriceDomainFailures).toEqual([{ symbol: "CL=F", exchange: "NYMEX", ...failure }]);
+      expect(Object.isFrozen(failure.sourcePoints)).toBe(true);
+      expect(Object.isFrozen(failure.sourcePoints[0])).toBe(true);
+      points[1]!.close = 123;
+      expect(failure.sourcePoints[0]!.close).toBe(0);
+    }
+  });
+
+  test("required earlier study inputs cannot bridge bad equity bars, but observations after the selected window do not reject it", async () => {
+    const selected = bars([10, 11]);
+    const before = await modelFor([...bars([-1, 2], "2020-04-19"), ...selected], quote("EQUITY"));
+    expect(before.model.complete).toBe(false);
+    expect(before.model.snapshot.intradayHistories[0]?.priceDomainFailure?.sourcePoints[0]?.date).toBe("2020-04-19T18:00:00.000Z");
+    const after = await modelFor([...selected, ...bars([-1, 2], "2020-04-21")], quote("EQUITY"));
+    expect(after.model.chart.series[0]?.points.map(({ value }) => value)).toEqual([10, 11]);
+    expect(after.model.errors).toEqual([]);
+  });
+
+  test("timestamp corrections supersede an earlier rejected close and positive histories incur no domain metadata request", async () => {
+    const points = bars([0, 11]);
+    points.push({ ...points[0]!, close: 10, open: 10, high: 11, low: 9 });
+    let calls = 0;
+    const loaded = await loadIntradayWindow({
+      provider: createTestDataProvider({ getDetailedPriceHistory: async () => points, getQuote: async () => { calls++; return quote("EQUITY"); } }),
+      symbol: "CL=F", exchange: "NYMEX", request,
+    });
+    expect(loaded.points.map(({ close }) => close)).toEqual([10, 11]);
+    expect(loaded.unavailableReason).toBeNull();
+    expect(calls).toBe(0);
+    expect((await modelFor(bars([10, 11]), quote("EQUITY"))).quoteCalls).toBe(1);
+    expect(resolveIntradaySessionWindow(bars([0, -1]), { rangePreset: "1D" }).points).toHaveLength(2);
+  });
+
+  test("futures permission preserves independent OHLC quarantine and logarithmic-scale guards", async () => {
+    const points = bars([10, -2, 3]);
+    points[1]!.high = -3;
+    const { model } = await modelFor(points, quote("FUTURE"));
+    expect(model.chart.series[0]?.points.map(({ value }) => value)).toEqual([10, null, 3]);
+    expect(model.complete).toBe(false);
+    expect(model.chart.priceHistoryIntegrity?.[0]?.integrity.sourcePoints[0]?.close).toBe(-2);
+    const log = await modelFor(bars([10, 0, -2, 3]), quote("FUTURE"), true);
+    expect(log.model.chart.warnings.join(" ")).toContain("2 non-positive observations");
+    expect(log.model.chart.series[0]?.points.map(({ value }) => value)).toEqual([10, 0, -2, 3]);
+  });
+
+  test("a captured domain quote serves scalar and batch metadata without inventing company financials", async () => {
+    const captured = quote("FUTURE");
+    const provider = createSnapshotDataProvider({ financials: [], intradayHistories: [{
+      symbol: "CL=F", exchange: "NYMEX", resolution: "1m", points: bars([-1, -2]), unavailableReason: null, quote: captured,
+    }] }, createTestDataProvider());
+    expect(await provider.getQuote("CL=F", "NYMEX")).toBe(captured);
+    expect((await provider.getQuotesBatch!([{ symbol: "CL=F", exchange: "NYMEX" }]))[0]?.quote).toBe(captured);
+    await expect(provider.getTickerFinancials("CL=F", "NYMEX")).rejects.toThrow("unused");
+    await expect(provider.getQuote("CL=F", "OTHER")).rejects.toThrow("unused");
+  });
+
+  test("captured GIP domain failures survive the chart reload used by rendered screenshots", async () => {
+    const { model } = await modelFor(bars([17.73, 0, -37.63, 1.5]), quote("EQUITY"));
+    const reason = model.snapshot.intradayHistories[0]!.unavailableReason!;
+    expect(model.errors).toHaveLength(1);
+    for (const exactWindow of [true, false]) {
+      let calls = 0;
+      const snapshot = createSnapshotDataProvider(model.snapshot, createTestDataProvider({
+        getPriceHistoryForResolution: async () => { calls++; return bars([10, 11]); },
+        getDetailedPriceHistory: async () => { calls++; return bars([10, 11]); },
+      }));
+      const spec = { ...model.spec, viewport: { ...model.spec.viewport } };
+      if (!exactWindow) delete spec.viewport.dateWindow;
+      const reloaded = await loadChartPaneModel(spec, {
+        marketData: snapshot, apiClient: {} as never,
+        config: createDefaultConfig("/tmp/gloom-session-domain-reload"),
+        signal: new AbortController().signal,
+      });
+      expect(reloaded.errors).toHaveLength(1);
+      expect(reloaded.errors?.[0]).toContain(reason);
+      expect(reloaded.chart.warnings.some((warning) => warning.includes(reason))).toBe(true);
+      expect(reloaded.chart.warnings.join(" ")).not.toContain("Choose Auto");
+      expect(reloaded.series.every(({ points }) => points.length === 0)).toBe(true);
+      expect(calls).toBe(0);
+    }
+  });
+});

package/src/{cli/pane-functions/intraday-shot.ts → time-series/session-history.ts}

@@ -1,30 +1,45 @@
-import type { DataProvider } from "../../types/data-provider";
-import type { PricePoint } from "../../types/financials";
-import type { TimeRange } from "../../time-series/range";
+import type { DataProvider, MarketDataRequestContext } from "../types/data-provider";
+import type { PricePoint, Quote } from "../types/financials";
+import type { TimeRange } from "./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";
+} from "./resolution";
+import { resolveExchangeTimeZone } from "../utils/exchanges";
+import { getPricePointTimestamp } from "../utils/price-history";
+import { pricePointIntegrity } from "../utils/price-history-integrity";
+import { zonedWallClockToUtcMs } from "../utils/zoned-date-time";
 
-export type ShotIntradayRangePreset = "1D" | "1W";
+export type IntradayRangePreset = "1D" | "1W";
 
-export interface ShotIntradayRequest {
-  rangePreset: ShotIntradayRangePreset;
+export interface IntradayRequest {
+  rangePreset: IntradayRangePreset;
   resolution: ManualChartResolution;
   session: string | null;
 }
 
-export interface ShotIntradayWindow {
+export interface IntradayWindow {
   points: PricePoint[];
   sessionDates: string[];
   start: Date | null;
   end: Date | null;
 }
 
+export interface IntradayPriceDomainFailure {
+  readonly reason: "nonpositive-price";
+  readonly instrumentType: string | null;
+  /** Rejected observations from the selected window or its calculation buffer. */
+  readonly sourcePoints: ReadonlyArray<Readonly<Omit<PricePoint, "date"> & { date: string }>>;
+}
+
+export interface LoadedIntradayWindow extends IntradayWindow {
+  bufferedPoints: PricePoint[];
+  unavailableReason: string | null;
+  quote?: Quote;
+  priceDomainFailure?: IntradayPriceDomainFailure;
+}
+
 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;
@@ -48,7 +63,7 @@ function sessionDate(timestamp: number, timeZone: string): string {
   return `${parts.get("year")}-${parts.get("month")}-${parts.get("day")}`;
 }
 
-export function parseShotSessionDate(value: string): {
+export function parseSessionDate(value: string): {
   year: number;
   month: number;
   day: number;
@@ -69,11 +84,11 @@ export function parseShotSessionDate(value: string): {
   return { year, month, day };
 }
 
-export function shotSessionUtcBounds(value: string, timeZone: string): {
+export function sessionUtcBounds(value: string, timeZone: string): {
   start: Date;
   end: Date;
 } {
-  const parsed = parseShotSessionDate(value);
+  const parsed = parseSessionDate(value);
   const next = new Date(Date.UTC(parsed.year, parsed.month - 1, parsed.day + 1));
   return {
     start: new Date(zonedWallClockToUtcMs(
@@ -101,7 +116,9 @@ 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;
+    // Session selection is independent of the asset's price domain. In
+    // particular, a zero/negative futures close is still an observation.
+    if (!Number.isFinite(timestamp) || (!Number.isFinite(point.close) && !pricePointIntegrity(point))) continue;
     byTimestamp.set(timestamp, {
       ...point,
       date: point.date instanceof Date ? point.date : new Date(timestamp),
@@ -112,14 +129,18 @@ function normalizedPoints(points: readonly PricePoint[]): PricePoint[] {
   );
 }
 
-export function resolveShotIntradaySessionWindow(
+export function intradaySessionDates(points: readonly PricePoint[], timeZone: string): string[] {
+  return [...new Set(normalizedPoints(points).map((point) => sessionDate(getPricePointTimestamp(point), timeZone)))];
+}
+
+export function resolveIntradaySessionWindow(
   points: readonly PricePoint[],
   options: {
-    rangePreset: ShotIntradayRangePreset;
+    rangePreset: IntradayRangePreset;
     session?: string | null;
     timeZone?: string | null;
   },
-): ShotIntradayWindow {
+): IntradayWindow {
   const timeZone = options.timeZone || "UTC";
   const normalized = normalizedPoints(points);
   const bySession = new Map<string, PricePoint[]>();
@@ -131,7 +152,7 @@ export function resolveShotIntradaySessionWindow(
   }
 
   const requestedSession = options.session?.trim() || null;
-  if (requestedSession) parseShotSessionDate(requestedSession);
+  if (requestedSession) parseSessionDate(requestedSession);
   const availableSessions = [...bySession.keys()].sort();
   const selectedSessions = requestedSession
     ? availableSessions.filter((date) => date === requestedSession)
@@ -149,7 +170,7 @@ export function resolveShotIntradaySessionWindow(
   };
 }
 
-export function hasIntradayBars(window: ShotIntradayWindow, timeZone = "UTC"): boolean {
+export function hasIntradayBars(window: IntradayWindow, timeZone = "UTC"): boolean {
   if (window.points.length < 2) return false;
   const pointsBySession = new Map<string, number[]>();
   for (const point of window.points) {
@@ -165,15 +186,15 @@ export function hasIntradayBars(window: ShotIntradayWindow, timeZone = "UTC"): b
   ));
 }
 
-export function resolveShotIntradayRequest(options: {
+export function resolveIntradayRequest(options: {
   rangePreset?: unknown;
   chartResolution?: unknown;
   session?: unknown;
-}): ShotIntradayRequest {
+}): IntradayRequest {
   const session = typeof options.session === "string" && options.session.trim()
     ? options.session.trim()
     : null;
-  if (session) parseShotSessionDate(session);
+  if (session) parseSessionDate(session);
   const rangePreset = session
     ? "1D"
     : options.rangePreset === "1W" ? "1W" : "1D";
@@ -189,7 +210,7 @@ export function resolveShotIntradayRequest(options: {
   return { rangePreset, resolution, session };
 }
 
-function unavailableReason(symbol: string, request: ShotIntradayRequest, kind: "empty" | "not-intraday"): string {
+function unavailableReason(symbol: string, request: IntradayRequest, kind: "empty" | "not-intraday"): string {
   const window = request.session
     ? `session ${request.session}`
     : request.rangePreset === "1W" ? "the latest five sessions" : "the latest session";
@@ -202,7 +223,8 @@ async function loadTrailingHistory(
   provider: DataProvider,
   symbol: string,
   exchange: string,
-  request: ShotIntradayRequest,
+  request: IntradayRequest,
+  context?: MarketDataRequestContext,
 ): Promise<PricePoint[]> {
   if (!provider.getPriceHistoryForResolution) return [];
   const fetchRange: TimeRange = request.rangePreset === "1W" && request.resolution !== "1m"
@@ -213,7 +235,7 @@ async function loadTrailingHistory(
       symbol,
       exchange,
       fetchRange,
-      request.resolution,
+      request.resolution, context,
     );
   } catch {
     return [];
@@ -224,19 +246,20 @@ async function loadHistoricalFallback(
   provider: DataProvider,
   symbol: string,
   exchange: string,
-  request: ShotIntradayRequest,
+  request: IntradayRequest,
   now: Date,
+  context?: MarketDataRequestContext,
 ): Promise<PricePoint[]> {
   if (!provider.getDetailedPriceHistory) return [];
   if (request.session) {
     const timeZone = resolveExchangeTimeZone(exchange) ?? "UTC";
-    const bounds = shotSessionUtcBounds(request.session, timeZone);
+    const bounds = sessionUtcBounds(request.session, timeZone);
     return provider.getDetailedPriceHistory(
       symbol,
       exchange,
       bounds.start,
       bounds.end,
-      request.resolution,
+      request.resolution, context,
     ).catch(() => []);
   }
   const end = new Date(now.getTime() - HISTORICAL_RETRY_DELAY_MS);
@@ -247,17 +270,18 @@ async function loadHistoricalFallback(
     exchange,
     start,
     end,
-    request.resolution,
+    request.resolution, context,
   ).catch(() => []);
 }
 
-export async function loadShotIntradayWindow(options: {
+export async function loadIntradayWindow(options: {
   provider: DataProvider;
   symbol: string;
   exchange: string;
-  request: ShotIntradayRequest;
+  request: IntradayRequest;
   now?: Date;
-}): Promise<ShotIntradayWindow & { unavailableReason: string | null }> {
+  context?: MarketDataRequestContext;
+}): Promise<LoadedIntradayWindow> {
   const timeZone = resolveExchangeTimeZone(options.exchange) ?? "UTC";
   let raw = options.request.session
     ? await loadHistoricalFallback(
@@ -265,15 +289,15 @@ export async function loadShotIntradayWindow(options: {
         options.symbol,
         options.exchange,
         options.request,
-        options.now ?? new Date(),
+        options.now ?? new Date(), options.context,
       )
     : await loadTrailingHistory(
         options.provider,
         options.symbol,
         options.exchange,
-        options.request,
+        options.request, options.context,
       );
-  let window = resolveShotIntradaySessionWindow(raw, {
+  let window = resolveIntradaySessionWindow(raw, {
     rangePreset: options.request.rangePreset,
     session: options.request.session,
     timeZone,
@@ -286,16 +310,16 @@ export async function loadShotIntradayWindow(options: {
           options.provider,
           options.symbol,
           options.exchange,
-          options.request,
+          options.request, options.context,
         )
       : await loadHistoricalFallback(
           options.provider,
           options.symbol,
           options.exchange,
           options.request,
-          options.now ?? new Date(),
+          options.now ?? new Date(), options.context,
         );
-    window = resolveShotIntradaySessionWindow(raw, {
+    window = resolveIntradaySessionWindow(raw, {
       rangePreset: options.request.rangePreset,
       session: options.request.session,
       timeZone,
@@ -305,10 +329,11 @@ export async function loadShotIntradayWindow(options: {
 
   if (window.points.length === 0) {
     const requestedWindow = options.request.session
-      ? shotSessionUtcBounds(options.request.session, timeZone)
+      ? sessionUtcBounds(options.request.session, timeZone)
       : null;
     return {
       ...window,
+      bufferedPoints: [],
       start: requestedWindow?.start ?? window.start,
       end: requestedWindow?.end ?? window.end,
       unavailableReason: unavailableReason(
@@ -320,15 +345,44 @@ export async function loadShotIntradayWindow(options: {
   }
   if (!hasIntradayBars(window, timeZone)) {
     const requestedWindow = options.request.session
-      ? shotSessionUtcBounds(options.request.session, timeZone)
+      ? sessionUtcBounds(options.request.session, timeZone)
       : null;
     return {
       points: [],
+      bufferedPoints: [],
       sessionDates: window.sessionDates,
       start: requestedWindow?.start ?? null,
       end: requestedWindow?.end ?? null,
       unavailableReason: unavailableReason(options.symbol, options.request, "not-intraday"),
     };
   }
-  return { ...window, unavailableReason: null };
+  const bufferedPoints = normalizedPoints(raw);
+  // Earlier rows feed study warmup; later rows cannot affect this window.
+  const nonpositive = bufferedPoints.filter((point) => point.close <= 0
+    && getPricePointTimestamp(point) <= window.end!.getTime());
+  if (nonpositive.length) {
+    // Metadata is needed only at this boundary. Do not infer a futures domain
+    // from a ticker suffix, a contract multiplier, or an option security type.
+    const reportedQuote = await options.provider.getQuote(options.symbol, options.exchange, options.context).catch(() => undefined);
+    const quote = reportedQuote?.symbol.trim().toUpperCase() === options.symbol.trim().toUpperCase()
+      ? reportedQuote : undefined;
+    const instrumentType = quote?.instrumentType?.trim().toUpperCase() || null;
+    if (instrumentType === "FUTURE" || instrumentType === "FUTURES" || instrumentType === "FUT") {
+      return { ...window, bufferedPoints, unavailableReason: null, quote };
+    }
+    const priceDomainFailure: IntradayPriceDomainFailure = Object.freeze({
+      reason: "nonpositive-price",
+      instrumentType,
+      sourcePoints: Object.freeze(nonpositive.map((point) => Object.freeze({
+        ...point,
+        date: new Date(point.date).toISOString(),
+        ...(point.historySource ? { historySource: Object.freeze({ ...point.historySource }) } : {}),
+      }))),
+    });
+    return {
+      ...window, points: [], bufferedPoints: [], quote, priceDomainFailure,
+      unavailableReason: `Intraday history for ${options.symbol} is unavailable: ${nonpositive.length} nonpositive close${nonpositive.length === 1 ? "" : "s"} in the selected window or its calculation buffer require verified futures metadata (type: ${instrumentType ?? "unknown"}).`,
+    };
+  }
+  return { ...window, bufferedPoints, unavailableReason: null };
 }