gloomberb 0.10.3 → 0.10.4

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

@@ -105,12 +105,64 @@ describe("resolveChartSpecData", () => {
     });
 
     expect(genericHistoryCalls).toBe(0);
-    expect(result.series).toEqual([]);
+    // The series keeps its legend slot with no observations so the chart and the
+    // series editor agree on what the user added.
+    expect(result.series.map((entry) => [entry.id, entry.points.length])).toEqual([["price", 0]]);
     expect(result.errors).toEqual([
       "price: Requested 5m price history is unavailable for TEST. Choose Auto or a supported interval.",
     ]);
   });
 
+  test("falls back from an unsupported manual interval while exposing source capabilities", async () => {
+    const requestedResolutions: string[] = [];
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: () => [
+        { resolution: "15m", maxRange: "1M" },
+        { resolution: "1h", maxRange: "3M" },
+      ],
+      getPriceHistoryForResolution: async (_symbol, _exchange, _range, resolution) => {
+        requestedResolutions.push(resolution);
+        return [{ date: new Date("2026-07-30T15:00:00Z"), close: 100 }];
+      },
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "1M", resolution: "45m" },
+      panels: [{ id: "main" }],
+      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: [],
+    };
+
+    const result = await resolveChartSpecData(spec, {
+      dataProvider: provider,
+      now: new Date("2026-07-30T16:00:00Z"),
+      loadFredSeries: async () => fredLoad(),
+    });
+
+    expect(requestedResolutions).toEqual(["15m"]);
+    expect(result.errors).toEqual([]);
+    expect(result.warnings).toContain(
+      "45M data is unavailable for this range. Auto resolution was used instead.",
+    );
+    expect(result.resolutionSupport).toEqual([
+      { resolution: "15m", maxRange: "1M" },
+      { resolution: "1h", maxRange: "3M" },
+    ]);
+  });
+
   test("keeps the snapshot exchange when a newer quote omits it", async () => {
     const historyExchanges: string[] = [];
     const source = {
@@ -179,6 +231,11 @@ describe("resolveChartSpecData", () => {
     expect(historyExchanges).toEqual(["XNAS"]);
     expect(result.series[0]?.points.at(-1)?.date.toISOString())
       .toBe("2026-07-30T15:26:00.000Z");
+    expect(result.series[0]?.timeBasis).toMatchObject({
+      kind: "market",
+      timeZone: "America/New_York",
+      cadenceMs: 5 * 60_000,
+    });
   });
 
   test("resolves the exchange before selecting an adaptive Auto resolution", async () => {
@@ -401,6 +458,87 @@ describe("resolveChartSpecData", () => {
     });
   });
 
+  test("accumulates historical windows without replacing the current tail", async () => {
+    const detailedRequests: Array<{ start: string; end: string }> = [];
+    const currentHistory = [
+      { date: "2026-01-02T16:00:00.000Z" as unknown as Date, close: 110 },
+      { date: new Date("2026-07-30T16:00:00.000Z"), close: 120 },
+    ];
+    const historicalHistory = [
+      { date: new Date("2024-08-01T16:00:00.000Z"), close: 90 },
+      { date: new Date("2025-07-29T16:00:00.000Z"), close: 100 },
+    ];
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => emptyFinancials(),
+      getChartResolutionSupport: () => [
+        { resolution: "1h", maxRange: "1Y" },
+        { resolution: "1d", maxRange: "ALL" },
+      ],
+      getPriceHistoryForResolution: async () => currentHistory,
+      getDetailedPriceHistory: async (_symbol, _exchange, start, end) => {
+        detailedRequests.push({
+          start: start.toISOString(),
+          end: end.toISOString(),
+        });
+        return historicalHistory;
+      },
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "1Y", resolution: "1h" },
+      panels: [{ id: "main" }],
+      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: [],
+    };
+    const sources = {
+      dataProvider: provider,
+      now: new Date("2026-07-30T16:00:00.000Z"),
+      loadFredSeries: async () => fredLoad(),
+    };
+    const cache = new ChartResolveCache();
+
+    const current = await resolveChartSpecData(spec, sources, cache);
+    const historical = await resolveChartSpecData(spec, sources, cache, {
+      requestViewport: {
+        start: new Date("2024-07-30T16:00:00.000Z"),
+        end: new Date("2025-07-30T16:00:00.000Z"),
+      },
+    });
+    const revisitedCurrent = await resolveChartSpecData(spec, sources, cache);
+    const bufferedDates = (result: typeof current) => (
+      result.bufferedSeries?.[0]?.points.map((point) => point.date.toISOString())
+    );
+
+    expect(detailedRequests).toEqual([{
+      start: "2024-07-30T16:00:00.000Z",
+      end: "2025-07-30T16:00:00.001Z",
+    }]);
+    expect(current.resolutionSupport).toEqual([
+      { resolution: "1h", maxRange: "1Y" },
+      { resolution: "1d", maxRange: "ALL" },
+    ]);
+    expect(bufferedDates(historical)).toEqual([
+      "2024-08-01T16:00:00.000Z",
+      "2025-07-29T16:00:00.000Z",
+      "2026-01-02T16:00:00.000Z",
+      "2026-07-30T16:00:00.000Z",
+    ]);
+    expect(bufferedDates(revisitedCurrent)).toEqual(bufferedDates(historical));
+    expect(revisitedCurrent.bufferedSeries?.[0]?.points.at(-1)?.value).toBe(120);
+  });
+
   test("keeps percent transforms and studies defined in a panned history window", async () => {
     const provider = createTestDataProvider({
       getTickerFinancials: async () => emptyFinancials(),
@@ -1029,6 +1167,74 @@ describe("resolveChartSpecData", () => {
     expect(sma.points.at(-1)?.value).toBeCloseTo(15.5);
   });
 
+  test("keeps a quote received after resolution starts inside the latest viewport", async () => {
+    const now = Date.parse("2026-08-05T14:00:00Z");
+    const quoteTime = now + 60_000;
+    const provider = createTestDataProvider({
+      getTickerFinancials: async () => ({
+        ...emptyFinancials(),
+        quote: {
+          symbol: "FRESH",
+          price: 130,
+          currency: "USD",
+          change: 30,
+          changePercent: 30,
+          lastUpdated: quoteTime,
+          listingExchangeName: "XNAS",
+          marketState: "POST",
+          postMarketPrice: 129,
+          postMarketChange: -1,
+          postMarketChangePercent: -0.77,
+        },
+      }),
+      getPriceHistoryForResolution: async () => [
+        { date: new Date(now - 2 * 86_400_000), open: 99, high: 102, low: 98, close: 100 },
+        { date: new Date(now - 86_400_000), open: 100, high: 101, low: 99, close: 100 },
+      ],
+    });
+    const spec: ChartSpec = {
+      version: CHART_SPEC_VERSION,
+      viewport: { range: "6M", resolution: "1d" },
+      panels: [{ id: "main" }],
+      series: [{
+        id: "price",
+        source: {
+          kind: "security",
+          instrument: { symbol: "FRESH", exchange: "XNAS" },
+          fieldId: "market.ohlcv",
+        },
+        style: "candles",
+        transform: "raw",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+      }],
+      studies: [{
+        id: "sma",
+        kind: "sma",
+        inputSeriesIds: ["price"],
+        parameters: { period: 2 },
+        panelId: "main",
+        axis: "left",
+      }],
+    };
+
+    const result = await resolveChartSpecData(spec, {
+      dataProvider: provider,
+      now: new Date(now),
+      loadFredSeries: async () => fredLoad(),
+    });
+
+    expect(result.errors).toEqual([]);
+    expect(result.viewport?.end.getTime()).toBe(quoteTime);
+    const price = result.series.find((entry) => entry.id === "price");
+    const sma = result.series.find((entry) => entry.id === "sma");
+    expect(price?.points.at(-1)?.date.getTime()).toBe(quoteTime);
+    expect(price?.points.at(-1)?.close).toBe(129);
+    expect(price?.latestChangePercent).toBe(30);
+    expect(sma?.points.at(-1)?.date.getTime()).toBe(quoteTime);
+  });
+
   test("reuses raw source loads while live quotes recompute the chart tail", async () => {
     const now = Date.parse("2026-05-15T20:30:00Z");
     const source = {

package/src/time-series/resolve.ts

@@ -1,6 +1,7 @@
 import { appendLiveQuotePoint } from "./chart-data";
 import {
   getTimeRangeForDateWindow,
+  isDateWindowWithinTimeRange,
   subtractTimeRange,
 } from "./date-window";
 import {
@@ -45,6 +46,7 @@ import {
   publicTickerKey,
   resolveExchangeTimeZone,
 } from "../utils/exchanges";
+import { getPricePointTimestamp } from "../utils/price-history";
 import type {
   ChartResolutionResult,
   ChartSeriesSpec,
@@ -87,6 +89,7 @@ export interface ChartResolveOptions {
 export class ChartResolveCache {
   readonly financialsByInstrument = new Map<string, Promise<TickerFinancials | null>>();
   readonly priceHistoryByRequest = new Map<string, Promise<TickerFinancials["priceHistory"]>>();
+  readonly accumulatedPriceHistory = new Map<string, TickerFinancials["priceHistory"]>();
   readonly resolutionSupportByInstrument = new Map<string, Promise<ChartResolutionSupport[]>>();
   readonly fredSeriesByRequest = new Map<string, Promise<FredSeriesLoadResult>>();
 }
@@ -99,6 +102,7 @@ interface DateBounds {
 
 interface PriceHistoryRequest {
   bounds: DateBounds;
+  visibleBounds: DateBounds;
   explicitWindow: boolean;
   fallbackRange: TimeRange;
   resolution: ManualChartResolution;
@@ -124,6 +128,32 @@ function instrumentLabel(spec: Extract<ChartSeriesSpec["source"], { kind: "secur
   return publicTickerKey(spec.instrument.symbol, spec.instrument.exchange);
 }
 
+// A series that fails to load keeps its place with no observations. Dropping it
+// made a series the user had added disappear from the legend while it still sat
+// in the series editor, with nothing on screen to explain the difference.
+function unloadableSeries(spec: ChartSeriesSpec, index: number, warning: string): ResolvedSeries {
+  const field = spec.source.kind === "security" ? getTimeSeriesField(spec.source.fieldId) : undefined;
+  const label = spec.source.kind === "economic"
+    ? `FRED ${spec.source.seriesId}`
+    : `${instrumentLabel(spec.source)} ${field?.shortLabel ?? spec.source.fieldId.split(".").at(-1) ?? "Series"}`;
+  return {
+    id: spec.id,
+    label: spec.label?.trim() || label,
+    color: spec.color ?? SERIES_COLORS[index % SERIES_COLORS.length]!,
+    unit: field?.unit ?? "",
+    unitGroup: field?.unitGroup ?? "unknown",
+    nativeFrequency: field?.nativeFrequency ?? "daily",
+    dataShape: field?.dataShape ?? "scalar",
+    style: spec.style,
+    transform: spec.transform,
+    axis: spec.axis === "right" ? "right" : "left",
+    panelId: spec.panelId,
+    interpolation: spec.interpolation,
+    warning,
+    points: [],
+  };
+}
+
 function withQuoteExchange(
   source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
   ...quotes: Array<Quote | undefined>
@@ -221,7 +251,21 @@ function requestResolution(
   options: ChartResolveOptions,
   sharedSupport: readonly ChartResolutionSupport[],
 ): ManualChartResolution {
-  if (spec.viewport.resolution !== "auto") return spec.viewport.resolution;
+  if (spec.viewport.resolution !== "auto") {
+    const maxRange = getSupportMaxRange(sharedSupport, spec.viewport.resolution);
+    const supported = sharedSupport.length === 0
+      || (
+        maxRange !== null
+        && bounds.start !== null
+        && bounds.end !== null
+        && isDateWindowWithinTimeRange(
+          new Date(bounds.start),
+          new Date(bounds.end),
+          maxRange,
+        )
+      );
+    if (supported) return spec.viewport.resolution;
+  }
   const runtimeBounds = runtimeAutoBounds(options);
   const adaptive = runtimeBounds && runtimeBounds.start !== null && runtimeBounds.end !== null
     ? getBestSupportedResolutionForVisibleWindow(
@@ -280,10 +324,73 @@ function filterPoints(points: readonly TimeSeriesPoint[], bounds: DateBounds): T
   });
 }
 
+function followLatestMarketObservation(
+  bounds: DateBounds,
+  series: readonly ResolvedSeries[],
+): DateBounds {
+  if (bounds.end === null) return bounds;
+  let latest = bounds.end;
+  for (const entry of series) {
+    if (entry.timeBasis?.kind !== "market") continue;
+    for (const point of entry.points) {
+      const timestamp = point.date.getTime();
+      if (Number.isFinite(timestamp) && timestamp > latest) latest = timestamp;
+    }
+  }
+  if (latest === bounds.end) return bounds;
+  const shift = latest - bounds.end;
+  return {
+    start: bounds.start === null ? null : bounds.start + shift,
+    end: latest,
+  };
+}
+
 function emptyFinancials(priceHistory: TickerFinancials["priceHistory"] = []): TickerFinancials {
   return { annualStatements: [], quarterlyStatements: [], priceHistory };
 }
 
+function mergePriceHistoryWindows(
+  current: TickerFinancials["priceHistory"],
+  incoming: TickerFinancials["priceHistory"],
+): TickerFinancials["priceHistory"] {
+  const byTimestamp = new Map<number, TickerFinancials["priceHistory"][number]>();
+  for (const point of [...current, ...incoming]) {
+    const timestamp = getPricePointTimestamp(point);
+    if (Number.isFinite(timestamp)) {
+      byTimestamp.set(
+        timestamp,
+        point.date instanceof Date ? point : { ...point, date: new Date(timestamp) },
+      );
+    }
+  }
+  return [...byTimestamp.values()].sort(
+    (left, right) => getPricePointTimestamp(left) - getPricePointTimestamp(right),
+  );
+}
+
+function historyIntersectsBounds(
+  history: TickerFinancials["priceHistory"],
+  bounds: DateBounds,
+): boolean {
+  if (history.length === 0) return false;
+  if (bounds.start === null || bounds.end === null) return true;
+  return history.some((point) => {
+    const timestamp = getPricePointTimestamp(point);
+    return Number.isFinite(timestamp) && timestamp >= bounds.start! && timestamp <= bounds.end!;
+  });
+}
+
+function clampHistoryBoundsToSupport(
+  bounds: DateBounds,
+  maxRange: TimeRange | null,
+): DateBounds {
+  if (bounds.start === null || bounds.end === null || !maxRange || maxRange === "ALL") {
+    return bounds;
+  }
+  const supportedStart = subtractTimeRange(new Date(bounds.end), maxRange).getTime();
+  return { start: Math.max(bounds.start, supportedStart), end: bounds.end };
+}
+
 function latestQuote(snapshot: Quote | undefined, override: Quote | undefined): Quote | undefined {
   if (!snapshot) return override;
   if (!override) return snapshot;
@@ -326,7 +433,7 @@ async function loadPriceHistory(
         request.resolution,
         context,
       );
-      if (detailed.length > 0) return detailed;
+      if (historyIntersectsBounds(detailed, request.visibleBounds)) return detailed;
     } catch {
       // Fall through to trailing history when a provider cannot serve the exact window.
     }
@@ -340,7 +447,12 @@ async function loadPriceHistory(
         request.resolution,
         context,
       );
-      if (resolved.length > 0) return resolved;
+      if (
+        resolved.length > 0
+        && (!request.explicitWindow || historyIntersectsBounds(resolved, request.visibleBounds))
+      ) {
+        return resolved;
+      }
     } catch {
       // Some providers expose the resolution API but only support a subset.
     }
@@ -352,12 +464,20 @@ async function loadPriceHistory(
       `Requested ${request.resolution} price history is unavailable for ${instrumentLabel(source)}. Choose Auto or a supported interval.`,
     );
   }
-  return provider.getPriceHistory(
+  const fallback = await provider.getPriceHistory(
     source.instrument.symbol,
     source.instrument.exchange ?? "",
     request.fallbackRange,
     context,
   );
+  if (
+    request.explicitWindow
+    && fallback.length > 0
+    && !historyIntersectsBounds(fallback, request.visibleBounds)
+  ) {
+    throw new Error(`Price history for the requested window is unavailable for ${instrumentLabel(source)}.`);
+  }
+  return fallback;
 }
 
 function baseSecuritySeries(
@@ -381,10 +501,14 @@ function baseSecuritySeries(
   const marketExchange = spec.source.instrument.exchange
     || financials.quote?.listingExchangeName
     || financials.quote?.exchangeName;
-  const marketTimeZone = isMarketFieldId(spec.source.fieldId)
+  const marketField = isMarketFieldId(spec.source.fieldId);
+  const marketTimeZone = marketField
     && canonicalExchange(marketExchange) !== "CCC"
     ? resolveExchangeTimeZone(marketExchange)
     : null;
+  const latestChangePercent = marketField && field.unit.startsWith("currency")
+    ? financials.quote?.changePercent
+    : undefined;
   return {
     id: spec.id,
     label: spec.label?.trim() || `${symbol} ${field.shortLabel}`,
@@ -410,6 +534,9 @@ function baseSecuritySeries(
             : undefined,
         }
       : undefined,
+    latestChangePercent: typeof latestChangePercent === "number" && Number.isFinite(latestChangePercent)
+      ? latestChangePercent
+      : undefined,
     points,
   };
 }
@@ -640,14 +767,12 @@ export async function resolveChartSpecData(
       ? [[instrumentKey(entry.source), entry.source] as const]
       : []
   ))).values()];
-  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
+  const resolutionSupportSources = await Promise.all(activeMarketSources.map(async (source) => (
+    source.instrument.exchange?.trim()
+      ? source
+      : sourceWithResolvedExchange(source, await loadFinancials(source))
+  )));
+  const sharedSupport = activeMarketSources.length > 0
     ? intersectChartResolutionSupport(await Promise.all(
         resolutionSupportSources.map((source) => loadResolutionSupport(source)),
       ))
@@ -659,6 +784,14 @@ export async function resolveChartSpecData(
     options,
     sharedSupport,
   );
+  if (
+    spec.viewport.resolution !== "auto"
+    && initialResolution !== spec.viewport.resolution
+  ) {
+    warnings.push(
+      `${spec.viewport.resolution.toUpperCase()} data is unavailable for this range. Auto resolution was used instead.`,
+    );
+  }
   const requestVisibleBounds = requestBounds ?? initialVisibleBounds;
   const initialCalculationBounds = calculationBounds(
     spec,
@@ -672,16 +805,18 @@ export async function resolveChartSpecData(
     source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
     all = false,
   ) => {
-    const requestedFallbackRange = all
-      ? "ALL"
-      : trailingRangeForStart(initialCalculationBounds.start, referenceNow);
     const support = await loadResolutionSupport(source);
     const maxRange = getSupportMaxRange(support, initialResolution);
+    const historyBounds = clampHistoryBoundsToSupport(initialCalculationBounds, maxRange);
+    const requestedFallbackRange = all
+      ? "ALL"
+      : trailingRangeForStart(historyBounds.start, referenceNow);
     const fallbackRange = maxRange
       ? clampTimeRangeToMaxRange(requestedFallbackRange, maxRange)
       : requestedFallbackRange;
     const request: PriceHistoryRequest = {
-      bounds: initialCalculationBounds,
+      bounds: historyBounds,
+      visibleBounds: requestVisibleBounds,
       explicitWindow: hasExplicitWindow,
       fallbackRange,
       resolution: initialResolution,
@@ -700,7 +835,24 @@ export async function resolveChartSpecData(
       pending = loadPriceHistory(sources.dataProvider!, source, request);
       cache.priceHistoryByRequest.set(key, pending);
     }
-    return pending;
+    const history = await pending;
+    const accumulationKey = `${instrumentKey(source)}|${request.resolution}`;
+    const previousHistory = cache.accumulatedPriceHistory.get(accumulationKey) ?? [];
+    if (
+      request.explicitWindow
+      && !historyIntersectsBounds(history, request.visibleBounds)
+      && !historyIntersectsBounds(previousHistory, request.visibleBounds)
+    ) {
+      throw new Error(
+        `Price history for the requested window is unavailable for ${instrumentLabel(source)}.`,
+      );
+    }
+    const accumulated = mergePriceHistoryWindows(
+      previousHistory,
+      history,
+    );
+    cache.accumulatedPriceHistory.set(accumulationKey, accumulated);
+    return accumulated;
   };
 
   const loadEconomicSeries = (request: FredSeriesRequest) => {
@@ -739,17 +891,19 @@ export async function resolveChartSpecData(
         ? sources.quoteOverrides?.get(chartQuoteOverrideKeyForSource(source))
         : undefined;
       const financialsPromise = loadFinancials(source);
+      let resolvedSource = 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);
+        resolvedSource = sourceWithResolvedExchange(source, financials);
+        history = await loadHistory(resolvedSource, quoteDerivedValuation);
       } else {
         [financials, history] = await Promise.all([
           financialsPromise,
           needsHistory ? loadHistory(source, quoteDerivedValuation) : Promise.resolve(null),
         ]);
+        resolvedSource = sourceWithResolvedExchange(source, financials);
       }
       const liveBarResolution = isOhlcSeriesStyle(seriesSpec.style) ? initialResolution : undefined;
       const merged = history
@@ -758,15 +912,21 @@ export async function resolveChartSpecData(
           ? { ...financials, quote: latestQuote(financials.quote, quoteOverride) }
           : financials;
       if (!merged) throw new Error(`No financial data is available for ${instrumentLabel(source)}.`);
-      const result = baseSecuritySeries(seriesSpec, merged, index, initialResolution);
+      const result = baseSecuritySeries(
+        resolvedSource === source ? seriesSpec : { ...seriesSpec, source: resolvedSource },
+        merged,
+        index,
+        initialResolution,
+      );
       if (!result) throw new Error(`Unknown field ${source.fieldId}.`);
       if (isFundamentalFieldId(source.fieldId) && fundamentalSeriesUsesAvailabilityFallback(merged, source)) {
         result.warning = "Publication dates are unavailable for some observations; period-end dates are used as a fallback.";
       }
       return result;
     } catch (error) {
-      errors.push(`${seriesSpec.label ?? seriesSpec.id}: ${error instanceof Error ? error.message : String(error)}`);
-      return null;
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`${seriesSpec.label ?? seriesSpec.id}: ${message}`);
+      return unloadableSeries(seriesSpec, index, message);
     }
   }));
 
@@ -774,13 +934,19 @@ export async function resolveChartSpecData(
   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
-  // providers for a different window than the one ultimately rendered.
-  const bounds = initialVisibleBounds;
+  // Preset ranges normally end at the requested reference time. A quote fetched
+  // asynchronously can be timestamped just after that reference, so advance an
+  // untouched market viewport by the same amount instead of clipping its tail.
+  // Explicit and user-created windows stay fixed through hasExplicitWindow.
+  const bounds = hasExplicitWindow
+    ? initialVisibleBounds
+    : followLatestMarketObservation(initialVisibleBounds, rawSeries);
   const resolution = initialResolution;
-  const studyBounds = initialCalculationBounds;
+  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));
@@ -850,6 +1016,7 @@ export async function resolveChartSpecData(
     : undefined;
   return {
     series: resolved,
+    ...(sharedSupport.length > 0 ? { resolutionSupport: sharedSupport } : {}),
     legendSeries,
     ...(spec.viewport.maxPoints === undefined ? { bufferedSeries } : {}),
     ...(marketTimelineSeries.length > 0 ? { timelineSeries: marketTimelineSeries } : {}),

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

@@ -168,6 +168,10 @@ describe("chart spec normalization and validation", () => {
     expect(result.valid).toBe(false);
     expect(result.errors.map(({ code }) => code)).toContain("qoq-annual");
     expect(result.errors.map(({ code }) => code)).toContain("multiple-ohlc");
+    // The blocking series is usually hidden or drawn as a line for lack of OHLC
+    // data, so the message has to name it or it reads as a phantom conflict.
+    expect(result.errors.find(({ code }) => code === "multiple-ohlc")?.message)
+      .toBe("A already uses a candle or OHLC style on main. Give it another style first.");
     expect(result.errors.map(({ code }) => code)).toContain("missing-input");
   });
 

package/src/time-series/spec.ts

@@ -359,6 +359,7 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
 
   const seriesIds = new Set<string>();
   const candleCountByPanel = new Map<string, number>();
+  const firstCandleByPanel = new Map<string, string>();
   const unitGroupsByPanel = new Map<string, Set<string>>();
   const panelScaleById = new Map(spec.panels.map((panel) => [panel.id, panel.scale ?? "linear"] as const));
   spec.series.forEach((entry, index) => {
@@ -435,6 +436,13 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
     if (isOhlcSeriesStyle(entry.style)) {
       const count = (candleCountByPanel.get(entry.panelId) ?? 0) + 1;
       candleCountByPanel.set(entry.panelId, count);
+      if (count === 1) {
+        firstCandleByPanel.set(
+          entry.panelId,
+          entry.label?.trim()
+            || (entry.source.kind === "economic" ? entry.source.seriesId : entry.source.instrument.symbol),
+        );
+      }
       if (entry.transform !== "raw") {
         errors.push(issue(`${path}.transform`, "transformed-ohlc", "OHLC styles require raw values."));
       }
@@ -442,7 +450,13 @@ export function validateChartSpec(spec: ChartSpec): ChartSpecValidationResult {
   });
   for (const [panelId, count] of candleCountByPanel) {
     if (count > 1) {
-      errors.push(issue("series", "multiple-ohlc", `Panel ${panelId} may contain only one candle or OHLC series.`));
+      // Name the series holding the slot: it is often hidden or drawn as a line
+      // for lack of OHLC data, so "this panel already has one" reads as a ghost.
+      const panelLabel = spec.panels.find((panel) => panel.id === panelId)?.label ?? panelId;
+      const holder = firstCandleByPanel.get(panelId);
+      errors.push(issue("series", "multiple-ohlc", holder
+        ? `${holder} already uses a candle or OHLC style on ${panelLabel}. Give it another style first.`
+        : `Panel ${panelLabel} may contain only one candle or OHLC series.`));
     }
   }
   for (const [panelId, groups] of unitGroupsByPanel) {