@luxalgo/vela 0.6.10 → 0.6.12

package/dist/{chunk-FFOP37FQ.js → chunk-KV7FDWSL.js}

@@ -1,4 +1,4 @@
-import { deserializeDrawing, chartTypes, rendererLayers, foldBaseModulation, registerChartType, rendererDefaults, getDrawingType, settingsRowVisible, normalizeSettingsRow, TextLabel, Callout, resetDrawingSettings, registerNativeIndicator, chartType, getNativeIndicator, nativeIndicatorDescriptors, drawingTypes, settingsRowValueKeys, formatDuration, RegressionChannel, FixedRangeVolumeProfile, SegmentDrawing, ArrowMark, GlyphStamp, RadialFib, FibSpiral, DedekindTessellation, MachFigure, GannSquare, FibRatios, MeasureBox, PositionTool, AnchoredVwap, PatternDrawing, Comment, PriceNote, Signpost, Note, PriceLabel, GANN_SQUARE_ARCS, lineSegmentIntersection, DEFAULT_DRAWING_COLOR, GLYPH_OPTIONS, STAMP_SIZE_OPTIONS, LINE_STYLE_OPTIONS, DEDEKIND_CURVATURE_OPTIONS, MACH_NUMBER_OPTIONS, MACH_WAVE_COUNT_OPTIONS, TEXT_SIZE_OPTIONS, createDrawing, inputVisible, tickerModifierIds, CalloutBase, DIRECTION_OPTIONS } from './chunk-4KZVZ7QQ.js';
+import { deserializeDrawing, chartTypes, rendererLayers, foldBaseModulation, registerChartType, rendererDefaults, getDrawingType, settingsRowVisible, normalizeSettingsRow, Magnifier, TextLabel, Callout, resetDrawingSettings, registerNativeIndicator, chartType, getNativeIndicator, nativeIndicatorDescriptors, drawingTypes, settingsRowValueKeys, formatDuration, RegressionChannel, FixedRangeVolumeProfile, SegmentDrawing, ArrowMark, GlyphStamp, RadialFib, FibSpiral, DedekindTessellation, MachFigure, GannSquare, FibRatios, MeasureBox, PositionTool, AnchoredVwap, PatternDrawing, Comment, PriceNote, Signpost, Note, PriceLabel, GANN_SQUARE_ARCS, magnifierTimeframeLabel, lineSegmentIntersection, DEFAULT_DRAWING_COLOR, MAGNIFIER_TIMEFRAME_OPTIONS, GLYPH_OPTIONS, STAMP_SIZE_OPTIONS, LINE_STYLE_OPTIONS, DEDEKIND_CURVATURE_OPTIONS, MACH_NUMBER_OPTIONS, MACH_WAVE_COUNT_OPTIONS, TEXT_SIZE_OPTIONS, createDrawing, inputVisible, tickerModifierIds, CalloutBase, DIRECTION_OPTIONS } from './chunk-F4M24ANM.js';
 import { themeTokens, Dialog, closeOpenPopovers, closeWidthPopover, fieldSection, buildFieldControl, fieldSeparator, fieldGrid, fieldRow, blendOver, splitColor, CalloutBubble, Menu, TextArea, Popover, NumberInput, buildColorPicker, isPopoverOpen, eventDismissedPopover, toggleSelectList, openPopoverTrigger, fieldGridColumns, FIELD_GAP_PX, STATIC_TOKENS } from './chunk-MHY7MVXH.js';
 import { icon, iconAt, withAlpha, WARNING, ACCENT, NEUTRAL, BEARISH, BULLISH, isDarkColor, SERIES_LINE, SLATE, CROSSHAIR, TRADE_EXIT, TRADE_SHORT, TRADE_LONG, overlayScrollbarCss, SLATE_DEEP, VALID, INVALID, FIELD_FOCUS_CSS, FIELD_FOCUS_RING, svg24, svg24Solid } from './chunk-KG4YT3TI.js';
 
