gloomberb 0.18.2 → 0.18.4

package/src/time-series/resolve.ts

@@ -1,45 +1,32 @@
 import { logFailure } from "../utils/log-failure";
-import { resolveAssetDisplayKind } from "../market-data/market/format";
 import { hasValidQuoteObservationTime } from "../market-data/quotes/freshness";
 import { delistingLabel } from "../market-data/quotes/delisting";
-import { SnapshotHistoryUnavailableError } from "../market-data/snapshot-provider";
 import { financialPeriodCoverage, financialPeriodCoverageWarnings, limitSeriesObservations } from "./financial-period-coverage";
-import { HistoryCoverageError, historyCoverageNotice } from "../sources/history-coverage";
-import { ProviderMissError } from "../sources/provider-errors";
-import { HISTORY_RETENTION_MAX_AGE_MS, canonicalHistoryInterval, historyRetentionNotice, historyStartNotice, isHistoryRetentionError, parseHistoryRecoveryCandidate, type HistoryRecoveryCandidate, type HistoryRetention, type HistoryRetentionError } from "../sources/history-retention";
-import { getRouterEntityKey } from "../sources/provider-router/cache";
-import { publicListingTarget } from "../sources/listing-target";
-import { fetchHistoryResult } from "../sources/history-result";
-import type { HistorySession, PriceHistoryResult } from "../types/price-history";
+import { historyCoverageNotice } from "../sources/history-coverage";
+import { historyRetentionNotice, historyStartNotice } from "../sources/history-retention";
 import type { BrokerContractRef } from "../types/instrument";
 import { FINANCIAL_VINTAGE_NOTICE, SEC_EPS_BASIS_NOTICE } from "../utils/financial-statements";
-import { appendLiveQuotePoint, hasUnknownBondHistoryBasis } from "./chart-data";
-import { LiveBarAccumulator } from "./live-bars";
-import {
-  getTimeRangeForDateWindow,
-  isDateWindowWithinTimeRange,
-  subtractTimeRange,
-} from "./date-window";
+import { subtractTimeRange } from "./date-window";
 import {
   CHART_RESOLUTION_STEP_MS,
+  chartBarSizeSource,
   clampTimeRangeToMaxRange,
   DEFAULT_CHART_RESOLUTION_SUPPORT,
-  getBestSupportedResolutionForVisibleWindow,
-  getNextBufferRange,
-  getSupportedPresetResolution,
   getSupportMaxRange,
   intersectChartResolutionSupport,
+  isCustomChartResolution,
   isIntradayResolution,
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
   type ManualChartResolution,
 } from "./resolution";
+import { aggregatePriceBars, futuresOpenMinuteOf, withBuiltBarSize } from "./bar-aggregation";
 import { TIME_RANGES, type TimeRange } from "./range";
-import type { DataProvider, MarketDataRequestContext } from "../types/data-provider";
-import type { Quote, QuoteMetadata, TickerFinancials } from "../types/financials";
+import type { DataProvider } from "../types/data-provider";
+import type { Quote, TickerFinancials } from "../types/financials";
 import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../market-data/quotes/metadata";
-import type { FredSeriesLoadResult, FredSeriesRequest } from "../sources/gloomberb-cloud/fred-series";
-import { extractFredSeries, fredCreditCoverageNotice } from "./economic";
+import type { FredSeriesRequest } from "../sources/gloomberb-cloud/fred-series";
+import { fredCreditCoverageNotice } from "./economic";
 import {
   getTimeSeriesField,
   isFundamentalFieldId,
@@ -48,52 +35,36 @@ import {
 } from "./field-catalog";
 import {
   fundamentalSeriesUsesAvailabilityFallback,
-  unreportedStatementPeriod,
-  valuationCurrencyWarning,
-  valuationPriceIssues,
   valuationSeriesUsesLiveQuote,
   valuationSeriesUsesPriceHistory,
 } from "./fundamentals";
 import { FORWARD_PE_BASIS_NOTICE, REALIZED_NTM_PE_BASIS_NOTICE } from "./forward-valuation";
 import { valuationPriceWarning } from "./valuation-price";
 import { VALUATION_CURRENCY_WARNING_PREFIX } from "./valuation-currency";
-import { extractSecuritySeries, collectPriceHistoryIntegrity, chartPriceHistoryIntegrityNotices } from "./market";
-import {
-  activeStudyInputSeriesIds,
-  maxStudyWarmupPoints,
-  resolveStudies,
-} from "./studies";
-import { applyResolvedSeriesTransform } from "./transforms";
+import { chartPriceHistoryIntegrityNotices } from "./market";
+import { maxStudyWarmupPoints, resolveStudies } from "./studies";
 import { clipSeriesToWindow } from "./alignment";
-import { bufferPriceComparison, clipPriceComparison, comparedBufferPoints, priceComparisonBoundsForSeries, priceComparisonSeriesIds, priceObservationWindowFilter, resolvePriceComparison, type PriceComparison } from "./price-comparison";
-import { reportingCurrencySeries } from "./reporting-currency";
-import { chartQuoteOverrideKeyForSource, compareChartQuoteRecency } from "./live-quotes";
-import { chartSeriesSourceKey } from "../capabilities/chart-series";
-import { isResolutionFineEnoughForMarketPeriod, resolutionForExplicitMarketPeriods } from "./market-resolution";
-import { marketSeriesFrequency } from "./market";
 import {
-  rememberParsedPriceHistory,
-  parsedPriceHistoryKey,
-  readSeedListingFacts,
-  rememberSeedListingFacts,
-} from "./parsed-history-cache";
+  bufferPriceComparison,
+  clipPriceComparison,
+  priceComparisonBoundsForSeries,
+  priceComparisonSeriesIds,
+  resolvePriceComparison,
+} from "./price-comparison";
+import { chartQuoteOverrideKeyForSource } from "./live-quotes";
+import { chartSeriesSourceKey } from "../capabilities/chart-series";
+import { rememberSeedListingFacts } from "./parsed-history-cache";
 import {
   canonicalExchange,
   isUsListingExchange,
   parsePublicTickerKey,
-  publicTickerKey,
-  resolveExchangeTimeZone,
 } from "../utils/exchanges";
-import { getPricePointTimestamp, isPriceHistoryStaleForCurrentWindow } from "../utils/price-history";
-import { timeZoneLabel, zonedDateKey, zonedWallClockMs } from "../utils/zoned-date-time";
-import { formatShortDate } from "../utils/datetime-format";
-import { latestSessionStart, latestTradingSessionOpen, listingTimeZone, priorSessionClose } from "../market-data/market/trading-sessions";
-import { futuresGenericCaption, futuresGenericListing, futuresListingPriceBasis } from "../utils/futures-generic";
+import { isPriceHistoryStaleForCurrentWindow } from "../utils/price-history";
+import { listingTimeZone } from "../market-data/market/trading-sessions";
+import { futuresGenericListing, futuresListingPriceBasis } from "../utils/futures-generic";
 import { classifyInstrumentType, kindFromListingSyntax } from "../tickers/instrument-kind";
