@luxalgo/vela 0.7.8 → 0.8.1

package/dist/index.cjs

@@ -615,6 +615,7 @@ registerIcon("chevron-down", S('<path d="M3.5 6 8 10.5 12.5 6"/>'));
 registerIcon("chevron-up", S('<path d="M3.5 10 8 5.5 12.5 10"/>'));
 registerIcon("chevrons-right", S('<path d="m4 3.5 4.5 4.5L4 12.5"/><path d="m8.5 3.5 4.5 4.5-4.5 4.5"/>'));
 registerIcon("chevrons-left", S('<path d="M12 3.5 7.5 8l4.5 4.5"/><path d="M7.5 3.5 3 8l4.5 4.5"/>'));
+registerIcon("replay", S('<path d="M14 4.2v7.6L8.6 8z"/><path d="M7.4 4.2v7.6L2 8z"/>'));
 registerIcon("check", S('<path d="m2.8 8.4 3.4 3.4 7-7.6"/>'));
 registerIcon("close", S('<path d="m3.8 3.8 8.4 8.4M12.2 3.8l-8.4 8.4"/>'));
 registerIcon("pin", S('<path d="M5.6 2.5h4.8M6.4 2.5v3.6L4.4 8.4v.9h7.2v-.9L9.6 6.1V2.5M8 9.3v4.2"/>'));
@@ -7832,6 +7833,7 @@ var CHUNK_BARS = 1e4;
 var FIRST_PAINT_BARS = 20;
 var GAP_FACTOR = 1.5;
 var HEAL_COOLDOWN_MS = 5e3;
