@wick-charts/vue 0.6.2 → 0.6.4

package/dist/core/dist/chart.js

@@ -1,55 +1,57 @@
-import { Animator as Y } from "./animation/animator.js";
-import { AnimationConfig as X, DEFAULT_LINE_PULSE as $ } from "./animation/config.js";
-import { easeOutCubic as P } from "./animation/easing.js";
-import { prefersReducedMotion as Z } from "./animation/reduced-motion.js";
-import { createViewportEngine as _ } from "./animation/viewport-engine.js";
-import { CanvasManager as G } from "./canvas-manager.js";
-import { resolveEdgeAnchorValue as U, drawEdgeIndicators as K, resolveEdgeBoundary as j } from "./chart/edge-indicators.js";
-import { computeFitToData as q } from "./chart/fit-to-data.js";
-import { getLastValue as J, getPreviousClose as Q, getStackedLastValue as tt } from "./chart/last-value.js";
-import { resolveFade as H, resolveMaxVisibleBars as it, resolvePadding as z, resolvePerfOptions as et, isSameHorizontalPadding as V } from "./chart/options.js";
-import { computePan as st, computeZoom as rt } from "./chart/pan-zoom-math.js";
-import { StreamingCadence as nt } from "./chart/streaming-cadence.js";
-import { computeStreamingTarget as at } from "./chart/streaming-target.js";
-import { resolvePaddingTime as W } from "./chart/viewport-padding.js";
-import { computeTargetYRange as ht, resolveBound as F } from "./chart/y-target.js";
-import { renderCrosshair as ot } from "./components/crosshair.js";
-import { renderGrid as lt } from "./components/grid.js";
-import { renderMarker as ct } from "./components/marker.js";
-import { renderReferenceLine as dt } from "./components/reference-line.js";
-import { resolveTimeRegionColors as mt, renderTimeRegion as ut } from "./components/time-region.js";
-import { EventEmitter as ft } from "./events.js";
-import { InteractionHandler as gt } from "./interactions/handler.js";
-import { RenderScheduler as B } from "./render-scheduler.js";
-import { XScale as pt } from "./scales/x-scale.js";
-import { YScale as yt } from "./scales/y-scale.js";
-import { resolveSeriesDefinition as vt } from "./series/definition.js";
-import { isTimeSeriesRenderer as k } from "./series/types.js";
-import { catppuccin as xt } from "./theme/themes/catppuccin.js";
-import { clamp as bt } from "./utils/math.js";
-import { crispLineWidth as St, crispCenterOffset as kt } from "./utils/pixel-grid.js";
-import { normalizeTime as x, detectInterval as wt } from "./utils/time.js";
-const At = 200, Lt = 1500, Tt = 48, Mt = 12, T = 9;
-let Dt = 0, Rt = 0, Ct = 0, It = 0;
-function N(p, t) {
-  return p === t ? !0 : !p || !t || p.length !== t.length ? !1 : p.every((i, e) => i === t[e]);
+import { Animator as K } from "./animation/animator.js";
+import { AnimationConfig as j, DEFAULT_LINE_PULSE as J } from "./animation/config.js";
+import { easeOutCubic as W } from "./animation/easing.js";
+import { prefersReducedMotion as Q } from "./animation/reduced-motion.js";
+import { createViewportEngine as tt } from "./animation/viewport-engine.js";
+import { CanvasManager as it } from "./canvas-manager.js";
+import { resolveEdgeAnchorValue as et, drawEdgeIndicators as st, resolveEdgeBoundary as rt } from "./chart/edge-indicators.js";
+import { computeFitToData as nt } from "./chart/fit-to-data.js";
+import { getLastValue as at, getPreviousClose as ot, getStackedLastValue as ht } from "./chart/last-value.js";
+import { resolveFade as O, resolveMaxVisibleBars as lt, resolvePadding as F, resolvePerfOptions as ct, isSameHorizontalPadding as $ } from "./chart/options.js";
+import { computePan as dt, computeZoom as ut } from "./chart/pan-zoom-math.js";
+import { warnUnplottableBounds as N, assertStackingFitsScale as M, warnUnplottableValues as mt } from "./chart/scale-guards.js";
+import { StreamingCadence as ft } from "./chart/streaming-cadence.js";
+import { computeStreamingTarget as gt } from "./chart/streaming-target.js";
+import { resolvePaddingTime as B } from "./chart/viewport-padding.js";
+import { fromScaleSpace as pt, computeTargetYRange as yt, resolveYTarget as vt } from "./chart/y-target.js";
+import { renderCrosshair as bt } from "./components/crosshair.js";
+import { renderGrid as E } from "./components/grid.js";
+import { renderMarker as xt } from "./components/marker.js";
+import { renderReferenceLine as St } from "./components/reference-line.js";
+import { resolveTimeRegionColors as kt, renderTimeRegion as At } from "./components/time-region.js";
+import { EventEmitter as wt } from "./events.js";
+import { InteractionHandler as Tt } from "./interactions/handler.js";
+import { RenderScheduler as Y } from "./render-scheduler.js";
+import { XScale as Lt } from "./scales/x-scale.js";
+import { YScale as Mt, isPlottableOn as Pt } from "./scales/y-scale.js";
+import { resolveSeriesDefinition as Dt } from "./series/definition.js";
+import { isTimeSeriesRenderer as b } from "./series/types.js";
+import { catppuccin as Rt } from "./theme/themes/catppuccin.js";
+import { clamp as Ct } from "./utils/math.js";
+import { crispLineWidth as It, crispCenterOffset as Ht } from "./utils/pixel-grid.js";
+import { pointValue as X, isBandPoint as zt } from "./utils/point.js";
+import { normalizeTime as x, detectInterval as Vt } from "./utils/time.js";
+const Wt = 200, Ot = 1500, Ft = 48, Z = 12, P = 9, $t = ["left", "right"], Nt = ["left"], Bt = ["right"];
+let Et = 0, Yt = 0, Xt = 0, Zt = 0;
+function _(y, t) {
+  return y === t ? !0 : !y || !t || y.length !== t.length ? !1 : y.every((i, e) => i === t[e]);
 }
-function Pt(p, t) {
-  return p === t ? !0 : !p || !t || p.length !== t.length ? !1 : p.every((i, e) => i === t[e]);
+function _t(y, t) {
+  return y === t ? !0 : !y || !t || y.length !== t.length ? !1 : y.every((i, e) => i === t[e]);
 }
-class ci extends ft {
+class Li extends wt {
   /** Canvas lifecycle and DPR-aware sizing. */
   #a;
   /** Schedules main-layer redraws (background, grid, series). */
   #i;
   /** Schedules overlay redraws (crosshair). */
-  #h;
+  #o;
   /** Maps time values to horizontal pixel coordinates. */
   timeScale;
   /** Maps price/value to vertical pixel coordinates. */
   yScale;
   /** Zoom, pan, crosshair — null when interactive=false. */
-  #M;
+  #P;
   /** All registered series (candlestick, line, bar, pie). */
   #t = [];
   /** Point annotations (event markers) drawn on the overlay layer, kept out of the series model. */
@@ -66,8 +68,8 @@ class ci extends ft {
    * later — which re-arms `getIntroFront()`'s global min — can't blink settled
    * markers / reference lines back out.
    */
-  #nt = !1;
-  #at = !1;
+  #mt = !1;
+  #ft = !1;
   /** Active visual theme (colors, fonts, grid style). */
   #n;
   /** Whether to render the background grid. */
@@ -78,13 +80,15 @@ class ci extends ft {
    * per-tick fades stay snapped during mount (see the tracker's arming), so
    * this is what keeps `fitToData` tick churn from flickering the reveal.
    */
-  #I;
-  /** Resolved edge-fade zones — `right: null` tracks the live Y-axis width. */
-  #k;
+  #H;
+  /** Resolved edge-fade zones — a `null` side is auto: the axis-column ramp on the Y-axis side, off on the other. */
+  #A;
+  /** See {@link headerHeight}. */
+  #U = 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. */
-  #w = { top: null, right: null, left: null, tail: null };
+  #v = { top: null, axis: null, edge: { left: null, right: null }, tail: null, overhang: null };
   /** Detected time interval between data points (milliseconds). */
   #r = 6e4;
   /** Current crosshair position, null when cursor is outside the chart. */
@@ -96,45 +100,45 @@ class ci extends ft {
    * `time`/`y`; `'time'` (programmatic {@link setCrosshair}) keeps
    * `time`/`y` and re-projects the pixel position.
    */
-  #$ = "pointer";
+  #q = "pointer";
   /** Whether the last overlay pass painted anything — gates the full-bitmap
    *  clear so an empty overlay isn't cleared again every main frame. */
-  #ht = !1;
+  #gt = !1;
   /** User-specified Y-axis bounds (auto, fixed, percentage). */
-  #d = {};
+  #p = {};
   /** Cached series ID list — invalidated on add/remove. */
   #D = null;
   /** Axis visibility and sizing configuration. */
-  #B = {};
+  #T = {};
   /** Host-declared state per edge — drives the edge-indicator overlay. */
-  #b = { left: "idle", right: "idle" };
+  #S = { left: "idle", right: "idle" };
   /** Wall-clock start of a `loading` exit fade per side — set when the host
    *  drops `loading` back to `idle`/`has-more`, so the indicator fades out
    *  over {@link EDGE_EXIT_FADE_MS} instead of vanishing the same frame the
    *  fetched data lands. `null` = no fade in flight. */
-  #N = { left: null, right: null };
+  #$ = { left: null, right: null };
   /** Cached boundary timestamps from the last `edgeReached` emission, by side. */
-  #ot = { left: null, right: null };
+  #pt = { left: null, right: null };
   /** Latest placeholder shapes a `loading` indicator reported per side —
    *  the morph hand-off candidate consumed by {@link prependData}. */
-  #Z = { left: null, right: null };
+  #K = { 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. */
-  #P = { left: !1, right: !1 };
+  #z = { left: !1, right: !1 };
   /** Host-supplied callback fired when the user releases a pan/zoom past a data edge. */
-  #lt;
+  #yt;
   /** Per-side custom painter for the edge `loading` spinner. `null` falls back to the built-in dots. */
-  #ct = { left: null, right: null };
+  #vt = { left: null, right: null };
   /** Nesting depth for batch updates. Suppresses recomputes while > 0. */
   #L = 0;
   /** True when batched operations include data changes (triggers full onDataChanged on end). */
-  #_ = !1;
+  #j = !1;
   /** True when batched operations include visibility changes (triggers Y-range + redraw on end). */
-  #H = !1;
+  #V = !1;
   /** True when batched operations bumped overlay version (emits a single overlayChange on flush). */
-  #G = !1;
+  #J = !1;
   /**
    * Monotonic counter bumped on any mutation that affects overlay output —
    * data, visibility, series options, theme. Used by snapshot helpers in
@@ -144,17 +148,36 @@ class ci extends ft {
    *
    * @internal
    */
-  #dt = 0;
+  #bt = 0;
+  /** CSS px of the Y-axis column. The default collapses to `0` on a spatial-only chart. */
   get yAxisWidth() {
-    const t = this.#B.y;
-    return t?.visible === !1 ? 0 : t?.width ?? 55;
+    const t = this.#T.y;
+    return t?.visible === !1 ? 0 : t?.width !== void 0 ? t.width : this.#X() ? 0 : 55;
+  }
+  /** Side of the plot area the Y-axis column sits on. */
+  get yAxisPosition() {
+    return this.#T.y?.position ?? "right";
+  }
+  /**
+   * Left edge of the plot area in container CSS px — the Y-axis width when
+   * the axis sits on the left, `0` otherwise. Scales map into the plot area,
+   * so add this to `timeScale.timeToX()` to get a container coordinate.
+   */
+  get plotLeft() {
+    return this.yAxisPosition === "left" ? this.yAxisWidth : 0;
+  }
+  /** 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.#U;
   }
+  /** CSS px of the time-axis row. The default collapses to `0` on a spatial-only chart. */
   get xAxisHeight() {
-    const t = this.#B.x;
-    return t?.visible === !1 ? 0 : t?.height ?? 30;
+    const t = this.#T.x;
+    return t?.visible === !1 ? 0 : t?.height !== void 0 ? t.height : this.#X() ? 0 : 30;
   }
   /** Resolved animation config derived from `options.animations` at construction. */
-  #m;
+  #d;
   /**
    * Single source of truth for the chart's X / Y viewport animation.
    * Push-model API: chart emits intent signals (`onPointAppended`,
@@ -179,9 +202,9 @@ class ci extends ft {
    * field carries the decision across that gap. The closure also reads
    * `#dataStart` / `#dataEnd` directly for the timestamps.
    */
-  #mt = !1;
+  #xt = !1;
   /** Earliest data timestamp registered across all series, `null` before any data has arrived. */
-  #A = null;
+  #w = null;
   /** Latest data timestamp registered across all series, `null` before any data has arrived. */
   #e = null;
   /**
@@ -190,51 +213,51 @@ class ci extends ft {
    * left of the tail keeps that offset as new bars arrive, instead of
    * snapping back to the natural-pin position every frame.
    */
-  #O = null;
+  #N = null;
   /**
    * Warm-up window flag — `setVisibleRange({ from, bars })` arms it and
    * the streaming-target math suppresses pan ticks while the data hasn't
    * reached the right edge yet. Cleared by user interaction or once the
    * data fills the window.
    */
-  #T = !1;
+  #M = !1;
   /**
    * Cap for fit-to-data. When the data span exceeds this, the fit anchors
    * the right edge and trims the left. Resolved once at construction from
    * `options.viewport.maxVisibleBars`.
    */
-  #ut;
+  #St;
   /**
    * 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.
    */
-  #o = { from: 0, to: 0 };
+  #h = { from: 0, to: 0 };
   /** Padded Y range — engine's raw Y target plus pixel padding from `#padding`. */
-  #z = { min: 0, max: 0 };
+  #B = { min: 0, max: 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
    * screen; chart's per-frame autoscroll check re-engages it when a
    * follow-up pan brings the tail back into view.
    */
-  #f = !0;
+  #m = !0;
   /** Resolved viewport padding (top/bottom px + left/right pixels-or-intervals). */
   #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). */
   #E = 0;
   /** Active performance monitor, or `null` when instrumentation is disabled (the default). */
-  #S;
+  #k;
   /** When true, `destroy()` tears down the monitor; false for caller-supplied monitors we must not destroy. */
-  #U = !1;
+  #Q = !1;
   /** Visible HUD overlay (mounted by the perf config); non-null only when the caller requested one. */
-  #K = null;
+  #tt = null;
   constructor(t, i) {
-    super(), i?.axis && (this.#B = i.axis, this.#d = { min: i.axis.y?.min, max: i.axis.y?.max }), this.#n = i?.theme ?? xt.theme, this.#F = i?.grid?.visible !== !1, this.#k = H(i?.fade), this.#m = X.resolve(i?.animations), this.#ut = it(i?.viewport?.maxVisibleBars), this.#l = z(i?.padding), this.#R = new nt();
-    const e = this.#m.axis.y, s = this.#m.axis.x;
-    this.#s = _({
+    super(), i?.axis && (this.#T = i.axis, this.#p = { min: i.axis.y?.min, max: i.axis.y?.max }), this.#n = i?.theme ?? Rt.theme, this.#F = i?.grid?.visible !== !1, this.#A = O(i?.fade), this.#d = j.resolve(i?.animations), this.#St = lt(i?.viewport?.maxVisibleBars), this.#l = F(i?.padding), this.#R = new ft();
+    const e = this.#d.axis.y, s = this.#d.axis.x;
+    this.#s = tt({
       initial: { yRange: { min: 0, max: 0 }, xRange: { from: 0, to: 0 } },
       y: {
         curve: e.curve,
@@ -242,36 +265,36 @@ class ci extends ft {
         stickyMs: e.stickyMs,
         stickyFloorMs: e.stickyFloorMs,
         gestureMs: e.gestureMs,
-        toggleMs: this.#m.toggleMs
+        toggleMs: this.#d.toggleMs
       },
       x: {
         curve: s.curve,
         settleMs: s.settleMs,
         gestureMs: s.gestureMs
       },
-      computeXTarget: () => this.#Ft(),
-      computeYTarget: ({ xTarget: h }) => this.#St(h),
+      computeXTarget: () => this.#Jt(),
+      computeYTarget: ({ xTarget: o }) => this.#ht(o),
       onWake: () => this.#i?.markDirty()
-    }), this.#lt = i?.onEdgeReached, this.#Y = i?.viewport?.initialRange;
-    const r = et(i?.perf);
-    this.#S = r.monitor, this.#U = r.ownsMonitor, this.#a = new G(t, this.#S ?? void 0), this.timeScale = new pt(), this.yScale = new yt(), this.timeScale.setLocale(i?.locale), this.timeScale.setTimeZone(i?.timeZone);
-    const n = this.#m.axis.ticksMs;
-    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#I = new Y({
+    }), this.#yt = i?.onEdgeReached, this.#_ = i?.viewport?.initialRange;
+    const r = ct(i?.perf);
+    this.#k = r.monitor, this.#Q = r.ownsMonitor, this.#a = new it(t, this.#k ?? void 0), this.timeScale = new Lt(), this.yScale = new Mt(), this.yScale.setTransform(this.#T.y?.scale ?? null), N({ y: this.#T.y, isPlottable: this.#Y }), this.timeScale.setLocale(i?.locale), this.timeScale.setTimeZone(i?.timeZone);
+    const n = this.#d.axis.ticksMs;
+    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#H = new K({
       initial: 0,
-      duration: this.#m.axis.gridMs,
-      lerp: (h, l, o) => h + (l - h) * o
-    }), this.#i = new B((h) => this.#st(h)), this.#h = new B(
-      (h) => this.#rt("overlay", h, () => this.renderOverlay(h))
-    ), this.#S && r.hud && (this.#K = r.hud(t, this.#S));
+      duration: this.#d.axis.gridMs,
+      lerp: (o, l, h) => o + (l - o) * h
+    }), this.#i = new Y((o) => this.#dt(o)), this.#o = new Y(
+      (o) => this.#ut("overlay", o, () => this.renderOverlay(o))
+    ), this.#k && r.hud && (this.#tt = r.hud(t, this.#k));
     const a = i?.interactive !== !1;
-    this.#M = a ? new gt(this.#a.canvas, this, this.timeScale, this.yScale) : null, this.#a.on("resize", () => {
-      this.syncScales(), this.#st(), this.emit("viewportChange");
-    }), this.syncScales(), this.#M?.on("crosshairMove", (h) => {
-      this.#$ = "pointer", this.#c = h, this.#h.markDirty(), this.emit("crosshairMove", h), this.#J(h);
-    }), this.#M?.on("click", (h) => {
-      this.emit("pointClick", { ...h, spatialHit: this.#bt(h) });
-    }), this.#M?.on("dblclick", (h) => {
-      this.fitContent(), this.emit("pointDoubleClick", { ...h, spatialHit: this.#bt(h) });
+    this.#P = a ? new Tt(this.#a.canvas, this, this.timeScale, this.yScale) : null, this.#a.on("resize", () => {
+      this.syncScales(), this.#dt(), this.emit("viewportChange");
+    }), this.syncScales(), this.#P?.on("crosshairMove", (o) => {
+      this.#q = "pointer", this.#c = o, this.#o.markDirty(), this.emit("crosshairMove", o), this.#rt(o);
+    }), this.#P?.on("click", (o) => {
+      this.emit("pointClick", { ...o, spatialHit: this.#Dt(o) });
+    }), this.#P?.on("dblclick", (o) => {
+      this.fitContent(), this.emit("pointDoubleClick", { ...o, spatialHit: this.#Dt(o) });
     });
   }
   /**
@@ -286,9 +309,9 @@ class ci extends ft {
    * `setSeriesVisible` / `setLayerVisible` calls — produce one overlay
    * render instead of N.
    */
