gloomberb 0.10.1 → 0.10.2

package/src/time-series/resolve.ts

@@ -1,8 +1,8 @@
-import { appendLiveQuotePoint } from "../components/chart/core/data";
+import { appendLiveQuotePoint } from "./chart-data";
 import {
   getTimeRangeForDateWindow,
   subtractTimeRange,
-} from "../components/chart/core/date-window";
+} from "./date-window";
 import {
   CHART_RESOLUTION_STEP_MS,
   clampTimeRangeToMaxRange,
@@ -14,8 +14,8 @@ import {
   TIME_RANGE_ORDER,
   type ChartResolutionSupport,
   type ManualChartResolution,
-} from "../components/chart/core/resolution";
-import type { TimeRange } from "../components/chart/core/types";
+} from "./resolution";
+import type { TimeRange } from "./range";
 import type { DataProvider, MarketDataRequestContext } from "../types/data-provider";
 import type { Quote, TickerFinancials } from "../types/financials";
 import type { FredSeriesLoadResult, FredSeriesRequest } from "../data/fred-series";
@@ -75,8 +75,10 @@ export interface ChartResolveSources {
 }
 
 export interface ChartResolveOptions {
-  /** Runtime interaction window used only while the authored resolution is Auto. */
+  /** Runtime zoom window used only to choose an adaptive Auto resolution. */
   autoViewport?: { start: Date; end: Date } | null;
+  /** Runtime interaction window used to load history around the visible chart. */
+  requestViewport?: { start: Date; end: Date } | null;
   /** Approximate number of horizontal observations the current surface can use. */
   targetPointCount?: number;
 }
