gloomberb 0.11.3 → 0.13.1

package/src/time-series/chart-data.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, test } from "bun:test";
+import { appendLiveQuotePoint } from "./chart-data";
+import type { PricePoint, Quote } from "../types/financials";
+
+function quoteFixture(overrides: Partial<Quote> = {}): Quote {
+  return {
+    symbol: "INTC",
+    price: 129,
+    currency: "USD",
+    change: 0,
+    changePercent: 0,
+    lastUpdated: Date.parse("2026-05-15T20:30:00Z"),
+    listingExchangeName: "NASDAQ",
+    marketState: "REGULAR",
+    ...overrides,
+  };
+}
+
+describe("appendLiveQuotePoint", () => {
+  test("extends coarse chart histories with a fresh quote tail", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-04T00:00:00Z"), close: 56 },
+      { date: new Date("2026-05-11T00:00:00Z"), close: 68 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture(),
+      { now: Date.parse("2026-05-15T21:00:00Z") },
+    );
+
+    expect(extended).toHaveLength(3);
+    expect(extended.at(-1)).toEqual({
+      date: new Date("2026-05-15T20:30:00Z"),
+      close: 129,
+    });
+  });
+
+  test("merges a quote into the active OHLC bucket", () => {
+    const history: PricePoint[] = [
+      {
+        date: new Date("2026-05-15T20:25:00Z"),
+        open: 124,
+        high: 130,
+        low: 122,
+        close: 126,
+        volume: 1_000,
+      },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-05-15T20:29:00Z") }),
+      {
+        now: Date.parse("2026-05-15T20:30:00Z"),
+        mode: "ohlc",
+        resolution: "5m",
+      },
+    );
+
+    expect(extended).toHaveLength(1);
+    expect(extended[0]).toEqual({
+      date: new Date("2026-05-15T20:25:00Z"),
+      open: 124,
+      high: 130,
+      low: 122,
+      close: 129,
+      volume: 1_000,
+    });
+  });
+
+  test("seeds a new OHLC bucket from the live price instead of prior-bar extremes", () => {
+    const history: PricePoint[] = [
+      {
+        date: new Date("2026-05-15T20:25:00Z"),
+        open: 124,
+        high: 180,
+        low: 80,
+        close: 126,
+        volume: 1_000,
+      },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-05-15T20:30:00Z") }),
+      {
+        now: Date.parse("2026-05-15T20:31:00Z"),
+        mode: "ohlc",
+        resolution: "5m",
+      },
+    );
+
+    expect(extended).toHaveLength(2);
+    expect(extended[1]).toEqual({
+      date: new Date("2026-05-15T20:30:00Z"),
+      open: 129,
+      high: 129,
+      low: 129,
+      close: 129,
+    });
+  });
+
+  test("treats calendar-month bars as variable-length buckets", () => {
+    const history: PricePoint[] = [{
+      date: new Date("2026-01-01T00:00:00Z"),
+      open: 120,
+      high: 140,
+      low: 110,
+      close: 125,
+    }];
+
+    const endOfJanuary = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-01-31T20:30:00Z") }),
+      {
+        now: Date.parse("2026-01-31T20:31:00Z"),
+        mode: "ohlc",
+        resolution: "1mo",
+      },
+    );
+    const startOfFebruary = appendLiveQuotePoint(
+      history,
+      quoteFixture({ lastUpdated: Date.parse("2026-02-01T20:30:00Z") }),
+      {
+        now: Date.parse("2026-02-01T20:31:00Z"),
+        mode: "ohlc",
+        resolution: "1mo",
+      },
+    );
+
+    expect(endOfJanuary).toHaveLength(1);
+    expect(endOfJanuary[0]?.close).toBe(129);
+    expect(startOfFebruary).toHaveLength(2);
+    expect(startOfFebruary[1]).toMatchObject({
+      open: 129,
+      high: 129,
+      low: 129,
+      close: 129,
+    });
+  });
+
+  test("uses the active extended-hours price for the live tail", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-15T19:30:00Z"), close: 128 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        marketState: "POST",
+        postMarketPrice: 131,
+        lastUpdated: Date.parse("2026-05-15T21:10:00Z"),
+      }),
+      { now: Date.parse("2026-05-15T21:15:00Z") },
+    );
+
+    expect(extended.at(-1)?.close).toBe(131);
+  });
+
+  test("does not bridge a missing intraday history window with one synthetic candle", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-07-22T14:49:00Z"), close: 347.73 },
+      { date: new Date("2026-07-22T14:50:00Z"), close: 347.76 },
+      { date: new Date("2026-07-22T14:51:00Z"), close: 347.68 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        symbol: "GOOG",
+        price: 346.27,
+        lastUpdated: Date.parse("2026-07-22T18:52:00Z"),
+      }),
+      Date.parse("2026-07-22T18:53:00Z"),
+    );
+
+    expect(extended).toBe(history);
+  });
+
+  test("does not append a live quote tail with a likely unit mismatch", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-18T00:00:00Z"), close: 405 },
+      { date: new Date("2026-05-22T00:00:00Z"), close: 379 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        symbol: "FTC",
+        currency: "GBP",
+        price: 3.79,
+        lastUpdated: Date.parse("2026-05-22T16:39:00Z"),
+      }),
+      { now: Date.parse("2026-05-22T16:45:00Z") },
+    );
+
+    expect(extended).toBe(history);
+  });
+
+  test("does not append stale quotes from an older active session", () => {
+    const history: PricePoint[] = [
+      { date: new Date("2026-05-11T00:00:00Z"), close: 68 },
+    ];
+
+    const extended = appendLiveQuotePoint(
+      history,
+      quoteFixture({
+        lastUpdated: Date.parse("2026-05-08T20:00:00Z"),
+      }),
+      { now: Date.parse("2026-05-15T15:00:00Z") },
+    );
+
+    expect(extended).toBe(history);
+  });
+});