-  #p() {
-    if (this.#dt++, this.#L > 0) {
-      this.#G = !0;
+  #f() {
+    if (this.#bt++, this.#L > 0) {
+      this.#J = !0;
       return;
     }
     this.emit("overlayChange");
@@ -302,39 +325,46 @@ class ci extends ft {
    * @internal
    */
   getOverlayVersion() {
-    return this.#dt;
+    return this.#bt;
   }
   /**
    * 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.
    */
-  #Dt(t) {
+  #Et(t) {
     if (t && !this.#t.some((e) => e.id === t))
       return t;
     let i;
     do
-      i = `series_${++Dt}`;
+      i = `series_${++Et}`;
     while (this.#t.some((e) => e.id === i));
     return i;
   }
   addSeries(t, i = {}) {
-    const e = typeof t == "string" ? vt(t) : t;
+    const e = typeof t == "string" ? Dt(t) : t;
     if (!e)
       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, ...h } = i, l = s ?? 1, o = {
-      ...this.#m.defaults(e.type),
-      ...h,
-      ...this.#m.overrides(e.type)
-    }, m = e.create({ theme: this.#n, layerCount: l }, o), u = a ?? (typeof n == "string" ? [n] : void 0), c = this.#Dt(r);
-    return m.onDataChanged?.(() => this.onDataChanged()), this.#t.push({ id: c, labels: u, renderer: m, visible: !0 }), this.#D = null, this.#q(), this.emit("seriesChange"), this.#p(), c;
+    const { layers: s, id: r, label: n, labels: a, ...o } = i, l = s ?? 1;
+    M({ seriesId: r ?? e.type, stacking: o.stacking, isPlottable: this.#Y });
+    const h = {
+      ...this.#d.defaults(e.type),
+      ...o,
+      ...this.#d.overrides(e.type)
+    }, d = e.create({ theme: this.#n, layerCount: l }, h), m = a ?? (typeof n == "string" ? [n] : void 0), c = this.#Et(r);
+    d.onDataChanged?.(() => this.onDataChanged());
+    const f = this.#Z();
+    return this.#t.push({ id: c, labels: m, renderer: d, visible: !0 }), this.#D = null, this.#st(), this.#et(f), this.emit("seriesChange"), this.#f(), c;
   }
   /** Remove a series by ID and clean up its resources. */
   removeSeries(t) {
     const i = this.#t.findIndex((e) => e.id === t);
-    i >= 0 && (this.#t[i].renderer.dispose(), this.#t.splice(i, 1), this.#D = null, this.#q(), this.#i.markDirty(), this.emit("seriesChange"), this.#p());
+    if (i >= 0) {
+      const e = this.#Z();
+      this.#t[i].renderer.dispose(), this.#t.splice(i, 1), this.#D = null, this.#st(), this.#et(e), this.#i.markDirty(), this.emit("seriesChange"), this.#f();
+    }
   }
   // --- Markers (point annotations) -----------------------------------------
   /**
@@ -347,24 +377,24 @@ class ci extends ft {
    * appear in series queries.
    */
   addMarker(t) {
-    const i = `marker_${++Rt}`;
-    return this.#u.push(this.#ft(i, t)), this.#h.markDirty(), i;
+    const i = `marker_${++Yt}`;
+    return this.#u.push(this.#kt(i, t)), this.#o.markDirty(), i;
   }
   /** Replace a marker's config in place. No-op when the id is unknown. */
   updateMarker(t, i) {
     const e = this.#u.findIndex((s) => s.id === t);
-    e !== -1 && (this.#u[e] = this.#ft(t, i), this.#h.markDirty());
+    e !== -1 && (this.#u[e] = this.#kt(t, i), this.#o.markDirty());
   }
   /** Remove a marker by id. No-op when the id is unknown. */
   removeMarker(t) {
     const i = this.#u.findIndex((e) => e.id === t);
-    i !== -1 && (this.#u.splice(i, 1), this.#h.markDirty());
+    i !== -1 && (this.#u.splice(i, 1), this.#o.markDirty());
   }
   /** Read-only snapshot of the registered markers (normalized). Mutate via add / update / removeMarker. */
   getMarkers() {
     return this.#u;
   }
-  #ft(t, i) {
+  #kt(t, i) {
     return {
       id: t,
       time: x(i.time),
@@ -377,14 +407,14 @@ class ci extends ft {
     };
   }
   /** Resolve a marker's Y value: explicit `value`, else snapped to its series at `time`. Null when neither resolves. */
-  #Rt(t) {
+  #Yt(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;
+    return i ? X(i) : null;
   }
   /** Resolve a marker's color: explicit `color`, else the series color, else the theme line color. */
-  #Ct(t) {
+  #Xt(t) {
     if (t.color !== void 0) return t.color;
     if (t.seriesId !== void 0) {
       const i = this.getSeriesColor(t.seriesId);
@@ -392,16 +422,16 @@ class ci extends ft {
     }
     return this.#n.line.color;
   }
-  #It(t, i, e) {
+  #Zt(t, i, e) {
     if (this.#u.length === 0) return;
-    const s = performance.now() / ($ * 2 * Math.PI) % 1, r = this.#j();
+    const s = performance.now() / (J * 2 * Math.PI) % 1, r = this.#it();
     for (const n of this.#u) {
-      const a = this.#Rt(n);
+      const a = this.#Yt(n);
       if (a === null) continue;
-      const h = this.#yt(r, n.time);
-      if (h <= 0) continue;
+      const o = this.#Lt(r, n.time);
+      if (o <= 0) continue;
       const l = t.context.globalAlpha;
-      h < 1 && (t.context.globalAlpha = l * h), ct({
+      o < 1 && (t.context.globalAlpha = l * o), xt({
         scope: t,
         timeScale: this.timeScale,
         yScale: this.yScale,
@@ -409,7 +439,7 @@ class ci extends ft {
         marker: {
           time: n.time,
           value: a,
-          color: this.#Ct(n),
+          color: this.#Xt(n),
           shape: n.shape,
           pulse: n.pulse,
           label: n.label
@@ -417,7 +447,7 @@ class ci extends ft {
         phase: s,
         plotWidth: i,
         plotHeight: e
-      }), h < 1 && (t.context.globalAlpha = l);
+      }), o < 1 && (t.context.globalAlpha = l);
     }
   }
   // --- Time regions (shaded bands) -----------------------------------------
@@ -433,13 +463,13 @@ class ci extends ft {
    * legend.
    */
   addRegion(t) {
-    const i = `region_${++Ct}`;
-    return this.#x.push(this.#gt(i, t)), this.#i.markDirty(), i;
+    const i = `region_${++Xt}`;
+    return this.#x.push(this.#At(i, t)), this.#i.markDirty(), i;
   }
   /** Replace a region's config in place. No-op when the id is unknown. */
   updateRegion(t, i) {
     const e = this.#x.findIndex((s) => s.id === t);
-    e !== -1 && (this.#x[e] = this.#gt(t, i), this.#i.markDirty());
+    e !== -1 && (this.#x[e] = this.#At(t, i), this.#i.markDirty());
   }
   /** Remove a region by id. No-op when the id is unknown. */
   removeRegion(t) {
@@ -450,7 +480,7 @@ class ci extends ft {
   getRegions() {
     return this.#x;
   }
-  #gt(t, i) {
+  #At(t, i) {
     const { to: e } = i, s = e === void 0 || e === "now" ? null : x(e);
     return {
       id: t,
@@ -461,11 +491,11 @@ class ci extends ft {
       label: i.label
     };
   }
-  #Pt(t, i, e) {
+  #_t(t, i, e) {
     if (this.#x.length !== 0)
       for (const s of this.#x) {
-        const { color: r, fill: n } = mt(s, this.#n);
-        ut({
+        const { color: r, fill: n } = kt(s, this.#n);
+        At({
           scope: t,
           timeScale: this.timeScale,
           theme: this.#n,
@@ -487,24 +517,24 @@ class ci extends ft {
    * legend.
    */
   addLine(t) {
-    const i = `line_${++It}`;
-    return this.#y.push(this.#pt(i, t)), this.#h.markDirty(), i;
+    const i = `line_${++Zt}`;
+    return this.#y.push(this.#wt(i, t)), this.#o.markDirty(), i;
   }
   /** Replace a reference line's config in place. No-op when the id is unknown. */
   updateLine(t, i) {
     const e = this.#y.findIndex((s) => s.id === t);
-    e !== -1 && (this.#y[e] = this.#pt(t, i), this.#h.markDirty());
+    e !== -1 && (this.#y[e] = this.#wt(t, i), this.#o.markDirty());
   }
   /** Remove a reference line by id. No-op when the id is unknown. */
   removeLine(t) {
     const i = this.#y.findIndex((e) => e.id === t);
-    i !== -1 && (this.#y.splice(i, 1), this.#h.markDirty());
+    i !== -1 && (this.#y.splice(i, 1), this.#o.markDirty());
   }
   /** Read-only snapshot of the registered reference lines (normalized). Mutate via add / update / removeLine. */
   getLines() {
     return this.#y;
   }
-  #pt(t, i) {
+  #wt(t, i) {
     const { time: e, value: s } = i, r = {
       id: t,
       color: i.color,
@@ -514,14 +544,14 @@ class ci extends ft {
     };
     return e !== void 0 ? { ...r, orientation: "vertical", coord: x(e) } : { ...r, orientation: "horizontal", coord: s ?? Number.NaN };
   }
-  #Ht(t, i, e) {
+  #Gt(t, i, e) {
     if (this.#y.length === 0) return;
-    const s = this.#j();
+    const s = this.#it();
     for (const r of this.#y) {
-      const n = s >= 1 ? 1 : r.orientation === "vertical" ? this.#yt(s, r.coord) : P(s);
+      const n = s >= 1 ? 1 : r.orientation === "vertical" ? this.#Lt(s, r.coord) : W(s);
       if (n <= 0) continue;
       const a = t.context.globalAlpha;
-      n < 1 && (t.context.globalAlpha = a * n), dt({
+      n < 1 && (t.context.globalAlpha = a * n), St({
         scope: t,
         timeScale: this.timeScale,
         yScale: this.yScale,
@@ -546,8 +576,15 @@ class ci extends ft {
    * underlying animator mutates between frames.
    */
   getAnimationState() {
-    return this.#s.getAnimationState();
+    return this.#Tt(this.#s.getAnimationState());
+  }
+  /** The engine animates Y in scale space (`axis.y.scale`'s forward); readers outside it get values. */
+  #Tt(t) {
+    const i = this.yScale.getTransform();
+    return i === null ? t : { ...t, yRange: pt(t.yRange, i) };
   }
+  /** `yScale.isPlottable`, bound once for the helpers that take a predicate. */
+  #Y = (t) => this.yScale.isPlottable(t);
   /**
    * Reveal-front position in `[0, 1]` of any in-flight initial-load intro.
    * With a `seriesId`, that series' own front; without, the minimum across
@@ -574,10 +611,10 @@ class ci extends ft {
    * 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.
    */
-  #j() {
-    if (this.#at) return 1;
+  #it() {
+    if (this.#ft) return 1;
     const t = this.getIntroFront();
-    return t < 1 ? (this.#nt = !0, t) : (this.#nt && (this.#at = !0), 1);
+    return t < 1 ? (this.#mt = !0, t) : (this.#mt && (this.#ft = !0), 1);
   }
   /**
    * Entrance alpha for an overlay pinned at `time`, given the intro reveal
@@ -585,10 +622,10 @@ class ci extends ft {
    * 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, i) {
+  #Lt(t, i) {
     if (t >= 1) return 1;
     const { from: e, to: s } = this.timeScale.getRange(), r = s - e, n = r > 0 ? (i - e) / r : 0;
-    return bt((t - n) / 0.12, 0, 1);
+    return Ct((t - n) / 0.12, 0, 1);
   }
   /**
    * Replace all data for a series.
@@ -601,7 +638,7 @@ class ci extends ft {
    */
   setSeriesData(t, i, e) {
     const s = this.#t.find((r) => r.id === t);
-    s && (this.#Q = !0, s.renderer.setData(i, e));
+    s && (this.#nt = !0, s.renderer.setData(i, e));
   }
   /** Append a new data point to the end of a series (real-time tick). */
   appendData(t, i, e) {
@@ -624,8 +661,8 @@ class ci extends ft {
   prependData(t, i, e) {
     const s = this.#t.find((n) => n.id === t);
     if (s === void 0 || s.renderer.prependPoints === void 0) return;
-    const r = this.#Z.left;
-    r !== null && s.renderer.setHistoryHandoff !== void 0 && performance.now() - r.at < Lt && (s.renderer.setHistoryHandoff(r.bars), this.#P.left = !0, this.#N.left = null, this.#Z.left = null, this.#h.markDirty()), s.renderer.prependPoints(i, e);
+    const r = this.#K.left;
+    r !== null && s.renderer.setHistoryHandoff !== void 0 && performance.now() - r.at < Ot && (s.renderer.setHistoryHandoff(r.bars), this.#z.left = !0, this.#$.left = null, this.#K.left = null, this.#o.markDirty()), s.renderer.prependPoints(i, e);
   }
   /** Update the last data point of a series in place (e.g. live candle update). */
   updateData(t, i, e) {
@@ -649,12 +686,13 @@ class ci extends ft {
   }
   /** Update visual options (color, width, etc.) for an existing series. */
   updateSeriesOptions(t, i) {
-    const e = this.#t.find((o) => o.id === t);
+    const e = this.#t.find((h) => h.id === t);
     if (!e) return;
-    const s = e.labels, r = e.renderer.getLayerColors().slice(), n = this.#m.overrides(e.renderer.kind);
+    "stacking" in i && M({ seriesId: t, stacking: i.stacking, isPlottable: this.#Y });
+    const s = e.labels, r = e.renderer.getLayerColors().slice(), n = this.#d.overrides(e.renderer.kind);
     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, m) => o !== a[m]), l = !N(s, e.labels);
-    (h || l) && this.#p();
+    const a = e.renderer.getLayerColors(), o = r.length !== a.length || r.some((h, d) => h !== a[d]), l = !_(s, e.labels);
+    (o || l) && this.#f();
   }
   /**
    * Batch multiple updates: suppress recomputes until `fn` returns. Exceptions
@@ -666,14 +704,14 @@ class ci extends ft {
       t();
     } finally {
       if (--this.#L <= 0) {
-        if (this.#L = 0, this.#_)
-          this.#_ = !1, this.#H = !1, this.onDataChanged();
-        else if (this.#H) {
-          this.#H = !1, this.#g = !0;
+        if (this.#L = 0, this.#j)
+          this.#j = !1, this.#V = !1, this.onDataChanged();
+        else if (this.#V) {
+          this.#V = !1, this.#g = !0;
           const i = performance.now();
-          this.#s.onAxisReconfig(i), this.#v(i), this.#i.markDirty();
+          this.#s.onSeriesVisibilityChanged(i), this.#b(i), this.#i.markDirty();
         }
-        this.#G && (this.#G = !1, this.emit("overlayChange"));
+        this.#J && (this.#J = !1, this.emit("overlayChange"));
       }
     }
   }
@@ -687,15 +725,15 @@ class ci extends ft {
   setSeriesVisible(t, i) {
     const e = this.#t.find((n) => n.id === t);
     if (!e || e.visible === i) return;
-    e.visible = i, this.#p(), this.#q();
-    const s = this.#m.toggleMs;
+    e.visible = i, this.#f(), this.#st();
+    const s = this.#d.toggleMs;
     if (e.renderer.setAlpha?.(i ? 1 : 0, s), this.#i.markDirty(), this.#L > 0) {
-      this.#H = !0;
+      this.#V = !0;
       return;
     }
     this.#g = !0;
     const r = performance.now();
-    this.#s.onSeriesVisibilityChanged(r), this.#v(r);
+    this.#s.onSeriesVisibilityChanged(r), this.#b(r);
   }
   /**
    * Whether streaming ticks slide the visible range to track the data tail.
@@ -705,7 +743,7 @@ class ci extends ft {
    * containing the tail.
    */
   getAutoScroll() {
-    return this.#f;
+    return this.#m;
   }
   isSeriesVisible(t) {
     return this.#t.find((i) => i.id === t)?.visible ?? !0;
@@ -723,15 +761,15 @@ class ci extends ft {
   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.#p();
-    const r = this.#m.toggleMs;
+    s.renderer.setLayerVisible(i, e), this.#f();
+    const r = this.#d.toggleMs;
     if (s.renderer.setLayerAlpha?.(i, e ? 1 : 0, r), this.#i.markDirty(), this.#L > 0) {
-      this.#H = !0;
+      this.#V = !0;
       return;
     }
     this.#g = !0;
     const n = performance.now();
-    this.#s.onSeriesVisibilityChanged(n), this.#v(n);
+    this.#s.onSeriesVisibilityChanged(n), this.#b(n);
   }
   isLayerVisible(t, i) {
     return this.#t.find((e) => e.id === t)?.renderer.isLayerVisible(i) ?? !0;
@@ -741,10 +779,10 @@ class ci extends ft {
     const { first: t, last: i } = this.getDataBounds();
     if (t === void 0 || i === void 0) return;
     const e = this.#a.size.media.width - this.yAxisWidth;
-    this.#W(t, i, e), this.#X({ xEase: !0 });
+    this.#O(t, i, e), this.#G({ xEase: !0 });
   }
   getVisibleRange() {
-    return this.#o.from === 0 && this.#o.to === 0 ? this.#s.getAnimationState().xRange : this.#o;
+    return this.#h.from === 0 && this.#h.to === 0 ? this.#s.getAnimationState().xRange : this.#h;
   }
   /**
    * Return the full span of registered data, or `null` before any data has
@@ -752,7 +790,7 @@ class ci extends ft {
    * tracking and is cheaper than recomputing from series stores.
    */
   getDataRange() {
-    return this.#A === null || this.#e === null ? null : { from: this.#A, to: this.#e };
+    return this.#w === null || this.#e === null ? null : { from: this.#w, to: this.#e };
   }
   /**
    * Imperatively set the visible time range. Three forms:
@@ -783,27 +821,27 @@ class ci extends ft {
       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.#r), l = this.#a.size.media.width - this.yAxisWidth;
-      this.#W(h, a, l), this.#X();
+      const o = Math.max(n, a - (t - 1) * this.#r), l = this.#a.size.media.width - this.yAxisWidth;
+      this.#O(o, a, l), this.#G();
       return;
     }
     if ("bars" in t) {
       if (!Number.isInteger(t.bars) || t.bars < 2) return;
       const n = x(t.from), a = n + t.bars * this.#r;
-      this.#f = this.#e !== null && this.#e >= n && this.#e <= a, this.#C({ from: n, to: a }, { emitChange: !0 }), this.#T = !0, this.#X();
+      this.#m = this.#e !== null && this.#e >= n && this.#e <= a, this.#C({ from: n, to: a }, { emitChange: !0 }), this.#M = !0, this.#G();
       return;
     }
     const e = x(t.from), s = x(t.to);
-    this.#f = this.#e !== null && this.#e >= e && this.#e <= s, this.#T = !1;
+    this.#m = this.#e !== null && this.#e >= e && this.#e <= s, this.#M = !1;
     const r = this.#C({ from: e, to: s }, { emitChange: !0 });
     if (i?.gesture) {
-      r && this.#Bt();
+      r && this.#Qt();
       return;
     }
-    this.#X();
+    this.#G();
   }
   getYRange() {
-    return this.#z;
+    return this.#B;
   }
   getCrosshairPosition() {
     return this.#c;
@@ -844,36 +882,28 @@ class ci extends ft {
   setCrosshair(t) {
     if (t === null) {
       if (this.#c === null) return;
-      this.#c = null, this.#h.markDirty(), this.emit("crosshairMove", null);
+      this.#c = null, this.#o.markDirty(), this.emit("crosshairMove", null);
       return;
     }
     const { time: i } = t;
     if (!Number.isFinite(i)) return;
     const e = this.#c;
     let s;
-    if (t.y !== void 0)
-      s = t.y;
-    else if (e !== null)
-      s = e.y;
-    else {
-      const a = this.#z;
-      s = (a.min + a.max) / 2;
-    }
-    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.#$ = "time", this.#c = { mediaX: r, mediaY: n, time: i, y: s }, this.#h.markDirty(), this.emit("crosshairMove", this.#c);
+    if (t.y !== void 0 ? s = t.y : e !== null ? s = e.y : s = this.yScale.yToValue(this.yScale.getMediaHeight() / 2), !Number.isFinite(s) || e !== null && e.time === i && e.y === s) return;
+    const r = this.plotLeft + this.timeScale.timeToX(i), n = this.yScale.valueToY(s);
+    this.#q = "time", this.#c = { mediaX: r, mediaY: n, time: i, y: s }, this.#o.markDirty(), this.emit("crosshairMove", this.#c);
   }
   /** Get the last visible value and whether the absolute last point is on screen. */
   getLastValue(t) {
-    return J(t, this.#t, this.#s.getAnimationState().xRange);
+    return at(t, this.#t, this.#s.getAnimationState().xRange);
   }
   /** Get the second-to-last value, useful for computing change. */
   getPreviousClose(t) {
-    return Q(t, this.#t);
+    return ot(t, this.#t);
   }
   getLastData(t) {
     const i = this.#t.find((e) => e.id === t);
-    return !i || !k(i.renderer) ? null : i.renderer.getLastDataPoint();
+    return !i || !b(i.renderer) ? null : i.renderer.getLastDataPoint();
   }
   /** Find the data point closest to the given timestamp within one data interval. */
   getDataAtTime(t, i) {
@@ -899,12 +929,30 @@ class ci extends ft {
    * has no meaningful x/y coordinate system, so the dashed hairlines would
    * just be visual noise.
    */
-  #vt() {
+  #Mt() {
     for (const t of this.#t)
-      if (t.visible && k(t.renderer))
+      if (t.visible && b(t.renderer))
         return !0;
     return !1;
   }
+  /**
+   * True when series exist and none has a time axis (pie, heatmap): those
+   * renderers lay out against the whole canvas, so there are no axis gutters
+   * to reserve and nothing slides under an axis column. Reads registration,
+   * not visibility — a legend toggle must not shift the layout.
+   */
+  #X() {
+    return this.#t.length === 0 ? !1 : this.#t.every((t) => !b(t.renderer));
+  }
+  #Z() {
+    return { yAxisWidth: this.yAxisWidth, xAxisHeight: this.xAxisHeight, yAxisPosition: this.yAxisPosition };
+  }
+  /** Resync the scales after the axis gutters moved, and let DOM axis / label
+   *  components re-read the layout, as they do after a resize. */
+  #et(t) {
+    const i = this.#Z();
+    (i.yAxisWidth !== t.yAxisWidth || i.xAxisHeight !== t.xAxisHeight || i.yAxisPosition !== t.yAxisPosition) && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
+  }
   /**
    * Whether pan/zoom gestures currently apply — true when any visible series
    * has a time axis. Part of the {@link PanZoomTarget} surface: on a
@@ -912,7 +960,7 @@ class ci extends ft {
    * wheel and touch events, so the page scrolls normally under the cursor.
    */
   canPanZoom() {
-    return this.#vt();
+    return this.#Mt();
   }
   /**
    * Push the current pan/zoom capability into the interaction layer (canvas
@@ -921,8 +969,8 @@ class ci extends ft {
    * every mutation that can flip {@link canPanZoom}: series add/remove and
    * series visibility.
    */
-  #q() {
-    this.#M?.syncPanZoomMode();
+  #st() {
+    this.#P?.syncPanZoomMode();
   }
   /**
    * Filter `getSeriesIds()` by renderer type. A concrete kind (`'pie'`,
@@ -938,19 +986,19 @@ class ci extends ft {
   getSeriesIdsByType(t, i) {
     const e = i?.visibleOnly === !0, s = i?.singleLayerOnly === !0, r = [];
     for (const n of this.#t) {
-      if (!(t === "time" ? k(n.renderer) : n.renderer.kind === t)) continue;
+      if (!(t === "time" ? b(n.renderer) : n.renderer.kind === t)) continue;
       const a = n.renderer.getLayerCount();
       if (!(s && a > 1)) {
         if (e) {
           if (!n.visible) continue;
           if (a > 1) {
-            let h = !1;
+            let o = !1;
             for (let l = 0; l < a; l++)
               if (n.renderer.isLayerVisible(l)) {
-                h = !0;
+                o = !0;
                 break;
               }
-            if (!h) continue;
+            if (!o) continue;
           }
         }
         r.push(n.id);
@@ -965,7 +1013,7 @@ class ci extends ft {
    * Returns `null` for unknown ids or empty series.
    */
   getStackedLastValue(t) {
-    return tt(t, this.#t, this.#s.getAnimationState().xRange);
+    return ht(t, this.#t, this.#s.getAnimationState().xRange);
   }
   /**
    * Stacked value at an arbitrary `time` — the cumulative stack top at that
@@ -980,7 +1028,7 @@ class ci extends ft {
     const s = e.renderer.getStackedValueAtTime?.(i, this.#r);
     if (s != null) return s;
     const r = e.renderer.getDataAtTime?.(i, this.#r);
-    return r ? "close" in r ? r.close : r.value : null;
+    return !r || zt(r) ? null : X(r);
   }
   /**
    * Per-layer last snapshots with each layer's own `time`. Returns `null`
@@ -1022,7 +1070,7 @@ class ci extends ft {
    */
   setSeriesLabels(t, i) {
     const e = this.#t.find((s) => s.id === t);
-    !e || N(e.labels, i) || (e.labels = i, this.#p());
+    !e || _(e.labels, i) || (e.labels = i, this.#f());
   }
   /**
    * Set the per-layer color overrides carried in `data` (sparse — `undefined`
@@ -1033,7 +1081,7 @@ class ci extends ft {
    */
   setLayerColors(t, i) {
     const e = this.#t.find((s) => s.id === t);
-    !e || Pt(e.colorOverrides, i) || (e.colorOverrides = i, e.renderer.setColorOverrides?.(i), this.#i.markDirty(), this.#p());
+    !e || _t(e.colorOverrides, i) || (e.colorOverrides = i, e.renderer.setColorOverrides?.(i), this.#i.markDirty(), this.#f());
   }
   /** Get per-layer colors for a series. Returns null for single-layer non-bar/line series. */
   getSeriesLayers(t) {
@@ -1058,31 +1106,34 @@ class ci extends ft {
     this.#n = t;
     for (const e of this.#t)
       e.renderer.applyTheme(t, i);
-    this.#i.markDirty(), this.#p();
+    this.#i.markDirty(), this.#f();
   }
   getTheme() {
     return this.#n;
   }
   /** BCP 47 locale applied to the built-in time-axis / tooltip / crosshair formatting. */
   setLocale(t) {
-    this.timeScale.setLocale(t), this.#p();
+    this.timeScale.setLocale(t), this.#f();
   }
   getLocale() {
     return this.timeScale.getLocale();
   }
   /** IANA timezone applied to the same built-in date-time formatting. */
   setTimeZone(t) {
-    this.timeScale.setTimeZone(t), this.#p();
+    this.timeScale.setTimeZone(t), this.#f();
   }
   getTimeZone() {
     return this.timeScale.getTimeZone();
   }
   /** Update axis configuration and re-render. */
   setAxis(t) {
-    const i = this.yAxisWidth, e = this.xAxisHeight;
-    this.#B = t, this.#d = { min: t.y?.min, max: t.y?.max }, this.#g = !0;
-    const s = performance.now();
-    this.#s.onAxisReconfig(s), this.#v(s), (this.yAxisWidth !== i || this.xAxisHeight !== e) && this.syncScales(), this.#i.markDirty();
+    const i = t.y?.scale ?? null, e = (a) => Pt(i, a);
+    for (const a of this.#t)
+      b(a.renderer) && M({ seriesId: a.id, stacking: a.renderer.stacking, isPlottable: e });
+    const s = this.#Z(), r = i !== this.yScale.getTransform();
+    this.#T = t, this.#p = { min: t.y?.min, max: t.y?.max }, N({ y: t.y, isPlottable: e });
+    const n = performance.now();
+    r && (this.yScale.setTransform(i), this.yScale.tickTracker.reset(), this.#ht() === null && this.#s.snap({ y: { min: 0, max: 0 } }, n)), this.#g = !0, this.#s.onAxisReconfig(n), this.#b(n), this.#et(s), this.#i.markDirty();
   }
   /**
    * Apply label-density knobs driven by `<YAxis labelCount=… minLabelSpacing=…>`
@@ -1106,8 +1157,9 @@ class ci extends ft {
   getLayout() {
     const t = this.#a.size.media, i = this.yAxisWidth, e = this.xAxisHeight;
     return {
-      chartArea: { x: 0, y: 0, width: t.width - i, height: t.height - e },
+      chartArea: { x: this.plotLeft, y: 0, width: t.width - i, height: t.height - e },
       yAxisWidth: i,
+      yAxisPosition: this.yAxisPosition,
       xAxisHeight: e
     };
   }
@@ -1124,19 +1176,19 @@ class ci extends ft {
    */
   setPadding(t) {
     const i = this.#l;
-    this.#l = z(t);
-    const e = this.#l, s = !V(i.left, e.left) || !V(i.right, e.right), r = i.top !== e.top || i.bottom !== e.bottom;
+    this.#l = F(t);
+    const e = this.#l, s = !$(i.left, e.left) || !$(i.right, e.right), r = i.top !== e.top || i.bottom !== e.bottom;
     if (s) {
       const { first: n, last: a } = this.getDataBounds();
       if (n !== void 0 && a !== void 0) {
-        const h = this.#a.size.media.width - this.yAxisWidth;
-        this.#W(n, a, h);
+        const o = this.#a.size.media.width - this.yAxisWidth;
+        this.#O(n, a, o);
       }
     }
     if (s || r) {
       this.#g = !0;
       const n = performance.now();
-      this.#s.onAxisReconfig(n), this.#v(n);
+      this.#s.onAxisReconfig(n), this.#b(n);
     }
     this.syncScales(), this.#i.markDirty(), r && this.emit("viewportChange");
   }
@@ -1152,8 +1204,14 @@ class ci extends ft {
    * the next render frame.
    */
   setFade(t) {
-    const i = H(t), e = this.#k;
-    i.top === e.top && i.right === e.right && i.left === e.left || (this.#k = i, this.#i.markDirty());
+    const i = O(t), e = this.#A;
+    i.top === e.top && i.right === e.right && i.left === e.left || (this.#A = i, 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 i = Number.isFinite(t) && t > 0 ? t : 0;
+    i !== this.#U && (this.#U = i, this.#f());
   }
   /**
    * Set the visual state for one side of the chart. Typically called in
@@ -1165,23 +1223,23 @@ class ci extends ft {
    * symmetry and currently renders identically to `idle`.
    */
   setEdgeState(t, i) {
-    if (this.#b[t] === i) return;
-    const e = this.#b[t] === "loading", s = this.#P[t];
-    this.#P[t] = !1, this.#N[t] = e && !s && (i === "idle" || i === "has-more") ? performance.now() : null, this.#b[t] = i, this.#h.markDirty();
+    if (this.#S[t] === i) return;
+    const e = this.#S[t] === "loading", s = this.#z[t];
+    this.#z[t] = !1, this.#$[t] = e && !s && (i === "idle" || i === "has-more") ? performance.now() : null, this.#S[t] = i, this.#o.markDirty();
   }
   /** Read the current host-declared state for a given edge. */
   getEdgeState(t) {
-    return this.#b[t];
+    return this.#S[t];
   }
   /**
    * Alpha for a side's `loading` exit fade, or `null` when none is in
    * flight. Self-cleaning: an elapsed fade clears its start stamp.
    */
-  #xt(t) {
-    const i = this.#N[t];
+  #Pt(t) {
+    const i = this.#$[t];
     if (i === null) return null;
-    const e = (performance.now() - i) / At;
-    return e >= 1 ? (this.#N[t] = null, null) : 1 - P(Math.max(0, e));
+    const e = (performance.now() - i) / Wt;
+    return e >= 1 ? (this.#$[t] = null, null) : 1 - W(Math.max(0, e));
   }
   /**
    * Swap the painter used for a side's `loading` spinner — the same
@@ -1190,7 +1248,7 @@ class ci extends ft {
    * immediately if that side is currently in the `loading` state.
    */
   setEdgeIndicator(t, i) {
-    this.#ct[t] = i, this.#b[t] === "loading" && this.#h.markDirty();
+    this.#vt[t] = i, this.#S[t] === "loading" && this.#o.markDirty();
   }
   /**
    * Resolve the boundary point's Y position and series kind on the primary
@@ -1200,14 +1258,14 @@ class ci extends ft {
    * `open` (the value immediately preceding the boundary); `right` from the
    * last visible candle's `close`.
    */
-  #zt(t, i) {
+  #Ut(t, i) {
     const e = this.getSeriesIdsByType("time", { visibleOnly: !0, singleLayerOnly: !0 })[0] ?? this.getSeriesIdsByType("time", { visibleOnly: !0 })[0];
     if (!e) return null;
     const s = this.getDataAtTime(e, i);
     if (!s) return null;
     const r = this.#t.find((n) => n.id === e);
     return r ? {
-      valueY: this.yScale.valueToY(U(t, s)),
+      valueY: this.yScale.valueToY(et(t, s)),
       seriesKind: r.renderer.kind
     } : null;
   }
@@ -1217,7 +1275,7 @@ class ci extends ft {
    * placeholder shapes to match the real bars that will render once data
    * lands. `null` when the viewport has no meaningful span yet.
    */
-  #Vt() {
+  #qt() {
     const t = this.timeScale.barWidthMedia(this.#r);
     return Number.isFinite(t) && t > 0 ? t : null;
   }
@@ -1236,7 +1294,7 @@ class ci extends ft {
    * probed, not kind-gated: a kind check here silently kills hover for the
    * next spatial renderer.
    */
-  #J(t) {
+  #rt(t) {
     const i = this.#a.size, e = this.#l, s = {
       top: e.top * i.verticalPixelRatio,
       bottom: e.bottom * i.verticalPixelRatio
@@ -1244,12 +1302,12 @@ class ci extends ft {
     let r = !1, n = null;
     for (const a of this.#t) {
       if (!a.renderer.hitTest || !a.renderer.setHoverIndex) continue;
-      let h = -1;
+      let o = -1;
       if (t) {
-        const l = t.mediaX * i.horizontalPixelRatio, o = t.mediaY * i.verticalPixelRatio;
-        h = a.renderer.hitTest(l, o, i.bitmap.width, i.bitmap.height, s);
+        const l = (t.mediaX - this.plotLeft) * i.horizontalPixelRatio, h = t.mediaY * i.verticalPixelRatio;
+        o = a.renderer.hitTest(l, h, i.bitmap.width, i.bitmap.height, s);
       }
-      a.renderer.setHoverIndex(h) && (r = !0), h >= 0 && !n && (n = { seriesId: a.id, index: h, 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.#n) ?? null });
     }
     r && (this.#i.markDirty(), this.emit("seriesHover", n));
   }
@@ -1260,15 +1318,15 @@ class ci extends ft {
    * Returns the first spatial series (pie, heatmap, or a custom spatial kind)
    * whose `hitTest` claims the position, or `null` if none does.
    */
-  #bt(t) {
+  #Dt(t) {
     const i = this.#a.size, e = this.#l, s = {
       top: e.top * i.verticalPixelRatio,
       bottom: e.bottom * i.verticalPixelRatio
-    }, r = t.mediaX * i.horizontalPixelRatio, n = t.mediaY * i.verticalPixelRatio;
+    }, r = (t.mediaX - this.plotLeft) * i.horizontalPixelRatio, n = t.mediaY * i.verticalPixelRatio;
     for (const a of this.#t) {
       if (!a.renderer.hitTest) continue;
-      const h = a.renderer.hitTest(r, n, i.bitmap.width, i.bitmap.height, s);
-      if (h >= 0) return { seriesId: a.id, index: h };
+      const o = a.renderer.hitTest(r, n, i.bitmap.width, i.bitmap.height, s);
+      if (o >= 0) return { seriesId: a.id, index: o };
     }
     return null;
   }
@@ -1292,40 +1350,40 @@ class ci extends ft {
    * viewport didn't move, the re-derived values are bit-identical and the
    * method exits without emitting.
    */
-  #Wt() {
+  #Kt() {
     const t = this.#c;
     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.#$ === "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 };
+    let o;
+    if (this.#q === "pointer") {
+      const l = this.timeScale.xToTime(t.mediaX - this.plotLeft), h = this.yScale.yToValue(t.mediaY);
+      if (!Number.isFinite(l) || !Number.isFinite(h) || Math.abs(l - t.time) <= r && Math.abs(h - t.y) <= n) return;
+      o = { mediaX: t.mediaX, mediaY: t.mediaY, time: l, y: h };
     } else {
       if (t.time < i || t.time > e) {
-        this.#c = null, this.#h.markDirty(), this.emit("crosshairMove", null), this.#J(null);
+        this.#c = null, this.#o.markDirty(), this.emit("crosshairMove", null), this.#rt(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 };
+      const l = this.plotLeft + this.timeScale.timeToX(t.time), h = this.yScale.valueToY(t.y);
+      if (!Number.isFinite(l) || !Number.isFinite(h) || Math.abs(l - t.mediaX) <= a && Math.abs(h - t.mediaY) <= a) return;
+      o = { mediaX: l, mediaY: h, time: t.time, y: t.y };
     }
-    this.#c = h, this.#h.markDirty(), this.emit("crosshairMove", h), this.#J(h);
+    this.#c = o, this.#o.markDirty(), this.emit("crosshairMove", o), this.#rt(o);
   }
   /** 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.#u = [], this.#x = [], this.#y = [], this.#D = null, this.#i.destroy(), this.#h.destroy(), this.#M?.destroy(), this.#a.destroy(), this.#K?.destroy(), this.#K = null, this.#U && this.#S?.destroy(), this.#S = null, this.#U = !1, this.removeAllListeners();
+    this.#t = [], this.#u = [], this.#x = [], this.#y = [], this.#D = null, this.#i.destroy(), this.#o.destroy(), this.#P?.destroy(), this.#a.destroy(), this.#tt?.destroy(), this.#tt = null, this.#Q && this.#k?.destroy(), this.#k = null, this.#Q = !1, this.removeAllListeners();
   }
   /** The attached performance monitor, or `null` when instrumentation is disabled. */
   getPerfMonitor() {
-    return this.#S;
+    return this.#k;
   }
   /** Compute the earliest and latest timestamps across all series. */
   getDataBounds() {
     let t, i;
     for (const e of this.#t) {
-      if (!e.visible || !k(e.renderer)) continue;
+      if (!e.visible || !b(e.renderer)) continue;
       const s = e.renderer.getTimeBounds();
       s !== null && ((t === void 0 || s.first < t) && (t = s.first), (i === void 0 || s.last > i) && (i = s.last));
     }
@@ -1334,28 +1392,28 @@ class ci extends ft {
   /** 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. */
-  #Q = !1;
+  #nt = !1;
   onDataChanged() {
     if (this.#L > 0) {
-      this.#_ = !0;
+      this.#j = !0;
       return;
     }
     this.updateDataInterval();
     const { first: t, last: i } = this.getDataBounds();
-    t !== void 0 && (this.#A = t), i !== void 0 && (this.#O = this.#e, this.#e = i);
-    const e = this.#Q;
-    this.#Q = !1;
+    t !== void 0 && (this.#w = t), i !== void 0 && (this.#N = this.#e, this.#e = i);
+    const e = this.#nt;
+    this.#nt = !1;
     const s = !this.#g && t !== void 0;
-    e && (this.yScale.tickTracker.reset(), this.timeScale.tickTracker.reset()), this.#mt = e;
+    e && (this.yScale.tickTracker.reset(), this.timeScale.tickTracker.reset()), this.#xt = e;
     const r = performance.now();
-    e || s ? (this.#R.seed(r), this.#s.onDataReplaced(r)) : this.#s.onPointAppended(r), this.#s.lastXTarget !== null && (this.#V = !0), t !== void 0 && (this.#g = !0), this.#v(r), this.syncScales(), s ? this.#st() : this.#i.markDirty(), this.emit("dataUpdate"), this.#p();
+    e || s ? (this.#R.seed(r), this.#s.onDataReplaced(r)) : this.#s.onPointAppended(r), this.#s.lastXTarget !== null && (this.#W = !0), t !== void 0 && (this.#g = !0), this.#b(r), this.syncScales(), s ? this.#dt() : this.#i.markDirty(), this.emit("dataUpdate"), this.#f();
   }
   updateDataInterval() {
     for (const t of this.#t) {
-      if (!k(t.renderer)) continue;
+      if (!b(t.renderer)) continue;
       const i = t.renderer.sampleTimes(20);
       if (i.length >= 2) {
-        this.#r = wt(i);
+        this.#r = Vt(i);
         break;
       }
     }
@@ -1371,36 +1429,52 @@ class ci extends ft {
    *  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. */
-  #V = !1;
+  #W = !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.
    */
-  #Y;
+  #_;
   /** 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. */
-  #tt = Number.NaN;
-  #it = 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.
+  #at = Number.NaN;
+  #ot = Number.NaN;
+  /** Dev warning for values the Y scale can't place — fires once per chart. */
+  #Rt = !1;
+  /**
+   * Sample the visible data window and return the resolved Y bounds in scale
+   * space (see {@link resolveYTarget}), or `null` when no series has data
+   * inside the X destination range.
    * Sampling runs against `logicalRange` (the X target, not the animating
    * current), so Y stays on a stable target while X eases — both dimensions
    * converge together. Clears {@link #yInited} on empty so the next emit
    * with valid data lands as an instant snap.
    */
-  #St(t) {
-    const i = t ?? this.#o, e = this.#d.min !== void 0 && this.#d.min !== "auto" && typeof this.#d.min != "number" || this.#d.max !== void 0 && this.#d.max !== "auto" && typeof this.#d.max != "number" ? [] : null, s = ht(i, this.#t, e);
-    if (s === null)
-      return this.#g = !1, null;
-    const r = F(this.#d.min, s.min, s.max, e ?? [], "min"), n = F(this.#d.max, s.max, s.min, e ?? [], "max");
-    return { min: r, max: n };
+  #ht(t) {
+    const i = t ?? this.#h, e = this.#p.min !== void 0 && this.#p.min !== "auto" && typeof this.#p.min != "number" || this.#p.max !== void 0 && this.#p.max !== "auto" && typeof this.#p.max != "number" ? [] : null, s = this.yScale.getTransform(), r = s === null ? void 0 : this.#Y;
+    r && this.#jt(i);
+    const n = yt({ targetVisible: i, series: this.#t, allValues: e, plottable: r });
+    return n === null ? (this.#g = !1, null) : vt({ raw: n, bounds: this.#p, allValues: e ?? [], transform: s });
+  }
+  /** Dev-only sweep behind {@link warnUnplottableValues}; stops once it has warned. */
+  #jt(t) {
+    if (!(this.#Rt || process.env.NODE_ENV === "production"))
+      for (const i of this.#t) {
+        if (!i.visible || !b(i.renderer)) continue;
+        const e = i.renderer.getValueRange(t.from, t.to);
+        if (e === null) continue;
+        const s = (i.renderer.stacking === "normal" ? e.min < 0 && !this.yScale.isPlottable(e.min) : !this.yScale.isPlottable(e.min)) ? e.min : this.yScale.isPlottable(e.max) ? null : e.max;
+        if (s !== null) {
+          this.#Rt = !0, mt({ seriesId: i.id, value: s });
+          return;
+        }
+      }
   }
   /**
    * Engine pull-on-demand X target. Called by the engine's `computeXTarget`
@@ -1420,29 +1494,29 @@ class ci extends ft {
    * - **autoscroll off** → `null` (no X retarget; user has panned away
    *   from the tail).
    */
-  #Ft() {
-    if (this.#A === null || this.#e === null) return null;
-    const { from: t, to: i } = this.#o, e = t === 0 && i === 0, s = this.#a.size.media.width - this.yAxisWidth;
+  #Jt() {
+    if (this.#w === null || this.#e === null) return null;
+    const { from: t, to: i } = this.#h, e = t === 0 && i === 0, s = this.#a.size.media.width - this.yAxisWidth;
     if (e) {
-      if (this.#W(this.#A, this.#e, s), this.#Y !== void 0 && (this.setVisibleRange(this.#Y), this.#Y = void 0, !this.#f && this.#e !== null)) {
-        const { to: n } = this.#o;
-        this.#e >= n && this.#e - n <= this.#r * 1.5 && (this.#f = !0);
+      if (this.#O(this.#w, this.#e, s), this.#_ !== void 0 && (this.setVisibleRange(this.#_), this.#_ = void 0, !this.#m && this.#e !== null)) {
+        const { to: n } = this.#h;
+        this.#e >= n && this.#e - n <= this.#r * 1.5 && (this.#m = !0);
       }
-      return this.#o;
+      return this.#h;
     }
-    if (!this.#f) return null;
-    if (this.#mt)
-      return this.#W(this.#A, this.#e, s), this.#o;
-    const r = at({
-      currentLogical: this.#o,
+    if (!this.#m) return null;
+    if (this.#xt)
+      return this.#O(this.#w, this.#e, s), this.#h;
+    const r = gt({
+      currentLogical: this.#h,
       lastTime: this.#e,
-      prevDataEnd: this.#O,
+      prevDataEnd: this.#N,
       dataInterval: this.#r,
       paddingRight: this.#l.right,
       chartWidth: s,
-      holdUntilFilled: this.#T
+      holdUntilFilled: this.#M
     });
-    return r.releaseHold && (this.#T = !1), r.reengageAutoScroll && (this.#f = !0), r.newLogical === null ? null : (this.#R.observe(performance.now()), this.#s.setXSettleMs(this.#R.pickSettleMs(this.#m.axis.x.settleMs)), this.#C(r.newLogical, { emitChange: !1, skipValidation: !0 }), this.#O = this.#e, r.newLogical);
+    return r.releaseHold && (this.#M = !1), r.reengageAutoScroll && (this.#m = !0), r.newLogical === null ? null : (this.#R.observe(performance.now()), this.#s.setXSettleMs(this.#R.pickSettleMs(this.#d.axis.x.settleMs)), this.#C(r.newLogical, { emitChange: !1, skipValidation: !0 }), this.#N = this.#e, r.newLogical);
   }
   /**
    * Fit the viewport's logical X range around a data span. Mirrors the
@@ -1450,16 +1524,16 @@ class ci extends ft {
    * forces autoscroll on (data tail is in the new window by construction),
    * commits the new range via `viewport.setRange` (which emits `change`).
    */
-  #W(t, i, e) {
-    const s = this.#l, r = q({
+  #O(t, i, e) {
+    const s = this.#l, r = nt({
       firstTime: t,
       lastTime: i,
       dataInterval: this.#r,
-      maxVisibleBars: this.#ut,
+      maxVisibleBars: this.#St,
       chartWidth: e,
       padding: { left: s.left, right: s.right }
     });
-    this.#T = !1, this.#f = !0, this.#C(r, { emitChange: !0 });
+    this.#M = !1, this.#m = !0, this.#C(r, { emitChange: !0 });
   }
   /**
    * Commit a programmatic zoom — `fitContent` or `setVisibleRange`. Reads
@@ -1475,15 +1549,15 @@ class ci extends ft {
    *   passes `xEase: true` so X eases instead — viewport and axis converge
    *   on the same frame.
    */
-  #X(t) {
-    const i = this.#o;
+  #G(t) {
+    const i = this.#h;
     if (i.to <= i.from) return;
     const e = performance.now();
-    if (!this.#V || !this.#g) {
-      this.#kt(e);
+    if (!this.#W || !this.#g) {
+      this.#Ct(e);
       return;
     }
-    this.#s.onProgrammaticZoom({ xTarget: i, xEase: t?.xEase }, e), this.#v(e);
+    this.#s.onProgrammaticZoom({ xTarget: i, xEase: t?.xEase }, e), this.#b(e);
   }
   /**
    * Commit the current logical X to the engine on the *gesture* profile:
@@ -1497,15 +1571,15 @@ class ci extends ft {
    * instead of lagging on the long sticky contract. First paint still snaps
    * (same as the programmatic path) so synchronous readers see final values.
    */
-  #Bt() {
-    const t = this.#o;
+  #Qt() {
+    const t = this.#h;
     if (t.to <= t.from) return;
     const i = performance.now();
-    if (!this.#V || !this.#g) {
-      this.#kt(i);
+    if (!this.#W || !this.#g) {
+      this.#Ct(i);
       return;
     }
-    this.#s.onPanZoom({ xTarget: t, yAuto: !0 }, i), this.#v(i);
+    this.#s.onPanZoom({ xTarget: t, yAuto: !0 }, i), this.#b(i);
   }
   /**
    * First-paint snap: land both axes on the current logical X immediately
@@ -1514,9 +1588,9 @@ class ci extends ft {
    * commits — both must snap before the chart has painted once so a
    * synchronous `getYRange()` / `getVisibleRange()` read sees final values.
    */
-  #kt(t) {
-    const i = this.#o, e = this.#St(i);
-    this.#V = !0, e !== null && (this.#g = !0), this.#s.snap({ x: i, y: e ?? void 0 }, t), this.#v(t);
+  #Ct(t) {
+    const i = this.#h, e = this.#ht(i);
+    this.#W = !0, e !== null && (this.#g = !0), this.#s.snap({ x: i, y: e ?? void 0 }, t), this.#b(t);
   }
   /**
    * Validate and commit a new logical X range. Mirrors the old
@@ -1538,28 +1612,37 @@ class ci extends ft {
    */
   #C(t, i) {
     const { from: e, to: s } = t;
-    return !Number.isFinite(e) || !Number.isFinite(s) || s <= e || !i.skipValidation && (s - e) / this.#r < 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);
+    return !Number.isFinite(e) || !Number.isFinite(s) || s <= e || !i.skipValidation && (s - e) / this.#r < 2 || this.#h.from === e && this.#h.to === s ? !1 : (this.#h = { 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
-   * result in `#yRange`. Mirrors the old `Viewport.setYRange` contract:
+   * Apply pixel-padding to the engine's Y (scale space) and return it as
+   * values for `#yRange`. Mirrors the old `Viewport.setYRange` contract:
    * symmetric pad top / bottom from `#padding`, suppressed on the side
-   * that has an explicit (fixed) axis bound.
+   * that has an explicit (fixed) axis bound. Padding in scale space keeps
+   * the pixel gutters even on a log axis.
    */
-  #wt(t) {
-    const { min: i, max: e, chartHeight: s } = t, { min: r, max: n } = this.#Nt(), a = e - i, h = s > 0 ? this.#l.top / s * a : 0, l = s > 0 ? this.#l.bottom / s * a : 0;
-    return {
+  #It(t) {
+    const { min: i, max: e, chartHeight: s } = t, { min: r, max: n } = this.#ti(), a = e - i, o = s > 0 ? this.#l.top / s * a : 0, l = s > 0 ? this.#l.bottom / s * a : 0, h = {
       min: r ? i : i - l,
-      max: n ? e : e + h
+      max: n ? e : e + o
+    }, d = this.yScale.getTransform();
+    if (d === null) return h;
+    const m = d.inverse(h.min), c = d.inverse(h.max), f = this.yScale.isPlottable(m) && m <= d.inverse(i), g = this.yScale.isPlottable(c) && c >= d.inverse(e);
+    return {
+      min: f ? m : d.inverse(i),
+      max: g ? c : d.inverse(e)
     };
   }
   /** Which Y edges the user pinned — a pinned edge takes no padding. */
-  #Nt() {
+  #ti() {
     return {
-      min: this.#d.min !== void 0 && this.#d.min !== "auto",
-      max: this.#d.max !== void 0 && this.#d.max !== "auto"
+      min: this.#Ht(this.#p.min),
+      max: this.#Ht(this.#p.max)
     };
   }
+  #Ht(t) {
+    return t === void 0 || t === "auto" ? !1 : !(typeof t == "number" && !this.yScale.isPlottable(t));
+  }
   /**
    * Shift the visible time range by `timeDelta` ms. Hard-clamped so at
    * least one data point stays on screen — no rubber-band, no overshoot.
@@ -1571,17 +1654,17 @@ class ci extends ft {
    * programmatically.
    */
   pan(t, i = this.#E) {
-    i > 0 && (this.#E = i), this.#T = !1;
-    const e = st({
-      currentLogical: this.#o,
+    i > 0 && (this.#E = i), this.#M = !1;
+    const e = dt({
+      currentLogical: this.#h,
       timeDelta: t,
       chartWidth: i,
       dataInterval: this.#r,
       padding: { left: this.#l.left, right: this.#l.right },
-      dataStart: this.#A,
+      dataStart: this.#w,
       dataEnd: this.#e
     });
-    e.newLogical !== null && (this.#f = !e.autoScrollOff, this.#C(e.newLogical, { emitChange: !0 }), e.edgeReached !== null && (this.#ot[e.edgeReached.side] = e.edgeReached.boundaryTime, this.#lt?.(e.edgeReached)), this.#R.pause(), this.#At());
+    e.newLogical !== null && (this.#m = !e.autoScrollOff, this.#C(e.newLogical, { emitChange: !0 }), e.edgeReached !== null && (this.#pt[e.edgeReached.side] = e.edgeReached.boundaryTime, this.#yt?.(e.edgeReached)), this.#R.pause(), this.#zt());
   }
   /**
    * Zoom around a time anchor. `factor < 1` zooms in, `> 1` zooms out.
@@ -1599,36 +1682,36 @@ class ci extends ft {
    * sacrificed in follow-live mode — pan first to inspect history.
    */
   zoomAt(t, i, e = this.#E) {
-    e > 0 && (this.#E = e), this.#T = !1;
-    const s = rt({
-      currentLogical: this.#o,
+    e > 0 && (this.#E = e), this.#M = !1;
+    const s = ut({
+      currentLogical: this.#h,
       centerTime: t,
       factor: i,
       chartWidth: e,
       dataInterval: this.#r,
       padding: { left: this.#l.left, right: this.#l.right },
-      dataStart: this.#A,
+      dataStart: this.#w,
       dataEnd: this.#e
     });
     if (s.newLogical === null) return;
     let r = s.newLogical;
-    if (this.#f && this.#e !== null) {
-      const n = r.to - r.from, a = W(this.#l.right, n, this.#r, e), h = this.#e + a;
-      r = { from: h - n, to: h }, this.#O = this.#e;
+    if (this.#m && this.#e !== null) {
+      const n = r.to - r.from, a = B(this.#l.right, n, this.#r, e), o = this.#e + a;
+      r = { from: o - n, to: o }, this.#N = this.#e;
     }
-    this.#C(r, { emitChange: !0 }), this.#R.pause(), this.#At();
+    this.#C(r, { emitChange: !0 }), this.#R.pause(), this.#zt();
   }
   /**
    * 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`.
    */
-  #At() {
-    const t = this.#o;
+  #zt() {
+    const t = this.#h;
     if (t.to <= t.from) return;
-    this.#V = !0, this.#g = !0;
+    this.#W = !0, this.#g = !0;
     const i = performance.now();
-    this.#s.onPanZoom({ xTarget: t, yAuto: !0 }, i), this.#v(i);
+    this.#s.onPanZoom({ xTarget: t, yAuto: !0 }, i), this.#b(i);
   }
   /**
    * Tick the engine at the given wall clock and push the resolved X / Y
@@ -1643,11 +1726,11 @@ class ci extends ft {
    * `effectiveNow === startWall` and the prune step keeps zero-duration
    * events long enough for the slot processor to snap them.
    */
-  #v(t) {
+  #b(t) {
     const i = this.#s.tick(t), e = this.#a.size;
     if (e.media.width === 0 || e.media.height === 0) return;
     const s = e.media.height - this.xAxisHeight;
-    this.#z = this.#wt({ min: i.yRange.min, max: i.yRange.max, chartHeight: s }), this.#tt = i.yRange.min, this.#it = i.yRange.max, this.syncScales();
+    this.#B = this.#It({ min: i.yRange.min, max: i.yRange.max, chartHeight: s }), this.#at = i.yRange.min, this.#ot = i.yRange.max, this.syncScales();
   }
   /**
    * Lightweight scale sync: updates timeScale/yScale from current viewport state
@@ -1663,7 +1746,7 @@ class ci extends ft {
       i,
       t.horizontalPixelRatio,
       this.#r
-    ), this.yScale.update(this.#z, e, t.verticalPixelRatio);
+    ), this.yScale.update(this.#B, e, t.verticalPixelRatio);
   }
   /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
   renderMain(t) {
@@ -1671,80 +1754,74 @@ class ci extends ft {
     if (i.media.width === 0 || i.media.height === 0) return;
     const e = typeof t == "number" ? t : performance.now(), s = this.#s.tick(e);
     s.animating && this.#i.markDirty();
-    const r = s.yRange.min, n = s.yRange.max, a = r !== this.#tt || n !== this.#it;
+    const r = s.yRange.min, n = s.yRange.max, a = r !== this.#at || n !== this.#ot;
     if (a) {
       const c = i.media.height - this.xAxisHeight;
-      this.#z = this.#wt({ min: r, max: n, chartHeight: c }), this.#tt = r, this.#it = n;
+      this.#B = this.#It({ min: r, max: n, chartHeight: c }), this.#at = r, this.#ot = n;
     }
-    if (this.syncScales(), this.#Wt(), this.#e !== null && !this.#f) {
-      const c = this.#s.lastXTarget ?? this.#o, f = c.to - c.from;
+    if (this.syncScales(), this.#Kt(), this.#e !== null && !this.#m) {
+      const c = this.#s.lastXTarget ?? this.#h, f = c.to - c.from;
       if (f > 0) {
-        const y = this.#a.size.media.width - this.yAxisWidth, d = W(this.#l.right, f, this.#r, y), g = this.#r * 0.5;
-        Math.abs(c.to - (this.#e + d)) < g && (this.#f = !0);
+        const g = this.#a.size.media.width - this.yAxisWidth, u = B(this.#l.right, f, this.#r, g), p = this.#r * 0.5;
+        Math.abs(c.to - (this.#e + u)) < p && (this.#m = !0);
       }
     }
     a && this.emit("viewportChange");
-    let h = !1, l = !1, o = !1;
+    let o = !1, l = !1, h = !1;
     this.#a.useMainLayer((c) => {
-      const { context: f, bitmapSize: y } = c, d = (i.media.width - this.yAxisWidth) * i.horizontalPixelRatio, g = (i.media.height - this.xAxisHeight) * i.verticalPixelRatio;
-      f.clearRect(0, 0, y.width, y.height), f.save(), f.beginPath();
-      const b = this.#et(c, d);
-      f.rect(0, 0, d + b.intrusion, g), f.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#r).ticks), this.yScale.tickTracker.tick(e), this.timeScale.tickTracker.tick(e);
-      const w = this.yScale.tickTracker.snapshot(), S = this.timeScale.tickTracker.snapshot();
-      h = w.isAnimating, l = S.isAnimating, (w.isAnimating || S.isAnimating || s.animating) && this.emit("tickFrame");
-      const L = this.#F ? 1 : 0;
-      if ((L === 0 || w.entries.length > 0 || S.entries.length > 0) && L !== this.#I.target) {
-        const v = Z() ? 0 : this.#m.axis.gridMs;
-        this.#I.setTarget(L, { now: e, duration: v });
+      const { context: f, bitmapSize: g } = c, u = (i.media.width - this.yAxisWidth) * i.horizontalPixelRatio, p = (i.media.height - this.xAxisHeight) * i.verticalPixelRatio, S = this.#I(c);
+      f.clearRect(0, 0, g.width, g.height), f.save(), f.translate(S, 0), f.beginPath(), f.rect(0, 0, this.#Bt(c, u), p), f.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#r).ticks), this.yScale.tickTracker.tick(e), this.timeScale.tickTracker.tick(e);
+      const A = this.yScale.tickTracker.snapshot(), k = this.timeScale.tickTracker.snapshot();
+      o = A.isAnimating, l = k.isAnimating, (A.isAnimating || k.isAnimating || s.animating) && this.emit("tickFrame");
+      const T = this.#F ? 1 : 0;
+      if ((T === 0 || A.entries.length > 0 || k.entries.length > 0) && T !== this.#H.target) {
+        const v = Q() ? 0 : this.#d.axis.gridMs;
+        this.#H.setTarget(T, { now: e, duration: v });
       }
-      o = this.#I.tick(e);
-      const M = this.#I.current;
-      lt({
+      h = this.#H.tick(e);
+      const D = this.#H.current, R = {
         scope: c,
         timeScale: this.timeScale,
         yScale: this.yScale,
         theme: this.#n,
-        yTicks: w,
-        timeTicks: S,
-        alpha: M
-      }), this.#Pt(c, d, g);
-      const D = this.#l, O = { top: D.top, bottom: D.bottom }, R = this.#S;
+        yTicks: A,
+        timeTicks: k,
+        alpha: D
+      }, L = this.#$t(c, u);
+      L === 0 && E(R), this.#_t(c, u, p);
+      const C = this.#l, G = { top: C.top, bottom: C.bottom }, U = this.#Tt(s), I = this.#k;
       for (const v of this.#t) {
-        const A = v.renderer.getAlpha?.() ?? (v.visible ? 1 : 0);
-        if (A <= 0) continue;
-        const C = {
+        const w = v.renderer.getAlpha?.() ?? (v.visible ? 1 : 0);
+        if (w <= 0) continue;
+        const z = {
           scope: c,
           timeScale: this.timeScale,
           yScale: this.yScale,
           theme: this.#n,
           dataInterval: this.#r,
-          padding: O,
-          state: s,
+          padding: G,
+          state: U,
           seriesId: v.id
-        }, I = f.globalAlpha;
-        if (A < 1 && (f.globalAlpha = I * A), R) {
-          const E = performance.now();
-          v.renderer.render(C), R.recordSeries(v.id, performance.now() - E, e);
+        }, V = f.globalAlpha;
+        if (w < 1 && (f.globalAlpha = V * w), I) {
+          const q = performance.now();
+          v.renderer.render(z), I.recordSeries(v.id, performance.now() - q, e);
         } else
-          v.renderer.render(C);
-        A < 1 && (f.globalAlpha = I);
+          v.renderer.render(z);
+        w < 1 && (f.globalAlpha = V);
       }
-      f.restore(), this.#Ot({
-        scope: c,
-        paneBitmapWidth: d,
-        paneBitmapHeight: g,
-        timeTicks: S,
-        alpha: M
-      }), this.#Lt(c, g), this.#Mt(c, d);
-    }), this.#j();
-    let m = !1;
+      f.restore();
+      const H = { left: S, width: u, height: p };
+      L === 0 ? (this.#Wt({ scope: c, pane: H, timeTicks: k, alpha: D }), this.#lt(c, u)) : (this.#lt(c, u), this.#si({ grid: R, pane: H, overhang: L })), this.#Ft(c, u), this.#Vt(c, p);
+    }), this.#it();
+    let d = !1;
     for (const c of this.#t)
       if (c.renderer.needsAnimation) {
-        m = !0, this.#i.markDirty();
+        d = !0, this.#i.markDirty();
         break;
       }
-    const u = h || l;
-    (u || o) && this.#i.markDirty(), !s.animating && !m && !u && (this.yScale.tickTracker.markArmed(), this.timeScale.tickTracker.markArmed());
+    const m = o || l;
+    (m || h) && this.#i.markDirty(), !s.animating && !d && !m && (this.yScale.tickTracker.markArmed(), this.timeScale.tickTracker.markArmed());
   }
   /**
    * Erase the main layer's alpha across the top fade zone so content
@@ -1753,12 +1830,12 @@ class ci extends ft {
    * a paint-over — so the container background behind the canvas (solid or
    * CSS gradient) shows through untouched.
    */
-  #Lt(t, i) {
-    if (this.#k.top <= 0) return;
-    const e = Math.min(Math.round(this.#k.top * t.verticalPixelRatio), Math.round(i));
+  #Vt(t, i) {
+    if (this.#A.top <= 0) return;
+    const e = Math.min(Math.round(this.#A.top * t.verticalPixelRatio), Math.round(i));
     if (e < 1) return;
     const { context: s } = t;
-    s.save(), s.globalCompositeOperation = "destination-out", s.fillStyle = this.#Yt(s, e), s.fillRect(0, 0, t.bitmapSize.width, e), s.restore();
+    s.save(), s.globalCompositeOperation = "destination-out", s.fillStyle = this.#ni(s, e), s.fillRect(0, 0, t.bitmapSize.width, e), s.restore();
   }
   /**
    * Run the vertical gridlines a short stub past the pane floor, dissolving
@@ -1768,21 +1845,23 @@ class ci extends ft {
    * nothing else paints) and faded with the same destination-out ramp the
    * edge masks use, so the taper stays correct over any background.
    */
-  #Ot(t) {
-    const { scope: i, paneBitmapWidth: e, paneBitmapHeight: s, timeTicks: r, alpha: n } = t;
-    if (!this.#F && n <= 0.01 || this.xAxisHeight === 0) return;
-    const { context: a, horizontalPixelRatio: h, verticalPixelRatio: l } = i, o = Math.round(s), m = Math.round(T * l);
-    if (m < 1) return;
-    const u = this.#n.grid;
-    a.save(), a.strokeStyle = u.color, u.style === "dashed" ? a.setLineDash([4 * h, 4 * h]) : u.style === "dotted" && a.setLineDash([1 * h, 3 * h]), a.lineDashOffset = o, a.lineWidth = St(h);
-    const c = kt(h), f = Math.round(e);
-    for (const { value: y, opacity: d } of r.entries) {
-      const g = d * n;
-      if (g <= 0.01) continue;
-      const b = Math.round(this.timeScale.timeToBitmapX(y)) + c;
-      b < 0 || b > f || (a.globalAlpha = g, a.beginPath(), a.moveTo(b, o), a.lineTo(b, o + m), a.stroke());
+  #Wt(t) {
+    const { scope: i, pane: e, timeTicks: s, alpha: r } = t;
+    if (!this.#F && r <= 0.01 || this.xAxisHeight === 0) return;
+    const { context: n, horizontalPixelRatio: a, verticalPixelRatio: o } = i, l = Math.round(e.height), h = Math.round(P * o);
+    if (h < 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 = l, n.lineWidth = It(a);
+    const m = Ht(a), c = Math.round(e.width);
+    for (const { value: f, opacity: g } of s.entries) {
+      const u = g * r;
+      if (u <= 0.01) continue;
+      const p = Math.round(this.timeScale.timeToBitmapX(f)) + m;
+      if (p < 0 || p > c) continue;
+      const S = e.left + p;
+      n.globalAlpha = u, n.beginPath(), n.moveTo(S, l), n.lineTo(S, l + h), n.stroke();
     }
-    a.restore(), this.#Tt(i, s);
+    n.restore(), this.#Ot(i, e.height);
   }
   /**
    * Erase ramp over the below-pane overrun strip — the gridline tail stubs
@@ -1790,16 +1869,16 @@ class ci extends ft {
    * 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.
    */
-  #Tt(t, i) {
+  #Ot(t, i) {
     if (this.xAxisHeight === 0) return;
-    const e = Math.round(i), s = Math.round(T * t.verticalPixelRatio);
+    const e = Math.round(i), s = Math.round(P * t.verticalPixelRatio);
     if (s < 1) return;
     const { context: r } = t;
-    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#$t({ context: r, start: e, height: s }), r.fillRect(0, e, t.bitmapSize.width, s), r.restore();
+    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#oi({ context: r, start: e, height: s }), r.fillRect(0, e, t.bitmapSize.width, s), r.restore();
   }
   /**
    * Crosshair hairlines with the same edge melt the main layer runs: the
-   * pane clip widens by the right-fade intrusion and by a gridline-tail's
+   * pane clip widens by the axis-side fade intrusion and by a gridline-tail's
    * overrun below the floor, then the shared erase ramps dissolve the
    * overhangs — the vertical line tapers toward the time-axis labels in
    * step with the gridline stubs and the horizontal line rides under the
@@ -1807,104 +1886,177 @@ class ci extends ft {
    * edge. Erases alpha (destination-out), so it must run while the
    * crosshair is the only content on the layer.
    */
-  #Et(t) {
+  #ii(t) {
     const i = this.#c;
     if (i === null) return;
-    const { scope: e, chartBitmapWidth: s, chartBitmapHeight: r } = t, { context: n } = e, a = this.#et(e, s), h = this.xAxisHeight > 0 ? Math.round(T * e.verticalPixelRatio) : 0;
-    n.save(), n.beginPath(), n.rect(0, 0, s + a.intrusion, r + h), n.clip(), ot({
+    const { scope: e, chartBitmapWidth: s, chartBitmapHeight: r } = t, { context: n } = e, a = this.#I(e), o = this.#Bt(e, s), l = this.#$t(e, s), h = this.xAxisHeight > 0 ? Math.round(P * e.verticalPixelRatio) : 0;
+    n.save(), n.translate(a, 0), n.beginPath(), n.rect(-l, 0, o + l, r + h), n.clip(), bt({
       scope: e,
-      bitmapX: i.mediaX * e.horizontalPixelRatio,
+      bitmapX: i.mediaX * e.horizontalPixelRatio - a,
       bitmapY: i.mediaY * e.verticalPixelRatio,
       theme: this.#n,
-      pane: { width: s, height: r }
-    }), n.restore(), this.#Tt(e, r), this.#Lt(e, r), this.#Mt(e, s);
+      pane: { width: s, height: r },
+      leftOverhang: l
+    }), n.restore(), this.#Ot(e, r), l === 0 ? this.#lt(e, s) : this.#Nt(e, l), this.#Ft(e, s), this.#Vt(e, r);
   }
   /**
-   * Horizontal companions to {@link #applyTopFade}: dissolve content that
-   * rides under the Y-axis column on the right (the pane clip is widened by
-   * the same zone) and, when configured, content leaving through the left
-   * pane edge. Same destination-out erase — background-safe over gradients.
+   * Horizontal companion to {@link #applyTopFade}: dissolve content that
+   * rides under the Y-axis column (the pane clip is widened by the same
+   * zone). Same destination-out erase — background-safe over gradients.
    * Runs the full bitmap height so the below-pane gridline tail stubs melt
    * at the edges in step with their lines above.
    */
-  #Mt(t, i) {
-    const { context: e } = t, s = t.bitmapSize.height, r = this.#et(t, i);
-    r.width >= 1 && (e.save(), e.globalCompositeOperation = "destination-out", e.fillStyle = this.#Xt({ context: e, start: r.start, width: r.width }), e.fillRect(r.start, 0, r.width, s), e.restore());
-    const n = Math.min(Math.round(this.#k.left * t.horizontalPixelRatio), Math.round(i));
-    n >= 1 && (e.save(), e.globalCompositeOperation = "destination-out", e.fillStyle = this.#Zt(e, n), e.fillRect(0, 0, n, s), e.restore());
-  }
-  /**
-   * Bitmap geometry of the right fade zone. The ramp finishes just inside
-   * the Y-axis column — {@link RIGHT_FADE_END_GAP_PX} past the pane edge,
-   * still short of where the right-anchored label glyphs start — so content
-   * is fully erased before it can cross any axis text. Everything wider
-   * spills backward into the pane as the soft lead-in. `width: 0` (axis
-   * hidden, or `right: 0`) means no zone; `intrusion` is what the pane clip
-   * extends by (content past the ramp is total-erased anyway, so the clip
-   * stops with the ramp).
-   */
-  #et(t, i) {
-    const e = { start: 0, width: 0, intrusion: 0 }, s = Math.max(0, Math.round(t.bitmapSize.width - i));
-    if (s === 0) return e;
-    const r = t.horizontalPixelRatio, n = Math.min(Math.round(Mt * r), s), a = this.#k.right === null ? n + Math.round(Tt * r) : Math.round(this.#k.right * r);
-    if (a < 1) return e;
-    const h = i + n, l = Math.min(a, h);
-    return { start: h - l, width: l, intrusion: n };
+  #lt(t, i) {
+    const e = this.#ct(t, i);
+    if (e === null) return;
+    const { context: s } = t, r = Math.min(e.inner, e.outer), n = Math.abs(e.outer - e.inner);
+    s.save(), s.globalCompositeOperation = "destination-out", s.fillStyle = this.#ai({ context: s, zone: e }), s.fillRect(r, 0, n, t.bitmapSize.height), s.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. */
+  #Ft(t, i) {
+    const { context: e } = t;
+    for (const s of this.#ei()) {
+      const r = this.#ri({ scope: t, paneBitmapWidth: i, side: s });
+      if (r === null) continue;
+      const n = Math.min(r.edge, r.inner), a = Math.abs(r.inner - r.edge);
+      e.save(), e.globalCompositeOperation = "destination-out", e.fillStyle = this.#li({ context: e, side: s, zone: r }), e.fillRect(n, 0, a, t.bitmapSize.height), e.restore();
+    }
+  }
+  /** Sides whose fade is a plain edge zone rather than the axis-column ramp. */
+  #ei() {
+    return this.#X() ? $t : this.yAxisPosition === "left" ? Bt : Nt;
+  }
+  /** Bitmap px the gridlines and crosshair run under a left Y-axis column, where
+   *  data can't follow (see {@link #axisFadeZone}). `0` on the right or with the fade off. */
+  #$t(t, i) {
+    return this.yAxisPosition !== "left" || this.#ct(t, i) === null ? 0 : Math.min(Math.round(Z * t.horizontalPixelRatio), this.#I(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. */
+  #si(t) {
+    const { grid: i, pane: e, overhang: s } = t, { scope: r } = i, { context: n } = r;
+    n.save(), n.globalCompositeOperation = "destination-over", n.save(), n.translate(e.left, 0), n.beginPath(), n.rect(-s, 0, e.width + s, e.height), n.clip(), E({ ...i, leftOverhang: s }), n.restore(), this.#Wt({ scope: r, pane: e, timeTicks: i.timeTicks, alpha: i.alpha ?? 1 }), n.restore(), this.#Nt(r, s);
+  }
+  /** Erase the {@link #gridOverhang} strip: none at the pane edge, total at its outer end. */
+  #Nt(t, i) {
+    const e = this.#I(t), s = e - i, { context: r } = t;
+    r.save(), r.globalCompositeOperation = "destination-out", r.fillStyle = this.#hi({ context: r, start: s, end: e }), r.fillRect(s, 0, i, t.bitmapSize.height), r.restore();
+  }
+  /** Canvas bitmap x of the pane's left edge — whole device pixels, so the
+   *  translated pane keeps crisp strokes. */
+  #I(t) {
+    return Math.round(this.plotLeft * t.horizontalPixelRatio);
+  }
+  /** Pane-local width of the pane clip: the pane plus the axis-side fade
+   *  intrusion, so content can slide under a right Y-axis column before the
+   *  mask dissolves it. */
+  #Bt(t, i) {
+    const e = this.#ct(t, i)?.intrusion ?? 0;
+    return i + e;
+  }
+  /**
+   * Bitmap geometry of the fade zone on the Y-axis side. On the right the
+   * ramp finishes just inside the column — {@link AXIS_FADE_END_GAP_PX} past
+   * the pane edge, still short of where the label glyphs start — so content
+   * is fully erased before it can cross any axis text; everything wider
+   * spills back into the pane as the soft lead-in. On the left it finishes
+   * at the pane edge. Erasing starts at `inner` and is total at `outer`;
+   * `intrusion` is what the pane clip extends by (content past the ramp is
+   * total-erased anyway). `null` when the axis is hidden, its side's fade
+   * is `0`, or the chart is spatial-only.
+   */
+  #ct(t, i) {
+    if (this.#X()) return null;
+    const e = this.yAxisPosition === "left", s = t.bitmapSize.width, r = e ? this.#I(t) : Math.max(0, Math.round(s - i));
+    if (r === 0) return null;
+    const n = t.horizontalPixelRatio, a = Math.round(Z * n), o = Math.round(Ft * n), l = e ? 0 : Math.min(a, r), h = e ? a + o : l + o, d = e ? this.#A.left : this.#A.right, m = d === null ? h : Math.round(d * n);
+    if (m < 1) return null;
+    if (e) {
+      const g = r, u = Math.min(m, s - g);
+      return { inner: g + u, outer: g, intrusion: l };
+    }
+    const c = i + l, f = Math.min(m, c);
+    return { inner: c - f, outer: c, intrusion: l };
+  }
+  /** 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. */
+  #ri(t) {
+    const { scope: i, paneBitmapWidth: e, side: s } = t, r = this.#A[s];
+    if (r === null) return null;
+    const n = Math.min(Math.round(r * i.horizontalPixelRatio), Math.round(e));
+    if (n < 1) return null;
+    if (s === "right") {
+      const a = i.bitmapSize.width;
+      return { edge: a, inner: a - n };
+    }
+    return { edge: 0, inner: n };
   }
   /** Memoized mask gradient — rebuilt only when the bitmap zone height
    *  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. */
-  #Yt(t, i) {
-    const e = this.#w.top;
+  #ni(t, i) {
+    const e = this.#v.top;
     if (e !== null && e.height === i) return e.gradient;
     const s = t.createLinearGradient(0, 0, 0, i);
     for (let r = 0; r <= 4; r++) {
       const n = r / 4;
       s.addColorStop(n, `rgba(0, 0, 0, ${1 - n * n})`);
     }
-    return this.#w.top = { height: i, gradient: s }, s;
+    return this.#v.top = { height: i, gradient: s }, s;
   }
-  /** Right-zone mask — erase grows from 0 at the ramp's inner start to
+  /** 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
    *  curvature at the entry, so the in-pane lead-in barely dims the newest
    *  candles at rest and the aggressive erasing all happens deep under the
    *  axis column. Nine stops keep the piecewise interpolation smooth across
    *  the zone. */
-  #Xt(t) {
-    const i = this.#w.right;
-    if (i !== null && i.start === t.start && i.width === t.width) return i.gradient;
-    const e = t.context.createLinearGradient(t.start, 0, t.start + t.width, 0);
-    for (let s = 0; s <= 8; s++) {
-      const r = s / 8;
-      e.addColorStop(r, `rgba(0, 0, 0, ${r * r * r})`);
+  #ai(t) {
+    const { context: i, zone: e } = t, s = this.#v.axis;
+    if (s !== null && s.inner === e.inner && s.outer === e.outer) return s.gradient;
+    const r = i.createLinearGradient(e.inner, 0, e.outer, 0);
+    for (let n = 0; n <= 8; n++) {
+      const a = n / 8;
+      r.addColorStop(a, `rgba(0, 0, 0, ${a * a * a})`);
     }
-    return this.#w.right = { start: t.start, width: t.width, gradient: e }, e;
+    return this.#v.axis = { inner: e.inner, outer: e.outer, gradient: r }, r;
   }
   /** 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. */
-  #$t(t) {
-    const i = this.#w.tail;
+  #oi(t) {
+    const i = this.#v.tail;
     if (i !== null && i.start === t.start && i.height === t.height) return i.gradient;
     const e = t.context.createLinearGradient(0, t.start, 0, t.start + t.height);
     for (let s = 0; s <= 4; s++) {
       const r = s / 4;
       e.addColorStop(r, `rgba(0, 0, 0, ${r * r})`);
     }
-    return this.#w.tail = { start: t.start, height: t.height, gradient: e }, e;
-  }
-  /** Left-zone mask — mirror of the top ramp: total erase at the canvas
-   *  edge, fully opaque at the zone's inner boundary. */
-  #Zt(t, i) {
-    const e = this.#w.left;
-    if (e !== null && e.width === i) return e.gradient;
-    const s = t.createLinearGradient(0, 0, i, 0);
-    for (let r = 0; r <= 4; r++) {
-      const n = r / 4;
-      s.addColorStop(n, `rgba(0, 0, 0, ${1 - n * n})`);
+    return this.#v.tail = { start: t.start, height: t.height, gradient: e }, e;
+  }
+  /** Gridline overhang ramp — ease-in (`t²`) like the tail stubs. */
+  #hi(t) {
+    const i = this.#v.overhang;
+    if (i !== null && i.start === t.start && i.end === t.end) return i.gradient;
+    const e = t.context.createLinearGradient(t.end, 0, t.start, 0);
+    for (let s = 0; s <= 4; s++) {
+      const r = s / 4;
+      e.addColorStop(r, `rgba(0, 0, 0, ${r * r})`);
+    }
+    return this.#v.overhang = { start: t.start, end: t.end, gradient: e }, e;
+  }
+  /** Opposite-edge mask — mirror of the top ramp: total erase at the
+   *  canvas edge, fully opaque at the zone's inner boundary. */
+  #li(t) {
+    const { context: i, side: e, zone: s } = t, r = this.#v.edge[e];
+    if (r !== null && r.edge === s.edge && r.inner === s.inner) return r.gradient;
+    const n = i.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.#w.left = { width: i, gradient: s }, s;
+    return this.#v.edge[e] = { edge: s.edge, inner: s.inner, gradient: n }, n;
   }
   /**
    * Paint a full frame: the main layer, then the overlay synchronously on
@@ -1915,13 +2067,13 @@ class ci extends ft {
    * `markDirty` calls made *during* `renderOverlay` (pulse, edge spinner)
    * land after the consume and re-arm cleanly for the next frame.
    */
-  #st(t) {
-    this.#rt("main", t, () => this.renderMain(t)), this.#h.consume(), this.#rt("overlay", t, () => this.renderOverlay(t));
+  #dt(t) {
+    this.#ut("main", t, () => this.renderMain(t)), this.#o.consume(), this.#ut("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. */
-  #rt(t, i, e) {
-    const s = this.#S;
+  #ut(t, i, e) {
+    const s = this.#k;
     if (!s) {
       e();
       return;
@@ -1935,74 +2087,74 @@ class ci extends ft {
     const i = this.#a.size;
     if (i.media.width === 0 || i.media.height === 0) return;
     let e = !1;
-    for (const o of this.#t)
-      if (o.visible && o.renderer.overlayNeedsAnimation) {
+    for (const h of this.#t)
+      if (h.visible && h.renderer.overlayNeedsAnimation) {
         e = !0;
         break;
       }
-    this.#u.some((o) => o.pulse) && (e = !0);
+    this.#u.some((h) => h.pulse) && (e = !0);
     const s = {
-      left: this.#P.left && this.#b.left === "loading" ? "idle" : this.#b.left,
-      right: this.#P.right && this.#b.right === "loading" ? "idle" : this.#b.right
+      left: this.#z.left && this.#S.left === "loading" ? "idle" : this.#S.left,
+      right: this.#z.right && this.#S.right === "loading" ? "idle" : this.#S.right
     }, r = {
-      left: this.#xt("left"),
-      right: this.#xt("right")
-    }, n = r.left !== null || r.right !== null, a = s.left === "loading" || s.right === "loading" || n, h = s.left !== "idle" || s.right !== "idle" || n, l = !!this.#c || e || h || this.#u.length > 0 || this.#y.length > 0;
-    if (!(!l && !this.#ht)) {
-      if (this.#ht = l, this.#a.useOverlayLayer((o) => {
+      left: this.#Pt("left"),
+      right: this.#Pt("right")
+    }, n = r.left !== null || r.right !== null, a = s.left === "loading" || s.right === "loading" || n, o = s.left !== "idle" || s.right !== "idle" || n, l = !!this.#c || e || o || this.#u.length > 0 || this.#y.length > 0;
+    if (!(!l && !this.#gt)) {
+      if (this.#gt = l, this.#a.useOverlayLayer((h) => {
         if (!l) return;
-        const m = (i.media.width - this.yAxisWidth) * i.horizontalPixelRatio, u = (i.media.height - this.xAxisHeight) * i.verticalPixelRatio;
-        this.#c && this.#vt() && this.#Et({ scope: o, chartBitmapWidth: m, chartBitmapHeight: u }), o.context.save(), o.context.beginPath(), o.context.rect(0, 0, m, u), o.context.clip();
-        const c = this.#l, f = { top: c.top, bottom: c.bottom }, y = this.#s.getAnimationState();
-        for (const d of this.#t)
-          d.visible && d.renderer.drawOverlay?.({
-            scope: o,
+        const d = (i.media.width - this.yAxisWidth) * i.horizontalPixelRatio, m = (i.media.height - this.xAxisHeight) * i.verticalPixelRatio;
+        this.#c && this.#Mt() && this.#ii({ scope: h, chartBitmapWidth: d, chartBitmapHeight: m }), h.context.save(), h.context.translate(this.#I(h), 0), h.context.beginPath(), h.context.rect(0, 0, d, m), h.context.clip();
+        const c = this.#l, f = { top: c.top, bottom: c.bottom }, g = this.getAnimationState();
+        for (const u of this.#t)
+          u.visible && u.renderer.drawOverlay?.({
+            scope: h,
             timeScale: this.timeScale,
             yScale: this.yScale,
             theme: this.#n,
             dataInterval: this.#r,
             padding: f,
             crosshair: this.#c,
-            state: y,
-            seriesId: d.id
+            state: g,
+            seriesId: u.id
           });
-        this.#Ht(o, m, u), this.#It(o, m, u), h && K({
-          scope: o,
+        this.#Gt(h, d, m), this.#Zt(h, d, m), o && st({
+          scope: h,
           chartMediaWidth: i.media.width - this.yAxisWidth,
           chartMediaHeight: i.media.height - this.xAxisHeight,
           timeScale: this.timeScale,
           theme: this.#n,
           edgeStates: s,
           edgeExitFades: r,
-          edgeIndicatorFns: this.#ct,
-          resolveBoundary: (d) => j(d, this.#ot[d], this.getDataBounds()),
-          resolveEdgeAnchor: (d, g) => this.#zt(d, g),
-          resolveEdgeBarSpacing: () => this.#Vt(),
-          reportPlaceholders: (d, g) => {
-            this.#Z[d] = { bars: g, at: performance.now() };
+          edgeIndicatorFns: this.#vt,
+          resolveBoundary: (u) => rt(u, this.#pt[u], this.getDataBounds()),
+          resolveEdgeAnchor: (u, p) => this.#Ut(u, p),
+          resolveEdgeBarSpacing: () => this.#qt(),
+          reportPlaceholders: (u, p) => {
+            this.#K[u] = { bars: p, at: performance.now() };
           }
-        }), o.context.restore();
+        }), h.context.restore();
       }), e) {
-        const { from: o, to: m } = this.timeScale.getRange();
-        let u = !1;
+        const { from: h, to: d } = this.timeScale.getRange();
+        let m = !1;
         for (const c of this.#t)
-          if (!(!c.visible || !c.renderer.overlayNeedsAnimation) && (c.renderer.hasOverlayContentInRange?.(o, m) ?? !0)) {
-            u = !0;
+          if (!(!c.visible || !c.renderer.overlayNeedsAnimation) && (c.renderer.hasOverlayContentInRange?.(h, d) ?? !0)) {
+            m = !0;
             break;
           }
-        if (!u) {
+        if (!m) {
           for (const c of this.#u)
-            if (c.pulse && c.time >= o && c.time <= m) {
-              u = !0;
+            if (c.pulse && c.time >= h && c.time <= d) {
+              m = !0;
               break;
             }
         }
-        u && this.#h.markDirty();
+        m && this.#o.markDirty();
       }
-      a && this.#h.markDirty();
+      a && this.#o.markDirty();
     }
   }
 }
 export {
-  ci as ChartInstance
+  Li as ChartInstance
 };