-import { contractPriceUnit } from "./price-units";
-import { INDEX_POINTS_UNIT, isIndexLevel } from "../market-data/market/index-level";
-import { isDatasetChart, isOhlcSeriesStyle } from "./spec";
-import { SERIES_COLORS } from "../theme/series-colors";
+import { isDatasetChart } from "./spec";
+import { seriesMessageName } from "./series-name";
 import type {
   ChartResolutionResult,
   ChartSeriesSpec,
@@ -101,242 +72,67 @@ import type {
   ResolvedSeries,
   TimeSeriesPoint,
 } from "./types";
-
-export interface ChartResolveSources {
-  dataProvider: DataProvider | null;
-  loadFredSeries: (request: FredSeriesRequest) => Promise<FredSeriesLoadResult>;
-  now?: Date;
-  /** Latest streamed quote per security identity, layered over snapshot data. */
-  quoteOverrides?: ReadonlyMap<string, Quote>;
-  /**
-   * Start of the current uninterrupted quote observation. Bars formed from
-   * quotes inside it are continuous with the loaded history.
-   */
-  liveSince?: number;
-  /** Capture the resolved inputs, including the calculation buffer, for an export. */
-  onSecurityData?: (series: ChartSeriesSpec, data: TickerFinancials, includesHistory: boolean) => void;
-  /**
-   * How often, in milliseconds, a plugin-owned series is loaded again while
-   * it is charted; nothing for a series that keeps what it loaded.
-   */
-  capabilityRefreshMs?: (source: Extract<ChartSeriesSpec["source"], { kind: "capability" }>) => number | undefined;
-  /**
-   * What a futures price counts, from its contract terms ("USD / gallon"), so
-   * the chart states it and a formula can tell gallons from barrels. Null where
-   * the terms do not say. Without it a future's price is in its currency alone.
-   */
-  loadFuturesPriceUnit?: (symbol: string) => Promise<string | null>;
-  /** Provider-neutral boundary for plugin-owned chart series. */
-  resolveCapabilitySeries?: (
-    source: Extract<ChartSeriesSpec["source"], { kind: "capability" }>,
-    viewport: ChartSpec["viewport"],
-    spec: ChartSeriesSpec,
-  ) => Promise<ResolvedSeries>;
-}
-
-export interface ChartResolveOptions {
-  /** 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;
-  /** Resolution currently on screen, kept through small Auto zooms. */
-  currentResolution?: ManualChartResolution | null;
-  /**
-   * Price-only charts paint before slow broker support answers and stand in a
-   * placeholder list meanwhile. One-shot loaders wait for the real list.
-   */
-  awaitResolutionSupport?: boolean;
-  /** Fired once the real support list lands after a placeholder was used. */
-  onResolutionSupportSettled?: () => void;
-}
-
-/** A current-window intraday history whose newest bars can be refreshed in place. */
-interface LiveTailRequest {
-  source: Extract<ChartSeriesSpec["source"], { kind: "security" }>;
-  resolution: ManualChartResolution;
-  accumulationKey: string;
-  historySession?: "extended";
-}
-
-/** Recent-window requests for the same history, shared by every chart asking at once. */
-const tailRequestsInFlight = new WeakMap<DataProvider, Map<string, Promise<PriceHistoryResult | null>>>();
-
-/** Raw source data retained while live quotes recompute the chart tail. */
-export class ChartResolveCache {
-  readonly financialsByInstrument = new Map<string, Promise<TickerFinancials | null>>();
-  readonly quoteMetadataByInstrument = new Map<string, Promise<QuoteMetadata | null>>();
-  /** Each futures symbol's contract price unit, asked once per chart once known. */
-  readonly futuresPriceUnits = new Map<string, Promise<string | null>>();
-  readonly priceHistoryByRequest = new Map<string, Promise<LoadedPriceHistory>>();
-  readonly priceHistoryExpiryByRequest = new Map<string, number>();
-  readonly priceHistoryRefreshAfter = new Map<string, number>();
-  readonly accumulatedPriceHistory = new Map<string, LoadedPriceHistory>();
-  readonly resolutionSupportByInstrument = new Map<string, Promise<ChartResolutionSupport[]>>();
-  readonly settledResolutionSupport = new Map<string, ChartResolutionSupport[]>();
-  readonly rejectedResolutionSupport = new Set<string>();
-  readonly fredSeriesByRequest = new Map<string, Promise<FredSeriesLoadResult>>();
-  readonly capabilitySeriesByRequest = new Map<string, Promise<ResolvedSeries>>();
-  /** Forming bars per accumulated history, kept across live re-resolves. */
-  readonly liveBars = new Map<string, LiveBarAccumulator>();
-  /** The loaded history each accumulated history last merged, so an unchanged load is not merged again. */
-  readonly accumulatedFrom = new Map<string, LoadedPriceHistory>();
-  /** Histories plotted by the latest resolve that follow the present. */
-  liveTails: ReadonlyMap<string, LiveTailRequest> = new Map();
-  tailReconcile: Promise<boolean> | null = null;
-  /**
-   * Bumped whenever source data enters the cache. A resolve that ran without a
-   * bump changed at most what the quotes change: the newest points.
-   */
-  revision = 0;
-
-  /** Broker history endpoints are paced per account, so their recent windows are requested less often. */
-  get liveTailsUseBroker(): boolean {
-    for (const tail of this.liveTails.values()) if (requestContext(tail.source).brokerId) return true;
-    return false;
-  }
-
-  liveBarsFor(accumulationKey: string): LiveBarAccumulator {
-    let bars = this.liveBars.get(accumulationKey);
-    if (!bars) {
-      bars = new LiveBarAccumulator();
-      this.liveBars.set(accumulationKey, bars);
-    }
-    return bars;
-  }
-
-  /** True once after a streamed quote met a gap between the loaded history and now. */
-  takeTailReconcileRequest(): boolean {
-    let requested = false;
-    for (const bars of this.liveBars.values()) requested = bars.takeReconcileRequest() || requested;
-    return requested;
-  }
-}
-
-interface DateBounds {
-  start: number | null;
-  /** Inclusive upper bound. */
-  end: number | null;
-}
-
-interface PriceHistoryRequest {
-  bounds: DateBounds;
-  visibleBounds: DateBounds;
-  explicitWindow: boolean;
-  /** Dates the chart was given, not a view the user panned or zoomed to. */
-  authoredWindow: boolean;
-  fallbackRange: TimeRange;
-  resolution: ManualChartResolution;
-  allowProviderDefaultFallback: boolean;
-  support: readonly ChartResolutionSupport[];
-  requiredWarmupPoints: number;
-  historyRequestKey?: string;
-  /** Ask for pre-market and after-hours bars. */
-  historySession?: "extended";
-}
-
-interface LoadedPriceHistory extends PriceHistoryResult {
-  expiresAt?: number;
-  requestKey?: string;
-  accumulationKey?: string | null;
-  /** The first bar the source has at this cadence, once it has said there is nothing older. */
-  historyStart?: number;
-  recovery?: {
-    sourceKey: string;
-    /** First bar requested from the retained window. */
-    start: number;
-    end: number;
-    requiredWarmupPoints: number;
-    usableWarmupPoints: number;
-    /** The validated source evidence the recovery was requested with. */
-    retention: HistoryRetention;
-  };
-}
-
-class PriceHistoryAcquisitionError extends Error {
-  constructor(message: string, readonly retryAt: number) { super(message); }
-}
-
-/** Compatible intervals from different source/session contracts cannot share a capture. */
-export function priceHistoryAcquisitionIdentity(result: Pick<PriceHistoryResult, "session" | "sourceKey">): string {
-  const { observedAt: _observedAt, ...session } = result.session ?? {};
-  return JSON.stringify([result.sourceKey ?? null, result.session ? session : null]);
-}
-
-/** Merged history keeps the actual acquisition clock belonging to its finite tail. */
-export function priceHistoryTailAcquisition<T extends { points: TickerFinancials["priceHistory"] }>(previous: T | undefined, incoming: T): T {
-  const latest = (value: T) => value.points.reduce((last, point) => {
-    const time = getPricePointTimestamp(point);
-    return Number.isFinite(point.close) && Number.isFinite(time) ? Math.max(last, time) : last;
-  }, Number.NEGATIVE_INFINITY);
-  return previous && latest(previous) > latest(incoming) ? previous : incoming;
-}
-
-const DAY_MS = 24 * 60 * 60 * 1_000;
-const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-
-function requestContext(spec: Extract<ChartSeriesSpec["source"], { kind: "security" }>): MarketDataRequestContext {
-  return {
-    brokerId: spec.instrument.instrument?.brokerId ?? spec.instrument.brokerId,
-    brokerInstanceId: spec.instrument.instrument?.brokerInstanceId ?? spec.instrument.brokerInstanceId,
-    instrument: spec.instrument.instrument ?? null,
-  };
-}
-
-function instrumentKey(spec: Extract<ChartSeriesSpec["source"], { kind: "security" }>): string {
-  return chartQuoteOverrideKeyForSource(spec);
-}
-
-function instrumentLabel(spec: Extract<ChartSeriesSpec["source"], { kind: "security" }>): string {
-  return publicTickerKey(spec.instrument.symbol, spec.instrument.exchange);
-}
-
-/**
- * Shown while a current chart draws a saved copy that no refetch brought up
- * to date: the last saved bar on the venue's clock, as the axis reads it.
- */
-function behindHistoryNotice(
-  source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
-  points: TickerFinancials["priceHistory"],
-  now: number,
-): string | null {
-  const latest = points.findLast((point) => Number.isFinite(point.close) && Number.isFinite(getPricePointTimestamp(point)));
-  if (!latest) return null;
-  const zone = listingTimeZone(source.instrument.symbol, source.instrument.exchange) ?? "UTC";
-  const wall = new Date(zonedWallClockMs(getPricePointTimestamp(latest), zone)).toISOString();
-  const sameYear = wall.slice(0, 4) === zonedDateKey(now, zone).slice(0, 4);
-  const day = formatShortDate(wall.slice(0, 10), { utc: true, year: sameYear ? false : "numeric" });
-  return `${instrumentLabel(source)}: newer bars are unavailable; showing saved bars as of ${day} ${wall.slice(11, 16)} ${timeZoneLabel(zone)}.`;
-}
-
-// 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 === "security"
-    ? `${instrumentLabel(spec.source)} ${field?.seriesLabel ?? field?.shortLabel ?? spec.source.fieldId.split(".").at(-1) ?? "Series"}`
-    : spec.source.kind === "economic"
-      ? `FRED ${spec.source.seriesId}`
-      : spec.source.seriesId;
-  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: [],
-  };
-}
+import {
+  type ChartResolveSources,
+  type ChartResolveOptions,
+  type LiveTailRequest,
+  ChartResolveCache,
+  type LoadedPriceHistory,
+  requestContext,
+  instrumentKey,
+  instrumentLabel,
+} from "./resolve-context";
+import {
+  dateOnly,
+  explicitBounds,
+  rangeDurationBounds,
+  requestedBounds,
+  runtimeAutoBounds,
+  runtimeRequestBounds,
+  sameBounds,
+  requestResolution,
+  calculationBounds,
+  barsAhead,
+  trailingRangeForStart,
+  filterPoints,
+  comparisonDisplayBounds,
+  followLatestMarketObservation,
+  capabilityRequestBounds,
+  endAtNewestObservation,
+  latestSessionView,
+} from "./chart-bounds";
+import {
+  type PriceHistoryRequest,
+  PriceHistoryAcquisitionError,
+  priceHistoryAcquisitionIdentity,
+  priceHistoryTailAcquisition,
+  behindHistoryNotice,
+  mergePriceHistoryWindows,
+  historyIntersectsBounds,
+  clampHistoryBoundsToSupport,
+  retainedWarmup,
+  loadPriceHistory,
+} from "./history-acquisition";
+import {
+  unloadableSeries,
+  emptyFinancials,
+  chartCalculationSeriesIds,
+  latestQuote,
+  mergeHistory,
+  baseSecuritySeries,
+  baseEconomicSeries,
+  baseCapabilitySeries,
+  staleFredWarning,
+} from "./base-series";
+import {
+  resolvePriceHistoryIntegrity,
+  assignAxes,
+  adoptPriceUnits,
+  prepareBaseSeriesForStudies,
+  presentationBounds,
+  applyStudyPresentationTransforms,
+  studyAnchors,
+} from "./series-presentation";
 
 function withQuoteExchange(
   source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
@@ -356,433 +152,6 @@ function withQuoteExchange(
   };
 }
 
