@wick-charts/vue 0.5.0 → 0.5.1

package/dist/core/dist/chart.js

@@ -1,15 +1,15 @@
-import { AnimationConfig as z, DEFAULT_LINE_PULSE as H } from "./animation/config.js";
-import { createViewportEngine as N } from "./animation/viewport-engine.js";
+import { AnimationConfig as z, DEFAULT_LINE_PULSE as N } from "./animation/config.js";
+import { createViewportEngine as H } from "./animation/viewport-engine.js";
 import { CanvasManager as W } from "./canvas-manager.js";
-import { drawEdgeIndicators as E, resolveEdgeBoundary as $ } from "./chart/edge-indicators.js";
+import { drawEdgeIndicators as E, resolveEdgeBoundary as F } from "./chart/edge-indicators.js";
 import { computeFitToData as O } from "./chart/fit-to-data.js";
-import { getLastValue as B, getPreviousClose as F, getStackedLastValue as Y } from "./chart/last-value.js";
-import { resolveMaxVisibleBars as X, resolvePadding as D, resolvePerfOptions as _, isSameHorizontalPadding as C } from "./chart/options.js";
+import { getLastValue as Y, getPreviousClose as B, getStackedLastValue as X } from "./chart/last-value.js";
+import { resolveMaxVisibleBars as _, resolvePadding as D, resolvePerfOptions as $, isSameHorizontalPadding as T } from "./chart/options.js";
 import { computePan as U, computeZoom as Z } from "./chart/pan-zoom-math.js";
 import { StreamingCadence as G } from "./chart/streaming-cadence.js";
 import { computeStreamingTarget as j } from "./chart/streaming-target.js";
-import { resolvePaddingTime as T } from "./chart/viewport-padding.js";
-import { computeTargetYRange as q, resolveBound as R } from "./chart/y-target.js";
+import { resolvePaddingTime as C } from "./chart/viewport-padding.js";
+import { computeTargetYRange as q, resolveBound as M } from "./chart/y-target.js";
 import { renderCrosshair as J } from "./components/crosshair.js";
 import { renderGrid as K } from "./components/grid.js";
 import { renderMarker as Q } from "./components/marker.js";
@@ -17,18 +17,18 @@ import { renderReferenceLine as tt } from "./components/reference-line.js";
 import { resolveTimeRegionColors as it, renderTimeRegion as et } from "./components/time-region.js";
 import { EventEmitter as st } from "./events.js";
 import { InteractionHandler as rt } from "./interactions/handler.js";
-import { RenderScheduler as M } from "./render-scheduler.js";
+import { RenderScheduler as R } from "./render-scheduler.js";
 import { XScale as nt } from "./scales/x-scale.js";
-import { YScale as ht } from "./scales/y-scale.js";
-import { resolveSeriesDefinition as at } from "./series/definition.js";
+import { YScale as at } from "./scales/y-scale.js";
+import { resolveSeriesDefinition as ht } from "./series/definition.js";
 import { catppuccin as ot } from "./theme/themes/catppuccin.js";
 import { normalizeTime as g, detectInterval as lt } from "./utils/time.js";
-let dt = 0, ct = 0, mt = 0, ut = 0;
-function I(m, i) {
-  return m === i ? !0 : !m || !i || m.length !== i.length ? !1 : m.every((t, e) => t === i[e]);
+let ct = 0, dt = 0, mt = 0, ut = 0;
+function I(m, t) {
+  return m === t ? !0 : !m || !t || m.length !== t.length ? !1 : m.every((i, e) => i === t[e]);
 }
-function ft(m, i) {
-  return m === i ? !0 : !m || !i || m.length !== i.length ? !1 : m.every((t, e) => t === i[e]);
+function ft(m, t) {
+  return m === t ? !0 : !m || !t || m.length !== t.length ? !1 : m.every((i, e) => i === t[e]);
 }
 class Ot extends st {
   /** Canvas lifecycle and DPR-aware sizing. */
@@ -36,7 +36,7 @@ class Ot extends st {
   /** Schedules main-layer redraws (background, grid, series). */
   #i;
   /** Schedules overlay redraws (crosshair). */
-  #d;
+  #l;
   /** Maps time values to horizontal pixel coordinates. */
   timeScale;
   /** Maps price/value to vertical pixel coordinates. */
@@ -46,7 +46,7 @@ class Ot extends st {
   /** All registered series (candlestick, line, bar, pie). */
   #t = [];
   /** Point annotations (event markers) drawn on the overlay layer, kept out of the series model. */
-  #c = [];
+  #m = [];
   /** Time-region bands drawn on the main layer behind the series, kept out of the series model. */
   #v = [];
   /** Reference lines (horizontal threshold / vertical event) drawn on the overlay layer, kept out of the series model. */
@@ -56,32 +56,40 @@ class Ot extends st {
   /** Whether to render the background grid. */
   #E;
   /** Detected time interval between data points (milliseconds). */
-  #h = 6e4;
+  #a = 6e4;
   /** Current crosshair position, null when cursor is outside the chart. */
-  #m = null;
+  #d = null;
+  /**
+   * What the crosshair is anchored to, deciding which half of the position
+   * survives a viewport move (see {@link #syncCrosshairToViewport}):
+   * `'pointer'` (real hover) keeps `mediaX`/`mediaY` and re-resolves
+   * `time`/`y`; `'time'` (programmatic {@link setCrosshair}) keeps
+   * `time`/`y` and re-projects the pixel position.
+   */
+  #F = "pointer";
   /** Whether the last overlay pass painted anything — gates the full-bitmap
    *  clear so an empty overlay isn't cleared again every main frame. */
-  #G = !1;
+  #q = !1;
   /** User-specified Y-axis bounds (auto, fixed, percentage). */
-  #a = {};
+  #h = {};
   /** Cached series ID list — invalidated on add/remove. */
   #A = null;
   /** Axis visibility and sizing configuration. */
   #I = {};
   /** Host-declared state per edge — drives the edge-indicator overlay. */
-  #b = { left: "idle", right: "idle" };
+  #x = { left: "idle", right: "idle" };
   /** Cached boundary timestamps from the last `edgeReached` emission, by side. */
-  #j = { left: null, right: null };
+  #J = { left: null, right: null };
   /** Host-supplied callback fired when the user releases a pan/zoom past a data edge. */
-  #q;
+  #K;
   /** Nesting depth for batch updates. Suppresses recomputes while > 0. */
   #w = 0;
   /** True when batched operations include data changes (triggers full onDataChanged on end). */
-  #$ = !1;
+  #O = !1;
   /** True when batched operations include visibility changes (triggers Y-range + redraw on end). */
-  #T = !1;
+  #C = !1;
   /** True when batched operations bumped overlay version (emits a single overlayChange on flush). */
-  #O = !1;
+  #Y = !1;
   /**
    * Monotonic counter bumped on any mutation that affects overlay output —
    * data, visibility, series options, theme. Used by snapshot helpers in
@@ -91,14 +99,14 @@ class Ot extends st {
    *
    * @internal
    */
-  #J = 0;
+  #Q = 0;
   get yAxisWidth() {
-    const i = this.#I.y;
-    return i?.visible === !1 ? 0 : i?.width ?? 55;
+    const t = this.#I.y;
+    return t?.visible === !1 ? 0 : t?.width ?? 55;
   }
   get xAxisHeight() {
-    const i = this.#I.x;
-    return i?.visible === !1 ? 0 : i?.height ?? 30;
+    const t = this.#I.x;
+    return t?.visible === !1 ? 0 : t?.height ?? 30;
   }
   /** Resolved animation config derived from `options.animations` at construction. */
   #f;
@@ -126,7 +134,7 @@ class Ot extends st {
    * field carries the decision across that gap. The closure also reads
    * `#dataStart` / `#dataEnd` directly for the timestamps.
    */
-  #K = !1;
+  #tt = !1;
   /** Earliest data timestamp registered across all series, `null` before any data has arrived. */
   #k = null;
   /** Latest data timestamp registered across all series, `null` before any data has arrived. */
@@ -150,7 +158,7 @@ class Ot extends st {
    * the right edge and trims the left. Resolved once at construction from
    * `options.viewport.maxVisibleBars`.
    */
-  #Q;
+  #it;
   /**
    * Committed logical X range — the "where X should be" target. Engine
    * eases its visual toward this. Pan / zoom / setRange / fitContent /
@@ -166,22 +174,22 @@ class Ot extends st {
    * screen; chart's per-frame autoscroll check re-engages it when a
    * follow-up pan brings the tail back into view.
    */
-  #p = !0;
+  #y = !0;
   /** Resolved viewport padding (top/bottom px + left/right pixels-or-intervals). */
-  #l;
+  #c;
   /** 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). */
   #z = 0;
   /** Active performance monitor, or `null` when instrumentation is disabled (the default). */
-  #x;
+  #S;
   /** When true, `destroy()` tears down the monitor; false for caller-supplied monitors we must not destroy. */
   #B = !1;
   /** Visible HUD overlay (mounted by the perf config); non-null only when the caller requested one. */
-  #F = null;
-  constructor(i, t) {
-    super(), t?.axis && (this.#I = t.axis, this.#a = { min: t.axis.y?.min, max: t.axis.y?.max }), this.#r = t?.theme ?? ot.theme, this.#E = t?.grid?.visible !== !1, this.#f = z.resolve(t?.animations), this.#Q = X(t?.viewport?.maxVisibleBars), this.#l = D(t?.padding), this.#D = new G();
+  #X = null;
+  constructor(t, i) {
+    super(), i?.axis && (this.#I = i.axis, this.#h = { min: i.axis.y?.min, max: i.axis.y?.max }), this.#r = i?.theme ?? ot.theme, this.#E = i?.grid?.visible !== !1, this.#f = z.resolve(i?.animations), this.#it = _(i?.viewport?.maxVisibleBars), this.#c = D(i?.padding), this.#D = new G();
     const e = this.#f.axis.y, s = this.#f.axis.x;
-    this.#e = N({
+    this.#e = H({
       initial: { yRange: { min: 0, max: 0 }, xRange: { from: 0, to: 0 } },
       y: {
         curve: e.curve,
@@ -196,21 +204,21 @@ class Ot extends st {
         settleMs: s.settleMs,
         gestureMs: s.gestureMs
       },
-      computeXTarget: () => this.#gt(),
-      computeYTarget: ({ xTarget: a }) => this.#st(a),
+      computeXTarget: () => this.#pt(),
+      computeYTarget: ({ xTarget: h }) => this.#nt(h),
       onWake: () => this.#i?.markDirty()
-    }), this.#q = t?.onEdgeReached, this.#H = t?.viewport?.initialRange;
-    const r = _(t?.perf);
-    this.#x = r.monitor, this.#B = r.ownsMonitor, this.#n = new W(i, this.#x ?? void 0), this.timeScale = new nt(), this.yScale = new ht();
+    }), this.#K = i?.onEdgeReached, this.#N = i?.viewport?.initialRange;
+    const r = $(i?.perf);
+    this.#S = r.monitor, this.#B = r.ownsMonitor, this.#n = new W(t, this.#S ?? void 0), this.timeScale = new nt(), this.yScale = new at();
     const n = this.#f.axis.ticksMs;
-    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#i = new M((a) => this.#U(a)), this.#d = new M(
-      (a) => this.#Z("overlay", a, () => this.renderOverlay(a))
-    ), this.#x && r.hud && (this.#F = r.hud(i, this.#x));
-    const h = t?.interactive !== !1;
-    this.#W = h ? new rt(this.#n.canvas, this, this.timeScale, this.yScale) : null, this.#n.on("resize", () => {
-      this.syncScales(), this.#U(), this.emit("viewportChange");
-    }), this.syncScales(), this.#W?.on("crosshairMove", (a) => {
-      this.#m = a, this.#d.markDirty(), this.emit("crosshairMove", a), this.#ft(a);
+    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#i = new R((h) => this.#G(h)), this.#l = new R(
+      (h) => this.#j("overlay", h, () => this.renderOverlay(h))
+    ), this.#S && r.hud && (this.#X = r.hud(t, this.#S));
+    const a = i?.interactive !== !1;
+    this.#W = a ? new rt(this.#n.canvas, this, this.timeScale, this.yScale) : null, this.#n.on("resize", () => {
+      this.syncScales(), this.#G(), this.emit("viewportChange");
+    }), this.syncScales(), this.#W?.on("crosshairMove", (h) => {
+      this.#F = "pointer", this.#d = h, this.#l.markDirty(), this.emit("crosshairMove", h), this.#_(h);
     });
   }
   /**
@@ -225,9 +233,9 @@ class Ot extends st {
    * `setSeriesVisible` / `setLayerVisible` calls — produce one overlay
    * render instead of N.
    */