+var MIN_TICK_UPDATE_MS = 16;
 var EngineOrchestrator = class _EngineOrchestrator {
   constructor(container, renderer, feed, engines, config, dataControl) {
     this.renderer = renderer;
@@ -7884,6 +7886,32 @@ var EngineOrchestrator = class _EngineOrchestrator {
     this.lastHealAt = 0;
     /** The `visibilitychange` catch-up listener (removed on destroy). */
     this.onVisible = null;
+    // ── bar replay: `rawBars` holds the history up to the cursor, the rest waits here ──
+    /** Bars still hidden right of the replay cursor, oldest first; null ≡ replay off. */
+    this.replayQueue = null;
+    this.replayTimer = null;
+    this.replayPlaying = false;
+    this.replayIntervalMs = 1e3;
+    /** The depth (`market.bars`) before a replay deepened the history — restored when it ends. */
+    this.replayDepth = null;
+    /** A start is loading older history before it can cut; `seek` = a replay was running
+     *  (and left silently to deepen), so abandoning the load must announce its end. */
+    this.replayLoading = null;
+    /** A replay carried over a timeframe/session switch, between the old series' silent end
+     *  and the cut of the new one: still ACTIVE for the outside (`replayState`), resumed
+     *  at `revealedEnd` once the new bars land, unless stopped (`cancelled`) meanwhile. */
+    this.replayCarrying = null;
+    /** Intrabar prices for the bars replay reveals — null ≡ whole bars. */
+    this.replayTickSource = null;
+    /** The bar being revealed tick by tick: its stored form (what it settles on), its ticks,
+     *  the next tick to apply, the candle built so far, the volume each tick adds when the
+     *  ticks carry none, and its pacing (ticks per update, ms between updates — one play
+     *  interval per tick — and the clock time tick 0 is due at, so late timers catch up). */
+    this.replayForming = null;
+    /** Tick requests by bar time, shared by prefetch and playback; `ticks` once they landed. */
+    this.replayTickFetches = /* @__PURE__ */ new Map();
+    /** Aborts the tick requests in flight — renewed whenever the replay moves on. */
+    this.replayTickAbort = null;
     /** What the last applied bar did: refine the open candle, or open a new one (which
      *  settles the previous). Read by the `script:run` cause attribution. */
     this.barCause = "tick";
@@ -8107,6 +8135,10 @@ var EngineOrchestrator = class _EngineOrchestrator {
       const paint = (bars, final) => {
         if (this.generation !== gen || !final && bars.length === 0) return;
         if (!painted && !final && bars.length < Math.min(requested, FIRST_PAINT_BARS)) return;
+        if (painted && this.replayQueue) {
+          this.mergeHistoryIntoReplay(bars);
+          return;
+        }
         this.setBarSeries(bars, painted ? { preserveView: true } : void 0);
         if (!painted && bars.length > 0) {
           painted = true;
@@ -8249,6 +8281,36 @@ var EngineOrchestrator = class _EngineOrchestrator {
     // exactly like a timeframe change; the cache keys the sessions apart.
     next.session !== void 0 && next.session !== m.session || next.data !== void 0;
     const depthChanged = next.bars !== void 0 && next.bars !== m.bars;
+    const sameClock = identityChanged && next.data === void 0 && (next.symbol === void 0 || next.symbol === m.symbol) && (next.timeframe !== void 0 || next.session !== void 0);
+    const pending = identityChanged ? this.replayCarrying : null;
+    if (pending) {
+      this.replayCarrying = null;
+      if (!sameClock) {
+        pending.cancelled = true;
+        this.events.emit("replay:end", { reason: "market" });
+      }
+    }
+    const replayCarry = this.replayQueue && sameClock && this.rawBars.length > 0 ? { revealedEnd: this.rawBars[this.rawBars.length - 1].time + this.barIntervalMs(), playing: this.replayPlaying, cancelled: false } : pending && sameClock ? { revealedEnd: pending.revealedEnd, playing: pending.playing, cancelled: false } : null;
+    if (pending) pending.cancelled = true;
+    if (replayCarry) this.replayCarrying = replayCarry;
+    if (replayCarry && this.replayQueue) {
+      this.endReplay(null, { restore: false, resume: false });
+      const depth = this.replayDepth;
+      this.replayDepth = null;
+      if (depth && next.bars === void 0) {
+        if (depth.bars === void 0) delete m.bars;
+        else m.bars = depth.bars;
+      }
+    }
+    if (this.replayQueue && (identityChanged || depthChanged)) this.endReplay("market", { restore: !identityChanged, resume: false });
+    if (this.replayLoading && (identityChanged || depthChanged)) {
+      const depth = this.replayDepth;
+      this.abandonReplayLoad("market");
+      if (depth && next.bars === void 0) {
+        if (depth.bars === void 0) delete m.bars;
+        else m.bars = depth.bars;
+      }
+    }
     const depthOnly = depthChanged && !identityChanged && this.rawBars.length > 0 && !m.data?.length && ((next.bars ?? 0) <= this.rawBars.length || typeof this.feed.loadRange === "function");
     if (!identityChanged && !depthChanged) {
       if (typeof next.visibleRange === "string") this.setVisibleRangePreset(next.visibleRange);
@@ -8306,15 +8368,20 @@ var EngineOrchestrator = class _EngineOrchestrator {
       const from = bars[Math.max(0, idx - (carriedCount - 1))].time;
       this.renderer.setVisibleRange({ from, to: Math.max(carried.right, bars[idx].time + 1) });
     }
-    if (!depthOnly) {
+    const carry = replayCarry && !replayCarry.cancelled ? replayCarry : null;
+    const carryFrom = carry ? carry.revealedEnd - this.barIntervalMs() : 0;
+    const carryNow = carry != null && this.rawBars.length > 0 && carryFrom >= this.rawBars[0].time;
+    const replayBack = carryNow && this.resumeCarriedReplay(this.replayStart({ from: carryFrom }), carry);
+    if (!depthOnly && !replayBack) {
       this.restartNativeIndicators();
       this.restartChartTypeEngine();
       this.reexecuteIndicators();
     }
-    this.startLive();
+    if (!replayBack) this.startLive();
     if (identityChanged) {
       this.events.emit("market:changed", { symbol: m.symbol ?? "TEST", timeframe: m.timeframe ?? "60", prev: prev2 });
     }
+    if (carry && !carryNow) this.resumeCarriedReplay(this.replayStart({ from: carryFrom }), carry);
   }
   /**
    * Restart every native indicator over the new market: a `NativeIndicatorContext`
@@ -8438,6 +8505,397 @@ var EngineOrchestrator = class _EngineOrchestrator {
   historyComplete() {
     return this.historyCompletePromise;
   }
+  // ── bar replay ──────────────────────────────────────────────
+  /**
+   * Enter replay — or seek, when already replaying — keeping every bar opened at or before
+   * `opts.from` and queueing the rest. A `from` inside the loaded bars cuts at once, even
+   * while older history is still streaming in: what lands later joins the tape's head
+   * (see {@link mergeHistoryIntoReplay}) and leaves the cut alone. An older `from` waits
+   * for that load, then deepens if it still has to. Consumers restart over the cut exactly
+   * as on a market switch — their models describe bars that are now hidden — and the
+   * active chart-type engine is rebuilt without live data.
+   */
+  async replayStart(opts) {
+    if (this.rawBars.length === 0) {
+      console.warn("[vela] chart.replay.start() ignored \u2014 the chart has no bars yet");
+      return;
+    }
+    let gen = this.generation;
+    if (opts.from < this.rawBars[0].time) {
+      await this.historyCompletePromise;
+      if (this.generation !== gen || this.rawBars.length === 0) return;
+    }
+    const oldest = this.rawBars[0].time;
+    if (opts.from < oldest && this.canHeal() && typeof this.feed.loadRange === "function") {
+      const held = this.rawBars.length + (this.replayQueue?.length ?? 0);
+      const bars = held + Math.ceil((oldest - opts.from) / this.barIntervalMs()) + 1;
+      const seek = this.replayQueue !== null;
+      if (seek) this.endReplay(null, { restore: true, resume: false });
+      this.replayDepth ?? (this.replayDepth = { bars: this.config.market.bars });
+      const deepened = this.setMarket({ bars });
+      this.replayLoading = { seek };
+      await deepened;
+      gen = this.generation;
+      await this.historyCompletePromise;
+      if (!this.replayLoading || this.generation !== gen || this.rawBars.length === 0) return;
+      this.replayLoading = null;
+    }
+    this.settleFormingBar();
+    this.dropTickFetches();
+    const tape = this.replayQueue ? [...this.rawBars, ...this.replayQueue] : this.rawBars;
+    let cut = 0;
+    while (cut < tape.length && tape[cut].time <= opts.from) cut += 1;
+    cut = Math.max(1, cut);
+    if (cut >= tape.length) {
+      console.warn("[vela] chart.replay.start() ignored \u2014 no bar opens after the requested time");
+      return;
+    }
+    const wasPlaying = this.replayPlaying;
+    this.clearReplayTimer();
+    if (!this.replayQueue) this.stopLive();
+    this.replayQueue = tape.slice(cut);
+    this.setBarSeries(tape.slice(0, cut));
+    this.restartBarConsumers({ blank: true });
+    if (wasPlaying) this.events.emit("replay:pause", void 0);
+    this.events.emit("replay:start", { cursorTime: tape[cut - 1].time, remaining: this.replayQueue.length });
+    this.prefetchTicks();
+  }
+  /** Reveal the next queued bar through the live-bar path — or complete the bar forming
+   *  tick by tick; the last one ends the replay. */
+  replayStep() {
+    if (this.replayForming) {
+      this.finishFormingBar();
+      return true;
+    }
+    const queue = this.replayQueue;
+    const bar = queue?.shift();
+    if (!queue || !bar) return false;
+    this.replayTickFetches.delete(bar.time);
+    this.applyBar(bar);
+    this.completeReveal(bar);
+    this.prefetchTicks();
+    return true;
+  }
+  /**
+   * Follow up a replay carried onto a new series of the same symbol (another timeframe or
+   * session). The cut asked for keeps the bars that CLOSED by the end of what was revealed —
+   * every finer bar of the last revealed one, never a coarser bar still open at that point
+   * (no look-ahead). Once it settles: playback resumes if it was on; if the replay did not
+   * come back (nothing left after that point, or a later switch took over), it ends as a
+   * market switch would. Returns whether the replay is back already — a start with no
+   * history to wait for cuts synchronously (an async function runs up to its first await).
+   */
+  resumeCarriedReplay(start, carry) {
+    if (this.replayQueue && this.replayCarrying === carry) this.replayCarrying = null;
+    void start.then(() => {
+      if (this.replayCarrying === carry) this.replayCarrying = null;
+      if (carry.cancelled) return;
+      if (!this.replayQueue) this.events.emit("replay:end", { reason: "market" });
+      else if (carry.playing) this.replayPlay();
+    });
+    return this.replayQueue !== null;
+  }
+  replayStepUpdate() {
+    if (!this.replayQueue) return false;
+    if (this.replayForming) {
+      this.applyReplayTicks(1);
+      return true;
+    }
+    const bar = this.replayQueue[0];
+    if (!bar) return false;
+    const entry = this.replayTickSource ? this.requestTicks(bar) : null;
+    if (entry && !entry.ticks) {
+      const epoch = this.replayTickAbort;
+      void entry.done.then(() => {
+        if (!this.replayPlaying && !this.replayForming && this.replayTickAbort === epoch && this.replayQueue?.[0] === bar) this.replayStepUpdate();
+      });
+      return true;
+    }
+    if (!entry?.ticks?.length) return this.replayStep();
+    this.openFormingBar(entry.ticks, 1);
+    return true;
+  }
+  replaySetTicks(source) {
+    this.finishFormingBar();
+    this.dropTickFetches();
+    this.replayTickSource = source;
+    this.prefetchTicks();
+  }
+  replayPlay(intervalMs2) {
+    if (!this.replayQueue) return;
+    if (intervalMs2 !== void 0) {
+      if (!(Number.isFinite(intervalMs2) && intervalMs2 > 0)) {
+        console.warn(`[vela] chart.replay.play(${intervalMs2}) ignored \u2014 the interval must be a positive number of ms`);
+        return;
+      }
+      this.replayIntervalMs = intervalMs2;
+    }
+    this.clearReplayTimer();
+    this.replayPlaying = true;
+    if (this.replayForming) this.paceFormingBar(this.replayForming);
+    this.scheduleReplayStep(this.replayForming?.delayMs);
+    this.events.emit("replay:play", { intervalMs: this.replayIntervalMs });
+  }
+  replayPause() {
+    if (!this.replayPlaying) return;
+    this.clearReplayTimer();
+    this.events.emit("replay:pause", void 0);
+  }
+  replayStop() {
+    const carrying = this.replayCarrying;
+    if (carrying) {
+      carrying.cancelled = true;
+      this.replayCarrying = null;
+      this.events.emit("replay:end", { reason: "stopped" });
+    }
+    if (this.replayLoading) {
+      const depth = this.replayDepth;
+      this.abandonReplayLoad("stopped");
+      void this.setMarket({ bars: depth?.bars ?? 500 });
+      return;
+    }
+    this.endReplay("stopped", { restore: true, resume: true });
+  }
+  abandonReplayLoad(reason) {
+    const loading = this.replayLoading;
+    if (!loading) return;
+    this.replayLoading = null;
+    this.replayDepth = null;
+    if (loading.seek) this.events.emit("replay:end", { reason });
+  }
+  replayState() {
+    const active = this.replayQueue !== null;
+    return {
+      active: active || this.replayCarrying !== null,
+      // a replay carried over a switch stays on while the new bars load
+      playing: this.replayCarrying?.playing ?? this.replayPlaying,
+      cursorTime: active ? this.rawBars[this.rawBars.length - 1]?.time ?? null : null,
+      remaining: this.replayQueue?.length ?? 0,
+      nextTime: this.replayForming?.bar.time ?? this.replayQueue?.[0]?.time ?? null,
+      intervalMs: this.replayIntervalMs
+    };
+  }
+  replayBounds() {
+    const first = this.rawBars[0];
+    const last = this.replayQueue?.[this.replayQueue.length - 1] ?? this.rawBars[this.rawBars.length - 1];
+    return first && last ? { first: first.time, last: last.time } : null;
+  }
+  scheduleReplayStep(delayMs = this.replayIntervalMs) {
+    this.replayTimer = setTimeout(() => {
+      this.replayTimer = null;
+      this.replayAdvance();
+    }, delayMs);
+  }
+  /** One beat of timed playback: the forming bar's next ticks, else the next bar — whole,
+   *  or opened from its ticks (waiting for them when they have not landed yet). */
+  replayAdvance() {
+    if (!this.replayPlaying || !this.replayQueue) return;
+    const forming = this.replayForming;
+    if (forming) {
+      const due = Math.floor((now() - forming.origin) / this.replayIntervalMs) + 1;
+      this.applyReplayTicks(Math.max(forming.batch, due - forming.next));
+      if (this.replayPlaying) this.scheduleReplayStep(forming.delayMs);
+      return;
+    }
+    const bar = this.replayQueue[0];
+    if (!bar) return;
+    const entry = this.replayTickSource ? this.requestTicks(bar) : null;
+    if (entry && !entry.ticks) {
+      const epoch = this.replayTickAbort;
+      void entry.done.then(() => {
+        if (this.replayPlaying && this.replayTimer == null && this.replayTickAbort === epoch && this.replayQueue?.[0] === bar) this.replayAdvance();
+      });
+      return;
+    }
+    if (!entry?.ticks?.length) {
+      if (this.replayStep() && this.replayPlaying) this.scheduleReplayStep();
+      return;
+    }
+    this.openFormingBar(entry.ticks);
+    if (this.replayPlaying) this.scheduleReplayStep(this.replayForming?.delayMs);
+  }
+  /** Take the next queued bar off the tape and open it at its first tick (the first
+   *  `count` ticks — default: one timed update's worth). */
+  openFormingBar(ticks, count) {
+    const bar = this.replayQueue.shift();
+    const volumeEach = ticks.every((t) => t.volume === void 0) ? (bar.volume ?? 0) / ticks.length : null;
+    const forming = { bar, ticks, next: 0, candle: null, volumeEach, batch: 1, delayMs: this.replayIntervalMs, origin: 0 };
+    this.paceFormingBar(forming);
+    this.replayForming = forming;
+    this.applyReplayTicks(count ?? forming.batch);
+    this.prefetchTicks();
+  }
+  /** One tick per interval, batched when the interval is shorter than a frame; the clock
+   *  is anchored on the ticks already applied (a resume or a pace change carries on from
+   *  there, never jumps). */
+  paceFormingBar(f) {
+    f.batch = Math.max(1, Math.ceil(MIN_TICK_UPDATE_MS / this.replayIntervalMs));
+    f.delayMs = this.replayIntervalMs * f.batch;
+    f.origin = now() - Math.max(0, f.next - 1) * this.replayIntervalMs;
+  }
+  /** Fold the next `count` ticks into the forming candle; the last one settles the bar. */
+  applyReplayTicks(count) {
+    const f = this.replayForming;
+    if (!f) return;
+    let c = f.candle;
+    const stop = Math.min(f.ticks.length, f.next + count);
+    for (; f.next < stop; f.next += 1) {
+      const t = f.ticks[f.next];
+      const v = f.volumeEach ?? t.volume ?? 0;
+      const hi = Math.max(t.high ?? t.price, t.price);
+      const lo = Math.min(t.low ?? t.price, t.price);
+      if (c) {
+        c = { ...c, high: Math.max(c.high, hi), low: Math.min(c.low, lo), close: t.price, volume: (c.volume ?? 0) + v };
+      } else {
+        const open2 = t.open ?? t.price;
+        c = { time: f.bar.time, open: open2, high: Math.max(open2, hi), low: Math.min(open2, lo), close: t.price, volume: v };
+      }
+    }
+    f.candle = c;
+    if (f.next >= f.ticks.length) {
+      this.finishFormingBar();
+      return;
+    }
+    this.applyBar(c);
+    this.events.emit("replay:tick", { cursorTime: f.bar.time, index: f.next - 1, count: f.ticks.length });
+  }
+  /** Settle the forming bar on its stored values and announce it revealed. */
+  finishFormingBar() {
+    const f = this.replayForming;
+    if (!f) return;
+    this.replayForming = null;
+    this.replayTickFetches.delete(f.bar.time);
+    this.applyBar(f.bar);
+    this.events.emit("replay:tick", { cursorTime: f.bar.time, index: f.ticks.length - 1, count: f.ticks.length });
+    this.completeReveal(f.bar);
+  }
+  /** Put the forming bar back in its stored form, silently — a seek or an end rebuilds
+   *  from the tape, which must hold the stored bar. */
+  settleFormingBar() {
+    const f = this.replayForming;
+    if (!f) return;
+    this.replayForming = null;
+    this.applyBar(f.bar);
+  }
+  /**
+   * A history answer landing mid-replay (a progressive snapshot — the whole answer so far):
+   * the tape keeps its cut and its hidden queue; bars older than the tape join its head,
+   * bars newer than it join the queue's end.
+   */
+  mergeHistoryIntoReplay(bars) {
+    const queue = this.replayQueue;
+    const head = this.rawBars[0];
+    if (!queue || !head) return;
+    const tail = queue[queue.length - 1] ?? this.rawBars[this.rawBars.length - 1];
+    let older = 0;
+    while (older < bars.length && bars[older].time < head.time) older += 1;
+    let newer = bars.length;
+    while (newer > older && bars[newer - 1].time > tail.time) newer -= 1;
+    if (newer < bars.length) queue.push(...bars.slice(newer));
+    if (older > 0) {
+      this.setBarSeries([...bars.slice(0, older), ...this.rawBars], { preserveView: true });
+      this.notifySessionsBars("backfill");
+    }
+  }
+  /** A bar is fully on screen: announce it, and end the replay if it was the last. */
+  completeReveal(bar) {
+    const queue = this.replayQueue;
+    if (!queue) return;
+    this.events.emit("replay:step", { cursorTime: bar.time, remaining: queue.length });
+    if (queue.length === 0) this.endReplay("finished", { restore: true, resume: true });
+  }
+  /** Ask for the ticks of the next hidden bar ahead of time. */
+  prefetchTicks() {
+    const next = this.replayQueue?.[0];
+    if (next && this.replayTickSource) this.requestTicks(next);
+  }
+  /** The (shared) tick request of a queued bar — the source runs once per bar. */
+  requestTicks(bar) {
+    const known = this.replayTickFetches.get(bar.time);
+    if (known) return known;
+    const source = this.replayTickSource;
+    this.replayTickAbort ?? (this.replayTickAbort = new AbortController());
+    const signal = this.replayTickAbort.signal;
+    const queue = this.replayQueue ?? [];
+    const end = queue[queue.indexOf(bar) + 1]?.time ?? bar.time + this.barIntervalMs();
+    const entry = { ticks: null, done: Promise.resolve() };
+    const land = (ticks) => {
+      entry.ticks = usableTicks(ticks);
+    };
+    const fail = (e) => {
+      if (!signal.aborted) console.warn(`[vela] replay tick source failed \u2014 revealing the bar whole (${e instanceof Error ? e.message : String(e)})`);
+      land([]);
+    };
+    try {
+      const out = source(bar, { end, signal });
+      if (Array.isArray(out)) land(out);
+      else entry.done = Promise.resolve(out).then(land, fail);
+    } catch (e) {
+      fail(e);
+    }
+    this.replayTickFetches.set(bar.time, entry);
+    return entry;
+  }
+  /** Abort the tick requests in flight and forget the landed ones. */
+  dropTickFetches() {
+    this.replayTickAbort?.abort();
+    this.replayTickAbort = null;
+    this.replayTickFetches.clear();
+  }
+  clearReplayTimer() {
+    if (this.replayTimer != null) clearTimeout(this.replayTimer);
+    this.replayTimer = null;
+    this.replayPlaying = false;
+  }
+  /**
+   * Leave replay. `restore` puts the queued bars back and restarts the consumers over the
+   * full history (a market switch skips it: its load replaces everything anyway); `resume`
+   * restarts live updates and heals the bars that closed while replaying. A null reason
+   * leaves silently — a seek that re-enters right after.
+   */
+  endReplay(reason, opts) {
+    const queue = this.replayQueue;
+    if (!queue) return;
+    this.clearReplayTimer();
+    if (opts.restore) this.settleFormingBar();
+    else this.replayForming = null;
+    this.dropTickFetches();
+    this.replayQueue = null;
+    const depth = reason ? this.replayDepth : null;
+    if (reason) this.replayDepth = null;
+    if (depth) {
+      if (depth.bars === void 0) delete this.config.market.bars;
+      else this.config.market.bars = depth.bars;
+    }
+    if (opts.restore) {
+      const keep = depth ? depth.bars ?? 500 : Infinity;
+      if (queue.length > 0 || this.rawBars.length > keep) {
+        const full = [...this.rawBars, ...queue];
+        this.setBarSeries(full.length > keep ? full.slice(full.length - keep) : full);
+        this.restartBarConsumers({ blank: false });
+      } else if (this.config.live) {
+        this.restartNativeIndicators();
+        this.restartChartTypeEngine();
+      }
+    }
+    if (opts.resume && this.config.live) {
+      this.startLive();
+      const last = this.rawBars[this.rawBars.length - 1];
+      if (last && this.canHeal()) void this.healGap(last.time);
+    }
+    if (reason) this.events.emit("replay:end", { reason });
+  }
+  /**
+   * The bars were replaced by a cut or a restore of the SAME market: every consumer re-runs.
+   * A cut also blanks the mounted models first — they still paint the hidden bars' values,
+   * which must not show until the re-runs land.
+   */
+  restartBarConsumers(opts) {
+    if (opts.blank) this.blankIndicatorVisuals();
+    this.restartNativeIndicators();
+    this.restartChartTypeEngine();
+    this.reexecuteIndicators();
+  }
   /** The primary symbol as the data layer resolves it, or null if no symbol is set. */
   qualifiedSymbol() {
     const market = this.config.market;
@@ -8509,7 +8967,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
     engine.start({
       symbol: this.config.market.symbol ?? "TEST",
       timeframe: this.config.market.timeframe ?? "60",
-      live: this.config.live ?? false,
+      live: (this.config.live ?? false) && this.replayQueue === null,
       session: this.config.market.session,
       bars: () => this.bars,
       data: this.dataControl,
@@ -8635,6 +9093,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
         record.session.notifyBars(reason);
       } else if (record.native) record.native.instance.onBars();
     }
+    if (this.activeEngineStyle) this.typeEngines.get(this.activeEngineStyle)?.onBars?.();
   }
   /** Gap healing needs a ranged feed and a provider-backed series (offline `data` has no source). */
   canHeal() {
@@ -8657,10 +9116,11 @@ var EngineOrchestrator = class _EngineOrchestrator {
     try {
       const bars = await this.feed.loadRange(this.config.market, { from: fromMs });
       if (this.generation !== gen) return;
+      if (this.replayQueue) return;
       for (const b of bars) this.applyBar(b, false);
     } catch {
     } finally {
-      if (this.generation === gen) {
+      if (this.generation === gen && !this.replayQueue) {
         this.healing = false;
         const pending = this.healBuffer;
         this.healBuffer = [];
@@ -8965,6 +9425,13 @@ var EngineOrchestrator = class _EngineOrchestrator {
   destroy() {
     this.bumpGeneration();
     this.resolveHistoryComplete();
+    this.clearReplayTimer();
+    this.replayQueue = null;
+    this.replayForming = null;
+    this.replayCarrying = null;
+    this.dropTickFetches();
+    this.replayDepth = null;
+    this.replayLoading = null;
     this.stopLive();
     if (this.viewportTimer != null) clearTimeout(this.viewportTimer);
     this.viewportUnsub?.();
@@ -9063,6 +9530,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
           this.emitScriptRun(id, cause, first);
         },
         onAlert: (a) => {
+          if (this.replayQueue || this.replayCarrying) return;
           const indicator = record.options?.title ?? record.prepared?.meta.title ?? record.title;
           this.events.emit("alert", { ...a, indicator });
           handle.emit("alert", { id: a.id, message: a.message, title: a.title, time: a.time });
@@ -9089,7 +9557,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
         id,
         symbol: this.config.market.symbol ?? "TEST",
         timeframe: this.config.market.timeframe ?? "60",
-        live: this.config.live,
+        live: this.config.live && this.replayQueue === null,
         session: this.config.market.session,
         bars: () => this.bars,
         data: this.dataControl,
@@ -9492,17 +9960,17 @@ var EngineOrchestrator = class _EngineOrchestrator {
   }
   emitContextChanged(id) {
     if (!this.registry.get(id)?.session?.getContext) return;
-    const now = Date.now();
-    if (now - (this.contextEmitAt.get(id) ?? 0) < 1e3) return;
-    this.contextEmitAt.set(id, now);
+    const now2 = Date.now();
+    if (now2 - (this.contextEmitAt.get(id) ?? 0) < 1e3) return;
+    this.contextEmitAt.set(id, now2);
     this.events.emit("context:changed", { id });
   }
   emitScriptRun(id, cause, first) {
     const record = this.registry.get(id);
     if (!record || record.native || !this.events.hasListeners("script:run")) return;
-    const now = Date.now();
-    if (cause === "tick" && now - (this.runEmitAt.get(id) ?? 0) < RUN_EMIT_THROTTLE_MS) return;
-    this.runEmitAt.set(id, now);
+    const now2 = Date.now();
+    if (cause === "tick" && now2 - (this.runEmitAt.get(id) ?? 0) < RUN_EMIT_THROTTLE_MS) return;
+    this.runEmitAt.set(id, now2);
     void Promise.resolve().then(() => this.buildScriptRun(record, cause, first)).then((run) => {
       if (run && this.registry.get(id)) this.events.emit("script:run", run);
     });
@@ -9555,6 +10023,16 @@ var EngineOrchestrator = class _EngineOrchestrator {
     handle?.emit("error", { error });
   }
 };
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function usableTicks(value) {
+  if (!Array.isArray(value)) return [];
+  const optional = (n) => n === void 0 || Number.isFinite(n);
+  return value.filter(
+    (t) => t != null && Number.isFinite(t.price) && optional(t.volume) && optional(t.high) && optional(t.low) && optional(t.open)
+  );
+}
 function yieldToPaint() {
   if (typeof requestAnimationFrame === "function") {
     return new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve())));
@@ -9755,6 +10233,12 @@ var RendererControl = class {
   onCrosshairMove(cb) {
     return this.renderer.onCrosshairMove(cb);
   }
+  /** A click — or a touch tap — on the plot, never the end of a pan: the open time of
+   *  the bar under it (`null` off the bars). On touch, where a tap moves no crosshair,
+   *  this is how an interaction learns which bar was chosen. */
+  onClick(cb) {
+    return this.renderer.onClick(cb);
+  }
   /** Touch long-press on a price or time axis strip — silent no-op without the seam. */
   onAxisLongPress(cb) {
     return this.renderer.onAxisLongPress?.(cb) ?? (() => void 0);
@@ -10830,11 +11314,76 @@ var MarksControl = class {
   }
 };
 
+// src/core/ReplayControl.ts
+var ReplayControl = class {
+  constructor(ctrl) {
+    this.ctrl = ctrl;
+  }
+  /**
+   * Enter replay (or seek, when already replaying) at `opts.from`. Resolves once the
+   * chart shows the rewound history — after any in-flight history load has finished.
+   * Starts paused; call {@link play} or {@link step}.
+   */
+  start(opts) {
+    return this.ctrl.replayStart(opts);
+  }
+  /** Reveal the next bar — or, mid-way through a bar played tick by tick, complete it.
+   *  Returns false when replay is off or nothing is left. */
+  step() {
+    return this.ctrl.replayStep();
+  }
+  /** Reveal the next UPDATE: with {@link setTicks}, the next tick of the forming bar — or
+   *  the next bar opened at its first tick (once its ticks are in, if still loading);
+   *  otherwise the next whole bar, like {@link step}. Returns false when nothing is left. */
+  stepUpdate() {
+    return this.ctrl.replayStepUpdate();
+  }
+  /** Reveal one bar (one tick, with {@link setTicks}) every `intervalMs` (default: the last
+   *  interval used, else 1000). Calling it again while playing changes the pace. */
+  play(intervalMs2) {
+    this.ctrl.replayPlay(intervalMs2);
+    return this;
+  }
+  pause() {
+    this.ctrl.replayPause();
+    return this;
+  }
+  /** Leave replay: the full history comes back and live updates resume. Also cancels a
+   *  `start()` still loading older history (the chart returns to its previous depth). */
+  stop() {
+    this.ctrl.replayStop();
+    return this;
+  }
+  get state() {
+    return this.ctrl.replayState();
+  }
+  /** The loaded history a replay can walk — hidden bars included while replaying. Null
+   *  before any bar loaded. A start older than `first` deepens the history first. */
+  get bounds() {
+    return this.ctrl.replayBounds();
+  }
+  /**
+   * Play each revealed bar as a series of intrabar updates instead of whole: while
+   * playing, the forming candle opens at the first tick, then every tick moves its close
+   * and stretches its high and low, exactly like a live tick — indicators, chart types
+   * and the `bar` event follow — and the last one settles it on the stored bar. The play
+   * interval is then the time between two TICKS: a bar lasts as many intervals as it
+   * has ticks (below ~16 ms, ticks are batched per frame). The next bar's ticks are
+   * requested while the current one plays; playback waits for them. `null` goes back to
+   * whole bars. Takes effect from the next bar; a bar forming when the source changes
+   * completes at once.
+   */
+  setTicks(source) {
+    this.ctrl.replaySetTicks(source);
+    return this;
+  }
+};
+
 // src/core/util/wall-clock.ts
 var BOUNDARY_SLACK_MS = 5;
 var SecondClock = class _SecondClock {
-  constructor(now = () => Date.now()) {
-    this.now = now;
+  constructor(now2 = () => Date.now()) {
+    this.now = now2;
     this.subs = /* @__PURE__ */ new Set();
     this.timer = null;
   }
@@ -10850,15 +11399,15 @@ var SecondClock = class _SecondClock {
     };
   }
   /** Milliseconds from `now` to just past the next second boundary. */
-  static delayToNextSecond(now) {
-    const intoSecond = (now % 1e3 + 1e3) % 1e3;
+  static delayToNextSecond(now2) {
+    const intoSecond = (now2 % 1e3 + 1e3) % 1e3;
     return 1e3 - intoSecond + BOUNDARY_SLACK_MS;
   }
   arm() {
     this.timer = setTimeout(() => {
       this.timer = null;
-      const now = this.now();
-      for (const cb of this.subs) cb(now);
+      const now2 = this.now();
+      for (const cb of this.subs) cb(now2);
       if (this.subs.size > 0) this.arm();
     }, _SecondClock.delayToNextSecond(this.now()));
   }
@@ -12519,6 +13068,264 @@ var Dialog = class {
   }
 };
 
+// src/ui/components/date-picker/controller.ts
+var MONTH_LABELS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var MONTH_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var WEEKDAY_LABELS = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"];
+function isoDate(d) {
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function normalizeDateInput(raw) {
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(raw.trim());
+  if (!m) return null;
+  const y = Number(m[1]);
+  const mo = Number(m[2]);
+  const d = Number(m[3]);
+  const dt = new Date(y, mo - 1, d);
+  if (dt.getFullYear() !== y || dt.getMonth() !== mo - 1 || dt.getDate() !== d) return null;
+  return isoDate(dt);
+}
+function parseIsoDate(raw) {
+  const iso = raw ? normalizeDateInput(raw) : null;
+  if (!iso) return null;
+  const [y, mo, d] = iso.split("-").map(Number);
+  return new Date(y, mo - 1, d);
+}
+function datePickerController(opts = {}) {
+  const today = opts.today ?? /* @__PURE__ */ new Date();
+  let selected = parseIsoDate(opts.value);
+  let year = selected?.getFullYear() ?? today.getFullYear();
+  let month = selected?.getMonth() ?? today.getMonth();
+  let panel = "date";
+  const decade = () => Math.floor(year / 10) * 10;
+  return {
+    get panel() {
+      return panel;
+    },
+    get year() {
+      return year;
+    },
+    get month() {
+      return month;
+    },
+    get value() {
+      return selected ? isoDate(selected) : null;
+    },
+    header() {
+      return {
+        month: MONTH_LABELS[month] ?? "",
+        monthVisible: panel === "date",
+        year: panel === "year" ? `${decade()}-${decade() + 9}` : String(year),
+        yearDisabled: panel === "year"
+        // in the decade panel the year reads as its title
+      };
+    },
+    navLabels() {
+      if (panel === "date") return { prev: "Previous month", next: "Next month" };
+      if (panel === "month") return { prev: "Previous year", next: "Next year" };
+      return { prev: "Previous decade", next: "Next decade" };
+    },
+    cells() {
+      const out = [];
+      if (panel === "date") {
+        const startPad = new Date(year, month, 1).getDay();
+        const days = new Date(year, month + 1, 0).getDate();
+        const todayIso = isoDate(today);
+        const selectedIso = selected ? isoDate(selected) : "";
+        for (let i = 0; i < startPad; i++) out.push({ label: "", value: "", checked: false, today: false, blank: true });
+        for (let day = 1; day <= days; day++) {
+          const iso = `${year}-${String(month + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+          out.push({ label: String(day), value: iso, checked: iso === selectedIso, today: iso === todayIso });
+        }
+        return out;
+      }
+      if (panel === "month") {
+        for (let m = 0; m < 12; m++) {
+          out.push({
+            label: MONTH_SHORT[m] ?? "",
+            value: m,
+            checked: selected?.getFullYear() === year && selected.getMonth() === m,
+            today: today.getFullYear() === year && today.getMonth() === m
+          });
+        }
+        return out;
+      }
+      const d = decade();
+      for (let y = d - 1; y <= d + 10; y++) {
+        out.push({ label: String(y), value: y, checked: selected?.getFullYear() === y, today: today.getFullYear() === y, outside: y < d || y > d + 9 });
+      }
+      return out;
+    },
+    step(dir) {
+      if (panel === "date") {
+        month += dir;
+        if (month < 0) {
+          month = 11;
+          year -= 1;
+        }
+        if (month > 11) {
+          month = 0;
+          year += 1;
+        }
+      } else {
+        year += panel === "month" ? dir : dir * 10;
+      }
+    },
+    showMonths() {
+      panel = "month";
+    },
+    showYears() {
+      panel = "year";
+    },
+    choose(cell) {
+      if (cell.blank) return null;
+      if (panel === "date") {
+        selected = parseIsoDate(String(cell.value));
+        return selected ? isoDate(selected) : null;
+      }
+      if (panel === "month") {
+        month = Number(cell.value);
+        panel = "date";
+        return null;
+      }
+      year = Number(cell.value);
+      panel = "month";
+      return null;
+    },
+    setValue(value) {
+      selected = parseIsoDate(value);
+      if (selected) {
+        year = selected.getFullYear();
+        month = selected.getMonth();
+      }
+      panel = "date";
+    }
+  };
+}
+
+// src/ui/components/date-picker/styles.ts
+var DATE_PICKER_STYLE_ID = "vela-date-picker-styles";
+var DATE_PICKER_CSS = `
+.vela-date-picker{color:var(--vela-fg);font:14px var(--vela-font);user-select:none;}
+.vela-date-picker [hidden]{display:none !important;}
+.vela-date-picker-head{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-bottom:8px;}
+.vela-date-picker-title{flex:1;display:flex;align-items:center;justify-content:center;gap:2px;min-width:0;}
+.vela-date-picker-switch{border:none;background:transparent;color:var(--vela-fg-bright);font:inherit;font-weight:600;font-size:14px;padding:2px 6px;border-radius:4px;cursor:pointer;}
+.vela-date-picker-switch:not(:disabled):hover{background:var(--vela-hover);}
+.vela-date-picker-switch:disabled{cursor:default;}
+.vela-date-picker-nav{width:24px;height:24px;border:none;background:transparent;color:var(--vela-fg-muted);border-radius:4px;padding:0;cursor:pointer;display:inline-flex;align-items:center;justify-content:center;font-size:14px;}
+.vela-date-picker-nav:hover{background:var(--vela-hover);color:var(--vela-fg-bright);}
+.vela-date-picker-week,.vela-date-picker-grid{display:grid;grid-template-columns:repeat(7,28px);gap:2px;}
+.vela-date-picker-week{margin-bottom:4px;color:var(--vela-fg-muted);font-size:11px;text-align:center;}
+.vela-date-picker-week span{line-height:20px;}
+.vela-date-picker-blank{width:28px;height:28px;}
+.vela-date-picker-day{width:28px;height:28px;border:none;background:transparent;color:inherit;border-radius:4px;padding:0;cursor:pointer;font:inherit;font-size:14px;}
+.vela-date-picker-day:hover{background:var(--vela-hover);}
+.vela-date-picker-day[data-checked]{background:var(--vela-hover-strong);color:var(--vela-fg-bright);}
+.vela-date-picker-day[data-today]:not([data-checked]){box-shadow:inset 0 0 0 1px var(--vela-border-strong);}
+.vela-date-picker-cells{display:grid;grid-template-columns:repeat(3,1fr);gap:4px;width:calc(7 * 28px + 6 * 2px);}
+.vela-date-picker-cell{height:36px;border:none;background:transparent;color:inherit;border-radius:4px;padding:0 4px;cursor:pointer;font:inherit;font-size:14px;}
+.vela-date-picker-cell:hover{background:var(--vela-hover);}
+.vela-date-picker-cell[data-checked]{background:var(--vela-hover-strong);color:var(--vela-fg-bright);}
+.vela-date-picker-cell[data-today]:not([data-checked]){box-shadow:inset 0 0 0 1px var(--vela-border-strong);}
+.vela-date-picker-cell[data-outside]{opacity:0.45;}
+`;
+
+// src/ui/components/date-picker/view.ts
+var DatePicker = class {
+  constructor(opts = {}) {
+    this.opts = opts;
+    const doc = document;
+    injectStyles(DATE_PICKER_STYLE_ID, DATE_PICKER_CSS, doc);
+    this.ctrl = datePickerController(opts);
+    const button = (className) => {
+      const b = doc.createElement("button");
+      b.type = "button";
+      b.className = className;
+      return b;
+    };
+    this.prev = button("vela-date-picker-nav");
+    this.prev.append(iconEl("chevron-left", doc));
+    this.next = button("vela-date-picker-nav");
+    this.next.append(iconEl("chevron-right", doc));
+    this.monthBtn = button("vela-date-picker-switch");
+    this.monthBtn.setAttribute("aria-label", "Choose month");
+    this.yearBtn = button("vela-date-picker-switch");
+    this.yearBtn.setAttribute("aria-label", "Choose year");
+    const title = doc.createElement("div");
+    title.className = "vela-date-picker-title";
+    title.append(this.monthBtn, this.yearBtn);
+    const head = doc.createElement("div");
+    head.className = "vela-date-picker-head";
+    head.append(this.prev, title, this.next);
+    this.week = doc.createElement("div");
+    this.week.className = "vela-date-picker-week";
+    for (const d of WEEKDAY_LABELS) {
+      const cell = doc.createElement("span");
+      cell.textContent = d;
+      this.week.appendChild(cell);
+    }
+    this.grid = doc.createElement("div");
+    const on = (el, run) => el.addEventListener("click", (e) => {
+      e.stopPropagation();
+      run();
+      this.paint();
+    });
+    on(this.prev, () => this.ctrl.step(-1));
+    on(this.next, () => this.ctrl.step(1));
+    on(this.monthBtn, () => this.ctrl.showMonths());
+    on(this.yearBtn, () => this.ctrl.showYears());
+    this.el = doc.createElement("div");
+    this.el.className = "vela-date-picker";
+    this.el.append(head, this.week, this.grid);
+    this.paint();
+  }
+  get value() {
+    return this.ctrl.value;
+  }
+  /** Rewrite the selection without emitting (the calendar opens on its month). */
+  setValue(value) {
+    this.ctrl.setValue(value);
+    this.paint();
+  }
+  paint() {
+    const doc = this.el.ownerDocument;
+    const h = this.ctrl.header();
+    this.monthBtn.hidden = !h.monthVisible;
+    this.monthBtn.textContent = h.month;
+    this.yearBtn.textContent = h.year;
+    this.yearBtn.disabled = h.yearDisabled;
+    const nav = this.ctrl.navLabels();
+    this.prev.setAttribute("aria-label", nav.prev);
+    this.next.setAttribute("aria-label", nav.next);
+    const dates = this.ctrl.panel === "date";
+    this.week.hidden = !dates;
+    this.grid.className = dates ? "vela-date-picker-grid" : "vela-date-picker-cells";
+    this.grid.replaceChildren(...this.ctrl.cells().map((cell) => this.cellEl(doc, cell, dates)));
+  }
+  cellEl(doc, cell, dates) {
+    if (cell.blank) {
+      const blank = doc.createElement("span");
+      blank.className = "vela-date-picker-blank";
+      return blank;
+    }
+    const b = doc.createElement("button");
+    b.type = "button";
+    b.className = dates ? "vela-date-picker-day" : "vela-date-picker-cell";
+    b.textContent = cell.label;
+    if (cell.checked) b.dataset.checked = "1";
+    if (cell.today) b.dataset.today = "1";
+    if (cell.outside) b.dataset.outside = "1";
+    b.addEventListener("click", (e) => {
+      e.stopPropagation();
+      const picked = this.ctrl.choose(cell);
+      if (picked) this.opts.onPick?.(picked);
+      else this.paint();
+    });
+    return b;
+  }
+};
+
 // src/ui/components/switch/controller.ts
 function switchController(opts = {}) {
   let checked = opts.checked ?? false;
@@ -13240,14 +14047,49 @@ function buildColorPicker(color, theme, onChange, options = {}) {
   const knob = document.createElement("div");
   knob.style.cssText = "position:absolute;top:50%;width:15px;height:15px;border-radius:50%;background:var(--vela-selected-bg);box-shadow:0 1px 3px rgba(0,0,0,0.55);transform:translate(-50%,-50%);pointer-events:none;";
   track.appendChild(knob);
-  const pctBox = document.createElement("div");
-  pctBox.style.cssText = `min-width:42px;text-align:center;font:var(--vela-font-size-md) ${theme.fontFamily};color:var(--vela-fg);border:1px solid var(--vela-border);border-radius:5px;padding:3px 4px;`;
+  const pctBox = document.createElement("input");
+  pctBox.type = "text";
+  pctBox.inputMode = "numeric";
+  pctBox.title = "Opacity (%)";
+  pctBox.style.cssText = `width:46px;box-sizing:border-box;text-align:center;font:var(--vela-font-size-md) ${theme.fontFamily};color:var(--vela-fg);background:transparent;border:1px solid var(--vela-border);border-radius:5px;padding:3px 4px;outline:none;`;
+  pctBox.addEventListener("focus", () => {
+    pctBox.style.borderColor = "var(--vela-border-strong)";
+    pctBox.select();
+  });
   opRow.append(track, pctBox);
   const paintOpacity = () => {
     track.style.background = `linear-gradient(to right, ${curHex}00, ${curHex}ff), ${CHECKER}`;
     knob.style.left = `${curAlpha * 100}%`;
-    pctBox.textContent = `${Math.round(curAlpha * 100)}%`;
+    pctBox.value = `${Math.round(curAlpha * 100)}%`;
   };
+  const commitTyped = () => {
+    pctBox.style.borderColor = "var(--vela-border)";
+    const n = parseFloat(pctBox.value.replace("%", ""));
+    if (Number.isFinite(n)) {
+      const next = Math.max(0, Math.min(100, n)) / 100;
+      if (Math.round(next * 100) !== Math.round(curAlpha * 100)) {
+        curAlpha = next;
+        paintOpacity();
+        emit();
+        return;
+      }
+    }
+    paintOpacity();
+  };
+  pctBox.addEventListener("change", commitTyped);
+  pctBox.addEventListener("blur", () => {
+    pctBox.style.borderColor = "var(--vela-border)";
+    paintOpacity();
+  });
+  pctBox.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") return;
+    e.stopPropagation();
+    if (e.key === "Enter") {
+      e.preventDefault();
+      commitTyped();
+      pctBox.blur();
+    }
+  });
   let dragging = false;
   const onDrag = (clientX) => {
     const r = track.getBoundingClientRect();
@@ -14471,10 +15313,16 @@ var IndicatorInputsDialog = class {
         this.calendarPop = null;
         this.calendarAnchor = null;
       },
-      content: (el) => fillCalendar(el, current, (iso) => {
-        pop.hide();
-        onPick(iso);
-      })
+      content: (el) => {
+        const picker = new DatePicker({
+          value: current,
+          onPick: (iso) => {
+            pop.hide();
+            onPick(iso);
+          }
+        });
+        el.append(picker.el);
+      }
     });
     this.calendarPop = pop;
     this.calendarAnchor = anchor;
@@ -14599,28 +15447,6 @@ function ensureDialogStyles() {
 .vela-ind-combo-chevron{position:absolute;right:0;top:0;bottom:0;width:26px;border:none;background:transparent;color:inherit;opacity:0.55;cursor:pointer;display:flex;align-items:center;justify-content:center;padding:0;}
 .vela-ind-combo-chevron:hover{opacity:0.9;}
 .vela-ind-cal{background:var(--vela-bg);color:var(--vela-fg);border:none;border-radius:6px;box-shadow:var(--vela-shadow);font:14px var(--vela-font);padding:10px 12px;user-select:none;}
-.vela-ind-cal [hidden]{display:none !important;}
-.vela-ind-cal-head{display:flex;align-items:center;justify-content:space-between;gap:8px;margin-bottom:8px;}
-.vela-ind-cal-title{flex:1;display:flex;align-items:center;justify-content:center;gap:2px;min-width:0;}
-.vela-ind-cal-switch{border:none;background:transparent;color:var(--vela-fg-bright);font:inherit;font-weight:600;font-size:14px;padding:2px 6px;border-radius:4px;cursor:pointer;}
-.vela-ind-cal-switch:not(:disabled):hover{background:var(--vela-hover);}
-.vela-ind-cal-switch:disabled{cursor:default;}
-.vela-ind-cal-nav{width:24px;height:24px;border:none;background:transparent;color:var(--vela-fg-muted);border-radius:4px;padding:0;cursor:pointer;display:inline-flex;align-items:center;justify-content:center;}
-.vela-ind-cal-nav:hover{background:var(--vela-hover);color:var(--vela-fg-bright);}
-.vela-ind-cal-week,.vela-ind-cal-grid{display:grid;grid-template-columns:repeat(7,28px);gap:2px;}
-.vela-ind-cal-week{margin-bottom:4px;color:var(--vela-fg-muted);font-size:11px;text-align:center;}
-.vela-ind-cal-week span{line-height:20px;}
-.vela-ind-cal-blank{width:28px;height:28px;}
-.vela-ind-cal-day{width:28px;height:28px;border:none;background:transparent;color:inherit;border-radius:4px;padding:0;cursor:pointer;font:inherit;font-size:14px;}
-.vela-ind-cal-day:hover{background:var(--vela-hover);}
-.vela-ind-cal-day[data-checked]{background:var(--vela-hover-strong);color:var(--vela-fg-bright);}
-.vela-ind-cal-day[data-today]:not([data-checked]){box-shadow:inset 0 0 0 1px var(--vela-border-strong);}
-.vela-ind-cal-cells{display:grid;grid-template-columns:repeat(3,1fr);gap:4px;width:calc(7 * 28px + 6 * 2px);}
-.vela-ind-cal-cell{height:36px;border:none;background:transparent;color:inherit;border-radius:4px;padding:0 4px;cursor:pointer;font:inherit;font-size:14px;}
-.vela-ind-cal-cell:hover{background:var(--vela-hover);}
-.vela-ind-cal-cell[data-checked]{background:var(--vela-hover-strong);color:var(--vela-fg-bright);}
-.vela-ind-cal-cell[data-today]:not([data-checked]){box-shadow:inset 0 0 0 1px var(--vela-border-strong);}
-.vela-ind-cal-cell[data-outside]{opacity:0.45;}
 ${overlayScrollbarCss(".vela-dialog.vela-ind-dialog *", 9)}
 .vela-ind-tab{font-weight:600;font-size:13px;line-height:20px;transition:color var(--vela-dur-fast) ease,border-color var(--vela-dur-fast) ease;}
 .vela-ind-tab:not(.vela-ind-tab-active):hover{color:var(--vela-fg-bright);}
@@ -14654,174 +15480,6 @@ var TIME_OPTIONS = Array.from({ length: 48 }, (_, i) => {
   const v = `${hh}:${mm}`;
   return { value: v, label: v };
 });
-var MONTH_LABELS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
-var MONTH_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
-var WEEKDAY_LABELS = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"];
-function normalizeDateInput(raw) {
-  const t = raw.trim();
-  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})$/.exec(t);
-  if (!m) return null;
-  const y = Number(m[1]);
-  const mo = Number(m[2]);
-  const d = Number(m[3]);
-  const dt = new Date(y, mo - 1, d);
-  if (dt.getFullYear() !== y || dt.getMonth() !== mo - 1 || dt.getDate() !== d) return null;
-  return isoDate(dt);
-}
-function parseIsoDate(raw) {
-  const iso = normalizeDateInput(raw);
-  if (!iso) return null;
-  const [y, mo, d] = iso.split("-").map(Number);
-  return new Date(y, mo - 1, d);
-}
-function isoDate(d) {
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-}
-function fillCalendar(el, current, onPick) {
-  const today = /* @__PURE__ */ new Date();
-  const selected = parseIsoDate(current);
-  let year = selected?.getFullYear() ?? today.getFullYear();
-  let month = selected?.getMonth() ?? today.getMonth();
-  let mode = "date";
-  const prev2 = document.createElement("button");
-  prev2.type = "button";
-  prev2.className = "vela-ind-cal-nav";
-  prev2.innerHTML = iconAt("chevron-left", 14);
-  const next = document.createElement("button");
-  next.type = "button";
-  next.className = "vela-ind-cal-nav";
-  next.innerHTML = iconAt("chevron-right", 14);
-  const monthBtn = document.createElement("button");
-  monthBtn.type = "button";
-  monthBtn.className = "vela-ind-cal-switch";
-  monthBtn.setAttribute("aria-label", "Choose month");
-  const yearBtn = document.createElement("button");
-  yearBtn.type = "button";
-  yearBtn.className = "vela-ind-cal-switch";
-  yearBtn.setAttribute("aria-label", "Choose year");
-  const title = document.createElement("div");
-  title.className = "vela-ind-cal-title";
-  title.append(monthBtn, yearBtn);
-  const head = document.createElement("div");
-  head.className = "vela-ind-cal-head";
-  head.append(prev2, title, next);
-  const week = document.createElement("div");
-  week.className = "vela-ind-cal-week";
-  for (const d of WEEKDAY_LABELS) {
-    const cell = document.createElement("span");
-    cell.textContent = d;
-    week.appendChild(cell);
-  }
-  const grid = document.createElement("div");
-  const paint = () => {
-    const decade = Math.floor(year / 10) * 10;
-    monthBtn.hidden = mode !== "date";
-    monthBtn.textContent = MONTH_LABELS[month] ?? "";
-    yearBtn.textContent = mode === "year" ? `${decade}-${decade + 9}` : String(year);
-    yearBtn.disabled = mode === "year";
-    week.hidden = mode !== "date";
-    prev2.setAttribute("aria-label", mode === "date" ? "Previous month" : mode === "month" ? "Previous year" : "Previous decade");
-    next.setAttribute("aria-label", mode === "date" ? "Next month" : mode === "month" ? "Next year" : "Next decade");
-    grid.className = mode === "date" ? "vela-ind-cal-grid" : "vela-ind-cal-cells";
-    grid.replaceChildren();
-    if (mode === "date") {
-      const startPad = new Date(year, month, 1).getDay();
-      const days = new Date(year, month + 1, 0).getDate();
-      const todayIso = isoDate(today);
-      const selectedIso = selected ? isoDate(selected) : "";
-      for (let i = 0; i < startPad; i++) {
-        const blank = document.createElement("span");
-        blank.className = "vela-ind-cal-blank";
-        grid.appendChild(blank);
-      }
-      for (let day = 1; day <= days; day++) {
-        const iso = `${year}-${String(month + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
-        const b = document.createElement("button");
-        b.type = "button";
-        b.className = "vela-ind-cal-day";
-        b.textContent = String(day);
-        if (iso === selectedIso) b.dataset.checked = "1";
-        if (iso === todayIso) b.dataset.today = "1";
-        b.addEventListener("click", (e) => {
-          e.stopPropagation();
-          onPick(iso);
-        });
-        grid.appendChild(b);
-      }
-      return;
-    }
-    if (mode === "month") {
-      for (let m = 0; m < 12; m++) {
-        const b = document.createElement("button");
-        b.type = "button";
-        b.className = "vela-ind-cal-cell";
-        b.textContent = MONTH_SHORT[m] ?? "";
-        if (selected?.getFullYear() === year && selected.getMonth() === m) b.dataset.checked = "1";
-        if (today.getFullYear() === year && today.getMonth() === m) b.dataset.today = "1";
-        b.addEventListener("click", (e) => {
-          e.stopPropagation();
-          month = m;
-          mode = "date";
-          paint();
-        });
-        grid.appendChild(b);
-      }
-      return;
-    }
-    for (let y = decade - 1; y <= decade + 10; y++) {
-      const b = document.createElement("button");
-      b.type = "button";
-      b.className = "vela-ind-cal-cell";
-      b.textContent = String(y);
-      if (y < decade || y > decade + 9) b.dataset.outside = "1";
-      if (selected?.getFullYear() === y) b.dataset.checked = "1";
-      if (today.getFullYear() === y) b.dataset.today = "1";
-      b.addEventListener("click", (e) => {
-        e.stopPropagation();
-        year = y;
-        mode = "month";
-        paint();
-      });
-      grid.appendChild(b);
-    }
-  };
-  const step = (dir) => {
-    if (mode === "date") {
-      month += dir;
-      if (month < 0) {
-        month = 11;
-        year -= 1;
-      }
-      if (month > 11) {
-        month = 0;
-        year += 1;
-      }
-    } else {
-      year += mode === "month" ? dir : dir * 10;
-    }
-    paint();
-  };
-  prev2.addEventListener("click", (e) => {
-    e.stopPropagation();
-    step(-1);
-  });
-  next.addEventListener("click", (e) => {
-    e.stopPropagation();
-    step(1);
-  });
-  monthBtn.addEventListener("click", (e) => {
-    e.stopPropagation();
-    mode = "month";
-    paint();
-  });
-  yearBtn.addEventListener("click", (e) => {
-    e.stopPropagation();
-    mode = "year";
-    paint();
-  });
-  paint();
-  el.append(head, week, grid);
-}
 function normalizeTimeInput(raw) {
   const t = raw.trim();
   const m = /^(\d{1,2}):(\d{2})$/.exec(t) ?? /^(\d{2})(\d{2})$/.exec(t);
@@ -16199,6 +16857,22 @@ function priceStyleIds() {
   for (const t of chartTypes()) if (!out.includes(t.id)) out.push(t.id);
   return out;
 }
+function sanitizeCrosshairOverride(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  const out = {};
+  if (isBool(v.vertical)) out.vertical = v.vertical;
+  if (isBool(v.horizontal)) out.horizontal = v.horizontal;
+  if (isColor(v.color)) out.color = v.color;
+  if (isNum(v.width)) out.width = Math.max(0.5, Math.min(8, v.width));
+  if (isLineStyle(v.style)) out.style = v.style;
+  if (isNum(v.opacity)) out.opacity = clampOpacity(v.opacity);
+  const shade = v.shadeRight;
+  if (shade && typeof shade === "object" && isColor(shade.color)) {
+    out.shadeRight = isNum(shade.opacity) ? { color: shade.color, opacity: clampOpacity(shade.opacity) } : { color: shade.color };
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
 function isColor(v) {
   return typeof v === "string" && v.trim().length > 0;
 }
@@ -17860,7 +18534,7 @@ var Scheduler = class {
 
 // src/renderers/native/core/Animator.ts
 var Animator = class {
-  constructor(tick, raf, cancel, now) {
+  constructor(tick, raf, cancel, now2) {
     this.tick = tick;
     this.handle = null;
     this.last = 0;
@@ -17874,7 +18548,7 @@ var Animator = class {
     };
     this.raf = raf ?? ((cb) => requestAnimationFrame(cb));
     this.cancel = cancel ?? ((h) => cancelAnimationFrame(h));
-    this.now = now ?? (() => performance.now());
+    this.now = now2 ?? (() => performance.now());
   }
   get active() {
     return this.handle !== null;
@@ -18006,6 +18680,12 @@ var InputController = class {
     this.lastTapT = 0;
     this.lastTapX = 0;
     this.lastTapY = 0;
+    // Whether the last two primary presses were claimed by the drawings layer. A double-click
+    // is the last press plus the one before it; a tool-driven click pair must never fall through
+    // to the pane maximize toggle, even when the tool disarmed itself between the two clicks
+    // (a finished placement leaves plain cursor mode for the second click).
+    this.lastPressDrawing = false;
+    this.prevPressDrawing = false;
     this.onTouchContextMenu = (e) => {
       if (this.touches.size === 0) return;
       if (!(e.target instanceof Node) || !this.el?.contains(e.target)) return;
@@ -18060,19 +18740,24 @@ var InputController = class {
       this.moved = false;
       this.startX = x;
       this.startY = y;
+      this.prevPressDrawing = this.lastPressDrawing;
+      this.lastPressDrawing = false;
       if (this.deps.drawingsClaim?.(x, y)) {
         this.region = "drawing";
+        this.lastPressDrawing = true;
         this.deps.drawingsPointerDown?.(x, y, this.snapMode(e), e.shiftKey, e.ctrlKey || e.metaKey);
         this.capture(e.pointerId);
         return;
       }
       if (e.shiftKey && this.regionAt(x, y) === "data" && this.deps.drawingsMeasureStart?.(x, y, this.snapMode(e))) {
         this.region = "drawing";
+        this.lastPressDrawing = true;
         this.capture(e.pointerId);
         return;
       }
       if ((e.ctrlKey || e.metaKey) && this.regionAt(x, y) === "data" && this.deps.drawingsMarqueeStart?.(x, y)) {
         this.region = "drawing";
+        this.lastPressDrawing = true;
         this.capture(e.pointerId);
         return;
       }
@@ -18394,6 +19079,7 @@ var InputController = class {
     if (region === "price") this.deps.resetPriceScale(x, y);
     else if (region === "separator") this.deps.resetPaneSize(y);
     else if (region === "time") this.deps.resetView();
+    else if (this.lastPressDrawing || this.prevPressDrawing) return;
     else this.deps.dataDblClick(x, y);
   }
 };
@@ -18673,6 +19359,8 @@ var SceneGraph = class {
     /** VPVR-layer config pushed by the VPVR native indicator (null ⇒ layer off). Ephemeral. */
     this.vpvrLayer = null;
     this.crosshair = null;
+    /** Runtime override of the crosshair's lines and style (the `crosshairOverride` feature). Ephemeral. */
+    this.crosshairOverride = null;
     /** How the base price series is drawn on the price pane (candles by default). */
     this.priceStyle = "candles";
     /** Price-series base painting for the ACTIVE style (see ChartTypeDefinition.basePainting). */
@@ -20557,6 +21245,7 @@ function timeTicks(fromMs, toMs, target = 8, offsetMs = 0) {
   const step = pickStep(span / Math.max(1, target));
   const zFrom = fromMs + offsetMs;
   const zTo = toMs + offsetMs;
+  if (step >= MONTH) return calendarTicks(zFrom, zTo, step >= YEAR ? 12 : step >= 3 * MONTH ? 3 : 1, offsetMs);
   const first = Math.ceil(zFrom / step) * step;
   const out = [];
   for (let zt = first; zt <= zTo; zt += step) {
@@ -20587,11 +21276,23 @@ function timeTicks(fromMs, toMs, target = 8, offsetMs = 0) {
   }
   return out;
 }
+function calendarTicks(zFrom, zTo, months, offsetMs) {
+  const d0 = new Date(zFrom);
+  let idx = d0.getUTCFullYear() * 12 + d0.getUTCMonth();
+  if (Date.UTC(Math.floor(idx / 12), idx % 12, 1) < zFrom) idx += 1;
+  idx = Math.ceil(idx / months) * months;
+  const out = [];
+  for (let zt = Date.UTC(Math.floor(idx / 12), idx % 12, 1); zt <= zTo; idx += months, zt = Date.UTC(Math.floor(idx / 12), idx % 12, 1)) {
+    const label = months === 12 ? String(Math.floor(idx / 12)) : MONTHS[idx % 12];
+    out.push({ time: zt - offsetMs, label, major: true });
+  }
+  return out;
+}
 
 // src/renderers/native/chrome/countdown.ts
-function countdownText(barOpen, barMs, now) {
+function countdownText(barOpen, barMs, now2) {
   if (!(barMs > 0)) return null;
-  const remaining = barOpen + barMs - now;
+  const remaining = barOpen + barMs - now2;
   if (remaining <= 0) return null;
   return formatCountdown(remaining);
 }
@@ -21403,19 +22104,35 @@ var CrosshairRenderer = class {
     const dataH = coords.height;
     if (!ch || ch.x < 0 || ch.x > dataW || ch.y < 0 || ch.y > dataH) return;
     const cs = scene.style.crosshair;
+    const ov = scene.crosshairOverride;
+    const vertical = ov?.vertical !== false;
+    const horizontal = ov?.horizontal !== false;
     ctx.font = `${scene.style.fontSize}px ${theme.fontFamily}`;
     ctx.textBaseline = "middle";
     const logical = Math.round(coords.xToLogical(ch.x));
-    const x = Math.round(coords.logicalToX(logical)) + 0.5;
-    ctx.strokeStyle = cs.color ?? theme.textColor;
-    ctx.lineWidth = cs.width;
-    ctx.globalAlpha = cs.opacity;
-    setDash3(ctx, cs.style);
+    const x = crisp(coords.logicalToX(logical), ov?.width ?? cs.width);
+    if (vertical && ov?.shadeRight) {
+      const from = Math.max(0, Math.round(coords.logicalToX(logical + 0.5)));
+      if (from < dataW) {
+        ctx.fillStyle = ov.shadeRight.color;
+        ctx.globalAlpha = ov.shadeRight.opacity ?? 1;
+        ctx.fillRect(from, 0, dataW - from, dataH);
+        ctx.globalAlpha = 1;
+      }
+    }
+    ctx.strokeStyle = ov?.color ?? cs.color ?? theme.textColor;
+    ctx.lineWidth = ov?.width ?? cs.width;
+    ctx.globalAlpha = ov?.opacity ?? cs.opacity;
+    setDash3(ctx, ov?.style ?? cs.style);
     ctx.beginPath();
-    ctx.moveTo(x, 0);
-    ctx.lineTo(x, dataH);
-    ctx.moveTo(0, Math.round(ch.y) + 0.5);
-    ctx.lineTo(dataW, Math.round(ch.y) + 0.5);
+    if (vertical) {
+      ctx.moveTo(x, 0);
+      ctx.lineTo(x, dataH);
+    }
+    if (horizontal) {
+      ctx.moveTo(0, Math.round(ch.y) + 0.5);
+      ctx.lineTo(dataW, Math.round(ch.y) + 0.5);
+    }
     ctx.stroke();
     ctx.setLineDash([]);
     ctx.lineWidth = 1;
@@ -21428,11 +22145,11 @@ var CrosshairRenderer = class {
       }
     }
     const chipBg = cs.labelBackground ?? theme.borderColor;
-    if (pane && pane.axisFormat !== "none") {
+    if (horizontal && pane && pane.axisFormat !== "none") {
       const price = coords.yToPrice(ch.y, pane.scale, pane.bounds);
       this.chip(ctx, dataW + 1, ch.y, formatAxisValue(pane.scale, pane.bounds.height, price, percentScaleFor(scene, pane), scene.priceMintick, pane.axisFormat), chipBg, "left", false, theme.background);
     }
-    this.chip(ctx, x, dataH + 1, formatTimeStamp(coords.logicalToTime(logical), scene.timezone, coords.barInterval), chipBg, "center", true, theme.background);
+    if (vertical) this.chip(ctx, x, dataH + 1, formatTimeStamp(coords.logicalToTime(logical), scene.timezone, coords.barInterval), chipBg, "center", true, theme.background);
   }
   destroy() {
     this.canvas = null;
@@ -21443,23 +22160,37 @@ var CrosshairRenderer = class {
    *  along), with that bar's time chip in this chart's own timezone and — when the
    *  level resolved — the price chip on the right axis. The snap happened upstream
    *  (`externalCrossPx`, floor-to-containing-bar) — this method only draws. Chips
-   *  render slightly dimmed so the ghost still reads as foreign. */
+   *  render slightly dimmed so the ghost still reads as foreign. A `crosshairOverride`
+   *  applies to the ghost as well — its line style, a dropped horizontal line, and the
+   *  `shadeRight` veil from the ghost bar's right edge — so a pick that spans several
+   *  charts reads the same on every one of them. */
   drawExternal(ctx, ext, scene, coords, theme) {
     const cs = scene.style.crosshair;
+    const ov = scene.crosshairOverride;
     const dataW = coords.width;
     const dataH = coords.height;
-    const x = Math.round(ext.x) + 0.5;
-    if (x < 0 || x > dataW) return;
+    const x = crisp(ext.x, ov?.width ?? cs.width);
+    if (ov?.vertical === false) return;
+    if (ov?.shadeRight) {
+      const from = Math.max(0, Math.round(coords.logicalToX(Math.round(coords.xToLogical(ext.x)) + 0.5)));
+      if (from < dataW) {
+        ctx.fillStyle = ov.shadeRight.color;
+        ctx.globalAlpha = ov.shadeRight.opacity ?? 1;
+        ctx.fillRect(from, 0, dataW - from, dataH);
+        ctx.globalAlpha = 1;
+      }
+    }
+    if (ext.line === false || x < 0 || x > dataW) return;
     ctx.font = `${scene.style.fontSize}px ${theme.fontFamily}`;
     ctx.textBaseline = "middle";
-    ctx.strokeStyle = cs.color ?? theme.textColor;
-    ctx.lineWidth = cs.width;
-    ctx.globalAlpha = cs.opacity * 0.55;
-    setDash3(ctx, cs.style);
+    ctx.strokeStyle = ov?.color ?? cs.color ?? theme.textColor;
+    ctx.lineWidth = ov?.width ?? cs.width;
+    ctx.globalAlpha = (ov?.opacity ?? cs.opacity) * 0.55;
+    setDash3(ctx, ov?.style ?? cs.style);
     ctx.beginPath();
     ctx.moveTo(x, 0);
     ctx.lineTo(x, dataH);
-    if (ext.y != null) {
+    if (ext.y != null && ov?.horizontal !== false) {
       ctx.moveTo(0, Math.round(ext.y) + 0.5);
       ctx.lineTo(dataW, Math.round(ext.y) + 0.5);
     }
@@ -21468,7 +22199,7 @@ var CrosshairRenderer = class {
     ctx.lineWidth = 1;
     ctx.globalAlpha = 0.8;
     const chipBg = cs.labelBackground ?? theme.borderColor;
-    if (ext.y != null && ext.price != null) {
+    if (ext.y != null && ext.price != null && ov?.horizontal !== false) {
       let pane;
       for (const p of scene.panes.values()) {
         if (ext.y >= p.bounds.top && ext.y <= p.bounds.top + p.bounds.height) {
@@ -21508,6 +22239,9 @@ var CrosshairRenderer = class {
     ctx.textAlign = "start";
   }
 };
+function crisp(px, width) {
+  return Math.round(px) + (Math.round(width) % 2 === 1 ? 0.5 : 0);
+}
 function setDash3(ctx, style) {
   if (style === "dashed") ctx.setLineDash([6, 4]);
   else if (style === "dotted") ctx.setLineDash([2, 3]);
@@ -29099,23 +29833,21 @@ function stackLayers(entries, candleZ) {
   return { below, above };
 }
 
-// src/renderers/native/chrome/luxalgo-logos.ts
-var LUXALGO_SYMBOL_SVG = '<svg viewBox="0 0 45 40" aria-hidden="true"><g fill="currentColor"><path d="m40.25 38 4.58-7.998L28.802 2l-16.03 28 9.16-.001 6.87-12z"/><path d="M34.525 32.002 9.33 31.997 27.655 0h-9.158L.18 31.993 4.759 40h34.347z"/></g></svg>';
-var LUXALGO_WORDMARK_SVG = '<svg viewBox="0 0 964 252" aria-hidden="true"><path fill="currentColor" fill-rule="evenodd" d="M 614 94.500 L 614 189 633.500 189 L 653 189 653 94.500 L 653 0 633.500 0 L 614 0 614 94.500 M 0 97.500 L 0 189 63.023 189 L 126.045 189 125.773 170.750 L 125.500 152.500 84.250 152.239 L 43 151.978 43 78.989 L 43 6 21.500 6 L 0 6 0 97.500 M 450.387 96.451 C 421.871 146.253, 398.306 186.994, 398.020 186.987 C 397.423 186.972, 362 124.724, 362 123.691 C 362 123.316, 370.100 108.818, 380 91.472 C 389.900 74.127, 398 59.500, 398 58.968 C 398 58.380, 391.007 58, 380.210 58 L 362.420 58 348.060 83.138 C 334.400 107.052, 333.637 108.160, 332.399 105.888 C 331.682 104.575, 325.287 93.375, 318.187 81 L 305.277 58.500 287.139 58.227 C 277.162 58.078, 269 58.186, 269 58.469 C 269 58.751, 277.154 73.274, 287.120 90.741 C 297.086 108.209, 305.261 122.983, 305.287 123.574 C 305.312 124.164, 297.318 138.789, 287.522 156.074 C 277.725 173.358, 269.524 187.838, 269.296 188.250 C 269.068 188.662, 276.977 189, 286.870 189 L 304.859 189 319.163 163.959 C 331.321 142.674, 333.647 139.165, 334.670 140.563 C 335.331 141.468, 341.864 152.737, 349.186 165.606 L 362.500 189.003 402.442 188.752 L 442.384 188.500 472.080 136.695 C 488.413 108.203, 501.939 84.729, 502.138 84.531 C 502.337 84.333, 516 107.757, 532.500 136.583 L 562.500 188.994 584.750 188.997 C 596.987 188.999, 607 188.854, 607 188.675 C 607 188.319, 503.014 6.686, 502.532 6.201 C 502.369 6.037, 478.904 46.649, 450.387 96.451 M 717.500 55.017 C 697.175 57.389, 680.641 68.752, 672.036 86.264 C 665.866 98.818, 663.840 108.024, 663.840 123.500 C 663.840 133.409, 664.328 138.355, 665.892 144.300 C 672.076 167.810, 689.191 184.757, 711.529 189.489 C 730.549 193.518, 747.264 189.540, 761.282 177.648 C 764.944 174.542, 768.178 172, 768.470 172 C 769.345 172, 769.030 185.018, 767.979 192.285 C 765.618 208.613, 755.148 218.672, 738.473 220.632 C 732.586 221.324, 723.136 219.599, 717.709 216.843 C 712.693 214.295, 706.636 207.946, 703.972 202.443 C 702.789 199.999, 701.749 198, 701.661 198.001 C 700.201 198.007, 665.596 205.071, 665.230 205.437 C 664.326 206.341, 669.156 218.313, 672.607 223.721 C 682.146 238.672, 700.008 248.257, 723.500 251.033 C 758.132 255.124, 788.930 241.875, 800.287 218 C 806.923 204.047, 807 203.001, 807 126.542 L 807 58 788.500 58 L 770 58 770 66.500 C 770 71.175, 769.641 75, 769.203 75 C 768.765 75, 766.627 73.142, 764.453 70.872 C 752.805 58.708, 735.614 52.903, 717.500 55.017 M 878.500 55.031 C 850.107 59.412, 830.755 75.064, 822.285 100.500 C 819.905 107.644, 819.614 110.051, 819.565 123 C 819.501 139.581, 820.786 145.825, 826.763 158 C 832.104 168.880, 842.842 179.424, 854.077 184.822 C 867.651 191.343, 873.132 192.462, 891.500 192.462 C 909.868 192.462, 915.349 191.343, 928.923 184.822 C 944.653 177.265, 956.667 162.306, 961.710 144 C 963.074 139.048, 963.481 134.047, 963.418 123 C 963.346 110.140, 963.038 107.595, 960.694 100.500 C 953.325 78.193, 936.695 62.854, 913.500 56.969 C 904.262 54.625, 887.240 53.682, 878.500 55.031 M 134.015 102.750 C 134.027 139.250, 134.310 148.689, 135.549 153.947 C 141.139 177.663, 159.815 193, 183.105 193 C 196.453 193, 210.163 186.171, 217.936 175.650 C 219.826 173.093, 221.738 171, 222.186 171 C 222.634 171, 223 175.050, 223 180 L 223 189 242.507 189 L 262.014 189 261.757 123.750 L 261.500 58.500 242.500 58.500 L 223.500 58.500 223 99.500 C 222.513 139.406, 222.441 140.610, 220.289 144.634 C 209.729 164.377, 183.014 164.880, 174.299 145.500 C 172.677 141.895, 172.469 137.382, 172.190 99.750 L 171.880 58 152.940 58 L 134 58 134.015 102.750 M 729.932 87.998 C 719.311 89.821, 710.155 97.164, 705.141 107.880 C 702.851 112.772, 702.510 114.798, 702.505 123.521 C 702.500 132.834, 702.732 134.014, 705.787 140.218 C 709.761 148.290, 715.989 154.097, 723.853 157.063 C 731.409 159.912, 744.359 159.466, 750.795 156.136 C 767.289 147.601, 774.103 127.713, 767.019 108.780 C 761.433 93.851, 746.051 85.232, 729.932 87.998 M 883.972 88.348 C 865.749 92.310, 854.873 109.966, 858.119 130.316 C 860.933 147.963, 872.346 158.830, 889.084 159.799 C 900.714 160.472, 906.867 158.234, 914.650 150.497 C 919.856 145.323, 921.123 143.340, 922.900 137.587 C 925.412 129.456, 925.655 118.570, 923.489 111.275 C 918.479 94.405, 901.478 84.541, 883.972 88.348"/></svg>';
+// src/renderers/native/chrome/vela-logos.ts
+var VELA_MARK_SVG = '<svg viewBox="0 -142 161.66 148" aria-hidden="true"><g fill="currentColor"><path d="M0 -140L32.91 -140L77.52 -62.73L61.06 -34.24Z"/><path d="M161.66 -140L128.75 -140L84.14 -62.73L100.59 -34.24Z"/><path d="M80.83 -52.04L95.85 -26.02L80.83 0L65.81 -26.02Z"/></g></svg>';
+var VELA_LETTERS_SVG = '<svg viewBox="161.66 -142 310.57 148" aria-hidden="true"><g fill="currentColor"><path d="M226.3 1.17Q200.81 1.17 186.12 -12.99Q171.42 -27.15 171.42 -51.17Q171.42 -75.2 185.87 -89.6Q200.33 -104 224.25 -104Q247.4 -104 261.7 -90.58Q276.01 -77.15 276.3 -54.59Q276.3 -49.9 275.42 -45.02H200.81V-43.55Q201.2 -32.62 207.75 -26.42Q214.29 -20.21 225.03 -20.21Q233.72 -20.21 239.34 -23.93Q244.95 -27.64 246.81 -34.77H274.64Q272.1 -19.14 259.16 -8.98Q246.22 1.17 226.3 1.17ZM201.5 -63.38H247.88Q246.42 -72.75 240.27 -77.88Q234.12 -83.01 224.45 -83.01Q215.17 -83.01 208.92 -77.73Q202.67 -72.46 201.5 -63.38ZM287.54 0V-140.04H315.76V0ZM429.34 -23.83H432.56V0H418.11Q407.76 0 403.36 -4.44Q398.97 -8.89 399.16 -16.8Q387.83 1.17 365.57 1.17Q348.48 1.17 337.88 -6.74Q327.29 -14.65 327.29 -29Q327.29 -45.41 339.45 -54.3Q351.6 -63.18 374.55 -63.18H394.96V-68.16Q394.96 -75.2 390.08 -79.3Q385.2 -83.4 376.51 -83.4Q368.3 -83.4 363.03 -79.98Q357.76 -76.56 356.88 -70.8H329.73Q331.19 -85.84 344.08 -94.92Q356.97 -104 377.29 -104Q399.06 -104 410.88 -94.43Q422.7 -84.86 422.7 -66.6V-30.18Q422.7 -26.37 424.26 -25.1Q425.82 -23.83 429.34 -23.83ZM394.96 -42.38V-44.43H374.36Q365.47 -44.43 360.59 -40.92Q355.7 -37.4 355.7 -30.96Q355.7 -25.59 359.81 -22.41Q363.91 -19.24 370.94 -19.24Q381.97 -19.24 388.37 -25.54Q394.77 -31.84 394.96 -42.38Z"/><path fill-opacity="0.55" d="M437.44 -124.28H441.96V-113.41H445.34V-124.28H449.87V-127.4H437.44ZM451.43 -113.41H454.7V-123.29L458.97 -113.41H461.62L465.99 -123.29V-113.41H469.21V-127.4H464.53L460.42 -117.68L456.16 -127.4H451.43Z"/></g></svg>';
 
 // src/renderers/native/chrome/AttributionMark.ts
-var ATTRIBUTION_URL = "https://luxalgo.com/vela";
+var ATTRIBUTION_URL = "https://velacharts.dev/?utm_source=vela&utm_medium=attribution";
 var STYLE_ID5 = "vela-attribution-styles";
 var CSS2 = `
 .vela-attribution {
     text-decoration: none;
     display: flex;
     align-items: center;
-    /* Gutter, wordmark size and offset below are the brand lockup's own ratios,
-       measured off the official horizontal logo: gutter 0.157, wordmark height
-       0.966, and wordmark 0.109 LOWER than the symbol \u2014 box-centering the two
-       reads wrong because the symbol's ink hangs low and the wordmark descends. */
-    gap: 4px;
+    /* No gutter: the V is the wordmark's first letter, and the letters' viewBox starts
+       where the V's ends, so the kit's own letter spacing comes with them. */
+    gap: 0;
 }
 .vela-attribution .vela-attr-symbol {
     flex: none;
@@ -29123,7 +29855,7 @@ var CSS2 = `
     line-height: 0;
 }
 .vela-attribution .vela-attr-symbol svg {
-    height: 28px;
+    height: 24px;
     width: auto;
     display: block;
     filter: drop-shadow(0 1px 2px var(--vela-attr-shadow, rgba(0,0,0,0.45)));
@@ -29134,15 +29866,13 @@ var CSS2 = `
     opacity: 0;
     display: flex;
     align-items: center;
-    /* Offset here, not on the image: the clip box must not crop the descender. */
-    position: relative;
-    top: 3px;
+    /* Same height and baseline as the V (one viewBox height), so no vertical offset. */
     transform: translateX(-8px);
     transition: max-width 0.3s ease, opacity 0.25s ease, transform 0.3s ease;
     flex: none;
 }
 .vela-attribution .vela-attr-wordmark svg {
-    height: 27px;
+    height: 24px;
     width: auto;
     display: block;
     filter: drop-shadow(0 1px 2px var(--vela-attr-shadow, rgba(0,0,0,0.45)));
@@ -29157,14 +29887,11 @@ var CSS2 = `
    (data-layout): the workspace's single grid-wide mark lives OUTSIDE any renderer
    container, so only the shell attribute reaches it. */
 [data-vela-layout='mobile'] .vela-attribution .vela-attr-symbol svg,
-[data-layout='mobile'] .vela-attribution .vela-attr-symbol svg { height: 22px; }
+[data-layout='mobile'] .vela-attribution .vela-attr-symbol svg { height: 20px; }
 [data-vela-layout='mobile'] .vela-attribution .vela-attr-wordmark,
-[data-layout='mobile'] .vela-attribution .vela-attr-wordmark {
-    top: 2px;
-    transform: translateX(-6px);
-}
+[data-layout='mobile'] .vela-attribution .vela-attr-wordmark { transform: translateX(-6px); }
 [data-vela-layout='mobile'] .vela-attribution .vela-attr-wordmark svg,
-[data-layout='mobile'] .vela-attribution .vela-attr-wordmark svg { height: 21px; }
+[data-layout='mobile'] .vela-attribution .vela-attr-wordmark svg { height: 20px; }
 [data-vela-layout='mobile'] .vela-attribution:hover .vela-attr-wordmark,
 [data-layout='mobile'] .vela-attribution:hover .vela-attr-wordmark { transform: translateX(0); }
 `;
@@ -29221,10 +29948,10 @@ function createAttributionMark(doc, background) {
   const symbol = doc.createElement("span");
   symbol.className = "vela-attr-symbol";
   symbol.setAttribute("aria-hidden", "true");
-  symbol.innerHTML = LUXALGO_SYMBOL_SVG;
+  symbol.innerHTML = VELA_MARK_SVG;
   const wordmark = doc.createElement("span");
   wordmark.className = "vela-attr-wordmark";
-  wordmark.innerHTML = LUXALGO_WORDMARK_SVG;
+  wordmark.innerHTML = VELA_LETTERS_SVG;
   a.append(symbol, wordmark);
   return a;
 }
@@ -29804,7 +30531,7 @@ var NativeRenderer = class {
     this.moveIndicatorCbs = /* @__PURE__ */ new Set();
     this.priceStyleCbs = /* @__PURE__ */ new Set();
     this.name = "native";
-    this.features = ["logScale", "currentPriceLine", "priceLabel", "countdown", "upColor", "downColor", "glow", "animZoom", "animPan", "animScroll", "animAutoscale", "animLiveBar", "intro", "zoomAnchor", "axisDrag", "paneResize", "candleZOrder", "candleVisible", "seriesOrder", "highlights", "sessionZones", "gridlines", "axisLabels", "scaleMode", "invertScale", "paneScales", "autoScale", "timezone", "keyboard", "historyChords", "priceStyle", "priceBaseline", "baselinePrice", "settings", "attribution", "dialogHost", "tradeMarkers", "marks", "indicatorTitles", "indicatorValues"];
+    this.features = ["logScale", "currentPriceLine", "priceLabel", "countdown", "upColor", "downColor", "glow", "animZoom", "animPan", "animScroll", "animAutoscale", "animLiveBar", "intro", "zoomAnchor", "axisDrag", "paneResize", "candleZOrder", "candleVisible", "seriesOrder", "highlights", "sessionZones", "gridlines", "axisLabels", "scaleMode", "invertScale", "paneScales", "autoScale", "timezone", "keyboard", "historyChords", "priceStyle", "priceBaseline", "baselinePrice", "settings", "attribution", "dialogHost", "tradeMarkers", "marks", "indicatorTitles", "indicatorValues", "crosshairOverride"];
     /** Track cursor proximity to the scroll button on the plot (bubbles from the button too,
      *  so moving onto the button doesn't count as leaving). */
     this.onScrollProximityMove = (e) => {
@@ -29983,6 +30710,9 @@ var NativeRenderer = class {
         this.scene.marks = mergeMarksState(this.scene.marks, value);
         this.markPopover?.close();
         break;
+      case "crosshairOverride":
+        this.scene.crosshairOverride = sanitizeCrosshairOverride(value);
+        break;
       case "keyboard":
         this.setKeyboardEnabled(Boolean(value));
         return;
@@ -30096,6 +30826,8 @@ var NativeRenderer = class {
         return { ...this.scene.tradeMarkers, colors: { ...this.scene.tradeMarkers.colors } };
       case "marks":
         return { visible: this.scene.marks.visible, groups: { ...this.scene.marks.groups } };
+      case "crosshairOverride":
+        return this.scene.crosshairOverride ? { ...this.scene.crosshairOverride } : null;
       case "keyboard":
         return this.keyboardEnabled;
       case "historyChords":
@@ -30674,8 +31406,8 @@ var NativeRenderer = class {
     for (const pane of this.scene.panes.values()) pane.scale = { ...pane.scaleTarget };
     this.modelAlpha = 0;
     const start = performance.now();
-    const step = (now) => {
-      const p = Math.min(1, (now - start) / duration);
+    const step = (now2) => {
+      const p = Math.min(1, (now2 - start) / duration);
       this.scene.bars = p >= 1 ? real : real.map((b, i) => this.revealCandle(b, i, p, n, style));
       this.paintData();
       if (p < 1) {
@@ -30691,8 +31423,8 @@ var NativeRenderer = class {
   fadeInModels() {
     const fade = Math.min(INTRO_MODEL_FADE_MS, this.intro.duration || INTRO_MODEL_FADE_MS);
     const start = performance.now();
-    const step = (now) => {
-      this.modelAlpha = Math.min(1, (now - start) / fade);
+    const step = (now2) => {
+      this.modelAlpha = Math.min(1, (now2 - start) / fade);
       this.paintData();
       if (this.modelAlpha < 1) {
         this.introRaf = requestAnimationFrame(step);
@@ -31215,10 +31947,13 @@ var NativeRenderer = class {
         this.animator.start();
       }
     } else if (!last || bar.time > last.time) {
+      const vp = this.coords.getViewport();
+      const holdView = n > 0 && vp.rightOffset < 0 && this.scrollTargetRO === null;
       this.bars.push(bar);
       this.syncLiveEase(bar);
       if (this.coords.barInterval > 0) this.coords.appendBar(bar.time);
       else this.coords.setBars(this.bars.map((b) => b.time));
+      if (holdView) this.coords.setViewport({ ...vp, rightOffset: vp.rightOffset - 1 });
     } else {
       return;
     }
@@ -31900,10 +32635,10 @@ var NativeRenderer = class {
     if (this.markPulseRaf !== null || typeof requestAnimationFrame !== "function") return;
     const tick = () => {
       this.markPulseRaf = null;
-      const now = frameNow();
-      if (this.scene.marksFlash && this.scene.marksFlash.until <= now) this.scene.marksFlash = null;
+      const now2 = frameNow();
+      if (this.scene.marksFlash && this.scene.marksFlash.until <= now2) this.scene.marksFlash = null;
       this.scheduler?.invalidate(2 /* Chrome */);
-      const pulsing = this.scene.marksHoverKey !== null && now - this.scene.marksHoverSince < MARK_PULSE_MS;
+      const pulsing = this.scene.marksHoverKey !== null && now2 - this.scene.marksHoverSince < MARK_PULSE_MS;
       if (pulsing || this.scene.marksFlash !== null) this.markPulseRaf = requestAnimationFrame(tick);
     };
     this.markPulseRaf = requestAnimationFrame(tick);
@@ -32464,9 +33199,10 @@ var NativeRenderer = class {
     const ext = this.externalCross;
     if (!ext || this.coords.barCount === 0) return null;
     const logical = Math.floor(this.coords.timeToLogical(ext.time));
-    if (logical < 0 || logical >= this.coords.barCount) return null;
-    const x = this.coords.logicalToX(logical);
-    if (!Number.isFinite(x) || x < 0 || x > this.coords.width) return null;
+    if (!(logical < this.coords.barCount)) return null;
+    const x = this.coords.logicalToX(Math.max(logical, -1));
+    if (!Number.isFinite(x)) return null;
+    const line = logical >= 0 && x >= 0 && x <= this.coords.width;
     let y = null;
     if (ext.price != null) {
       const pricePane = this.scene.orderedPanes().find((p) => p.kind === "price");
@@ -32475,7 +33211,7 @@ var NativeRenderer = class {
         if (!Number.isFinite(y) || y < pricePane.bounds.top || y > pricePane.bounds.top + pricePane.bounds.height) y = null;
       }
     }
-    return { x, y, time: this.coords.logicalToTime(logical), price: y != null ? ext.price : null };
+    return { x, y, time: this.coords.logicalToTime(Math.max(logical, 0)), price: y != null ? ext.price : null, line };
   }
   /** Set the sticky magnet mode (called by the drawings toolbar's 3-state button). */
   setSnapMode(mode) {
@@ -37180,6 +37916,7 @@ var Vela = class {
     this.panesControl = new PanesControl(this.orchestrator);
     this.drawingsControl = new DrawingsControl(this.orchestrator.drawings);
     this.marksControl = new MarksControl(this.orchestrator.marks);
+    this.replayControl = new ReplayControl(this.orchestrator);
   }
   /**
    * Register a scripting engine so `addIndicator({ language })` can run that
@@ -37419,6 +38156,16 @@ var Vela = class {
   get marks() {
     return this.marksControl;
   }
+  /**
+   * The chart's bar-replay control surface: rewind to a past bar and reveal the
+   * following ones by hand or on a timer, from the history already loaded —
+   * `await chart.replay.start({ from })`, `chart.replay.play(2000)`, `chart.replay.step()`,
+   * `chart.replay.stop()`. Revealed bars behave like live bars for indicators; live
+   * updates pause meanwhile. Follow it with the `replay:*` events.
+   */
+  get replay() {
+    return this.replayControl;
+  }
   on(event, handler) {
     return this.orchestrator.events.on(event, handler);
   }
@@ -37477,6 +38224,28 @@ function resolveElement(container) {
   return element;
 }
 
+// src/core/replayTicks.ts
+function lowerTimeframeTicks(chart, timeframe) {
+  return async (bar, { end, signal }) => {
+    const { symbol, session } = chart.market;
+    const resolved = symbol ? chart.data.resolve(symbol) : null;
+    const provider = resolved ? chart.data.providerInstance(resolved.provider) : void 0;
+    if (!resolved || !provider) return [];
+    const bars = await provider.getBars(resolved.ticker, timeframe, { from: bar.time, to: end - 1, ...session ? { session } : {} });
+    if (signal.aborted) return [];
+    return barsToTicks(bars.filter((b) => b.time >= bar.time && b.time < end));
+  };
+}
+function barsToTicks(bars) {
+  return bars.map((b) => ({
+    price: b.close,
+    open: b.open,
+    high: b.high,
+    low: b.low,
+    ...b.volume === void 0 ? {} : { volume: b.volume }
+  }));
+}
+
 // src/widget/topbar-composition.ts
 var TOPBAR_BUILTIN_IDS = ["symbol", "timeframes", "style", "layout", "indicators", "actions", "undo-redo", "alerts", "panels", "screenshot"];
 
@@ -37637,6 +38406,7 @@ exports.NEUTRAL = NEUTRAL;
 exports.NativeRenderer = NativeRenderer;
 exports.OVERRIDABLE_TOPBAR_IDS = OVERRIDABLE_TOPBAR_IDS;
 exports.RendererControl = RendererControl;
+exports.ReplayControl = ReplayControl;
 exports.SERIES_LINE = SERIES_LINE;
 exports.SESSION_OFF = SESSION_OFF;
 exports.SESSION_POST = SESSION_POST;
@@ -37651,6 +38421,7 @@ exports.TypedEventBus = TypedEventBus;
 exports.VALID = VALID;
 exports.Vela = Vela;
 exports.WARNING = WARNING;
+exports.barsToTicks = barsToTicks;
 exports.buildToolbar = buildToolbar;
 exports.categoricalColor = categoricalColor;
 exports.chartType = chartType;
@@ -37667,6 +38438,7 @@ exports.inputDeltas = inputDeltas;
 exports.inputVisible = inputVisible;
 exports.legendActions = legendActions;
 exports.legendCallouts = legendCallouts;
+exports.lowerTimeframeTicks = lowerTimeframeTicks;
 exports.nativeIndicatorDescriptors = nativeIndicatorDescriptors;
 exports.nativeIndicatorTypes = nativeIndicatorTypes;
 exports.normalizeSettingsRow = normalizeSettingsRow;