package/src/time-series/resolution.test.ts

@@ -44,7 +44,7 @@ describe("chart-resolution", () => {
     expect(sortChartResolutions(["1wk", "auto", "15m", "1d"])).toEqual(["auto", "15m", "1d", "1wk"]);
   });
 
-  test("picks a denser supported resolution as the visible window narrows", () => {
+  test("picks the supported resolution whose bar count sits nearest the target", () => {
     const support = [
       { resolution: "1m", maxRange: "1D" },
       { resolution: "5m", maxRange: "1W" },
@@ -53,31 +53,30 @@ describe("chart-resolution", () => {
       { resolution: "1d", maxRange: "5Y" },
       { resolution: "1wk", maxRange: "ALL" },
     ] as const;
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2021-01-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("1wk");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2025-01-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("1d");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2025-12-01T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("1h");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2025-12-25T00:00:00Z"),
-      end: new Date("2026-01-01T00:00:00Z"),
-    }, support, 100)).toBe("15m");
-
-    expect(getBestSupportedResolutionForVisibleWindow({
-      start: new Date("2026-01-01T00:00:00Z"),
-      end: new Date("2026-01-02T00:00:00Z"),
-    }, support, 100)).toBe("1m");
+    const pick = (start: string, end: string, current?: "5m" | "15m") => (
+      getBestSupportedResolutionForVisibleWindow(
+        { start: new Date(start), end: new Date(end) },
+        support,
+        230,
+        current,
+      )
+    );
+
+    expect(pick("2021-01-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1wk");
+    expect(pick("2025-01-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1d");
+    // Five months of daily bars beat 1h bars packed three to a pixel.
+    expect(pick("2025-08-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1d");
+    expect(pick("2025-12-01T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("1h");
+    // Two weeks hold ten sessions: 15m bars, not the 780 5m bars of a
+    // calendar-day estimate.
+    expect(pick("2025-12-18T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("15m");
+    expect(pick("2025-12-29T00:00:00Z", "2026-01-01T00:00:00Z")).toBe("5m");
+    expect(pick("2026-01-01T00:00:00Z", "2026-01-02T00:00:00Z")).toBe("1m");
+
+    // A modest zoom keeps the resolution on screen; a large one still switches.
+    expect(pick("2025-12-26T09:36:00Z", "2026-01-01T00:00:00Z", "15m")).toBe("15m");
+    expect(pick("2025-12-29T00:00:00Z", "2026-01-01T00:00:00Z", "15m")).toBe("5m");
+    expect(pick("2025-12-15T00:00:00Z", "2026-01-01T00:00:00Z", "5m")).toBe("15m");
 
     expect(CHART_RESOLUTION_STEP_MS["1h"]).toBe(60 * 60_000);
   });

package/src/time-series/resolution.ts

@@ -256,15 +256,42 @@ export function isRangePresetSupported(
   return maxRange !== null && isTimeRangeAtOrBelow(range, maxRange);
 }
 
+const INTRADAY_TRADING_DAY_RATIO = 5 / 7;
+/** Bars packed tighter than the target cost more than bars spread wider. */
+const DENSE_SCORE_PENALTY = 1.5;
+/** Score margin a candidate must win by before the active resolution changes. */
+const RESOLUTION_SWITCH_HYSTERESIS = 0.35;
+
+function estimateVisiblePointCount(resolution: ManualChartResolution, spanMs: number): number {
+  const calendarDays = Math.max(spanMs / CHART_RESOLUTION_STEP_MS["1d"], 1 / 24);
+  // Intraday bars only exist on trading days, so a multi-day window holds
+  // about five sessions a week. Anything up to a day is one session.
+  const days = isIntradayResolution(resolution) && calendarDays > 1
+    ? Math.max(calendarDays * INTRADAY_TRADING_DAY_RATIO, 1)
+    : calendarDays;
+  return Math.max(days * CHART_RESOLUTION_POINTS_PER_DAY[resolution], 1);
+}
+
+function resolutionFitScore(estimatedPointCount: number, targetPointCount: number): number {
+  const ratio = estimatedPointCount / targetPointCount;
+  return ratio > 1 ? Math.log(ratio) * DENSE_SCORE_PENALTY : -Math.log(ratio);
+}
+
+/**
+ * Picks the supported resolution whose bar count sits closest to the target
+ * on a log scale, leaning toward fewer bars. A current resolution is kept
+ * until another candidate is clearly better, so a small zoom does not swap
+ * the whole data set.
+ */
 export function getBestSupportedResolutionForVisibleWindow(
   window: { start: Date | null; end: Date | null } | null,
   support: readonly ChartResolutionSupport[] | ReadonlyMap<ManualChartResolution, TimeRange>,
   targetPointCount: number,
+  currentResolution?: ManualChartResolution | null,
 ): ManualChartResolution | null {
   if (!window?.start || !window.end) return null;
 
   const spanMs = Math.max(window.end.getTime() - window.start.getTime(), 0);
-  const dayCount = Math.max(spanMs / CHART_RESOLUTION_STEP_MS["1d"], 1 / 24);
   const supportedResolutions = sortChartResolutions(
     CHART_RESOLUTION_ORDER
       .filter((resolution): resolution is ManualChartResolution => resolution !== "auto")
@@ -273,16 +300,20 @@ export function getBestSupportedResolutionForVisibleWindow(
         return maxRange !== null && isDateWindowWithinTimeRange(window.start!, window.end!, maxRange);
       }),
   );
-
   if (supportedResolutions.length === 0) return null;
 
-  const minimumPointTarget = Math.max(targetPointCount, 1);
-  for (const resolution of [...supportedResolutions].reverse()) {
-    const estimatedPointCount = Math.max(dayCount * CHART_RESOLUTION_POINTS_PER_DAY[resolution], 1);
-    if (estimatedPointCount >= minimumPointTarget) {
-      return resolution;
-    }
+  const target = Math.max(targetPointCount, 1);
+  const scores = new Map(supportedResolutions.map((resolution) => [
+    resolution,
+    resolutionFitScore(estimateVisiblePointCount(resolution, spanMs), target),
+  ] as const));
+  let best = supportedResolutions[0]!;
+  for (const resolution of supportedResolutions) {
+    if (scores.get(resolution)! <= scores.get(best)!) best = resolution;
   }
-
-  return supportedResolutions[0] ?? null;
+  if (currentResolution && scores.has(currentResolution)) {
+    const currentScore = scores.get(currentResolution)!;
+    if (currentScore <= scores.get(best)! + RESOLUTION_SWITCH_HYSTERESIS) return currentResolution;
+  }
+  return best;
 }

package/src/time-series/resolve.test.ts

@@ -3,7 +3,12 @@ import type { FredSeriesData, FredSeriesLoadResult } from "../data/fred-series";
 import { createTestDataProvider } from "../test-support/data-provider";
 import type { TickerFinancials } from "../types/financials";
 import { CHART_SPEC_VERSION, type ChartSpec } from "./types";
-import { ChartResolveCache, mergePriceHistoryWindows, resolveChartSpecData } from "./resolve";
+import {
+  ChartResolveCache,
+  mergePriceHistoryWindows,
+  resolveChartSpecData,
+  seedChartResolutionResult,
+} from "./resolve";
 import { chartQuoteOverrideKeyForSource } from "./live-quotes";
 import { chartSeriesSourceKey } from "../capabilities";
 import { buildCustomChartPreset } from "../plugins/builtin/chart-composer/presets";
@@ -26,6 +31,118 @@ const fredLoad = (
 });
 
 describe("resolveChartSpecData", () => {
+  test("seeds study series so their panels survive the wait for real data", async () => {
+    const date = new Date("2026-01-05T00:00:00.000Z");
+    const seeded = seedChartResolutionResult(
+      {
+        version: CHART_SPEC_VERSION,
+        viewport: { range: "1M", resolution: "auto" },
+        panels: [{ id: "main" }, { id: "volume" }],
+        series: [{
+          id: "price",
+          source: {
+            kind: "security",
+            instrument: { symbol: "TEST", exchange: "NASDAQ" },
+            fieldId: "market.ohlcv",
+          },
+          style: "candles",
+          transform: "raw",
+          axis: "left",
+          panelId: "main",
+          interpolation: "none",
+        }],
+        studies: [{
+          id: "volume",
+          kind: "volume",
+          inputSeriesIds: ["price"],
+          parameters: {},
+          panelId: "volume",
+          axis: "left",
+        }],
+      },
+      new Map([[
+        chartQuoteOverrideKeyForSource({
+          kind: "security",
+          instrument: { symbol: "TEST", exchange: "NASDAQ" },
+          fieldId: "market.ohlcv",
+        }),
+        [{ date, open: 10, high: 12, low: 9, close: 11, volume: 5_000 }],
+      ]]),
+    );
+
+    const volume = seeded?.series.find((entry) => entry.panelId === "volume");
+    expect(volume?.points.map((point) => point.value)).toEqual([5_000]);
+    expect(seeded?.bufferedSeries).toBe(seeded?.series);
+  });
+
+  test("keeps study output over the whole buffered history its base series carries", async () => {
+    const history = Array.from({ length: 900 }, (_, day) => {
+      const date = new Date(Date.UTC(2024, 0, 1) + day * 86_400_000);
+      return date.getUTCDay() === 0 || date.getUTCDay() === 6
+        ? null
+        : { date, open: 100, high: 101, low: 99, close: 100 + (day % 7), volume: 1_000 + day };
+    }).filter((point): point is NonNullable<typeof point> => point !== null);
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: () => [{ resolution: "1d", maxRange: "ALL" }],
+      getPriceHistoryForResolution: async () => history,
+      getDetailedPriceHistory: async () => history,
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "1Y", resolution: "1d" },
+      panels: [{ id: "main" }, { id: "volume", label: "Volume", height: 0.24 }],
+      series: [{
+        id: "price",
+        source: {
+          kind: "security",
+          instrument: { symbol: "TEST", exchange: "NASDAQ" },
+          fieldId: "market.close",
+        },
+        style: "line",
+        transform: "raw",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+      }],
+      studies: [{
+        id: "volume",
+        kind: "volume",
+        inputSeriesIds: ["price"],
+        parameters: {},
+        panelId: "volume",
+        axis: "left",
+      }],
+    };
+    const sources = {
+      dataProvider: provider,
+      now: new Date("2026-06-15T00:00:00.000Z"),
+      loadFredSeries: async () => fredLoad(),
+    };
+    const cache = new ChartResolveCache();
+
+    await resolveChartSpecData(spec, sources, cache);
+    // Panning back accumulates older bars into the buffer. The study has to
+    // follow, or it empties out wherever the base series has already been.
+    const panned = await resolveChartSpecData(spec, sources, cache, {
+      requestViewport: {
+        start: new Date("2024-02-01T00:00:00.000Z"),
+        end: new Date("2024-08-01T00:00:00.000Z"),
+      },
+    });
+
+    const span = (id: string) => {
+      const entry = panned.bufferedSeries?.find((candidate) => candidate.id === id);
+      return entry && entry.points.length > 0
+        ? {
+            first: entry.points[0]!.date.toISOString(),
+            last: entry.points.at(-1)!.date.toISOString(),
+          }
+        : null;
+    };
+    expect(span("volume")).toEqual(span("price"));
+  });
+
   test("routes futures and Treasury aliases through the existing market and FRED pipelines", async () => {
     const marketRequests: string[] = [];
     const fredRequests: string[] = [];

package/src/time-series/resolve.ts

@@ -98,6 +98,8 @@ export interface ChartResolveOptions {
   requestViewport?: { start: Date; end: Date } | null;
   /** Approximate number of horizontal observations the current surface can use. */
   targetPointCount?: number;
+  /** Resolution currently on screen, kept through small Auto zooms. */
+  currentResolution?: ManualChartResolution | null;
 }
 
 /** Raw source data retained while live quotes recompute the chart tail. */
@@ -290,6 +292,7 @@ function requestResolution(
         { start: new Date(runtimeBounds.start), end: new Date(runtimeBounds.end) },
         sharedSupport,
         options.targetPointCount ?? 120,
+        options.currentResolution,
       )
     : null;
   const preferred = adaptive
@@ -381,13 +384,22 @@ export function seedChartResolutionResult(
     if (resolved?.points.length) series.push(resolved);
   });
   if (series.length === 0) return null;
+  // Studies ride along with the seed. Without them the chart briefly drops to
+  // base series alone whenever it falls back here, and every panel a study
+  // owns loses its rows until the first real resolve lands.
+  const seeded = spec.studies.length > 0
+    ? [...series, ...resolveStudies(series, spec.studies).series]
+    : series;
   return {
-    series,
-    legendSeries: series,
-    bufferedSeries: series,
+    series: seeded,
+    legendSeries: seeded,
+    bufferedSeries: seeded,
     loading: false,
     errors: [],
     warnings: [],
+    resolution: spec.viewport.resolution === "auto"
+      ? getPresetResolution(spec.viewport.range)
+      : spec.viewport.resolution,
   };
 }
 
@@ -799,13 +811,6 @@ function prepareBaseSeriesForStudies(
   );
 }
 
-function rawCalculationSeries(series: ResolvedSeries, bounds: DateBounds): ResolvedSeries {
-  if (bounds.start !== null && bounds.end !== null) {
-    return clipSeriesToWindow(series, new Date(bounds.start), new Date(bounds.end));
-  }
-  return { ...series, points: filterPoints(series.points, bounds) };
-}
-
 function scalarBaseline(series: ResolvedSeries, bounds: DateBounds): number | null {
   const points = filterPoints(series.points, bounds);
   for (const point of points) {
@@ -1142,15 +1147,14 @@ export async function resolveChartSpecData(
     ? requestVisibleBounds
     : followLatestMarketObservation(initialVisibleBounds, rawSeries);
   const resolution = initialResolution;
-  const studyBounds = bounds.end !== null
-      && initialCalculationBounds.end !== null
-      && bounds.end > initialCalculationBounds.end
-    ? { ...initialCalculationBounds, end: bounds.end }
-    : initialCalculationBounds;
   const baseSeries = rawSeries
     .filter((entry) => visibleSeriesIds.has(entry.id))
     .map((entry) => prepareBaseSeriesForStudies(entry, bounds, false, requestVisibleBounds));
-  const calculationSeries = rawSeries.map((entry) => rawCalculationSeries(entry, studyBounds));
+  // Studies run over the same loaded history their base series carries. Clipping
+  // them to the requested window instead left a study with no observations
+  // wherever the accumulated buffer had already been panned past, so a study's
+  // panel emptied out mid-pan and only refilled once the next fetch landed.
+  const calculationSeries = rawSeries;
   let resolved = baseSeries;
 
   // Study outputs are appended by the pure engine before the final viewport clip.
@@ -1224,5 +1228,6 @@ export async function resolveChartSpecData(
     errors,
     warnings: [...new Set([...priorityWarnings, ...warnings])],
     viewport,
+    resolution,
   };
 }

package/src/time-series/types.ts

@@ -1,5 +1,5 @@
 import type { ChartResolution, TimeRange } from "./range";
-import type { ChartResolutionSupport } from "./resolution";
+import type { ChartResolutionSupport, ManualChartResolution } from "./resolution";
 import type { InstrumentRef } from "../market-data/request-types";
 
 export const CHART_SPEC_VERSION = 2 as const;
@@ -175,4 +175,6 @@ export interface ChartResolutionResult {
   warnings: string[];
   /** Effective inclusive bounds used to clip the resolved chart data. */
   viewport?: { start: Date; end: Date };
+  /** Bar resolution the loaded market history was fetched at. */
+  resolution?: ManualChartResolution;
 }

package/src/time-series/use-chart-resolution.ts

@@ -35,6 +35,7 @@ export interface UseChartResolutionOptions {
   autoViewport?: ChartResolveOptions["autoViewport"];
   requestViewport?: ChartResolveOptions["requestViewport"];
   targetPointCount?: number;
+  currentResolution?: ChartResolveOptions["currentResolution"];
 }
 
 const DEFAULT_QUOTE_POLL_INTERVAL_MS = 60_000;
@@ -146,10 +147,14 @@ export function useChartResolution(
     ? { start: new Date(requestViewportStart), end: new Date(requestViewportEnd) }
     : null;
   const adaptiveTargetPointCount = validAutoViewport ? options.targetPointCount : undefined;
+  // Read at resolve time only: hysteresis breaks ties when the viewport moves,
+  // and echoing the chosen resolution back must not trigger another resolve.
+  const currentResolution = validAutoViewport ? options.currentResolution ?? null : null;
   const resolveOptions: ChartResolveOptions = {
     autoViewport: validAutoViewport,
     requestViewport: validRequestViewport,
     targetPointCount: adaptiveTargetPointCount,
+    currentResolution,
   };
   const latestRequestRef = useRef({ spec, sources, options: resolveOptions });
   latestRequestRef.current = { spec, sources, options: resolveOptions };