-  #S() {
-    if (this.#J++, this.#w > 0) {
-      this.#O = !0;
+  #b() {
+    if (this.#Q++, this.#w > 0) {
+      this.#Y = !0;
       return;
     }
     this.emit("overlayChange");
@@ -241,39 +249,39 @@ class Ot extends st {
    * @internal
    */
   getOverlayVersion() {
-    return this.#J;
+    return this.#Q;
   }
   /**
    * 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.
    */
-  #at(i) {
-    if (i && !this.#t.some((e) => e.id === i))
-      return i;
-    let t;
+  #lt(t) {
+    if (t && !this.#t.some((e) => e.id === t))
+      return t;
+    let i;
     do
-      t = `series_${++dt}`;
-    while (this.#t.some((e) => e.id === t));
-    return t;
+      i = `series_${++ct}`;
+    while (this.#t.some((e) => e.id === i));
+    return i;
   }
-  addSeries(i, t = {}) {
-    const e = typeof i == "string" ? at(i) : i;
+  addSeries(t, i = {}) {
+    const e = typeof t == "string" ? ht(t) : t;
     if (!e)
       throw new Error(
-        `[wick-charts] Unknown series type '${String(i)}'. The string form of addSeries resolves through the series registry — call registerBuiltinSeries() once at startup, or pass the definition directly: chart.addSeries(LineSeriesDef, options).`
+        `[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: h, ...a } = t, d = s ?? 1, l = {
+    const { layers: s, id: r, label: n, labels: a, ...h } = i, l = s ?? 1, o = {
       ...this.#f.defaults(e.type),
-      ...a,
+      ...h,
       ...this.#f.overrides(e.type)
-    }, u = e.create({ theme: this.#r, layerCount: d }, l), c = h ?? (typeof n == "string" ? [n] : void 0), o = this.#at(r);
-    return u.onDataChanged?.(() => this.onDataChanged()), this.#t.push({ id: o, labels: c, renderer: u, visible: !0 }), this.#A = null, this.emit("seriesChange"), this.#S(), o;
+    }, u = e.create({ theme: this.#r, layerCount: l }, o), d = a ?? (typeof n == "string" ? [n] : void 0), c = this.#lt(r);
+    return u.onDataChanged?.(() => this.onDataChanged()), this.#t.push({ id: c, labels: d, renderer: u, visible: !0 }), this.#A = null, this.emit("seriesChange"), this.#b(), c;
   }
   /** Remove a series by ID and clean up its resources. */
-  removeSeries(i) {
-    const t = this.#t.findIndex((e) => e.id === i);
-    t >= 0 && (this.#t[t].renderer.dispose(), this.#t.splice(t, 1), this.#A = null, this.#i.markDirty(), this.emit("seriesChange"), this.#S());
+  removeSeries(t) {
+    const i = this.#t.findIndex((e) => e.id === t);
+    i >= 0 && (this.#t[i].renderer.dispose(), this.#t.splice(i, 1), this.#A = null, this.#i.markDirty(), this.emit("seriesChange"), this.#b());
   }
   // --- Markers (point annotations) -----------------------------------------
   /**
@@ -285,71 +293,71 @@ class Ot extends st {
    * are excluded from tooltips, the legend, and the Y-range autoscale, and never
    * appear in series queries.
    */
-  addMarker(i) {
-    const t = `marker_${++ct}`;
-    return this.#c.push(this.#tt(t, i)), this.#d.markDirty(), t;
+  addMarker(t) {
+    const i = `marker_${++dt}`;
+    return this.#m.push(this.#et(i, t)), this.#l.markDirty(), i;
   }
   /** Replace a marker's config in place. No-op when the id is unknown. */
-  updateMarker(i, t) {
-    const e = this.#c.findIndex((s) => s.id === i);
-    e !== -1 && (this.#c[e] = this.#tt(i, t), this.#d.markDirty());
+  updateMarker(t, i) {
+    const e = this.#m.findIndex((s) => s.id === t);
+    e !== -1 && (this.#m[e] = this.#et(t, i), this.#l.markDirty());
   }
   /** Remove a marker by id. No-op when the id is unknown. */
-  removeMarker(i) {
-    const t = this.#c.findIndex((e) => e.id === i);
-    t !== -1 && (this.#c.splice(t, 1), this.#d.markDirty());
+  removeMarker(t) {
+    const i = this.#m.findIndex((e) => e.id === t);
+    i !== -1 && (this.#m.splice(i, 1), this.#l.markDirty());
   }
   /** Read-only snapshot of the registered markers (normalized). Mutate via add / update / removeMarker. */
   getMarkers() {
-    return this.#c;
+    return this.#m;
   }
-  #tt(i, t) {
+  #et(t, i) {
     return {
-      id: i,
-      time: g(t.time),
-      value: t.value,
-      seriesId: t.seriesId,
-      shape: t.shape ?? "dot",
-      pulse: t.pulse ?? !1,
-      label: t.label,
-      color: t.color
+      id: t,
+      time: g(i.time),
+      value: i.value,
+      seriesId: i.seriesId,
+      shape: i.shape ?? "dot",
+      pulse: i.pulse ?? !1,
+      label: i.label,
+      color: i.color
     };
   }
   /** Resolve a marker's Y value: explicit `value`, else snapped to its series at `time`. Null when neither resolves. */
-  #ot(i) {
-    if (i.value !== void 0 && Number.isFinite(i.value)) return i.value;
-    if (i.seriesId === void 0) return null;
-    const t = this.getDataAtTime(i.seriesId, i.time);
-    return t ? "close" in t ? t.close : t.value : null;
+  #ct(t) {
+    if (t.value !== void 0 && Number.isFinite(t.value)) return t.value;
+    if (t.seriesId === void 0) return null;
+    const i = this.getDataAtTime(t.seriesId, t.time);
+    return i ? "close" in i ? i.close : i.value : null;
   }
   /** Resolve a marker's color: explicit `color`, else the series color, else the theme line color. */
-  #lt(i) {
-    if (i.color !== void 0) return i.color;
-    if (i.seriesId !== void 0) {
-      const t = this.getSeriesColor(i.seriesId);
-      if (t !== null) return t;
+  #dt(t) {
+    if (t.color !== void 0) return t.color;
+    if (t.seriesId !== void 0) {
+      const i = this.getSeriesColor(t.seriesId);
+      if (i !== null) return i;
     }
     return this.#r.line.color;
   }
-  #dt(i) {
-    if (this.#c.length === 0) return;
-    const t = performance.now() / (H * 2 * Math.PI) % 1;
-    for (const e of this.#c) {
-      const s = this.#ot(e);
+  #mt(t) {
+    if (this.#m.length === 0) return;
+    const i = performance.now() / (N * 2 * Math.PI) % 1;
+    for (const e of this.#m) {
+      const s = this.#ct(e);
       s !== null && Q({
-        scope: i,
+        scope: t,
         timeScale: this.timeScale,
         yScale: this.yScale,
         theme: this.#r,
         marker: {
           time: e.time,
           value: s,
-          color: this.#lt(e),
+          color: this.#dt(e),
           shape: e.shape,
           pulse: e.pulse,
           label: e.label
         },
-        phase: t
+        phase: i
       });
     }
   }
@@ -365,45 +373,45 @@ class Ot extends st {
    * series model — they never affect the Y-range autoscale, tooltips, or the
    * legend.
    */
-  addRegion(i) {
-    const t = `region_${++mt}`;
-    return this.#v.push(this.#it(t, i)), this.#i.markDirty(), t;
+  addRegion(t) {
+    const i = `region_${++mt}`;
+    return this.#v.push(this.#st(i, t)), this.#i.markDirty(), i;
   }
   /** Replace a region's config in place. No-op when the id is unknown. */
-  updateRegion(i, t) {
-    const e = this.#v.findIndex((s) => s.id === i);
-    e !== -1 && (this.#v[e] = this.#it(i, t), this.#i.markDirty());
+  updateRegion(t, i) {
+    const e = this.#v.findIndex((s) => s.id === t);
+    e !== -1 && (this.#v[e] = this.#st(t, i), this.#i.markDirty());
   }
   /** Remove a region by id. No-op when the id is unknown. */
-  removeRegion(i) {
-    const t = this.#v.findIndex((e) => e.id === i);
-    t !== -1 && (this.#v.splice(t, 1), this.#i.markDirty());
+  removeRegion(t) {
+    const i = this.#v.findIndex((e) => e.id === t);
+    i !== -1 && (this.#v.splice(i, 1), this.#i.markDirty());
   }
   /** Read-only snapshot of the registered regions (normalized). Mutate via add / update / removeRegion. */
   getRegions() {
     return this.#v;
   }
-  #it(i, t) {
-    const { to: e } = t, s = e === void 0 || e === "now" ? null : g(e);
+  #st(t, i) {
+    const { to: e } = i, s = e === void 0 || e === "now" ? null : g(e);
     return {
-      id: i,
-      from: g(t.from),
+      id: t,
+      from: g(i.from),
       to: s,
-      fill: t.fill,
-      color: t.color,
-      label: t.label
+      fill: i.fill,
+      color: i.color,
+      label: i.label
     };
   }
-  #ct(i, t, e) {
+  #ut(t, i, e) {
     if (this.#v.length !== 0)
       for (const s of this.#v) {
         const { color: r, fill: n } = it(s, this.#r);
         et({
-          scope: i,
+          scope: t,
           timeScale: this.timeScale,
           theme: this.#r,
           region: { from: s.from, to: s.to, fill: n, color: r, label: s.label },
-          plotWidth: t,
+          plotWidth: i,
           plotHeight: e
         });
       }
@@ -419,39 +427,39 @@ class Ot extends st {
    * series model — they never affect the Y-range autoscale, tooltips, or the
    * legend.
    */
-  addLine(i) {
-    const t = `line_${++ut}`;
-    return this.#g.push(this.#et(t, i)), this.#d.markDirty(), t;
+  addLine(t) {
+    const i = `line_${++ut}`;
+    return this.#g.push(this.#rt(i, t)), this.#l.markDirty(), i;
   }
   /** Replace a reference line's config in place. No-op when the id is unknown. */
-  updateLine(i, t) {
-    const e = this.#g.findIndex((s) => s.id === i);
-    e !== -1 && (this.#g[e] = this.#et(i, t), this.#d.markDirty());
+  updateLine(t, i) {
+    const e = this.#g.findIndex((s) => s.id === t);
+    e !== -1 && (this.#g[e] = this.#rt(t, i), this.#l.markDirty());
   }
   /** Remove a reference line by id. No-op when the id is unknown. */
-  removeLine(i) {
-    const t = this.#g.findIndex((e) => e.id === i);
-    t !== -1 && (this.#g.splice(t, 1), this.#d.markDirty());
+  removeLine(t) {
+    const i = this.#g.findIndex((e) => e.id === t);
+    i !== -1 && (this.#g.splice(i, 1), this.#l.markDirty());
   }
   /** Read-only snapshot of the registered reference lines (normalized). Mutate via add / update / removeLine. */
   getLines() {
     return this.#g;
   }
-  #et(i, t) {
-    const { time: e, value: s } = t, r = {
-      id: i,
-      color: t.color,
-      label: t.label,
-      style: t.style ?? "dashed",
-      width: t.width ?? 1
+  #rt(t, i) {
+    const { time: e, value: s } = i, r = {
+      id: t,
+      color: i.color,
+      label: i.label,
+      style: i.style ?? "dashed",
+      width: i.width ?? 1
     };
     return e !== void 0 ? { ...r, orientation: "vertical", coord: g(e) } : { ...r, orientation: "horizontal", coord: s ?? Number.NaN };
   }
-  #mt(i, t, e) {
+  #ft(t, i, e) {
     if (this.#g.length !== 0)
       for (const s of this.#g)
         tt({
-          scope: i,
+          scope: t,
           timeScale: this.timeScale,
           yScale: this.yScale,
           theme: this.#r,
@@ -463,7 +471,7 @@ class Ot extends st {
             width: s.width,
             label: s.label
           },
-          plotWidth: t,
+          plotWidth: i,
           plotHeight: e
         });
   }
@@ -485,18 +493,18 @@ class Ot extends st {
    * For line/bar accepts `TimePointInput[]` (time may be `Date`); for candlestick accepts `OHLCInput[]`;
    * for pie accepts `PieSliceData[]`. Time fields are normalized internally.
    */
-  setSeriesData(i, t, e) {
-    const s = this.#t.find((r) => r.id === i);
-    s && (this.#Y = !0, s.renderer.setData(t, e));
+  setSeriesData(t, i, e) {
+    const s = this.#t.find((r) => r.id === t);
+    s && (this.#$ = !0, s.renderer.setData(i, e));
   }
   /** Append a new data point to the end of a series (real-time tick). */
-  appendData(i, t, e) {
-    const s = this.#t.find((r) => r.id === i);
-    s === void 0 || s.renderer.appendPoint === void 0 || s.renderer.appendPoint(t, e);
+  appendData(t, i, e) {
+    const s = this.#t.find((r) => r.id === t);
+    s === void 0 || s.renderer.appendPoint === void 0 || s.renderer.appendPoint(i, e);
   }
   /** Update the last data point of a series in place (e.g. live candle update). */
-  updateData(i, t, e) {
-    this.#t.find((s) => s.id === i)?.renderer.updateLastPoint?.(t, e);
+  updateData(t, i, e) {
+    this.#t.find((s) => s.id === t)?.renderer.updateLastPoint?.(i, e);
   }
   /**
    * Keep only the most recent `count` points of a series — drop the oldest
@@ -511,36 +519,36 @@ class Ot extends st {
    * chart.keepLast('feed', 100);
    * ```
    */
-  keepLast(i, t, e) {
-    this.#t.find((s) => s.id === i)?.renderer.keepLast?.(t, e);
+  keepLast(t, i, e) {
+    this.#t.find((s) => s.id === t)?.renderer.keepLast?.(i, e);
   }
   /** Update visual options (color, width, etc.) for an existing series. */
-  updateSeriesOptions(i, t) {
-    const e = this.#t.find((l) => l.id === i);
+  updateSeriesOptions(t, i) {
+    const e = this.#t.find((o) => o.id === t);
     if (!e) return;
     const s = e.labels, r = e.renderer.getLayerColors().slice(), n = this.#f.overrides(e.renderer.kind);
-    e.renderer.updateOptions({ ...t, ...n }), "label" in t && typeof t.label == "string" && (e.labels = [t.label]), this.#i.markDirty();
-    const h = e.renderer.getLayerColors(), a = r.length !== h.length || r.some((l, u) => l !== h[u]), d = !I(s, e.labels);
-    (a || d) && this.#S();
+    e.renderer.updateOptions({ ...i, ...n }), "label" in i && typeof i.label == "string" && (e.labels = [i.label]), this.#i.markDirty();
+    const a = e.renderer.getLayerColors(), h = r.length !== a.length || r.some((o, u) => o !== a[u]), l = !I(s, e.labels);
+    (h || l) && this.#b();
   }
   /**
    * Batch multiple updates: suppress recomputes until `fn` returns. Exceptions
    * inside `fn` still flush the batch so counters don't leak across calls.
    */
-  batch(i) {
+  batch(t) {
     this.#w++;
     try {
-      i();
+      t();
     } finally {
       if (--this.#w <= 0) {
-        if (this.#w = 0, this.#$)
-          this.#$ = !1, this.#T = !1, this.onDataChanged();
-        else if (this.#T) {
-          this.#T = !1, this.#u = !0;
-          const t = performance.now();
-          this.#e.onAxisReconfig(t), this.#y(t), this.#i.markDirty();
+        if (this.#w = 0, this.#O)
+          this.#O = !1, this.#C = !1, this.onDataChanged();
+        else if (this.#C) {
+          this.#C = !1, this.#u = !0;
+          const i = performance.now();
+          this.#e.onAxisReconfig(i), this.#p(i), this.#i.markDirty();
         }
-        this.#O && (this.#O = !1, this.emit("overlayChange"));
+        this.#Y && (this.#Y = !1, this.emit("overlayChange"));
       }
     }
   }
@@ -551,18 +559,18 @@ class Ot extends st {
    *  computation immediately so the axis can start moving while the line
    *  fades out in parallel.
    */
-  setSeriesVisible(i, t) {
-    const e = this.#t.find((n) => n.id === i);
-    if (!e || e.visible === t) return;
-    e.visible = t, this.#S();
+  setSeriesVisible(t, i) {
+    const e = this.#t.find((n) => n.id === t);
+    if (!e || e.visible === i) return;
+    e.visible = i, this.#b();
     const s = this.#f.toggleMs;
-    if (e.renderer.setAlpha?.(t ? 1 : 0, s), this.#i.markDirty(), this.#w > 0) {
-      this.#T = !0;
+    if (e.renderer.setAlpha?.(i ? 1 : 0, s), this.#i.markDirty(), this.#w > 0) {
+      this.#C = !0;
       return;
     }
     this.#u = !0;
     const r = performance.now();
-    this.#e.onSeriesVisibilityChanged(r), this.#y(r);
+    this.#e.onSeriesVisibilityChanged(r), this.#p(r);
   }
   /**
    * Whether streaming ticks slide the visible range to track the data tail.
@@ -572,10 +580,10 @@ class Ot extends st {
    * containing the tail.
    */
   getAutoScroll() {
-    return this.#p;
+    return this.#y;
   }
-  isSeriesVisible(i) {
-    return this.#t.find((t) => t.id === i)?.visible ?? !0;
+  isSeriesVisible(t) {
+    return this.#t.find((i) => i.id === t)?.visible ?? !0;
   }
   /**
    * Show or hide a specific layer within a multi-layer series.
@@ -587,28 +595,28 @@ class Ot extends st {
    * `getValueRange` reading `store.isVisible()`); the alpha fade keeps the
    * layer's geometry on screen until the engine's Y ease settles.
    */
-  setLayerVisible(i, t, e) {
-    const s = this.#t.find((h) => h.id === i);
-    if (!s || s.renderer.getLayerCount() <= 1 || s.renderer.isLayerVisible(t) === e) return;
-    s.renderer.setLayerVisible(t, e), this.#S();
+  setLayerVisible(t, i, e) {
+    const s = this.#t.find((a) => a.id === t);
+    if (!s || s.renderer.getLayerCount() <= 1 || s.renderer.isLayerVisible(i) === e) return;
+    s.renderer.setLayerVisible(i, e), this.#b();
     const r = this.#f.toggleMs;
-    if (s.renderer.setLayerAlpha?.(t, e ? 1 : 0, r), this.#i.markDirty(), this.#w > 0) {
-      this.#T = !0;
+    if (s.renderer.setLayerAlpha?.(i, e ? 1 : 0, r), this.#i.markDirty(), this.#w > 0) {
+      this.#C = !0;
       return;
     }
     this.#u = !0;
     const n = performance.now();
-    this.#e.onSeriesVisibilityChanged(n), this.#y(n);
+    this.#e.onSeriesVisibilityChanged(n), this.#p(n);
   }
-  isLayerVisible(i, t) {
-    return this.#t.find((e) => e.id === i)?.renderer.isLayerVisible(t) ?? !0;
+  isLayerVisible(t, i) {
+    return this.#t.find((e) => e.id === t)?.renderer.isLayerVisible(i) ?? !0;
   }
   /** Auto-fit the viewport to show all data across every series. */
   fitContent() {
-    const { first: i, last: t } = this.getDataBounds();
-    if (i === void 0 || t === void 0) return;
+    const { first: t, last: i } = this.getDataBounds();
+    if (t === void 0 || i === void 0) return;
     const e = this.#n.size.media.width - this.yAxisWidth;
-    this.#M(i, t, e), this.#N({ xEase: !0 });
+    this.#R(t, i, e), this.#H({ xEase: !0 });
   }
   getVisibleRange() {
     return this.#o.from === 0 && this.#o.to === 0 ? this.#e.getAnimationState().xRange : this.#o;
@@ -645,35 +653,35 @@ class Ot extends st {
    * multi-chart sync so a synced pane tracks the originating gesture in
    * lockstep rather than lagging behind on the long sticky contract.
    */
-  setVisibleRange(i, t) {
-    if (typeof i == "number") {
-      if (!Number.isInteger(i) || i < 2) return;
-      const { first: n, last: h } = this.getDataBounds();
-      if (n === void 0 || h === void 0) return;
-      const a = Math.max(n, h - (i - 1) * this.#h), d = this.#n.size.media.width - this.yAxisWidth;
-      this.#M(a, h, d), this.#N();
+  setVisibleRange(t, i) {
+    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 h = Math.max(n, a - (t - 1) * this.#a), l = this.#n.size.media.width - this.yAxisWidth;
+      this.#R(h, a, l), this.#H();
       return;
     }
-    if ("bars" in i) {
-      if (!Number.isInteger(i.bars) || i.bars < 2) return;
-      const n = g(i.from), h = n + i.bars * this.#h;
-      this.#p = this.#s !== null && this.#s >= n && this.#s <= h, this.#C({ from: n, to: h }, { emitChange: !0 }), this.#L = !0, this.#N();
+    if ("bars" in t) {
+      if (!Number.isInteger(t.bars) || t.bars < 2) return;
+      const n = g(t.from), a = n + t.bars * this.#a;
+      this.#y = this.#s !== null && this.#s >= n && this.#s <= a, this.#T({ from: n, to: a }, { emitChange: !0 }), this.#L = !0, this.#H();
       return;
     }
-    const e = g(i.from), s = g(i.to);
-    this.#p = this.#s !== null && this.#s >= e && this.#s <= s, this.#L = !1;
-    const r = this.#C({ from: e, to: s }, { emitChange: !0 });
-    if (t?.gesture) {
-      r && this.#pt();
+    const e = g(t.from), s = g(t.to);
+    this.#y = this.#s !== null && this.#s >= e && this.#s <= s, this.#L = !1;
+    const r = this.#T({ from: e, to: s }, { emitChange: !0 });
+    if (i?.gesture) {
+      r && this.#vt();
       return;
     }
-    this.#N();
+    this.#H();
   }
   getYRange() {
     return this.#V;
   }
   getCrosshairPosition() {
-    return this.#m;
+    return this.#d;
   }
   /**
    * Programmatically set or clear the crosshair. Same effect as the user
@@ -700,45 +708,52 @@ class Ot extends st {
    * current crosshair is a no-op (no emit). Combined with the y-preservation
    * above, this lets N charts broadcast their hover to each other without
    * a feedback-loop guard.
+   *
+   * The echo protection assumes the broadcast is **synchronous** (call
+   * `setCrosshair` directly from the `crosshairMove` listener). An echo
+   * routed through an async hop — a state store, a React render — can
+   * arrive with a stale `time` while the origin chart streams, miss the
+   * idempotency check, and flip that chart to time-anchored until the next
+   * real pointer move (see {@link #syncCrosshairToViewport}).
    */
-  setCrosshair(i) {
-    if (i === null) {
-      if (this.#m === null) return;
-      this.#m = null, this.#d.markDirty(), this.emit("crosshairMove", null);
+  setCrosshair(t) {
+    if (t === null) {
+      if (this.#d === null) return;
+      this.#d = null, this.#l.markDirty(), this.emit("crosshairMove", null);
       return;
     }
-    const { time: t } = i;
-    if (!Number.isFinite(t)) return;
-    const e = this.#m;
+    const { time: i } = t;
+    if (!Number.isFinite(i)) return;
+    const e = this.#d;
     let s;
-    if (i.y !== void 0)
-      s = i.y;
+    if (t.y !== void 0)
+      s = t.y;
     else if (e !== null)
       s = e.y;
     else {
-      const h = this.#V;
-      s = (h.min + h.max) / 2;
+      const a = this.#V;
+      s = (a.min + a.max) / 2;
     }
-    if (!Number.isFinite(s) || e !== null && e.time === t && e.y === s) return;
-    const r = this.timeScale.timeToX(t), n = this.yScale.valueToY(s);
-    this.#m = { mediaX: r, mediaY: n, time: t, y: s }, this.#d.markDirty(), this.emit("crosshairMove", this.#m);
+    if (!Number.isFinite(s) || e !== null && e.time === i && e.y === s) return;
+    const r = this.timeScale.timeToX(i), n = this.yScale.valueToY(s);
+    this.#F = "time", this.#d = { mediaX: r, mediaY: n, time: i, y: s }, this.#l.markDirty(), this.emit("crosshairMove", this.#d);
   }
   /** Get the last visible value and whether the absolute last point is on screen. */
-  getLastValue(i) {
-    return B(i, this.#t, this.#e.getAnimationState().xRange);
+  getLastValue(t) {
+    return Y(t, this.#t, this.#e.getAnimationState().xRange);
   }
   /** Get the second-to-last value, useful for computing change. */
-  getPreviousClose(i) {
-    return F(i, this.#t);
+  getPreviousClose(t) {
+    return B(t, this.#t);
   }
-  getLastData(i) {
-    const t = this.#t.find((e) => e.id === i);
-    return !t || t.renderer.kind === "pie" ? null : t.renderer.getLastDataPoint();
+  getLastData(t) {
+    const i = this.#t.find((e) => e.id === t);
+    return !i || i.renderer.kind === "pie" ? null : i.renderer.getLastDataPoint();
   }
   /** Find the data point closest to the given timestamp within one data interval. */
-  getDataAtTime(i, t) {
-    const e = this.#t.find((s) => s.id === i);
-    return e ? e.renderer.getDataAtTime?.(t, this.#h) ?? null : null;
+  getDataAtTime(t, i) {
+    const e = this.#t.find((s) => s.id === t);
+    return e ? e.renderer.getDataAtTime?.(i, this.#a) ?? null : null;
   }
   /**
    * Get all layers' data at a given time for multi-layer series (Bar/Line
@@ -746,21 +761,21 @@ class Ot extends st {
    * snapped sample time — callers must not derive layer identity from the
    * array index, because hidden layers are filtered out.
    */
-  getLayerSnapshots(i, t) {
-    const e = this.#t.find((s) => s.id === i);
-    return e?.visible ? e.renderer.getLayerSnapshots?.(t, this.#h) ?? null : null;
+  getLayerSnapshots(t, i) {
+    const e = this.#t.find((s) => s.id === t);
+    return e?.visible ? e.renderer.getLayerSnapshots?.(i, this.#a) ?? null : null;
   }
   getSeriesIds() {
-    return this.#A || (this.#A = this.#t.map((i) => i.id)), this.#A.slice();
+    return this.#A || (this.#A = this.#t.map((t) => t.id)), this.#A.slice();
   }
   /**
    * True if any visible series is non-pie (line / bar / candlestick). Used
    * to gate crosshair rendering — a pie-only chart has no meaningful x/y
    * coordinate system, so the dashed hairlines would just be visual noise.
    */
-  #ut() {
-    for (const i of this.#t)
-      if (i.visible && i.renderer.kind !== "pie")
+  #gt() {
+    for (const t of this.#t)
+      if (t.visible && t.renderer.kind !== "pie")
         return !0;
     return !1;
   }
@@ -773,23 +788,23 @@ class Ot extends st {
    * - `opts.singleLayerOnly` — exclude series with more than one layer.
    *   Useful for YLabel fallback priority (stick to a single line first).
    */
-  getSeriesIdsByType(i, t) {
-    const e = t?.visibleOnly === !0, s = t?.singleLayerOnly === !0, r = [];
+  getSeriesIdsByType(t, i) {
+    const e = i?.visibleOnly === !0, s = i?.singleLayerOnly === !0, r = [];
     for (const n of this.#t) {
-      const h = n.renderer.kind === "pie";
-      if (i === "pie" && !h || i === "time" && h) continue;
-      const a = n.renderer.getLayerCount();
-      if (!(s && a > 1)) {
+      const a = n.renderer.kind === "pie";
+      if (t === "pie" && !a || t === "time" && a) continue;
+      const h = n.renderer.getLayerCount();
+      if (!(s && h > 1)) {
         if (e) {
           if (!n.visible) continue;
-          if (a > 1) {
-            let d = !1;
-            for (let l = 0; l < a; l++)
-              if (n.renderer.isLayerVisible(l)) {
-                d = !0;
+          if (h > 1) {
+            let l = !1;
+            for (let o = 0; o < h; o++)
+              if (n.renderer.isLayerVisible(o)) {
+                l = !0;
                 break;
               }
-            if (!d) continue;
+            if (!l) continue;
           }
         }
         r.push(n.id);
@@ -803,8 +818,8 @@ class Ot extends st {
    * series without stacked concepts (Candlestick, single-layer Line/Bar).
    * Returns `null` for unknown ids or empty series.
    */
-  getStackedLastValue(i) {
-    return Y(i, this.#t, this.#e.getAnimationState().xRange);
+  getStackedLastValue(t) {
+    return X(t, this.#t, this.#e.getAnimationState().xRange);
   }
   /**
    * Per-layer last snapshots with each layer's own `time`. Returns `null`
@@ -812,8 +827,8 @@ class Ot extends st {
    * overlay components that must display every layer in last-mode even
    * when layers advance at different rates (ragged streams).
    */
-  getLayerLastSnapshots(i) {
-    return this.#t.find((t) => t.id === i)?.renderer.getLayerLastSnapshots?.() ?? null;
+  getLayerLastSnapshots(t) {
+    return this.#t.find((i) => i.id === t)?.renderer.getLayerLastSnapshots?.() ?? null;
   }
   /**
    * Shallow view of the internal series entries so unit tests can introspect
@@ -823,20 +838,20 @@ class Ot extends st {
    * @internal
    */
   listSeriesForTest() {
-    return this.#t.map((i) => ({ id: i.id, renderer: i.renderer }));
+    return this.#t.map((t) => ({ id: t.id, renderer: t.renderer }));
   }
   /** Get the primary display color for a series. */
-  getSeriesColor(i) {
-    const t = this.#t.find((e) => e.id === i);
-    return t ? t.renderer.getLayerColors()[0] ?? this.#r.line.color : null;
+  getSeriesColor(t) {
+    const i = this.#t.find((e) => e.id === t);
+    return i ? i.renderer.getLayerColors()[0] ?? this.#r.line.color : null;
   }
   /** The series' primary name (first layer). Used for single-layer overlays. */
-  getSeriesLabel(i) {
-    return this.#t.find((t) => t.id === i)?.labels?.[0];
+  getSeriesLabel(t) {
+    return this.#t.find((i) => i.id === t)?.labels?.[0];
   }
   /** The display name of one layer, or `undefined` when that layer is unnamed. */
-  getLayerLabel(i, t) {
-    return this.#t.find((e) => e.id === i)?.labels?.[t];
+  getLayerLabel(t, i) {
+    return this.#t.find((e) => e.id === t)?.labels?.[i];
   }
   /**
    * Set every layer's display name at once (index = layer). Drives the tooltip,
@@ -844,9 +859,9 @@ class Ot extends st {
    * per-layer labels in `data` change. No-ops (and skips the overlay bump) when
    * the labels are unchanged, so it's safe to call on every data tick.
    */
-  setSeriesLabels(i, t) {
-    const e = this.#t.find((s) => s.id === i);
-    !e || I(e.labels, t) || (e.labels = t, this.#S());
+  setSeriesLabels(t, i) {
+    const e = this.#t.find((s) => s.id === t);
+    !e || I(e.labels, i) || (e.labels = i, this.#b());
   }
   /**
    * Set the per-layer color overrides carried in `data` (sparse — `undefined`
@@ -855,44 +870,44 @@ class Ot extends st {
    * the renderer, which keeps them separate from the theme base so a theme swap
    * preserves them. Called by the framework wrappers; no-ops when unchanged.
    */
-  setLayerColors(i, t) {
-    const e = this.#t.find((s) => s.id === i);
-    !e || ft(e.colorOverrides, t) || (e.colorOverrides = t, e.renderer.setColorOverrides?.(t), this.#i.markDirty(), this.#S());
+  setLayerColors(t, i) {
+    const e = this.#t.find((s) => s.id === t);
+    !e || ft(e.colorOverrides, i) || (e.colorOverrides = i, e.renderer.setColorOverrides?.(i), this.#i.markDirty(), this.#b());
   }
   /** Get per-layer colors for a series. Returns null for single-layer non-bar/line series. */
-  getSeriesLayers(i) {
-    const t = this.#t.find((r) => r.id === i);
-    if (!t) return null;
-    const e = t.renderer.getLayerCount();
+  getSeriesLayers(t) {
+    const i = this.#t.find((r) => r.id === t);
+    if (!i) return null;
+    const e = i.renderer.getLayerCount();
     if (e <= 1) return null;
-    const s = t.renderer.getLayerColors();
+    const s = i.renderer.getLayerColors();
     return Array.from({ length: e }, (r, n) => ({ color: s[n % s.length] }));
   }
   /** Get all slices with computed colors and percentages. Returns null for series without slice data (e.g. candlestick, line, bar). */
-  getSliceInfo(i) {
-    return this.#t.find((t) => t.id === i)?.renderer.getSliceInfo?.(this.#r) ?? null;
+  getSliceInfo(t) {
+    return this.#t.find((i) => i.id === t)?.renderer.getSliceInfo?.(this.#r) ?? null;
   }
   /** Get hover info (label/value/percent/color) for the currently hovered element, or null. */
-  getHoverInfo(i) {
-    return this.#t.find((t) => t.id === i)?.renderer.getHoverInfo?.(this.#r) ?? null;
+  getHoverInfo(t) {
+    return this.#t.find((i) => i.id === t)?.renderer.getHoverInfo?.(this.#r) ?? null;
   }
   /** Apply a new theme and update series colors where appropriate. */
-  setTheme(i) {
-    const t = this.#r;
-    this.#r = i;
+  setTheme(t) {
+    const i = this.#r;
+    this.#r = t;
     for (const e of this.#t)
-      e.renderer.applyTheme(i, t);
-    this.#i.markDirty(), this.#S();
+      e.renderer.applyTheme(t, i);
+    this.#i.markDirty(), this.#b();
   }
   getTheme() {
     return this.#r;
   }
   /** Update axis configuration and re-render. */
-  setAxis(i) {
-    const t = this.yAxisWidth, e = this.xAxisHeight;
-    this.#I = i, this.#a = { min: i.y?.min, max: i.y?.max }, this.#u = !0;
+  setAxis(t) {
+    const i = this.yAxisWidth, e = this.xAxisHeight;
+    this.#I = t, this.#h = { min: t.y?.min, max: t.y?.max }, this.#u = !0;
     const s = performance.now();
-    this.#e.onAxisReconfig(s), this.#y(s), (this.yAxisWidth !== t || this.xAxisHeight !== e) && this.syncScales(), this.#i.markDirty();
+    this.#e.onAxisReconfig(s), this.#p(s), (this.yAxisWidth !== i || this.xAxisHeight !== e) && this.syncScales(), this.#i.markDirty();
   }
   /**
    * Apply label-density knobs driven by `<YAxis labelCount=… minLabelSpacing=…>`
@@ -900,29 +915,29 @@ class Ot extends st {
    * Y-animation reset. Triggers a viewportChange + repaint so static charts
    * react without waiting for pan/zoom.
    */
-  setYAxisLabelDensity(i) {
-    let t = !1;
-    "labelCount" in i && (this.yScale.setLabelCount(i.labelCount ?? null), t = !0), "minLabelSpacing" in i && (this.yScale.setMinSpacing(i.minLabelSpacing ?? null), t = !0), t && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
+  setYAxisLabelDensity(t) {
+    let i = !1;
+    "labelCount" in t && (this.yScale.setLabelCount(t.labelCount ?? null), i = !0), "minLabelSpacing" in t && (this.yScale.setMinSpacing(t.minLabelSpacing ?? null), i = !0), i && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
   }
   /** Label-density knobs for the time axis — mirror of {@link setYAxisLabelDensity}. */
-  setTimeAxisLabelDensity(i) {
-    let t = !1;
-    "labelCount" in i && (this.timeScale.setLabelCount(i.labelCount ?? null), t = !0), "minLabelSpacing" in i && (this.timeScale.setMinSpacing(i.minLabelSpacing ?? null), t = !0), t && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
+  setTimeAxisLabelDensity(t) {
+    let i = !1;
+    "labelCount" in t && (this.timeScale.setLabelCount(t.labelCount ?? null), i = !0), "minLabelSpacing" in t && (this.timeScale.setMinSpacing(t.minLabelSpacing ?? null), i = !0), i && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
   }
   getMediaSize() {
     return this.#n.size.media;
   }
   /** Returns layout metrics for the chart area, Y axis, and time axis. */
   getLayout() {
-    const i = this.#n.size.media, t = this.yAxisWidth, e = this.xAxisHeight;
+    const t = this.#n.size.media, i = this.yAxisWidth, e = this.xAxisHeight;
     return {
-      chartArea: { x: 0, y: 0, width: i.width - t, height: i.height - e },
-      yAxisWidth: t,
+      chartArea: { x: 0, y: 0, width: t.width - i, height: t.height - e },
+      yAxisWidth: i,
       xAxisHeight: e
     };
   }
   getDataInterval() {
-    return this.#h;
+    return this.#a;
   }
   /**
    * Update viewport padding at runtime. Refits the visible time range to
@@ -932,27 +947,27 @@ class Ot extends st {
    * a wrapper re-applies padding reactively (e.g. in response to a Title /
    * InfoBar ResizeObserver).
    */
-  setPadding(i) {
-    const t = this.#l;
-    this.#l = D(i);
-    const e = this.#l, s = !C(t.left, e.left) || !C(t.right, e.right), r = t.top !== e.top || t.bottom !== e.bottom;
+  setPadding(t) {
+    const i = this.#c;
+    this.#c = D(t);
+    const e = this.#c, s = !T(i.left, e.left) || !T(i.right, e.right), r = i.top !== e.top || i.bottom !== e.bottom;
     if (s) {
-      const { first: n, last: h } = this.getDataBounds();
-      if (n !== void 0 && h !== void 0) {
-        const a = this.#n.size.media.width - this.yAxisWidth;
-        this.#M(n, h, a);
+      const { first: n, last: a } = this.getDataBounds();
+      if (n !== void 0 && a !== void 0) {
+        const h = this.#n.size.media.width - this.yAxisWidth;
+        this.#R(n, a, h);
       }
     }
     if (s || r) {
       this.#u = !0;
       const n = performance.now();
-      this.#e.onAxisReconfig(n), this.#y(n);
+      this.#e.onAxisReconfig(n), this.#p(n);
     }
     this.syncScales(), this.#i.markDirty(), r && this.emit("viewportChange");
   }
   /** Show or hide the background grid. Takes effect on the next render frame. */
-  setGrid(i) {
-    this.#E = i.visible, this.#i.markDirty();
+  setGrid(t) {
+    this.#E = t.visible, this.#i.markDirty();
   }
   /**
    * Set the visual state for one side of the chart. Typically called in
@@ -963,12 +978,12 @@ class Ot extends st {
    * The state persists until replaced. `has-more` is accepted for API
    * symmetry and currently renders identically to `idle`.
    */
-  setEdgeState(i, t) {
-    this.#b[i] !== t && (this.#b[i] = t, this.#d.markDirty());
+  setEdgeState(t, i) {
+    this.#x[t] !== i && (this.#x[t] = i, this.#l.markDirty());
   }
   /** Read the current host-declared state for a given edge. */
-  getEdgeState(i) {
-    return this.#b[i];
+  getEdgeState(t) {
+    return this.#x[t];
   }
   /**
    * Notify chart that a YLabel overlay is mounted / unmounted. Currently a
@@ -976,73 +991,113 @@ class Ot extends st {
    * chart area to make room for the badge.
    * TODO: implement reflow.
    */
-  setYLabel(i) {
+  setYLabel(t) {
   }
   /**
    * Dispatch a crosshair move to every renderer that supports spatial hover
    * (currently: pie). Any change in hover index schedules a main-layer redraw.
    */
-  #ft(i) {
-    const t = this.#n.size, e = this.#l, s = {
-      top: e.top * t.verticalPixelRatio,
-      bottom: e.bottom * t.verticalPixelRatio
+  #_(t) {
+    const i = this.#n.size, e = this.#c, s = {
+      top: e.top * i.verticalPixelRatio,
+      bottom: e.bottom * i.verticalPixelRatio
     };
     let r = !1;
     for (const n of this.#t) {
       if (!n.renderer.hitTest || !n.renderer.setHoverIndex) continue;
-      let h = -1;
-      if (i) {
-        const a = i.mediaX * t.horizontalPixelRatio, d = i.mediaY * t.verticalPixelRatio;
-        h = n.renderer.hitTest(a, d, t.bitmap.width, t.bitmap.height, s);
+      let a = -1;
+      if (t) {
+        const h = t.mediaX * i.horizontalPixelRatio, l = t.mediaY * i.verticalPixelRatio;
+        a = n.renderer.hitTest(h, l, i.bitmap.width, i.bitmap.height, s);
       }
-      n.renderer.setHoverIndex(h) && (r = !0);
+      n.renderer.setHoverIndex(a) && (r = !0);
     }
     r && this.#i.markDirty();
   }
+  /**
+   * Re-derive the crosshair after the viewport moved beneath it. A streaming
+   * auto-scroll, wheel zoom, or animated Y re-fit shifts the pixel↔data
+   * mapping while the cursor stays put — without this, the stored position
+   * goes stale: the tooltip freezes on the old time/values while the data
+   * (and any snap dots anchored to it) slides away underneath.
+   *
+   * Which half of the position is truth depends on {@link #crosshairAnchor}:
+   * a pointer-anchored crosshair stays under the cursor and re-resolves
+   * `time`/`y`; a time-anchored one keeps `time`/`y` and re-projects the
+   * pixel position so it tracks its data point across the screen. A
+   * time-anchored point whose time scrolls out of the visible range clears
+   * the crosshair entirely (mirroring pointer-leave) — otherwise the
+   * edge-clamped tooltip would pin to the chart border, live-updating for
+   * an invisible point.
+   *
+   * Called once per painted main frame (after `syncScales`). When the
+   * viewport didn't move, the re-derived values are bit-identical and the
+   * method exits without emitting.
+   */
+  #yt() {
+    const t = this.#d;
+    if (t === null) return;
+    const { from: i, to: e } = this.timeScale.getRange(), s = this.yScale.getRange(), r = Math.abs(e - i) * 1e-9, n = Math.abs(s.max - s.min) * 1e-9, a = 1e-6;
+    let h;
+    if (this.#F === "pointer") {
+      const l = this.timeScale.xToTime(t.mediaX), o = this.yScale.yToValue(t.mediaY);
+      if (!Number.isFinite(l) || !Number.isFinite(o) || Math.abs(l - t.time) <= r && Math.abs(o - t.y) <= n) return;
+      h = { mediaX: t.mediaX, mediaY: t.mediaY, time: l, y: o };
+    } else {
+      if (t.time < i || t.time > e) {
+        this.#d = null, this.#l.markDirty(), this.emit("crosshairMove", null), this.#_(null);
+        return;
+      }
+      const l = this.timeScale.timeToX(t.time), o = this.yScale.valueToY(t.y);
+      if (!Number.isFinite(l) || !Number.isFinite(o) || Math.abs(l - t.mediaX) <= a && Math.abs(o - t.mediaY) <= a) return;
+      h = { mediaX: l, mediaY: o, time: t.time, y: t.y };
+    }
+    this.#d = h, this.#l.markDirty(), this.emit("crosshairMove", h), this.#_(h);
+  }
   /** Tear down the chart: cancel animations, remove listeners, and detach the canvas. */
   destroy() {
-    for (const i of this.#t) i.renderer.dispose();
-    this.#t = [], this.#c = [], this.#v = [], this.#g = [], this.#A = null, this.#i.destroy(), this.#d.destroy(), this.#W?.destroy(), this.#n.destroy(), this.#F?.destroy(), this.#F = null, this.#B && this.#x?.destroy(), this.#x = null, this.#B = !1, this.removeAllListeners();
+    for (const t of this.#t) t.renderer.dispose();
+    this.#t = [], this.#m = [], this.#v = [], this.#g = [], this.#A = null, this.#i.destroy(), this.#l.destroy(), this.#W?.destroy(), this.#n.destroy(), this.#X?.destroy(), this.#X = null, this.#B && this.#S?.destroy(), this.#S = null, this.#B = !1, this.removeAllListeners();
   }
   /** The attached performance monitor, or `null` when instrumentation is disabled. */
   getPerfMonitor() {
-    return this.#x;
+    return this.#S;
   }
   /** Compute the earliest and latest timestamps across all series. */
   getDataBounds() {
-    let i, t;
+    let t, i;
     for (const e of this.#t) {
       if (!e.visible || e.renderer.kind === "pie") continue;
       const s = e.renderer.getTimeBounds();
-      s !== null && ((i === void 0 || s.first < i) && (i = s.first), (t === void 0 || s.last > t) && (t = s.last));
+      s !== null && ((t === void 0 || s.first < t) && (t = s.first), (i === void 0 || s.last > i) && (i = s.last));
     }
-    return { first: i, last: t };
+    return { first: t, last: i };
   }
   /** 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. */
-  #Y = !1;
+  #$ = !1;
   onDataChanged() {
     if (this.#w > 0) {
-      this.#$ = !0;
+      this.#O = !0;
       return;
     }
     this.updateDataInterval();
-    const { first: i, last: t } = this.getDataBounds();
-    i !== void 0 && (this.#k = i), t !== void 0 && (this.#P = this.#s, this.#s = t);
-    const e = this.#Y;
-    this.#Y = !1;
-    const s = !this.#u && i !== void 0;
-    e && (this.yScale.tickTracker.reset(), this.timeScale.tickTracker.reset()), this.#K = e;
+    const { first: t, last: i } = this.getDataBounds();
+    t !== void 0 && (this.#k = t), i !== void 0 && (this.#P = this.#s, this.#s = i);
+    const e = this.#$;
+    this.#$ = !1;
+    const s = !this.#u && t !== void 0;
+    e && (this.yScale.tickTracker.reset(), this.timeScale.tickTracker.reset()), this.#tt = e;
     const r = performance.now();
-    e || s ? (this.#D.seed(r), this.#e.onDataReplaced(r)) : this.#e.onPointAppended(r), this.#e.lastXTarget !== null && (this.#R = !0), i !== void 0 && (this.#u = !0), this.#y(r), this.syncScales(), s ? this.#U() : this.#i.markDirty(), this.emit("dataUpdate"), this.#S();
+    e || s ? (this.#D.seed(r), this.#e.onDataReplaced(r)) : this.#e.onPointAppended(r), this.#e.lastXTarget !== null && (this.#M = !0), t !== void 0 && (this.#u = !0), this.#p(r), this.syncScales(), s ? this.#G() : this.#i.markDirty(), this.emit("dataUpdate"), this.#b();
   }
   updateDataInterval() {
-    for (const i of this.#t) {
-      if (i.renderer.kind === "pie") continue;
-      const t = i.renderer.sampleTimes(20);
-      if (t.length >= 2) {
-        this.#h = lt(t);
+    for (const t of this.#t) {
+      if (t.renderer.kind === "pie") continue;
+      const i = t.renderer.sampleTimes(20);
+      if (i.length >= 2) {
+        this.#a = lt(i);
         break;
       }
     }
@@ -1058,22 +1113,22 @@ class Ot extends st {
    *  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. */
-  #R = !1;
+  #M = !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.
    */
-  #H;
+  #N;
   /** Last Y bounds the engine resolved into {@link AnimationState.yRange}.
    *  Used by {@link renderMain} to detect Y movement frame-to-frame so
    *  `viewportChange` only emits when the Y range actually shifted — DOM
    *  axis labels subscribe to that event and re-renders on every tick are
    *  expensive. Initialised to NaN so the first real Y emit always passes
    *  the change check. */
-  #X = Number.NaN;
-  #_ = Number.NaN;
+  #U = Number.NaN;
+  #Z = Number.NaN;
   /**
    * Sample the visible data window and return the resolved Y bounds, or
    * `null` when no series has data inside the X destination range.
@@ -1082,11 +1137,11 @@ class Ot extends st {
    * converge together. Clears {@link #yInited} on empty so the next emit
    * with valid data lands as an instant snap.
    */
-  #st(i) {
-    const t = i ?? this.#o, e = this.#a.min !== void 0 && this.#a.min !== "auto" && typeof this.#a.min != "number" || this.#a.max !== void 0 && this.#a.max !== "auto" && typeof this.#a.max != "number" ? [] : null, s = q(t, this.#t, e);
+  #nt(t) {
+    const i = t ?? this.#o, e = this.#h.min !== void 0 && this.#h.min !== "auto" && typeof this.#h.min != "number" || this.#h.max !== void 0 && this.#h.max !== "auto" && typeof this.#h.max != "number" ? [] : null, s = q(i, this.#t, e);
     if (s === null)
       return this.#u = !1, null;
-    const r = R(this.#a.min, s.min, s.max, e ?? [], "min"), n = R(this.#a.max, s.max, s.min, e ?? [], "max");
+    const r = M(this.#h.min, s.min, s.max, e ?? [], "min"), n = M(this.#h.max, s.max, s.min, e ?? [], "max");
     return { min: r, max: n };
   }
   /**
@@ -1107,24 +1162,24 @@ class Ot extends st {
    * - **autoscroll off** → `null` (no X retarget; user has panned away
    *   from the tail).
    */
-  #gt() {
+  #pt() {
     if (this.#k === null || this.#s === null) return null;
-    const { from: i, to: t } = this.#o, e = i === 0 && t === 0, s = this.#n.size.media.width - this.yAxisWidth;
+    const { from: t, to: i } = this.#o, e = t === 0 && i === 0, s = this.#n.size.media.width - this.yAxisWidth;
     if (e)
-      return this.#M(this.#k, this.#s, s), this.#H !== void 0 && (this.setVisibleRange(this.#H), this.#H = void 0), this.#o;
-    if (!this.#p) return null;
-    if (this.#K)
-      return this.#M(this.#k, this.#s, s), this.#o;
+      return this.#R(this.#k, this.#s, s), this.#N !== void 0 && (this.setVisibleRange(this.#N), this.#N = void 0), this.#o;
+    if (!this.#y) return null;
+    if (this.#tt)
+      return this.#R(this.#k, this.#s, s), this.#o;
     const r = j({
       currentLogical: this.#o,
       lastTime: this.#s,
       prevDataEnd: this.#P,
-      dataInterval: this.#h,
-      paddingRight: this.#l.right,
+      dataInterval: this.#a,
+      paddingRight: this.#c.right,
       chartWidth: s,
       holdUntilFilled: this.#L
     });
-    return r.releaseHold && (this.#L = !1), r.reengageAutoScroll && (this.#p = !0), r.newLogical === null ? null : (this.#D.observe(performance.now()), this.#e.setXSettleMs(this.#D.pickSettleMs(this.#f.axis.x.settleMs)), this.#C(r.newLogical, { emitChange: !1, skipValidation: !0 }), this.#P = this.#s, r.newLogical);
+    return r.releaseHold && (this.#L = !1), r.reengageAutoScroll && (this.#y = !0), r.newLogical === null ? null : (this.#D.observe(performance.now()), this.#e.setXSettleMs(this.#D.pickSettleMs(this.#f.axis.x.settleMs)), this.#T(r.newLogical, { emitChange: !1, skipValidation: !0 }), this.#P = this.#s, r.newLogical);
   }
   /**
    * Fit the viewport's logical X range around a data span. Mirrors the
@@ -1132,16 +1187,16 @@ class Ot extends st {
    * forces autoscroll on (data tail is in the new window by construction),
    * commits the new range via `viewport.setRange` (which emits `change`).
    */
-  #M(i, t, e) {
-    const s = this.#l, r = O({
-      firstTime: i,
-      lastTime: t,
-      dataInterval: this.#h,
-      maxVisibleBars: this.#Q,
+  #R(t, i, e) {
+    const s = this.#c, r = O({
+      firstTime: t,
+      lastTime: i,
+      dataInterval: this.#a,
+      maxVisibleBars: this.#it,
       chartWidth: e,
       padding: { left: s.left, right: s.right }
     });
-    this.#L = !1, this.#p = !0, this.#C(r, { emitChange: !0 });
+    this.#L = !1, this.#y = !0, this.#T(r, { emitChange: !0 });
   }
   /**
    * Commit a programmatic zoom — `fitContent` or `setVisibleRange`. Reads
@@ -1157,15 +1212,15 @@ class Ot extends st {
    *   passes `xEase: true` so X eases instead — viewport and axis converge
    *   on the same frame.
    */
-  #N(i) {
-    const t = this.#o;
-    if (t.to <= t.from) return;
+  #H(t) {
+    const i = this.#o;
+    if (i.to <= i.from) return;
     const e = performance.now();
-    if (!this.#R || !this.#u) {
-      this.#rt(e);
+    if (!this.#M || !this.#u) {
+      this.#at(e);
       return;
     }
-    this.#e.onProgrammaticZoom({ xTarget: t, xEase: i?.xEase }, e), this.#y(e);
+    this.#e.onProgrammaticZoom({ xTarget: i, xEase: t?.xEase }, e), this.#p(e);
   }
   /**
    * Commit the current logical X to the engine on the *gesture* profile:
@@ -1179,15 +1234,15 @@ class Ot extends st {
    * instead of lagging on the long sticky contract. First paint still snaps
    * (same as the programmatic path) so synchronous readers see final values.
    */
-  #pt() {
-    const i = this.#o;
-    if (i.to <= i.from) return;
-    const t = performance.now();
-    if (!this.#R || !this.#u) {
-      this.#rt(t);
+  #vt() {
+    const t = this.#o;
+    if (t.to <= t.from) return;
+    const i = performance.now();
+    if (!this.#M || !this.#u) {
+      this.#at(i);
       return;
     }
-    this.#e.onPanZoom({ xTarget: i, yAuto: !0 }, t), this.#y(t);
+    this.#e.onPanZoom({ xTarget: t, yAuto: !0 }, i), this.#p(i);
   }
   /**
    * First-paint snap: land both axes on the current logical X immediately
@@ -1196,9 +1251,9 @@ class Ot extends st {
    * commits — both must snap before the chart has painted once so a
    * synchronous `getYRange()` / `getVisibleRange()` read sees final values.
    */
-  #rt(i) {
-    const t = this.#o, e = this.#st(t);
-    this.#R = !0, e !== null && (this.#u = !0), this.#e.snap({ x: t, y: e ?? void 0 }, i), this.#y(i);
+  #at(t) {
+    const i = this.#o, e = this.#nt(i);
+    this.#M = !0, e !== null && (this.#u = !0), this.#e.snap({ x: i, y: e ?? void 0 }, t), this.#p(t);
   }
   /**
    * Validate and commit a new logical X range. Mirrors the old
@@ -1218,9 +1273,9 @@ class Ot extends st {
    * see `setVisibleRange`'s gesture path, where a per-frame echo would
    * otherwise re-arm and stall the in-flight Y ease.
    */
-  #C(i, t) {
-    const { from: e, to: s } = i;
-    return !Number.isFinite(e) || !Number.isFinite(s) || s <= e || !t.skipValidation && (s - e) / this.#h < 2 || this.#o.from === e && this.#o.to === s ? !1 : (this.#o = { from: e, to: s }, t.emitChange && (this.syncScales(), this.#i?.markDirty(), this.emit("viewportChange")), !0);
+  #T(t, i) {
+    const { from: e, to: s } = t;
+    return !Number.isFinite(e) || !Number.isFinite(s) || s <= e || !i.skipValidation && (s - e) / this.#a < 2 || this.#o.from === e && this.#o.to === s ? !1 : (this.#o = { from: e, to: s }, i.emitChange && (this.syncScales(), this.#i?.markDirty(), this.emit("viewportChange")), !0);
   }
   /**
    * Apply pixel-padding to the engine's raw Y target and store the
@@ -1228,11 +1283,11 @@ class Ot extends st {
    * symmetric pad top / bottom from `#padding`, suppressed on the side
    * that has an explicit (fixed) axis bound.
    */
-  #nt(i, t, e, s, r) {
-    const n = t - i, h = e > 0 ? this.#l.top / e * n : 0, a = e > 0 ? this.#l.bottom / e * n : 0;
+  #ht(t, i, e, s, r) {
+    const n = i - t, a = e > 0 ? this.#c.top / e * n : 0, h = e > 0 ? this.#c.bottom / e * n : 0;
     this.#V = {
-      min: s ? i : i - a,
-      max: r ? t : t + h
+      min: s ? t : t - h,
+      max: r ? i : i + a
     };
   }
   /**
@@ -1245,18 +1300,18 @@ class Ot extends st {
    * as a gesture for visual easing. Public so consumers can drive pan
    * programmatically.
    */
-  pan(i, t = this.#z) {
-    t > 0 && (this.#z = t), this.#L = !1;
+  pan(t, i = this.#z) {
+    i > 0 && (this.#z = i), this.#L = !1;
     const e = U({
       currentLogical: this.#o,
-      timeDelta: i,
-      chartWidth: t,
-      dataInterval: this.#h,
-      padding: { left: this.#l.left, right: this.#l.right },
+      timeDelta: t,
+      chartWidth: i,
+      dataInterval: this.#a,
+      padding: { left: this.#c.left, right: this.#c.right },
       dataStart: this.#k,
       dataEnd: this.#s
     });
-    e.newLogical !== null && (this.#p = !e.autoScrollOff, this.#C(e.newLogical, { emitChange: !0 }), e.edgeReached !== null && (this.#j[e.edgeReached.side] = e.edgeReached.boundaryTime, this.#q?.(e.edgeReached)), this.#D.pause(), this.#ht());
+    e.newLogical !== null && (this.#y = !e.autoScrollOff, this.#T(e.newLogical, { emitChange: !0 }), e.edgeReached !== null && (this.#J[e.edgeReached.side] = e.edgeReached.boundaryTime, this.#K?.(e.edgeReached)), this.#D.pause(), this.#ot());
   }
   /**
    * Zoom around a time anchor. `factor < 1` zooms in, `> 1` zooms out.
@@ -1273,37 +1328,37 @@ class Ot extends st {
    * and produce a visible jump). Cursor-anchored zoom is intentionally
    * sacrificed in follow-live mode — pan first to inspect history.
    */
-  zoomAt(i, t, e = this.#z) {
+  zoomAt(t, i, e = this.#z) {
     e > 0 && (this.#z = e), this.#L = !1;
     const s = Z({
       currentLogical: this.#o,
-      centerTime: i,
-      factor: t,
+      centerTime: t,
+      factor: i,
       chartWidth: e,
-      dataInterval: this.#h,
-      padding: { left: this.#l.left, right: this.#l.right },
+      dataInterval: this.#a,
+      padding: { left: this.#c.left, right: this.#c.right },
       dataStart: this.#k,
       dataEnd: this.#s
     });
     if (s.newLogical === null) return;
     let r = s.newLogical;
-    if (this.#p && this.#s !== null) {
-      const n = r.to - r.from, h = T(this.#l.right, n, this.#h, e), a = this.#s + h;
-      r = { from: a - n, to: a }, this.#P = this.#s;
+    if (this.#y && this.#s !== null) {
+      const n = r.to - r.from, a = C(this.#c.right, n, this.#a, e), h = this.#s + a;
+      r = { from: h - n, to: h }, this.#P = this.#s;
     }
-    this.#C(r, { emitChange: !0 }), this.#D.pause(), this.#ht();
+    this.#T(r, { emitChange: !0 }), this.#D.pause(), this.#ot();
   }
   /**
    * 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`.
    */
-  #ht() {
-    const i = this.#o;
-    if (i.to <= i.from) return;
-    this.#R = !0, this.#u = !0;
-    const t = performance.now();
-    this.#e.onPanZoom({ xTarget: i, yAuto: !0 }, t), this.#y(t);
+  #ot() {
+    const t = this.#o;
+    if (t.to <= t.from) return;
+    this.#M = !0, this.#u = !0;
+    const i = performance.now();
+    this.#e.onPanZoom({ xTarget: t, yAuto: !0 }, i), this.#p(i);
   }
   /**
    * Tick the engine at the given wall clock and push the resolved X / Y
@@ -1318,11 +1373,11 @@ class Ot extends st {
    * `effectiveNow === startWall` and the prune step keeps zero-duration
    * events long enough for the slot processor to snap them.
    */
-  #y(i) {
-    const t = this.#e.tick(i), e = this.#n.size;
+  #p(t) {
+    const i = this.#e.tick(t), e = this.#n.size;
     if (e.media.width === 0 || e.media.height === 0) return;
-    const s = this.#a.min !== void 0 && this.#a.min !== "auto", r = this.#a.max !== void 0 && this.#a.max !== "auto", n = e.media.height - this.xAxisHeight;
-    this.#nt(t.yRange.min, t.yRange.max, n, s, r), this.#X = t.yRange.min, this.#_ = t.yRange.max, this.syncScales();
+    const s = this.#h.min !== void 0 && this.#h.min !== "auto", r = this.#h.max !== void 0 && this.#h.max !== "auto", n = e.media.height - this.xAxisHeight;
+    this.#ht(i.yRange.min, i.yRange.max, n, s, r), this.#U = i.yRange.min, this.#Z = i.yRange.max, this.syncScales();
   }
   /**
    * Lightweight scale sync: updates timeScale/yScale from current viewport state
@@ -1330,79 +1385,79 @@ class Ot extends st {
    * handler, so DOM axis components always read fresh coordinates on re-render.
    */
   syncScales() {
-    const i = this.#n.size;
-    if (i.media.width === 0 || i.media.height === 0) return;
-    const t = i.media.width - this.yAxisWidth, e = i.media.height - this.xAxisHeight;
+    const t = this.#n.size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    const i = t.media.width - this.yAxisWidth, e = t.media.height - this.xAxisHeight;
     this.timeScale.update(
       this.#e.getAnimationState().xRange,
-      t,
-      i.horizontalPixelRatio,
-      this.#h
-    ), this.yScale.update(this.#V, e, i.verticalPixelRatio);
+      i,
+      t.horizontalPixelRatio,
+      this.#a
+    ), this.yScale.update(this.#V, e, t.verticalPixelRatio);
   }
   /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
-  renderMain(i) {
-    const t = this.#n.size;
-    if (t.media.width === 0 || t.media.height === 0) return;
-    const e = typeof i == "number" ? i : performance.now(), s = this.#e.tick(e);
+  renderMain(t) {
+    const i = this.#n.size;
+    if (i.media.width === 0 || i.media.height === 0) return;
+    const e = typeof t == "number" ? t : performance.now(), s = this.#e.tick(e);
     s.animating && this.#i.markDirty();
-    const r = s.yRange.min, n = s.yRange.max, h = r !== this.#X || n !== this.#_;
-    if (h) {
-      const c = this.#a.min !== void 0 && this.#a.min !== "auto", o = this.#a.max !== void 0 && this.#a.max !== "auto", f = t.media.height - this.xAxisHeight;
-      this.#nt(r, n, f, c, o), this.#X = r, this.#_ = n;
+    const r = s.yRange.min, n = s.yRange.max, a = r !== this.#U || n !== this.#Z;
+    if (a) {
+      const d = this.#h.min !== void 0 && this.#h.min !== "auto", c = this.#h.max !== void 0 && this.#h.max !== "auto", f = i.media.height - this.xAxisHeight;
+      this.#ht(r, n, f, d, c), this.#U = r, this.#Z = n;
     }
-    if (this.syncScales(), this.#s !== null && !this.#p) {
-      const c = this.#e.lastXTarget ?? this.#o, o = c.to - c.from;
-      if (o > 0) {
-        const f = this.#n.size.media.width - this.yAxisWidth, y = T(this.#l.right, o, this.#h, f), v = this.#h * 0.5;
-        Math.abs(c.to - (this.#s + y)) < v && (this.#p = !0);
+    if (this.syncScales(), this.#yt(), this.#s !== null && !this.#y) {
+      const d = this.#e.lastXTarget ?? this.#o, c = d.to - d.from;
+      if (c > 0) {
+        const f = this.#n.size.media.width - this.yAxisWidth, p = C(this.#c.right, c, this.#a, f), v = this.#a * 0.5;
+        Math.abs(d.to - (this.#s + p)) < v && (this.#y = !0);
       }
     }
-    h && this.emit("viewportChange");
-    let a = !1, d = !1;
-    this.#n.useMainLayer((c) => {
-      const { context: o, bitmapSize: f } = c, y = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, v = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
-      o.clearRect(0, 0, f.width, f.height), o.save(), o.beginPath(), o.rect(0, 0, y, v), o.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#h).ticks), this.yScale.tickTracker.tick(e), this.timeScale.tickTracker.tick(e);
-      const S = this.yScale.tickTracker.snapshot(), b = this.timeScale.tickTracker.snapshot();
-      a = S.isAnimating, d = b.isAnimating, (S.isAnimating || b.isAnimating || s.animating) && this.emit("tickFrame"), this.#E && K({
-        scope: c,
+    a && this.emit("viewportChange");
+    let h = !1, l = !1;
+    this.#n.useMainLayer((d) => {
+      const { context: c, bitmapSize: f } = d, p = (i.media.width - this.yAxisWidth) * i.horizontalPixelRatio, v = (i.media.height - this.xAxisHeight) * i.verticalPixelRatio;
+      c.clearRect(0, 0, f.width, f.height), c.save(), c.beginPath(), c.rect(0, 0, p, v), c.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#a).ticks), this.yScale.tickTracker.tick(e), this.timeScale.tickTracker.tick(e);
+      const b = this.yScale.tickTracker.snapshot(), x = this.timeScale.tickTracker.snapshot();
+      h = b.isAnimating, l = x.isAnimating, (b.isAnimating || x.isAnimating || s.animating) && this.emit("tickFrame"), this.#E && K({
+        scope: d,
         timeScale: this.timeScale,
         yScale: this.yScale,
         theme: this.#r,
-        yTicks: S,
-        timeTicks: b
-      }), this.#ct(c, y, v);
-      const k = this.#l, P = { top: k.top, bottom: k.bottom }, w = this.#x;
-      for (const p of this.#t) {
-        const x = p.renderer.getAlpha?.() ?? (p.visible ? 1 : 0);
-        if (x <= 0) continue;
+        yTicks: b,
+        timeTicks: x
+      }), this.#ut(d, p, v);
+      const k = this.#c, P = { top: k.top, bottom: k.bottom }, w = this.#S;
+      for (const y of this.#t) {
+        const S = y.renderer.getAlpha?.() ?? (y.visible ? 1 : 0);
+        if (S <= 0) continue;
         const L = {
-          scope: c,
+          scope: d,
           timeScale: this.timeScale,
           yScale: this.yScale,
           theme: this.#r,
-          dataInterval: this.#h,
+          dataInterval: this.#a,
           padding: P,
           state: s,
-          seriesId: p.id
-        }, A = o.globalAlpha;
-        if (x < 1 && (o.globalAlpha = A * x), w) {
+          seriesId: y.id
+        }, A = c.globalAlpha;
+        if (S < 1 && (c.globalAlpha = A * S), w) {
           const V = performance.now();
-          p.renderer.render(L), w.recordSeries(p.id, performance.now() - V, e);
+          y.renderer.render(L), w.recordSeries(y.id, performance.now() - V, e);
         } else
-          p.renderer.render(L);
-        x < 1 && (o.globalAlpha = A);
+          y.renderer.render(L);
+        S < 1 && (c.globalAlpha = A);
       }
-      o.restore();
+      c.restore();
     });
-    let l = !1;
-    for (const c of this.#t)
-      if (c.renderer.needsAnimation) {
-        l = !0, this.#i.markDirty();
+    let o = !1;
+    for (const d of this.#t)
+      if (d.renderer.needsAnimation) {
+        o = !0, this.#i.markDirty();
         break;
       }
-    const u = a || d;
-    !s.animating && !l && !u && (this.yScale.tickTracker.markArmed(), this.timeScale.tickTracker.markArmed());
+    const u = h || l;
+    !s.animating && !o && !u && (this.yScale.tickTracker.markArmed(), this.timeScale.tickTracker.markArmed());
   }
   /**
    * Paint a full frame: the main layer, then the overlay synchronously on
@@ -1413,80 +1468,80 @@ class Ot extends st {
    * `markDirty` calls made *during* `renderOverlay` (pulse, edge spinner)
    * land after the consume and re-arm cleanly for the next frame.
    */
-  #U(i) {
-    this.#Z("main", i, () => this.renderMain(i)), this.#d.consume(), this.#Z("overlay", i, () => this.renderOverlay(i));
+  #G(t) {
+    this.#j("main", t, () => this.renderMain(t)), this.#l.consume(), this.#j("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. */
-  #Z(i, t, e) {
-    const s = this.#x;
+  #j(t, i, e) {
+    const s = this.#S;
     if (!s) {
       e();
       return;
     }
-    s.resetDrawCalls(i);
+    s.resetDrawCalls(t);
     const r = performance.now();
-    e(), s.recordFrame(i, performance.now() - r, t ?? r);
+    e(), s.recordFrame(t, performance.now() - r, i ?? r);
   }
   /** Cheap overlay: crosshair, nearest-point dots, pulse animation, edge indicator. */
-  renderOverlay(i) {
-    const t = this.#n.size;
-    if (t.media.width === 0 || t.media.height === 0) return;
+  renderOverlay(t) {
+    const i = this.#n.size;
+    if (i.media.width === 0 || i.media.height === 0) return;
     let e = !1;
-    for (const h of this.#t)
-      if (h.visible && h.renderer.overlayNeedsAnimation) {
+    for (const a of this.#t)
+      if (a.visible && a.renderer.overlayNeedsAnimation) {
         e = !0;
         break;
       }
-    this.#c.some((h) => h.pulse) && (e = !0);
-    const s = this.#b.left === "loading" || this.#b.right === "loading", r = this.#b.left !== "idle" || this.#b.right !== "idle", n = !!this.#m || e || r || this.#c.length > 0 || this.#g.length > 0;
-    if (!(!n && !this.#G)) {
-      if (this.#G = n, this.#n.useOverlayLayer((h) => {
+    this.#m.some((a) => a.pulse) && (e = !0);
+    const s = this.#x.left === "loading" || this.#x.right === "loading", r = this.#x.left !== "idle" || this.#x.right !== "idle", n = !!this.#d || e || r || this.#m.length > 0 || this.#g.length > 0;
+    if (!(!n && !this.#q)) {
+      if (this.#q = n, this.#n.useOverlayLayer((a) => {
         if (!n) return;
-        const a = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, d = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
-        if (h.context.save(), h.context.beginPath(), h.context.rect(0, 0, a, d), h.context.clip(), this.#m && this.#ut()) {
-          const o = this.#m.mediaX * t.horizontalPixelRatio, f = this.#m.mediaY * t.verticalPixelRatio;
-          J(h, o, f, this.#r);
+        const h = (i.media.width - this.yAxisWidth) * i.horizontalPixelRatio, l = (i.media.height - this.xAxisHeight) * i.verticalPixelRatio;
+        if (a.context.save(), a.context.beginPath(), a.context.rect(0, 0, h, l), a.context.clip(), this.#d && this.#gt()) {
+          const c = this.#d.mediaX * i.horizontalPixelRatio, f = this.#d.mediaY * i.verticalPixelRatio;
+          J(a, c, f, this.#r);
         }
-        const l = this.#l, u = { top: l.top, bottom: l.bottom }, c = this.#e.getAnimationState();
-        for (const o of this.#t)
-          o.visible && o.renderer.drawOverlay?.({
-            scope: h,
+        const o = this.#c, u = { top: o.top, bottom: o.bottom }, d = this.#e.getAnimationState();
+        for (const c of this.#t)
+          c.visible && c.renderer.drawOverlay?.({
+            scope: a,
             timeScale: this.timeScale,
             yScale: this.yScale,
             theme: this.#r,
-            dataInterval: this.#h,
+            dataInterval: this.#a,
             padding: u,
-            crosshair: this.#m,
-            state: c,
-            seriesId: o.id
+            crosshair: this.#d,
+            state: d,
+            seriesId: c.id
           });
-        this.#mt(h, a, d), this.#dt(h), r && E({
-          scope: h,
-          chartMediaHeight: t.media.height - this.xAxisHeight,
+        this.#ft(a, h, l), this.#mt(a), r && E({
+          scope: a,
+          chartMediaHeight: i.media.height - this.xAxisHeight,
           timeScale: this.timeScale,
           theme: this.#r,
-          edgeStates: this.#b,
-          resolveBoundary: (o) => $(o, this.#j[o], this.getDataBounds())
-        }), h.context.restore();
+          edgeStates: this.#x,
+          resolveBoundary: (c) => F(c, this.#J[c], this.getDataBounds())
+        }), a.context.restore();
       }), e) {
-        const { from: h, to: a } = this.timeScale.getRange();
-        let d = !1;
-        for (const l of this.#t)
-          if (!(!l.visible || !l.renderer.overlayNeedsAnimation) && (l.renderer.hasOverlayContentInRange?.(h, a) ?? !0)) {
-            d = !0;
+        const { from: a, to: h } = this.timeScale.getRange();
+        let l = !1;
+        for (const o of this.#t)
+          if (!(!o.visible || !o.renderer.overlayNeedsAnimation) && (o.renderer.hasOverlayContentInRange?.(a, h) ?? !0)) {
+            l = !0;
             break;
           }
-        if (!d) {
-          for (const l of this.#c)
-            if (l.pulse && l.time >= h && l.time <= a) {
-              d = !0;
+        if (!l) {
+          for (const o of this.#m)
+            if (o.pulse && o.time >= a && o.time <= h) {
+              l = !0;
               break;
             }
         }
-        d && this.#d.markDirty();
+        l && this.#l.markDirty();
       }
-      s && this.#d.markDirty();
+      s && this.#l.markDirty();
     }
   }
 }