@@ -62,7 +62,7 @@ var GEOMETRY_TYPES = ["dedekind", "sonic", "supersonic", "goldensonic", "goldens
 var PATTERN_TYPES = ["xabcd", "abcd", "headshoulders"];
 var ELLIOTT_TYPES = ["elliottimpulse", "elliottcorrection"];
 var HARMONIC_TYPES = ["gartley", "bat", "butterfly", "crab", "shark", "cypher"];
-var MEASUREMENT_TYPES = ["position", "datepricerange"];
+var MEASUREMENT_TYPES = ["position", "datepricerange", "magnifier"];
 var VOLUME_TYPES = ["anchoredvwap", "fixedrangevp"];
 var BRUSH_TYPES = ["freehand", "highlighter"];
 var ARROW_TYPES = ["arrow", "arrowmarkup", "arrowmarkdown"];
@@ -1138,6 +1138,7 @@ function intervalMs(timeframe) {
     "4h": 144e5,
     "1d": 864e5,
     "1w": 6048e5,
+    "1M": 2592e6,
     "1": 6e4,
     "5": 3e5,
     "15": 9e5,
@@ -1145,7 +1146,8 @@ function intervalMs(timeframe) {
     "60": 36e5,
     "240": 144e5,
     D: 864e5,
-    W: 6048e5
+    W: 6048e5,
+    M: 2592e6
   };
   return map[timeframe] ?? 36e5;
 }
@@ -1859,7 +1861,7 @@ var DrawingHistory = class {
 
 // src/core/drawings/DrawingController.ts
 var DrawingController = class {
-  constructor(renderer, events, option) {
+  constructor(renderer, events, option, seriesGateway) {
     this.events = events;
     this.store = new DrawingStore();
     this.history = new DrawingHistory();
@@ -1885,6 +1887,7 @@ var DrawingController = class {
       const { definition, visible } = buildToolbar(option);
       this.port.setToolbar(definition);
       this.port.showToolbar(visible);
+      if (seriesGateway) this.port.setSeriesGateway?.(seriesGateway);
       this.subs.push(this.port.onDrawingIntent((i) => this.onIntent(i)));
       this.subs.push(this.store.onChange(() => this.sync()));
     }
@@ -1990,7 +1993,7 @@ var DrawingController = class {
       style,
       text: init.text,
       props: init.props,
-      zIndex: init.zIndex ?? this.startZ(init.paneId ?? "price")
+      zIndex: init.zIndex ?? this.startZ(type, init.paneId ?? "price")
     });
     if (!d) return null;
     this.history.record(this.store.serialize());
@@ -2065,10 +2068,14 @@ var DrawingController = class {
    *  (falling back to just under the pane's top series where there is no price — a study
    *  pane). Half a key down never ties a series; drawings tying each other paint in insertion
    *  order, so consecutive new drawings still stack newest-in-front. Undefined without a
-   *  shared z space — the store then places it over the other drawings, its own layer's top. */
-  startZ(paneId) {
+   *  shared z space — the store then places it over the other drawings, its own layer's top.
+   *  A type that COVERS the series (an opaque inset, `coversSeries`) instead starts just
+   *  above the whole stack — under the candles its content would be buried. */
+  startZ(type, paneId) {
     const range = this.port?.stackRange?.(paneId);
-    return range ? (range.price ?? range.front) - 0.5 : void 0;
+    if (!range) return void 0;
+    if (getDrawingType(type)?.coversSeries) return range.front + 0.5;
+    return (range.price ?? range.front) - 0.5;
   }
   /** Programmatically select drawings (host UI → chart): shows the on-chart handles + toolbar.
    *  `additive` toggles membership (matching shift-click) instead of replacing. */
@@ -2213,7 +2220,7 @@ var DrawingController = class {
         const style = last ? { ...i.doc.style, ...last } : i.doc.style;
         const d = deserializeDrawing({ ...i.doc, id: this.store.nextId(), style });
         if (!d) return;
-        if (!d.zIndex) d.zIndex = this.startZ(d.paneId) ?? 0;
+        if (!d.zIndex) d.zIndex = this.startZ(d.type, d.paneId) ?? 0;
         this.history.record(before);
         this.store.add(d);
         this.captureStyle(d.id);
@@ -6859,6 +6866,7 @@ var DOUBLE_TAP_MS = 350;
 var DOUBLE_TAP_SLOP = 30;
 var TIME_SCALE_K = 4e-3;
 var WHEEL_ZOOM_K = 4e-3;
+var WHEEL_PRICE_DRAG_PX = 0.25;
 function wheelZoomAnchor(coords, cursorX, rightEdge) {
   if (rightEdge) return { logical: coords.rightEdgeLogical, x: coords.width };
   return { logical: coords.xToLogical(cursorX), x: cursorX };
@@ -6989,7 +6997,7 @@ var InputController = class {
         this.capture(e.pointerId);
         return;
       }
-      if (e.shiftKey && this.regionAt(x, y) === "data" && this.deps.drawingsMeasureStart?.(x, y)) {
+      if (e.shiftKey && this.regionAt(x, y) === "data" && this.deps.drawingsMeasureStart?.(x, y, this.snapMode(e))) {
         this.region = "drawing";
         this.capture(e.pointerId);
         return;
@@ -7103,7 +7111,7 @@ var InputController = class {
       const wasTouch = e.pointerType === "touch";
       const tapRelease = this.dragging && !this.moved && (!wasTouch || Math.hypot(x - this.startX, y - this.startY) <= TOUCH_TAP_SLOP);
       if (this.dragging && this.region === "drawing") {
-        this.deps.drawingsPointerUp?.(x, y);
+        this.deps.drawingsPointerUp?.(x, y, this.snapMode(e));
       } else if (tapRelease && this.region === "data") {
         this.deps.onClick(x, y);
       } else if (this.dragging && this.region === "data") {
@@ -7124,7 +7132,7 @@ var InputController = class {
       if (e.pointerType === "touch") this.touches.delete(e.pointerId);
       this.cancelLongPress();
       if (!this.dragging) return;
-      if (this.region === "drawing" && !Number.isNaN(this.cursorX)) this.deps.drawingsPointerUp?.(this.cursorX, this.cursorY);
+      if (this.region === "drawing" && !Number.isNaN(this.cursorX)) this.deps.drawingsPointerUp?.(this.cursorX, this.cursorY, this.snapMode(e));
       if (this.region === "crosshair" || e.pointerType === "touch") this.deps.onPointerMove(null, null);
       this.endGesture(e);
     };
@@ -7140,6 +7148,12 @@ var InputController = class {
     this.onWheel = (e) => {
       e.preventDefault();
       this.deps.drawingsClearTransient?.();
+      const { x, y } = this.local(e);
+      if (this.regionAt(x, y) === "price" && e.deltaY !== 0) {
+        this.deps.beginPriceScale(x, y);
+        this.deps.priceScaleBy(e.deltaY * WHEEL_PRICE_DRAG_PX);
+        return;
+      }
       const coords = this.deps.getCoords();
       const vp = coords.getViewport();
       const pan = wheelPanDelta(e.deltaX, e.deltaY, e.shiftKey);
@@ -7147,9 +7161,8 @@ var InputController = class {
         this.deps.apply({ barSpacing: vp.barSpacing, rightOffset: wheelPanRightOffset(vp.rightOffset, pan, coords.pxPerBar()) });
         return;
       }
-      const cursorX = this.local(e).x;
       const rightEdge = this.rightEdgeZoom && !(e.ctrlKey || e.metaKey);
-      const anchor = wheelZoomAnchor(coords, cursorX, rightEdge);
+      const anchor = wheelZoomAnchor(coords, x, rightEdge);
       const target = clampBarSpacing(vp.barSpacing * Math.exp(-e.deltaY * WHEEL_ZOOM_K));
       this.deps.zoomTo(target, anchor.logical, anchor.x);
     };
@@ -8631,6 +8644,15 @@ function drawingSetEmpty(s) {
 function fontSizePx(size) {
   return size === "auto" ? 12 : namedFontSize(size);
 }
+function lineCoversWindow(a, b, extend, lo, hi) {
+  const minX = Math.min(a, b);
+  const maxX = Math.max(a, b);
+  if (a === b) return a >= lo && a <= hi;
+  if (extend === "both") return true;
+  if (extend === "left") return maxX >= lo;
+  if (extend === "right") return minX <= hi;
+  return maxX >= lo && minX <= hi;
+}
 var DrawingSceneRenderer = class {
   constructor(deps, set = EMPTY_DRAWING_SET) {
     this.deps = deps;
@@ -8684,7 +8706,9 @@ var DrawingSceneRenderer = class {
     const lo = Math.min(from, to);
     const hi = Math.max(from, to);
     const visible = (a, b, extend) => {
-      if (extend !== "none") return true;
+      if (extend === "both") return true;
+      if (extend === "left") return Math.max(a, b) >= lo;
+      if (extend === "right") return Math.min(a, b) <= hi;
       return Math.max(a, b) >= lo && Math.min(a, b) <= hi;
     };
     let min = Infinity;
@@ -8695,7 +8719,7 @@ var DrawingSceneRenderer = class {
     };
     for (const ln of this.set.lines) {
       if (ln.invisible) continue;
-      if (!visible(this.logicalOf(ln.xloc, ln.x1), this.logicalOf(ln.xloc, ln.x2), ln.extend)) continue;
+      if (!lineCoversWindow(this.logicalOf(ln.xloc, ln.x1), this.logicalOf(ln.xloc, ln.x2), ln.extend, lo, hi)) continue;
       fold(ln.y1);
       fold(ln.y2);
     }
@@ -11139,6 +11163,18 @@ function timezoneOptions(current) {
   return [[normalized, tzMenuLabel(normalized, normalized)], ...options];
 }
 
+// src/core/price-styles/BarTransform.ts
+function barTransformFor(style) {
+  return chartType(style)?.barTransform ?? null;
+}
+function parseExtendedTicker(symbol) {
+  const at = symbol.lastIndexOf(";");
+  if (at <= 0 || at === symbol.length - 1) return { symbol, modifier: null, transform: null };
+  const modifier = symbol.slice(at + 1).toLowerCase();
+  if (modifier !== "standard" && !tickerModifierIds().includes(modifier)) return { symbol, modifier: null, transform: null };
+  return { symbol: symbol.slice(0, at), modifier, transform: barTransformFor(modifier) };
+}
+
 // src/renderers/native/drawings/DrawingPainter.ts
 var HANDLE_RADIUS = 4.5;
 var HANDLE_BORDER = DEFAULT_DRAWING_COLOR;
@@ -11158,6 +11194,17 @@ var DrawingPainter = class {
   constructor() {
     /** The current `paintAll` call's interaction state, visible to the per-type painters. */
     this.targets = {};
+    /** The chart's active series LOOK — style + resolved series colors — pushed by the
+     *  controller before each paint. The magnifier's inset mirrors both: candles/bars/line/
+     *  area restyle the paint (bar-transform styles like Heikin Ashi transform the fetched
+     *  bars; unknown/custom styles fall back to candles), and the colors default to the main
+     *  series' own so the inset reads as a finer copy of the chart. */
+    this.seriesLook = {
+      style: "candles",
+      upColor: BULLISH,
+      downColor: BEARISH,
+      lineColor: BULLISH
+    };
   }
   /** Paint every visible drawing, then selection handles for the targeted ones.
    *  Each drawing is clipped to its own pane's rect (and skipped entirely while that pane
@@ -11202,6 +11249,8 @@ var DrawingPainter = class {
     ctx.globalAlpha = GHOST_ALPHA;
     if (ghost instanceof RegressionChannel || ghost instanceof FixedRangeVolumeProfile) {
       this.paintTimeSpanGhost(ctx, ghost, proj);
+    } else if (ghost instanceof Magnifier) {
+      this.paintMagnifierGhost(ctx, ghost, proj, theme);
     } else this.paintOne(ctx, ghost, proj, theme);
     ctx.globalAlpha = 1;
   }
@@ -11335,6 +11384,10 @@ var DrawingPainter = class {
       this.paintLabel(ctx, d, proj, theme);
       return;
     }
+    if (d instanceof Magnifier) {
+      this.paintMagnifier(ctx, d, proj, theme);
+      return;
+    }
     if (d instanceof PatternDrawing) {
       this.paintPattern(ctx, d, proj, theme);
       return;
@@ -11827,6 +11880,216 @@ var DrawingPainter = class {
       ctx.textBaseline = "alphabetic";
     }
   }
+  /** Placement preview for the magnifier: a dashed rectangle outline only — no backdrop and
+   *  no series read, so dragging the area open never kicks a fetch per cursor move. */
+  paintMagnifierGhost(ctx, d, proj, theme) {
+    const r = d.rect(proj);
+    if (!r) return;
+    ctx.save();
+    ctx.strokeStyle = d.style.lineColor || contrastColor(theme.background);
+    ctx.lineWidth = 1;
+    ctx.setLineDash([4, 4]);
+    ctx.strokeRect(Math.min(r.x1, r.x2), Math.min(r.y1, r.y2), Math.abs(r.x2 - r.x1), Math.abs(r.y2 - r.y1));
+    ctx.restore();
+  }
+  /** Paint a magnifier: an opaque theme-background inset whose interior shows the chart's
+   *  market at a finer timeframe — candles at their true time/price positions, clipped to
+   *  the rectangle. Bars come through `Projector.seriesInRange` (cache read; `loading` and
+   *  `unavailable` states paint a short notice instead). The lower-timeframe candles shift
+   *  half a chart bar LEFT of their raw time pixel so each chart candle's visual cell —
+   *  centered on its open time — subdivides in place. */
+  paintMagnifier(ctx, d, proj, theme) {
+    const r = d.rect(proj);
+    const a = d.anchors[0];
+    const b = d.anchors[1];
+    if (!r || !a || !b) return;
+    const x0 = Math.min(r.x1, r.x2);
+    const x1 = Math.max(r.x1, r.x2);
+    const y0 = Math.min(r.y1, r.y2);
+    const y1 = Math.max(r.y1, r.y2);
+    const w = x1 - x0;
+    const h = y1 - y0;
+    ctx.save();
+    ctx.globalAlpha = 1;
+    ctx.fillStyle = theme.background;
+    ctx.fillRect(x0, y0, w, h);
+    ctx.restore();
+    const from = Math.min(a.time, b.time);
+    const to = Math.max(a.time, b.time);
+    const chartBars = proj.barsBetween ? proj.barsBetween(from, to) : 0;
+    const chartMs = chartBars > 0 ? (to - from) / chartBars : 0;
+    const res = proj.seriesInRange && chartMs > 0 && w > 1 && h > 1 ? proj.seriesInRange(d.magnifier.timeframe, from, to + chartMs) : void 0;
+    let seriesBars = res?.state === "ready" || res?.state === "loading" ? res.bars ?? [] : [];
+    if (res && (res.state === "ready" || res.state === "loading") && seriesBars.length > 0) {
+      const look = this.seriesLook;
+      const transform = look.style !== "candles" ? barTransformFor(look.style) : null;
+      if (transform) seriesBars = transform.full(seriesBars);
+      const mode = look.style === "bars" ? "bars" : look.style === "line" || look.style === "baseline" ? "line" : look.style === "area" ? "area" : "candles";
+      const halfPitch = (proj.xOf(from + chartMs) - proj.xOf(from)) / 2;
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(x0, y0, w, h);
+      ctx.clip();
+      if (mode === "line" || mode === "area") {
+        this.paintMagnifierLine(ctx, d, proj, seriesBars, res.barMs, halfPitch, y1, mode === "area", d.magnifier.upColor || look.lineColor);
+      } else {
+        this.paintMagnifierBars(ctx, d, proj, seriesBars, res.barMs, halfPitch, x0, x1, mode, d.magnifier.upColor || look.upColor, d.magnifier.downColor || look.downColor);
+      }
+      ctx.restore();
+    } else if (res) {
+      const notice = res.state === "loading" ? "Loading\u2026" : res.state === "ready" ? "No lower-timeframe data" : res.reason === "too-wide" ? "Area too wide for this timeframe" : res.reason === "none-lower" ? "No lower timeframe available" : res.reason === "not-lower" ? "Pick a timeframe below the chart" : "No data source";
+      this.paintMagnifierNotice(ctx, notice, x0, y0, w, h, theme);
+    }
+    ctx.save();
+    ctx.strokeStyle = d.style.lineColor || contrastColor(theme.background);
+    ctx.lineWidth = d.style.lineWidth || 1;
+    ctx.setLineDash(dashPattern(d.style.lineStyle, d.style.lineWidth || 1));
+    ctx.strokeRect(x0, y0, w, h);
+    ctx.restore();
+    if (w > 44) {
+      const label = magnifierTimeframeLabel(res?.state === "ready" || res?.state === "loading" ? res.timeframe : d.magnifier.timeframe);
+      const chipH = 17;
+      const gap = 4;
+      const pane = proj.paneRect?.(d.paneId);
+      const paneBottom = pane ? pane.top + pane.height : proj.height;
+      const below = y1 + gap + chipH <= paneBottom;
+      const chipY = below ? y1 + gap : y1 - gap - chipH;
+      ctx.save();
+      ctx.font = `10px ${theme.fontFamily}`;
+      const tw = ctx.measureText(label).width;
+      const caretW = 11;
+      const chipW = tw + 12 + caretW;
+      roundRect(ctx, x0, chipY, chipW, chipH, 3);
+      ctx.fillStyle = theme.background;
+      ctx.fill();
+      ctx.strokeStyle = withAlpha(theme.textColor, 0.28);
+      ctx.lineWidth = 1;
+      ctx.setLineDash([]);
+      ctx.stroke();
+      ctx.fillStyle = theme.textColor;
+      ctx.textAlign = "left";
+      ctx.textBaseline = "middle";
+      ctx.fillText(label, x0 + 6, chipY + chipH / 2 + 0.5);
+      const cxr = x0 + 6 + tw + 5;
+      const cyr = chipY + chipH / 2;
+      ctx.strokeStyle = withAlpha(theme.textColor, 0.7);
+      ctx.lineWidth = 1.2;
+      ctx.beginPath();
+      ctx.moveTo(cxr, cyr - 1.5);
+      ctx.lineTo(cxr + 2.5, cyr + 1.5);
+      ctx.lineTo(cxr + 5, cyr - 1.5);
+      ctx.stroke();
+      ctx.restore();
+      d.chipRect = { x: x0, y: chipY, w: chipW, h: chipH };
+    } else {
+      d.chipRect = null;
+    }
+  }
+  /** The magnifier's candle/bar loop: each bar's cell spans its open→close time (shifted left
+   *  by half a chart bar). Candles: wick always, body once the cell is wide enough to carry
+   *  one. OHLC bars: the high–low spine with open/close ticks once the cell has the room. */
+  paintMagnifierBars(ctx, d, proj, bars, barMs, halfPitch, x0, x1, mode, upColor, downColor) {
+    ctx.setLineDash([]);
+    ctx.lineWidth = 1;
+    for (const bar of bars) {
+      const cx0 = proj.xOf(bar.time) - halfPitch;
+      const cx1 = proj.xOf(bar.time + barMs) - halfPitch;
+      if (cx1 < x0 || cx0 > x1) continue;
+      const yHigh = proj.yOf(bar.high, d.paneId);
+      const yLow = proj.yOf(bar.low, d.paneId);
+      const yOpen = proj.yOf(bar.open, d.paneId);
+      const yClose = proj.yOf(bar.close, d.paneId);
+      if (yHigh == null || yLow == null || yOpen == null || yClose == null) continue;
+      const color = bar.close >= bar.open ? upColor : downColor;
+      const cellW = cx1 - cx0;
+      const cx = (cx0 + cx1) / 2;
+      ctx.strokeStyle = color;
+      ctx.beginPath();
+      ctx.moveTo(cx, yHigh);
+      ctx.lineTo(cx, yLow);
+      ctx.stroke();
+      if (cellW < 3) continue;
+      if (mode === "bars") {
+        const tick = Math.max(1, cellW * 0.35);
+        ctx.beginPath();
+        ctx.moveTo(cx - tick, yOpen);
+        ctx.lineTo(cx, yOpen);
+        ctx.moveTo(cx, yClose);
+        ctx.lineTo(cx + tick, yClose);
+        ctx.stroke();
+      } else {
+        const bw = Math.max(1, cellW * 0.7);
+        ctx.fillStyle = color;
+        ctx.fillRect(cx - bw / 2, Math.min(yOpen, yClose), bw, Math.max(1, Math.abs(yClose - yOpen)));
+      }
+    }
+  }
+  /** The magnifier's line/area rendering: a close polyline through each cell's center (same
+   *  half-chart-bar shift as the candles), with an optional translucent fill down to the
+   *  rectangle's bottom edge for the area style. Colored like the chart's own line series. */
+  paintMagnifierLine(ctx, d, proj, bars, barMs, halfPitch, yBottom, area, color) {
+    const pts = [];
+    for (const bar of bars) {
+      const y = proj.yOf(bar.close, d.paneId);
+      if (y == null) continue;
+      pts.push([proj.xOf(bar.time + barMs / 2) - halfPitch, y]);
+    }
+    if (pts.length < 2) return;
+    if (area) {
+      ctx.beginPath();
+      ctx.moveTo(pts[0][0], yBottom);
+      for (const [px, py] of pts) ctx.lineTo(px, py);
+      ctx.lineTo(pts[pts.length - 1][0], yBottom);
+      ctx.closePath();
+      ctx.fillStyle = withAlpha(color, 0.15);
+      ctx.fill();
+    }
+    ctx.setLineDash([]);
+    ctx.lineWidth = 1.5;
+    ctx.strokeStyle = color;
+    ctx.beginPath();
+    ctx.moveTo(pts[0][0], pts[0][1]);
+    for (let i = 1; i < pts.length; i += 1) ctx.lineTo(pts[i][0], pts[i][1]);
+    ctx.stroke();
+  }
+  /** Centered muted notice inside the magnifier rect (loading / unavailable states). */
+  paintMagnifierNotice(ctx, text, x0, y0, w, h, theme) {
+    if (w < 60 || h < 20) return;
+    ctx.save();
+    ctx.beginPath();
+    ctx.rect(x0, y0, w, h);
+    ctx.clip();
+    ctx.font = `11px ${theme.fontFamily}`;
+    ctx.fillStyle = withAlpha(theme.textColor, 0.55);
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillText(text, x0 + w / 2, y0 + h / 2);
+    ctx.restore();
+  }
+  /** A bottom-center pill prompting the armed tool's placement gesture (e.g. the magnifier's
+   *  "drag an area"). Painted by the drawings layer while the tool is armed and no placement
+   *  is in progress; chart-background fill so it reads as chrome over any content. */
+  paintPlacementHint(ctx, text, theme, width, height) {
+    ctx.save();
+    ctx.font = `11px ${theme.fontFamily}`;
+    const tw = ctx.measureText(text).width;
+    const pillW = tw + 24;
+    const pillH = 24;
+    const x = (width - pillW) / 2;
+    const y = height - pillH - 14;
+    roundRect(ctx, x, y, pillW, pillH, pillH / 2);
+    ctx.fillStyle = theme.background;
+    ctx.fill();
+    ctx.strokeStyle = withAlpha(theme.textColor, 0.28);
+    ctx.lineWidth = 1;
+    ctx.setLineDash([]);
+    ctx.stroke();
+    ctx.fillStyle = theme.textColor;
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillText(text, width / 2, y + pillH / 2 + 0.5);
+    ctx.restore();
+  }
   /** Paint a fixed-range volume profile: horizontal histogram rows (up/down split) anchored to
    *  the left or right of the time span, optional VAH / VAL / POC levels across the range, and
    *  optional developing POC / VA polylines. Recomputes from the two anchors on every paint. */
@@ -12545,6 +12808,22 @@ var DrawingInteraction = class {
     this.snapAt = changed ? { point: snapped, paneId } : null;
     return snapped;
   }
+  /**
+   * Resolve a cursor pixel through the magnet and return the snapped pixel — the same
+   * conversion drawing placement uses. Updates the snap-ring marker. The measure
+   * ruler goes through this so its endpoints follow weak/strong/Ctrl magnet too.
+   */
+  snapCursor(x, y, mode) {
+    const proj = this.deps.projector();
+    const paneId = proj.paneIdAtY(y) ?? "price";
+    const point = this.resolve(x, y, paneId, mode);
+    const sy = proj.yOf(point.price, paneId);
+    return { x: proj.xOf(point.time), y: sy ?? y };
+  }
+  /** Drop the snap-ring marker (a transient mode ended without going through `up`). */
+  clearSnapMarker() {
+    this.snapAt = null;
+  }
   /** Resolve a pixel to a data point with the segment angle locked to 45° steps around
    *  `pivot` (Shift held on a line tool). Works in PIXEL space — the user reasons about
    *  the angle they see, not about time/price units. The magnet is bypassed: snapping
@@ -13226,8 +13505,9 @@ function ensureStyles4() {
   if (!existing) document.head.appendChild(s);
 }
 var DrawingSettingsPopup = class {
-  constructor(host, theme) {
+  constructor(host, theme, chartBarMs = () => 0) {
     this.host = host;
+    this.chartBarMs = chartBarMs;
     this.el = null;
     this.tipEl = null;
     // floating hover-label (above/below the toolbar)
@@ -13252,6 +13532,14 @@ var DrawingSettingsPopup = class {
     this.theme = theme;
     this.settingsDialog = new DrawingSettingsDialog(host, theme);
   }
+  /** The magnifier timeframe choices strictly below the chart's own bar duration
+   *  (`auto` rides along while at least one concrete lower step exists). */
+  lowerTimeframeOptions() {
+    const chartMs = this.chartBarMs();
+    if (!(chartMs > 0)) return [...MAGNIFIER_TIMEFRAME_OPTIONS];
+    const lower = MAGNIFIER_TIMEFRAME_OPTIONS.filter((o) => o.ms > 0 && o.ms < chartMs);
+    return lower.length > 0 ? [MAGNIFIER_TIMEFRAME_OPTIONS[0], ...lower] : [];
+  }
   setTheme(theme) {
     this.theme = theme;
     this.settingsDialog.setTheme(theme);
@@ -13294,7 +13582,20 @@ var DrawingSettingsPopup = class {
       const sz = drawing.size ?? "normal";
       bar.appendChild(this.dropdown("Icon size", STAMP_SIZE_OPTIONS, sz, (s) => stampSizeIcon(s), (v) => actions.patch({ size: v }), { label: sizeLabel }));
     }
-    if (paths.has("style.lineColor")) bar.appendChild(this.colorButton("Line color", BRUSH_ICON, drawing.style.lineColor || DEFAULT_DRAWING_COLOR, (v) => actions.patch({ "style.lineColor": v })));
+    if (paths.has("magnifier.timeframe") && drawing instanceof Magnifier) {
+      const options = this.lowerTimeframeOptions();
+      if (options.length > 0) {
+        bar.appendChild(
+          this.dropdown("Lower timeframe", options.map((o) => o.value), drawing.magnifier.timeframe, () => "", (v) => actions.patch({ "magnifier.timeframe": v }), {
+            label: (v) => magnifierTimeframeLabel(String(v)),
+            labelInTrigger: true
+          })
+        );
+      }
+      bar.appendChild(this.colorButton("Up candles", BUCKET_ICON, drawing.magnifier.upColor || t.upColor, (v) => actions.patch({ "magnifier.upColor": v })));
+      bar.appendChild(this.colorButton("Down candles", BUCKET_ICON, drawing.magnifier.downColor || t.downColor, (v) => actions.patch({ "magnifier.downColor": v })));
+    }
+    if (paths.has("style.lineColor")) bar.appendChild(this.colorButton("Line color", BRUSH_ICON, drawing.style.lineColor || (drawing instanceof Magnifier ? contrastColor(this.theme.background) : DEFAULT_DRAWING_COLOR), (v) => actions.patch({ "style.lineColor": v })));
     if (paths.has("style.lineWidth")) {
       const wf = schema.fields.find((f) => f.path === "style.lineWidth");
       if (wf?.kind === "number" && (wf.min ?? 1) > 1) {
@@ -13616,6 +13917,7 @@ var DrawingSettingsPopup = class {
           this.colorPop = null;
           this.colorOwner = null;
         }
+        opts.onClose?.();
       }
     });
     const el = pop.el;
@@ -13634,6 +13936,49 @@ var DrawingSettingsPopup = class {
     pop.show();
     return pop;
   }
+  /**
+   * A standalone timeframe menu for the magnifier's ON-CHART chip. The chip lives on
+   * canvas, so a transient invisible anchor is dropped at its pixel rect for the popover
+   * to position against, and removed again when the menu closes. Independent of the
+   * quick toolbar — the chip works without selecting the drawing first.
+   */
+  openMagnifierTimeframeMenu(rect, current, onPick) {
+    ensureStyles4();
+    closeOpenPopovers();
+    const options = this.lowerTimeframeOptions();
+    const anchor = document.createElement("div");
+    anchor.style.cssText = `position:absolute;left:${rect.x}px;top:${rect.y}px;width:${rect.w}px;height:${rect.h}px;pointer-events:none;`;
+    this.host.appendChild(anchor);
+    this.menuPop = this.hostFloat(anchor, {
+      zIndex: 26,
+      padding: "4px",
+      onClose: () => anchor.remove(),
+      fill: (menu, pop) => {
+        if (options.length === 0) {
+          const note = document.createElement("div");
+          note.style.cssText = "padding:6px 10px;opacity:0.65;white-space:nowrap;";
+          note.textContent = "No lower timeframe available";
+          menu.appendChild(note);
+          return;
+        }
+        for (const o of options) {
+          const item = document.createElement("button");
+          item.type = "button";
+          item.className = "vela-dpop-item";
+          item.dataset.active = o.value === current ? "1" : "0";
+          item.style.cssText = "display:flex;align-items:center;min-width:88px;padding:5px 10px;border:none;border-radius:5px;color:inherit;cursor:pointer;text-align:left;font:inherit;font-variant-numeric:tabular-nums;";
+          item.textContent = o.label;
+          item.addEventListener("click", (e) => {
+            e.stopPropagation();
+            pop.hide();
+            onPick(o.value);
+          });
+          menu.appendChild(item);
+        }
+      }
+    });
+    this.menuOwner = anchor;
+  }
   /** A floating list of one-shot actions (icon + label rows) opened by the kebab. */
   openActionMenu(anchor, rows) {
     this.menuPop = this.hostFloat(anchor, {
@@ -13744,10 +14089,13 @@ var DrawingSettingsPopup = class {
     let cur = current;
     const paint = (v) => {
       b.replaceChildren();
-      const ic = document.createElement("span");
-      ic.style.cssText = "display:flex;";
-      ic.innerHTML = sized(render(v));
-      b.appendChild(ic);
+      const glyph = render(v);
+      if (glyph) {
+        const ic = document.createElement("span");
+        ic.style.cssText = "display:flex;";
+        ic.innerHTML = sized(glyph);
+        b.appendChild(ic);
+      }
       if (opts.label && opts.labelInTrigger) {
         const tx = document.createElement("span");
         tx.textContent = opts.label(v);
@@ -13789,10 +14137,13 @@ var DrawingSettingsPopup = class {
           item.className = "vela-dpop-item";
           item.dataset.active = active ? "1" : "0";
           item.style.cssText = `display:flex;align-items:center;gap:8px;${label ? "min-width:118px;" : ""}padding:5px 8px;border:none;border-radius:5px;color:inherit;cursor:pointer;text-align:left;font:inherit;`;
-          const ic = document.createElement("span");
-          ic.style.cssText = "display:flex;flex:none;width:22px;justify-content:center;";
-          ic.innerHTML = sized(render(v), 18);
-          item.appendChild(ic);
+          const glyph = render(v);
+          if (glyph) {
+            const ic = document.createElement("span");
+            ic.style.cssText = "display:flex;flex:none;width:22px;justify-content:center;";
+            ic.innerHTML = sized(glyph, 18);
+            item.appendChild(ic);
+          }
           if (label) {
             const tx = document.createElement("span");
             tx.textContent = label(v);
@@ -13950,30 +14301,39 @@ var MeasureOverlay = class {
   isFinished() {
     return this.state === "finished";
   }
-  /** A press: begin the measurement, or finish it on the second click. */
-  down(x, y) {
+  /** A press: begin the measurement, or finish it on the second click.
+   *  `x,y` are the raw cursor (drag-slop vs click-move-click). `gx,gy` are the
+   *  graphic endpoints — magnet-snapped when the magnet is on, else the same as `x,y`. */
+  down(x, y, gx = x, gy = y) {
     if (this.state === "measuring") {
-      this.end = { x, y };
+      this.end = { x: gx, y: gy };
       this.state = "finished";
       return;
     }
-    this.start = { x, y };
-    this.end = { x, y };
+    this.start = { x: gx, y: gy };
+    this.end = { x: gx, y: gy };
     this.pressX = x;
     this.pressY = y;
     this.state = "measuring";
   }
+  /** Size the in-progress ruler. `x,y` are the graphic (magnet-snapped) cursor. */
   move(x, y) {
     if (this.state === "measuring") this.end = { x, y };
   }
   /** A release: finish if the press was actually dragged (press-drag-release), else wait
-   *  for the second click (click-move-click). */
-  up(x, y) {
+   *  for the second click (click-move-click). `x,y` are the raw cursor (slop); `gx,gy`
+   *  are the graphic end (magnet-snapped when the magnet is on). */
+  up(x, y, gx = x, gy = y) {
     if (this.state === "measuring" && Math.hypot(x - this.pressX, y - this.pressY) > DRAG_SLOP3) {
-      this.end = { x, y };
+      this.end = { x: gx, y: gy };
       this.state = "finished";
     }
   }
+  /** Current graphic endpoints in media pixels, or null when idle. */
+  points() {
+    if (!this.start || !this.end) return null;
+    return { start: this.start, end: this.end };
+  }
   clear() {
     this.state = "idle";
     this.start = null;
@@ -14135,6 +14495,9 @@ var UserDrawingController = class {
     this.intentCb = null;
     /** Another chart's in-progress placement, mirrored here as a ghost (drawings sync). */
     this.externalGhost = null;
+    /** Core-pushed series gateway (finer-timeframe bars for data-driven drawings). */
+    this.seriesGw = null;
+    this.seriesGwUnsub = null;
     /** Last draft fingerprint reported upstream — gates the per-render emission to actual changes. */
     this.lastDraftKey = null;
     this.measure = new MeasureOverlay();
@@ -14162,7 +14525,7 @@ var UserDrawingController = class {
     this.textEditor = null;
     this.painter = new DrawingPainter();
     this.ctx = canvas.getContext("2d");
-    this.popup = new DrawingSettingsPopup(overlayHost, deps.theme());
+    this.popup = new DrawingSettingsPopup(overlayHost, deps.theme(), () => deps.chartBarMs());
     this.toolbar = new DrawingToolbar(
       toolbarHost,
       deps.theme(),
@@ -14220,6 +14583,22 @@ var UserDrawingController = class {
     const shown = this.toolbarVisible && !this.mobileLayout;
     this.deps.setToolbarGutter(shown ? this.toolbarCollapsed ? TOOLBAR_COLLAPSED_WIDTH : TOOLBAR_WIDTH : 0);
   }
+  /** Core push: the series gateway data-driven drawings read finer-timeframe bars
+   *  through (surfaced to them as `Projector.seriesInRange`). A landed background
+   *  fetch repaints both this layer and the interleave slices under the series. */
+  setSeriesGateway(gateway) {
+    this.seriesGwUnsub?.();
+    this.seriesGw = gateway;
+    this.seriesGwUnsub = gateway.onUpdate(() => {
+      this.invalidateSlices();
+      this.render();
+      this.deps.requestDataPaint();
+    });
+  }
+  /** The pushed series gateway, or null before the core provides one. */
+  get seriesGateway() {
+    return this.seriesGw;
+  }
   /** Core push: mirror (or clear) another chart's in-progress placement as a ghost. */
   setExternalGhost(doc) {
     this.externalGhost = doc ? deserializeDrawing(doc) : null;
@@ -14337,8 +14716,34 @@ var UserDrawingController = class {
   /** Should the drawing layer win this press (vs pan)? */
   claim(x, y) {
     if (this.measureMode || this.eraserMode) return true;
+    if (this.magnifierChipAt(x, y)) return true;
     return this.interaction.claim(x, y);
   }
+  /** The topmost visible (unlocked) magnifier whose timeframe chip contains (x, y) —
+   *  the chip's rect is what the painter measured last frame. */
+  magnifierChipAt(x, y) {
+    for (let i = this.drawings.length - 1; i >= 0; i -= 1) {
+      const d = this.drawings[i];
+      if (!(d instanceof Magnifier) || !d.visible || d.locked) continue;
+      const r = d.chipRect;
+      if (r && x >= r.x && x <= r.x + r.w && y >= r.y && y <= r.y + r.h) return d;
+    }
+    return null;
+  }
+  /** Open the on-chart chip's timeframe menu; the pick patches the drawing like a
+   *  settings-popup edit (same intent, same undo step). */
+  openMagnifierChipMenu(drawing) {
+    const rect = drawing.chipRect;
+    if (!rect) return;
+    const id = drawing.id;
+    this.popup.openMagnifierTimeframeMenu(rect, drawing.magnifier.timeframe, (value) => {
+      const d = this.drawings.find((x) => x.id === id);
+      if (!(d instanceof Magnifier)) return;
+      d.applySettings({ "magnifier.timeframe": value });
+      this.render();
+      this.emit({ kind: "edit", doc: d.serialize() });
+    });
+  }
   /** Delete the (unlocked) drawing under the cursor. True when one was removed.
    *  Shared by the eraser (click + drag) and the middle-click shortcut. */
   deleteAt(x, y) {
@@ -14350,11 +14755,13 @@ var UserDrawingController = class {
   }
   /** Shift+press on the empty plot: arm the measure ruler AND start it at (x, y) in one
    *  gesture — the equivalent of clicking the toolbar's Measure button, then pressing.
-   *  Returns false when a mode/tool is already active (the normal press path owns it). */
-  beginMeasureAt(x, y) {
+   *  `snap` is the effective magnet (sticky mode, or Ctrl/Cmd-forced strong). Returns
+   *  false when a mode/tool is already active (the normal press path owns it). */
+  beginMeasureAt(x, y, snap = "off") {
     if (this.measureMode || this.eraserMode || this.activeTool != null) return false;
     this.withModeIntent(() => this.toggleMeasure());
-    this.measure.down(x, y);
+    const g = this.interaction.snapCursor(x, y, snap);
+    this.measure.down(x, y, g.x, g.y);
     this.render();
     return true;
   }
@@ -14376,11 +14783,19 @@ var UserDrawingController = class {
       return;
     }
     if (this.measureMode) {
-      this.measure.down(x, y);
+      const g = this.interaction.snapCursor(x, y, snap);
+      this.measure.down(x, y, g.x, g.y);
       if (this.measure.isFinished()) this.withModeIntent(() => this.exitMeasure(false));
       this.render();
       return;
     }
+    if (this.activeTool == null) {
+      const chipOwner = this.magnifierChipAt(x, y);
+      if (chipOwner) {
+        this.openMagnifierChipMenu(chipOwner);
+        return;
+      }
+    }
     this.interaction.down(x, y, snap, shift);
   }
   pointerMove(x, y, snap = "off", shift = false) {
@@ -14389,7 +14804,8 @@ var UserDrawingController = class {
       return;
     }
     if (this.measureMode) {
-      this.measure.move(x, y);
+      const g = this.interaction.snapCursor(x, y, snap);
+      this.measure.move(g.x, g.y);
       this.render();
       return;
     }
@@ -14407,13 +14823,14 @@ var UserDrawingController = class {
       this.render();
     }
   }
-  pointerUp(x, y) {
+  pointerUp(x, y, snap = "off") {
     if (this.eraserMode) {
       this.erasing = false;
       return;
     }
     if (this.measureMode) {
-      this.measure.up(x, y);
+      const g = this.interaction.snapCursor(x, y, snap);
+      this.measure.up(x, y, g.x, g.y);
       if (this.measure.isFinished()) this.withModeIntent(() => this.exitMeasure(false));
       this.render();
       return;
@@ -14458,6 +14875,7 @@ var UserDrawingController = class {
   /** Leave ruler mode. `clearGraphic` keeps a just-finished measurement on screen (false). */
   exitMeasure(clearGraphic = true) {
     this.measureMode = false;
+    this.interaction.clearSnapMarker();
     if (clearGraphic) this.measure.clear();
     this.toolbar.setMeasureActive(false);
     this.render();
@@ -14596,17 +15014,31 @@ var UserDrawingController = class {
   /** Cursor hint while hovering — `'pointer'` over a drawing/handle, else null. */
   cursorAt(x, y) {
     if (this.eraserMode) return "pointer";
+    if (this.activeTool == null && this.magnifierChipAt(x, y)) return "pointer";
     return this.interaction.cursorAt(x, y);
   }
-  /** Right-click while placing: cancel the in-progress drawing and revert to the
-   *  pointer — the gesture is an explicit escape, so it disarms even in
-   *  stay-in-drawing-mode (where Escape would leave the tool armed). Returns whether
-   *  the press was consumed; false lets the host's context menu open normally. */
+  /** Right-click: an explicit escape back to the pointer. Cancels an in-progress
+   *  placement or measurement, and also plain-disarms an armed-but-idle drawing
+   *  tool or the eraser — so a right-click ALWAYS reverts to the pointer, even in
+   *  stay-in-drawing-mode (where Escape would leave a drawing tool armed).
+   *  Persistent toggles (magnet, stay-mode, favorites) are untouched. Returns
+   *  whether the press was consumed; false lets the host's context menu open
+   *  normally. */
   cancelPlacement() {
-    if (!this.interaction.isPlacing()) return false;
-    this.interaction.cancel();
-    if (this.activeTool != null) this.emit({ kind: "arm", type: null });
-    return true;
+    if (this.measureMode || this.eraserMode) {
+      this.withModeIntent(() => this.measureMode ? this.exitMeasure() : this.exitEraser());
+      return true;
+    }
+    if (this.interaction.isPlacing()) {
+      this.interaction.cancel();
+      if (this.activeTool != null) this.emit({ kind: "arm", type: null });
+      return true;
+    }
+    if (this.activeTool != null) {
+      this.emit({ kind: "arm", type: null });
+      return true;
+    }
+    return false;
   }
   /** Double-click over a drawing → suppress the chart's view reset (single-click already
    *  opens settings). Returns true only when a drawing is under the cursor. */
@@ -14632,6 +15064,10 @@ var UserDrawingController = class {
         return true;
       }
       if (this.interaction.cancel()) return true;
+      if (this.measureMode) {
+        this.withModeIntent(() => this.exitMeasure());
+        return true;
+      }
       if (this.selectedIds.size) {
         this.clearSelection();
         return true;
@@ -14757,6 +15193,7 @@ var UserDrawingController = class {
       if (!sctx) continue;
       sctx.setTransform(dpr, 0, 0, dpr, 0, 0);
       sctx.clearRect(0, 0, canvas.width / dpr, canvas.height / dpr);
+      this.painter.seriesLook = this.deps.seriesLook();
       this.painter.paintAll(sctx, drawings, proj, theme, EMPTY_TARGETS);
       const slices = out.get(paneId) ?? [];
       slices.push({ beforeZ, canvas });
@@ -14784,6 +15221,7 @@ var UserDrawingController = class {
       dragged: this.interaction.activeDragId(),
       mutedLabel: edited instanceof TextLabel ? edited.id : null
     };
+    this.painter.seriesLook = this.deps.seriesLook();
     this.painter.paintAll(ctx, this.drawings.filter((d) => !this.isInterleaved(d)), proj, this.deps.theme(), targets);
     this.painter.paintHighlights(ctx, this.drawings.filter((d) => this.isInterleaved(d)), proj, handleIdsFor(targets));
     this.layoutTextEditor();
@@ -14791,6 +15229,10 @@ var UserDrawingController = class {
     if (ghost) this.painter.paintGhost(ctx, ghost, proj, this.deps.theme());
     if (this.externalGhost) this.painter.paintGhost(ctx, this.externalGhost, proj, this.deps.theme());
     this.emitDraft(ghost);
+    if (this.activeTool && !ghost) {
+      const hint = getDrawingType(this.activeTool)?.placementHint;
+      if (hint) this.painter.paintPlacementHint(ctx, hint, this.deps.theme(), proj.width, proj.height);
+    }
     const markers = this.interaction.placingMarkers(proj);
     if (markers) this.painter.paintHandles(ctx, markers);
     const m = this.interaction.snapMarker();
@@ -14802,6 +15244,9 @@ var UserDrawingController = class {
     this.closeTextEditor();
     this.popup.destroy();
     this.toolbar.destroy();
+    this.seriesGwUnsub?.();
+    this.seriesGwUnsub = null;
+    this.seriesGw = null;
     this.intentCb = null;
     this.drawings = [];
   }
@@ -15199,7 +15644,7 @@ function mergeSlices(indicator, user) {
 }
 
 // src/renderers/native/drawings/Projector.ts
-function createProjector(coords, paneOf, paneIdAtY, barsInRange) {
+function createProjector(coords, paneOf, paneIdAtY, barsInRange, seriesInRange) {
   return {
     xOf: (time) => coords.timeToX(time),
     yOf: (price, paneId) => {
@@ -15220,6 +15665,7 @@ function createProjector(coords, paneOf, paneIdAtY, barsInRange) {
     },
     barsBetween: (t1, t2) => Math.abs(coords.timeToLogical(t2) - coords.timeToLogical(t1)),
     barsInRange: barsInRange ? (from, to) => barsInRange(from, to) : void 0,
+    seriesInRange,
     width: coords.width,
     height: coords.height
   };
@@ -17164,13 +17610,13 @@ var NativeRenderer = class {
       resetView: () => this.resetView(),
       // User drawings claim a gesture before pan when armed / over a drawing.
       drawingsClaim: (x, y) => this.userDrawings?.claim(x, y) ?? false,
-      drawingsMeasureStart: (x, y) => this.userDrawings?.beginMeasureAt(x, y) ?? false,
+      drawingsMeasureStart: (x, y, snap) => this.userDrawings?.beginMeasureAt(x, y, snap) ?? false,
       drawingsDeleteAt: (x, y) => this.userDrawings?.deleteAt(x, y) ?? false,
       drawingsCancelPlacement: () => this.userDrawings?.cancelPlacement() ?? false,
       drawingsSnapMode: () => this.snapMode,
       drawingsPointerDown: (x, y, snap, shift) => this.userDrawings?.pointerDown(x, y, snap, shift),
       drawingsPointerMove: (x, y, snap, shift) => this.userDrawings?.pointerMove(x, y, snap, shift),
-      drawingsPointerUp: (x, y) => this.userDrawings?.pointerUp(x, y),
+      drawingsPointerUp: (x, y, snap) => this.userDrawings?.pointerUp(x, y, snap),
       drawingsCursor: (x, y) => this.userDrawings?.cursorAt(x, y) ?? null,
       drawingsDblClick: (x, y) => this.userDrawings?.dblClick(x, y) ?? false,
       drawingsClearTransient: () => this.userDrawings?.clearTransient()
@@ -17197,6 +17643,23 @@ var NativeRenderer = class {
       seriesBoundaries: (paneId) => this.scene.seriesBoundaries(paneId),
       priceZ: (paneId) => paneId === PRICE_PANE_ID ? this.scene.candleZ : null,
       requestDataPaint: () => this.scheduler.invalidate(3 /* Light */),
+      // The look the price series ACTUALLY paints with: candle colors resolved through
+      // the per-style override, line/area colors through their configured styles — so
+      // series-mirroring content (the magnifier inset) matches the chart exactly.
+      seriesLook: () => {
+        const st = this.scene.style;
+        const paint = effectiveCandlePaint(st.candle, this.scene.candleOverride, this.theme.upColor, this.theme.downColor);
+        const barsUp = st.bars.upColor ?? this.theme.upColor;
+        const barsDown = st.bars.downColor ?? this.theme.downColor;
+        const style = this.scene.priceStyle;
+        return {
+          style,
+          upColor: style === "bars" ? barsUp : paint.up,
+          downColor: style === "bars" ? barsDown : paint.down,
+          lineColor: style === "area" ? st.area.lineColor ?? this.theme.upColor : st.line.color ?? this.theme.upColor
+        };
+      },
+      chartBarMs: () => this.coords.barInterval,
       snap: (pt, paneId, mode, cursorPx) => this.snapToCandle(pt, paneId, mode, cursorPx),
       setSnapMode: (mode) => this.setSnapMode(mode),
       setToolbarGutter: (px) => this.setToolbarGutter(px)
@@ -17485,7 +17948,8 @@ var NativeRenderer = class {
     }
     const skipFit = opts?.preserveView === true && this.didInitialFit;
     if (this.coords.width > 0 && !skipFit) {
-      this.fitContent();
+      if (this.didInitialFit) this.reframeKeepZoom();
+      else this.fitContent();
       this.didInitialFit = true;
     }
     if (!this.introPlayed && this.bars.length > 0) {
@@ -18133,6 +18597,7 @@ var NativeRenderer = class {
     this.scaleDragHeight = res.height;
     this.scaleDragStart = { ...res.holder.scale };
     res.holder.manualScale = { ...res.holder.scale };
+    this.axisScaleButtons?.reposition();
     this.scheduler.invalidate(4 /* Full */);
   }
   /** Rescale the grabbed scale around its center by the total drag (down ⇒ zoom out). */
@@ -18164,6 +18629,7 @@ var NativeRenderer = class {
     const res = this.resolveScaleHolder(x, y);
     if (!res) return;
     res.holder.manualScale = null;
+    this.axisScaleButtons?.reposition();
     this.scheduler.invalidate(4 /* Full */);
   }
   /**
@@ -18587,7 +19053,8 @@ var NativeRenderer = class {
         return p ? { scale: p.scale, bounds: p.bounds, collapsed: p.collapsed } : null;
       },
       (y) => this.paneNodeAtY(y)?.id ?? null,
-      (from, to) => this.barsInTimeRange(from, to)
+      (from, to) => this.barsInTimeRange(from, to),
+      this.userDrawings?.seriesGateway ? (tf, from, to) => this.userDrawings.seriesGateway.seriesInRange(tf, from, to) : void 0
     );
   }
   /** OHLC bars whose open-time falls within `[from, to]` (inclusive) — the data a regression
@@ -18801,6 +19268,20 @@ var NativeRenderer = class {
     this.coords.setViewport(v);
     this.targetBarSpacing = v.barSpacing;
   }
+  /** Re-frame after a series replacement (a symbol/timeframe switch): keep the user's
+   *  zoom (bar spacing), re-anchor the newest bars at the default right offset.
+   *  `clampViewport`'s fit-all-bars floor deliberately does NOT apply — a progressive
+   *  head may still be backfilling toward the previous depth, and raising the spacing
+   *  to its temporary bar count would lose the zoom this exists to keep. */
+  reframeKeepZoom() {
+    this.animator?.stop();
+    this.panVelocity = 0;
+    for (const pane of this.scene.panes.values()) pane.manualScale = null;
+    for (const sl of this.scene.indicatorScales.values()) sl.manualScale = null;
+    const v = { barSpacing: clampBarSpacing(this.coords.getViewport().barSpacing), rightOffset: defaultViewport().rightOffset };
+    this.coords.setViewport(v);
+    this.targetBarSpacing = v.barSpacing;
+  }
   paneBoundsFor(paneId) {
     const p = this.scene.panes.get(paneId);
     return { top: p?.bounds.top ?? 0, height: p?.bounds.height ?? 0, rightAxis: this.rightAxisW };
@@ -19367,6 +19848,12 @@ var IndicatorHandleImpl = class {
   get visible() {
     return this.visibleState;
   }
+  inputValues() {
+    return this.controller.inputValuesOf(this.id);
+  }
+  propValues() {
+    return this.controller.propValuesOf(this.id);
+  }
   setInput(key, value) {
     this.controller.applyInputs(this.id, { [key]: value });
   }
@@ -19488,17 +19975,179 @@ function presetToRange(preset, bars) {
   return { from: Math.max(first, from), to: last };
 }
 
-// src/core/price-styles/BarTransform.ts
-function barTransformFor(style) {
-  return chartType(style)?.barTransform ?? null;
-}
-function parseExtendedTicker(symbol) {
-  const at = symbol.lastIndexOf(";");
-  if (at <= 0 || at === symbol.length - 1) return { symbol, modifier: null, transform: null };
-  const modifier = symbol.slice(at + 1).toLowerCase();
-  if (modifier !== "standard" && !tickerModifierIds().includes(modifier)) return { symbol, modifier: null, transform: null };
-  return { symbol: symbol.slice(0, at), modifier, transform: barTransformFor(modifier) };
-}
+// src/core/engine/DrawingSeriesService.ts
+var MAX_BARS = 5e3;
+var PAD_FRAC = 0.25;
+var MAX_ENTRIES = 16;
+var RETRY_MS = 15e3;
+var AUTO_STEPS = ["240", "60", "30", "15", "5", "1"];
+var DrawingSeriesService = class {
+  constructor(deps) {
+    this.deps = deps;
+    /** Cached windows per `market|timeframe` key, newest-used last (LRU across keys). */
+    this.cache = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  seriesInRange(timeframe, from, to) {
+    if (!this.deps.canFetch()) return { state: "unavailable", reason: "no-source" };
+    const resolved = this.resolveTimeframe(timeframe);
+    if (typeof resolved !== "string") return { state: "unavailable", reason: resolved.reason };
+    const barMs = timeframeToMs(resolved);
+    const lo = Math.min(from, to);
+    const hi = Math.max(from, to);
+    if (!(hi > lo) || !(barMs > 0)) return { state: "unavailable", reason: "not-lower" };
+    if ((hi - lo) / barMs > MAX_BARS) return { state: "unavailable", reason: "too-wide" };
+    const key = `${this.deps.marketKey()}|${resolved}`;
+    const entries = this.cache.get(key) ?? [];
+    const covering = entries.find((e) => e.from <= lo && e.to >= hi);
+    if (covering) {
+      if (covering.pending) return this.loading(entries, resolved, barMs, lo, hi);
+      if (covering.failedAt > 0) {
+        if (Date.now() - covering.failedAt < RETRY_MS) return this.loading(entries, resolved, barMs, lo, hi);
+        entries.splice(entries.indexOf(covering), 1);
+      } else {
+        this.maybeRefresh(key, covering, resolved, barMs, hi);
+        return { state: "ready", bars: this.slice(covering.bars, lo, hi), timeframe: resolved, barMs };
+      }
+    }
+    this.fetchWindow(key, entries, resolved, lo, hi);
+    return this.loading(entries, resolved, barMs, lo, hi);
+  }
+  onUpdate(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  // ── internals ──
+  /** `'auto'` → the largest standard step at least 4× finer than the chart (else the finest
+   *  step still below it); an explicit timeframe passes only when strictly finer. Failures
+   *  distinguish "this pick isn't lower" from "NOTHING lower exists" (the chart is already
+   *  at the finest offered step) so the consumer can word its notice honestly. */
+  resolveTimeframe(timeframe) {
+    const chartMs = timeframeToMs(this.deps.chartTimeframe());
+    const finest = AUTO_STEPS[AUTO_STEPS.length - 1];
+    if (timeframeToMs(finest) >= chartMs) return { reason: "none-lower" };
+    const tf = timeframe.trim() || "auto";
+    if (tf === "auto") {
+      for (const step of AUTO_STEPS) {
+        if (timeframeToMs(step) <= chartMs / 4) return step;
+      }
+      return finest;
+    }
+    return timeframeToMs(tf) < chartMs ? tf : { reason: "not-lower" };
+  }
+  /** The `loading` answer, carrying best-effort PARTIAL bars from settled overlapping
+   *  windows — a widened window keeps painting what it already has while it fetches. */
+  loading(entries, timeframe, barMs, lo, hi) {
+    const partial = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      if (e.pending || e.failedAt > 0) continue;
+      if (e.to < lo || e.from > hi) continue;
+      for (const b of this.slice(e.bars, lo, hi)) partial.set(b.time, b);
+    }
+    if (partial.size === 0) return { state: "loading", timeframe, barMs };
+    const bars = [...partial.values()].sort((a, b) => a.time - b.time);
+    return { state: "loading", timeframe, barMs, bars };
+  }
+  /** Kick ONE background fetch for the padded window. Any OVERLAPPING in-flight fetch
+   *  defers this one (a corner drag repaints per pointer move — kicking a window per
+   *  frame would spam the provider); when it lands, the next paint re-evaluates. */
+  fetchWindow(key, entries, timeframe, lo, hi) {
+    if (entries.some((e) => e.pending && e.to >= lo && e.from <= hi)) return;
+    const pad = (hi - lo) * PAD_FRAC;
+    const entry = { from: lo - pad, to: hi + pad, bars: [], fetchedAt: 0, pending: true, failedAt: 0 };
+    entries.push(entry);
+    this.cache.set(key, entries);
+    this.evict();
+    void this.deps.fetchBars(timeframe, { from: entry.from, to: entry.to }).then((bars) => {
+      entry.bars = bars;
+      entry.fetchedAt = Date.now();
+      entry.pending = false;
+      this.absorbOverlaps(key, entry);
+      this.fire();
+    }).catch(() => {
+      entry.pending = false;
+      entry.failedAt = Date.now();
+      this.fire();
+    });
+  }
+  /** A window whose right edge reaches the newest fetched bar refreshes at most once per
+   *  bar interval — new closed bars ride the feed's cache, only the live tail re-fetches. */
+  maybeRefresh(key, entry, timeframe, barMs, hi) {
+    if (entry.pending) return;
+    const lastBar = entry.bars.length > 0 ? entry.bars[entry.bars.length - 1].time : entry.from;
+    if (hi < lastBar) return;
+    if (Date.now() - entry.fetchedAt < barMs) return;
+    entry.pending = true;
+    void this.deps.fetchBars(timeframe, { from: entry.from, to: entry.to }).then((bars) => {
+      entry.bars = bars;
+      entry.fetchedAt = Date.now();
+      entry.pending = false;
+      this.fire();
+    }).catch(() => {
+      entry.pending = false;
+      entry.fetchedAt = Date.now();
+    });
+  }
+  /** Merge windows that overlap `entry` into it (dedupe by bar time) so a key's list
+   *  converges instead of accumulating slivers. */
+  absorbOverlaps(key, entry) {
+    const entries = this.cache.get(key);
+    if (!entries) return;
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+      const other = entries[i];
+      if (other === entry || other.pending || other.failedAt > 0) continue;
+      if (other.to < entry.from || other.from > entry.to) continue;
+      const byTime = /* @__PURE__ */ new Map();
+      for (const b of other.bars) byTime.set(b.time, b);
+      for (const b of entry.bars) byTime.set(b.time, b);
+      entry.bars = [...byTime.values()].sort((a, b) => a.time - b.time);
+      entry.from = Math.min(entry.from, other.from);
+      entry.to = Math.max(entry.to, other.to);
+      entry.fetchedAt = Math.min(entry.fetchedAt, other.fetchedAt || entry.fetchedAt);
+      entries.splice(i, 1);
+    }
+  }
+  /** Drop the oldest settled windows once the global count passes {@link MAX_ENTRIES}. */
+  evict() {
+    let total = 0;
+    for (const entries of this.cache.values()) total += entries.length;
+    while (total > MAX_ENTRIES) {
+      let oldestKey = null;
+      let oldestIdx = -1;
+      let oldestAt = Infinity;
+      for (const [key, entries2] of this.cache) {
+        for (let i = 0; i < entries2.length; i += 1) {
+          const e = entries2[i];
+          if (e.pending) continue;
+          const at = e.fetchedAt || e.failedAt;
+          if (at < oldestAt) {
+            oldestKey = key;
+            oldestIdx = i;
+            oldestAt = at;
+          }
+        }
+      }
+      if (oldestKey == null) return;
+      const entries = this.cache.get(oldestKey);
+      entries.splice(oldestIdx, 1);
+      if (entries.length === 0) this.cache.delete(oldestKey);
+      total -= 1;
+    }
+  }
+  /** Bars whose open time falls within `[lo, hi]` (ascending input → linear scan is fine). */
+  slice(bars, lo, hi) {
+    const out = [];
+    for (const b of bars) {
+      if (b.time < lo) continue;
+      if (b.time > hi) break;
+      out.push(b);
+    }
+    return out;
+  }
+  fire() {
+    for (const l of [...this.listeners]) l();
+  }
+};
 
 // src/core/engine/EngineOrchestrator.ts
 var VIEWPORT_DEBOUNCE_MS = 150;
@@ -19506,6 +20155,7 @@ var RUN_EMIT_THROTTLE_MS = 1e3;
 var PREVIEW_BARS = 300;
 var SINGLE_LOAD_BARS = 5e3;
 var CHUNK_BARS = 1e4;
+var FIRST_PAINT_BARS = 100;
 var GAP_FACTOR = 1.5;
 var HEAL_COOLDOWN_MS = 5e3;
 var EngineOrchestrator = class _EngineOrchestrator {
@@ -19623,7 +20273,13 @@ var EngineOrchestrator = class _EngineOrchestrator {
     const initialStyle = this.renderer.readFeature("priceStyle");
     if (typeof initialStyle === "string") this.priceStyle = initialStyle;
     this.barTransform = barTransformFor(initialStyle);
-    this.drawings = new DrawingController(this.renderer, this.events, config.drawings);
+    const drawingSeries = new DrawingSeriesService({
+      fetchBars: (tf, range) => this.fetchSeries(this.config.market.symbol ?? "", tf, range),
+      canFetch: () => !!this.feed.loadRange && !this.config.market.data?.length && !!this.config.market.symbol,
+      chartTimeframe: () => this.config.market.timeframe ?? "60",
+      marketKey: () => `${this.config.market.symbol ?? ""}|${this.config.market.session ?? ""}`
+    });
+    this.drawings = new DrawingController(this.renderer, this.events, config.drawings, drawingSeries);
     this.unresolvedUnsub = this.feed.onUnresolved?.((info) => {
       this.endLoad();
       this.events.emit("data:unresolved", info);
@@ -19775,6 +20431,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
       let painted = false;
       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;
         this.setBarSeries(bars, painted ? { preserveView: true } : void 0);
         if (!painted && bars.length > 0) {
           painted = true;
@@ -20405,6 +21062,15 @@ var EngineOrchestrator = class _EngineOrchestrator {
     record.pendingCause = "inputs";
     if (record.session) record.session.update(record.inputValues);
     else if (record.native && !record.hidden) record.native.instance.setInputs(record.inputValues);
+    this.events.emit("indicator:inputs", { id });
+  }
+  /** IndicatorController: the CURRENT stored input values (defaults merged with edits). */
+  inputValuesOf(id) {
+    return { ...this.registry.get(id)?.inputValues };
+  }
+  /** IndicatorController: the CURRENT declaration-prop overrides. */
+  propValuesOf(id) {
+    return { ...this.registry.get(id)?.propValues };
   }
   /** IndicatorController: re-run an indicator with merged declaration-prop overrides.
    *  Same lifecycle as {@link applyInputs} — a prop change replays the whole script.
@@ -20418,6 +21084,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
     if (!record.hidden) this.setLoading(record, true);
     record.pendingCause = "inputs";
     record.session.update(record.inputValues, record.propValues);
+    this.events.emit("indicator:inputs", { id });
   }
   /** IndicatorController: tear down an indicator and (if now empty) its pane. */
   /** Live handles of every indicator on the chart (script + native), insertion order. */
@@ -20605,8 +21272,8 @@ var EngineOrchestrator = class _EngineOrchestrator {
         onModel: (model) => {
           const first = !record.announced;
           const cause = record.pendingCause ?? "history";
+          if (!this.applyModel(id, model)) return;
           record.pendingCause = void 0;
-          this.applyModel(id, model);
           this.emitContextChanged(id);
           this.emitScriptRun(id, cause, first);
         },
@@ -20899,10 +21566,16 @@ var EngineOrchestrator = class _EngineOrchestrator {
    * Apply an emitted model. First emission mounts (and routes the pane); a pending
    * structural change (after an input edit) remounts idempotently; everything else
    * (live tick / viewport re-run) value-patches.
+   *
+   * Returns false when the model was DEFERRED — an output-free model arriving while
+   * the record is still loading and the chart has no bars (see below); every other
+   * outcome, including the hidden drop, returns true so the caller's event semantics
+   * stay unchanged.
    */
   applyModel(id, model) {
     const record = this.registry.get(id);
-    if (!record || record.hidden) return;
+    if (!record || record.hidden) return true;
+    if (record.loading && this.bars.length === 0 && !_EngineOrchestrator.modelHasOutput(model)) return false;
     const handle = this.handles.get(id);
     if (!record.renderHandle) {
       const paneId2 = this.routePane(id, model, record.options ?? {});
@@ -20912,7 +21585,7 @@ var EngineOrchestrator = class _EngineOrchestrator {
       record.renderHandle = this.renderer.mountIndicator(model);
       record.pendingStructural = false;
       this.announce(record, handle);
-      return;
+      return true;
     }
     let paneId = record.model?.paneId ?? "price";
     const prevOwnScale = record.model?.ownScale === true;
@@ -20940,6 +21613,11 @@ var EngineOrchestrator = class _EngineOrchestrator {
     }
     if (record.loading) this.setLoading(record, false);
     this.announce(record, handle);
+    return true;
+  }
+  /** True when the model carries ANY executed output — series, drawings, bar colors, or trades. */
+  static modelHasOutput(model) {
+    return model.series.length > 0 || model.fills.length > 0 || model.backgrounds.length > 0 || model.priceLines.length > 0 || (model.lines?.length ?? 0) > 0 || (model.boxes?.length ?? 0) > 0 || (model.labels?.length ?? 0) > 0 || (model.polylines?.length ?? 0) > 0 || (model.linefills?.length ?? 0) > 0 || (model.tables?.length ?? 0) > 0 || (model.barColors?.length ?? 0) > 0 || (model.trades?.length ?? 0) > 0;
   }
   routePane(id, model, options) {
     if (options.pane === "new") return `pane-${id}`;