-function finiteDate(value: string | Date | undefined): Date | null {
-  if (!value) return null;
-  const date = value instanceof Date ? new Date(value) : new Date(value);
-  return Number.isFinite(date.getTime()) ? date : null;
-}
-
-function inclusiveEndDate(value: string | Date | undefined): Date | null {
-  const parsed = finiteDate(value);
-  if (!parsed) return null;
-  return typeof value === "string" && DATE_ONLY_PATTERN.test(value.trim())
-    ? new Date(parsed.getTime() + DAY_MS - 1)
-    : parsed;
-}
-
-function dateOnly(date: Date): string {
-  return date.toISOString().slice(0, 10);
-}
-
-function explicitBounds(spec: ChartSpec): DateBounds | null {
-  const explicitStart = finiteDate(spec.viewport.dateWindow?.start);
-  const explicitEnd = inclusiveEndDate(spec.viewport.dateWindow?.end);
-  if (!explicitStart || !explicitEnd || explicitStart.getTime() > explicitEnd.getTime()) return null;
-  return { start: explicitStart.getTime(), end: explicitEnd.getTime() };
-}
-
-/** Calendar range limits use the authored dates; observation filters include the final day. */
-function rangeDurationBounds(spec: ChartSpec, bounds: DateBounds): DateBounds {
-  const window = spec.viewport.dateWindow;
-  if (!window || !DATE_ONLY_PATTERN.test(window.start) || !DATE_ONLY_PATTERN.test(window.end)
-    || bounds.end !== inclusiveEndDate(window.end)?.getTime()) return bounds;
-  return { ...bounds, end: finiteDate(window.end)!.getTime() };
-}
-
-function requestedBounds(spec: ChartSpec, latestObservation: Date): DateBounds {
-  const explicit = explicitBounds(spec);
-  if (explicit) return explicit;
-  return {
-    start: spec.viewport.range === "ALL"
-      ? null
-      : subtractTimeRange(latestObservation, spec.viewport.range).getTime(),
-    end: latestObservation.getTime(),
-  };
-}
-
-function runtimeAutoBounds(options: ChartResolveOptions): DateBounds | null {
-  const start = options.autoViewport?.start.getTime();
-  const end = options.autoViewport?.end.getTime();
-  return typeof start === "number"
-      && Number.isFinite(start)
-      && typeof end === "number"
-      && Number.isFinite(end)
-      && start <= end
-    ? { start, end }
-    : 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;
-}
-
-function boundsRange(bounds: DateBounds): TimeRange {
-  if (bounds.start === null || bounds.end === null) return "ALL";
-  return getTimeRangeForDateWindow({
-    start: new Date(bounds.start),
-    end: new Date(bounds.end),
-  });
-}
-
-function requestResolution(
-  spec: ChartSpec,
-  bounds: DateBounds,
-  calculationSeriesIds: ReadonlySet<string>,
-  options: ChartResolveOptions,
-  sharedSupport: readonly ChartResolutionSupport[],
-  provisionalSupport = false,
-): ManualChartResolution {
-  const duration = rangeDurationBounds(spec, bounds);
-  if (spec.viewport.resolution === "auto" && spec.studies.some((study) => study.kind === "realized-vol" && study.visible !== false)) {
-    // A 252-session estimator must see daily observations even on a long chart.
-    const maxRange = getSupportMaxRange(sharedSupport, "1d");
-    if (sharedSupport.length === 0 || provisionalSupport || maxRange === "ALL"
-      || (maxRange !== null && duration.start !== null && duration.end !== null
-        && isDateWindowWithinTimeRange(new Date(duration.start), new Date(duration.end), maxRange))) return "1d";
-  }
-  if (spec.viewport.resolution !== "auto") {
-    const maxRange = getSupportMaxRange(sharedSupport, spec.viewport.resolution);
-    // A placeholder list cannot rule out a manual pick; the real list decides
-    // on the next pass.
-    const supported = sharedSupport.length === 0
-      || provisionalSupport
-      || maxRange === "ALL"
-      || (
-        maxRange !== null
-        && duration.start !== null
-        && duration.end !== null
-        && isDateWindowWithinTimeRange(
-          new Date(duration.start),
-          new Date(duration.end),
-          maxRange,
-        )
-      );
-    if (supported) return spec.viewport.resolution;
-  }
-  const runtimeBounds = runtimeAutoBounds(options);
-  const adaptive = runtimeBounds && runtimeBounds.start !== null && runtimeBounds.end !== null
-    ? getBestSupportedResolutionForVisibleWindow(
-        { start: new Date(runtimeBounds.start), end: new Date(runtimeBounds.end) },
-        sharedSupport,
-        options.targetPointCount ?? 120,
-        options.currentResolution,
-      )
-    : null;
-  const preferred = adaptive
-    ?? getSupportedPresetResolution(
-      explicitBounds(spec) ? boundsRange(duration) : spec.viewport.range,
-      provisionalSupport ? [] : sharedSupport,
-      duration.start !== null && duration.end !== null
-        ? { start: new Date(duration.start), end: new Date(duration.end) }
-        : null,
-    );
-  const activeSeries = spec.series.filter((entry) => calculationSeriesIds.has(entry.id));
-  return resolutionForExplicitMarketPeriods(preferred, activeSeries);
-}
-
-function calculationBounds(
-  spec: ChartSpec,
-  visibleBounds: DateBounds,
-  resolution: ManualChartResolution,
-): DateBounds {
-  if (visibleBounds.start === null) return visibleBounds;
-  const warmupPoints = maxStudyWarmupPoints(spec.studies);
-
-  const duration = rangeDurationBounds(spec, visibleBounds);
-  const visibleEnd = duration.end ?? visibleBounds.start;
-  const bufferedRange = getNextBufferRange(boundsRange(duration));
-  let start = bufferedRange === "ALL"
-    ? subtractTimeRange(new Date(visibleEnd), "ALL").getTime()
-    : subtractTimeRange(new Date(visibleEnd), bufferedRange).getTime();
-
-  if (warmupPoints > 0) {
-    // Calendar gaps and closed sessions mean N observations often span more
-    // than N nominal bars. The doubled point window is a bounded safety margin.
-    const pointWarmup = warmupPoints * CHART_RESOLUTION_STEP_MS[resolution] * 2;
-    start = Math.min(start, visibleBounds.start - pointWarmup);
-  }
-  return { start: Math.min(start, visibleBounds.start), end: visibleBounds.end };
-}
-
-/**
- * How far past a view moved into the past its history reaches: half a view,
- * as far as the interval's longest window allows with the view still in it.
- * Those are the bars a pan forward meets first. Without them, a view whose
- * bars were loaded for it alone (a zoom to finer bars, then a pan) ends where
- * they do, and a pan forward stops there with nothing to ask for.
- */
-function barsAhead(view: DateBounds, maxRange: TimeRange | null, now: number): number {
-  if (view.start === null || view.end === null || view.end >= now) return 0;
-  const room = maxRange && maxRange !== "ALL"
-    ? view.start - subtractTimeRange(new Date(view.end), maxRange).getTime()
-    : Number.POSITIVE_INFINITY;
-  return Math.max(0, Math.min((view.end - view.start) / 2, room, now - view.end));
-}
-
-function trailingRangeForStart(start: number | null, referenceDate: Date): TimeRange {
-  if (start === null) return "ALL";
-  for (const range of TIME_RANGES) {
-    if (range === "ALL" || start >= subtractTimeRange(referenceDate, range).getTime()) return range;
-  }
-  return "ALL";
-}
-
-function exclusiveEnd(bounds: DateBounds): Date | null {
-  return bounds.end === null ? null : new Date(bounds.end + 1);
-}
-
-function filterPoints(points: readonly TimeSeriesPoint[], bounds: DateBounds): TimeSeriesPoint[] {
-  return points.filter((point) => {
-    const time = point.date.getTime();
-    return Number.isFinite(time)
-      && (bounds.start === null || time >= bounds.start)
-      && (bounds.end === null || time <= bounds.end);
-  });
-}
-
-function resolvePriceHistoryIntegrity(
-  spec: ChartSpec,
-  requestedSeries: readonly ResolvedSeries[],
-  visibleSeries: readonly ResolvedSeries[],
-  bounds: DateBounds,
-  resolution: ManualChartResolution | "auto",
-  dateWindow: ChartSpec["viewport"]["dateWindow"] | null,
-) {
-  const filters = new Map(requestedSeries.map((entry) => [entry.id, priceObservationWindowFilter(entry, bounds, resolution, dateWindow)]));
-  const requestedIds = activeStudyInputSeriesIds(spec.studies);
-  spec.series.filter((entry) => entry.visible !== false).forEach((entry) => requestedIds.add(entry.id));
-  const selected = requestedSeries.filter((entry) => requestedIds.has(entry.id)).map((entry) => limitSeriesObservations(spec, {
-    ...entry, points: entry.points.filter((point) => filters.get(entry.id)!(point.date.getTime())),
-  }));
-  return [
-    ...collectPriceHistoryIntegrity(selected, "requested-observation", (id, time) => filters.get(id)!(time)),
-    ...collectPriceHistoryIntegrity(visibleSeries, "visible-calculation"),
-  ];
-}
-
-function comparisonDisplayBounds(bounds: DateBounds, comparison: PriceComparison | null): DateBounds {
-  if (comparison?.alignment !== "session-date" || comparison.start === null || comparison.end === null) return bounds;
-  // A date-only selection can include a local session that began on the prior
-  // UTC day. Keep its original timestamp visible in the rendering viewport.
-  return {
-    start: bounds.start === null ? null : Math.min(bounds.start, comparison.start),
-    end: bounds.end === null ? null : Math.max(bounds.end, comparison.end),
-  };
-}
-
-/**
- * An untouched market chart ends at its newest bar. A quote that arrives just
- * after the reference time moves it on; a closed market (a night, a weekend)
- * moves it back, so the plot does not end in an empty stretch that the first
- * pan would then collapse.
- */
-function followLatestMarketObservation(
-  bounds: DateBounds,
-  series: readonly ResolvedSeries[],
-): DateBounds {
-  if (bounds.end === null) return bounds;
-  let latest = Number.NEGATIVE_INFINITY;
-  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 (!Number.isFinite(latest) || latest === bounds.end) return bounds;
-  const shift = latest - bounds.end;
-  return {
-    start: bounds.start === null ? null : bounds.start + shift,
-    end: latest,
-  };
-}
-
-/**
- * The dates a capability series (CHOKE's transits) is asked for. A view the
- * user panned or zoomed keeps the range's dates loaded too: the chart's
- * navigation stops at the newest observation it has, so a series asked for
- * the moved view alone ended where the view did, and the view could never go
- * forward to the newest data again, not even by zooming out.
- */
-function capabilityRequestBounds(view: DateBounds, range: DateBounds, moved: boolean): DateBounds {
-  if (!moved) return view;
-  return {
-    start: view.start === null || range.start === null ? null : Math.min(view.start, range.start),
-    end: view.end === null || range.end === null ? null : Math.max(view.end, range.end),
-  };
-}
-
-/**
- * A chart of capability series alone (CHOKE's vessel transits) ends at its
- * newest observation, not today: such data is published days late, and an
- * axis running on to today would read as days with nothing in them. The
- * start stays where the range put it, so no empty span opens on the left.
- */
-function endAtNewestObservation(bounds: DateBounds, series: readonly ResolvedSeries[]): DateBounds {
-  if (bounds.end === null) return bounds;
-  let newest = Number.NEGATIVE_INFINITY;
-  for (const entry of series) {
-    for (const point of entry.points) {
-      const timestamp = point.date.getTime();
-      if (point.value !== null && Number.isFinite(timestamp) && timestamp > newest) newest = timestamp;
-    }
-  }
-  if (!Number.isFinite(newest) || newest >= bounds.end || (bounds.start !== null && newest <= bounds.start)) return bounds;
-  return { start: bounds.start, end: newest };
-}
-
-/**
- * 1D shows the latest trading session of the chart's first market listing,
- * from its open to the newest bar, with the close before it as a reference.
- * Null keeps the rolling day: crypto, FX and venues without known hours.
- * The reference is the quote's previous close when the quote is from the
- * session shown, as the legend's change is; otherwise the last bar of the
- * session before.
- */
-function latestSessionView(
-  primary: ResolvedSeries | undefined,
-  marketSeries: readonly ResolvedSeries[],
-  extendedHours: boolean,
-  quoteReference: { close: number; time: number } | undefined,
-): { bounds: DateBounds; priorClose: number | null } | null {
-  if (!primary?.listing) return null;
-  const bars = primary.points.flatMap((point) => {
-    const close = point.close ?? point.value;
-    const time = point.date.getTime();
-    return typeof close === "number" && Number.isFinite(close) && Number.isFinite(time) ? [{ time, close }] : [];
-  });
-  const latest = bars.at(-1)?.time;
-  if (latest === undefined) return null;
-  const { symbol, exchange } = primary.listing;
-  const open = latestSessionStart(symbol, exchange, latest, { extendedHours });
-  if (open === null) return null;
-  // The axis starts at the session's first bar, which a quiet pre-market can leave well after the open.
-  const start = bars.find((bar) => bar.time >= open)?.time ?? open;
-  // Another listing on the chart can trade later than the primary one.
-  let end = latest;
-  for (const entry of marketSeries) {
-    const last = entry.points.at(-1)?.date.getTime();
-    if (last !== undefined && Number.isFinite(last) && last > end) end = last;
-  }
-  const regularOpen = latestTradingSessionOpen(symbol, exchange, latest);
-  const quoteOpen = quoteReference ? latestTradingSessionOpen(symbol, exchange, quoteReference.time) : null;
-  const priorClose = quoteReference && regularOpen !== null && quoteOpen === regularOpen
-    ? quoteReference.close
-    : priorSessionClose(bars, open, symbol, exchange);
-  return { bounds: { start, end }, priorClose };
-}
-
-function emptyFinancials(priceHistory: TickerFinancials["priceHistory"] = []): TickerFinancials {
-  return { annualStatements: [], quarterlyStatements: [], priceHistory };
-}
-
-function chartCalculationSeriesIds(spec: ChartSpec): Set<string> {
-  const ids = activeStudyInputSeriesIds(spec.studies);
-  spec.series.filter(entry => entry.visible !== false).forEach(entry => ids.add(entry.id));
-  // Hidden primary market data still owns the shared session anchor.
-  const primary = spec.series.find(entry => entry.source.kind === "security" && isMarketFieldId(entry.source.fieldId));
-  if (primary) ids.add(primary.id);
-  return ids;
-}
-
-/** Select the provisional seed cadence before provider resolution support arrives. */
-export function chartSeedResolution(spec: ChartSpec, now: Date, options: ChartResolveOptions = {}): ManualChartResolution {
-  return requestResolution(spec, requestedBounds(spec, now), chartCalculationSeriesIds(spec), options, []);
-}
-
-export function seedChartResolutionResult(
-  spec: ChartSpec,
-  historyByInstrument: ReadonlyMap<string, TickerFinancials["priceHistory"]>,
-  referenceNow?: Date,
-  options: ChartResolveOptions = {},
-): ChartResolutionResult | null {
-  let latest = Number.NEGATIVE_INFINITY;
-  for (const history of historyByInstrument.values()) {
-    for (const point of history) latest = Math.max(latest, getPricePointTimestamp(point));
-  }
-  if (!Number.isFinite(latest)) return null;
-  const now = referenceNow ?? new Date(latest);
-  const resolution = chartSeedResolution(spec, now, options);
-  // The seed is replaced by the settled chart moments later. Draw it with
-  // what that chart will know (units, served cadence, where its axis ends) so
-  // the swap changes no label and moves no plot.
-  const support: ChartResolutionSupport[][] = [];
-  const series: ResolvedSeries[] = [];
-  spec.series.forEach((seriesSpec, index) => {
-    if (seriesSpec.visible === false || seriesSpec.source.kind !== "security") return;
-    if (!isMarketFieldId(seriesSpec.source.fieldId)) return;
-    const history = historyByInstrument.get(instrumentKey(seriesSpec.source));
-    if (!history?.length) return;
-    const facts = readSeedListingFacts(seriesSpec.source.instrument);
-    const resolved = baseSecuritySeries(seriesSpec, emptyFinancials(history), index, resolution, facts?.quoteMetadata, facts?.contractUnit);
-    if (!resolved?.points.length) return;
-    series.push(resolved);
-    if (facts?.resolutionSupport?.length) support.push(facts.resolutionSupport);
-  });
-  if (series.length === 0) return null;
-  const requested = requestedBounds(spec, now);
-  const sessionView = spec.viewport.range === "1D" && !explicitBounds(spec)
-    ? latestSessionView(series[0], series, spec.viewport.extendedHours === true, undefined)
-    : null;
-  const bounds = explicitBounds(spec) || runtimeRequestBounds(options)
-    ? requested
-    : sessionView?.bounds ?? followLatestMarketObservation(requested, series);
-  const primary = series[0]!;
-  if (sessionView?.priorClose != null && primary.transform === "raw"
-    && primary.unitGroup.startsWith("price") && primary.unitGroup !== "price:unknown") {
-    series[0] = { ...primary, priorClose: sessionView.priorClose };
-  }
-  const resolutionSupport = support.length === series.length ? intersectChartResolutionSupport(support) : [];
-  const priceComparison = resolvePriceComparison(spec, series, bounds, resolution);
-  const displayBounds = comparisonDisplayBounds(bounds, priceComparison);
-  const comparisonBounds = priceComparison && priceComparison.start !== null
-    ? priceComparison : bounds;
-  const baseSeries = series.map((entry) => prepareBaseSeriesForStudies(entry, priceComparisonBoundsForSeries(entry, priceComparison) ?? comparisonBounds));
-  // Calculate studies from raw buffered inputs, then use the same presentation
-  // and visible-window rules as the network result.
-  const studies = resolveStudies(series, spec.studies, resolution);
-  const axisWarnings: string[] = [];
-  const bufferedSeries = assignAxes([
-    ...baseSeries,
-    ...applyStudyPresentationTransforms(studies.series, spec.studies, series, comparisonBounds, undefined, priceComparison, bounds),
-  ], [...spec.series, ...spec.studies], axisWarnings).map((entry) => bufferPriceComparison(entry, priceComparison, bounds));
-  const visible = bufferedSeries.map((entry) => {
-    const entryBounds = presentationBounds(entry, spec.studies, priceComparison, bounds);
-    const clipped = entryBounds.start !== null && entryBounds.end !== null
-      ? clipSeriesToWindow(entry, new Date(entryBounds.start), new Date(entryBounds.end))
-      : { ...entry, points: filterPoints(entry.points, entryBounds) };
-    return clipPriceComparison(limitSeriesObservations(spec, clipped), priceComparison);
-  });
-  const priceHistoryIntegrity = resolvePriceHistoryIntegrity(spec, series, visible, bounds, resolution, spec.viewport.dateWindow ?? null);
-  return {
-    series: visible,
-    ...(priceHistoryIntegrity.length ? { priceHistoryIntegrity } : {}),
-    ...(priceComparison ? { priceComparison } : {}),
-    ...(resolutionSupport.length > 0 ? { resolutionSupport } : {}),
-    legendSeries: visible,
-    ...(spec.viewport.maxPoints === undefined ? { bufferedSeries } : {}),
-    ...((explicitBounds(spec) !== null || spec.viewport.maxPoints === undefined)
-      && displayBounds.start !== null && displayBounds.end !== null
-      ? { viewport: { start: new Date(displayBounds.start), end: new Date(displayBounds.end) } } : {}),
-    loading: true,
-    errors: studies.errors,
-    warnings: [...studies.warnings, ...axisWarnings, ...chartPriceHistoryIntegrityNotices(priceHistoryIntegrity), ...(priceComparison ? [priceComparison.notice] : [])],
-    resolution,
-  };
-}
-
 
 function chartIsPriceOnly(spec: ChartSpec, calculationSeriesIds: ReadonlySet<string>): boolean {
   return spec.series.every((entry) => {
@@ -791,385 +160,6 @@ function chartIsPriceOnly(spec: ChartSpec, calculationSeriesIds: ReadonlySet<str
   });
 }
 
-function isSortedPriceHistory(points: TickerFinancials["priceHistory"]): boolean {
-  let previous = Number.NEGATIVE_INFINITY;
-  for (const point of points) {
-    const timestamp = getPricePointTimestamp(point);
-    if (!Number.isFinite(timestamp)) continue;
-    if (timestamp < previous) return false;
-    previous = timestamp;
-  }
-  return true;
-}
-
-export function mergePriceHistoryWindows(
-  current: TickerFinancials["priceHistory"],
-  incoming: TickerFinancials["priceHistory"],
-  resolution: ManualChartResolution,
-): TickerFinancials["priceHistory"] {
-  let sorted: TickerFinancials["priceHistory"];
-  if (!isSortedPriceHistory(current) || !isSortedPriceHistory(incoming)) {
-    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) },
-        );
-      }
-    }
-    sorted = [...byTimestamp.values()].sort(
-      (left, right) => getPricePointTimestamp(left) - getPricePointTimestamp(right),
-    );
-  } else {
-    sorted = [];
-    let currentIndex = 0;
-    let incomingIndex = 0;
-    // An intraday point strictly inside a later window's bar is that window's
-    // earlier observation of it, such as a trade-time final print.
-    const step = isIntradayResolution(resolution) ? CHART_RESOLUTION_STEP_MS[resolution] : 0;
-    let coveredUntil = Number.NEGATIVE_INFINITY;
-    const append = (
-      point: TickerFinancials["priceHistory"][number],
-      timestamp: number,
-    ) => {
-      const normalized = point.date instanceof Date ? point : { ...point, date: new Date(timestamp) };
-      const previous = sorted.at(-1);
-      if (previous && getPricePointTimestamp(previous) === timestamp) sorted[sorted.length - 1] = normalized;
-      else sorted.push(normalized);
-    };
-
-    while (currentIndex < current.length || incomingIndex < incoming.length) {
-      const currentPoint = current[currentIndex];
-      const incomingPoint = incoming[incomingIndex];
-      const currentTimestamp = currentPoint ? getPricePointTimestamp(currentPoint) : Number.POSITIVE_INFINITY;
-      const incomingTimestamp = incomingPoint ? getPricePointTimestamp(incomingPoint) : Number.POSITIVE_INFINITY;
-      if (currentPoint && !Number.isFinite(currentTimestamp)) {
-        currentIndex += 1;
-      } else if (incomingPoint && !Number.isFinite(incomingTimestamp)) {
-        incomingIndex += 1;
-      } else if (currentPoint && currentTimestamp <= incomingTimestamp) {
-        if (!(incomingPoint && currentTimestamp < incomingTimestamp && currentTimestamp < coveredUntil)) {
-          append(currentPoint, currentTimestamp);
-        }
-        currentIndex += 1;
-      } else if (incomingPoint) {
-        append(incomingPoint, incomingTimestamp);
-        if (step) coveredUntil = incomingTimestamp + step;
-        incomingIndex += 1;
-      }
-    }
-  }
-
-  if (isIntradayResolution(resolution)) return sorted;
-  // Windows can be served by different sources, and they stamp the same session
-  // differently: local midnight, UTC midnight, or the opening bell. Keying on the
-  // exact timestamp keeps both copies, so the chart draws every bar twice and
-  // carries twice the points through every pan. Daily and slower bars are never
-  // closer than one step apart, so anything closer is the same session; keep the
-  // copy already plotted to leave existing bars where they are.
-  const minimumGapMs = CHART_RESOLUTION_STEP_MS[resolution] * 0.8;
-  const plotted = new Set(current.map(getPricePointTimestamp));
-  const merged: TickerFinancials["priceHistory"] = [];
-  for (const point of sorted) {
-    const previous = merged.at(-1);
-    if (!previous || getPricePointTimestamp(point) - getPricePointTimestamp(previous) >= minimumGapMs) {
-      merged.push(point);
-      continue;
-    }
-    if (!plotted.has(getPricePointTimestamp(previous)) && plotted.has(getPricePointTimestamp(point))) {
-      merged[merged.length - 1] = point;
-    }
-  }
-  return merged;
-}
-
-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,
-  durationEnd: number | null = bounds.end,
-): DateBounds {
-  if (bounds.start === null || bounds.end === null || !maxRange || maxRange === "ALL") {
-    return bounds;
-  }
-  const supportedStart = subtractTimeRange(new Date(durationEnd ?? 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;
-  return compareChartQuoteRecency(override, snapshot) >= 0 ? override : snapshot;
-}
-
-function mergeHistory(
-  financials: TickerFinancials | null,
-  history: TickerFinancials["priceHistory"],
-  quoteOverride: Quote | undefined,
-  now: number,
-  liveBarResolution?: ManualChartResolution,
-  exchange?: string,
-  appendQuote = true,
-  assetCategory?: string,
-  live?: { bars: LiveBarAccumulator; since?: number; session?: HistorySession; extendedHours?: boolean },
-): TickerFinancials {
-  const base = financials ?? emptyFinancials();
-  const quote = latestQuote(base.quote, quoteOverride);
-  const unknownHistoryBasis = hasUnknownBondHistoryBasis(quote, assetCategory, base.quoteMetadata?.instrumentType);
-  if (!appendQuote || unknownHistoryBasis) return { ...base, quote, priceHistory: history };
-  // Market bars fold every observed quote into the forming bar; other series
-  // price their latest point from the current quote alone.
-  const priceHistory = live && liveBarResolution
-    ? live.bars.apply(history, quote, { now, resolution: liveBarResolution, exchange, liveSince: live.since, session: live.session,
-      extendedHours: live.extendedHours })
-    : appendLiveQuotePoint(history, quote, liveBarResolution
-      ? { now, mode: "ohlc", resolution: liveBarResolution, exchange }
-      : { now });
-  return { ...base, quote, priceHistory };
-}
-
-function retainedWarmup(points: TickerFinancials["priceHistory"], visibleStart: number | null): number {
-  return visibleStart === null ? 0 : points.filter((point) => Number.isFinite(point.close)
-    && getPricePointTimestamp(point) < visibleStart).length;
-}
-
-function recoveryCandidates(
-  error: HistoryRetentionError,
-  provider: DataProvider,
-  source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
-): readonly HistoryRecoveryCandidate[] {
-  if (error.candidates.length) return error.candidates;
-  // A direct Cloud adapter enforces this constraint itself. Routed errors must
-  // carry the router's actual attempted-source scope, including across RPC.
-  if (provider.id !== "gloomberb-cloud") return [];
-  const target = publicListingTarget(source.instrument.symbol, source.instrument.exchange);
-  const context = requestContext(source);
-  const candidate = parseHistoryRecoveryCandidate({
-    sourceKey: `provider:${provider.id}`, retention: error.retention,
-    request: { symbol: target.symbol, exchange: target.exchange ?? "",
-      entityKey: getRouterEntityKey(source.instrument.symbol, context.instrument),
-      brokerId: context.brokerId, brokerInstanceId: context.brokerInstanceId,
-      interval: error.retention.interval, requestedStart: error.retention.requestedStart,
-      requestedEnd: error.retention.requestedEnd },
-  });
-  return candidate ? [candidate] : [];
-}
-
-/** Requests for older bars one panned window may add when its source answers only the newest part. */
-const OLDER_BAR_REQUESTS = 3;
-/** A window may start this far before its first bar for closed sessions alone: weekends and holiday weeks. */
-const CLOSED_SESSION_GAP_MS = 10 * DAY_MS;
-/**
- * An answer cut short at the source's cap holds thousands of bars. A shorter
- * one that starts late is a young listing or a source that keeps less: it
- * holds all there is, and an older request cannot change that.
- */
-const CAPPED_ANSWER_MIN_BARS = 1_000;
-
-function firstBarTime(points: TickerFinancials["priceHistory"]): number {
-  for (const point of points) {
-    const time = getPricePointTimestamp(point);
-    if (Number.isFinite(time) && Number.isFinite(point.close)) return time;
-  }
-  return Number.NaN;
-}
-
-/**
- * A source caps the bars one request returns and answers with the newest, so
- * a panned window can come back starting weeks after it was asked to. The
- * older part is asked for on its own, from the same source and session, until
- * it is covered or the source has nothing older: then the first bar is where
- * this listing's history at this cadence starts, and the chart stops there
- * instead of asking again. So does an answer that starts late without being
- * cut short, or one the source says its coverage starts with.
- */
-async function withOlderBars(
-  provider: DataProvider,
-  source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
-  request: PriceHistoryRequest,
-  result: PriceHistoryResult,
-  context: MarketDataRequestContext,
-): Promise<LoadedPriceHistory> {
-  const start = request.bounds.start;
-  const end = request.bounds.end;
-  if (start === null || end === null || result.resolution !== request.resolution) return result;
-  const toleranceMs = Math.max(CLOSED_SESSION_GAP_MS, (end - start) / 5);
-  let current: LoadedPriceHistory = result;
-  let answerBars = result.points.length;
-  for (let attempt = 0; attempt < OLDER_BAR_REQUESTS; attempt += 1) {
-    const first = firstBarTime(current.points);
-    if (!Number.isFinite(first) || first - start <= toleranceMs) return current;
-    // An answer short of the cap that still starts late is everything the source has.
-    if (answerBars < CAPPED_ANSWER_MIN_BARS || current.coverageStart) return { ...current, historyStart: first };
-    let older: PriceHistoryResult | null;
-    try {
-      older = await fetchHistoryResult(provider, source.instrument.symbol, source.instrument.exchange ?? "",
-        { kind: "detail", start: new Date(start), end: new Date(first), interval: request.resolution }, context);
-    } catch (error) {
-      // The source keeps nothing that old, by its own account; anything else may pass.
-      return isHistoryRetentionError(error) || error instanceof ProviderMissError
-        ? { ...current, historyStart: first } : current;
-    }
-    if (!older || older.resolution !== current.resolution
-      || priceHistoryAcquisitionIdentity(older) !== priceHistoryAcquisitionIdentity(current)) return current;
-    const earlier = older.points.filter((point) => getPricePointTimestamp(point) < first);
-    if (!Number.isFinite(firstBarTime(earlier))) return { ...current, historyStart: first };
-    current = { ...current, points: [...earlier, ...current.points] };
-    answerBars = older.points.length;
-  }
-  return current;
-}
-
-async function loadPriceHistory(
-  provider: DataProvider,
-  source: Extract<ChartSeriesSpec["source"], { kind: "security" }>,
-  request: PriceHistoryRequest,
-): Promise<LoadedPriceHistory> {
-  const context = { ...requestContext(source), historyRequestKey: request.historyRequestKey,
-    ...(request.historySession ? { historySession: request.historySession } : {}) };
-  let coverageNotice: string | null = null;
-  let retentionError: HistoryRetentionError | null = null;
-  const observeFailure = (error: unknown) => {
-    if (error instanceof SnapshotHistoryUnavailableError) throw error;
-    if (error instanceof HistoryCoverageError) coverageNotice ??= error.message;
-    if (isHistoryRetentionError(error)) retentionError ??= error;
-  };
-  const observeCoverage = (result: PriceHistoryResult) => {
-    coverageNotice ??= historyCoverageNotice(result.coverageStart, request.visibleBounds.start);
-  };
-  const accepted = (points: TickerFinancials["priceHistory"]) => points.length > 0
-    && (!request.explicitWindow || historyIntersectsBounds(points, request.visibleBounds));
-  const detailStart = request.bounds.start === null ? null : new Date(request.bounds.start);
-  const detailEnd = exclusiveEnd(request.bounds);
-  if (request.explicitWindow && detailStart && detailEnd && (provider.getDetailedPriceHistoryWithMetadata || provider.getDetailedPriceHistory)) {
-    try {
-      const result = (await fetchHistoryResult(provider, source.instrument.symbol, source.instrument.exchange ?? "",
-        { kind: "detail", start: detailStart, end: detailEnd, interval: request.resolution }, context))!;
-      const { points } = result;
-      observeCoverage(result);
-      // Authored dates chart what their source answers; a panned view reaches for the rest.
-      if (accepted(points)) return request.authoredWindow ? result : await withOlderBars(provider, source, request, result, context);
-    } catch (error) { observeFailure(error); }
-  }
-  if (provider.getPriceHistoryForResolutionWithMetadata || provider.getPriceHistoryForResolution) {
-    try {
-      const result = (await fetchHistoryResult(provider, source.instrument.symbol, source.instrument.exchange ?? "",
-        { kind: "resolution", range: request.fallbackRange, resolution: request.resolution }, context))!;
-      const { points } = result;
-      observeCoverage(result);
-      if (accepted(points)) {
-        rememberParsedPriceHistory(parsedPriceHistoryKey(source.instrument, request.fallbackRange, request.resolution), points, result);
-        return result;
-      }
-    } catch (error) { observeFailure(error); }
-  }
-
-  // Only original source/cache exhaustion reaches recovery. Ask the selected
-  // source for its retained window; a nominal clock multiplier cannot guarantee
-  // enough observations across exchange closures for a study's warmup.
-  const retainedFailure = retentionError as HistoryRetentionError | null;
-  let recoveryAttempted = false;
-  const retryAt = retainedFailure ? retainedFailure.retention.observedAt + HISTORY_RETENTION_MAX_AGE_MS : undefined;
-  if (retainedFailure && !coverageNotice && (provider.getDetailedPriceHistoryWithMetadata || provider.getDetailedPriceHistory)) {
-    const step = CHART_RESOLUTION_STEP_MS[request.resolution];
-    const target = publicListingTarget(source.instrument.symbol, source.instrument.exchange);
-    const candidate = recoveryCandidates(retainedFailure, provider, source).map((value) => parseHistoryRecoveryCandidate(value))
-      .find((value) => value && value.request.symbol === target.symbol
-        && value.request.exchange === (target.exchange ?? "")
-        && value.request.interval === canonicalHistoryInterval(request.resolution)
-        && value.request.entityKey === getRouterEntityKey(source.instrument.symbol, context.instrument)
-        && value.request.brokerId === context.brokerId && value.request.brokerInstanceId === context.brokerInstanceId);
-    if (candidate && request.visibleBounds.start !== null) {
-      // One complete bar inside the advancing source limit absorbs acquisition
-      // latency. Keep the source's original exclusive end at its second precision.
-      const start = Math.ceil(candidate.retention.availableStart / step) * step + step;
-      const end = candidate.retention.requestedEnd;
-      const visibleEnd = request.visibleBounds.end === null ? end : Math.floor(request.visibleBounds.end / 1000) * 1000;
-      // At an interval the user chose, a preset range or a panned or zoomed
-      // view that reaches back past the retained bars, but still reaches them,
-      // charts what the source keeps. Auto steps to coarser bars below instead,
-      // and authored dates keep failing.
-      const retainedOnly = !request.allowProviderDefaultFallback && !request.authoredWindow && visibleEnd >= start;
-      if ((retainedOnly || request.visibleBounds.start >= start) && visibleEnd <= end && start < end) {
-        recoveryAttempted = true;
-        try {
-          const result = (await fetchHistoryResult(provider, source.instrument.symbol, source.instrument.exchange ?? "",
-            { kind: "detail", start: new Date(start), end: new Date(end), interval: request.resolution }, { ...context, historyRecovery: candidate }))!;
-          const { points } = result;
-          observeCoverage(result);
-          if (accepted(points)) return { ...result, expiresAt: retryAt, historyStart: firstBarTime(points),
-            recovery: { sourceKey: candidate.sourceKey, start, end, requiredWarmupPoints: request.requiredWarmupPoints,
-              usableWarmupPoints: retainedWarmup(points, request.visibleBounds.start), retention: candidate.retention } };
-        } catch (error) { observeFailure(error); }
-      }
-    }
-  }
-
-  const unavailable = () => coverageNotice
-    ?? `Requested ${request.resolution} price history is unavailable for ${instrumentLabel(source)}. Choose Auto or a supported interval.`;
-  const fail = (message: string): never => {
-    if (retryAt !== undefined) throw new PriceHistoryAcquisitionError(message, retryAt);
-    throw new Error(message);
-  };
-  if (!request.allowProviderDefaultFallback || recoveryAttempted) return fail(unavailable());
-
-  // After a proved retention failure, one explicit calendar fallback can retain
-  // the familiar broader chart with known cadence. Never substitute coarser bars
-  // for an authored financial/market period that requires finer observations.
-  const coarser = retainedFailure && (provider.getPriceHistoryForResolutionWithMetadata || provider.getPriceHistoryForResolution)
-    ? (["1d", "1wk", "1mo"] as const).find((resolution) =>
-      CHART_RESOLUTION_STEP_MS[resolution] > CHART_RESOLUTION_STEP_MS[request.resolution]
-      && isResolutionFineEnoughForMarketPeriod(resolution, source.period)
-      && request.support.some((entry) => entry.resolution === resolution
-        && TIME_RANGES.indexOf(entry.maxRange) >= TIME_RANGES.indexOf(request.fallbackRange))) : undefined;
-  if (coarser) {
-    try {
-      const result = (await fetchHistoryResult(provider, source.instrument.symbol, source.instrument.exchange ?? "",
-        { kind: "resolution", range: request.fallbackRange, resolution: coarser }, context))!;
-      const { points } = result;
-      observeCoverage(result);
-      if (accepted(points)) {
-        rememberParsedPriceHistory(parsedPriceHistoryKey(source.instrument, request.fallbackRange, coarser), points, result);
-        return { ...result, expiresAt: retryAt };
-      }
-    } catch (error) { observeFailure(error); }
-    return fail(unavailable());
-  }
-  if (retainedFailure) return fail(unavailable());
-  if (!provider.getPriceHistoryWithMetadata && source.period && source.period !== "auto" && isMarketFieldId(source.fieldId)) return fail(unavailable());
-  let result: PriceHistoryResult;
-  try {
-    result = (await fetchHistoryResult(provider, source.instrument.symbol, source.instrument.exchange ?? "",
-      { kind: "range", range: request.fallbackRange }, context))!;
-    if (source.period && source.period !== "auto" && isMarketFieldId(source.fieldId)
-      && (result.resolution === null || !isResolutionFineEnoughForMarketPeriod(result.resolution, source.period))) return fail(unavailable());
-  } catch (error) {
-    return fail(coverageNotice ?? (error instanceof Error ? error.message : String(error)));
-  }
-  const { points } = result;
-  observeCoverage(result);
-  if (points.length === 0 && coverageNotice) return fail(coverageNotice);
-  if (request.explicitWindow && points.length > 0 && !historyIntersectsBounds(points, request.visibleBounds)) {
-    return fail(coverageNotice ?? `Price history for the requested window is unavailable for ${instrumentLabel(source)}.`);
-  }
-  // A default-only provider remains usable, but its bare array cannot establish
-  // an interval for live-bar merging, annualization or a requested-cadence cache.
-  return { ...result, expiresAt: retryAt ?? Date.now() + HISTORY_RETENTION_MAX_AGE_MS };
-}
-
 /**
  * A US stock or fund listing, including one a broker contract routes through
  * SMART in dollars. Options and futures have no pre-market session.
@@ -1181,361 +171,6 @@ function tradesUsExtendedHours(exchange: string | undefined, contract: BrokerCon
     || (!!contract && canonicalExchange(venue) === "SMART" && (!contract.currency || contract.currency.toUpperCase() === "USD"));
 }
 
-function baseSecuritySeries(
-  spec: ChartSeriesSpec,
-  financials: TickerFinancials,
-  index: number,
-  marketResolution?: ManualChartResolution | null,
-  quoteMetadata: QuoteMetadata | null | undefined = financials.quoteMetadata,
-  /** What a futures contract's price counts ("USD / gallon"), from its terms. */
-  contractUnit?: string | null,
-): ResolvedSeries | null {
-  if (spec.source.kind !== "security") return null;
-  const field = getTimeSeriesField(spec.source.fieldId);
-  if (!field) return null;
-  const points = extractSecuritySeries(financials, spec.source);
-  const unreportedPeriod = points.length === 0 ? unreportedStatementPeriod(financials, spec.source) : null;
-  const symbol = instrumentLabel(spec.source);
-  const statementCurrency = field.id.startsWith("fundamental.") && field.unit.startsWith("currency")
-    ? reportingCurrencySeries(points, financials.financialCurrency) : null;
-  // A broker contract names its currency even before (or without) a quote.
-  const currency = statementCurrency ? statementCurrency.currency : financials.quote?.currency || quoteMetadata?.currency || spec.source.instrument.instrument?.currency;
-  const assetKind = resolveAssetDisplayKind({ assetCategory: financials.quote?.instrumentType || quoteMetadata?.instrumentType });
-  const unknownBondBasis = hasUnknownBondHistoryBasis(financials.quote,
-    spec.source.instrument.instrument?.secType, quoteMetadata?.instrumentType);
-  const volumeUnit = unknownBondBasis ? undefined : assetKind === "equity" ? "shares" as const : assetKind === "contract" ? "contracts" as const : undefined;
-  // A price quote establishes its currency, but only instrument metadata can
-  // establish a per-share or per-crypto-unit basis. This does not establish the
-  // provider's volume denomination or a derivative's contract multiplier.
-  const unitTemplate = field.unitGroup === "price" && isMarketFieldId(field.id)
-    ? unknownBondBasis ? "unknown" : `currency${assetKind === "equity" ? "/share" : assetKind === "crypto" ? "/unit" : ""}`
-    : field.unit;
-  const generic = field.unitGroup === "price"
-    ? futuresGenericListing(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
-  // A generic future on an index, VIX or Treasuries reads in points or 32nds, and an index
-  // future's continuous symbol or contract in points, not dollars, as its quote does.
-  const genericBasis = field.unitGroup === "price" && isMarketFieldId(field.id)
-    ? futuresListingPriceBasis(spec.source.instrument.symbol, spec.source.instrument.exchange) : null;
-  // An index's level is points too, never the currency its members trade in.
-  const indexLevel = field.unitGroup === "price" && isMarketFieldId(field.id)
-    && isIndexLevel(financials.quote?.instrumentType || quoteMetadata?.instrumentType);
-  const genericUnit = genericBasis === "points" || indexLevel ? INDEX_POINTS_UNIT : genericBasis === "thirty-seconds" ? "32nds" : null;
-  // A future's price in a currency counts what its contract terms say: heating
-  // oil is USD / gallon and crude USD / barrel, which a bare USD does not tell apart.
-  const statedUnit = !genericUnit && unitTemplate === "currency" ? contractPriceUnit(contractUnit, currency) : null;
-  const unit = field.id === "market.volume" ? volumeUnit ?? ""
-    : statedUnit ?? genericUnit ?? (unitTemplate.startsWith("currency") && currency ? unitTemplate.replace("currency", currency) : unitTemplate);
-  const currencyUnitGroup = genericUnit ? `${field.unitGroup}:${genericUnit}`
-    : unknownBondBasis && field.unitGroup === "price" ? "price:unknown"
-    : field.unit.startsWith("currency") && currency
-    ? `${field.unitGroup}:${currency}`
-    : field.unitGroup;
-  const marketExchange = spec.source.instrument.exchange
-    || financials.quote?.listingExchangeName
-    || financials.quote?.exchangeName;
-  const marketField = isMarketFieldId(spec.source.fieldId);
-  // A routing code such as a broker's SMART names no venue. The quote's
-  // listing then supplies the session clock, so closed hours stay off the axis.
-  const sessionExchange = [marketExchange, financials.quote?.listingExchangeName, quoteMetadata?.listingExchangeName, financials.quote?.exchangeName]
-    .find((value) => resolveExchangeTimeZone(value));
-  // A dollar listing saved with IBKR's SMART route and no other venue trades on
-  // the US session, and so does a dollar option, which names no venue at all.
-  const dollars = !currency || currency === "USD";
-  const usOption = dollars && (spec.source.instrument.instrument?.secType?.toUpperCase() === "OPT"
-    || /^OPTION$/i.test(financials.quote?.instrumentType ?? quoteMetadata?.instrumentType ?? ""));
-  const routedUsListing = !sessionExchange && ((canonicalExchange(marketExchange) === "SMART" && dollars) || usOption);
-  const marketTimeZone = marketField
-    && canonicalExchange(marketExchange) !== "CCC"
-    ? resolveExchangeTimeZone(sessionExchange) ?? (routedUsListing ? "America/New_York" : null)
-    : null;
-  // A route has no hours of its own: its sessions, which the day view and
-  // VWAP follow, are the venue's, and NYSE's for an unnamed dollar listing.
-  const listingExchange = canonicalExchange(marketExchange) === "SMART" || usOption
-    ? canonicalExchange(sessionExchange) || (routedUsListing ? "NYSE" : marketExchange)
-    : marketExchange;
-  const latestChangePercent = marketField && field.unit.startsWith("currency")
-    && !unknownBondBasis
-    && financials.quote && hasValidQuoteObservationTime(financials.quote)
-    ? financials.quote.changePercent
-    : undefined;
-  const priceIssues = valuationPriceIssues(financials, spec.source);
-  // A source with closes only, such as a generic future, has flat bars (open,
-  // high and low filled from the close): nothing to draw as candles.
-  const closesOnly = marketField && points.length > 1
-    && points.every((point) => [point.open, point.high, point.low].every((value) => value == null || value === point.close));
-  return {
-    id: spec.id,
-    label: spec.label?.trim() || (generic ? futuresGenericCaption(generic) : `${symbol} ${field.seriesLabel ?? field.shortLabel}`),
-    color: spec.color ?? SERIES_COLORS[index % SERIES_COLORS.length]!,
-    unit,
-    unitGroup: currencyUnitGroup,
-    ...(statedUnit ? { statedUnit } : {}),
-    priceAssetCategory: marketField && field.unitGroup === "price" && !unknownBondBasis
-      ? financials.quote?.instrumentType || quoteMetadata?.instrumentType : undefined,
-    volumeUnit,
-    ...(priceIssues.length ? { valuationPriceIssues: priceIssues } : {}),
-    warning: field.id === "market.volume" && !volumeUnit && points.length > 0
-      ? "Volume unit unknown." : statementCurrency?.warning ?? valuationCurrencyWarning(financials, spec.source),
-    nativeFrequency: marketField ? marketSeriesFrequency(spec.source, marketResolution)
-      : spec.source.period && spec.source.period !== "auto" ? spec.source.period : field.nativeFrequency,
-    ...(unreportedPeriod ? { unreportedPeriod } : {}),
-    ...(marketField ? { historyResolution: marketResolution } : {}),
-    timestampMode: spec.source.timestampMode,
-    dataShape: field.dataShape,
-    style: closesOnly && isOhlcSeriesStyle(spec.style ?? field.defaultStyle) ? "line" : spec.style,
-    transform: spec.transform,
-    axis: spec.axis === "right" ? "right" : "left",
-    panelId: spec.panelId,
-    interpolation: spec.interpolation,
-    observationKind: marketField ? "market" : undefined,
-    ...(marketField ? { listing: { symbol: spec.source.instrument.symbol, exchange: listingExchange ?? "" } } : {}),
-    timeBasis: marketTimeZone
-      ? {
-          kind: "market",
-          timeZone: marketTimeZone,
-          exchange: canonicalExchange(sessionExchange) || undefined,
-          cadenceMs: marketResolution
-            ? CHART_RESOLUTION_STEP_MS[marketResolution]
-            : undefined,
-        }
-      : undefined,
-    latestChangePercent: typeof latestChangePercent === "number" && Number.isFinite(latestChangePercent)
-      ? latestChangePercent
-      : undefined,
-    points,
-  };
-}
-
-const FRED_CATALOG_UNITS: Readonly<Record<string, string>> = {
-  "percent": "%",
-  "millions of u.s. dollars": "million USD",
-  "millions of dollars": "million USD",
-  "billions of dollars": "billion USD",
-  "billions of u.s. dollars": "billion USD",
-  "billions of us dollars": "billion USD",
-  "dollars per barrel": "USD/barrel",
-  "thousands of persons": "thousand people",
-};
-
-function fredCatalogUnit(units: string): string {
-  return FRED_CATALOG_UNITS[units.toLowerCase()] ?? units;
-}
-
-function baseEconomicSeries(
-  spec: ChartSeriesSpec,
-  loaded: FredSeriesLoadResult,
-  index: number,
-): ResolvedSeries | null {
-  if (spec.source.kind !== "economic") return null;
-  const { data } = loaded;
-  const units = data.info?.units?.trim() || "value";
-  const catalogUnit = fredCatalogUnit(units);
-  // "Percent Change from Year Ago" and "Percent per Annum" are percent too.
-  const isPercent = units.toLowerCase().includes("percent");
-  return {
-    id: spec.id,
-    label: spec.label?.trim() || data.info?.title?.trim() || spec.source.seriesId,
-    color: spec.color ?? SERIES_COLORS[index % SERIES_COLORS.length]!,
-    unit: isPercent ? "%" : catalogUnit,
-    unitGroup: isPercent ? "percent" : `economic:${catalogUnit.toLowerCase()}`,
-    nativeFrequency: "auto",
-    timestampMode: "period-end",
-    dataShape: "scalar",
-    style: spec.style,
-    transform: spec.transform,
-    axis: spec.axis === "right" ? "right" : "left",
-    panelId: spec.panelId,
-    interpolation: spec.interpolation,
-    points: extractFredSeries(data.observations, { providerId: "fred", timestampMode: "period-end" }),
-    warning: "FRED vintage dates are unavailable; observations use period dates.",
-  };
-}
-
-function baseCapabilitySeries(
-  spec: ChartSeriesSpec,
-  loaded: ResolvedSeries,
-  index: number,
-): ResolvedSeries {
-  const points = loaded.points.flatMap((point) => {
-    const date = finiteDate(point.date as unknown as string | Date | undefined);
-    const observedAt = finiteDate(point.observedAt as unknown as string | Date | undefined) ?? date;
-    const availableAt = finiteDate(point.availableAt as unknown as string | Date | undefined) ?? undefined;
-    return date && observedAt ? [{ ...point, date, observedAt, ...(availableAt ? { availableAt } : {}) }] : [];
-  });
-  return {
-    ...loaded,
-    id: spec.id,
-    label: spec.label?.trim() || loaded.label || (spec.source.kind === "capability" ? spec.source.seriesId : spec.id),
-    color: spec.color ?? loaded.color ?? SERIES_COLORS[index % SERIES_COLORS.length]!,
-    style: spec.style,
-    transform: spec.transform,
-    axis: spec.axis === "right" ? "right" : spec.axis === "left" ? "left" : loaded.axis,
-    panelId: spec.panelId,
-    interpolation: spec.interpolation,
-    observationKind: loaded.observationKind ?? "dataset",
-    points,
-  };
-}
-
-function staleFredWarning(loaded: FredSeriesLoadResult): string | null {
-  if (!loaded.stale) return null;
-  return `FRED refresh failed${loaded.refreshError ? ` (${loaded.refreshError})` : ""}; showing cached data fetched ${new Date(loaded.fetchedAt).toISOString().slice(0, 10)}.`;
-}
-
-function assignAxes(
-  series: ResolvedSeries[],
-  specs: readonly { id: string; axis: ChartSeriesSpec["axis"] }[],
-  warnings: string[],
-): ResolvedSeries[] {
-  const requested = new Map(specs.map((spec) => [spec.id, spec.axis] as const));
-  const groupsByPanel = new Map<string, Partial<Record<"left" | "right", string>>>();
-  return series.map((entry) => {
-    const groups = groupsByPanel.get(entry.panelId) ?? {};
-    groupsByPanel.set(entry.panelId, groups);
-    const preferred = requested.get(entry.id);
-    let axis: "left" | "right";
-    if (preferred === "left" || preferred === "right") {
-      axis = preferred;
-    } else if (groups.left === entry.unitGroup) {
-      axis = "left";
-    } else if (groups.right === entry.unitGroup) {
-      axis = "right";
-    } else if (!groups.left) {
-      axis = "left";
-    } else {
-      axis = "right";
-    }
-    if (groups[axis] && groups[axis] !== entry.unitGroup) {
-      warnings.push(`${entry.label} shares the ${axis} axis with a different unit; choose an explicit panel for independent scaling.`);
-    }
-    groups[axis] ??= entry.unitGroup;
-    return { ...entry, axis };
-  });
-}
-
-/**
- * A series drawn in a ticker's price (a moving average of it, a band around
- * it) takes the units of that ticker's price series when the chart has it, so
- * the two share an axis and the line sits on the price instead of on a scale
- * of its own.
- */
-function adoptPriceUnits(series: ResolvedSeries[], specs: readonly ChartSeriesSpec[]): ResolvedSeries[] {
-  if (!series.some((entry) => entry.priceOf)) return series;
-  const specsById = new Map(specs.map((spec) => [spec.id, spec]));
-  const prices = series.filter((entry) => {
-    const source = specsById.get(entry.id)?.source;
-    return source?.kind === "security" && getTimeSeriesField(source.fieldId)?.unitGroup === "price"
-      && entry.transform === "raw";
-  });
-  if (prices.length === 0) return series;
-  return series.map((entry) => {
-    if (!entry.priceOf) return entry;
-    const wanted = parsePublicTickerKey(entry.priceOf.toUpperCase());
-    const key = publicTickerKey(wanted.symbol, wanted.exchange);
-    const named = (price: ResolvedSeries) => {
-      const source = specsById.get(price.id)?.source;
-      if (source?.kind !== "security") return false;
-      return publicTickerKey(source.instrument.symbol, source.instrument.exchange) === key
-        || (!wanted.exchange && source.instrument.symbol.toUpperCase() === wanted.symbol);
-    };
-    const price = prices.find((candidate) => named(candidate) && candidate.panelId === entry.panelId)
-      ?? prices.find(named);
-    return price && entry.transform === "raw"
-      ? { ...entry, unit: price.unit, unitGroup: price.unitGroup }
-      : entry;
-  });
-}
-
-function prepareBaseSeriesForStudies(
-  series: ResolvedSeries,
-  bounds: DateBounds,
-  clipToBounds = false,
-  fallbackBaselineBounds?: DateBounds,
-): ResolvedSeries {
-  const baselineTransform = series.transform === "percent" || series.transform === "index100";
-  let source = series;
-  if (clipToBounds && bounds.start !== null && bounds.end !== null) {
-    source = clipSeriesToWindow(series, new Date(bounds.start), new Date(bounds.end));
-  } 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 } : undefined,
-  );
-}
-
-function scalarBaseline(series: ResolvedSeries, bounds: DateBounds): number | null {
-  const points = filterPoints(series.points, bounds);
-  for (const point of points) {
-    const value = typeof point.value === "number" && Number.isFinite(point.value)
-      ? point.value
-      : typeof point.close === "number" && Number.isFinite(point.close)
-        ? point.close
-        : null;
-    if (value !== null && value !== 0) return value;
-  }
-  return null;
-}
-
-function studyForOutput(
-  outputId: string,
-  studies: readonly ChartSpec["studies"][number][],
-): ChartSpec["studies"][number] | undefined {
-  return studies
-    .filter((study) => outputId === study.id || outputId.startsWith(`${study.id}:`))
-    .sort((left, right) => right.id.length - left.id.length)[0];
-}
-
-/** Price overlays read in the price's own terms, so they take its transform. */
-function followsInputTransform(kind: ChartSpec["studies"][number]["kind"]): boolean {
-  return kind === "sma" || kind === "ema" || kind === "bollinger" || kind === "vwap" || kind === "anchored-vwap";
-}
-
-function presentationBounds(
-  series: ResolvedSeries,
-  studies: readonly ChartSpec["studies"][number][],
-  comparison: PriceComparison | null,
-  fallback: DateBounds,
-): DateBounds {
-  const study = studyForOutput(series.id, studies);
-  const sourceId = study && followsInputTransform(study.kind)
-    ? study.inputSeriesIds[0] : series.id;
-  return (sourceId && comparison?.sourceBounds?.[sourceId]) || fallback;
-}
-
-function applyStudyPresentationTransforms(
-  outputs: ResolvedSeries[],
-  studies: readonly ChartSpec["studies"][number][],
-  rawSeries: readonly ResolvedSeries[],
-  visibleBounds: DateBounds,
-  fallbackBaselineBounds?: DateBounds,
-  priceComparison?: PriceComparison | null,
-  view: DateBounds = visibleBounds,
-): ResolvedSeries[] {
-  const rawById = new Map(rawSeries.map((series) => [series.id, series] as const));
-  return outputs.map((output) => {
-    const study = studyForOutput(output.id, studies);
-    if (!study || !followsInputTransform(study.kind)) {
-      return output;
-    }
-    const input = rawById.get(study.inputSeriesIds[0] ?? "");
-    if (!input || input.transform === "raw") return output;
-    const baseline = input.transform === "percent" || input.transform === "index100"
-      ? scalarBaseline(input, priceComparisonBoundsForSeries(input, priceComparison ?? null) ?? visibleBounds)
-        ?? (fallbackBaselineBounds ? scalarBaseline(input, fallbackBaselineBounds) : null)
-      : undefined;
-    const transformed = applyResolvedSeriesTransform(output, input.transform, { baseline });
-    const inputBounds = priceComparison?.sourceBounds?.[input.id];
-    return inputBounds ? { ...transformed, points: comparedBufferPoints(transformed.points, inputBounds, view) } : transformed;
-  });
-}
-
 /** Fewer daily or coarser bars than this make a line or two, not a chart. */
 const SHORT_HISTORY_MAX_BARS = 20;
 
