@wick-charts/vue 0.8.0 → 0.8.2

package/dist/core/dist/chart.js

@@ -1,100 +1,117 @@
-import { Animator as nt } from "./animation/animator.js";
-import { AnimationConfig as at, DEFAULT_LINE_PULSE as ot } from "./animation/config.js";
-import { easeOutCubic as W } from "./animation/easing.js";
-import { prefersReducedMotion as ht } from "./animation/reduced-motion.js";
-import { createViewportEngine as lt } from "./animation/viewport-engine.js";
-import { CanvasManager as ct } from "./canvas-manager.js";
-import { resolveEdgeAnchorValue as dt, drawEdgeIndicators as ut, resolveEdgeBoundary as mt } from "./chart/edge-indicators.js";
-import { computeFitToData as ft } from "./chart/fit-to-data.js";
-import { getLastValue as gt, getPreviousClose as pt, getStackedLastValue as yt } from "./chart/last-value.js";
-import { resolveFade as Y, resolveMaxVisibleBars as xt, resolvePadding as E, resolvePerfOptions as vt, isSameHorizontalPadding as B } from "./chart/options.js";
-import { computePan as St, computeZoom as bt } from "./chart/pan-zoom-math.js";
-import { warnUnplottableBounds as C, assertStackingFitsScale as L, warnScaleSideTaken as kt, warnUnknownScale as wt, warnStackingOffScale as Tt, warnUnplottableValues as At } from "./chart/scale-guards.js";
-import { StreamingCadence as Mt } from "./chart/streaming-cadence.js";
-import { computeStreamingTarget as Pt } from "./chart/streaming-target.js";
-import { resolvePaddingTime as N } from "./chart/viewport-padding.js";
-import { assertSeriesFitsXAxis as Ct, warnXMisfit as Lt, warnXTimeMixed as Dt, warnTimeOnlyFeature as Rt, warnXTypeChange as It } from "./chart/x-guards.js";
-import { fromScaleSpace as Ht, computeTargetYRange as Vt, resolveYTarget as zt } from "./chart/y-target.js";
-import { renderCrosshair as Ft } from "./components/crosshair.js";
-import { renderGrid as X } from "./components/grid.js";
-import { renderMarker as Ot } from "./components/marker.js";
-import { renderReferenceLine as $t } from "./components/reference-line.js";
-import { resolveTimeRegionColors as Wt, renderTimeRegion as Yt } from "./components/time-region.js";
-import { EventEmitter as Et } from "./events.js";
-import { InteractionHandler as Bt } from "./interactions/handler.js";
-import { RenderScheduler as Z } from "./render-scheduler.js";
-import { XScale as Nt } from "./scales/x-scale.js";
-import { YScale as U, isPlottableOn as _ } from "./scales/y-scale.js";
-import { resolveSeriesDefinition as Xt } from "./series/definition.js";
-import { isTimeSeriesRenderer as v } from "./series/types.js";
-import { catppuccin as Zt } from "./theme/themes/catppuccin.js";
-import { deepEqual as Ut } from "./utils/deep-equal.js";
-import { clamp as _t } from "./utils/math.js";
-import { crispLineWidth as Gt, crispCenterOffset as Kt } from "./utils/pixel-grid.js";
-import { pointValue as G, isBandPoint as jt } from "./utils/point.js";
-import { normalizeTime as k, detectInterval as qt } from "./utils/time.js";
-const Jt = 200, Qt = 1500, te = 48, K = 12, D = 9, ee = ["left", "right"], ie = { entries: [], isAnimating: !1 }, se = [], re = ["left"], ne = ["right"], ae = 55;
-function j(p, t) {
+import { Animator as gt } from "./animation/animator.js";
+import { AnimationConfig as pt, DEFAULT_LINE_PULSE as yt } from "./animation/config.js";
+import { easeOutCubic as X } from "./animation/easing.js";
+import { prefersReducedMotion as xt } from "./animation/reduced-motion.js";
+import { createViewportEngine as vt } from "./animation/viewport-engine.js";
+import { CanvasManager as St } from "./canvas-manager.js";
+import { resolveEdgeAnchorValue as bt, drawEdgeIndicators as kt, resolveEdgeBoundary as Tt } from "./chart/edge-indicators.js";
+import { computeFitToData as Z } from "./chart/fit-to-data.js";
+import { getLastValue as wt, getPreviousClose as Mt, getStackedLastValue as At } from "./chart/last-value.js";
+import { resolveFade as _, resolveMaxVisibleBars as Pt, resolvePadding as U, resolvePerfOptions as Ct, isSameHorizontalPadding as G } from "./chart/options.js";
+import { computePan as Lt, computeZoom as It } from "./chart/pan-zoom-math.js";
+import { warnUnplottableBounds as D, assertStackingFitsScale as R, warnScaleSideTaken as Dt, warnUnknownScale as Rt, warnStackingOffScale as Vt, warnUnplottableValues as Ht } from "./chart/scale-guards.js";
+import { StreamingCadence as Nt } from "./chart/streaming-cadence.js";
+import { computeStreamingTarget as Ft } from "./chart/streaming-target.js";
+import { resolvePaddingTime as j } from "./chart/viewport-padding.js";
+import { assertSeriesFitsXAxis as Wt, warnXMisfit as $t, warnXTimeMixed as zt, warnTimeOnlyFeature as Ot, warnXTypeChange as Yt } from "./chart/x-guards.js";
+import { fromScaleSpace as Et, computeTargetYRange as Bt, resolveYTarget as Xt, widenFlatRange as Zt } from "./chart/y-target.js";
+import { renderCrosshair as _t } from "./components/crosshair.js";
+import { renderGrid as K } from "./components/grid.js";
+import { renderMarker as Ut } from "./components/marker.js";
+import { renderReferenceLine as Gt } from "./components/reference-line.js";
+import { resolveTimeRegionColors as jt, renderTimeRegion as Kt } from "./components/time-region.js";
+import { EventEmitter as qt } from "./events.js";
+import { InteractionHandler as Jt } from "./interactions/handler.js";
+import { RenderScheduler as q } from "./render-scheduler.js";
+import { XScale as Qt } from "./scales/x-scale.js";
+import { YScale as J, isPlottableOn as Q } from "./scales/y-scale.js";
+import { resolveSeriesDefinition as te } from "./series/definition.js";
+import { isTimeSeriesRenderer as S } from "./series/types.js";
+import { catppuccin as ee } from "./theme/themes/catppuccin.js";
+import { deepEqual as ie } from "./utils/deep-equal.js";
+import { clamp as se } from "./utils/math.js";
+import { crispLineWidth as re, crispCenterOffset as ne } from "./utils/pixel-grid.js";
+import { pointValue as tt, isBandPoint as ae } from "./utils/point.js";
+import { normalizeTime as k, detectInterval as V } from "./utils/time.js";
+const oe = 200, he = 1500, le = 48, et = 12, H = 9, ce = ["left", "right"], de = { entries: [], isAnimating: !1 }, ue = [], me = ["left"], fe = ["right"], ge = 55, it = 2e3, st = 20;
+function A(d) {
+  return Number.isInteger(d) && d >= 2;
+}
+function pe(d) {
+  if (typeof d == "number") return A(d) ? d : void 0;
+  if (!(d !== void 0 && "bars" in d && !A(d.bars)))
+    return d;
+}
+function ye(d) {
+  return typeof d == "object" && "to" in d;
+}
+function rt(d, t) {
   return {
-    yScale: p,
+    yScale: d,
     bounds: { min: t?.min, max: t?.max },
     range: { min: 0, max: 0 },
     prevMin: Number.NaN,
-    prevMax: Number.NaN
+    prevMax: Number.NaN,
+    paintedMin: Number.NaN,
+    paintedMax: Number.NaN
   };
 }
-function q(p) {
-  return p === "left" ? "right" : "left";
+function nt(d) {
+  const t = d.range.min !== d.paintedMin || d.range.max !== d.paintedMax;
+  return d.paintedMin = d.range.min, d.paintedMax = d.range.max, t;
+}
+function at(d) {
+  return d === "left" ? "right" : "left";
 }
-function J(p, t) {
-  return p === void 0 || p === "auto" ? !1 : !(typeof p == "number" && !t.isPlottable(p));
+function ot(d, t) {
+  return d === void 0 || d === "auto" ? !1 : !(typeof d == "number" && !t.isPlottable(d));
 }
-let oe = 0, he = 0, le = 0, ce = 0;
-function Q(p, t) {
-  return p === t ? !0 : !p || !t || p.length !== t.length ? !1 : p.every((e, i) => e === t[i]);
+let xe = 0, ve = 0, Se = 0, be = 0;
+function ht(d, t) {
+  return d === t ? !0 : !d || !t || d.length !== t.length ? !1 : d.every((e, i) => e === t[i]);
 }
-function tt(p) {
-  return v(p) ? p.stacking : void 0;
+function lt(d) {
+  return S(d) ? d.stacking : void 0;
 }
-function de(p, t) {
-  return p === t ? !0 : !p || !t || p.length !== t.length ? !1 : p.every((e, i) => e === t[i]);
+function ke(d, t) {
+  return d === t ? !0 : !d || !t || d.length !== t.length ? !1 : d.every((e, i) => e === t[i]);
 }
-class _e extends Et {
+class ri extends qt {
   /** Canvas lifecycle and DPR-aware sizing. */
-  #l;
+  #c;
   /** Schedules main-layer redraws (background, grid, series). */
   #i;
   /** Schedules overlay redraws (crosshair). */
-  #c;
+  #d;
   /** Maps time values to horizontal pixel coordinates. */
   timeScale;
   /** Maps price/value to vertical pixel coordinates — the default Y scale. */
   yScale;
   /** Default-scale Y state; `yScale` is its scale. */
-  #P;
+  #w;
   /** Named Y scales from `options.scales`, in declaration order. */
-  #a = /* @__PURE__ */ new Map();
+  #o = /* @__PURE__ */ new Map();
   /** Copy of the `scales` option as last applied — `setScales` skips a deep-equal replay,
    *  and the copy keeps an in-place edit of the caller's object from comparing equal. */
-  #At = {};
+  #It = {};
   /** Set when a named scale's range moved, so the crosshair re-emits for its axis label. */
-  #nt = !1;
+  #ot = !1;
   /** Keys of dev warnings already printed, so each fires once. */
-  #Mt = /* @__PURE__ */ new Set();
+  #Dt = /* @__PURE__ */ new Set();
   /** What the X axis maps — read from `axis.x.type` once, at construction. */
-  #r;
+  #n;
   /** Category axis: name → band index, in first-seen order across the series. */
-  #Y = /* @__PURE__ */ new Map();
+  #O = /* @__PURE__ */ new Map();
   /** Zoom, pan, crosshair — null when interactive=false. */
-  #V;
+  #N;
   /** All registered series (candlestick, line, bar, pie). */
   #t = [];
   /** Point annotations (event markers) drawn on the overlay layer, kept out of the series model. */
   #y = [];
   /** Time-region bands drawn on the main layer behind the series, kept out of the series model. */
-  #T = [];
+  #M = [];
   /** Reference lines (horizontal threshold / vertical event) drawn on the overlay layer, kept out of the series model. */
-  #b = [];
+  #S = [];
   /**
    * Overlay-intro latch. Annotations ride the *initial* reveal, then stay put.
    * `#overlayIntroSeen` flips once we've actually watched an intro in progress
@@ -103,29 +120,31 @@ class _e extends Et {
    * later — which re-arms `getIntroFront()`'s global min — can't blink settled
    * markers / reference lines back out.
    */
-  #Pt = !1;
-  #Ct = !1;
+  #Rt = !1;
+  #Vt = !1;
   /** Active visual theme (colors, fonts, grid style). */
-  #n;
+  #h;
   /** Whether to render the background grid. */
-  #G;
+  #j;
   /**
    * Gridline layer opacity, multiplied into every per-tick fade: `0 → 1` on
    * the opening reveal, `1 → 0` when {@link setGrid} hides the grid. The
    * per-tick fades stay snapped during mount (see the tracker's arming), so
    * this is what keeps `fitToData` tick churn from flickering the reveal.
    */
-  #E;
+  #Y;
+  /** Whether a tick fade ran on the last main frame — the frame it settles on still owes the DOM labels a sync. */
+  #Ht = !1;
   /** Resolved edge-fade zones — a `null` side is auto: the axis-column ramp on the Y-axis side, off on the other. */
   #C;
   /** See {@link headerHeight}. */
-  #at = 0;
+  #ht = 0;
   /** Memoized destination-out mask gradients, one per edge, keyed by the
    *  zone's bitmap geometry so a resize / DPR change / `setFade` rebuilds
    *  them and steady frames reuse them. */
-  #k = { top: null, axis: { left: null, right: null }, edge: { left: null, right: null }, tail: null, overhang: null };
+  #b = { top: null, axis: { left: null, right: null }, edge: { left: null, right: null }, tail: null, overhang: null };
   /** Detected time interval between data points (milliseconds). */
-  #o = 6e4;
+  #r = 6e4;
   /** Current crosshair position, null when cursor is outside the chart. */
   #f = null;
   /**
@@ -135,12 +154,12 @@ class _e extends Et {
    * `time`/`y`; `'time'` (programmatic {@link setCrosshair}) keeps
    * `time`/`y` and re-projects the pixel position.
    */
-  #ot = "pointer";
+  #lt = "pointer";
   /** Whether the last overlay pass painted anything — gates the full-bitmap
    *  clear so an empty overlay isn't cleared again every main frame. */
-  #Lt = !1;
+  #Nt = !1;
   /** Cached series ID list — invalidated on add/remove. */
-  #z = null;
+  #F = null;
   /** Axis visibility and sizing configuration. */
   #v = {};
   /** Host-declared state per edge — drives the edge-indicator overlay. */
@@ -151,27 +170,27 @@ class _e extends Et {
    *  fetched data lands. `null` = no fade in flight. */
   #K = { left: null, right: null };
   /** Cached boundary timestamps from the last `edgeReached` emission, by side. */
-  #Dt = { left: null, right: null };
+  #Ft = { left: null, right: null };
   /** Latest placeholder shapes a `loading` indicator reported per side —
    *  the morph hand-off candidate consumed by {@link prependData}. */
-  #ht = { left: null, right: null };
+  #ct = { left: null, right: null };
   /** True after a prepend consumed a side's placeholder snapshot: the series'
    *  reveal owns those pixels now, so the still-`loading` indicator is hidden
    *  and the upcoming `loading → idle` transition skips its exit fade. Reset
    *  by the next {@link setEdgeState} call. */
-  #B = { left: !1, right: !1 };
+  #E = { left: !1, right: !1 };
   /** Host-supplied callback fired when the user releases a pan/zoom past a data edge. */
-  #Rt;
+  #Wt;
   /** Per-side custom painter for the edge `loading` spinner. `null` falls back to the built-in dots. */
-  #It = { left: null, right: null };
+  #$t = { left: null, right: null };
   /** Nesting depth for batch updates. Suppresses recomputes while > 0. */
   #R = 0;
   /** True when batched operations include data changes (triggers full onDataChanged on end). */
-  #lt = !1;
+  #dt = !1;
   /** True when batched operations include visibility changes (triggers Y-range + redraw on end). */
-  #N = !1;
+  #B = !1;
   /** True when batched operations bumped overlay version (emits a single overlayChange on flush). */
-  #ct = !1;
+  #ut = !1;
   /**
    * Monotonic counter bumped on any mutation that affects overlay output —
    * data, visibility, series options, theme. Used by snapshot helpers in
@@ -181,10 +200,13 @@ class _e extends Et {
    *
    * @internal
    */
-  #Ht = 0;
+  #mt = 0;
+  /** Main frames that moved a series' animated values; see `seriesFrame`. */
+  #zt = 0;
+  #Ot = !1;
   /** CSS px of the default Y-axis column. The default collapses to `0` on a spatial-only chart. */
   get yAxisWidth() {
-    return this.#j(this.#v.y);
+    return this.#q(this.#v.y);
   }
   /** Side of the plot area the default Y-axis column sits on. */
   get yAxisPosition() {
@@ -204,33 +226,33 @@ class _e extends Et {
    */
   getAxisColumnWidth(t) {
     if (t === this.yAxisPosition && this.yAxisWidth > 0) return this.yAxisWidth;
-    for (const e of this.#a.values())
-      if (e.column === t) return this.#j(e.config);
+    for (const e of this.#o.values())
+      if (e.column === t) return this.#q(e.config);
     return 0;
   }
   /** The named scale whose axis column sits on `side`, `null` when the default axis's does or none. */
   getAxisColumnScale(t) {
-    for (const [e, i] of this.#a)
+    for (const [e, i] of this.#o)
       if (i.column === t) return e;
     return null;
   }
   /** Both Y-axis columns together — the plot area is the canvas width minus this. */
-  #w() {
+  #k() {
     return this.getAxisColumnWidth("left") + this.getAxisColumnWidth("right");
   }
   /** Column width a Y-axis config asks for; `0` when hidden, and by default on a spatial-only chart. */
-  #j(t) {
-    return t?.visible === !1 ? 0 : t?.width !== void 0 ? t.width : this.#Q() ? 0 : ae;
+  #q(t) {
+    return t?.visible === !1 ? 0 : t?.width !== void 0 ? t.width : this.#it() ? 0 : ge;
   }
   /** CSS px height of the floating Title / InfoBar header, `0` without one. A left
    *  axis shares its column with it, so tick labels fade out underneath. */
   get headerHeight() {
-    return this.#at;
+    return this.#ht;
   }
   /** CSS px of the time-axis row. The default collapses to `0` on a spatial-only chart. */
   get xAxisHeight() {
     const t = this.#v.x;
-    return t?.visible === !1 ? 0 : t?.height !== void 0 ? t.height : this.#Q() ? 0 : 30;
+    return t?.visible === !1 ? 0 : t?.height !== void 0 ? t.height : this.#it() ? 0 : 30;
   }
   /** Resolved animation config derived from `options.animations` at construction. */
   #g;
@@ -248,7 +270,7 @@ class _e extends Et {
    *  longer than the producer's tick interval — the spring never quite
    *  settles between ticks, so velocity carries continuously and the slide
    *  doesn't pulse. */
-  #F;
+  #W;
   /**
    * Mirrors `#dataReplaceSnapPending` for the engine signal that follows
    * inside the same `onDataChanged` call. `#dataReplaceSnapPending` is
@@ -258,9 +280,9 @@ class _e extends Et {
    * field carries the decision across that gap. The closure also reads
    * `#dataStart` / `#dataEnd` directly for the timestamps.
    */
-  #Vt = !1;
+  #Yt = !1;
   /** Earliest data timestamp registered across all series, `null` before any data has arrived. */
-  #S = null;
+  #T = null;
   /** Latest data timestamp registered across all series, `null` before any data has arrived. */
   #s = null;
   /**
@@ -269,7 +291,7 @@ class _e extends Et {
    * left of the tail keeps that offset as new bars arrive, instead of
    * snapping back to the natural-pin position every frame.
    */
-  #q = null;
+  #J = null;
   /**
    * Warm-up window flag — `setVisibleRange({ from, bars })` arms it and
    * the streaming-target math suppresses pan ticks while the data hasn't
@@ -282,14 +304,14 @@ class _e extends Et {
    * the right edge and trims the left. Resolved once at construction from
    * `options.viewport.maxVisibleBars`.
    */
-  #zt;
+  #ft;
   /**
    * Committed logical X range — the "where X should be" target. Engine
    * eases its visual toward this. Pan / zoom / setRange / fitContent /
    * streaming-target writes go here. Initialized to `{0,0}` and treated
    * as "uninitialized" by `#computeXTarget` until first paint.
    */
-  #h = { from: 0, to: 0 };
+  #a = { from: 0, to: 0 };
   /**
    * Auto-scroll flag — when `true`, streaming ticks slide X to track the
    * data tail. Pan flips this off when the gesture pushes the tail off
@@ -298,20 +320,22 @@ class _e extends Et {
    */
   #p = !0;
   /** Resolved viewport padding (top/bottom px + left/right pixels-or-intervals). */
-  #d;
+  #l;
   /** Cached chart width — passed by interactions on every call; kept for the rare
    *  call that omits it (e.g. programmatic `chart.pan(...)` without explicit width). */
-  #J = 0;
+  #Q = 0;
+  /** X range the last main paint drew. */
+  #tt = { from: Number.NaN, to: Number.NaN };
   /** Active performance monitor, or `null` when instrumentation is disabled (the default). */
-  #M;
+  #P;
   /** When true, `destroy()` tears down the monitor; false for caller-supplied monitors we must not destroy. */
-  #dt = !1;
+  #gt = !1;
   /** Visible HUD overlay (mounted by the perf config); non-null only when the caller requested one. */
-  #ut = null;
+  #pt = null;
   constructor(t, e) {
-    super(), e?.axis && (this.#v = e.axis), this.#r = this.#v.x?.type ?? "time", this.#n = e?.theme ?? Zt.theme, this.#G = e?.grid?.visible !== !1, this.#C = Y(e?.fade), this.#g = at.resolve(e?.animations), this.#zt = xt(e?.viewport?.maxVisibleBars), this.#d = E(e?.padding), this.#F = new Mt();
+    super(), e?.axis && (this.#v = e.axis), this.#n = this.#v.x?.type ?? "time", this.#h = e?.theme ?? ee.theme, this.#j = e?.grid?.visible !== !1, this.#C = _(e?.fade), this.#g = pt.resolve(e?.animations), this.#ft = Pt(e?.viewport?.maxVisibleBars), this.#l = U(e?.padding), this.#W = new Nt();
     const i = this.#g.axis.y, s = this.#g.axis.x;
-    this.#e = lt({
+    this.#e = vt({
       initial: { yRange: { min: 0, max: 0 }, xRange: { from: 0, to: 0 } },
       y: {
         curve: i.curve,
@@ -326,36 +350,36 @@ class _e extends Et {
         settleMs: s.settleMs,
         gestureMs: s.gestureMs
       },
-      computeXTarget: () => this.#we(),
-      computeYTarget: ({ xTarget: o, scale: h }) => this.#_(o, h),
+      computeXTarget: () => this.#Ne(),
+      computeYTarget: ({ xTarget: o, scale: h }) => this.#G(o, h),
       onWake: () => this.#i?.markDirty()
-    }), e?.onEdgeReached && this.checkTimeOnlyFeature("onEdgeReached") && (this.#Rt = e.onEdgeReached), this.#it = e?.viewport?.initialRange;
-    const r = vt(e?.perf);
-    this.#M = r.monitor, this.#dt = r.ownsMonitor, this.#l = new ct(t, this.#M ?? void 0), this.timeScale = new Nt(), this.timeScale.setType(this.#r), this.timeScale.setBandPadding(this.#v.x?.padding), this.yScale = new U(), this.#P = j(this.yScale, this.#v.y), this.yScale.setTransform(this.#v.y?.scale ?? null), C({ y: this.#v.y, isPlottable: this.#gt(void 0) }), this.timeScale.setLocale(e?.locale), this.timeScale.setTimeZone(e?.timeZone);
+    }), e?.onEdgeReached && this.checkTimeOnlyFeature("onEdgeReached") && (this.#Wt = e.onEdgeReached), this.#H = pe(e?.viewport?.initialRange);
+    const r = Ct(e?.perf);
+    this.#P = r.monitor, this.#gt = r.ownsMonitor, this.#c = new St(t, this.#P ?? void 0), this.timeScale = new Qt(), this.timeScale.setType(this.#n), this.timeScale.setBandPadding(this.#v.x?.padding), this.yScale = new J(), this.#w = rt(this.yScale, this.#v.y), this.yScale.setTransform(this.#v.y?.scale ?? null), D({ y: this.#v.y, isPlottable: this.#vt(void 0) }), this.timeScale.setLocale(e?.locale), this.timeScale.setTimeZone(e?.timeZone);
     const n = this.#g.axis.ticksMs;
-    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#Xt(e?.scales ?? {}), this.#St(), this.#E = new nt({
+    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#qt(e?.scales ?? {}), this.#wt(), this.#Y = new gt({
       initial: 0,
       duration: this.#g.axis.gridMs,
       lerp: (o, h, l) => o + (h - o) * l
-    }), this.#i = new Z((o) => this.#wt(o)), this.#c = new Z(
-      (o) => this.#Tt("overlay", o, () => this.renderOverlay(o))
-    ), this.#M && r.hud && (this.#ut = r.hud(t, this.#M));
+    }), this.#i = new q((o) => this.#Ct(o)), this.#d = new q(
+      (o) => this.#Lt("overlay", o, () => this.renderOverlay(o))
+    ), this.#P && r.hud && (this.#pt = r.hud(t, this.#P));
     const a = e?.interactive !== !1;
-    this.#V = a ? new Bt(this.#l.canvas, this, this.timeScale, this.yScale) : null, this.#l.on("resize", () => {
-      this.syncScales(), this.#wt(), this.emit("viewportChange");
-    }), this.syncScales(), this.#V?.on("crosshairMove", (o) => {
-      const h = o === null ? null : this.#mt(o);
-      this.#ot = "pointer", this.#f = h, this.#c.markDirty(), this.emit("crosshairMove", h), this.#bt(h);
-    }), this.#V?.on("click", (o) => {
-      const h = this.#mt(o);
-      this.emit("pointClick", { ...h, spatialHit: this.#Ut(h) });
-    }), this.#V?.on("dblclick", (o) => {
-      const h = this.#mt(o);
-      this.fitContent(), this.emit("pointDoubleClick", { ...h, spatialHit: this.#Ut(h) });
+    this.#N = a ? new Jt(this.#c.canvas, this, this.timeScale, this.yScale) : null, this.#c.on("resize", () => {
+      this.syncScales(), this.#Ct(), this.emit("viewportChange");
+    }), this.syncScales(), this.#N?.on("crosshairMove", (o) => {
+      const h = o === null ? null : this.#yt(o);
+      this.#lt = "pointer", this.#f = h, this.#d.markDirty(), this.emit("crosshairMove", h), this.#Mt(h);
+    }), this.#N?.on("click", (o) => {
+      const h = this.#yt(o);
+      this.emit("pointClick", { ...h, spatialHit: this.#Qt(h) });
+    }), this.#N?.on("dblclick", (o) => {
+      const h = this.#yt(o);
+      this.fitContent(), this.emit("pointDoubleClick", { ...h, spatialHit: this.#Qt(h) });
     });
   }
   /** A pointer position on a category axis snaps to the nearest band; `x` is the coordinate in the axis domain. */
-  #mt(t) {
+  #yt(t) {
     const e = this.timeScale.snapToBand(t.time);
     return { ...t, time: e, x: this.timeScale.domainValue(e) };
   }
@@ -371,9 +395,9 @@ class _e extends Et {
    * `setSeriesVisible` / `setLayerVisible` calls — produce one overlay
    * render instead of N.
    */
-  #u() {
-    if (this.#Ht++, this.#R > 0) {
-      this.#ct = !0;
+  #m() {
+    if (this.#mt++, this.#R > 0) {
+      this.#ut = !0;
       return;
     }
     this.emit("overlayChange");
@@ -387,59 +411,86 @@ class _e extends Et {
    * @internal
    */
   getOverlayVersion() {
-    return this.#Ht;
+    return this.#mt;
+  }
+  /**
+   * {@link getOverlayVersion} that also advances on every `seriesFrame`: the
+   * snapshot helpers key their cache on it, since a snapshot reads the
+   * animated values a frame moves.
+   *
+   * @internal
+   */
+  getSnapshotVersion() {
+    return this.#mt + this.#zt;
   }
   /**
    * Return a series ID: use the provided hint if it's non-empty and not already taken,
    * otherwise generate a new auto ID. Auto-generated IDs never collide with each other
    * or with user-provided IDs because they use a monotonically increasing counter.
    */
-  #ne(t) {
+  #ge(t) {
     if (t && !this.#t.some((i) => i.id === t))
       return t;
     let e;
     do
-      e = `series_${++oe}`;
+      e = `series_${++xe}`;
     while (this.#t.some((i) => i.id === e));
     return e;
   }
   addSeries(t, e = {}) {
-    const i = typeof t == "string" ? Xt(t) : t;
+    const i = typeof t == "string" ? te(t) : t;
     if (!i)
       throw new Error(
         `[wick-charts] Unknown series type '${String(t)}'. The string form of addSeries resolves through the series registry — call registerBuiltinSeries() once at startup, or pass the definition directly: chart.addSeries(LineSeriesDef, options).`
       );
     const { layers: s, id: r, label: n, labels: a, scale: o, ...h } = e, l = s ?? 1;
-    o === void 0 && L({
+    o === void 0 && R({
       seriesId: r ?? i.type,
       stacking: h.stacking,
-      isPlottable: this.#gt(o)
+      isPlottable: this.#vt(o)
     });
-    const d = {
+    const c = {
       ...this.#g.defaults(i.type),
       ...h,
       ...this.#g.overrides(i.type)
-    }, f = i.create({ theme: this.#n, layerCount: l }, d);
-    v(f) && Ct({ seriesType: i.type, axisType: this.#r, supported: i.xTypes ?? ["time"] });
-    const c = a ?? (typeof n == "string" ? [n] : void 0), m = this.#ne(r);
-    f.onDataChanged?.(() => this.onDataChanged());
-    const y = this.#Z();
+    }, f = this.#pe({ type: i.type, count: l }), g = i.create({ theme: this.#h, layerCount: l, paletteIndex: f }, c);
+    S(g) && Wt({ seriesType: i.type, axisType: this.#n, supported: i.xTypes ?? ["time"] });
+    const y = a ?? (typeof n == "string" ? [n] : void 0), u = this.#ge(r);
+    g.onDataChanged?.(() => this.onDataChanged());
+    const m = this.#Z();
     return this.#t.push({
-      id: m,
-      labels: c,
-      renderer: f,
+      id: u,
+      labels: y,
+      renderer: g,
       visible: !0,
       scale: o,
       xKeys: { x: !1, time: !1 },
-      categoryPoints: []
-    }), this.#z = null, this.#et(), this.#tt(y), this.emit("seriesChange"), this.#u(), m;
+      categoryPoints: [],
+      palette: { type: i.type, start: f, count: l }
+    }), this.#F = null, this.#rt(), this.#st(m), this.emit("seriesChange"), this.#m(), u;
+  }
+  /** The lowest run of `count` palette slots that no other series of `type` holds. */
+  #pe(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const r of this.#t)
+      if (r.palette.type === t.type)
+        for (let n = 0; n < r.palette.count; n++)
+          e.add(r.palette.start + n);
+    const i = (r) => {
+      for (let n = r; n < r + t.count; n++)
+        if (e.has(n)) return !0;
+      return !1;
+    };
+    let s = 0;
+    for (; i(s); ) s++;
+    return s;
   }
   /** Remove a series by ID and clean up its resources. */
   removeSeries(t) {
     const e = this.#t.findIndex((i) => i.id === t);
     if (e >= 0) {
       const i = this.#Z();
-      this.#t[e].renderer.dispose(), this.#t.splice(e, 1), this.#z = null, this.#r === "category" && this.#Bt(), this.#et(), this.#tt(i), this.#i.markDirty(), this.emit("seriesChange"), this.#u();
+      this.#t[e].renderer.dispose(), this.#t.splice(e, 1), this.#F = null, this.#n === "category" && this.#Gt(), this.#rt(), this.#st(i), this.#i.markDirty(), this.emit("seriesChange"), this.#m();
     }
   }
   // --- Markers (point annotations) -----------------------------------------
@@ -453,24 +504,24 @@ class _e extends Et {
    * appear in series queries.
    */
   addMarker(t) {
-    const e = `marker_${++he}`;
-    return this.#y.push(this.#Ft(e, t)), this.#c.markDirty(), e;
+    const e = `marker_${++ve}`;
+    return this.#y.push(this.#Et(e, t)), this.#d.markDirty(), e;
   }
   /** Replace a marker's config in place. No-op when the id is unknown. */
   updateMarker(t, e) {
     const i = this.#y.findIndex((s) => s.id === t);
-    i !== -1 && (this.#y[i] = this.#Ft(t, e), this.#c.markDirty());
+    i !== -1 && (this.#y[i] = this.#Et(t, e), this.#d.markDirty());
   }
   /** Remove a marker by id. No-op when the id is unknown. */
   removeMarker(t) {
     const e = this.#y.findIndex((i) => i.id === t);
-    e !== -1 && (this.#y.splice(e, 1), this.#c.markDirty());
+    e !== -1 && (this.#y.splice(e, 1), this.#d.markDirty());
   }
   /** Read-only snapshot of the registered markers (normalized). Mutate via add / update / removeMarker. */
   getMarkers() {
     return this.#y;
   }
-  #Ft(t, e) {
+  #Et(t, e) {
     return {
       id: t,
       time: k(e.time),
@@ -484,43 +535,43 @@ class _e extends Et {
     };
   }
   /** The scale a marker's value maps through: its own `scale`, else its series' scale. */
-  #ae(t) {
+  #ye(t) {
     return t.scale !== void 0 || t.seriesId === void 0 ? this.getYScale(t.scale) : this.getYScale(this.getSeriesScale(t.seriesId));
   }
   /** Resolve a marker's Y value: explicit `value`, else snapped to its series at `time`. Null when neither resolves. */
-  #oe(t) {
+  #xe(t) {
     if (t.value !== void 0 && Number.isFinite(t.value)) return t.value;
     if (t.seriesId === void 0) return null;
     const e = this.getDataAtTime(t.seriesId, t.time);
-    return e ? G(e) : null;
+    return e ? tt(e) : null;
   }
   /** Resolve a marker's color: explicit `color`, else the series color, else the theme line color. */
-  #he(t) {
+  #ve(t) {
     if (t.color !== void 0) return t.color;
     if (t.seriesId !== void 0) {
       const e = this.getSeriesColor(t.seriesId);
       if (e !== null) return e;
     }
-    return this.#n.line.color;
+    return this.#h.line.color;
   }
-  #le(t, e, i) {
+  #Se(t, e, i) {
     if (this.#y.length === 0) return;
-    const s = performance.now() / (ot * 2 * Math.PI) % 1, r = this.#pt();
+    const s = performance.now() / (yt * 2 * Math.PI) % 1, r = this.#St();
     for (const n of this.#y) {
-      const a = this.#oe(n);
+      const a = this.#xe(n);
       if (a === null) continue;
-      const o = this.#Yt(r, n.time);
+      const o = this.#_t(r, n.time);
       if (o <= 0) continue;
       const h = t.context.globalAlpha;
-      o < 1 && (t.context.globalAlpha = h * o), Ot({
+      o < 1 && (t.context.globalAlpha = h * o), Ut({
         scope: t,
         timeScale: this.timeScale,
-        yScale: this.#ae(n),
-        theme: this.#n,
+        yScale: this.#ye(n),
+        theme: this.#h,
         marker: {
           time: n.time,
           value: a,
-          color: this.#he(n),
+          color: this.#ve(n),
           shape: n.shape,
           pulse: n.pulse,
           label: n.label
@@ -544,24 +595,24 @@ class _e extends Et {
    * legend.
    */
   addRegion(t) {
-    const e = `region_${++le}`;
-    return this.checkTimeOnlyFeature("TimeRegion") && (this.#T.push(this.#Ot(e, t)), this.#i.markDirty()), e;
+    const e = `region_${++Se}`;
+    return this.checkTimeOnlyFeature("TimeRegion") && (this.#M.push(this.#Bt(e, t)), this.#i.markDirty()), e;
   }
   /** Replace a region's config in place. No-op when the id is unknown. */
   updateRegion(t, e) {
-    const i = this.#T.findIndex((s) => s.id === t);
-    i !== -1 && (this.#T[i] = this.#Ot(t, e), this.#i.markDirty());
+    const i = this.#M.findIndex((s) => s.id === t);
+    i !== -1 && (this.#M[i] = this.#Bt(t, e), this.#i.markDirty());
   }
   /** Remove a region by id. No-op when the id is unknown. */
   removeRegion(t) {
-    const e = this.#T.findIndex((i) => i.id === t);
-    e !== -1 && (this.#T.splice(e, 1), this.#i.markDirty());
+    const e = this.#M.findIndex((i) => i.id === t);
+    e !== -1 && (this.#M.splice(e, 1), this.#i.markDirty());
   }
   /** Read-only snapshot of the registered regions (normalized). Mutate via add / update / removeRegion. */
   getRegions() {
-    return this.#T;
+    return this.#M;
   }
-  #Ot(t, e) {
+  #Bt(t, e) {
     const { to: i } = e, s = i === void 0 || i === "now" ? null : k(i);
     return {
       id: t,
@@ -572,14 +623,14 @@ class _e extends Et {
       label: e.label
     };
   }
-  #ce(t, e, i) {
-    if (this.#T.length !== 0)
-      for (const s of this.#T) {
-        const { color: r, fill: n } = Wt(s, this.#n);
-        Yt({
+  #be(t, e, i) {
+    if (this.#M.length !== 0)
+      for (const s of this.#M) {
+        const { color: r, fill: n } = jt(s, this.#h);
+        Kt({
           scope: t,
           timeScale: this.timeScale,
-          theme: this.#n,
+          theme: this.#h,
           region: { from: s.from, to: s.to, fill: n, color: r, label: s.label },
           plotWidth: e,
           plotHeight: i
@@ -598,24 +649,24 @@ class _e extends Et {
    * legend.
    */
   addLine(t) {
-    const e = `line_${++ce}`;
-    return this.#b.push(this.#$t(e, t)), this.#c.markDirty(), e;
+    const e = `line_${++be}`;
+    return this.#S.push(this.#Xt(e, t)), this.#d.markDirty(), e;
   }
   /** Replace a reference line's config in place. No-op when the id is unknown. */
   updateLine(t, e) {
-    const i = this.#b.findIndex((s) => s.id === t);
-    i !== -1 && (this.#b[i] = this.#$t(t, e), this.#c.markDirty());
+    const i = this.#S.findIndex((s) => s.id === t);
+    i !== -1 && (this.#S[i] = this.#Xt(t, e), this.#d.markDirty());
   }
   /** Remove a reference line by id. No-op when the id is unknown. */
   removeLine(t) {
-    const e = this.#b.findIndex((i) => i.id === t);
-    e !== -1 && (this.#b.splice(e, 1), this.#c.markDirty());
+    const e = this.#S.findIndex((i) => i.id === t);
+    e !== -1 && (this.#S.splice(e, 1), this.#d.markDirty());
   }
   /** Read-only snapshot of the registered reference lines (normalized). Mutate via add / update / removeLine. */
   getLines() {
-    return this.#b;
+    return this.#S;
   }
-  #$t(t, e) {
+  #Xt(t, e) {
     const { time: i, value: s } = e, r = {
       id: t,
       color: e.color,
@@ -626,22 +677,22 @@ class _e extends Et {
     };
     return i !== void 0 ? { ...r, orientation: "vertical", coord: k(i) } : { ...r, orientation: "horizontal", coord: s ?? Number.NaN };
   }
-  #de(t, e, i) {
-    if (this.#b.length === 0) return;
-    const s = this.#pt();
-    for (const r of this.#b) {
-      const n = s >= 1 ? 1 : r.orientation === "vertical" ? this.#Yt(s, r.coord) : W(s);
+  #ke(t, e, i) {
+    if (this.#S.length === 0) return;
+    const s = this.#St();
+    for (const r of this.#S) {
+      const n = s >= 1 ? 1 : r.orientation === "vertical" ? this.#_t(s, r.coord) : X(s);
       if (n <= 0) continue;
       const a = t.context.globalAlpha;
-      n < 1 && (t.context.globalAlpha = a * n), $t({
+      n < 1 && (t.context.globalAlpha = a * n), Gt({
         scope: t,
         timeScale: this.timeScale,
         yScale: this.getYScale(r.scale),
-        theme: this.#n,
+        theme: this.#h,
         line: {
           orientation: r.orientation,
           coord: r.coord,
-          color: r.color ?? this.#n.line.color,
+          color: r.color ?? this.#h.line.color,
           style: r.style,
           width: r.width,
           label: r.label
@@ -658,20 +709,20 @@ class _e extends Et {
    * underlying animator mutates between frames.
    */
   getAnimationState() {
-    return this.#ft(this.#e.getAnimationState());
+    return this.#xt(this.#e.getAnimationState());
   }
   /** The engine animates Y in scale space (the scale's forward); readers outside it get values. */
-  #ft(t, e = this.yScale) {
+  #xt(t, e = this.yScale) {
     const i = e.getTransform();
-    return i === null ? t : { ...t, yRange: Ht(t.yRange, i) };
+    return i === null ? t : { ...t, yRange: Et(t.yRange, i) };
   }
   /** The animation state as a named scale's series see it: its own Y, in values. */
-  #Wt(t, e) {
+  #Zt(t, e) {
     const i = this.#e.getScaleYRange(e) ?? t.yRange;
-    return this.#ft({ ...t, yRange: i }, this.getYScale(e));
+    return this.#xt({ ...t, yRange: i }, this.getYScale(e));
   }
   /** `isPlottable` of a scale (`undefined` = default), as a predicate for the guard helpers. */
-  #gt(t) {
+  #vt(t) {
     const e = this.getYScale(t);
     return (i) => e.isPlottable(i);
   }
@@ -701,10 +752,10 @@ class _e extends Et {
    * has actually been observed in progress, so an annotation drawn on a chart
    * that has no data yet still rides the reveal once data arrives.
    */
-  #pt() {
-    if (this.#Ct) return 1;
+  #St() {
+    if (this.#Vt) return 1;
     const t = this.getIntroFront();
-    return t < 1 ? (this.#Pt = !0, t) : (this.#Pt && (this.#Ct = !0), 1);
+    return t < 1 ? (this.#Rt = !0, t) : (this.#Rt && (this.#Vt = !0), 1);
   }
   /**
    * Entrance alpha for an overlay pinned at `time`, given the intro reveal
@@ -712,10 +763,10 @@ class _e extends Et {
    * then fades in over a short band — so annotations surface in step with the
    * series drawing past them. `1` once the intro has settled.
    */
-  #Yt(t, e) {
+  #_t(t, e) {
     if (t >= 1) return 1;
     const { from: i, to: s } = this.timeScale.getRange(), r = s - i, n = r > 0 ? (e - i) / r : 0;
-    return _t((t - n) / 0.12, 0, 1);
+    return se((t - n) / 0.12, 0, 1);
   }
   /**
    * Replace all data for a series.
@@ -732,24 +783,24 @@ class _e extends Et {
   setSeriesData(t, e, i) {
     const s = this.#t.find((a) => a.id === t);
     if (!s) return;
-    const r = this.#r === "category" && this.#vt(s);
-    if (this.#kt = !r, !this.#vt(s)) {
+    const r = this.#n === "category" && this.#Tt(s);
+    if (this.#nt = !r, !this.#Tt(s)) {
       s.renderer.setData(e, i);
       return;
     }
-    const n = this.#Et(s, e ?? []);
+    const n = this.#Ut(s, e ?? []);
     if (!r) {
       s.renderer.setData(n, i);
       return;
     }
-    this.#xt({ entry: s, layerIndex: i, mutate: () => n });
+    this.#kt({ entry: s, layerIndex: i, mutate: () => n });
   }
   /** Append a new data point to the end of a series (real-time tick). */
   appendData(t, e, i) {
     const s = this.#t.find((n) => n.id === t);
     if (s === void 0 || s.renderer.appendPoint === void 0) return;
     const r = s.renderer.appendPoint.bind(s.renderer);
-    this.#yt({
+    this.#bt({
       entry: s,
       layerIndex: i,
       points: [e],
@@ -763,19 +814,19 @@ class _e extends Et {
    * category axis applies `mutateCategory` to the layer's input-order points
    * instead, then re-sets the store from them.
    */
-  #yt(t) {
+  #bt(t) {
     const { entry: e, apply: i } = t;
-    if (!this.#vt(e)) {
+    if (!this.#Tt(e)) {
       i(t.points.slice());
       return;
     }
-    const s = this.#Et(e, t.points);
+    const s = this.#Ut(e, t.points);
     if (s.length !== 0) {
-      if (this.#r === "numeric") {
+      if (this.#n === "numeric") {
         i(s);
         return;
       }
-      this.#xt({
+      this.#kt({
         entry: e,
         layerIndex: t.layerIndex,
         mutate: (r) => t.mutateCategory(r, s)
@@ -783,66 +834,66 @@ class _e extends Et {
     }
   }
   /** Replace a category layer's input-order points with `mutate`'s result and sync the categories and stores. */
-  #xt(t) {
+  #kt(t) {
     const { entry: e } = t, i = t.layerIndex ?? 0;
-    e.categoryPoints[i] = t.mutate(e.categoryPoints[i] ?? []), this.#Bt({ entry: e, layerIndex: i });
+    e.categoryPoints[i] = t.mutate(e.categoryPoints[i] ?? []), this.#Gt({ entry: e, layerIndex: i });
   }
   /** Whether `entry`'s points go through the numeric / category ingest. */
-  #vt(t) {
-    return this.#r !== "time" && v(t.renderer);
+  #Tt(t) {
+    return this.#n !== "time" && S(t.renderer);
   }
   /**
    * Points that fit the X axis, a numeric one with its `x` copied to `time`.
    * The rest are skipped with a dev warning, as is a series mixing `x` and `time`.
    */
-  #Et(t, e) {
+  #Ut(t, e) {
     const i = [];
     for (const s of e) {
       const r = s.x !== void 0;
-      if (r && (t.xKeys.x = !0), s.time !== void 0 && (t.xKeys.time = !0), !(this.#r === "category" ? typeof s.x == "string" : !r || typeof s.x == "number")) {
-        this.#I(
+      if (r && (t.xKeys.x = !0), s.time !== void 0 && (t.xKeys.time = !0), !(this.#n === "category" ? typeof s.x == "string" : !r || typeof s.x == "number")) {
+        this.#V(
           `x-misfit:${t.id}`,
-          () => Lt({ seriesId: t.id, axisType: this.#r, x: s.x })
+          () => $t({ seriesId: t.id, axisType: this.#n, x: s.x })
         );
         continue;
       }
-      i.push(r && this.#r === "numeric" ? { ...s, time: s.x } : s);
+      i.push(r && this.#n === "numeric" ? { ...s, time: s.x } : s);
     }
-    return t.xKeys.x && t.xKeys.time && this.#I(`x-mixed:${t.id}`, () => Dt({ seriesId: t.id })), i;
+    return t.xKeys.x && t.xKeys.time && this.#V(`x-mixed:${t.id}`, () => zt({ seriesId: t.id })), i;
   }
   /** Category points with `time` set to their band index. */
-  #ue(t) {
-    return t.map((e) => ({ ...e, time: this.#Y.get(e.x) }));
+  #Te(t) {
+    return t.map((e) => ({ ...e, time: this.#O.get(e.x) }));
   }
   /**
    * Re-derive the categories — first-seen order across the series (mount
    * order, then layers, then points in input order) — and re-set every store
    * whose band indices moved, plus the `changed` layer.
    */
-  #Bt(t) {
+  #Gt(t) {
     const e = /* @__PURE__ */ new Set();
     for (const a of this.#t)
       for (const o of a.categoryPoints)
         for (const h of o ?? [])
           e.add(h.x);
-    const i = [...e], s = this.timeScale.getCategories(), r = i.length !== s.length || i.some((a, o) => a !== s[o]), n = this.#Y;
-    this.#Y = new Map(i.map((a, o) => [a, o])), this.timeScale.setCategories(i), this.batch(() => {
+    const i = [...e], s = this.timeScale.getCategories(), r = i.length !== s.length || i.some((a, o) => a !== s[o]), n = this.#O;
+    this.#O = new Map(i.map((a, o) => [a, o])), this.timeScale.setCategories(i), this.batch(() => {
       for (const a of this.#t)
-        this.#me({ entry: a, previous: n, changed: t });
+        this.#we({ entry: a, previous: n, changed: t });
       r && this.onDataChanged();
     });
   }
   /** Re-set `entry`'s layers whose points moved band, or that `changed` names, from their input-order points. */
-  #me(t) {
+  #we(t) {
     const { entry: e, previous: i, changed: s } = t;
     for (let r = 0; r < e.categoryPoints.length; r++) {
       const n = e.categoryPoints[r] ?? [], a = s?.entry === e && s.layerIndex === r, o = n.some(
-        (d) => i.get(d.x) !== this.#Y.get(d.x)
+        (c) => i.get(c.x) !== this.#O.get(c.x)
       );
       if (!a && !o) continue;
-      const h = this.#ue(n).sort((d, f) => d.time - f.time), l = n.some((d) => {
-        const f = i.get(d.x);
-        return f !== void 0 && f !== this.#Y.get(d.x);
+      const h = this.#Te(n).sort((c, f) => c.time - f.time), l = n.some((c) => {
+        const f = i.get(c.x);
+        return f !== void 0 && f !== this.#O.get(c.x);
       });
       a && !l && e.renderer.morphData !== void 0 ? e.renderer.morphData(h, r) : e.renderer.setData(h, r);
     }
@@ -863,10 +914,10 @@ class _e extends Et {
   prependData(t, e, i) {
     const s = this.#t.find((a) => a.id === t);
     if (s === void 0 || s.renderer.prependPoints === void 0) return;
-    const r = this.#ht.left;
-    r !== null && s.renderer.setHistoryHandoff !== void 0 && performance.now() - r.at < Qt && (s.renderer.setHistoryHandoff(r.bars), this.#B.left = !0, this.#K.left = null, this.#ht.left = null, this.#c.markDirty());
+    const r = this.#ct.left;
+    r !== null && s.renderer.setHistoryHandoff !== void 0 && performance.now() - r.at < he && (s.renderer.setHistoryHandoff(r.bars), this.#E.left = !0, this.#K.left = null, this.#ct.left = null, this.#d.markDirty());
     const n = s.renderer.prependPoints.bind(s.renderer);
-    this.#yt({
+    this.#bt({
       entry: s,
       layerIndex: i,
       points: e,
@@ -879,7 +930,7 @@ class _e extends Et {
     const s = this.#t.find((n) => n.id === t);
     if (s === void 0 || s.renderer.updateLastPoint === void 0) return;
     const r = s.renderer.updateLastPoint.bind(s.renderer);
-    this.#yt({
+    this.#bt({
       entry: s,
       layerIndex: i,
       points: [e],
@@ -904,11 +955,11 @@ class _e extends Et {
   keepLast(t, e, i) {
     const s = this.#t.find((r) => r.id === t);
     if (s?.renderer.keepLast !== void 0) {
-      if (this.#r !== "category") {
+      if (this.#n !== "category") {
         s.renderer.keepLast(e, i);
         return;
       }
-      this.#xt({
+      this.#kt({
         entry: s,
         layerIndex: i,
         mutate: (r) => e < 0 ? [...r] : r.slice(Math.max(0, r.length - e))
@@ -920,21 +971,21 @@ class _e extends Et {
    * (time series) moves it onto a named Y scale, `undefined` back to the default.
    */
   updateSeriesOptions(t, e) {
-    const i = this.#t.find((u) => u.id === t);
+    const i = this.#t.find((m) => m.id === t);
     if (!i) return;
     const { scale: s, ...r } = e, n = "scale" in e, a = n ? s : i.scale;
     if (("stacking" in e || n) && a === void 0) {
-      const u = "stacking" in e ? e.stacking : tt(i.renderer);
-      L({ seriesId: t, stacking: u, isPlottable: this.#gt(a) });
+      const m = "stacking" in e ? e.stacking : lt(i.renderer);
+      R({ seriesId: t, stacking: m, isPlottable: this.#vt(a) });
     }
     const o = i.labels, h = i.renderer.getLayerColors().slice(), l = this.#g.overrides(i.renderer.kind);
     i.renderer.updateOptions({ ...r, ...l }), "label" in e && typeof e.label == "string" && (i.labels = [e.label]), this.#i.markDirty();
-    const d = this.#D(i);
+    const c = this.#I(i);
     i.scale = a;
-    const f = this.#D(i) !== d;
-    f && this.#xe();
-    const c = i.renderer.getLayerColors(), m = h.length !== c.length || h.some((u, g) => u !== c[g]), y = !Q(o, i.labels);
-    (m || y || f) && this.#u();
+    const f = this.#I(i) !== c;
+    f && this.#Le();
+    const g = i.renderer.getLayerColors(), y = h.length !== g.length || h.some((m, p) => m !== g[p]), u = !ht(o, i.labels);
+    (y || u || f) && this.#m();
   }
   /**
    * Batch multiple updates: suppress recomputes until `fn` returns. Exceptions
@@ -946,14 +997,14 @@ class _e extends Et {
       t();
     } finally {
       if (--this.#R <= 0) {
-        if (this.#R = 0, this.#lt)
-          this.#lt = !1, this.#N = !1, this.onDataChanged();
-        else if (this.#N) {
-          this.#N = !1, this.#m = !0;
+        if (this.#R = 0, this.#dt)
+          this.#dt = !1, this.#B = !1, this.onDataChanged();
+        else if (this.#B) {
+          this.#B = !1, this.#u = !0;
           const e = performance.now();
           this.#e.onSeriesVisibilityChanged(e), this.#x(e), this.#i.markDirty();
         }
-        this.#ct && (this.#ct = !1, this.emit("overlayChange"));
+        this.#ut && (this.#ut = !1, this.emit("overlayChange"));
       }
     }
   }
@@ -967,13 +1018,13 @@ class _e extends Et {
   setSeriesVisible(t, e) {
     const i = this.#t.find((n) => n.id === t);
     if (!i || i.visible === e) return;
-    i.visible = e, this.#u(), this.#et();
+    i.visible = e, this.#m(), this.#rt();
     const s = this.#g.toggleMs;
     if (i.renderer.setAlpha?.(e ? 1 : 0, s), this.#i.markDirty(), this.#R > 0) {
-      this.#N = !0;
+      this.#B = !0;
       return;
     }
-    this.#m = !0;
+    this.#u = !0;
     const r = performance.now();
     this.#e.onSeriesVisibilityChanged(r), this.#x(r);
   }
@@ -1003,28 +1054,28 @@ class _e extends Et {
   setLayerVisible(t, e, i) {
     const s = this.#t.find((a) => a.id === t);
     if (!s || s.renderer.getLayerCount() <= 1 || s.renderer.isLayerVisible(e) === i) return;
-    s.renderer.setLayerVisible(e, i), this.#u();
+    s.renderer.setLayerVisible(e, i), this.#m();
     const r = this.#g.toggleMs;
     if (s.renderer.setLayerAlpha?.(e, i ? 1 : 0, r), this.#i.markDirty(), this.#R > 0) {
-      this.#N = !0;
+      this.#B = !0;
       return;
     }
-    this.#m = !0;
+    this.#u = !0;
     const n = performance.now();
     this.#e.onSeriesVisibilityChanged(n), this.#x(n);
   }
   isLayerVisible(t, e) {
     return this.#t.find((i) => i.id === t)?.renderer.isLayerVisible(e) ?? !0;
   }
-  /** Auto-fit the viewport to show all data across every series. */
+  /** Auto-fit the viewport to show all data across every series, however many bars that is. */
   fitContent() {
     const { first: t, last: e } = this.getDataBounds();
     if (t === void 0 || e === void 0) return;
-    const i = this.#l.size.media.width - this.#w();
-    this.#O(t, e, i), this.#st({ xEase: !0 });
+    const i = this.#c.size.media.width - this.#k();
+    this.#et(), this.#Pt({ firstTime: t, lastTime: e, chartWidth: i }), this.#se({ xEase: !0 });
   }
   getVisibleRange() {
-    return this.#h.from === 0 && this.#h.to === 0 ? this.#e.getAnimationState().xRange : this.#h;
+    return this.#a.from === 0 && this.#a.to === 0 ? this.#e.getAnimationState().xRange : this.#a;
   }
   /**
    * Return the full span of registered data, or `null` before any data has
@@ -1032,7 +1083,7 @@ class _e extends Et {
    * tracking and is cheaper than recomputing from series stores.
    */
   getDataRange() {
-    return this.#S === null || this.#s === null ? null : { from: this.#S, to: this.#s };
+    return this.#T === null || this.#s === null ? null : { from: this.#T, to: this.#s };
   }
   /**
    * Imperatively set the visible time range. Three forms:
@@ -1059,31 +1110,44 @@ class _e extends Et {
    * lockstep rather than lagging behind on the long sticky contract.
    */
   setVisibleRange(t, e) {
+    const i = this.#jt(t);
+    if (i !== null) {
+      if (this.#et(), e?.gesture && ye(t)) {
+        i && this.#$e();
+        return;
+      }
+      this.#se();
+    }
+  }
+  /**
+   * Write `spec` into the logical X range, the autoscroll flag and the warm-up
+   * hold, without touching the engine. Returns whether the range changed, or
+   * `null` when the spec is invalid or a bar count has no data to count back from.
+   */
+  #jt(t) {
     if (typeof t == "number") {
-      if (!Number.isInteger(t) || t < 2) return;
-      const { first: n, last: a } = this.getDataBounds();
-      if (n === void 0 || a === void 0) return;
-      const o = Math.max(n, a - (t - 1) * this.#o), h = this.#l.size.media.width - this.#w();
-      this.#O(o, a, h), this.#st();
-      return;
+      if (!A(t)) return null;
+      const { first: s, last: r } = this.getDataBounds();
+      if (s === void 0 || r === void 0) return null;
+      const n = Math.max(s, r - (t - 1) * this.#r), a = this.#c.size.media.width - this.#k();
+      return this.#Pt({ firstTime: n, lastTime: r, chartWidth: a });
     }
     if ("bars" in t) {
-      if (!Number.isInteger(t.bars) || t.bars < 2) return;
-      const n = k(t.from), a = n + t.bars * this.#o;
-      this.#p = this.#s !== null && this.#s >= n && this.#s <= a, this.#H({ from: n, to: a }, { emitChange: !0 }), this.#L = !0, this.#st();
-      return;
-    }
-    const i = k(t.from), s = k(t.to);
-    this.#p = this.#s !== null && this.#s >= i && this.#s <= s, this.#L = !1;
-    const r = this.#H({ from: i, to: s }, { emitChange: !0 });
-    if (e?.gesture) {
-      r && this.#Te();
-      return;
+      if (!A(t.bars)) return null;
+      const s = k(t.from), r = s + t.bars * this.#r;
+      this.#p = this.#s !== null && this.#s >= s && this.#s <= r;
+      const n = this.#D({ from: s, to: r }, { emitChange: !0 });
+      return this.#L = !0, n;
     }
-    this.#st();
+    const e = k(t.from), i = k(t.to);
+    return this.#p = this.#s !== null && this.#s >= e && this.#s <= i, this.#L = !1, this.#D({ from: e, to: i }, { emitChange: !0 });
+  }
+  /** The user or the app took over the view: drop `initialRange` and stop growing the chart's own fit. */
+  #et() {
+    this.#H = void 0, this.#U = !1;
   }
   getYRange() {
-    return this.#P.range;
+    return this.#w.range;
   }
   getCrosshairPosition() {
     return this.#f;
@@ -1124,7 +1188,7 @@ class _e extends Et {
   setCrosshair(t) {
     if (t === null) {
       if (this.#f === null) return;
-      this.#f = null, this.#c.markDirty(), this.emit("crosshairMove", null);
+      this.#f = null, this.#d.markDirty(), this.emit("crosshairMove", null);
       return;
     }
     const { time: e } = t;
@@ -1133,19 +1197,19 @@ class _e extends Et {
     let s;
     if (t.y !== void 0 ? s = t.y : i !== null ? s = i.y : s = this.yScale.yToValue(this.yScale.getMediaHeight() / 2), !Number.isFinite(s) || i !== null && i.time === e && i.y === s) return;
     const r = this.plotLeft + this.timeScale.timeToX(e), n = this.yScale.valueToY(s);
-    this.#ot = "time", this.#f = { mediaX: r, mediaY: n, time: e, x: this.timeScale.domainValue(e), y: s }, this.#c.markDirty(), this.emit("crosshairMove", this.#f);
+    this.#lt = "time", this.#f = { mediaX: r, mediaY: n, time: e, x: this.timeScale.domainValue(e), y: s }, this.#d.markDirty(), this.emit("crosshairMove", this.#f);
   }
   /** Get the last visible value and whether the absolute last point is on screen. */
   getLastValue(t) {
-    return gt(t, this.#t, this.#e.getAnimationState().xRange);
+    return wt(t, this.#t, this.#e.getAnimationState().xRange);
   }
   /** Get the second-to-last value, useful for computing change. */
   getPreviousClose(t) {
-    return pt(t, this.#t);
+    return Mt(t, this.#t);
   }
   getLastData(t) {
     const e = this.#t.find((i) => i.id === t);
-    return !e || !v(e.renderer) ? null : e.renderer.getLastDataPoint();
+    return !e || !S(e.renderer) ? null : e.renderer.getLastDataPoint();
   }
   /** Find the data point closest to the given timestamp within one data interval. */
   getDataAtTime(t, e) {
@@ -1169,10 +1233,10 @@ class _e extends Et {
    * past a wide gap is still the nearest.
    */
   #X() {
-    return this.#r === "category" ? 0.5 : this.#r === "time" || this.#S === null || this.#s === null ? this.#o : Math.max(this.#o, this.#s - this.#S);
+    return this.#n === "category" ? 0.5 : this.#n === "time" || this.#T === null || this.#s === null ? this.#r : Math.max(this.#r, this.#s - this.#T);
   }
   getSeriesIds() {
-    return this.#z || (this.#z = this.#t.map((t) => t.id)), this.#z.slice();
+    return this.#F || (this.#F = this.#t.map((t) => t.id)), this.#F.slice();
   }
   /**
    * True if any visible series has a time axis (line / bar / candlestick).
@@ -1180,9 +1244,9 @@ class _e extends Et {
    * has no meaningful x/y coordinate system, so the dashed hairlines would
    * just be visual noise.
    */
-  #Nt() {
+  #Kt() {
     for (const t of this.#t)
-      if (t.visible && v(t.renderer))
+      if (t.visible && S(t.renderer))
         return !0;
     return !1;
   }
@@ -1192,8 +1256,8 @@ class _e extends Et {
    * to reserve and nothing slides under an axis column. Reads registration,
    * not visibility — a legend toggle must not shift the layout.
    */
-  #Q() {
-    return this.#t.length === 0 ? !1 : this.#t.every((t) => !v(t.renderer));
+  #it() {
+    return this.#t.length === 0 ? !1 : this.#t.every((t) => !S(t.renderer));
   }
   #Z() {
     return {
@@ -1206,8 +1270,8 @@ class _e extends Et {
   }
   /** Reassign the Y-axis columns, then resync the scales if the gutters moved
    *  and let DOM axis / label components re-read the layout, as they do after a resize. */
-  #tt(t) {
-    this.#St();
+  #st(t) {
+    this.#wt();
     const e = this.#Z();
     (e.yAxisWidth !== t.yAxisWidth || e.xAxisHeight !== t.xAxisHeight || e.yAxisPosition !== t.yAxisPosition || e.leftWidth !== t.leftWidth || e.rightWidth !== t.rightWidth) && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
   }
@@ -1218,7 +1282,7 @@ class _e extends Et {
    * capturing wheel and touch events, so the page scrolls normally under the cursor.
    */
   canPanZoom() {
-    return (this.#v.x?.panZoom ?? this.#r !== "category") && this.#Nt();
+    return (this.#v.x?.panZoom ?? this.#n !== "category") && this.#Kt();
   }
   /**
    * Whether a time-only feature (Navigator, EdgeLoader, TimeRegion) can run
@@ -1228,7 +1292,7 @@ class _e extends Et {
    * @internal
    */
   checkTimeOnlyFeature(t) {
-    return this.#r === "time" ? !0 : (this.#I(`time-only:${t}`, () => Rt({ feature: t, axisType: this.#r })), !1);
+    return this.#n === "time" ? !0 : (this.#V(`time-only:${t}`, () => Ot({ feature: t, axisType: this.#n })), !1);
   }
   /**
    * Push the current pan/zoom capability into the interaction layer (canvas
@@ -1237,8 +1301,8 @@ class _e extends Et {
    * every mutation that can flip {@link canPanZoom}: series add/remove and
    * series visibility.
    */
-  #et() {
-    this.#V?.syncPanZoomMode();
+  #rt() {
+    this.#N?.syncPanZoomMode();
   }
   /**
    * Filter `getSeriesIds()` by renderer type. A concrete kind (`'pie'`,
@@ -1254,7 +1318,7 @@ class _e extends Et {
   getSeriesIdsByType(t, e) {
     const i = e?.visibleOnly === !0, s = e?.singleLayerOnly === !0, r = [];
     for (const n of this.#t) {
-      if (!(t === "time" ? v(n.renderer) : n.renderer.kind === t)) continue;
+      if (!(t === "time" ? S(n.renderer) : n.renderer.kind === t)) continue;
       const a = n.renderer.getLayerCount();
       if (!(s && a > 1)) {
         if (i) {
@@ -1281,7 +1345,7 @@ class _e extends Et {
    * Returns `null` for unknown ids or empty series.
    */
   getStackedLastValue(t) {
-    return yt(t, this.#t, this.#e.getAnimationState().xRange);
+    return At(t, this.#t, this.#e.getAnimationState().xRange);
   }
   /**
    * Stacked value at an arbitrary `time` — the cumulative stack top at that
@@ -1296,7 +1360,7 @@ class _e extends Et {
     const s = i.renderer.getStackedValueAtTime?.(e, this.#X());
     if (s != null) return s;
     const r = i.renderer.getDataAtTime?.(e, this.#X());
-    return !r || jt(r) ? null : G(r);
+    return !r || ae(r) ? null : tt(r);
   }
   /**
    * Per-layer last snapshots with each layer's own `time`. Returns `null`
@@ -1320,7 +1384,7 @@ class _e extends Et {
   /** Get the primary display color for a series. */
   getSeriesColor(t) {
     const e = this.#t.find((i) => i.id === t);
-    return e ? e.renderer.getLayerColors()[0] ?? this.#n.line.color : null;
+    return e ? e.renderer.getLayerColors()[0] ?? this.#h.line.color : null;
   }
   /** The series' primary name (first layer). Used for single-layer overlays. */
   getSeriesLabel(t) {
@@ -1338,7 +1402,7 @@ class _e extends Et {
    */
   setSeriesLabels(t, e) {
     const i = this.#t.find((s) => s.id === t);
-    !i || Q(i.labels, e) || (i.labels = e, this.#u());
+    !i || ht(i.labels, e) || (i.labels = e, this.#m());
   }
   /**
    * Set the per-layer color overrides carried in `data` (sparse — `undefined`
@@ -1349,7 +1413,7 @@ class _e extends Et {
    */
   setLayerColors(t, e) {
     const i = this.#t.find((s) => s.id === t);
-    !i || de(i.colorOverrides, e) || (i.colorOverrides = e, i.renderer.setColorOverrides?.(e), this.#i.markDirty(), this.#u());
+    !i || ke(i.colorOverrides, e) || (i.colorOverrides = e, i.renderer.setColorOverrides?.(e), this.#i.markDirty(), this.#m());
   }
   /** Get per-layer colors for a series. Returns null for single-layer non-bar/line series. */
   getSeriesLayers(t) {
@@ -1362,50 +1426,50 @@ class _e extends Et {
   }
   /** Get all slices with computed colors and percentages. Returns null for series without slice data (e.g. candlestick, line, bar). */
   getSliceInfo(t) {
-    return this.#t.find((e) => e.id === t)?.renderer.getSliceInfo?.(this.#n) ?? null;
+    return this.#t.find((e) => e.id === t)?.renderer.getSliceInfo?.(this.#h) ?? null;
   }
   /** Get hover info (label/value/percent/color) for the currently hovered element, or null. */
   getHoverInfo(t) {
-    return this.#t.find((e) => e.id === t)?.renderer.getHoverInfo?.(this.#n) ?? null;
+    return this.#t.find((e) => e.id === t)?.renderer.getHoverInfo?.(this.#h) ?? null;
   }
   /** Apply a new theme and update series colors where appropriate. */
   setTheme(t) {
-    const e = this.#n;
-    this.#n = t;
+    const e = this.#h;
+    this.#h = t;
     for (const i of this.#t)
       i.renderer.applyTheme(t, e);
-    this.#i.markDirty(), this.#u();
+    this.#i.markDirty(), this.#m();
   }
   getTheme() {
-    return this.#n;
+    return this.#h;
   }
   /** BCP 47 locale applied to the built-in time-axis / tooltip / crosshair formatting. */
   setLocale(t) {
-    this.timeScale.setLocale(t), this.#u();
+    this.timeScale.setLocale(t), this.#m();
   }
   getLocale() {
     return this.timeScale.getLocale();
   }
   /** IANA timezone applied to the same built-in date-time formatting. */
   setTimeZone(t) {
-    this.timeScale.setTimeZone(t), this.#u();
+    this.timeScale.setTimeZone(t), this.#m();
   }
   getTimeZone() {
     return this.timeScale.getTimeZone();
   }
   /** Update axis configuration and re-render. */
   setAxis(t) {
-    const e = t.y?.scale ?? null, i = (d) => _(e, d);
-    for (const d of this.#t)
-      !v(d.renderer) || d.scale !== void 0 || L({ seriesId: d.id, stacking: d.renderer.stacking, isPlottable: i });
+    const e = t.y?.scale ?? null, i = (c) => Q(e, c);
+    for (const c of this.#t)
+      !S(c.renderer) || c.scale !== void 0 || R({ seriesId: c.id, stacking: c.renderer.stacking, isPlottable: i });
     const s = this.#Z(), r = e !== this.yScale.getTransform(), n = t.x?.type ?? "time";
-    n !== this.#r && this.#I("x-type", () => It({ from: this.#r, to: n }));
+    n !== this.#n && this.#V("x-type", () => Yt({ from: this.#n, to: n }));
     const a = this.timeScale.getBandPadding();
     this.timeScale.setBandPadding(t.x?.padding);
     const o = this.timeScale.getBandPadding(), h = a.inner !== o.inner || a.outer !== o.outer;
-    this.#v = t, this.#P.bounds = { min: t.y?.min, max: t.y?.max }, C({ y: t.y, isPlottable: i });
+    this.#v = t, this.#w.bounds = { min: t.y?.min, max: t.y?.max }, D({ y: t.y, isPlottable: i });
     const l = performance.now();
-    r && (this.yScale.setTransform(e), this.yScale.tickTracker.reset(), this.#_() === null && this.#e.snap({ y: { min: 0, max: 0 } }, l)), this.#m = !0, this.#e.onAxisReconfig(l), this.#x(l), this.#tt(s), this.#et(), h && this.#r === "category" && this.fitContent(), this.#i.markDirty();
+    r && (this.yScale.setTransform(e), this.yScale.tickTracker.reset(), this.#G() === null && this.#e.snap({ y: { min: 0, max: 0 } }, l)), this.#u = !0, this.#e.onAxisReconfig(l), this.#x(l), this.#st(s), this.#rt(), h && this.#n === "category" && this.fitContent(), this.#i.markDirty();
   }
   /**
    * Replace the named Y scales (see {@link ChartOptions.scales}). Added,
@@ -1414,69 +1478,69 @@ class _e extends Et {
    */
   setScales(t) {
     const e = t ?? {};
-    if (Ut(e, this.#At)) return;
-    const i = this.#Z(), s = this.#Xt(e);
-    this.#St();
+    if (ie(e, this.#It)) return;
+    const i = this.#Z(), s = this.#qt(e);
+    this.#wt();
     const r = performance.now(), n = {};
     for (const a of s)
-      this.#_(void 0, a) === null && (n[a] = { min: 0, max: 0 });
-    this.#e.snap({ scales: n }, r), this.#m = !0, this.#e.onAxisReconfig(r), this.#x(r), this.#tt(i), this.emit("viewportChange"), this.#u(), this.#i.markDirty();
+      this.#G(void 0, a) === null && (n[a] = { min: 0, max: 0 });
+    this.#e.snap({ scales: n }, r), this.#u = !0, this.#e.onAxisReconfig(r), this.#x(r), this.#st(i), this.emit("viewportChange"), this.#m(), this.#i.markDirty();
   }
   /**
    * Create, update and drop named-scale slots to match `next`, in its key
    * order. Returns the ids of existing scales whose transform changed.
    */
-  #Xt(t) {
+  #qt(t) {
     const e = /* @__PURE__ */ new Map(), i = [];
     for (const [s, r] of Object.entries(t)) {
       const n = r.scale ?? null;
-      let a = this.#a.get(s);
+      let a = this.#o.get(s);
       if (a === void 0) {
-        const o = new U();
-        o.setTransform(n), o.tickTracker.setFadeMs(this.#g.axis.ticksMs), a = { ...j(o, r), config: r, column: null };
+        const o = new J();
+        o.setTransform(n), o.tickTracker.setFadeMs(this.#g.axis.ticksMs), a = { ...rt(o, r), config: r, column: null };
       } else n !== a.yScale.getTransform() && (a.yScale.setTransform(n), a.yScale.tickTracker.reset(), i.push(s));
-      a.config = { ...r }, a.bounds = { min: r.min, max: r.max }, C({
+      a.config = { ...r }, a.bounds = { min: r.min, max: r.max }, D({
         y: r,
-        isPlottable: (o) => _(n, o),
+        isPlottable: (o) => Q(n, o),
         path: `scales.${s}`
       }), e.set(s, a);
     }
-    return this.#a = e, this.#At = Object.fromEntries([...e].map(([s, r]) => [s, r.config])), this.#e.setYScales([...e.keys()]), i;
+    return this.#o = e, this.#It = Object.fromEntries([...e].map(([s, r]) => [s, r.config])), this.#e.setYScales([...e.keys()]), i;
   }
   /**
    * Hand out the Y-axis columns: the default axis keeps its side, and each
    * visible named scale takes its side unless an earlier one holds it —
    * that one becomes an overlay scale (dev warning).
    */
-  #St() {
+  #wt() {
     const t = /* @__PURE__ */ new Set();
     this.yAxisWidth > 0 && t.add(this.yAxisPosition);
-    const e = q(this.yAxisPosition);
-    for (const [i, s] of this.#a) {
-      if (s.column = null, this.#j(s.config) <= 0) continue;
+    const e = at(this.yAxisPosition);
+    for (const [i, s] of this.#o) {
+      if (s.column = null, this.#q(s.config) <= 0) continue;
       const r = s.config.position ?? e;
       if (t.has(r)) {
-        this.#I(`side:${i}`, () => kt({ scaleId: i, side: r }));
+        this.#V(`side:${i}`, () => Dt({ scaleId: i, side: r }));
         continue;
       }
       t.add(r), s.column = r;
     }
   }
   /** Dev warnings for a series' `scale`: an id `scales` doesn't define, a percent stack on a scale without 0. */
-  #fe(t) {
+  #Me(t) {
     const e = t.scale;
-    e !== void 0 && (this.#a.has(e) || this.#I(`unknown:${e}`, () => wt({ seriesId: t.id, scaleId: e })), tt(t.renderer) === "percent" && !this.getYScale(this.#D(t)).isPlottable(0) && this.#I(`percent:${t.id}`, () => Tt({ seriesId: t.id })));
+    e !== void 0 && (this.#o.has(e) || this.#V(`unknown:${e}`, () => Rt({ seriesId: t.id, scaleId: e })), lt(t.renderer) === "percent" && !this.getYScale(this.#I(t)).isPlottable(0) && this.#V(`percent:${t.id}`, () => Vt({ seriesId: t.id })));
   }
-  #I(t, e) {
-    this.#Mt.has(t) || (this.#Mt.add(t), e());
+  #V(t, e) {
+    this.#Dt.has(t) || (this.#Dt.add(t), e());
   }
   /** Ids of the named Y scales, in declaration order. */
   getYScaleIds() {
-    return [...this.#a.keys()];
+    return [...this.#o.keys()];
   }
   /** The Y scale named `scaleId`; the default scale for `undefined` or an id `scales` doesn't define. */
   getYScale(t) {
-    return t === void 0 ? this.yScale : this.#a.get(t)?.yScale ?? this.yScale;
+    return t === void 0 ? this.yScale : this.#o.get(t)?.yScale ?? this.yScale;
   }
   /**
    * The column a scale's axis sits in — always the default axis's for
@@ -1484,31 +1548,31 @@ class _e extends Et {
    */
   getYScaleColumn(t) {
     if (t === void 0) return { position: this.yAxisPosition, width: this.yAxisWidth };
-    const e = this.#a.get(t);
-    return e === void 0 || e.column === null ? null : { position: e.column, width: this.#j(e.config) };
+    const e = this.#o.get(t);
+    return e === void 0 || e.column === null ? null : { position: e.column, width: this.#q(e.config) };
   }
   /** The named scale a series maps through, `undefined` for the default scale. */
   getSeriesScale(t) {
     const e = this.#t.find((i) => i.id === t);
-    return e === void 0 ? void 0 : this.#D(e);
+    return e === void 0 ? void 0 : this.#I(e);
   }
   /** `scale` if `options.scales` defines it, else `undefined` (the default scale). */
-  #ge(t) {
-    return t !== void 0 && this.#a.has(t) ? t : void 0;
+  #Ae(t) {
+    return t !== void 0 && this.#o.has(t) ? t : void 0;
   }
-  #D(t) {
-    return this.#ge(t.scale);
+  #I(t) {
+    return this.#Ae(t.scale);
   }
-  #pe(t) {
-    return t === void 0 ? this.#P : this.#a.get(t) ?? this.#P;
+  #Pe(t) {
+    return t === void 0 ? this.#w : this.#o.get(t) ?? this.#w;
   }
   /** The series a scale autoscales from. */
-  #ye(t) {
-    return this.#a.size === 0 ? this.#t : this.#t.filter((e) => this.#D(e) === t);
+  #Ce(t) {
+    return this.#o.size === 0 ? this.#t : this.#t.filter((e) => this.#I(e) === t);
   }
   /** Snap every scale to a fresh fit — what each one holds just changed. */
-  #xe() {
-    this.#m = !0;
+  #Le() {
+    this.#u = !0;
     const t = performance.now();
     this.#e.onAxisReconfig(t), this.#x(t), this.emit("viewportChange"), this.#i.markDirty();
   }
@@ -1518,7 +1582,7 @@ class _e extends Et {
    * picks a named scale; an id `scales` doesn't define is a no-op.
    */
   setYAxisFormat(t) {
-    t.scale !== void 0 && !this.#a.has(t.scale) || (this.getYScale(t.scale).setFormat(t.format), this.#u());
+    t.scale !== void 0 && !this.#o.has(t.scale) || (this.getYScale(t.scale).setFormat(t.format), this.#m());
   }
   /**
    * Apply label-density knobs driven by `<YAxis labelCount=… minLabelSpacing=…>`
@@ -1528,7 +1592,7 @@ class _e extends Et {
    * charts react without waiting for pan/zoom.
    */
   setYAxisLabelDensity(t) {
-    if (t.scale !== void 0 && !this.#a.has(t.scale)) return;
+    if (t.scale !== void 0 && !this.#o.has(t.scale)) return;
     const e = this.getYScale(t.scale);
     let i = !1;
     "labelCount" in t && (e.setLabelCount(t.labelCount ?? null), i = !0), "minLabelSpacing" in t && (e.setMinSpacing(t.minLabelSpacing ?? null), i = !0), i && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
@@ -1539,7 +1603,7 @@ class _e extends Et {
    * info-bar headers read it.
    */
   setXAxisFormat(t) {
-    this.timeScale.setFormat(t), this.#u();
+    this.timeScale.setFormat(t), this.#m();
   }
   /** Label-density knobs for the X axis — mirror of {@link setYAxisLabelDensity}. */
   setTimeAxisLabelDensity(t) {
@@ -1547,11 +1611,11 @@ class _e extends Et {
     "labelCount" in t && (this.timeScale.setLabelCount(t.labelCount ?? null), e = !0), "minLabelSpacing" in t && (this.timeScale.setMinSpacing(t.minLabelSpacing ?? null), e = !0), e && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
   }
   getMediaSize() {
-    return this.#l.size.media;
+    return this.#c.size.media;
   }
   /** Returns layout metrics for the chart area, Y axis, and time axis. */
   getLayout() {
-    const t = this.#l.size.media, e = this.yAxisWidth, i = this.xAxisHeight, s = t.width - this.#w();
+    const t = this.#c.size.media, e = this.yAxisWidth, i = this.xAxisHeight, s = t.width - this.#k();
     return {
       chartArea: { x: this.plotLeft, y: 0, width: s, height: t.height - i },
       yAxisWidth: e,
@@ -1560,7 +1624,7 @@ class _e extends Et {
     };
   }
   getDataInterval() {
-    return this.#o;
+    return this.#r;
   }
   /**
    * Update viewport padding at runtime. Refits the visible time range to
@@ -1571,18 +1635,15 @@ class _e extends Et {
    * InfoBar ResizeObserver).
    */
   setPadding(t) {
-    const e = this.#d;
-    this.#d = E(t);
-    const i = this.#d, s = !B(e.left, i.left) || !B(e.right, i.right), r = e.top !== i.top || e.bottom !== i.bottom;
+    const e = this.#l;
+    this.#l = U(t);
+    const i = this.#l, s = !G(e.left, i.left) || !G(e.right, i.right), r = e.top !== i.top || e.bottom !== i.bottom;
     if (s) {
-      const { first: n, last: a } = this.getDataBounds();
-      if (n !== void 0 && a !== void 0) {
-        const o = this.#l.size.media.width - this.#w();
-        this.#O(n, a, o);
-      }
+      const n = this.#c.size.media.width - this.#k();
+      this.#At(n);
     }
     if (s || r) {
-      this.#m = !0;
+      this.#u = !0;
       const n = performance.now();
       this.#e.onAxisReconfig(n), this.#x(n);
     }
@@ -1590,7 +1651,7 @@ class _e extends Et {
   }
   /** Show or hide the background grid. Takes effect on the next render frame. */
   setGrid(t) {
-    this.#G = t.visible, this.#i.markDirty();
+    this.#j = t.visible, this.#i.markDirty();
   }
   /**
    * Set or clear the edge fade masks (see {@link ChartOptions.fade}).
@@ -1600,14 +1661,14 @@ class _e extends Et {
    * the next render frame.
    */
   setFade(t) {
-    const e = Y(t), i = this.#C;
+    const e = _(t), i = this.#C;
     e.top === i.top && e.right === i.right && e.left === i.left || (this.#C = e, this.#i.markDirty());
   }
   /** Report the floating header's height (see {@link headerHeight}). The
    *  framework wrappers keep it in sync with the measured Title / InfoBar. */
   setHeaderHeight(t) {
     const e = Number.isFinite(t) && t > 0 ? t : 0;
-    e !== this.#at && (this.#at = e, this.#u());
+    e !== this.#ht && (this.#ht = e, this.#m());
   }
   /**
    * Set the visual state for one side of the chart. Typically called in
@@ -1620,8 +1681,8 @@ class _e extends Et {
    */
   setEdgeState(t, e) {
     if (this.#A[t] === e || !this.checkTimeOnlyFeature("EdgeLoader")) return;
-    const i = this.#A[t] === "loading", s = this.#B[t];
-    this.#B[t] = !1, this.#K[t] = i && !s && (e === "idle" || e === "has-more") ? performance.now() : null, this.#A[t] = e, this.#c.markDirty();
+    const i = this.#A[t] === "loading", s = this.#E[t];
+    this.#E[t] = !1, this.#K[t] = i && !s && (e === "idle" || e === "has-more") ? performance.now() : null, this.#A[t] = e, this.#d.markDirty();
   }
   /** Read the current host-declared state for a given edge. */
   getEdgeState(t) {
@@ -1631,11 +1692,11 @@ class _e extends Et {
    * Alpha for a side's `loading` exit fade, or `null` when none is in
    * flight. Self-cleaning: an elapsed fade clears its start stamp.
    */
-  #Zt(t) {
+  #Jt(t) {
     const e = this.#K[t];
     if (e === null) return null;
-    const i = (performance.now() - e) / Jt;
-    return i >= 1 ? (this.#K[t] = null, null) : 1 - W(Math.max(0, i));
+    const i = (performance.now() - e) / oe;
+    return i >= 1 ? (this.#K[t] = null, null) : 1 - X(Math.max(0, i));
   }
   /**
    * Swap the painter used for a side's `loading` spinner — the same
@@ -1644,7 +1705,7 @@ class _e extends Et {
    * immediately if that side is currently in the `loading` state.
    */
   setEdgeIndicator(t, e) {
-    e !== null && !this.checkTimeOnlyFeature("EdgeLoader") || (this.#It[t] = e, this.#A[t] === "loading" && this.#c.markDirty());
+    e !== null && !this.checkTimeOnlyFeature("EdgeLoader") || (this.#$t[t] = e, this.#A[t] === "loading" && this.#d.markDirty());
   }
   /**
    * Resolve the boundary point's Y position and series kind on the primary
@@ -1654,14 +1715,14 @@ class _e extends Et {
    * `open` (the value immediately preceding the boundary); `right` from the
    * last visible candle's `close`.
    */
-  #ve(t, e) {
+  #Ie(t, e) {
     const i = this.getSeriesIdsByType("time", { visibleOnly: !0, singleLayerOnly: !0 })[0] ?? this.getSeriesIdsByType("time", { visibleOnly: !0 })[0];
     if (!i) return null;
     const s = this.getDataAtTime(i, e);
     if (!s) return null;
     const r = this.#t.find((n) => n.id === i);
     return r ? {
-      valueY: this.getYScale(this.#D(r)).valueToY(dt(t, s)),
+      valueY: this.getYScale(this.#I(r)).valueToY(bt(t, s)),
       seriesKind: r.renderer.kind
     } : null;
   }
@@ -1671,8 +1732,8 @@ class _e extends Et {
    * placeholder shapes to match the real bars that will render once data
    * lands. `null` when the viewport has no meaningful span yet.
    */
-  #Se() {
-    const t = this.timeScale.barWidthMedia(this.#o);
+  #De() {
+    const t = this.timeScale.barWidthMedia(this.#r);
     return Number.isFinite(t) && t > 0 ? t : null;
   }
   /**
@@ -1690,8 +1751,8 @@ class _e extends Et {
    * probed, not kind-gated: a kind check here silently kills hover for the
    * next spatial renderer.
    */
-  #bt(t) {
-    const e = this.#l.size, i = this.#d, s = {
+  #Mt(t) {
+    const e = this.#c.size, i = this.#l, s = {
       top: i.top * e.verticalPixelRatio,
       bottom: i.bottom * e.verticalPixelRatio
     };
@@ -1703,7 +1764,7 @@ class _e extends Et {
         const h = (t.mediaX - this.plotLeft) * e.horizontalPixelRatio, l = t.mediaY * e.verticalPixelRatio;
         o = a.renderer.hitTest(h, l, e.bitmap.width, e.bitmap.height, s);
       }
-      a.renderer.setHoverIndex(o) && (r = !0), o >= 0 && !n && (n = { seriesId: a.id, index: o, info: a.renderer.getHoverInfo?.(this.#n) ?? null });
+      a.renderer.setHoverIndex(o) && (r = !0), o >= 0 && !n && (n = { seriesId: a.id, index: o, info: a.renderer.getHoverInfo?.(this.#h) ?? null });
     }
     r && (this.#i.markDirty(), this.emit("seriesHover", n));
   }
@@ -1714,8 +1775,8 @@ class _e extends Et {
    * Returns the first spatial series (pie, heatmap, or a custom spatial kind)
    * whose `hitTest` claims the position, or `null` if none does.
    */
-  #Ut(t) {
-    const e = this.#l.size, i = this.#d, s = {
+  #Qt(t) {
+    const e = this.#c.size, i = this.#l, s = {
       top: i.top * e.verticalPixelRatio,
       bottom: i.bottom * e.verticalPixelRatio
     }, r = (t.mediaX - this.plotLeft) * e.horizontalPixelRatio, n = t.mediaY * e.verticalPixelRatio;
@@ -1746,42 +1807,42 @@ class _e extends Et {
    * viewport didn't move, the re-derived values are bit-identical and the
    * method exits without emitting.
    */
-  #be() {
-    const t = this.#nt;
-    this.#nt = !1;
+  #Re() {
+    const t = this.#ot;
+    this.#ot = !1;
     const e = this.#f;
     if (e === null) return;
     const { from: i, to: s } = this.timeScale.getRange(), r = this.yScale.getRange(), n = Math.abs(s - i) * 1e-9, a = Math.abs(r.max - r.min) * 1e-9, o = 1e-6;
     let h;
-    if (this.#ot === "pointer") {
-      const l = this.timeScale.snapToBand(this.timeScale.xToTime(e.mediaX - this.plotLeft)), d = this.yScale.yToValue(e.mediaY);
-      if (!Number.isFinite(l) || !Number.isFinite(d) || Math.abs(l - e.time) <= n && Math.abs(d - e.y) <= a && !t && e.x === this.timeScale.domainValue(e.time)) return;
-      h = { mediaX: e.mediaX, mediaY: e.mediaY, time: l, x: this.timeScale.domainValue(l), y: d };
+    if (this.#lt === "pointer") {
+      const l = this.timeScale.snapToBand(this.timeScale.xToTime(e.mediaX - this.plotLeft)), c = this.yScale.yToValue(e.mediaY);
+      if (!Number.isFinite(l) || !Number.isFinite(c) || Math.abs(l - e.time) <= n && Math.abs(c - e.y) <= a && !t && e.x === this.timeScale.domainValue(e.time)) return;
+      h = { mediaX: e.mediaX, mediaY: e.mediaY, time: l, x: this.timeScale.domainValue(l), y: c };
     } else {
       if (e.time < i || e.time > s) {
-        this.#f = null, this.#c.markDirty(), this.emit("crosshairMove", null), this.#bt(null);
+        this.#f = null, this.#d.markDirty(), this.emit("crosshairMove", null), this.#Mt(null);
         return;
       }
-      const l = this.plotLeft + this.timeScale.timeToX(e.time), d = this.yScale.valueToY(e.y);
-      if (!Number.isFinite(l) || !Number.isFinite(d) || Math.abs(l - e.mediaX) <= o && Math.abs(d - e.mediaY) <= o && !t && e.x === this.timeScale.domainValue(e.time)) return;
-      h = { mediaX: l, mediaY: d, time: e.time, x: this.timeScale.domainValue(e.time), y: e.y };
+      const l = this.plotLeft + this.timeScale.timeToX(e.time), c = this.yScale.valueToY(e.y);
+      if (!Number.isFinite(l) || !Number.isFinite(c) || Math.abs(l - e.mediaX) <= o && Math.abs(c - e.mediaY) <= o && !t && e.x === this.timeScale.domainValue(e.time)) return;
+      h = { mediaX: l, mediaY: c, time: e.time, x: this.timeScale.domainValue(e.time), y: e.y };
     }
-    this.#f = h, this.#c.markDirty(), this.emit("crosshairMove", h), this.#bt(h);
+    this.#f = h, this.#d.markDirty(), this.emit("crosshairMove", h), this.#Mt(h);
   }
   /** Tear down the chart: cancel animations, remove listeners, and detach the canvas. */
   destroy() {
     for (const t of this.#t) t.renderer.dispose();
-    this.#t = [], this.#y = [], this.#T = [], this.#b = [], this.#z = null, this.#i.destroy(), this.#c.destroy(), this.#V?.destroy(), this.#l.destroy(), this.#ut?.destroy(), this.#ut = null, this.#dt && this.#M?.destroy(), this.#M = null, this.#dt = !1, this.removeAllListeners();
+    this.#t = [], this.#y = [], this.#M = [], this.#S = [], this.#F = null, this.#i.destroy(), this.#d.destroy(), this.#N?.destroy(), this.#c.destroy(), this.#pt?.destroy(), this.#pt = null, this.#gt && this.#P?.destroy(), this.#P = null, this.#gt = !1, this.removeAllListeners();
   }
   /** The attached performance monitor, or `null` when instrumentation is disabled. */
   getPerfMonitor() {
-    return this.#M;
+    return this.#P;
   }
   /** Compute the earliest and latest timestamps across all series. */
   getDataBounds() {
     let t, e;
     for (const i of this.#t) {
-      if (!i.visible || !v(i.renderer)) continue;
+      if (!i.visible || !S(i.renderer)) continue;
       const s = i.renderer.getTimeBounds();
       s !== null && ((t === void 0 || s.first < t) && (t = s.first), (e === void 0 || s.last > e) && (e = s.last));
     }
@@ -1790,62 +1851,72 @@ class _e extends Et {
   /** Set by `setSeriesData`/bulk-replace paths so the next `onDataChanged`
    * snaps the Y range (instead of easing) and `yScale.getRange()` reflects
    * the new domain synchronously. Cleared by `onDataChanged` after each run. */
-  #kt = !1;
+  #nt = !1;
   onDataChanged() {
     if (this.#R > 0) {
-      this.#lt = !0;
+      this.#dt = !0;
       return;
     }
-    this.updateDataInterval();
+    this.updateDataInterval({ full: this.#nt || !this.#u });
     const { first: t, last: e } = this.getDataBounds();
-    t !== void 0 && (this.#S = t), e !== void 0 && (this.#q = this.#s, this.#s = e);
-    const i = this.#kt;
-    this.#kt = !1;
-    const s = !this.#m && t !== void 0;
+    t !== void 0 && (this.#T = t), e !== void 0 && (this.#J = this.#s, this.#s = e);
+    const i = this.#nt;
+    this.#nt = !1;
+    const s = !this.#u && t !== void 0;
     if (i) {
       this.yScale.tickTracker.reset(), this.timeScale.tickTracker.reset();
-      for (const n of this.#a.values())
+      for (const n of this.#o.values())
         n.yScale.tickTracker.reset();
     }
-    this.#Vt = i;
+    this.#Yt = i;
     const r = performance.now();
-    i || s ? (this.#F.seed(r), this.#e.onDataReplaced(r)) : this.#e.onPointAppended(r), this.#e.lastXTarget !== null && (this.#U = !0), t !== void 0 && (this.#m = !0), this.#x(r), this.syncScales(), s ? this.#wt() : this.#i.markDirty(), this.emit("dataUpdate"), this.#u();
+    i || s ? (this.#W.seed(r), this.#e.onDataReplaced(r)) : this.#e.onPointAppended(r), this.#e.lastXTarget !== null && (this.#_ = !0), t !== void 0 && (this.#u = !0), this.#x(r), this.syncScales(), s ? this.#Ct() : this.#i.markDirty(), this.emit("dataUpdate"), this.#m();
   }
-  updateDataInterval() {
-    if (this.#r === "category") {
-      this.#o = 1;
+  /** `full`: the data was replaced, so a long series is read whole instead of from its tail. */
+  updateDataInterval(t) {
+    if (this.#n === "category") {
+      this.#r = 1;
       return;
     }
-    for (const t of this.#t) {
-      if (!v(t.renderer)) continue;
-      const e = t.renderer.sampleTimes(20);
-      if (e.length >= 2) {
-        this.#o = qt(e);
-        break;
+    for (const e of this.#t) {
+      if (!S(e.renderer)) continue;
+      const i = e.renderer.sampleTimes(it + 1);
+      if (!(i.length < 2)) {
+        this.#r = this.#Ve({ renderer: e.renderer, head: i, full: t.full });
+        return;
       }
     }
   }
+  /** The step of one series. Past {@link FULL_INTERVAL_SCAN_POINTS}, an append can only refine it from the tail. */
+  #Ve(t) {
+    const { renderer: e, head: i, full: s } = t;
+    if (i.length <= it) return V(i);
+    if (s) return V(e.sampleTimes(Number.POSITIVE_INFINITY));
+    const r = e.sampleTimes(st, "end");
+    return r.length < st ? this.#r : Math.min(this.#r, V(r));
+  }
   /** Whether the Y range has been initialized (first snap vs smooth lerp).
    *  Pre-init Y emits are forced to `instant` so the first paint snaps to
    *  data regardless of the caller's requested kind. Also reset by paths
    *  that intentionally invalidate the current Y baseline (axis bound
    *  change, empty viewport). */
-  #m = !1;
+  #u = !1;
   /** Whether the engine's X slot has received its first emit. Pre-init X
    *  emits are forced to `instant` so first paint snaps to the fitted
    *  range — without this guard the engine would ease from `{0,0}` into
    *  the new target and the very first frame would render with a
    *  zero-width X domain. */
-  #U = !1;
+  #_ = !1;
   /**
-   * One-shot `setVisibleRange` argument applied on the first data arrival.
-   * Captured at chart construction from {@link ChartOptions.viewport.initialRange};
-   * cleared the moment it's consumed so subsequent data swaps don't snap
-   * back to the initial window.
+   * {@link ChartOptions.viewport.initialRange}: the chart's own window until the
+   * user or the app moves the view, so more series or a re-seed keep it. A
+   * `{ from, to }` or `{ from, bars }` window also ends once streaming moves it.
    */
-  #it;
+  #H;
+  /** The chart's own fit holds fewer bars than it asks for, so appends widen it until it is full. */
+  #U = !1;
   /** Dev warning for values the Y scale can't place — fires once per chart. */
-  #_t = !1;
+  #te = !1;
   /**
    * Sample the visible data window and return the resolved Y bounds of one
    * scale (`undefined` = default) in its scale space (see {@link resolveYTarget}),
@@ -1855,23 +1926,23 @@ class _e extends Et {
    * converge together. Clears {@link #yInited} on empty so the next emit
    * with valid data lands as an instant snap.
    */
-  #_(t, e) {
-    const i = t ?? this.#h, { yScale: s, bounds: r } = this.#pe(e), n = r.min !== void 0 && r.min !== "auto" && typeof r.min != "number" || r.max !== void 0 && r.max !== "auto" && typeof r.max != "number" ? [] : null, a = this.#ye(e), o = s.getTransform(), h = o === null ? void 0 : (d) => s.isPlottable(d);
-    h && this.#ke({ window: i, series: a, yScale: s });
-    const l = Vt({ targetVisible: i, series: a, allValues: n, plottable: h });
-    return l === null ? (e === void 0 && (this.#m = !1), null) : (e !== void 0 && (this.#m = !0), zt({ raw: l, bounds: r, allValues: n ?? [], transform: o }));
+  #G(t, e) {
+    const i = t ?? this.#a, { yScale: s, bounds: r } = this.#Pe(e), n = r.min !== void 0 && r.min !== "auto" && typeof r.min != "number" || r.max !== void 0 && r.max !== "auto" && typeof r.max != "number" ? [] : null, a = this.#Ce(e), o = s.getTransform(), h = o === null ? void 0 : (c) => s.isPlottable(c);
+    h && this.#He({ window: i, series: a, yScale: s });
+    const l = Bt({ targetVisible: i, series: a, allValues: n, plottable: h });
+    return l === null ? (e === void 0 && (this.#u = !1), null) : (e !== void 0 && (this.#u = !0), Xt({ raw: Zt(l), bounds: r, allValues: n ?? [], transform: o }));
   }
   /** Dev-only sweep behind {@link warnUnplottableValues}; stops once it has warned. */
-  #ke(t) {
-    if (this.#_t || process.env.NODE_ENV === "production") return;
+  #He(t) {
+    if (this.#te || process.env.NODE_ENV === "production") return;
     const { window: e, series: i, yScale: s } = t;
     for (const r of i) {
-      if (!r.visible || !v(r.renderer)) continue;
+      if (!r.visible || !S(r.renderer)) continue;
       const n = r.renderer.getValueRange(e.from, e.to);
       if (n === null) continue;
       const a = (r.renderer.stacking === "normal" || r.renderer.stacking === "percent" ? n.min < 0 && !s.isPlottable(n.min) : !s.isPlottable(n.min)) ? n.min : s.isPlottable(n.max) ? null : n.max;
       if (a !== null) {
-        this.#_t = !0, At({ seriesId: r.id, value: a });
+        this.#te = !0, Ht({ seriesId: r.id, value: a });
         return;
       }
     }
@@ -1894,53 +1965,112 @@ class _e extends Et {
    * - **autoscroll off** → `null` (no X retarget; user has panned away
    *   from the tail).
    */
-  #we() {
-    if (this.#S === null || this.#s === null) return null;
-    const { from: t, to: e } = this.#h, i = t === 0 && e === 0, s = this.#l.size.media.width - this.#w();
-    if (this.#r === "category")
-      return this.#O(this.#S, this.#s, s), this.#h;
-    if (i) {
-      if (this.#O(this.#S, this.#s, s), this.#it !== void 0 && (this.setVisibleRange(this.#it), this.#it = void 0, !this.#p && this.#s !== null)) {
-        const { to: n } = this.#h;
-        this.#s >= n && this.#s - n <= this.#o * 1.5 && (this.#p = !0);
-      }
-      return this.#h;
-    }
+  #Ne() {
+    if (this.#T === null || this.#s === null) return null;
+    const { from: t, to: e } = this.#a, i = t === 0 && e === 0, s = this.#c.size.media.width - this.#k();
+    if (this.#n === "category")
+      return this.#Pt({ firstTime: this.#T, lastTime: this.#s, chartWidth: s }), this.#a;
+    if (i)
+      return this.#At(s), this.#a;
     if (!this.#p) return null;
-    if (this.#Vt)
-      return this.#O(this.#S, this.#s, s), this.#h;
-    const r = Pt({
-      currentLogical: this.#h,
+    if (this.#Yt)
+      return this.#At(s), this.#a;
+    if (this.#U) {
+      const n = this.#ie(s);
+      if (n !== null) return this.#Fe(n);
+    }
+    const r = Ft({
+      currentLogical: this.#a,
       lastTime: this.#s,
-      prevDataEnd: this.#q,
-      dataInterval: this.#o,
-      paddingRight: this.#d.right,
+      prevDataEnd: this.#J,
+      dataInterval: this.#r,
+      paddingRight: this.#l.right,
       chartWidth: s,
       holdUntilFilled: this.#L
     });
-    return r.releaseHold && (this.#L = !1), r.reengageAutoScroll && (this.#p = !0), r.newLogical === null ? null : (this.#F.observe(performance.now()), this.#e.setXSettleMs(this.#F.pickSettleMs(this.#g.axis.x.settleMs)), this.#H(r.newLogical, { emitChange: !1, skipValidation: !0 }), this.#q = this.#s, r.newLogical);
+    return r.releaseHold && (this.#L = !1), r.reengageAutoScroll && (this.#p = !0), r.newLogical === null ? null : (typeof this.#H == "object" && (this.#H = void 0), this.#ee(r.newLogical));
+  }
+  /** Commit an X target that follows the data tail; the engine eases there. */
+  #ee(t) {
+    return this.#W.observe(performance.now()), this.#e.setXSettleMs(this.#W.pickSettleMs(this.#g.axis.x.settleMs)), this.#D(t, { emitChange: !1, skipValidation: !0 }), this.#J = this.#s, t;
   }
   /**
-   * Fit the viewport's logical X range around a data span. Mirrors the
-   * old `viewport.fitToData` side effects: clears the warm-up hold,
-   * forces autoscroll on (data tail is in the new window by construction),
-   * commits the new range via `viewport.setRange` (which emits `change`).
+   * Fit X to the window the chart picks for itself: `initialRange` while it
+   * holds, else every bar up to `maxVisibleBars`. Runs on the first data, on a
+   * bulk replace and on a horizontal padding change.
    */
-  #O(t, e, i) {
-    const s = this.timeScale.bandRange();
-    if (this.#r === "category" && s !== null) {
-      this.#L = !1, this.#p = !0, this.#H(s, { emitChange: !0, skipValidation: !0 });
-      return;
+  #At(t) {
+    const e = this.#H;
+    if (typeof e == "object") {
+      if (this.#U = !1, this.#jt(e), this.#a.from !== 0 || this.#a.to !== 0) {
+        this.#We();
+        return;
+      }
+      this.#H = void 0;
     }
-    const r = this.#d, n = ft({
-      firstTime: t,
-      lastTime: e,
-      dataInterval: this.#o,
-      maxVisibleBars: this.#zt,
-      chartWidth: i,
-      padding: { left: r.left, right: r.right }
+    const i = this.#ie(t);
+    i !== null && (this.#L = !1, this.#p = !0, this.#U = i.filling, this.#D(i.range, { emitChange: !0 }));
+  }
+  /**
+   * The chart's own window over the current data: the last `initialRange`
+   * bars, else every bar up to `maxVisibleBars`. `filling` while the data holds
+   * fewer bars than that. `null` before data, or for a `{ from, … }` window.
+   */
+  #ie(t) {
+    const e = this.#H, i = this.#T, s = this.#s;
+    if (i === null || s === null || typeof e == "object") return null;
+    const r = e ?? this.#ft, n = Math.max(i, s - (r - 1) * this.#r);
+    return { range: Z({
+      firstTime: e === void 0 ? i : n,
+      lastTime: s,
+      dataInterval: this.#r,
+      // An explicit bar count is shown whole; only the default fit is capped.
+      maxVisibleBars: e === void 0 ? this.#ft : Number.POSITIVE_INFINITY,
+      chartWidth: t,
+      padding: { left: this.#l.left, right: this.#l.right }
+    }), filling: n === i };
+  }
+  /** Widen the chart's own fit to the data tail. A trimmed head never narrows it (`keepLast`). */
+  #Fe(t) {
+    this.#U = t.filling;
+    const e = this.#a, i = e.to - e.from, s = t.range.to - t.range.from;
+    if (t.range.to === e.to && s <= i) return null;
+    const r = Math.max(s, i);
+    return this.#ee({ from: t.range.to - r, to: t.range.to });
+  }
+  /**
+   * `setVisibleRange` reads a window that ends before the data tail as
+   * "panned into history" and drops tail-follow. That is wrong for a streaming
+   * lead-in that parks the seed just past the right edge so the first tick
+   * scrolls it into view (the Sparkline `flow.align: 'offscreen'` drive-in) —
+   * without follow-live the stream accumulates off-canvas forever. Re-arm when
+   * the tail sits within ~one interval past the window.
+   */
+  #We() {
+    if (this.#p || this.#s === null) return;
+    const { to: t } = this.#a;
+    this.#s >= t && this.#s - t <= this.#r * 1.5 && (this.#p = !0);
+  }
+  /**
+   * Fit the viewport's logical X range around a data span, padding included.
+   * Clears the warm-up hold, forces autoscroll on (the data tail is in the new
+   * window by construction) and emits `viewportChange`. Returns whether the range changed.
+   */
+  #Pt(t) {
+    const { firstTime: e, lastTime: i, chartWidth: s } = t;
+    this.#L = !1, this.#p = !0;
+    const r = this.timeScale.bandRange();
+    if (this.#n === "category" && r !== null)
+      return this.#D(r, { emitChange: !0, skipValidation: !0 });
+    const n = Z({
+      firstTime: e,
+      lastTime: i,
+      dataInterval: this.#r,
+      maxVisibleBars: Number.POSITIVE_INFINITY,
+      chartWidth: s,
+      padding: { left: this.#l.left, right: this.#l.right }
     });
-    this.#L = !1, this.#p = !0, this.#H(n, { emitChange: !0 });
+    return this.#D(n, { emitChange: !0 });
   }
   /**
    * Commit a programmatic zoom — `fitContent` or `setVisibleRange`. Reads
@@ -1956,12 +2086,12 @@ class _e extends Et {
    *   passes `xEase: true` so X eases instead — viewport and axis converge
    *   on the same frame.
    */
-  #st(t) {
-    const e = this.#h;
+  #se(t) {
+    const e = this.#a;
     if (e.to <= e.from) return;
     const i = performance.now();
-    if (!this.#U || !this.#m) {
-      this.#Gt(i);
+    if (!this.#_ || !this.#u) {
+      this.#re(i);
       return;
     }
     this.#e.onProgrammaticZoom({ xTarget: e, xEase: t?.xEase }, i), this.#x(i);
@@ -1978,12 +2108,12 @@ class _e extends Et {
    * instead of lagging on the long sticky contract. First paint still snaps
    * (same as the programmatic path) so synchronous readers see final values.
    */
-  #Te() {
-    const t = this.#h;
+  #$e() {
+    const t = this.#a;
     if (t.to <= t.from) return;
     const e = performance.now();
-    if (!this.#U || !this.#m) {
-      this.#Gt(e);
+    if (!this.#_ || !this.#u) {
+      this.#re(e);
       return;
     }
     this.#e.onPanZoom({ xTarget: t, yAuto: !0 }, e), this.#x(e);
@@ -1995,13 +2125,13 @@ class _e extends Et {
    * commits — both must snap before the chart has painted once so a
    * synchronous `getYRange()` / `getVisibleRange()` read sees final values.
    */
-  #Gt(t) {
-    const e = this.#h, i = this.#_(e), s = {};
-    for (const r of this.#a.keys()) {
-      const n = this.#_(e, r);
+  #re(t) {
+    const e = this.#a, i = this.#G(e), s = {};
+    for (const r of this.#o.keys()) {
+      const n = this.#G(e, r);
       n !== null && (s[r] = n);
     }
-    this.#U = !0, i !== null && (this.#m = !0), this.#e.snap({ x: e, y: i ?? void 0, scales: s }, t), this.#x(t);
+    this.#_ = !0, i !== null && (this.#u = !0), this.#e.snap({ x: e, y: i ?? void 0, scales: s }, t), this.#x(t);
   }
   /**
    * Validate and commit a new logical X range. Mirrors the old
@@ -2021,9 +2151,9 @@ class _e extends Et {
    * see `setVisibleRange`'s gesture path, where a per-frame echo would
    * otherwise re-arm and stall the in-flight Y ease.
    */
-  #H(t, e) {
+  #D(t, e) {
     const { from: i, to: s } = t;
-    return !Number.isFinite(i) || !Number.isFinite(s) || s <= i || !e.skipValidation && (s - i) / this.#o < 2 || this.#h.from === i && this.#h.to === s ? !1 : (this.#h = { from: i, to: s }, e.emitChange && (this.syncScales(), this.#i?.markDirty(), this.emit("viewportChange")), !0);
+    return !Number.isFinite(i) || !Number.isFinite(s) || s <= i || !e.skipValidation && (s - i) / this.#r < 2 || this.#a.from === i && this.#a.to === s ? !1 : (this.#a = { from: i, to: s }, e.emitChange && (this.syncScales(), this.#i?.markDirty(), this.emit("viewportChange")), !0);
   }
   /**
    * Apply pixel-padding to the engine's Y (scale space) and return it as
@@ -2032,23 +2162,23 @@ class _e extends Et {
    * that has an explicit (fixed) axis bound. Padding in scale space keeps
    * the pixel gutters even on a log axis.
    */
-  #Ae(t) {
-    const { slot: e, min: i, max: s, chartHeight: r } = t, { yScale: n } = e, { min: a, max: o } = this.#Me(e), h = s - i, l = r > 0 ? this.#d.top / r * h : 0, d = r > 0 ? this.#d.bottom / r * h : 0, f = {
-      min: a ? i : i - d,
+  #ze(t) {
+    const { slot: e, min: i, max: s, chartHeight: r } = t, { yScale: n } = e, { min: a, max: o } = this.#Oe(e), h = s - i, l = r > 0 ? this.#l.top / r * h : 0, c = r > 0 ? this.#l.bottom / r * h : 0, f = {
+      min: a ? i : i - c,
       max: o ? s : s + l
-    }, c = n.getTransform();
-    if (c === null) return f;
-    const m = c.inverse(f.min), y = c.inverse(f.max), u = n.isPlottable(m) && m <= c.inverse(i), g = n.isPlottable(y) && y >= c.inverse(s);
+    }, g = n.getTransform();
+    if (g === null) return f;
+    const y = g.inverse(f.min), u = g.inverse(f.max), m = n.isPlottable(y) && y <= g.inverse(i), p = n.isPlottable(u) && u >= g.inverse(s);
     return {
-      min: u ? m : c.inverse(i),
-      max: g ? y : c.inverse(s)
+      min: m ? y : g.inverse(i),
+      max: p ? u : g.inverse(s)
     };
   }
   /** Which Y edges of a scale the user pinned — a pinned edge takes no padding. */
-  #Me(t) {
+  #Oe(t) {
     return {
-      min: J(t.bounds.min, t.yScale),
-      max: J(t.bounds.max, t.yScale)
+      min: ot(t.bounds.min, t.yScale),
+      max: ot(t.bounds.max, t.yScale)
     };
   }
   /**
@@ -2061,18 +2191,18 @@ class _e extends Et {
    * as a gesture for visual easing. Public so consumers can drive pan
    * programmatically.
    */
-  pan(t, e = this.#J) {
-    e > 0 && (this.#J = e), this.#L = !1;
-    const i = St({
-      currentLogical: this.#h,
+  pan(t, e = this.#Q) {
+    e > 0 && (this.#Q = e), this.#L = !1, this.#et();
+    const i = Lt({
+      currentLogical: this.#a,
       timeDelta: t,
       chartWidth: e,
-      dataInterval: this.#o,
-      padding: { left: this.#d.left, right: this.#d.right },
-      dataStart: this.#S,
+      dataInterval: this.#r,
+      padding: { left: this.#l.left, right: this.#l.right },
+      dataStart: this.#T,
       dataEnd: this.#s
     });
-    i.newLogical !== null && (this.#p = !i.autoScrollOff, this.#H(i.newLogical, { emitChange: !0 }), i.edgeReached !== null && (this.#Dt[i.edgeReached.side] = i.edgeReached.boundaryTime, this.#Rt?.(i.edgeReached)), this.#F.pause(), this.#Kt());
+    i.newLogical !== null && (this.#p = !i.autoScrollOff, this.#D(i.newLogical, { emitChange: !0 }), i.edgeReached !== null && (this.#Ft[i.edgeReached.side] = i.edgeReached.boundaryTime, this.#Wt?.(i.edgeReached)), this.#W.pause(), this.#ne());
   }
   /**
    * Zoom around a time anchor. `factor < 1` zooms in, `> 1` zooms out.
@@ -2089,35 +2219,35 @@ class _e extends Et {
    * and produce a visible jump). Cursor-anchored zoom is intentionally
    * sacrificed in follow-live mode — pan first to inspect history.
    */
-  zoomAt(t, e, i = this.#J) {
-    i > 0 && (this.#J = i), this.#L = !1;
-    const s = bt({
-      currentLogical: this.#h,
+  zoomAt(t, e, i = this.#Q) {
+    i > 0 && (this.#Q = i), this.#L = !1, this.#et();
+    const s = It({
+      currentLogical: this.#a,
       centerTime: t,
       factor: e,
       chartWidth: i,
-      dataInterval: this.#o,
-      padding: { left: this.#d.left, right: this.#d.right },
-      dataStart: this.#S,
+      dataInterval: this.#r,
+      padding: { left: this.#l.left, right: this.#l.right },
+      dataStart: this.#T,
       dataEnd: this.#s
     });
     if (s.newLogical === null) return;
     let r = s.newLogical;
     if (this.#p && this.#s !== null) {
-      const n = r.to - r.from, a = N(this.#d.right, n, this.#o, i), o = this.#s + a;
-      r = { from: o - n, to: o }, this.#q = this.#s;
+      const n = r.to - r.from, a = j(this.#l.right, n, this.#r, i), o = this.#s + a;
+      r = { from: o - n, to: o }, this.#J = this.#s;
     }
-    this.#H(r, { emitChange: !0 }), this.#F.pause(), this.#Kt();
+    this.#D(r, { emitChange: !0 }), this.#W.pause(), this.#ne();
   }
   /**
    * Common tail for `pan` / `zoomAt`: routes the just-committed `#logical`
    * to the engine as a gesture so the X spring retargets and the Y spring
    * eases over `animations.axis.y.gesture`.
    */
-  #Kt() {
-    const t = this.#h;
+  #ne() {
+    const t = this.#a;
     if (t.to <= t.from) return;
-    this.#U = !0, this.#m = !0;
+    this.#_ = !0, this.#u = !0;
     const e = performance.now();
     this.#e.onPanZoom({ xTarget: t, yAuto: !0 }, e), this.#x(e);
   }
@@ -2135,26 +2265,34 @@ class _e extends Et {
    * events long enough for the slot processor to snap them.
    */
   #x(t) {
-    const e = this.#e.tick(t), i = this.#l.size;
+    const e = this.#e.tick(t), i = this.#c.size;
     if (i.media.width === 0 || i.media.height === 0) return;
     const s = i.media.height - this.xAxisHeight;
-    for (const { slot: r, range: n } of this.#jt(e))
-      this.#qt({ slot: r, range: n, chartHeight: s });
+    for (const { slot: r, range: n } of this.#ae(e))
+      this.#oe({ slot: r, range: n, chartHeight: s });
     this.syncScales();
   }
+  /** Record the X and Y ranges this paint draws; `true` when any moved since the last paint. */
+  #Ye(t) {
+    let e = t.from !== this.#tt.from || t.to !== this.#tt.to;
+    this.#tt.from = t.from, this.#tt.to = t.to, nt(this.#w) && (e = !0);
+    for (const i of this.#o.values())
+      nt(i) && (e = !0);
+    return e;
+  }
   /** Each scale's slot with the engine's current Y (scale space) for it. */
-  #jt(t) {
-    const e = [{ slot: this.#P, range: t.yRange }];
-    for (const [i, s] of this.#a) {
+  #ae(t) {
+    const e = [{ slot: this.#w, range: t.yRange }];
+    for (const [i, s] of this.#o) {
       const r = this.#e.getScaleYRange(i);
       r !== null && e.push({ slot: s, range: r });
     }
     return e;
   }
   /** Pad an engine Y (scale space) into the slot's value range and remember it. */
-  #qt(t) {
+  #oe(t) {
     const { slot: e, range: i, chartHeight: s } = t, r = e.range;
-    e.range = this.#Ae({ slot: e, min: i.min, max: i.max, chartHeight: s }), e.prevMin = i.min, e.prevMax = i.max, (r.min !== e.range.min || r.max !== e.range.max) && e !== this.#P && (this.#nt = !0);
+    e.range = this.#ze({ slot: e, min: i.min, max: i.max, chartHeight: s }), e.prevMin = i.min, e.prevMax = i.max, (r.min !== e.range.min || r.max !== e.range.max) && e !== this.#w && (this.#ot = !0);
   }
   /**
    * Lightweight scale sync: updates timeScale/yScale from current viewport state
@@ -2162,99 +2300,104 @@ class _e extends Et {
    * handler, so DOM axis components always read fresh coordinates on re-render.
    */
   syncScales() {
-    const t = this.#l.size;
+    const t = this.#c.size;
     if (t.media.width === 0 || t.media.height === 0) return;
-    const e = t.media.width - this.#w(), i = t.media.height - this.xAxisHeight;
+    const e = t.media.width - this.#k(), i = t.media.height - this.xAxisHeight;
     this.timeScale.update(
       this.#e.getAnimationState().xRange,
       e,
       t.horizontalPixelRatio,
-      this.#o
-    ), this.yScale.update(this.#P.range, i, t.verticalPixelRatio);
-    for (const s of this.#a.values())
+      this.#r
+    ), this.yScale.update(this.#w.range, i, t.verticalPixelRatio);
+    for (const s of this.#o.values())
       s.yScale.update(s.range, i, t.verticalPixelRatio);
   }
   /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
   renderMain(t) {
-    const e = this.#l.size;
+    const e = this.#c.size;
     if (e.media.width === 0 || e.media.height === 0) return;
     const i = typeof t == "number" ? t : performance.now(), s = this.#e.tick(i);
     s.animating && this.#i.markDirty();
     const r = e.media.height - this.xAxisHeight;
     let n = !1;
-    for (const { slot: c, range: m } of this.#jt(s))
-      m.min === c.prevMin && m.max === c.prevMax || (this.#qt({ slot: c, range: m, chartHeight: r }), n = !0);
-    if (this.syncScales(), this.#be(), this.#s !== null && !this.#p) {
-      const c = this.#e.lastXTarget ?? this.#h, m = c.to - c.from;
+    for (const { slot: u, range: m } of this.#ae(s))
+      m.min === u.prevMin && m.max === u.prevMax || (this.#oe({ slot: u, range: m, chartHeight: r }), n = !0);
+    if (this.syncScales(), this.#Re(), this.#s !== null && !this.#p) {
+      const u = this.#e.lastXTarget ?? this.#a, m = u.to - u.from;
       if (m > 0) {
-        const y = this.#l.size.media.width - this.#w(), u = N(this.#d.right, m, this.#o, y), g = this.#o * 0.5;
-        Math.abs(c.to - (this.#s + u)) < g && (this.#p = !0);
+        const p = this.#c.size.media.width - this.#k(), x = j(this.#l.right, m, this.#r, p), T = this.#r * 0.5;
+        Math.abs(u.to - (this.#s + x)) < T && (this.#p = !0);
       }
     }
-    n && this.emit("viewportChange");
-    let a = !1, o = !1, h = !1, l = !1;
-    this.#l.useMainLayer((c) => {
-      const { context: m, bitmapSize: y } = c, u = (e.media.width - this.#w()) * e.horizontalPixelRatio, g = (e.media.height - this.xAxisHeight) * e.verticalPixelRatio, S = this.#W(c);
-      m.clearRect(0, 0, y.width, y.height), m.save(), m.translate(S, 0), m.beginPath(), m.rect(0, 0, this.#re(c, u), g), m.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#o).ticks), this.yScale.tickTracker.tick(i), this.timeScale.tickTracker.tick(i);
-      for (const x of this.#a.values()) {
-        const b = x.yScale.tickTracker;
-        b.setCurrentTicks(x.yScale.niceTickValues()), b.tick(i) && (h = !0);
+    const a = this.#Ye(s.xRange);
+    (n || a && !s.animating) && this.emit("viewportChange");
+    let o = !1, h = !1, l = !1, c = !1;
+    this.#c.useMainLayer((u) => {
+      const { context: m, bitmapSize: p } = u, x = (e.media.width - this.#k()) * e.horizontalPixelRatio, T = (e.media.height - this.xAxisHeight) * e.verticalPixelRatio, N = this.#z(u);
+      m.clearRect(0, 0, p.width, p.height), m.save(), m.translate(N, 0), m.beginPath(), m.rect(0, 0, this.#fe(u, x), T), m.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#r).ticks), this.yScale.tickTracker.tick(i), this.timeScale.tickTracker.tick(i);
+      for (const v of this.#o.values()) {
+        const b = v.yScale.tickTracker;
+        b.setCurrentTicks(v.yScale.niceTickValues()), b.tick(i) && (l = !0);
       }
-      const w = this.yScale.tickTracker.snapshot(), T = this.timeScale.tickTracker.snapshot();
-      a = w.isAnimating, o = T.isAnimating, (w.isAnimating || T.isAnimating || h || s.animating) && this.emit("tickFrame");
-      const A = this.#G ? 1 : 0;
-      if ((A === 0 || w.entries.length > 0 || T.entries.length > 0) && A !== this.#E.target) {
-        const x = ht() ? 0 : this.#g.axis.gridMs;
-        this.#E.setTarget(A, { now: i, duration: x });
+      const w = this.yScale.tickTracker.snapshot(), M = this.timeScale.tickTracker.snapshot();
+      o = w.isAnimating, h = M.isAnimating;
+      const P = w.isAnimating || M.isAnimating || l, ct = this.#Ht && !P;
+      this.#Ht = P, (P || ct || s.animating) && this.emit("tickFrame");
+      const C = this.#j ? 1 : 0;
+      if ((C === 0 || w.entries.length > 0 || M.entries.length > 0) && C !== this.#Y.target) {
+        const v = xt() ? 0 : this.#g.axis.gridMs;
+        this.#Y.setTarget(C, { now: i, duration: v });
       }
-      l = this.#E.tick(i);
-      const R = this.#E.current, I = this.#r === "category" ? ie : T, H = {
-        scope: c,
+      c = this.#Y.tick(i);
+      const F = this.#Y.current, W = this.#n === "category" ? de : M, $ = {
+        scope: u,
         timeScale: this.timeScale,
         yScale: this.yScale,
-        theme: this.#n,
+        theme: this.#h,
         yTicks: w,
-        timeTicks: I,
-        alpha: R
-      }, M = this.#ie(c, u);
-      M === 0 && X(H), this.#ce(c, u, g);
-      const V = this.#d, et = { top: V.top, bottom: V.bottom }, it = this.#ft(s), z = this.#M;
-      for (const x of this.#t) {
-        this.#fe(x);
-        const b = x.renderer.getAlpha?.() ?? (x.visible ? 1 : 0);
+        timeTicks: W,
+        alpha: F
+      }, L = this.#ue(u, x);
+      L === 0 && K($), this.#be(u, x, T);
+      const z = this.#l, dt = { top: z.top, bottom: z.bottom }, ut = this.#xt(s), O = this.#P;
+      for (const v of this.#t) {
+        this.#Me(v);
+        const b = v.renderer.getAlpha?.() ?? (v.visible ? 1 : 0);
         if (b <= 0) continue;
-        const P = this.#D(x), st = this.getYScale(P), O = {
-          scope: c,
+        const I = this.#I(v), mt = this.getYScale(I), E = {
+          scope: u,
           timeScale: this.timeScale,
-          yScale: st,
-          theme: this.#n,
-          dataInterval: this.#o,
-          padding: et,
-          state: P === void 0 ? it : this.#Wt(s, P),
-          seriesId: x.id
-        }, $ = m.globalAlpha;
-        if (b < 1 && (m.globalAlpha = $ * b), z) {
-          const rt = performance.now();
-          x.renderer.render(O), z.recordSeries(x.id, performance.now() - rt, i);
+          yScale: mt,
+          theme: this.#h,
+          dataInterval: this.#r,
+          padding: dt,
+          state: I === void 0 ? ut : this.#Zt(s, I),
+          seriesId: v.id
+        }, B = m.globalAlpha;
+        if (b < 1 && (m.globalAlpha = B * b), O) {
+          const ft = performance.now();
+          v.renderer.render(E), O.recordSeries(v.id, performance.now() - ft, i);
         } else
-          x.renderer.render(O);
-        b < 1 && (m.globalAlpha = $);
+          v.renderer.render(E);
+        b < 1 && (m.globalAlpha = B);
       }
       m.restore();
-      const F = { left: S, width: u, height: g };
-      M === 0 ? (this.#Qt({ scope: c, pane: F, timeTicks: I, alpha: R }), this.#$(c, u, "left"), this.#$(c, u, "right")) : (this.#$(c, u, "left"), this.#Le({ grid: H, pane: F, overhang: M }), this.#$(c, u, "right")), this.#ee(c, u), this.#Jt(c, g);
-    }), this.#pt();
-    let d = !1;
-    for (const c of this.#t)
-      if (c.renderer.needsAnimation) {
-        d = !0, this.#i.markDirty();
+      const Y = { left: N, width: x, height: T };
+      L === 0 ? (this.#le({ scope: u, pane: Y, timeTicks: W, alpha: F }), this.#$(u, x, "left"), this.#$(u, x, "right")) : (this.#$(u, x, "left"), this.#Xe({ grid: $, pane: Y, overhang: L }), this.#$(u, x, "right")), this.#de(u, x), this.#he(u, T);
+    }), this.#St();
+    let f = !1;
+    for (const u of this.#t)
+      if (u.renderer.needsAnimation) {
+        f = !0, this.#i.markDirty();
         break;
       }
-    const f = a || o || h;
-    if ((f || l) && this.#i.markDirty(), !s.animating && !d && !f) {
+    const g = f || this.#Ot;
+    this.#Ot = f, g && (this.#zt++, this.emit("seriesFrame"));
+    const y = o || h || l;
+    if ((y || c) && this.#i.markDirty(), !s.animating && !f && !y) {
       this.yScale.tickTracker.markArmed(), this.timeScale.tickTracker.markArmed();
-      for (const c of this.#a.values())
-        c.yScale.tickTracker.markArmed();
+      for (const u of this.#o.values())
+        u.yScale.tickTracker.markArmed();
     }
   }
   /**
@@ -2264,12 +2407,12 @@ class _e extends Et {
    * a paint-over — so the container background behind the canvas (solid or
    * CSS gradient) shows through untouched.
    */
-  #Jt(t, e) {
+  #he(t, e) {
     if (this.#C.top <= 0) return;
     const i = Math.min(Math.round(this.#C.top * t.verticalPixelRatio), Math.round(e));
     if (i < 1) return;
     const { context: s } = t;
-    s.save(), s.globalCompositeOperation = "destination-out", s.fillStyle = this.#Re(s, i), s.fillRect(0, 0, t.bitmapSize.width, i), s.restore();
+    s.save(), s.globalCompositeOperation = "destination-out", s.fillStyle = this.#_e(s, i), s.fillRect(0, 0, t.bitmapSize.width, i), s.restore();
   }
   /**
    * Run the vertical gridlines a short stub past the pane floor, dissolving
@@ -2279,23 +2422,23 @@ class _e extends Et {
    * nothing else paints) and faded with the same destination-out ramp the
    * edge masks use, so the taper stays correct over any background.
    */
-  #Qt(t) {
+  #le(t) {
     const { scope: e, pane: i, timeTicks: s, alpha: r } = t;
-    if (!this.#G && r <= 0.01 || this.xAxisHeight === 0) return;
-    const { context: n, horizontalPixelRatio: a, verticalPixelRatio: o } = e, h = Math.round(i.height), l = Math.round(D * o);
+    if (!this.#j && r <= 0.01 || this.xAxisHeight === 0) return;
+    const { context: n, horizontalPixelRatio: a, verticalPixelRatio: o } = e, h = Math.round(i.height), l = Math.round(H * o);
     if (l < 1) return;
-    const d = this.#n.grid;
-    n.save(), n.strokeStyle = d.color, d.style === "dashed" ? n.setLineDash([4 * a, 4 * a]) : d.style === "dotted" && n.setLineDash([1 * a, 3 * a]), n.lineDashOffset = h, n.lineWidth = Gt(a);
-    const f = Kt(a), c = Math.round(i.width);
-    for (const { value: m, opacity: y } of s.entries) {
-      const u = y * r;
-      if (u <= 0.01) continue;
-      const g = Math.round(this.timeScale.timeToBitmapX(m)) + f;
-      if (g < 0 || g > c) continue;
-      const S = i.left + g;
-      n.globalAlpha = u, n.beginPath(), n.moveTo(S, h), n.lineTo(S, h + l), n.stroke();
+    const c = this.#h.grid;
+    n.save(), n.strokeStyle = c.color, c.style === "dashed" ? n.setLineDash([4 * a, 4 * a]) : c.style === "dotted" && n.setLineDash([1 * a, 3 * a]), n.lineDashOffset = h, n.lineWidth = re(a);
+    const f = ne(a), g = Math.round(i.width);
+    for (const { value: y, opacity: u } of s.entries) {
+      const m = u * r;
+      if (m <= 0.01) continue;
+      const p = Math.round(this.timeScale.timeToBitmapX(y)) + f;
+      if (p < 0 || p > g) continue;
+      const x = i.left + p;
+      n.globalAlpha = m, n.beginPath(), n.moveTo(x, h), n.lineTo(x, h + l), n.stroke();
     }
-    n.restore(), this.#te(e, i.height);
+    n.restore(), this.#ce(e, i.height);
   }
   /**
    * Erase ramp over the below-pane overrun strip — the gridline tail stubs
@@ -2303,12 +2446,12 @@ class _e extends Et {
    * erased at the pane floor, total at the strip's bottom edge, so whatever
    * crosses the floor tapers out short of the time-axis labels.
    */
-  #te(t, e) {
+  #ce(t, e) {
     if (this.xAxisHeight === 0) return;
-    const i = Math.round(e), s = Math.round(D * t.verticalPixelRatio);
+    const i = Math.round(e), s = Math.round(H * t.verticalPixelRatio);
     if (s < 1) return;
     const { context: r } = t;
-    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#He({ context: r, start: i, height: s }), r.fillRect(0, i, t.bitmapSize.width, s), r.restore();
+    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#Ge({ context: r, start: i, height: s }), r.fillRect(0, i, t.bitmapSize.width, s), r.restore();
   }
   /**
    * Crosshair hairlines with the same edge melt the main layer runs: the
@@ -2320,18 +2463,18 @@ class _e extends Et {
    * edge. Erases alpha (destination-out), so it must run while the
    * crosshair is the only content on the layer.
    */
-  #Pe(t) {
+  #Ee(t) {
     const e = this.#f;
     if (e === null) return;
-    const { scope: i, chartBitmapWidth: s, chartBitmapHeight: r } = t, { context: n } = i, a = this.#W(i), o = this.#re(i, s), h = this.#ie(i, s), l = this.xAxisHeight > 0 ? Math.round(D * i.verticalPixelRatio) : 0;
-    n.save(), n.translate(a, 0), n.beginPath(), n.rect(-h, 0, o + h, r + l), n.clip(), Ft({
+    const { scope: i, chartBitmapWidth: s, chartBitmapHeight: r } = t, { context: n } = i, a = this.#z(i), o = this.#fe(i, s), h = this.#ue(i, s), l = this.xAxisHeight > 0 ? Math.round(H * i.verticalPixelRatio) : 0;
+    n.save(), n.translate(a, 0), n.beginPath(), n.rect(-h, 0, o + h, r + l), n.clip(), _t({
       scope: i,
       bitmapX: e.mediaX * i.horizontalPixelRatio - a,
       bitmapY: e.mediaY * i.verticalPixelRatio,
-      theme: this.#n,
+      theme: this.#h,
       pane: { width: s, height: r },
       leftOverhang: h
-    }), n.restore(), this.#te(i, r), h === 0 ? this.#$(i, s, "left") : this.#se(i, h), this.#$(i, s, "right"), this.#ee(i, s), this.#Jt(i, r);
+    }), n.restore(), this.#ce(i, r), h === 0 ? this.#$(i, s, "left") : this.#me(i, h), this.#$(i, s, "right"), this.#de(i, s), this.#he(i, r);
   }
   /**
    * Horizontal companion to {@link #applyTopFade}: dissolve content that
@@ -2341,57 +2484,57 @@ class _e extends Et {
    * at the edges in step with their lines above.
    */
   #$(t, e, i) {
-    const s = this.#rt(t, e, i);
+    const s = this.#at(t, e, i);
     if (s === null) return;
     const { context: r } = t, n = Math.min(s.inner, s.outer), a = Math.abs(s.outer - s.inner);
-    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#Ie({ context: r, side: i, zone: s }), r.fillRect(n, 0, a, t.bitmapSize.height), r.restore();
+    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#Ue({ context: r, side: i, zone: s }), r.fillRect(n, 0, a, t.bitmapSize.height), r.restore();
   }
   /** Dissolve content leaving through a plain canvas edge — the side opposite
    *  the Y axis, or either side on a spatial-only chart — when configured. */
-  #ee(t, e) {
+  #de(t, e) {
     const { context: i } = t;
-    for (const s of this.#Ce()) {
-      const r = this.#De({ scope: t, paneBitmapWidth: e, side: s });
+    for (const s of this.#Be()) {
+      const r = this.#Ze({ scope: t, paneBitmapWidth: e, side: s });
       if (r === null) continue;
       const n = Math.min(r.edge, r.inner), a = Math.abs(r.inner - r.edge);
-      i.save(), i.globalCompositeOperation = "destination-out", i.fillStyle = this.#ze({ context: i, side: s, zone: r }), i.fillRect(n, 0, a, t.bitmapSize.height), i.restore();
+      i.save(), i.globalCompositeOperation = "destination-out", i.fillStyle = this.#Ke({ context: i, side: s, zone: r }), i.fillRect(n, 0, a, t.bitmapSize.height), i.restore();
     }
   }
   /** Sides whose fade is a plain edge zone rather than the axis-column ramp —
    *  neither the default axis's side nor one a named scale's column holds. */
-  #Ce() {
-    if (this.#Q()) return ee;
-    const t = q(this.yAxisPosition);
-    return this.getAxisColumnWidth(t) > 0 ? se : t === "left" ? re : ne;
+  #Be() {
+    if (this.#it()) return ce;
+    const t = at(this.yAxisPosition);
+    return this.getAxisColumnWidth(t) > 0 ? ue : t === "left" ? me : fe;
   }
   /** Bitmap px the gridlines and crosshair run under a left Y-axis column, where
    *  data can't follow (see {@link #axisFadeZone}). `0` without one or with its fade off. */
-  #ie(t, e) {
-    return this.#rt(t, e, "left") === null ? 0 : Math.min(Math.round(K * t.horizontalPixelRatio), this.#W(t));
+  #ue(t, e) {
+    return this.#at(t, e, "left") === null ? 0 : Math.min(Math.round(et * t.horizontalPixelRatio), this.#z(t));
   }
   /** Left-axis grid pass, run after the axis fade: `destination-over` keeps the
    *  gridlines out of the data ramp, then they taper out under the column. */
-  #Le(t) {
+  #Xe(t) {
     const { grid: e, pane: i, overhang: s } = t, { scope: r } = e, { context: n } = r;
     n.save(), n.globalCompositeOperation = "destination-over";
-    const a = this.#rt(r, i.width, "right")?.intrusion ?? 0;
-    n.save(), n.translate(i.left, 0), n.beginPath(), n.rect(-s, 0, i.width + s + a, i.height), n.clip(), X({ ...e, leftOverhang: s }), n.restore(), this.#Qt({ scope: r, pane: i, timeTicks: e.timeTicks, alpha: e.alpha ?? 1 }), n.restore(), this.#se(r, s);
+    const a = this.#at(r, i.width, "right")?.intrusion ?? 0;
+    n.save(), n.translate(i.left, 0), n.beginPath(), n.rect(-s, 0, i.width + s + a, i.height), n.clip(), K({ ...e, leftOverhang: s }), n.restore(), this.#le({ scope: r, pane: i, timeTicks: e.timeTicks, alpha: e.alpha ?? 1 }), n.restore(), this.#me(r, s);
   }
   /** Erase the {@link #gridOverhang} strip: none at the pane edge, total at its outer end. */
-  #se(t, e) {
-    const i = this.#W(t), s = i - e, { context: r } = t;
-    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#Ve({ context: r, start: s, end: i }), r.fillRect(s, 0, e, t.bitmapSize.height), r.restore();
+  #me(t, e) {
+    const i = this.#z(t), s = i - e, { context: r } = t;
+    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#je({ context: r, start: s, end: i }), r.fillRect(s, 0, e, t.bitmapSize.height), r.restore();
   }
   /** Canvas bitmap x of the pane's left edge — whole device pixels, so the
    *  translated pane keeps crisp strokes. */
-  #W(t) {
+  #z(t) {
     return Math.round(this.plotLeft * t.horizontalPixelRatio);
   }
   /** Pane-local width of the pane clip: the pane plus the right fade
    *  intrusion, so content can slide under a right Y-axis column before the
    *  mask dissolves it. */
-  #re(t, e) {
-    const i = this.#rt(t, e, "right")?.intrusion ?? 0;
+  #fe(t, e) {
+    const i = this.#at(t, e, "right")?.intrusion ?? 0;
     return e + i;
   }
   /**
@@ -2405,22 +2548,22 @@ class _e extends Et {
    * total-erased anyway). `null` when no column sits on `side`, its fade
    * is `0`, or the chart is spatial-only.
    */
-  #rt(t, e, i) {
-    if (this.#Q()) return null;
-    const s = i === "left", r = t.bitmapSize.width, n = this.#W(t), a = s ? n : Math.max(0, Math.round(r - n - e));
+  #at(t, e, i) {
+    if (this.#it()) return null;
+    const s = i === "left", r = t.bitmapSize.width, n = this.#z(t), a = s ? n : Math.max(0, Math.round(r - n - e));
     if (a === 0) return null;
-    const o = t.horizontalPixelRatio, h = Math.round(K * o), l = Math.round(te * o), d = s ? 0 : Math.min(h, a), f = s ? h + l : d + l, c = s ? this.#C.left : this.#C.right, m = c === null ? f : Math.round(c * o);
-    if (m < 1) return null;
+    const o = t.horizontalPixelRatio, h = Math.round(et * o), l = Math.round(le * o), c = s ? 0 : Math.min(h, a), f = s ? h + l : c + l, g = s ? this.#C.left : this.#C.right, y = g === null ? f : Math.round(g * o);
+    if (y < 1) return null;
     if (s) {
-      const g = a, S = Math.min(m, r - g);
-      return { inner: g + S, outer: g, intrusion: d };
+      const p = a, x = Math.min(y, r - p);
+      return { inner: p + x, outer: p, intrusion: c };
     }
-    const y = n + e + d, u = Math.min(m, y);
-    return { inner: y - u, outer: y, intrusion: d };
+    const u = n + e + c, m = Math.min(y, u);
+    return { inner: u - m, outer: u, intrusion: c };
   }
   /** Bitmap geometry of a plain fade at the `side` canvas edge — total erase
    *  at `edge`, none at `inner`. Off unless that side's fade is configured. */
-  #De(t) {
+  #Ze(t) {
     const { scope: e, paneBitmapWidth: i, side: s } = t, r = this.#C[s];
     if (r === null) return null;
     const n = Math.min(Math.round(r * e.horizontalPixelRatio), Math.round(i));
@@ -2435,15 +2578,15 @@ class _e extends Et {
    *  changes (resize, DPR change, `setFade`). Ease-out ramp (`1 - t²`):
    *  near-total erasure across the upper half keeps a floating header
    *  legible, then a soft tail into full opacity at the zone's bottom. */
-  #Re(t, e) {
-    const i = this.#k.top;
+  #_e(t, e) {
+    const i = this.#b.top;
     if (i !== null && i.height === e) return i.gradient;
     const s = t.createLinearGradient(0, 0, 0, e);
     for (let r = 0; r <= 4; r++) {
       const n = r / 4;
       s.addColorStop(n, `rgba(0, 0, 0, ${1 - n * n})`);
     }
-    return this.#k.top = { height: e, gradient: s }, s;
+    return this.#b.top = { height: e, gradient: s }, s;
   }
   /** Axis-column mask — erase grows from 0 at the ramp's inner start to
    *  total at its outer end on an ease-in (`s³`): zero slope *and* zero
@@ -2451,51 +2594,51 @@ class _e extends Et {
    *  candles at rest and the aggressive erasing all happens deep under the
    *  axis column. Nine stops keep the piecewise interpolation smooth across
    *  the zone. */
-  #Ie(t) {
-    const { context: e, side: i, zone: s } = t, r = this.#k.axis[i];
+  #Ue(t) {
+    const { context: e, side: i, zone: s } = t, r = this.#b.axis[i];
     if (r !== null && r.inner === s.inner && r.outer === s.outer) return r.gradient;
     const n = e.createLinearGradient(s.inner, 0, s.outer, 0);
     for (let a = 0; a <= 8; a++) {
       const o = a / 8;
       n.addColorStop(o, `rgba(0, 0, 0, ${o * o * o})`);
     }
-    return this.#k.axis[i] = { inner: s.inner, outer: s.outer, gradient: n }, n;
+    return this.#b.axis[i] = { inner: s.inner, outer: s.outer, gradient: n }, n;
   }
   /** Erase ramp for the gridline tail stubs — nothing erased at the pane
    *  floor, total at the stub tip, ease-in (`t²`) so a stub holds strength
    *  briefly before melting away short of the label glyphs. */
-  #He(t) {
-    const e = this.#k.tail;
+  #Ge(t) {
+    const e = this.#b.tail;
     if (e !== null && e.start === t.start && e.height === t.height) return e.gradient;
     const i = t.context.createLinearGradient(0, t.start, 0, t.start + t.height);
     for (let s = 0; s <= 4; s++) {
       const r = s / 4;
       i.addColorStop(r, `rgba(0, 0, 0, ${r * r})`);
     }
-    return this.#k.tail = { start: t.start, height: t.height, gradient: i }, i;
+    return this.#b.tail = { start: t.start, height: t.height, gradient: i }, i;
   }
   /** Gridline overhang ramp — ease-in (`t²`) like the tail stubs. */
-  #Ve(t) {
-    const e = this.#k.overhang;
+  #je(t) {
+    const e = this.#b.overhang;
     if (e !== null && e.start === t.start && e.end === t.end) return e.gradient;
     const i = t.context.createLinearGradient(t.end, 0, t.start, 0);
     for (let s = 0; s <= 4; s++) {
       const r = s / 4;
       i.addColorStop(r, `rgba(0, 0, 0, ${r * r})`);
     }
-    return this.#k.overhang = { start: t.start, end: t.end, gradient: i }, i;
+    return this.#b.overhang = { start: t.start, end: t.end, gradient: i }, i;
   }
   /** Opposite-edge mask — mirror of the top ramp: total erase at the
    *  canvas edge, fully opaque at the zone's inner boundary. */
-  #ze(t) {
-    const { context: e, side: i, zone: s } = t, r = this.#k.edge[i];
+  #Ke(t) {
+    const { context: e, side: i, zone: s } = t, r = this.#b.edge[i];
     if (r !== null && r.edge === s.edge && r.inner === s.inner) return r.gradient;
     const n = e.createLinearGradient(s.edge, 0, s.inner, 0);
     for (let a = 0; a <= 4; a++) {
       const o = a / 4;
       n.addColorStop(o, `rgba(0, 0, 0, ${1 - o * o})`);
     }
-    return this.#k.edge[i] = { edge: s.edge, inner: s.inner, gradient: n }, n;
+    return this.#b.edge[i] = { edge: s.edge, inner: s.inner, gradient: n }, n;
   }
   /**
    * Paint a full frame: the main layer, then the overlay synchronously on
@@ -2506,13 +2649,13 @@ class _e extends Et {
    * `markDirty` calls made *during* `renderOverlay` (pulse, edge spinner)
    * land after the consume and re-arm cleanly for the next frame.
    */
-  #wt(t) {
-    this.#Tt("main", t, () => this.renderMain(t)), this.#c.consume(), this.#Tt("overlay", t, () => this.renderOverlay(t));
+  #Ct(t) {
+    this.#Lt("main", t, () => this.renderMain(t)), this.#d.consume(), this.#Lt("overlay", t, () => this.renderOverlay(t));
   }
   /** Run a layer's paint, booking duration + draw calls to the perf monitor
    *  when one is attached — keeps overlay time out of the `main` samples. */
-  #Tt(t, e, i) {
-    const s = this.#M;
+  #Lt(t, e, i) {
+    const s = this.#P;
     if (!s) {
       i();
       return;
@@ -2523,7 +2666,7 @@ class _e extends Et {
   }
   /** Cheap overlay: crosshair, nearest-point dots, pulse animation, edge indicator. */
   renderOverlay(t) {
-    const e = this.#l.size;
+    const e = this.#c.size;
     if (e.media.width === 0 || e.media.height === 0) return;
     let i = !1;
     for (const l of this.#t)
@@ -2533,71 +2676,71 @@ class _e extends Et {
       }
     this.#y.some((l) => l.pulse) && (i = !0);
     const s = {
-      left: this.#B.left && this.#A.left === "loading" ? "idle" : this.#A.left,
-      right: this.#B.right && this.#A.right === "loading" ? "idle" : this.#A.right
+      left: this.#E.left && this.#A.left === "loading" ? "idle" : this.#A.left,
+      right: this.#E.right && this.#A.right === "loading" ? "idle" : this.#A.right
     }, r = {
-      left: this.#Zt("left"),
-      right: this.#Zt("right")
-    }, n = r.left !== null || r.right !== null, a = s.left === "loading" || s.right === "loading" || n, o = s.left !== "idle" || s.right !== "idle" || n, h = !!this.#f || i || o || this.#y.length > 0 || this.#b.length > 0;
-    if (!(!h && !this.#Lt)) {
-      if (this.#Lt = h, this.#l.useOverlayLayer((l) => {
+      left: this.#Jt("left"),
+      right: this.#Jt("right")
+    }, n = r.left !== null || r.right !== null, a = s.left === "loading" || s.right === "loading" || n, o = s.left !== "idle" || s.right !== "idle" || n, h = !!this.#f || i || o || this.#y.length > 0 || this.#S.length > 0;
+    if (!(!h && !this.#Nt)) {
+      if (this.#Nt = h, this.#c.useOverlayLayer((l) => {
         if (!h) return;
-        const d = (e.media.width - this.#w()) * e.horizontalPixelRatio, f = (e.media.height - this.xAxisHeight) * e.verticalPixelRatio;
-        this.#f && this.#Nt() && this.#Pe({ scope: l, chartBitmapWidth: d, chartBitmapHeight: f }), l.context.save(), l.context.translate(this.#W(l), 0), l.context.beginPath(), l.context.rect(0, 0, d, f), l.context.clip();
-        const c = this.#d, m = { top: c.top, bottom: c.bottom }, y = this.getAnimationState();
-        for (const u of this.#t) {
-          if (!u.visible) continue;
-          const g = this.#D(u);
-          u.renderer.drawOverlay?.({
+        const c = (e.media.width - this.#k()) * e.horizontalPixelRatio, f = (e.media.height - this.xAxisHeight) * e.verticalPixelRatio;
+        this.#f && this.#Kt() && this.#Ee({ scope: l, chartBitmapWidth: c, chartBitmapHeight: f }), l.context.save(), l.context.translate(this.#z(l), 0), l.context.beginPath(), l.context.rect(0, 0, c, f), l.context.clip();
+        const g = this.#l, y = { top: g.top, bottom: g.bottom }, u = this.getAnimationState();
+        for (const m of this.#t) {
+          if (!m.visible) continue;
+          const p = this.#I(m);
+          m.renderer.drawOverlay?.({
             scope: l,
             timeScale: this.timeScale,
-            yScale: this.getYScale(g),
-            theme: this.#n,
+            yScale: this.getYScale(p),
+            theme: this.#h,
             // Overlays only snap the crosshair dots with it.
             dataInterval: this.#X(),
-            padding: m,
+            padding: y,
             crosshair: this.#f,
-            state: g === void 0 ? y : this.#Wt(y, g),
-            seriesId: u.id
+            state: p === void 0 ? u : this.#Zt(u, p),
+            seriesId: m.id
           });
         }
-        this.#de(l, d, f), this.#le(l, d, f), o && ut({
+        this.#ke(l, c, f), this.#Se(l, c, f), o && kt({
           scope: l,
-          chartMediaWidth: e.media.width - this.#w(),
+          chartMediaWidth: e.media.width - this.#k(),
           chartMediaHeight: e.media.height - this.xAxisHeight,
           timeScale: this.timeScale,
-          theme: this.#n,
+          theme: this.#h,
           edgeStates: s,
           edgeExitFades: r,
-          edgeIndicatorFns: this.#It,
-          resolveBoundary: (u) => mt(u, this.#Dt[u], this.getDataBounds()),
-          resolveEdgeAnchor: (u, g) => this.#ve(u, g),
-          resolveEdgeBarSpacing: () => this.#Se(),
-          reportPlaceholders: (u, g) => {
-            this.#ht[u] = { bars: g, at: performance.now() };
+          edgeIndicatorFns: this.#$t,
+          resolveBoundary: (m) => Tt(m, this.#Ft[m], this.getDataBounds()),
+          resolveEdgeAnchor: (m, p) => this.#Ie(m, p),
+          resolveEdgeBarSpacing: () => this.#De(),
+          reportPlaceholders: (m, p) => {
+            this.#ct[m] = { bars: p, at: performance.now() };
           }
         }), l.context.restore();
       }), i) {
-        const { from: l, to: d } = this.timeScale.getRange();
+        const { from: l, to: c } = this.timeScale.getRange();
         let f = !1;
-        for (const c of this.#t)
-          if (!(!c.visible || !c.renderer.overlayNeedsAnimation) && (c.renderer.hasOverlayContentInRange?.(l, d) ?? !0)) {
+        for (const g of this.#t)
+          if (!(!g.visible || !g.renderer.overlayNeedsAnimation) && (g.renderer.hasOverlayContentInRange?.(l, c) ?? !0)) {
             f = !0;
             break;
           }
         if (!f) {
-          for (const c of this.#y)
-            if (c.pulse && c.time >= l && c.time <= d) {
+          for (const g of this.#y)
+            if (g.pulse && g.time >= l && g.time <= c) {
               f = !0;
               break;
             }
         }
-        f && this.#c.markDirty();
+        f && this.#d.markDirty();
       }
-      a && this.#c.markDirty();
+      a && this.#d.markDirty();
     }
   }
 }
 export {
-  _e as ChartInstance
+  ri as ChartInstance
 };