@@ -122,6 +124,24 @@ function instrumentLabel(spec: Extract<ChartSeriesSpec["source"], { kind: "secur
   return publicTickerKey(spec.instrument.symbol, spec.instrument.exchange);
 }
 
+function withQuoteExchange(
+  source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
+  ...quotes: Array<Quote | undefined>
+): Extract<ChartSeriesSpec["source"], { kind: "security" }> {
+  if (source.instrument.exchange?.trim()) return source;
+  const exchange = quotes
+    .map((quote) => quote?.listingExchangeName?.trim() || quote?.exchangeName?.trim())
+    .find((value): value is string => !!value);
+  if (!exchange) return source;
+  return {
+    ...source,
+    instrument: {
+      ...source.instrument,
+      exchange,
+    },
+  };
+}
+
 function finiteDate(value: string | Date | undefined): Date | null {
   if (!value) return null;
   const date = value instanceof Date ? new Date(value) : new Date(value);
@@ -170,6 +190,18 @@ function runtimeAutoBounds(options: ChartResolveOptions): DateBounds | null {
     : null;
 }
 
+function runtimeRequestBounds(options: ChartResolveOptions): DateBounds | null {
+  const start = options.requestViewport?.start.getTime();
+  const end = options.requestViewport?.end.getTime();
+  return typeof start === "number"
+      && Number.isFinite(start)
+      && typeof end === "number"
+      && Number.isFinite(end)
+      && start <= end
+    ? { start, end }
+    : null;
+}
+
 function sameBounds(left: DateBounds | null, right: DateBounds | null): boolean {
   return left?.start === right?.start && left?.end === right?.end;
 }
@@ -450,6 +482,7 @@ function prepareBaseSeriesForStudies(
   series: ResolvedSeries,
   bounds: DateBounds,
   clipToBounds = false,
+  fallbackBaselineBounds?: DateBounds,
 ): ResolvedSeries {
   const baselineTransform = series.transform === "percent" || series.transform === "index100";
   let source = series;
@@ -458,10 +491,14 @@ function prepareBaseSeriesForStudies(
   } else if (clipToBounds) {
     source = { ...series, points: filterPoints(series.points, bounds) };
   }
+  const baseline = baselineTransform
+    ? scalarBaseline(series, bounds)
+      ?? (fallbackBaselineBounds ? scalarBaseline(series, fallbackBaselineBounds) : null)
+    : null;
   return applyResolvedSeriesTransform(
     source,
     source.transform,
-    baselineTransform ? { baseline: scalarBaseline(series, bounds) } : undefined,
+    baselineTransform ? { baseline } : undefined,
   );
 }
 
@@ -499,6 +536,7 @@ function applyStudyPresentationTransforms(
   studies: readonly ChartSpec["studies"][number][],
   rawSeries: readonly ResolvedSeries[],
   visibleBounds: DateBounds,
+  fallbackBaselineBounds?: DateBounds,
 ): ResolvedSeries[] {
   const rawById = new Map(rawSeries.map((series) => [series.id, series] as const));
   return outputs.map((output) => {
@@ -510,6 +548,7 @@ function applyStudyPresentationTransforms(
     if (!input || input.transform === "raw") return output;
     const baseline = input.transform === "percent" || input.transform === "index100"
       ? scalarBaseline(input, visibleBounds)
+        ?? (fallbackBaselineBounds ? scalarBaseline(input, fallbackBaselineBounds) : null)
       : undefined;
     return applyResolvedSeriesTransform(output, input.transform, { baseline });
   });
@@ -577,10 +616,23 @@ export async function resolveChartSpecData(
     }
     return pending;
   };
+  const sourceWithResolvedExchange = (
+    source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
+    financials: TickerFinancials | null,
+  ) => {
+    const quoteOverride = sources.quoteOverrides?.get(chartQuoteOverrideKeyForSource(source));
+    return withQuoteExchange(
+      source,
+      latestQuote(financials?.quote, quoteOverride),
+      financials?.quote,
+      quoteOverride,
+    );
+  };
 
-  const runtimeBounds = spec.viewport.resolution === "auto"
+  const adaptiveBounds = spec.viewport.resolution === "auto"
     ? runtimeAutoBounds(options)
     : null;
+  const requestBounds = runtimeRequestBounds(options) ?? adaptiveBounds;
   const activeMarketSources = [...new Map(spec.series.flatMap((entry) => (
     calculationSeriesIds.has(entry.id)
       && entry.source.kind === "security"
@@ -588,9 +640,16 @@ export async function resolveChartSpecData(
       ? [[instrumentKey(entry.source), entry.source] as const]
       : []
   ))).values()];
-  const sharedSupport = runtimeBounds && activeMarketSources.length > 0
+  const resolutionSupportSources = adaptiveBounds
+    ? await Promise.all(activeMarketSources.map(async (source) => (
+        source.instrument.exchange?.trim()
+          ? source
+          : sourceWithResolvedExchange(source, await loadFinancials(source))
+      )))
+    : activeMarketSources;
+  const sharedSupport = adaptiveBounds && activeMarketSources.length > 0
     ? intersectChartResolutionSupport(await Promise.all(
-        activeMarketSources.map((source) => loadResolutionSupport(source)),
+        resolutionSupportSources.map((source) => loadResolutionSupport(source)),
       ))
     : [];
   const initialResolution = requestResolution(
@@ -600,14 +659,14 @@ export async function resolveChartSpecData(
     options,
     sharedSupport,
   );
-  const requestVisibleBounds = runtimeBounds ?? initialVisibleBounds;
+  const requestVisibleBounds = requestBounds ?? initialVisibleBounds;
   const initialCalculationBounds = calculationBounds(
     spec,
     requestVisibleBounds,
     initialResolution,
   );
   const hasExplicitWindow = explicitBounds(spec) !== null
-    || (runtimeBounds !== null && !sameBounds(runtimeBounds, initialVisibleBounds));
+    || (requestBounds !== null && !sameBounds(requestBounds, initialVisibleBounds));
 
   const loadHistory = async (
     source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
@@ -676,13 +735,22 @@ export async function resolveChartSpecData(
       const marketField = isMarketFieldId(source.fieldId);
       const quoteDerivedValuation = valuationSeriesUsesLiveQuote(source.fieldId);
       const needsHistory = marketField || quoteDerivedValuation;
-      const [financials, history] = await Promise.all([
-        loadFinancials(source),
-        needsHistory ? loadHistory(source, quoteDerivedValuation) : Promise.resolve(null),
-      ]);
       const quoteOverride = marketField || quoteDerivedValuation
         ? sources.quoteOverrides?.get(chartQuoteOverrideKeyForSource(source))
         : undefined;
+      const financialsPromise = loadFinancials(source);
+      let financials: TickerFinancials | null;
+      let history: TickerFinancials["priceHistory"] | null;
+      if (needsHistory && !source.instrument.exchange?.trim()) {
+        financials = await financialsPromise;
+        const historySource = sourceWithResolvedExchange(source, financials);
+        history = await loadHistory(historySource, quoteDerivedValuation);
+      } else {
+        [financials, history] = await Promise.all([
+          financialsPromise,
+          needsHistory ? loadHistory(source, quoteDerivedValuation) : Promise.resolve(null),
+        ]);
+      }
       const liveBarResolution = isOhlcSeriesStyle(seriesSpec.style) ? initialResolution : undefined;
       const merged = history
         ? mergeHistory(financials, history, quoteOverride, referenceNow.getTime(), liveBarResolution)
@@ -703,6 +771,9 @@ export async function resolveChartSpecData(
   }));
 
   const rawSeries = loaded.filter((entry): entry is ResolvedSeries => !!entry);
+  const marketTimelineSeries = primaryMarketSeries?.visible === false
+    ? rawSeries.filter((entry) => entry.id === primaryMarketSeries.id)
+    : [];
   // Preset ranges describe a window ending at the requested reference time,
   // even when the newest filing or economic observation lags that endpoint.
   // Re-anchoring to the latest observation both mislabels the range and asks
@@ -712,7 +783,7 @@ export async function resolveChartSpecData(
   const studyBounds = initialCalculationBounds;
   const baseSeries = rawSeries
     .filter((entry) => visibleSeriesIds.has(entry.id))
-    .map((entry) => prepareBaseSeriesForStudies(entry, bounds));
+    .map((entry) => prepareBaseSeriesForStudies(entry, bounds, false, requestVisibleBounds));
   const calculationSeries = rawSeries.map((entry) => rawCalculationSeries(entry, studyBounds));
   let resolved = baseSeries;
 
@@ -721,7 +792,13 @@ export async function resolveChartSpecData(
     const studyResult = resolveStudies(calculationSeries, spec.studies);
     resolved = [
       ...resolved,
-      ...applyStudyPresentationTransforms(studyResult.series, spec.studies, rawSeries, bounds),
+      ...applyStudyPresentationTransforms(
+        studyResult.series,
+        spec.studies,
+        rawSeries,
+        bounds,
+        requestVisibleBounds,
+      ),
     ];
     warnings.push(...studyResult.warnings);
     errors.push(...studyResult.errors);
@@ -742,7 +819,7 @@ export async function resolveChartSpecData(
   const resolvedById = new Map(resolved.map((entry) => [entry.id, entry] as const));
   const hiddenBaseSeries = rawSeries
     .filter((entry) => !visibleSeriesIds.has(entry.id))
-    .map((entry) => prepareBaseSeriesForStudies(entry, bounds, true));
+    .map((entry) => prepareBaseSeriesForStudies(entry, bounds, true, requestVisibleBounds));
   const hiddenBaseById = new Map(hiddenBaseSeries.map((entry) => [entry.id, entry] as const));
   const legendSeries = [
     ...spec.series.flatMap((seriesSpec) => {
@@ -775,6 +852,7 @@ export async function resolveChartSpecData(
     series: resolved,
     legendSeries,
     ...(spec.viewport.maxPoints === undefined ? { bufferedSeries } : {}),
+    ...(marketTimelineSeries.length > 0 ? { timelineSeries: marketTimelineSeries } : {}),
     loading: false,
     errors,
     warnings: [...new Set([...priorityWarnings, ...warnings])],

package/src/time-series/spec-studies.test.ts

@@ -281,6 +281,21 @@ describe("study resolution", () => {
     expect(maxStudyWarmupPoints(specs)).toBe(33);
   });
 
+  test("omits empty-volume noise while preserving analytical history warnings", () => {
+    const input = resolved("a");
+    input.points = input.points.map(({ volume: _volume, ...point }) => point);
+
+    const result = resolveStudies([input], [
+      study("volume", "volume", ["a"]),
+      study("sma", "sma", ["a"], { period: 100 }),
+    ]);
+
+    expect(result.series.find(({ id }) => id === "volume")?.points).toEqual([]);
+    expect(result.warnings).toEqual([
+      "sma: not enough valid history to calculate sma.",
+    ]);
+  });
+
   test("aligns pair formulas to the latest available value even when display interpolation is off", () => {
     const point = (date: string, value: number): TimeSeriesPoint => {
       const availableAt = new Date(`${date}T00:00:00Z`);

package/src/time-series/spec.ts

@@ -1,5 +1,5 @@
-import type { ChartResolution, TimeRange } from "../components/chart/core/types";
-import { getChartResolutionLabel } from "../components/chart/core/resolution";
+import type { ChartResolution, TimeRange } from "./range";
+import { getChartResolutionLabel } from "./resolution";
 import {
   canonicalTimeSeriesFieldId,
   getTimeSeriesField,

package/src/time-series/studies.ts

@@ -156,7 +156,7 @@ function studyPeriod(spec: ChartStudySpec, fallback: number): number {
   return positiveInteger(spec.parameters.period, fallback);
 }
 
-export function studyWarmupPoints(spec: ChartStudySpec): number {
+function studyWarmupPoints(spec: ChartStudySpec): number {
   if (spec.kind === "sma" || spec.kind === "ema" || spec.kind === "bollinger") {
     return studyPeriod(spec, 20) - 1;
   }
@@ -554,7 +554,10 @@ export function resolveStudies(
       }
       outputs = resolvePairStudy(spec, input, pairedInput, color);
     }
-    if (outputs.length === 0 || outputs.every((output) => output.points.length === 0)) {
+    if (
+      spec.kind !== "volume"
+      && (outputs.length === 0 || outputs.every((output) => output.points.length === 0))
+    ) {
       warnings.push(`${spec.id}: not enough valid history to calculate ${spec.kind}.`);
     }
     resolved.push(...outputs);

package/src/time-series/types.ts

@@ -1,4 +1,4 @@
-import type { ChartResolution, TimeRange } from "../components/chart/core/types";
+import type { ChartResolution, TimeRange } from "./range";
 import type { InstrumentRef } from "../market-data/request-types";
 
 export const CHART_SPEC_VERSION = 1 as const;
@@ -154,6 +154,8 @@ export interface ChartResolutionResult {
   legendSeries?: ResolvedSeries[];
   /** Loaded observations retained outside the visible window for interactive navigation. */
   bufferedSeries?: ResolvedSeries[];
+  /** Hidden market data retained as a deterministic session-time anchor. */
+  timelineSeries?: ResolvedSeries[];
   loading: boolean;
   errors: string[];
   warnings: string[];

package/src/time-series/use-chart-resolution.test.tsx

@@ -0,0 +1,358 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act, useState } from "react";
+import { testRender } from "../renderers/opentui/test-utils";
+import { createTestDataProvider } from "../test-support/data-provider";
+import type { DataProvider } from "../types/data-provider";
+import type { PricePoint, TickerFinancials } from "../types/financials";
+import type { ChartResolveSources } from "./resolve";
+import { CHART_SPEC_VERSION, type ChartSpec } from "./types";
+import {
+  useChartResolution,
+  type UseChartResolutionResult,
+} from "./use-chart-resolution";
+
+type AutoViewport = NonNullable<Parameters<typeof useChartResolution>[2]["autoViewport"]>;
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+let setAutoViewport: ((viewport: AutoViewport | null) => void) | null = null;
+let setRequestViewport: ((viewport: AutoViewport | null) => void) | null = null;
+let latestResult: UseChartResolutionResult | null = null;
+
+const EMPTY_FINANCIALS: TickerFinancials = {
+  annualStatements: [],
+  quarterlyStatements: [],
+  priceHistory: [],
+};
+
+const INITIAL_HISTORY: PricePoint[] = [
+  {
+    date: new Date("2025-01-02T16:00:00.000Z"),
+    open: 100,
+    high: 103,
+    low: 99,
+    close: 102,
+    volume: 1_000,
+  },
+  {
+    date: new Date("2025-01-03T16:00:00.000Z"),
+    open: 102,
+    high: 105,
+    low: 101,
+    close: 104,
+    volume: 1_200,
+  },
+];
+
+const SPEC: ChartSpec = {
+  version: CHART_SPEC_VERSION,
+  viewport: { range: "1Y", resolution: "auto" },
+  panels: [{ id: "main" }],
+  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: [],
+};
+
+function deferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+function sourcesFor(dataProvider: DataProvider): ChartResolveSources {
+  return {
+    dataProvider,
+    now: new Date("2025-01-10T00:00:00.000Z"),
+    loadFredSeries: async () => {
+      throw new Error("FRED is unused in this test.");
+    },
+  };
+}
+
+function ResolutionHarness({
+  sources,
+}: {
+  sources: ChartResolveSources;
+}) {
+  const [autoViewport, setAutoViewportState] = useState<AutoViewport | null>(null);
+  const [requestViewport, setRequestViewportState] = useState<AutoViewport | null>(null);
+  setAutoViewport = setAutoViewportState;
+  setRequestViewport = setRequestViewportState;
+  latestResult = useChartResolution(SPEC, sources, {
+    autoViewport,
+    requestViewport,
+    targetPointCount: 100,
+    liveRefreshIntervalMs: 0,
+  });
+  const pointCount = (latestResult.bufferedSeries ?? latestResult.series)
+    .reduce((total, series) => total + series.points.length, 0);
+  return <text>{`${latestResult.loading ? "loading" : "settled"}:${pointCount}`}</text>;
+}
+
+async function flushEffects(iterations = 1): Promise<void> {
+  for (let iteration = 0; iteration < iterations; iteration += 1) {
+    await act(async () => {
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+  }
+}
+
+async function waitFor(predicate: () => boolean): Promise<void> {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    await flushEffects();
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 1));
+  }
+  throw new Error("Timed out waiting for chart resolution.");
+}
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+  setAutoViewport = null;
+  setRequestViewport = null;
+  latestResult = null;
+});
+
+describe("useChartResolution", () => {
+  test("keeps renderable data settled through empty adaptive and live refreshes", async () => {
+    const adaptiveHistory = deferred<PricePoint[]>();
+    let detailedCalls = 0;
+    let quoteHandler: Parameters<NonNullable<DataProvider["subscribeQuotes"]>>[1] | null = null;
+    let quoteTarget: Parameters<NonNullable<DataProvider["subscribeQuotes"]>>[0][number] | null = null;
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => EMPTY_FINANCIALS,
+      getChartResolutionSupport: () => [
+        { resolution: "15m", maxRange: "1M" },
+        { resolution: "1d", maxRange: "ALL" },
+      ],
+      getPriceHistoryForResolution: async (_symbol, _exchange, _range, resolution) => (
+        resolution === "1d" ? INITIAL_HISTORY : []
+      ),
+      getDetailedPriceHistory: async () => {
+        detailedCalls += 1;
+        return adaptiveHistory.promise;
+      },
+      getPriceHistory: async () => [],
+      subscribeQuotes: (targets, onQuote) => {
+        quoteTarget = targets[0] ?? null;
+        quoteHandler = onQuote;
+        return () => {};
+      },
+    });
+    const sources = sourcesFor(provider);
+    testSetup = await testRender(<ResolutionHarness sources={sources} />, {
+      width: 24,
+      height: 1,
+    });
+
+    await waitFor(() => latestResult?.loading === false && latestResult.series[0]?.points.length === 2);
+    const lastGoodSeries = latestResult!.series;
+    const lastGoodBufferedSeries = latestResult!.bufferedSeries;
+
+    await act(async () => {
+      setAutoViewport?.({
+        start: new Date("2025-01-02T00:00:00.000Z"),
+        end: new Date("2025-01-04T00:00:00.000Z"),
+      });
+      await testSetup!.renderOnce();
+    });
+    await waitFor(() => detailedCalls === 1);
+
+    expect(latestResult?.loading).toBe(false);
+    expect(latestResult?.series).toBe(lastGoodSeries);
+    expect(latestResult?.bufferedSeries).toBe(lastGoodBufferedSeries);
+
+    adaptiveHistory.resolve([]);
+    await flushEffects(3);
+
+    expect(latestResult?.loading).toBe(false);
+    expect(latestResult?.series).toBe(lastGoodSeries);
+    expect(latestResult?.bufferedSeries).toBe(lastGoodBufferedSeries);
+    expect(latestResult?.errors).toEqual([]);
+
+    await act(async () => {
+      quoteHandler!(quoteTarget!, {
+        symbol: "TEST",
+        price: 105,
+        currency: "USD",
+        change: 1,
+        changePercent: 0.96,
+        lastUpdated: Date.parse("2025-01-03T20:00:00.000Z"),
+      });
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await testSetup!.renderOnce();
+    });
+    await flushEffects(3);
+
+    expect(latestResult?.loading).toBe(false);
+    expect(latestResult?.series).toBe(lastGoodSeries);
+    expect(latestResult?.bufferedSeries).toBe(lastGoodBufferedSeries);
+    expect(latestResult?.errors).toEqual([]);
+  });
+
+  test("keeps renderable data through an empty panned-history live refresh", async () => {
+    let detailedCalls = 0;
+    let fixedHistoryCalls = 0;
+    let quoteHandler: Parameters<NonNullable<DataProvider["subscribeQuotes"]>>[1] | null = null;
+    let quoteTarget: Parameters<NonNullable<DataProvider["subscribeQuotes"]>>[0][number] | null = null;
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => EMPTY_FINANCIALS,
+      getPriceHistoryForResolution: async () => {
+        fixedHistoryCalls += 1;
+        return fixedHistoryCalls === 1 ? INITIAL_HISTORY : [];
+      },
+      getDetailedPriceHistory: async () => {
+        detailedCalls += 1;
+        return [];
+      },
+      getPriceHistory: async () => [],
+      subscribeQuotes: (targets, onQuote) => {
+        quoteTarget = targets[0] ?? null;
+        quoteHandler = onQuote;
+        return () => {};
+      },
+    });
+    const sources = sourcesFor(provider);
+    testSetup = await testRender(<ResolutionHarness sources={sources} />, {
+      width: 24,
+      height: 1,
+    });
+
+    await waitFor(() => latestResult?.loading === false && latestResult.series[0]?.points.length === 2);
+    const lastGoodSeries = latestResult!.series;
+    const lastGoodBufferedSeries = latestResult!.bufferedSeries;
+
+    await act(async () => {
+      setRequestViewport?.({
+        start: new Date("2024-12-20T00:00:00.000Z"),
+        end: new Date("2024-12-27T00:00:00.000Z"),
+      });
+      await testSetup!.renderOnce();
+    });
+    await waitFor(() => detailedCalls === 1);
+    await flushEffects(3);
+
+    expect(latestResult?.series).toBe(lastGoodSeries);
+    expect(latestResult?.bufferedSeries).toBe(lastGoodBufferedSeries);
+
+    await act(async () => {
+      quoteHandler!(quoteTarget!, {
+        symbol: "TEST",
+        price: 105,
+        currency: "USD",
+        change: 1,
+        changePercent: 0.96,
+        lastUpdated: Date.parse("2025-01-03T20:00:00.000Z"),
+      });
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      await testSetup!.renderOnce();
+    });
+    await flushEffects(3);
+
+    expect(latestResult?.loading).toBe(false);
+    expect(latestResult?.series).toBe(lastGoodSeries);
+    expect(latestResult?.bufferedSeries).toBe(lastGoodBufferedSeries);
+    expect(latestResult?.errors).toEqual([]);
+  });
+
+  test("keeps renderable data when an adaptive viewport request rejects", async () => {
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => EMPTY_FINANCIALS,
+      getPriceHistoryForResolution: async () => INITIAL_HISTORY,
+    });
+    const sources = sourcesFor(provider);
+    testSetup = await testRender(<ResolutionHarness sources={sources} />, {
+      width: 24,
+      height: 1,
+    });
+
+    await waitFor(() => latestResult?.loading === false && latestResult.series[0]?.points.length === 2);
+    const lastGoodSeries = latestResult!.series;
+    const lastGoodBufferedSeries = latestResult!.bufferedSeries;
+    provider.getChartResolutionSupport = () => {
+      throw new Error("adaptive history failed");
+    };
+
+    await act(async () => {
+      setAutoViewport?.({
+        start: new Date("2025-01-02T00:00:00.000Z"),
+        end: new Date("2025-01-04T00:00:00.000Z"),
+      });
+      await testSetup!.renderOnce();
+    });
+    await flushEffects(3);
+
+    expect(latestResult?.loading).toBe(false);
+    expect(latestResult?.series).toBe(lastGoodSeries);
+    expect(latestResult?.bufferedSeries).toBe(lastGoodBufferedSeries);
+    expect(latestResult?.errors).toEqual([]);
+  });
+
+  test("keeps initial and explicit reloads blocking", async () => {
+    const initialHistory = deferred<PricePoint[]>();
+    const reloadHistory = deferred<PricePoint[]>();
+    let historyCalls = 0;
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => EMPTY_FINANCIALS,
+      getPriceHistoryForResolution: async () => {
+        historyCalls += 1;
+        return historyCalls === 1 ? initialHistory.promise : reloadHistory.promise;
+      },
+      getPriceHistory: async () => [],
+    });
+    const sources = sourcesFor(provider);
+    testSetup = await testRender(<ResolutionHarness sources={sources} />, {
+      width: 24,
+      height: 1,
+    });
+
+    await waitFor(() => historyCalls === 1);
+    expect(latestResult?.loading).toBe(true);
+    expect(latestResult?.series).toEqual([]);
+
+    await act(async () => {
+      initialHistory.resolve(INITIAL_HISTORY);
+      await testSetup!.renderOnce();
+    });
+    await waitFor(() => latestResult?.loading === false && latestResult.series[0]?.points.length === 2);
+    await act(async () => {
+      latestResult!.reload();
+      await testSetup!.renderOnce();
+    });
+    await waitFor(() => historyCalls === 2);
+
+    expect(latestResult?.loading).toBe(true);
+
+    await act(async () => {
+      reloadHistory.resolve([]);
+      await testSetup!.renderOnce();
+    });
+    await waitFor(() => (
+      latestResult?.loading === false
+      && latestResult.series.every((series) => series.points.length === 0)
+    ));
+
+    expect(latestResult?.series.every((series) => series.points.length === 0)).toBe(true);
+    expect(latestResult?.errors).toEqual([]);
+  });
+});