@@ -1822,6 +457,8 @@ async function resolveChartSpecPass(
     const served = supportBySource[index];
     if (served?.length) rememberSeedListingFacts(source.instrument, { resolutionSupport: served });
   });
+  // Futures source bars start on the clock: bars built from them must not straddle a session's open.
+  const openMinute = futuresOpenMinuteOf(activeMarketSources.map((source) => source.instrument));
   const initialResolution = requestResolution(
     spec,
     initialVisibleBounds,
@@ -1829,20 +466,23 @@ async function resolveChartSpecPass(
     options,
     sharedSupport,
     provisionalSupport,
+    openMinute,
   );
-  if (
-    spec.viewport.resolution !== "auto"
-    && initialResolution !== spec.viewport.resolution
-  ) {
+  const requestedSource = spec.viewport.resolution === "auto"
+    ? null : chartBarSizeSource(spec.viewport.resolution, provisionalSupport ? [] : sharedSupport, openMinute);
+  if (requestedSource !== null && initialResolution !== requestedSource) {
     warnings.push(
       `${spec.viewport.resolution.toUpperCase()} data is unavailable for this range. Auto resolution was used instead.`,
     );
   }
+  // Bars of a size the source does not serve (4h, 2d) are built from the bars it does (1h, 1d).
+  const builtBarSize = isCustomChartResolution(spec.viewport.resolution) && initialResolution === requestedSource
+    ? spec.viewport.resolution : null;
   const requestVisibleBounds = requestBounds ?? initialVisibleBounds;
   // A view the user panned or zoomed to, as opposed to authored dates.
   const movedWindow = requestBounds !== null && !sameBounds(requestBounds, initialVisibleBounds);
   const hasExplicitWindow = explicitBounds(spec) !== null || movedWindow;
-  const initialCalculationBounds = calculationBounds(spec, requestVisibleBounds, initialResolution);
+  const initialCalculationBounds = calculationBounds(spec, requestVisibleBounds, builtBarSize ?? initialResolution);
 
   // Only US stocks and funds trade before and after the regular session; asking elsewhere costs a request for nothing.
   const extendedHoursFor = (source: Extract<ChartSeriesSpec["source"], { kind: "security" }>, resolution: ManualChartResolution) => (
@@ -1993,7 +633,7 @@ async function resolveChartSpecPass(
     }
     // Read per request: one recovered window answers every visible window that shares its acquisition.
     if (loaded.recovery && request.visibleBounds.start !== null && request.visibleBounds.start < loaded.recovery.start) {
-      priorityWarnings.push(historyRetentionNotice(loaded.recovery.retention, loaded.resolution ?? request.resolution,
+      priorityWarnings.push(historyRetentionNotice(loaded.recovery.retention, builtBarSize ?? loaded.resolution ?? request.resolution,
         listingTimeZone(source.instrument.symbol, source.instrument.exchange)));
       retainedHistoryOnly = true;
     }
@@ -2036,7 +676,7 @@ async function resolveChartSpecPass(
     // A source that answered a panned view short, and then had nothing older, starts there.
     if (combined.historyStart !== undefined && !loaded.recovery && !combined.coverageStart && request.visibleBounds.start !== null
       && request.visibleBounds.start < combined.historyStart && combined.resolution) {
-      priorityWarnings.push(historyStartNotice(combined.historyStart, combined.resolution,
+      priorityWarnings.push(historyStartNotice(combined.historyStart, builtBarSize ?? combined.resolution,
         listingTimeZone(source.instrument.symbol, source.instrument.exchange), referenceNow.getTime()));
     }
     if (accumulationKey && loaded.resolution && isIntradayResolution(loaded.resolution)
@@ -2173,7 +813,7 @@ async function resolveChartSpecPass(
       }
       if (forwardPE && financials?.epsEstimates && !history) {
         history = await loadHistory(resolvedSource, true).catch((error: unknown) => {
-          warnings.push(`${seriesSpec.label ?? seriesSpec.id}: ${error instanceof Error ? error.message : String(error)}`);
+          warnings.push(`${seriesMessageName(seriesSpec)}: ${error instanceof Error ? error.message : String(error)}`);
           return null;
         });
       }
@@ -2225,6 +865,16 @@ async function resolveChartSpecPass(
           priceHistoryResolution: history.resolution, priceHistoryRequestKey: history.requestKey,
           priceHistorySession: history.session, priceHistorySourceKey: history.sourceKey };
       }
+      // Built after the live quote joins the source bars, so the forming bar holds it too.
+      // Captures keep the source bars, which their resolution names.
+      const sourceBars = merged;
+      const builtBars = builtBarSize && marketField && history?.resolution === initialResolution ? builtBarSize : null;
+      if (builtBars) {
+        merged = { ...merged, priceHistory: aggregatePriceBars(merged.priceHistory, builtBars, {
+          symbol: resolvedSource.instrument.symbol, exchange: resolvedSource.instrument.exchange,
+          extendedHours: history?.extendedHours === true,
+        }) };
+      }
       if ((source.fieldId === "fundamental.eps" || source.fieldId === "valuation.trailingPE")
         && [...merged.annualStatements, ...merged.quarterlyStatements].some((row) => row.epsBasis)) {
         warnings.push(SEC_EPS_BASIS_NOTICE);
@@ -2233,8 +883,8 @@ async function resolveChartSpecPass(
       // Keep provider history separate from quote-extended display bars. A live
       // mark is not a daily closing observation, including on snapshot replay.
       const historical = history ? { ...merged, priceHistory: history.points } : merged;
-      sources.onSecurityData?.(resolvedSpec, history?.session || realizedVolInputs.has(seriesSpec.id) ? historical : merged, history !== null);
-      const result = baseSecuritySeries(
+      sources.onSecurityData?.(resolvedSpec, history?.session || realizedVolInputs.has(seriesSpec.id) ? historical : sourceBars, history !== null);
+      const base = baseSecuritySeries(
         resolvedSpec,
         merged,
         index,
@@ -2242,7 +892,8 @@ async function resolveChartSpecPass(
         quoteMetadata,
         contractUnit,
       );
-      if (!result) throw new Error(`Unknown field ${source.fieldId}.`);
+      if (!base) throw new Error(`Unknown field ${source.fieldId}.`);
+      const result = builtBars ? withBuiltBarSize(base, builtBars) : base;
       if (marketField && history?.historyStart !== undefined && Number.isFinite(history.historyStart)) {
         result.historyStart = new Date(history.historyStart);
       }
@@ -2273,7 +924,7 @@ async function resolveChartSpecPass(
       return result;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      errors.push(`${seriesSpec.label ?? seriesSpec.id}: ${message}`);
+      errors.push(`${seriesMessageName(seriesSpec)}: ${message}`);
       return unloadableSeries(seriesSpec, index, message);
     }
   }));
@@ -2307,7 +958,8 @@ async function resolveChartSpecPass(
   const commonCadence = servedCadences.size === 1 ? [...servedCadences][0] : undefined;
   const resolution = commonCadence ?? undefined;
   const comparisonResolution = resolution ?? "auto";
-  const priceComparison = resolvePriceComparison(spec, rawSeries, bounds, comparisonResolution, requestBounds ? null : spec.viewport.dateWindow);
+  const priceComparison = resolvePriceComparison(spec, rawSeries, bounds, comparisonResolution, requestBounds ? null : spec.viewport.dateWindow,
+    { preset: hasExplicitWindow ? null : spec.viewport.range, now: referenceNow.getTime() + Math.max(0, Date.now() - resolutionStartedAt) });
   const displayBounds = comparisonDisplayBounds(bounds, priceComparison);
   const comparisonBounds = priceComparison && priceComparison.start !== null
     ? priceComparison : bounds;
@@ -2323,7 +975,8 @@ async function resolveChartSpecPass(
 
   // Study outputs are appended by the pure engine before the final viewport clip.
   if (spec.studies.length > 0) {
-    const studyResult = resolveStudies(calculationSeries, spec.studies, resolution, historicalPriceSeries);
+    const studyResult = resolveStudies(calculationSeries, spec.studies, resolution, historicalPriceSeries,
+      studyAnchors(calculationSeries, priceComparison, comparisonBounds));
     resolved = [
       ...resolved,
       ...applyStudyPresentationTransforms(
@@ -2396,13 +1049,13 @@ async function resolveChartSpecPass(
   }
   for (const panel of spec.panels) {
     if (panel.scale !== "log") continue;
-    const hiddenCount = resolved
-      .filter((entry) => entry.panelId === panel.id)
-      .flatMap((entry) => entry.points)
-      .filter((point) => typeof point.value === "number" && Number.isFinite(point.value) && point.value <= 0)
-      .length;
+    const isHidden = (point: TimeSeriesPoint) => typeof point.value === "number" && Number.isFinite(point.value) && point.value <= 0;
+    const affected = resolved.filter((entry) => entry.panelId === panel.id && entry.points.some(isHidden));
+    const hiddenCount = affected.reduce((total, entry) => total + entry.points.filter(isHidden).length, 0);
     if (hiddenCount > 0) {
-      warnings.push(`${panel.label ?? panel.id}: ${hiddenCount} non-positive observation${hiddenCount === 1 ? " is" : "s are"} hidden on the logarithmic scale.`);
+      // A panel without a title is named by the series it holds, never by its id (`main`).
+      const name = panel.label ?? [...new Set(affected.map((entry) => entry.label))].join(", ");
+      warnings.push(`${name}: ${hiddenCount} non-positive observation${hiddenCount === 1 ? " is" : "s are"} hidden on the logarithmic scale.`);
     }
   }
 
@@ -2431,110 +1084,6 @@ async function resolveChartSpecPass(
     ...(delistings.size ? { delistings: [...delistings.values()] } : {}),
     viewport,
     resolution,
+    ...(builtBarSize && rawSeries.some((entry) => entry.barSize === builtBarSize) ? { barSize: builtBarSize } : {}),
   };
 }
-
-/** Older tails are left to a full history refresh rather than a recent-window request. */
-const MAX_TAIL_RECONCILE_LAG_MS = 3 * DAY_MS;
-
-function latestObservationTime(points: TickerFinancials["priceHistory"]): number {
-  for (let index = points.length - 1; index >= 0; index -= 1) {
-    const point = points[index]!;
-    const time = getPricePointTimestamp(point);
-    if (Number.isFinite(time) && Number.isFinite(point.close)) return time;
-  }
-  return Number.NaN;
-}
-
-function samePricePoints(left: TickerFinancials["priceHistory"], right: TickerFinancials["priceHistory"]): boolean {
-  if (left.length !== right.length) return false;
-  for (let index = left.length - 1; index >= 0; index -= 1) {
-    const a = left[index]!;
-    const b = right[index]!;
-    if (a === b) continue;
-    if (getPricePointTimestamp(a) !== getPricePointTimestamp(b) || a.open !== b.open || a.high !== b.high
-      || a.low !== b.low || a.close !== b.close || a.volume !== b.volume) return false;
-  }
-  return true;
-}
-
-/**
- * Refreshes the newest bars of each intraday history the last resolve plotted
- * up to the present, so bars formed from quotes settle to the provider's
- * version shortly after they close. Only the recent window is requested, and a
- * window from a different source or session contract is never mixed in.
- * Resolves true when any plotted bar changed.
- */
-export function reconcileChartTail(
-  sources: Pick<ChartResolveSources, "dataProvider">,
-  cache: ChartResolveCache,
-  now = Date.now(),
-): Promise<boolean> {
-  if (cache.tailReconcile) return cache.tailReconcile;
-  const provider = sources.dataProvider;
-  if (!provider || cache.liveTails.size === 0
-    || !(provider.getDetailedPriceHistoryWithMetadata || provider.getDetailedPriceHistory)) {
-    return Promise.resolve(false);
-  }
-  const run: Promise<boolean> = Promise.all([...cache.liveTails].map(async ([key, tail]) => {
-    const pending = cache.priceHistoryByRequest.get(key);
-    const loaded = pending ? await pending.catch(() => {
-      // Intentional ignore: resolveChartSpecPass already includes this history failure in the series errors.
-      return null;
-    }) : null;
-    if (!pending || !loaded || loaded.resolution !== tail.resolution) return false;
-    const accumulated = cache.accumulatedPriceHistory.get(tail.accumulationKey);
-    const latest = latestObservationTime(accumulated?.points ?? loaded.points);
-    if (!Number.isFinite(latest) || now - latest > MAX_TAIL_RECONCILE_LAG_MS) return false;
-    // The newest loaded bar may still have been forming when it was fetched.
-    // Whole-bar starts and whole-minute ends let every chart of this history
-    // that asks at the same boundary share one request and one cached window.
-    const step = CHART_RESOLUTION_STEP_MS[tail.resolution];
-    const start = Math.floor((latest - step) / step) * step;
-    const end = Math.ceil(now / 60_000) * 60_000;
-    const { symbol, exchange } = tail.source.instrument;
-    const context = { ...requestContext(tail.source), ...(tail.historySession ? { historySession: tail.historySession } : {}) };
-    const requestKey = JSON.stringify([symbol, exchange ?? "", context.brokerId ?? null,
-      context.brokerInstanceId ?? null, context.instrument ?? null, tail.resolution, start, end, tail.historySession ?? null]);
-    const shared = tailRequestsInFlight.get(provider) ?? new Map<string, Promise<PriceHistoryResult | null>>();
-    tailRequestsInFlight.set(provider, shared);
-    let request = shared.get(requestKey);
-    if (!request) {
-      const fetched = fetchHistoryResult(provider, symbol, exchange ?? "",
-        { kind: "detail", start: new Date(start), end: new Date(end), interval: tail.resolution }, context)
-        .catch(logFailure("time-series-resolve", "Could not reconcile chart history", null))
-        .finally(() => {
-          if (shared.get(requestKey) === fetched) shared.delete(requestKey);
-        });
-      shared.set(requestKey, fetched);
-      request = fetched;
-    }
-    const result = await request;
-    if (!result || result.resolution !== loaded.resolution || !!result.extendedHours !== !!loaded.extendedHours
-      || priceHistoryAcquisitionIdentity(result) !== priceHistoryAcquisitionIdentity(loaded)) return false;
-    const points = result.points.filter((point) => {
-      const time = getPricePointTimestamp(point);
-      return Number.isFinite(time) && time >= start && Number.isFinite(point.close);
-    });
-    // A full refetch that landed meanwhile supersedes this window.
-    if (points.length === 0 || cache.priceHistoryByRequest.get(key) !== pending) return false;
-    const refreshed = mergePriceHistoryWindows(loaded.points, points, tail.resolution);
-    if (samePricePoints(refreshed, loaded.points)) return false;
-    const acquisition = priceHistoryTailAcquisition(loaded, result);
-    // The merged bars are as current as the newer acquisition says.
-    cache.priceHistoryByRequest.set(key, Promise.resolve({ ...loaded, points: refreshed,
-      session: acquisition.session, sourceKey: acquisition.sourceKey, savedCopyBehind: acquisition.savedCopyBehind }));
-    if (accumulated) {
-      const accumulatedAcquisition = priceHistoryTailAcquisition(accumulated, result);
-      cache.accumulatedPriceHistory.set(tail.accumulationKey, { ...accumulated,
-        points: mergePriceHistoryWindows(accumulated.points, points, tail.resolution),
-        session: accumulatedAcquisition.session, sourceKey: accumulatedAcquisition.sourceKey });
-    }
-    cache.revision += 1;
-    return true;
-  })).then((changes) => changes.some(Boolean)).finally(() => {
-    if (cache.tailReconcile === run) cache.tailReconcile = null;
-  });
-  cache.tailReconcile = run;
-  return run;
-}