@wick-charts/vue 0.4.1 → 0.5.0

package/dist/core/dist/chart.js

@@ -0,0 +1,1495 @@
+import { AnimationConfig as z, DEFAULT_LINE_PULSE as H } from "./animation/config.js";
+import { createViewportEngine as N } from "./animation/viewport-engine.js";
+import { CanvasManager as W } from "./canvas-manager.js";
+import { drawEdgeIndicators as E, resolveEdgeBoundary as $ } from "./chart/edge-indicators.js";
+import { computeFitToData as O } from "./chart/fit-to-data.js";
+import { getLastValue as B, getPreviousClose as F, getStackedLastValue as Y } from "./chart/last-value.js";
+import { resolveMaxVisibleBars as X, resolvePadding as D, resolvePerfOptions as _, isSameHorizontalPadding as C } from "./chart/options.js";
+import { computePan as U, computeZoom as Z } from "./chart/pan-zoom-math.js";
+import { StreamingCadence as G } from "./chart/streaming-cadence.js";
+import { computeStreamingTarget as j } from "./chart/streaming-target.js";
+import { resolvePaddingTime as T } from "./chart/viewport-padding.js";
+import { computeTargetYRange as q, resolveBound as R } from "./chart/y-target.js";
+import { renderCrosshair as J } from "./components/crosshair.js";
+import { renderGrid as K } from "./components/grid.js";
+import { renderMarker as Q } from "./components/marker.js";
+import { renderReferenceLine as tt } from "./components/reference-line.js";
+import { resolveTimeRegionColors as it, renderTimeRegion as et } from "./components/time-region.js";
+import { EventEmitter as st } from "./events.js";
+import { InteractionHandler as rt } from "./interactions/handler.js";
+import { RenderScheduler as M } from "./render-scheduler.js";
+import { XScale as nt } from "./scales/x-scale.js";
+import { YScale as ht } from "./scales/y-scale.js";
+import { resolveSeriesDefinition as at } from "./series/definition.js";
+import { catppuccin as ot } from "./theme/themes/catppuccin.js";
+import { normalizeTime as g, detectInterval as lt } from "./utils/time.js";
+let dt = 0, ct = 0, mt = 0, ut = 0;
+function I(m, i) {
+  return m === i ? !0 : !m || !i || m.length !== i.length ? !1 : m.every((t, e) => t === i[e]);
+}
+function ft(m, i) {
+  return m === i ? !0 : !m || !i || m.length !== i.length ? !1 : m.every((t, e) => t === i[e]);
+}
+class Ot extends st {
+  /** Canvas lifecycle and DPR-aware sizing. */
+  #n;
+  /** Schedules main-layer redraws (background, grid, series). */
+  #i;
+  /** Schedules overlay redraws (crosshair). */
+  #d;
+  /** Maps time values to horizontal pixel coordinates. */
+  timeScale;
+  /** Maps price/value to vertical pixel coordinates. */
+  yScale;
+  /** Zoom, pan, crosshair — null when interactive=false. */
+  #W;
+  /** All registered series (candlestick, line, bar, pie). */
+  #t = [];
+  /** Point annotations (event markers) drawn on the overlay layer, kept out of the series model. */
+  #c = [];
+  /** Time-region bands drawn on the main layer behind the series, kept out of the series model. */
+  #v = [];
+  /** Reference lines (horizontal threshold / vertical event) drawn on the overlay layer, kept out of the series model. */
+  #g = [];
+  /** Active visual theme (colors, fonts, grid style). */
+  #r;
+  /** Whether to render the background grid. */
+  #E;
+  /** Detected time interval between data points (milliseconds). */
+  #h = 6e4;
+  /** Current crosshair position, null when cursor is outside the chart. */
+  #m = null;
+  /** Whether the last overlay pass painted anything — gates the full-bitmap
+   *  clear so an empty overlay isn't cleared again every main frame. */
+  #G = !1;
+  /** User-specified Y-axis bounds (auto, fixed, percentage). */
+  #a = {};
+  /** Cached series ID list — invalidated on add/remove. */
+  #A = null;
+  /** Axis visibility and sizing configuration. */
+  #I = {};
+  /** Host-declared state per edge — drives the edge-indicator overlay. */
+  #b = { left: "idle", right: "idle" };
+  /** Cached boundary timestamps from the last `edgeReached` emission, by side. */
+  #j = { left: null, right: null };
+  /** Host-supplied callback fired when the user releases a pan/zoom past a data edge. */
+  #q;
+  /** Nesting depth for batch updates. Suppresses recomputes while > 0. */
+  #w = 0;
+  /** True when batched operations include data changes (triggers full onDataChanged on end). */
+  #$ = !1;
+  /** True when batched operations include visibility changes (triggers Y-range + redraw on end). */
+  #T = !1;
+  /** True when batched operations bumped overlay version (emits a single overlayChange on flush). */
+  #O = !1;
+  /**
+   * Monotonic counter bumped on any mutation that affects overlay output —
+   * data, visibility, series options, theme. Used by snapshot helpers in
+   * `@wick-charts/core` as a cache key, so `buildHoverSnapshots` /
+   * `buildLastSnapshots` return the same reference between ticks when
+   * nothing observable has changed.
+   *
+   * @internal
+   */
+  #J = 0;
+  get yAxisWidth() {
+    const i = this.#I.y;
+    return i?.visible === !1 ? 0 : i?.width ?? 55;
+  }
+  get xAxisHeight() {
+    const i = this.#I.x;
+    return i?.visible === !1 ? 0 : i?.height ?? 30;
+  }
+  /** Resolved animation config derived from `options.animations` at construction. */
+  #f;
+  /**
+   * Single source of truth for the chart's X / Y viewport animation.
+   * Push-model API: chart emits intent signals (`onPointAppended`,
+   * `onSeriesVisibilityChanged`, `onPanZoom`, `onProgrammaticZoom`,
+   * `onAxisReconfig`, `onDataReplaced`, `snap`); the engine pulls the
+   * matching targets back through `computeXTarget` / `computeYTarget`
+   * closures supplied at construction.
+   */
+  #e;
+  /** EMA-smoothed real-wall-clock cadence between streaming appends. The
+   *  X spring's `setSettleMs` is fed from this so the settle time stays just
+   *  longer than the producer's tick interval — the spring never quite
+   *  settles between ticks, so velocity carries continuously and the slide
+   *  doesn't pulse. */
+  #D;
+  /**
+   * Mirrors `#dataReplaceSnapPending` for the engine signal that follows
+   * inside the same `onDataChanged` call. `#dataReplaceSnapPending` is
+   * consumed at the top of `onDataChanged` (so a stray streaming append
+   * couldn't re-trigger the snap), but the `computeXTarget` closure runs
+   * later and still needs to know whether to refit the X window. This
+   * field carries the decision across that gap. The closure also reads
+   * `#dataStart` / `#dataEnd` directly for the timestamps.
+   */
+  #K = !1;
+  /** Earliest data timestamp registered across all series, `null` before any data has arrived. */
+  #k = null;
+  /** Latest data timestamp registered across all series, `null` before any data has arrived. */
+  #s = null;
+  /**
+   * Previous {@link #dataEnd} value. Streaming-target math reads it to
+   * preserve any pan offset across ticks: a user who panned a few bars
+   * left of the tail keeps that offset as new bars arrive, instead of
+   * snapping back to the natural-pin position every frame.
+   */
+  #P = 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.
+   */
+  #L = !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`.
+   */
+  #Q;
+  /**
+   * 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 };
+  /** Padded Y range — engine's raw Y target plus pixel padding from `#padding`. */
+  #V = { 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.
+   */
+  #p = !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). */
+  #z = 0;
+  /** Active performance monitor, or `null` when instrumentation is disabled (the default). */
+  #x;
+  /** When true, `destroy()` tears down the monitor; false for caller-supplied monitors we must not destroy. */
+  #B = !1;
+  /** Visible HUD overlay (mounted by the perf config); non-null only when the caller requested one. */
+  #F = null;
+  constructor(i, t) {
+    super(), t?.axis && (this.#I = t.axis, this.#a = { min: t.axis.y?.min, max: t.axis.y?.max }), this.#r = t?.theme ?? ot.theme, this.#E = t?.grid?.visible !== !1, this.#f = z.resolve(t?.animations), this.#Q = X(t?.viewport?.maxVisibleBars), this.#l = D(t?.padding), this.#D = new G();
+    const e = this.#f.axis.y, s = this.#f.axis.x;
+    this.#e = N({
+      initial: { yRange: { min: 0, max: 0 }, xRange: { from: 0, to: 0 } },
+      y: {
+        curve: e.curve,
+        settleMs: e.settleMs,
+        stickyMs: e.stickyMs,
+        stickyFloorMs: e.stickyFloorMs,
+        gestureMs: e.gestureMs,
+        toggleMs: this.#f.toggleMs
+      },
+      x: {
+        curve: s.curve,
+        settleMs: s.settleMs,
+        gestureMs: s.gestureMs
+      },
+      computeXTarget: () => this.#gt(),
+      computeYTarget: ({ xTarget: a }) => this.#st(a),
+      onWake: () => this.#i?.markDirty()
+    }), this.#q = t?.onEdgeReached, this.#H = t?.viewport?.initialRange;
+    const r = _(t?.perf);
+    this.#x = r.monitor, this.#B = r.ownsMonitor, this.#n = new W(i, this.#x ?? void 0), this.timeScale = new nt(), this.yScale = new ht();
+    const n = this.#f.axis.ticksMs;
+    this.timeScale.tickTracker.setFadeMs(n), this.yScale.tickTracker.setFadeMs(n), this.#i = new M((a) => this.#U(a)), this.#d = new M(
+      (a) => this.#Z("overlay", a, () => this.renderOverlay(a))
+    ), this.#x && r.hud && (this.#F = r.hud(i, this.#x));
+    const h = t?.interactive !== !1;
+    this.#W = h ? new rt(this.#n.canvas, this, this.timeScale, this.yScale) : null, this.#n.on("resize", () => {
+      this.syncScales(), this.#U(), this.emit("viewportChange");
+    }), this.syncScales(), this.#W?.on("crosshairMove", (a) => {
+      this.#m = a, this.#d.markDirty(), this.emit("crosshairMove", a), this.#ft(a);
+    });
+  }
+  /**
+   * Bump overlay version + emit `overlayChange`. Call from every mutation
+   * path whose output overlay components care about: data, series list,
+   * per-series/layer visibility, options, theme.
+   *
+   * Inside `batch(...)` the version still increments per call (so the
+   * snapshot cache invalidates at least once per logical change), but the
+   * `overlayChange` emission is coalesced to a single event on flush.
+   * That lets Legend-style isolate toggles — which batch multiple
+   * `setSeriesVisible` / `setLayerVisible` calls — produce one overlay
+   * render instead of N.
+   */
+  #S() {
+    if (this.#J++, this.#w > 0) {
+      this.#O = !0;
+      return;
+    }
+    this.emit("overlayChange");
+  }
+  /**
+   * Monotonic counter incremented on any mutation that affects overlay
+   * output. Snapshot helpers (`buildHoverSnapshots`, `buildLastSnapshots`)
+   * key their structural-equality cache on this value — same version +
+   * same `(time, sort, cacheKey)` returns the same frozen reference.
+   *
+   * @internal
+   */
+  getOverlayVersion() {
+    return this.#J;
+  }
+  /**
+   * Return a series ID: use the provided hint if it's non-empty and not already taken,
+   * otherwise generate a new auto ID. Auto-generated IDs never collide with each other
+   * or with user-provided IDs because they use a monotonically increasing counter.
+   */
+  #at(i) {
+    if (i && !this.#t.some((e) => e.id === i))
+      return i;
+    let t;
+    do
+      t = `series_${++dt}`;
+    while (this.#t.some((e) => e.id === t));
+    return t;
+  }
+  addSeries(i, t = {}) {
+    const e = typeof i == "string" ? at(i) : i;
+    if (!e)
+      throw new Error(
+        `[wick-charts] Unknown series type '${String(i)}'. The string form of addSeries resolves through the series registry — call registerBuiltinSeries() once at startup, or pass the definition directly: chart.addSeries(LineSeriesDef, options).`
+      );
+    const { layers: s, id: r, label: n, labels: h, ...a } = t, d = s ?? 1, l = {
+      ...this.#f.defaults(e.type),
+      ...a,
+      ...this.#f.overrides(e.type)
+    }, u = e.create({ theme: this.#r, layerCount: d }, l), c = h ?? (typeof n == "string" ? [n] : void 0), o = this.#at(r);
+    return u.onDataChanged?.(() => this.onDataChanged()), this.#t.push({ id: o, labels: c, renderer: u, visible: !0 }), this.#A = null, this.emit("seriesChange"), this.#S(), o;
+  }
+  /** Remove a series by ID and clean up its resources. */
+  removeSeries(i) {
+    const t = this.#t.findIndex((e) => e.id === i);
+    t >= 0 && (this.#t[t].renderer.dispose(), this.#t.splice(t, 1), this.#A = null, this.#i.markDirty(), this.emit("seriesChange"), this.#S());
+  }
+  // --- Markers (point annotations) -----------------------------------------
+  /**
+   * Pin a point annotation to `time` (X) and `value` (Y), or to a series via
+   * `seriesId` (Y snaps to the nearest data point at `time`). Returns the marker
+   * id for later {@link updateMarker} / {@link removeMarker}.
+   *
+   * Markers render on the overlay layer and stay out of the series model — they
+   * are excluded from tooltips, the legend, and the Y-range autoscale, and never
+   * appear in series queries.
+   */
+  addMarker(i) {
+    const t = `marker_${++ct}`;
+    return this.#c.push(this.#tt(t, i)), this.#d.markDirty(), t;
+  }
+  /** Replace a marker's config in place. No-op when the id is unknown. */
+  updateMarker(i, t) {
+    const e = this.#c.findIndex((s) => s.id === i);
+    e !== -1 && (this.#c[e] = this.#tt(i, t), this.#d.markDirty());
+  }
+  /** Remove a marker by id. No-op when the id is unknown. */
+  removeMarker(i) {
+    const t = this.#c.findIndex((e) => e.id === i);
+    t !== -1 && (this.#c.splice(t, 1), this.#d.markDirty());
+  }
+  /** Read-only snapshot of the registered markers (normalized). Mutate via add / update / removeMarker. */
+  getMarkers() {
+    return this.#c;
+  }
+  #tt(i, t) {
+    return {
+      id: i,
+      time: g(t.time),
+      value: t.value,
+      seriesId: t.seriesId,
+      shape: t.shape ?? "dot",
+      pulse: t.pulse ?? !1,
+      label: t.label,
+      color: t.color
+    };
+  }
+  /** Resolve a marker's Y value: explicit `value`, else snapped to its series at `time`. Null when neither resolves. */
+  #ot(i) {
+    if (i.value !== void 0 && Number.isFinite(i.value)) return i.value;
+    if (i.seriesId === void 0) return null;
+    const t = this.getDataAtTime(i.seriesId, i.time);
+    return t ? "close" in t ? t.close : t.value : null;
+  }
+  /** Resolve a marker's color: explicit `color`, else the series color, else the theme line color. */
+  #lt(i) {
+    if (i.color !== void 0) return i.color;
+    if (i.seriesId !== void 0) {
+      const t = this.getSeriesColor(i.seriesId);
+      if (t !== null) return t;
+    }
+    return this.#r.line.color;
+  }
+  #dt(i) {
+    if (this.#c.length === 0) return;
+    const t = performance.now() / (H * 2 * Math.PI) % 1;
+    for (const e of this.#c) {
+      const s = this.#ot(e);
+      s !== null && Q({
+        scope: i,
+        timeScale: this.timeScale,
+        yScale: this.yScale,
+        theme: this.#r,
+        marker: {
+          time: e.time,
+          value: s,
+          color: this.#lt(e),
+          shape: e.shape,
+          pulse: e.pulse,
+          label: e.label
+        },
+        phase: t
+      });
+    }
+  }
+  // --- Time regions (shaded bands) -----------------------------------------
+  /**
+   * Shade the time interval `[from, to]` with a translucent vertical band —
+   * an anomaly window, a maintenance window, a highlighted session. Omit `to`
+   * (or pass `'now'`) for an open-ended band that extends to the right edge of
+   * the plot — the "still firing" case. Returns the region id for later
+   * {@link updateRegion} / {@link removeRegion}.
+   *
+   * Regions render on the main layer *behind* the series and stay out of the
+   * series model — they never affect the Y-range autoscale, tooltips, or the
+   * legend.
+   */
+  addRegion(i) {
+    const t = `region_${++mt}`;
+    return this.#v.push(this.#it(t, i)), this.#i.markDirty(), t;
+  }
+  /** Replace a region's config in place. No-op when the id is unknown. */
+  updateRegion(i, t) {
+    const e = this.#v.findIndex((s) => s.id === i);
+    e !== -1 && (this.#v[e] = this.#it(i, t), this.#i.markDirty());
+  }
+  /** Remove a region by id. No-op when the id is unknown. */
+  removeRegion(i) {
+    const t = this.#v.findIndex((e) => e.id === i);
+    t !== -1 && (this.#v.splice(t, 1), this.#i.markDirty());
+  }
+  /** Read-only snapshot of the registered regions (normalized). Mutate via add / update / removeRegion. */
+  getRegions() {
+    return this.#v;
+  }
+  #it(i, t) {
+    const { to: e } = t, s = e === void 0 || e === "now" ? null : g(e);
+    return {
+      id: i,
+      from: g(t.from),
+      to: s,
+      fill: t.fill,
+      color: t.color,
+      label: t.label
+    };
+  }
+  #ct(i, t, e) {
+    if (this.#v.length !== 0)
+      for (const s of this.#v) {
+        const { color: r, fill: n } = it(s, this.#r);
+        et({
+          scope: i,
+          timeScale: this.timeScale,
+          theme: this.#r,
+          region: { from: s.from, to: s.to, fill: n, color: r, label: s.label },
+          plotWidth: t,
+          plotHeight: e
+        });
+      }
+  }
+  // --- Reference lines (thresholds / event boundaries) ---------------------
+  /**
+   * Draw a reference line across the plot — a horizontal threshold / baseline
+   * pinned to a `value`, or a vertical event boundary pinned to a `time`
+   * (mutually exclusive). Returns the line id for later {@link updateLine} /
+   * {@link removeLine}.
+   *
+   * Lines render on the overlay layer *above* the series and stay out of the
+   * series model — they never affect the Y-range autoscale, tooltips, or the
+   * legend.
+   */
+  addLine(i) {
+    const t = `line_${++ut}`;
+    return this.#g.push(this.#et(t, i)), this.#d.markDirty(), t;
+  }
+  /** Replace a reference line's config in place. No-op when the id is unknown. */
+  updateLine(i, t) {
+    const e = this.#g.findIndex((s) => s.id === i);
+    e !== -1 && (this.#g[e] = this.#et(i, t), this.#d.markDirty());
+  }
+  /** Remove a reference line by id. No-op when the id is unknown. */
+  removeLine(i) {
+    const t = this.#g.findIndex((e) => e.id === i);
+    t !== -1 && (this.#g.splice(t, 1), this.#d.markDirty());
+  }
+  /** Read-only snapshot of the registered reference lines (normalized). Mutate via add / update / removeLine. */
+  getLines() {
+    return this.#g;
+  }
+  #et(i, t) {
+    const { time: e, value: s } = t, r = {
+      id: i,
+      color: t.color,
+      label: t.label,
+      style: t.style ?? "dashed",
+      width: t.width ?? 1
+    };
+    return e !== void 0 ? { ...r, orientation: "vertical", coord: g(e) } : { ...r, orientation: "horizontal", coord: s ?? Number.NaN };
+  }
+  #mt(i, t, e) {
+    if (this.#g.length !== 0)
+      for (const s of this.#g)
+        tt({
+          scope: i,
+          timeScale: this.timeScale,
+          yScale: this.yScale,
+          theme: this.#r,
+          line: {
+            orientation: s.orientation,
+            coord: s.coord,
+            color: s.color ?? this.#r.line.color,
+            style: s.style,
+            width: s.width,
+            label: s.label
+          },
+          plotWidth: t,
+          plotHeight: e
+        });
+  }
+  /**
+   * Read-only snapshot of the chart's X / Y viewport animation. The same
+   * shape (`xRange`, `yRange`, `animating`) every frame — call this inside
+   * the current render pass rather than caching the reference, as the
+   * underlying animator mutates between frames.
+   */
+  getAnimationState() {
+    return this.#e.getAnimationState();
+  }
+  /**
+   * Replace all data for a series.
+   *
+   * - Single-layer series (candlestick, single-layer line/bar, pie): pass `data` directly.
+   * - Multi-layer series (line/bar with multiple layers): pass `layerIndex` to target a specific layer.
+   *
+   * For line/bar accepts `TimePointInput[]` (time may be `Date`); for candlestick accepts `OHLCInput[]`;
+   * for pie accepts `PieSliceData[]`. Time fields are normalized internally.
+   */
+  setSeriesData(i, t, e) {
+    const s = this.#t.find((r) => r.id === i);
+    s && (this.#Y = !0, s.renderer.setData(t, e));
+  }
+  /** Append a new data point to the end of a series (real-time tick). */
+  appendData(i, t, e) {
+    const s = this.#t.find((r) => r.id === i);
+    s === void 0 || s.renderer.appendPoint === void 0 || s.renderer.appendPoint(t, e);
+  }
+  /** Update the last data point of a series in place (e.g. live candle update). */
+  updateData(i, t, e) {
+    this.#t.find((s) => s.id === i)?.renderer.updateLastPoint?.(t, e);
+  }
+  /**
+   * Keep only the most recent `count` points of a series — drop the oldest
+   * tail when the series exceeds the cap. Smooth Y-range chase (no snap):
+   * unlike {@link setSeriesData}, this does NOT set the bulk-replace snap
+   * flag, so streaming windows can roll without per-tick Y jitter.
+   *
+   * Idempotent: a no-op when the series is already at or below `count`.
+   * Use after {@link appendData} in a rolling-window stream:
+   * ```ts
+   * chart.appendData('feed', point);
+   * chart.keepLast('feed', 100);
+   * ```
+   */
+  keepLast(i, t, e) {
+    this.#t.find((s) => s.id === i)?.renderer.keepLast?.(t, e);
+  }
+  /** Update visual options (color, width, etc.) for an existing series. */
+  updateSeriesOptions(i, t) {
+    const e = this.#t.find((l) => l.id === i);
+    if (!e) return;
+    const s = e.labels, r = e.renderer.getLayerColors().slice(), n = this.#f.overrides(e.renderer.kind);
+    e.renderer.updateOptions({ ...t, ...n }), "label" in t && typeof t.label == "string" && (e.labels = [t.label]), this.#i.markDirty();
+    const h = e.renderer.getLayerColors(), a = r.length !== h.length || r.some((l, u) => l !== h[u]), d = !I(s, e.labels);
+    (a || d) && this.#S();
+  }
+  /**
+   * Batch multiple updates: suppress recomputes until `fn` returns. Exceptions
+   * inside `fn` still flush the batch so counters don't leak across calls.
+   */
+  batch(i) {
+    this.#w++;
+    try {
+      i();
+    } finally {
+      if (--this.#w <= 0) {
+        if (this.#w = 0, this.#$)
+          this.#$ = !1, this.#T = !1, this.onDataChanged();
+        else if (this.#T) {
+          this.#T = !1, this.#u = !0;
+          const t = performance.now();
+          this.#e.onAxisReconfig(t), this.#y(t), this.#i.markDirty();
+        }
+        this.#O && (this.#O = !1, this.emit("overlayChange"));
+      }
+    }
+  }
+  /** Show or hide a series. The series cross-fades over
+   *  `animations.toggle`; the Y range re-fits on the same schedule
+   *  (one-shot duration override) so the fade and the axis adjustment
+   *  finish on the same frame. Hidden series are excluded from Y-range
+   *  computation immediately so the axis can start moving while the line
+   *  fades out in parallel.
+   */
+  setSeriesVisible(i, t) {
+    const e = this.#t.find((n) => n.id === i);
+    if (!e || e.visible === t) return;
+    e.visible = t, this.#S();
+    const s = this.#f.toggleMs;
+    if (e.renderer.setAlpha?.(t ? 1 : 0, s), this.#i.markDirty(), this.#w > 0) {
+      this.#T = !0;
+      return;
+    }
+    this.#u = !0;
+    const r = performance.now();
+    this.#e.onSeriesVisibilityChanged(r), this.#y(r);
+  }
+  /**
+   * Whether streaming ticks slide the visible range to track the data tail.
+   * Flipped off by a pan that pushes the tail off screen; re-engaged when
+   * a follow-up pan brings the tail back into the destination window or
+   * when {@link fitContent} / {@link setVisibleRange} commits a range
+   * containing the tail.
+   */
+  getAutoScroll() {
+    return this.#p;
+  }
+  isSeriesVisible(i) {
+    return this.#t.find((t) => t.id === i)?.visible ?? !0;
+  }
+  /**
+   * Show or hide a specific layer within a multi-layer series.
+   *
+   * Symmetric with {@link setSeriesVisible}: drives both the renderer's
+   * per-layer alpha fade and the engine's Y re-fit through `toggleMs` so the
+   * line fade and the axis adjustment finish on the same frame. Hidden layers
+   * are excluded from Y-range computation immediately (via the renderer's
+   * `getValueRange` reading `store.isVisible()`); the alpha fade keeps the
+   * layer's geometry on screen until the engine's Y ease settles.
+   */
+  setLayerVisible(i, t, e) {
+    const s = this.#t.find((h) => h.id === i);
+    if (!s || s.renderer.getLayerCount() <= 1 || s.renderer.isLayerVisible(t) === e) return;
+    s.renderer.setLayerVisible(t, e), this.#S();
+    const r = this.#f.toggleMs;
+    if (s.renderer.setLayerAlpha?.(t, e ? 1 : 0, r), this.#i.markDirty(), this.#w > 0) {
+      this.#T = !0;
+      return;
+    }
+    this.#u = !0;
+    const n = performance.now();
+    this.#e.onSeriesVisibilityChanged(n), this.#y(n);
+  }
+  isLayerVisible(i, t) {
+    return this.#t.find((e) => e.id === i)?.renderer.isLayerVisible(t) ?? !0;
+  }
+  /** Auto-fit the viewport to show all data across every series. */
+  fitContent() {
+    const { first: i, last: t } = this.getDataBounds();
+    if (i === void 0 || t === void 0) return;
+    const e = this.#n.size.media.width - this.yAxisWidth;
+    this.#M(i, t, e), this.#N({ xEase: !0 });
+  }
+  getVisibleRange() {
+    return this.#o.from === 0 && this.#o.to === 0 ? this.#e.getAnimationState().xRange : this.#o;
+  }
+  /**
+   * Return the full span of registered data, or `null` before any data has
+   * arrived. `{ from: dataStart, to: dataEnd }` mirrors the chart's own
+   * tracking and is cheaper than recomputing from series stores.
+   */
+  getDataRange() {
+    return this.#k === null || this.#s === null ? null : { from: this.#k, to: this.#s };
+  }
+  /**
+   * Imperatively set the visible time range. Three forms:
+   *
+   * - `number N` — show the last N bars from the data tail (anchor right).
+   *   Resolved against current data bounds and data interval; keeps
+   *   auto-scroll on. No-op if data hasn't loaded yet.
+   * - `{ from, to }` — explicit time range. `from`/`to` accept either
+   *   epoch milliseconds or `Date`. Cancels any in-flight animation and
+   *   applies immediately. Auto-scroll stays on only if the tail is
+   *   inside the new range (mirrors pan semantics).
+   * - `{ from, bars }` — anchor the visible window at `from` and extend
+   *   right by `bars` data intervals. Useful for warm-up windows where
+   *   seed points sit on the left and a stream fills the gap on the
+   *   right. `from` accepts a `Date` too.
+   *
+   * Typical use: on mount, zoom to the last N bars while keeping the full
+   * buffer available for pan-back history inspection.
+   *
+   * `opts.gesture` (explicit `{ from, to }` form only) eases X and Y on the
+   * same fast, velocity-matched profile a user pan/zoom uses instead of the
+   * default programmatic settle (snap X, sticky-Y ease). Use it for
+   * multi-chart sync so a synced pane tracks the originating gesture in
+   * lockstep rather than lagging behind on the long sticky contract.
+   */
+  setVisibleRange(i, t) {
+    if (typeof i == "number") {
+      if (!Number.isInteger(i) || i < 2) return;
+      const { first: n, last: h } = this.getDataBounds();
+      if (n === void 0 || h === void 0) return;
+      const a = Math.max(n, h - (i - 1) * this.#h), d = this.#n.size.media.width - this.yAxisWidth;
+      this.#M(a, h, d), this.#N();
+      return;
+    }
+    if ("bars" in i) {
+      if (!Number.isInteger(i.bars) || i.bars < 2) return;
+      const n = g(i.from), h = n + i.bars * this.#h;
+      this.#p = this.#s !== null && this.#s >= n && this.#s <= h, this.#C({ from: n, to: h }, { emitChange: !0 }), this.#L = !0, this.#N();
+      return;
+    }
+    const e = g(i.from), s = g(i.to);
+    this.#p = this.#s !== null && this.#s >= e && this.#s <= s, this.#L = !1;
+    const r = this.#C({ from: e, to: s }, { emitChange: !0 });
+    if (t?.gesture) {
+      r && this.#pt();
+      return;
+    }
+    this.#N();
+  }
+  getYRange() {
+    return this.#V;
+  }
+  getCrosshairPosition() {
+    return this.#m;
+  }
+  /**
+   * Programmatically set or clear the crosshair. Same effect as the user
+   * hovering over `(timeToX(time), valueToY(y))` — emits `crosshairMove`,
+   * marks the overlay layer dirty, and lets `<Crosshair>` / `<Tooltip>`
+   * react via their normal store subscriptions.
+   *
+   * Pass `null` to clear (mirrors the pointer-leave path).
+   *
+   * `y` is optional. Resolution order when omitted:
+   *   1. **current crosshair's y** — preserves whatever the chart already
+   *      has (real cursor y, or a previously-synthesised value). This is
+   *      what makes the cross-chart broadcast pattern work: when an echo
+   *      arrives at the chart that originated the hover, the existing y
+   *      stays in place and the idempotency check below short-circuits the
+   *      loop. Without preservation, the echo would overwrite the source's
+   *      real cursor y with the midpoint default and the tooltip would
+   *      jitter between cursor and midpoint every mouse-move.
+   *   2. **midpoint of the current Y range** — fallback when there is no
+   *      current crosshair (first programmatic set on a chart that hasn't
+   *      been hovered yet).
+   *
+   * Idempotent: a call that produces the same `(time, y)` pair as the
+   * current crosshair is a no-op (no emit). Combined with the y-preservation
+   * above, this lets N charts broadcast their hover to each other without
+   * a feedback-loop guard.
+   */
+  setCrosshair(i) {
+    if (i === null) {
+      if (this.#m === null) return;
+      this.#m = null, this.#d.markDirty(), this.emit("crosshairMove", null);
+      return;
+    }
+    const { time: t } = i;
+    if (!Number.isFinite(t)) return;
+    const e = this.#m;
+    let s;
+    if (i.y !== void 0)
+      s = i.y;
+    else if (e !== null)
+      s = e.y;
+    else {
+      const h = this.#V;
+      s = (h.min + h.max) / 2;
+    }
+    if (!Number.isFinite(s) || e !== null && e.time === t && e.y === s) return;
+    const r = this.timeScale.timeToX(t), n = this.yScale.valueToY(s);
+    this.#m = { mediaX: r, mediaY: n, time: t, y: s }, this.#d.markDirty(), this.emit("crosshairMove", this.#m);
+  }
+  /** Get the last visible value and whether the absolute last point is on screen. */
+  getLastValue(i) {
+    return B(i, this.#t, this.#e.getAnimationState().xRange);
+  }
+  /** Get the second-to-last value, useful for computing change. */
+  getPreviousClose(i) {
+    return F(i, this.#t);
+  }
+  getLastData(i) {
+    const t = this.#t.find((e) => e.id === i);
+    return !t || t.renderer.kind === "pie" ? null : t.renderer.getLastDataPoint();
+  }
+  /** Find the data point closest to the given timestamp within one data interval. */
+  getDataAtTime(i, t) {
+    const e = this.#t.find((s) => s.id === i);
+    return e ? e.renderer.getDataAtTime?.(t, this.#h) ?? null : null;
+  }
+  /**
+   * Get all layers' data at a given time for multi-layer series (Bar/Line
+   * with stacking). Each entry carries the owning `layerIndex` and the
+   * snapped sample time — callers must not derive layer identity from the
+   * array index, because hidden layers are filtered out.
+   */
+  getLayerSnapshots(i, t) {
+    const e = this.#t.find((s) => s.id === i);
+    return e?.visible ? e.renderer.getLayerSnapshots?.(t, this.#h) ?? null : null;
+  }
+  getSeriesIds() {
+    return this.#A || (this.#A = this.#t.map((i) => i.id)), this.#A.slice();
+  }
+  /**
+   * True if any visible series is non-pie (line / bar / candlestick). Used
+   * to gate crosshair rendering — a pie-only chart has no meaningful x/y
+   * coordinate system, so the dashed hairlines would just be visual noise.
+   */
+  #ut() {
+    for (const i of this.#t)
+      if (i.visible && i.renderer.kind !== "pie")
+        return !0;
+    return !1;
+  }
+  /**
+   * Filter `getSeriesIds()` by renderer type. `'pie'` returns pie series,
+   * `'time'` returns line/bar/candlestick.
+   *
+   * - `opts.visibleOnly` — exclude series with `isSeriesVisible=false`; for
+   *   multi-layer series also exclude when every layer is hidden.
+   * - `opts.singleLayerOnly` — exclude series with more than one layer.
+   *   Useful for YLabel fallback priority (stick to a single line first).
+   */
+  getSeriesIdsByType(i, t) {
+    const e = t?.visibleOnly === !0, s = t?.singleLayerOnly === !0, r = [];
+    for (const n of this.#t) {
+      const h = n.renderer.kind === "pie";
+      if (i === "pie" && !h || i === "time" && h) continue;
+      const a = n.renderer.getLayerCount();
+      if (!(s && a > 1)) {
+        if (e) {
+          if (!n.visible) continue;
+          if (a > 1) {
+            let d = !1;
+            for (let l = 0; l < a; l++)
+              if (n.renderer.isLayerVisible(l)) {
+                d = !0;
+                break;
+              }
+            if (!d) continue;
+          }
+        }
+        r.push(n.id);
+      }
+    }
+    return r;
+  }
+  /**
+   * Cumulative top last-value for stacked series — the point a YLabel badge
+   * anchors to on the rendered stack head. Falls back to `getLastValue` for
+   * series without stacked concepts (Candlestick, single-layer Line/Bar).
+   * Returns `null` for unknown ids or empty series.
+   */
+  getStackedLastValue(i) {
+    return Y(i, this.#t, this.#e.getAnimationState().xRange);
+  }
+  /**
+   * Per-layer last snapshots with each layer's own `time`. Returns `null`
+   * for single-layer renderers or when no visible layer has data. Used by
+   * overlay components that must display every layer in last-mode even
+   * when layers advance at different rates (ragged streams).
+   */
+  getLayerLastSnapshots(i) {
+    return this.#t.find((t) => t.id === i)?.renderer.getLayerLastSnapshots?.() ?? null;
+  }
+  /**
+   * Shallow view of the internal series entries so unit tests can introspect
+   * renderer state without exporting a public `getRenderer(id)` (which would
+   * leak an implementation detail). Named to discourage use outside of tests.
+   *
+   * @internal
+   */
+  listSeriesForTest() {
+    return this.#t.map((i) => ({ id: i.id, renderer: i.renderer }));
+  }
+  /** Get the primary display color for a series. */
+  getSeriesColor(i) {
+    const t = this.#t.find((e) => e.id === i);
+    return t ? t.renderer.getLayerColors()[0] ?? this.#r.line.color : null;
+  }
+  /** The series' primary name (first layer). Used for single-layer overlays. */
+  getSeriesLabel(i) {
+    return this.#t.find((t) => t.id === i)?.labels?.[0];
+  }
+  /** The display name of one layer, or `undefined` when that layer is unnamed. */
+  getLayerLabel(i, t) {
+    return this.#t.find((e) => e.id === i)?.labels?.[t];
+  }
+  /**
+   * Set every layer's display name at once (index = layer). Drives the tooltip,
+   * legend, and info bar. Called by the framework wrappers as the carried
+   * per-layer labels in `data` change. No-ops (and skips the overlay bump) when
+   * the labels are unchanged, so it's safe to call on every data tick.
+   */
+  setSeriesLabels(i, t) {
+    const e = this.#t.find((s) => s.id === i);
+    !e || I(e.labels, t) || (e.labels = t, this.#S());
+  }
+  /**
+   * Set the per-layer color overrides carried in `data` (sparse — `undefined`
+   * leaves that layer on the theme base). A {@link ValueColor} per layer: a
+   * string (uniform) or a function of value (per bar / per segment). Handed to
+   * the renderer, which keeps them separate from the theme base so a theme swap
+   * preserves them. Called by the framework wrappers; no-ops when unchanged.
+   */
+  setLayerColors(i, t) {
+    const e = this.#t.find((s) => s.id === i);
+    !e || ft(e.colorOverrides, t) || (e.colorOverrides = t, e.renderer.setColorOverrides?.(t), this.#i.markDirty(), this.#S());
+  }
+  /** Get per-layer colors for a series. Returns null for single-layer non-bar/line series. */
+  getSeriesLayers(i) {
+    const t = this.#t.find((r) => r.id === i);
+    if (!t) return null;
+    const e = t.renderer.getLayerCount();
+    if (e <= 1) return null;
+    const s = t.renderer.getLayerColors();
+    return Array.from({ length: e }, (r, n) => ({ color: s[n % s.length] }));
+  }
+  /** Get all slices with computed colors and percentages. Returns null for series without slice data (e.g. candlestick, line, bar). */
+  getSliceInfo(i) {
+    return this.#t.find((t) => t.id === i)?.renderer.getSliceInfo?.(this.#r) ?? null;
+  }
+  /** Get hover info (label/value/percent/color) for the currently hovered element, or null. */
+  getHoverInfo(i) {
+    return this.#t.find((t) => t.id === i)?.renderer.getHoverInfo?.(this.#r) ?? null;
+  }
+  /** Apply a new theme and update series colors where appropriate. */
+  setTheme(i) {
+    const t = this.#r;
+    this.#r = i;
+    for (const e of this.#t)
+      e.renderer.applyTheme(i, t);
+    this.#i.markDirty(), this.#S();
+  }
+  getTheme() {
+    return this.#r;
+  }
+  /** Update axis configuration and re-render. */
+  setAxis(i) {
+    const t = this.yAxisWidth, e = this.xAxisHeight;
+    this.#I = i, this.#a = { min: i.y?.min, max: i.y?.max }, this.#u = !0;
+    const s = performance.now();
+    this.#e.onAxisReconfig(s), this.#y(s), (this.yAxisWidth !== t || this.xAxisHeight !== e) && this.syncScales(), this.#i.markDirty();
+  }
+  /**
+   * Apply label-density knobs driven by `<YAxis labelCount=… minLabelSpacing=…>`
+   * — kept separate from {@link setAxis} so component props don't force a
+   * Y-animation reset. Triggers a viewportChange + repaint so static charts
+   * react without waiting for pan/zoom.
+   */
+  setYAxisLabelDensity(i) {
+    let t = !1;
+    "labelCount" in i && (this.yScale.setLabelCount(i.labelCount ?? null), t = !0), "minLabelSpacing" in i && (this.yScale.setMinSpacing(i.minLabelSpacing ?? null), t = !0), t && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
+  }
+  /** Label-density knobs for the time axis — mirror of {@link setYAxisLabelDensity}. */
+  setTimeAxisLabelDensity(i) {
+    let t = !1;
+    "labelCount" in i && (this.timeScale.setLabelCount(i.labelCount ?? null), t = !0), "minLabelSpacing" in i && (this.timeScale.setMinSpacing(i.minLabelSpacing ?? null), t = !0), t && (this.syncScales(), this.emit("viewportChange"), this.#i.markDirty());
+  }
+  getMediaSize() {
+    return this.#n.size.media;
+  }
+  /** Returns layout metrics for the chart area, Y axis, and time axis. */
+  getLayout() {
+    const i = this.#n.size.media, t = this.yAxisWidth, e = this.xAxisHeight;
+    return {
+      chartArea: { x: 0, y: 0, width: i.width - t, height: i.height - e },
+      yAxisWidth: t,
+      xAxisHeight: e
+    };
+  }
+  getDataInterval() {
+    return this.#h;
+  }
+  /**
+   * Update viewport padding at runtime. Refits the visible time range to
+   * current data bounds **only when horizontal padding (left/right) changes**
+   * — vertical padding only affects the Y-range computation, so touching it
+   * shouldn't reset the user's zoom / auto-scroll state. This matters when
+   * a wrapper re-applies padding reactively (e.g. in response to a Title /
+   * InfoBar ResizeObserver).
+   */
+  setPadding(i) {
+    const t = this.#l;
+    this.#l = D(i);
+    const e = this.#l, s = !C(t.left, e.left) || !C(t.right, e.right), r = t.top !== e.top || t.bottom !== e.bottom;
+    if (s) {
+      const { first: n, last: h } = this.getDataBounds();
+      if (n !== void 0 && h !== void 0) {
+        const a = this.#n.size.media.width - this.yAxisWidth;
+        this.#M(n, h, a);
+      }
+    }
+    if (s || r) {
+      this.#u = !0;
+      const n = performance.now();
+      this.#e.onAxisReconfig(n), this.#y(n);
+    }
+    this.syncScales(), this.#i.markDirty(), r && this.emit("viewportChange");
+  }
+  /** Show or hide the background grid. Takes effect on the next render frame. */
+  setGrid(i) {
+    this.#E = i.visible, this.#i.markDirty();
+  }
+  /**
+   * Set the visual state for one side of the chart. Typically called in
+   * response to the `onEdgeReached` callback:
+   *   - `loading` while a history fetch is in flight,
+   *   - `no-data` once the fetch confirmed there's nothing more,
+   *   - `idle` when the host no longer wants any edge affordance.
+   * The state persists until replaced. `has-more` is accepted for API
+   * symmetry and currently renders identically to `idle`.
+   */
+  setEdgeState(i, t) {
+    this.#b[i] !== t && (this.#b[i] = t, this.#d.markDirty());
+  }
+  /** Read the current host-declared state for a given edge. */
+  getEdgeState(i) {
+    return this.#b[i];
+  }
+  /**
+   * Notify chart that a YLabel overlay is mounted / unmounted. Currently a
+   * no-op — placeholder for the right-padding reflow that will adjust the
+   * chart area to make room for the badge.
+   * TODO: implement reflow.
+   */
+  setYLabel(i) {
+  }
+  /**
+   * Dispatch a crosshair move to every renderer that supports spatial hover
+   * (currently: pie). Any change in hover index schedules a main-layer redraw.
+   */
+  #ft(i) {
+    const t = this.#n.size, e = this.#l, s = {
+      top: e.top * t.verticalPixelRatio,
+      bottom: e.bottom * t.verticalPixelRatio
+    };
+    let r = !1;
+    for (const n of this.#t) {
+      if (!n.renderer.hitTest || !n.renderer.setHoverIndex) continue;
+      let h = -1;
+      if (i) {
+        const a = i.mediaX * t.horizontalPixelRatio, d = i.mediaY * t.verticalPixelRatio;
+        h = n.renderer.hitTest(a, d, t.bitmap.width, t.bitmap.height, s);
+      }
+      n.renderer.setHoverIndex(h) && (r = !0);
+    }
+    r && this.#i.markDirty();
+  }
+  /** Tear down the chart: cancel animations, remove listeners, and detach the canvas. */
+  destroy() {
+    for (const i of this.#t) i.renderer.dispose();
+    this.#t = [], this.#c = [], this.#v = [], this.#g = [], this.#A = null, this.#i.destroy(), this.#d.destroy(), this.#W?.destroy(), this.#n.destroy(), this.#F?.destroy(), this.#F = null, this.#B && this.#x?.destroy(), this.#x = null, this.#B = !1, this.removeAllListeners();
+  }
+  /** The attached performance monitor, or `null` when instrumentation is disabled. */
+  getPerfMonitor() {
+    return this.#x;
+  }
+  /** Compute the earliest and latest timestamps across all series. */
+  getDataBounds() {
+    let i, t;
+    for (const e of this.#t) {
+      if (!e.visible || e.renderer.kind === "pie") continue;
+      const s = e.renderer.getTimeBounds();
+      s !== null && ((i === void 0 || s.first < i) && (i = s.first), (t === void 0 || s.last > t) && (t = s.last));
+    }
+    return { first: i, last: t };
+  }
+  /** Set by `setSeriesData`/bulk-replace paths so the next `onDataChanged`
+   * snaps the Y range (instead of easing) and `yScale.getRange()` reflects
+   * the new domain synchronously. Cleared by `onDataChanged` after each run. */
+  #Y = !1;
+  onDataChanged() {
+    if (this.#w > 0) {
+      this.#$ = !0;
+      return;
+    }
+    this.updateDataInterval();
+    const { first: i, last: t } = this.getDataBounds();
+    i !== void 0 && (this.#k = i), t !== void 0 && (this.#P = this.#s, this.#s = t);
+    const e = this.#Y;
+    this.#Y = !1;
+    const s = !this.#u && i !== void 0;
+    e && (this.yScale.tickTracker.reset(), this.timeScale.tickTracker.reset()), this.#K = e;
+    const r = performance.now();
+    e || s ? (this.#D.seed(r), this.#e.onDataReplaced(r)) : this.#e.onPointAppended(r), this.#e.lastXTarget !== null && (this.#R = !0), i !== void 0 && (this.#u = !0), this.#y(r), this.syncScales(), s ? this.#U() : this.#i.markDirty(), this.emit("dataUpdate"), this.#S();
+  }
+  updateDataInterval() {
+    for (const i of this.#t) {
+      if (i.renderer.kind === "pie") continue;
+      const t = i.renderer.sampleTimes(20);
+      if (t.length >= 2) {
+        this.#h = lt(t);
+        break;
+      }
+    }
+  }
+  /** Whether the Y range has been initialized (first snap vs smooth lerp).
+   *  Pre-init Y emits are forced to `instant` so the first paint snaps to
+   *  data regardless of the caller's requested kind. Also reset by paths
+   *  that intentionally invalidate the current Y baseline (axis bound
+   *  change, empty viewport). */
+  #u = !1;
+  /** Whether the engine's X slot has received its first emit. Pre-init X
+   *  emits are forced to `instant` so first paint snaps to the fitted
+   *  range — without this guard the engine would ease from `{0,0}` into
+   *  the new target and the very first frame would render with a
+   *  zero-width X domain. */
+  #R = !1;
+  /**
+   * One-shot `setVisibleRange` argument applied on the first data arrival.
+   * Captured at chart construction from {@link ChartOptions.viewport.initialRange};
+   * cleared the moment it's consumed so subsequent data swaps don't snap
+   * back to the initial window.
+   */
+  #H;
+  /** Last Y bounds the engine resolved into {@link AnimationState.yRange}.
+   *  Used by {@link renderMain} to detect Y movement frame-to-frame so
+   *  `viewportChange` only emits when the Y range actually shifted — DOM
+   *  axis labels subscribe to that event and re-renders on every tick are
+   *  expensive. Initialised to NaN so the first real Y emit always passes
+   *  the change check. */
+  #X = Number.NaN;
+  #_ = Number.NaN;
+  /**
+   * Sample the visible data window and return the resolved Y bounds, 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(i) {
+    const t = i ?? this.#o, e = this.#a.min !== void 0 && this.#a.min !== "auto" && typeof this.#a.min != "number" || this.#a.max !== void 0 && this.#a.max !== "auto" && typeof this.#a.max != "number" ? [] : null, s = q(t, this.#t, e);
+    if (s === null)
+      return this.#u = !1, null;
+    const r = R(this.#a.min, s.min, s.max, e ?? [], "min"), n = R(this.#a.max, s.max, s.min, e ?? [], "max");
+    return { min: r, max: n };
+  }
+  /**
+   * Engine pull-on-demand X target. Called by the engine's `computeXTarget`
+   * closure during `engine.onPointAppended` / `engine.onDataReplaced`.
+   * Reads `#dataStart` / `#dataEnd` (refreshed by `onDataChanged` just
+   * before the engine signal) plus `#pendingFitToData` flag, then dispatches:
+   *
+   * - **uninit (viewport never committed)** → fit to data, apply any
+   *   one-shot `initialVisibleRange`, return the new logical range.
+   *   First-paint fit.
+   * - **bulk replace + autoscroll** (`#pendingFitToData`) → fit to data,
+   *   return logical. `chart.setSeriesData(...)` lands here.
+   * - **streaming append + autoscroll** → `computeStreamingTarget` (preserves
+   *   any pan offset across ticks via `#prevDataEnd`). The engine's X spring
+   *   absorbs the new target — velocity carries across retargets so a burst
+   *   of ticks doesn't restart easing on each one.
+   * - **autoscroll off** → `null` (no X retarget; user has panned away
+   *   from the tail).
+   */
+  #gt() {
+    if (this.#k === null || this.#s === null) return null;
+    const { from: i, to: t } = this.#o, e = i === 0 && t === 0, s = this.#n.size.media.width - this.yAxisWidth;
+    if (e)
+      return this.#M(this.#k, this.#s, s), this.#H !== void 0 && (this.setVisibleRange(this.#H), this.#H = void 0), this.#o;
+    if (!this.#p) return null;
+    if (this.#K)
+      return this.#M(this.#k, this.#s, s), this.#o;
+    const r = j({
+      currentLogical: this.#o,
+      lastTime: this.#s,
+      prevDataEnd: this.#P,
+      dataInterval: this.#h,
+      paddingRight: this.#l.right,
+      chartWidth: s,
+      holdUntilFilled: this.#L
+    });
+    return r.releaseHold && (this.#L = !1), r.reengageAutoScroll && (this.#p = !0), r.newLogical === null ? null : (this.#D.observe(performance.now()), this.#e.setXSettleMs(this.#D.pickSettleMs(this.#f.axis.x.settleMs)), this.#C(r.newLogical, { emitChange: !1, skipValidation: !0 }), this.#P = this.#s, r.newLogical);
+  }
+  /**
+   * Fit the viewport's logical X range around a data span. Mirrors the
+   * old `viewport.fitToData` side effects: clears the warm-up hold,
+   * forces autoscroll on (data tail is in the new window by construction),
+   * commits the new range via `viewport.setRange` (which emits `change`).
+   */
+  #M(i, t, e) {
+    const s = this.#l, r = O({
+      firstTime: i,
+      lastTime: t,
+      dataInterval: this.#h,
+      maxVisibleBars: this.#Q,
+      chartWidth: e,
+      padding: { left: s.left, right: s.right }
+    });
+    this.#L = !1, this.#p = !0, this.#C(r, { emitChange: !0 });
+  }
+  /**
+   * Commit a programmatic zoom — `fitContent` or `setVisibleRange`. Reads
+   * the viewport's just-committed logical range as the X target; pulls
+   * the matching Y target via the engine's `computeYTarget` callback so
+   * the axis re-fits to the new window without the chart having to wire
+   * Y separately.
+   *
+   * - First paint (`#xInited` or `#yInited` not yet set) → both axes snap
+   *   so consumers reading `chart.getYRange()` / `chart.getVisibleRange()`
+   *   synchronously after mount see the final values.
+   * - Otherwise X snaps and Y eases on the sticky baseline. `fitContent`
+   *   passes `xEase: true` so X eases instead — viewport and axis converge
+   *   on the same frame.
+   */
+  #N(i) {
+    const t = this.#o;
+    if (t.to <= t.from) return;
+    const e = performance.now();
+    if (!this.#R || !this.#u) {
+      this.#rt(e);
+      return;
+    }
+    this.#e.onProgrammaticZoom({ xTarget: t, xEase: i?.xEase }, e), this.#y(e);
+  }
+  /**
+   * Commit the current logical X to the engine on the *gesture* profile:
+   * X and Y both ease over `animations.axis.{x,y}.gesture` via `onPanZoom`,
+   * exactly the path a user pan/zoom takes. Contrast {@link
+   * #commitProgrammaticZoom}, which snaps X and eases Y on the slower
+   * sticky-Y baseline.
+   *
+   * Used by `setVisibleRange(..., { gesture: true })` for multi-chart sync,
+   * so a synced pane re-fits its Y in lockstep with the originating gesture
+   * instead of lagging on the long sticky contract. First paint still snaps
+   * (same as the programmatic path) so synchronous readers see final values.
+   */
+  #pt() {
+    const i = this.#o;
+    if (i.to <= i.from) return;
+    const t = performance.now();
+    if (!this.#R || !this.#u) {
+      this.#rt(t);
+      return;
+    }
+    this.#e.onPanZoom({ xTarget: i, yAuto: !0 }, t), this.#y(t);
+  }
+  /**
+   * First-paint snap: land both axes on the current logical X immediately
+   * (Y via {@link #computeYTarget}) and flip the init flags so later commits
+   * ease instead of snapping. Shared by the programmatic and gesture zoom
+   * commits — both must snap before the chart has painted once so a
+   * synchronous `getYRange()` / `getVisibleRange()` read sees final values.
+   */
+  #rt(i) {
+    const t = this.#o, e = this.#st(t);
+    this.#R = !0, e !== null && (this.#u = !0), this.#e.snap({ x: t, y: e ?? void 0 }, i), this.#y(i);
+  }
+  /**
+   * Validate and commit a new logical X range. Mirrors the old
+   * `Viewport.applyLogical` contract: silently no-ops on invalid input
+   * (`to <= from`, fewer than 2 bars), then writes `#logical` and (if
+   * `opts.emitChange` is true) wakes the render loop + emits
+   * `viewportChange` for DOM subscribers.
+   *
+   * Streaming-target writes pass `emitChange: false` because the engine
+   * drives the animation: `engine.onWake` already markedDirty, and the
+   * follow-up `renderMain` syncs scales — a redundant `viewportChange`
+   * emit here would just trigger a wasted React re-render per stream tick.
+   *
+   * Returns `true` when the range actually changed (passed validation and
+   * differed from the current logical), `false` on a no-op. Callers that
+   * drive the engine afterwards can skip a redundant retarget on `false` —
+   * see `setVisibleRange`'s gesture path, where a per-frame echo would
+   * otherwise re-arm and stall the in-flight Y ease.
+   */
+  #C(i, t) {
+    const { from: e, to: s } = i;
+    return !Number.isFinite(e) || !Number.isFinite(s) || s <= e || !t.skipValidation && (s - e) / this.#h < 2 || this.#o.from === e && this.#o.to === s ? !1 : (this.#o = { from: e, to: s }, t.emitChange && (this.syncScales(), this.#i?.markDirty(), this.emit("viewportChange")), !0);
+  }
+  /**
+   * Apply pixel-padding to the engine's raw Y target and store the
+   * result in `#yRange`. Mirrors the old `Viewport.setYRange` contract:
+   * symmetric pad top / bottom from `#padding`, suppressed on the side
+   * that has an explicit (fixed) axis bound.
+   */
+  #nt(i, t, e, s, r) {
+    const n = t - i, h = e > 0 ? this.#l.top / e * n : 0, a = e > 0 ? this.#l.bottom / e * n : 0;
+    this.#V = {
+      min: s ? i : i - a,
+      max: r ? t : t + h
+    };
+  }
+  /**
+   * Shift the visible time range by `timeDelta` ms. Hard-clamped so at
+   * least one data point stays on screen — no rubber-band, no overshoot.
+   * A pan that moves the viewport off the live-tail position flips
+   * autoscroll off. Fires `edgeReached` whenever the clamp trims the
+   * gesture (i.e., the user pushed past the boundary), so consumers can
+   * trigger history loads. Forwards the committed target to the engine
+   * as a gesture for visual easing. Public so consumers can drive pan
+   * programmatically.
+   */
+  pan(i, t = this.#z) {
+    t > 0 && (this.#z = t), this.#L = !1;
+    const e = U({
+      currentLogical: this.#o,
+      timeDelta: i,
+      chartWidth: t,
+      dataInterval: this.#h,
+      padding: { left: this.#l.left, right: this.#l.right },
+      dataStart: this.#k,
+      dataEnd: this.#s
+    });
+    e.newLogical !== null && (this.#p = !e.autoScrollOff, this.#C(e.newLogical, { emitChange: !0 }), e.edgeReached !== null && (this.#j[e.edgeReached.side] = e.edgeReached.boundaryTime, this.#q?.(e.edgeReached)), this.#D.pause(), this.#ht());
+  }
+  /**
+   * Zoom around a time anchor. `factor < 1` zooms in, `> 1` zooms out.
+   * In historical mode the window anchors to `centerTime` (cursor-driven).
+   * Zoom-out is hard-capped at the padded data span. Forwards the committed
+   * target to the engine as a gesture for visual easing. Public so consumers
+   * can drive zoom programmatically.
+   *
+   * Sticky-follow: while `#autoScroll` is on, the new window is repositioned
+   * so its right edge sits at `dataEnd + paddingRight` (follow position).
+   * Span (zoom level) from `computeZoom` is preserved; only the position
+   * is locked to the tail. This avoids the next-tick `computeStreamingTarget`
+   * offset clamp (which would otherwise slide X left to the follow position
+   * and produce a visible jump). Cursor-anchored zoom is intentionally
+   * sacrificed in follow-live mode — pan first to inspect history.
+   */
+  zoomAt(i, t, e = this.#z) {
+    e > 0 && (this.#z = e), this.#L = !1;
+    const s = Z({
+      currentLogical: this.#o,
+      centerTime: i,
+      factor: t,
+      chartWidth: e,
+      dataInterval: this.#h,
+      padding: { left: this.#l.left, right: this.#l.right },
+      dataStart: this.#k,
+      dataEnd: this.#s
+    });
+    if (s.newLogical === null) return;
+    let r = s.newLogical;
+    if (this.#p && this.#s !== null) {
+      const n = r.to - r.from, h = T(this.#l.right, n, this.#h, e), a = this.#s + h;
+      r = { from: a - n, to: a }, this.#P = this.#s;
+    }
+    this.#C(r, { emitChange: !0 }), this.#D.pause(), this.#ht();
+  }
+  /**
+   * Common tail for `pan` / `zoomAt`: routes the just-committed `#logical`
+   * to the engine as a gesture so the X spring retargets and the Y spring
+   * eases over `animations.axis.y.gesture`.
+   */
+  #ht() {
+    const i = this.#o;
+    if (i.to <= i.from) return;
+    this.#R = !0, this.#u = !0;
+    const t = performance.now();
+    this.#e.onPanZoom({ xTarget: i, yAuto: !0 }, t), this.#y(t);
+  }
+  /**
+   * Tick the engine at the given wall clock and push the resolved X / Y
+   * ranges into the viewport + scales. Called from every emit path so that
+   * synchronous readers (`chart.getYRange()`, `chart.getVisibleRange()`
+   * immediately after `setSeriesData` / `setSeriesVisible`) see the new
+   * values without waiting for the next RAF — matches the legacy contract
+   * pinned by `data-update-sync`, `visibility-batch`, and the `y-label`
+   * repositioning tests.
+   *
+   * The caller passes the same wall it used as the event's `startWall` so
+   * `effectiveNow === startWall` and the prune step keeps zero-duration
+   * events long enough for the slot processor to snap them.
+   */
+  #y(i) {
+    const t = this.#e.tick(i), e = this.#n.size;
+    if (e.media.width === 0 || e.media.height === 0) return;
+    const s = this.#a.min !== void 0 && this.#a.min !== "auto", r = this.#a.max !== void 0 && this.#a.max !== "auto", n = e.media.height - this.xAxisHeight;
+    this.#nt(t.yRange.min, t.yRange.max, n, s, r), this.#X = t.yRange.min, this.#_ = t.yRange.max, this.syncScales();
+  }
+  /**
+   * Lightweight scale sync: updates timeScale/yScale from current viewport state
+   * without advancing the Y smoothing animation. Called from the viewport 'change'
+   * handler, so DOM axis components always read fresh coordinates on re-render.
+   */
+  syncScales() {
+    const i = this.#n.size;
+    if (i.media.width === 0 || i.media.height === 0) return;
+    const t = i.media.width - this.yAxisWidth, e = i.media.height - this.xAxisHeight;
+    this.timeScale.update(
+      this.#e.getAnimationState().xRange,
+      t,
+      i.horizontalPixelRatio,
+      this.#h
+    ), this.yScale.update(this.#V, e, i.verticalPixelRatio);
+  }
+  /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
+  renderMain(i) {
+    const t = this.#n.size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    const e = typeof i == "number" ? i : performance.now(), s = this.#e.tick(e);
+    s.animating && this.#i.markDirty();
+    const r = s.yRange.min, n = s.yRange.max, h = r !== this.#X || n !== this.#_;
+    if (h) {
+      const c = this.#a.min !== void 0 && this.#a.min !== "auto", o = this.#a.max !== void 0 && this.#a.max !== "auto", f = t.media.height - this.xAxisHeight;
+      this.#nt(r, n, f, c, o), this.#X = r, this.#_ = n;
+    }
+    if (this.syncScales(), this.#s !== null && !this.#p) {
+      const c = this.#e.lastXTarget ?? this.#o, o = c.to - c.from;
+      if (o > 0) {
+        const f = this.#n.size.media.width - this.yAxisWidth, y = T(this.#l.right, o, this.#h, f), v = this.#h * 0.5;
+        Math.abs(c.to - (this.#s + y)) < v && (this.#p = !0);
+      }
+    }
+    h && this.emit("viewportChange");
+    let a = !1, d = !1;
+    this.#n.useMainLayer((c) => {
+      const { context: o, bitmapSize: f } = c, y = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, v = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
+      o.clearRect(0, 0, f.width, f.height), o.save(), o.beginPath(), o.rect(0, 0, y, v), o.clip(), this.yScale.tickTracker.setCurrentTicks(this.yScale.niceTickValues()), this.timeScale.tickTracker.setCurrentTicks(this.timeScale.niceTickValues(this.#h).ticks), this.yScale.tickTracker.tick(e), this.timeScale.tickTracker.tick(e);
+      const S = this.yScale.tickTracker.snapshot(), b = this.timeScale.tickTracker.snapshot();
+      a = S.isAnimating, d = b.isAnimating, (S.isAnimating || b.isAnimating || s.animating) && this.emit("tickFrame"), this.#E && K({
+        scope: c,
+        timeScale: this.timeScale,
+        yScale: this.yScale,
+        theme: this.#r,
+        yTicks: S,
+        timeTicks: b
+      }), this.#ct(c, y, v);
+      const k = this.#l, P = { top: k.top, bottom: k.bottom }, w = this.#x;
+      for (const p of this.#t) {
+        const x = p.renderer.getAlpha?.() ?? (p.visible ? 1 : 0);
+        if (x <= 0) continue;
+        const L = {
+          scope: c,
+          timeScale: this.timeScale,
+          yScale: this.yScale,
+          theme: this.#r,
+          dataInterval: this.#h,
+          padding: P,
+          state: s,
+          seriesId: p.id
+        }, A = o.globalAlpha;
+        if (x < 1 && (o.globalAlpha = A * x), w) {
+          const V = performance.now();
+          p.renderer.render(L), w.recordSeries(p.id, performance.now() - V, e);
+        } else
+          p.renderer.render(L);
+        x < 1 && (o.globalAlpha = A);
+      }
+      o.restore();
+    });
+    let l = !1;
+    for (const c of this.#t)
+      if (c.renderer.needsAnimation) {
+        l = !0, this.#i.markDirty();
+        break;
+      }
+    const u = a || d;
+    !s.animating && !l && !u && (this.yScale.tickTracker.markArmed(), this.timeScale.tickTracker.markArmed());
+  }
+  /**
+   * Paint a full frame: the main layer, then the overlay synchronously on
+   * top so both land in the same browser paint. The overlay scheduler's
+   * queued frame (a crosshair move, the pulse re-arm from the previous
+   * frame) is consumed first — the synchronous paint below replaces it, so
+   * the overlay is no longer cleared + repainted twice in the same frame.
+   * `markDirty` calls made *during* `renderOverlay` (pulse, edge spinner)
+   * land after the consume and re-arm cleanly for the next frame.
+   */
+  #U(i) {
+    this.#Z("main", i, () => this.renderMain(i)), this.#d.consume(), this.#Z("overlay", i, () => this.renderOverlay(i));
+  }
+  /** Run a layer's paint, booking duration + draw calls to the perf monitor
+   *  when one is attached — keeps overlay time out of the `main` samples. */
+  #Z(i, t, e) {
+    const s = this.#x;
+    if (!s) {
+      e();
+      return;
+    }
+    s.resetDrawCalls(i);
+    const r = performance.now();
+    e(), s.recordFrame(i, performance.now() - r, t ?? r);
+  }
+  /** Cheap overlay: crosshair, nearest-point dots, pulse animation, edge indicator. */
+  renderOverlay(i) {
+    const t = this.#n.size;
+    if (t.media.width === 0 || t.media.height === 0) return;
+    let e = !1;
+    for (const h of this.#t)
+      if (h.visible && h.renderer.overlayNeedsAnimation) {
+        e = !0;
+        break;
+      }
+    this.#c.some((h) => h.pulse) && (e = !0);
+    const s = this.#b.left === "loading" || this.#b.right === "loading", r = this.#b.left !== "idle" || this.#b.right !== "idle", n = !!this.#m || e || r || this.#c.length > 0 || this.#g.length > 0;
+    if (!(!n && !this.#G)) {
+      if (this.#G = n, this.#n.useOverlayLayer((h) => {
+        if (!n) return;
+        const a = (t.media.width - this.yAxisWidth) * t.horizontalPixelRatio, d = (t.media.height - this.xAxisHeight) * t.verticalPixelRatio;
+        if (h.context.save(), h.context.beginPath(), h.context.rect(0, 0, a, d), h.context.clip(), this.#m && this.#ut()) {
+          const o = this.#m.mediaX * t.horizontalPixelRatio, f = this.#m.mediaY * t.verticalPixelRatio;
+          J(h, o, f, this.#r);
+        }
+        const l = this.#l, u = { top: l.top, bottom: l.bottom }, c = this.#e.getAnimationState();
+        for (const o of this.#t)
+          o.visible && o.renderer.drawOverlay?.({
+            scope: h,
+            timeScale: this.timeScale,
+            yScale: this.yScale,
+            theme: this.#r,
+            dataInterval: this.#h,
+            padding: u,
+            crosshair: this.#m,
+            state: c,
+            seriesId: o.id
+          });
+        this.#mt(h, a, d), this.#dt(h), r && E({
+          scope: h,
+          chartMediaHeight: t.media.height - this.xAxisHeight,
+          timeScale: this.timeScale,
+          theme: this.#r,
+          edgeStates: this.#b,
+          resolveBoundary: (o) => $(o, this.#j[o], this.getDataBounds())
+        }), h.context.restore();
+      }), e) {
+        const { from: h, to: a } = this.timeScale.getRange();
+        let d = !1;
+        for (const l of this.#t)
+          if (!(!l.visible || !l.renderer.overlayNeedsAnimation) && (l.renderer.hasOverlayContentInRange?.(h, a) ?? !0)) {
+            d = !0;
+            break;
+          }
+        if (!d) {
+          for (const l of this.#c)
+            if (l.pulse && l.time >= h && l.time <= a) {
+              d = !0;
+              break;
+            }
+        }
+        d && this.#d.markDirty();
+      }
+      s && this.#d.markDirty();
+    }
+  }
+}
+export {
+  Ot as ChartInstance
+};