@luxalgo/vela 0.6.15 → 0.6.16

package/dist/{chunk-J5QIR2Z3.js → chunk-GIJYO4LO.js}

@@ -1,6 +1,6 @@
-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-32A7KHFM.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-MWDNPGU3.js';
-import { icon, iconAt, withAlpha, WARNING, ACCENT, NEUTRAL, BEARISH, BULLISH, isDarkColor, SERIES_LINE, CHIP_PLATE, CROSSHAIR, TRADE_EXIT, TRADE_SHORT, TRADE_LONG, overlayScrollbarCss, SLATE_DEEP, VALID, INVALID, SLATE, FIELD_FOCUS_CSS, FIELD_FOCUS_RING, svg24, svg24Solid } from './chunk-6DPAYEGO.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, stableSeriesId } from './chunk-I77F2SVE.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-MGU3USTP.js';
+import { icon, iconAt, withAlpha, WARNING, ACCENT, NEUTRAL, BEARISH, BULLISH, isDarkColor, SERIES_LINE, CHIP_PLATE, CROSSHAIR, TRADE_EXIT, TRADE_SHORT, TRADE_LONG, overlayScrollbarCss, SLATE_DEEP, VALID, INVALID, SLATE, FIELD_FOCUS_CSS, FIELD_FOCUS_RING, INFO, svg24, svg24Solid } from './chunk-6DPAYEGO.js';
 
 // src/core/events/EventBus.ts
 var TypedEventBus = class {
@@ -1136,7 +1136,7 @@ function attachForming(closed, forming) {
 
 // src/data/MultiProviderFeed.ts
 function intervalMs(timeframe) {
-  const map = {
+  const map2 = {
     "1m": 6e4,
     "3m": 18e4,
     "5m": 3e5,
@@ -1158,7 +1158,7 @@ function intervalMs(timeframe) {
     W: 6048e5,
     M: 2592e6
   };
-  return map[timeframe] ?? 36e5;
+  return map2[timeframe] ?? 36e5;
 }
 var MultiProviderFeed = class {
   constructor(store = sharedBarStore) {
@@ -1545,8 +1545,8 @@ var DrawingsControl = class {
   /** Show per-tool shortcut hints in the toolbar flyouts. Values are PRE-FORMATTED
    *  display strings (e.g. `'Alt+T'`, `'⌥T'`) — the host owns the keymap and the
    *  platform formatting, so hints always match the host's actual bindings. */
-  setToolShortcuts(map) {
-    if (this.ok("setToolShortcuts")) this.ctrl.setToolShortcuts(map);
+  setToolShortcuts(map2) {
+    if (this.ok("setToolShortcuts")) this.ctrl.setToolShortcuts(map2);
     return this;
   }
   /** Display another chart's in-progress placement as a GHOST at reduced opacity
@@ -1987,8 +1987,8 @@ var DrawingController = class {
     this.port?.setExternalGhost?.(doc);
   }
   /** Push per-tool shortcut hints (pre-formatted display strings) to the toolbar flyouts. */
-  setToolShortcuts(map) {
-    this.port?.setToolShortcuts?.(map);
+  setToolShortcuts(map2) {
+    this.port?.setToolShortcuts?.(map2);
   }
   // ── programmatic CRUD (facade-facing) ── each is one undo step
   add(type, init = {}) {
@@ -2475,8 +2475,8 @@ var DrawingToolbar = class {
   }
   /** Per-tool shortcut hints (pre-formatted display strings, e.g. `'Alt+T'`) shown at the
    *  right edge of the flyout rows, beside the favorite star. */
-  setShortcuts(map) {
-    this.shortcuts = new Map(Object.entries(map));
+  setShortcuts(map2) {
+    this.shortcuts = new Map(Object.entries(map2));
   }
   /** Paint one star for the current favorite state (filled + gold, or outline). */
   paintStar(el, type) {
@@ -4327,8 +4327,8 @@ var InputsUI = class {
     lg.style.top = `${top}px`;
   }
   /** Set which panes are collapsed and, for each, the master indicator to keep in its strip. */
-  setCollapsedPanes(map) {
-    this.paneCollapse = map;
+  setCollapsedPanes(map2) {
+    this.paneCollapse = map2;
   }
   /**
    * Keep the fold toggle in step with the indicator count: with 2+ indicators anywhere
@@ -5291,9 +5291,9 @@ function factoryResetConfig(factory) {
       if (inst.enableKey) defaults[inst.enableKey] = false;
       addRows(inst.rows);
     }
-    for (const sub of section.subsections ?? []) {
-      if (sub.enableKey) defaults[sub.enableKey] = false;
-      addRows(sub.rows);
+    for (const sub2 of section.subsections ?? []) {
+      if (sub2.enableKey) defaults[sub2.enableKey] = false;
+      addRows(sub2.rows);
     }
     if (!section.instances) addRows(section.rows);
     bag[t.id] = defaults;
@@ -6622,11 +6622,11 @@ function mergeBarColors(indicators) {
     }
   }
   if (!any) return EMPTY_BARCOLORS;
-  const map = /* @__PURE__ */ new Map();
+  const map2 = /* @__PURE__ */ new Map();
   for (const m of indicators.values()) {
-    if (m.barColors) for (const bc of m.barColors) map.set(bc.time, bc.color);
+    if (m.barColors) for (const bc of m.barColors) map2.set(bc.time, bc.color);
   }
-  return map;
+  return map2;
 }
 
 // src/renderers/native/core/ViewportState.ts
@@ -6923,9 +6923,9 @@ function isHorizontalWheel(deltaX, deltaY) {
 function wheelPanRightOffset(rightOffset, deltaX, barSpacing) {
   return rightOffset + deltaX / barSpacing;
 }
-function wheelPanDelta(deltaX, deltaY, shift) {
+function wheelPanDelta(deltaX, deltaY, shift2) {
   if (isHorizontalWheel(deltaX, deltaY)) return deltaX;
-  if (shift) return deltaY;
+  if (shift2) return deltaY;
   return null;
 }
 function effectiveSnapMode(momentaryOverride, sticky) {
@@ -8547,11 +8547,11 @@ function mergeBarColors2(indicators) {
     }
   }
   if (!any) return EMPTY_BARCOLORS2;
-  const map = /* @__PURE__ */ new Map();
+  const map2 = /* @__PURE__ */ new Map();
   for (const m of indicators.values()) {
-    if (m.barColors) for (const bc of m.barColors) map.set(bc.time, bc.color);
+    if (m.barColors) for (const bc of m.barColors) map2.set(bc.time, bc.color);
   }
-  return map;
+  return map2;
 }
 
 // src/renderers/shared/drawing-geometry.ts
@@ -10190,9 +10190,9 @@ function settingsIdCatalog(hostSections) {
     };
     if (section.rows) addRows(section.rows);
     for (const inst of section.instances ?? []) addRows(inst.rows);
-    for (const sub of section.subsections ?? []) {
-      ids.add(`${scope}.${settingsIdSlug(sub.title)}`);
-      addRows(sub.rows);
+    for (const sub2 of section.subsections ?? []) {
+      ids.add(`${scope}.${settingsIdSlug(sub2.title)}`);
+      addRows(sub2.rows);
     }
   }
   for (const hs of hostSections) {
@@ -10751,14 +10751,14 @@ var SettingsDialog = class {
     };
     if (section.rows) seed(section.rows);
     for (const inst of section.instances ?? []) seed(inst.rows);
-    for (const sub of section.subsections ?? []) seed(sub.rows);
+    for (const sub2 of section.subsections ?? []) seed(sub2.rows);
     for (const inst of section.instances ?? []) {
       if (!inst.enableKey || inst.enableKey in bag) continue;
       bag[inst.enableKey] = values[inst.enableKey] === true;
     }
-    for (const sub of section.subsections ?? []) {
-      if (!sub.enableKey || sub.enableKey in bag) continue;
-      bag[sub.enableKey] = values[sub.enableKey] === true;
+    for (const sub2 of section.subsections ?? []) {
+      if (!sub2.enableKey || sub2.enableKey in bag) continue;
+      bag[sub2.enableKey] = values[sub2.enableKey] === true;
     }
     const refreshers = [];
     const put = (key, v) => {
@@ -10775,16 +10775,16 @@ var SettingsDialog = class {
       if (section.layout === "grouped") body.append(this.groupedRows(`${typeId}/rows`, rows, bag, put, refreshers));
       else this.flatTypeRows(rows, bag, put, refreshers, body);
     }
-    for (const sub of section.subsections ?? []) {
-      if (settingsIdHidden(`${scope}.${settingsIdSlug(sub.title)}`, this.hiddenSettings)) continue;
-      const rows = filterHiddenRows(sub.rows, scope, this.hiddenSettings);
+    for (const sub2 of section.subsections ?? []) {
+      if (settingsIdHidden(`${scope}.${settingsIdSlug(sub2.title)}`, this.hiddenSettings)) continue;
+      const rows = filterHiddenRows(sub2.rows, scope, this.hiddenSettings);
       if (rows.length === 0) continue;
-      const subMarker = this.section(sub.title);
+      const subMarker = this.section(sub2.title);
       subMarker.dataset.sdStyle = typeId;
       subMarker.dataset.sdVisibility = section.visibility ?? "active";
       subMarker.dataset.sdSub = "1";
       body.append(subMarker);
-      body.append(this.groupedRows(`${typeId}/${sub.title}`, rows, bag, put, refreshers, sub.enableKey));
+      body.append(this.groupedRows(`${typeId}/${sub2.title}`, rows, bag, put, refreshers, sub2.enableKey));
     }
     for (const r of refreshers) r();
   }
@@ -12891,11 +12891,11 @@ var DrawingInteraction = class {
   /** A press: place the next anchor, or grab a drawing/handle (resolved as click or drag on release).
    *  `shift` over a drawing toggles it in/out of the selection (multi-select) instead of dragging;
    *  while placing a line tool it locks the segment angle to 45° steps. */
-  down(x, y, mode = "off", shift = false) {
+  down(x, y, mode = "off", shift2 = false) {
     const proj = this.deps.projector();
     if (this.state.kind === "placing") {
       if (this.state.draft.placementMode() !== "click") return;
-      const pivot = shift ? this.placingPivot(this.state.draft) : null;
+      const pivot = shift2 ? this.placingPivot(this.state.draft) : null;
       const point = pivot ? this.resolveAngleSnapped(pivot, this.state.draft.paneId, x, y) : this.resolve(x, y, this.state.draft.paneId, mode);
       this.state.draft.anchors.push(this.placementAnchor(this.state.draft, point));
       if (this.state.draft.anchors.length >= this.state.need) this.finalize();
@@ -12914,7 +12914,7 @@ var DrawingInteraction = class {
     }
     const hit = this.hitAt(x, y);
     if (hit) {
-      if (shift) {
+      if (shift2) {
         this.deps.emit({ kind: "select", ids: [hit.id], additive: true });
         return;
       }
@@ -12924,7 +12924,7 @@ var DrawingInteraction = class {
   }
   /** Pointer move: advance the placing ghost, or live-preview a drag once past the slop.
    *  `shift` on a line tool locks the segment angle to 45° steps (placing + handle drags). */
-  move(x, y, mode = "off", shift = false) {
+  move(x, y, mode = "off", shift2 = false) {
     if (this.state.kind === "idle") {
       const tool = this.deps.activeTool();
       const had = this.snapAt != null;
@@ -12938,7 +12938,7 @@ var DrawingInteraction = class {
         this.captureFreehand(x, y);
         return;
       }
-      const pivot = shift ? this.placingPivot(this.state.draft) : null;
+      const pivot = shift2 ? this.placingPivot(this.state.draft) : null;
       this.state.cursor = pivot ? this.resolveAngleSnapped(pivot, this.state.draft.paneId, x, y) : this.resolve(x, y, this.state.draft.paneId, mode);
       this.deps.changed();
       return;
@@ -12951,7 +12951,7 @@ var DrawingInteraction = class {
     if (this.state.handle >= 0) {
       const a = d.anchors[this.state.handle];
       if (a) {
-        const pivot = shift && ANGLE_SNAP_TYPES.has(d.type) && d.anchors.length === 2 ? d.anchors[1 - this.state.handle] : void 0;
+        const pivot = shift2 && ANGLE_SNAP_TYPES.has(d.type) && d.anchors.length === 2 ? d.anchors[1 - this.state.handle] : void 0;
         const point = pivot ? this.resolveAngleSnapped(pivot, d.paneId, x, y) : this.resolve(x, y, d.paneId, mode);
         applyFree(a, point, d.anchorSchema().slots[this.state.handle]?.free ?? "both");
       }
@@ -13649,21 +13649,21 @@ var DrawingSettingsPopup = class {
       bar.appendChild(this.colorButton("Lower fill", BUCKET_ICON, reg.lowerFill, (v) => actions.patch({ "reg.lowerFill": v })));
       bar.appendChild(this.toggle("Show R\xB2", R2_ICON, reg.showR2, (v) => actions.patch({ "reg.showR2": v })));
     }
-    const vwap = drawing.vwap;
-    if (paths.has("vwap.midColor") && vwap) {
+    const vwap2 = drawing.vwap;
+    if (paths.has("vwap.midColor") && vwap2) {
       const styles = LINE_STYLE_OPTIONS.map((o) => o.value);
       const MULTS = [0.5, 1, 1.5, 2, 2.5, 3, 4, 5];
-      bar.appendChild(this.colorButton("VWAP color", BRUSH_ICON, vwap.midColor, (v) => actions.patch({ "vwap.midColor": v })));
-      bar.appendChild(this.dropdown("VWAP style", styles, vwap.midStyle, (s) => lineIcon(2, s), (v) => actions.patch({ "vwap.midStyle": v }), { label: styleLabel2 }));
+      bar.appendChild(this.colorButton("VWAP color", BRUSH_ICON, vwap2.midColor, (v) => actions.patch({ "vwap.midColor": v })));
+      bar.appendChild(this.dropdown("VWAP style", styles, vwap2.midStyle, (s) => lineIcon(2, s), (v) => actions.patch({ "vwap.midStyle": v }), { label: styleLabel2 }));
       bar.appendChild(
-        this.dropdown("Band multiplier", MULTS, vwap.multiplier, () => BANDS_ICON, (v) => actions.patch({ "vwap.multiplier": v }), {
+        this.dropdown("Band multiplier", MULTS, vwap2.multiplier, () => BANDS_ICON, (v) => actions.patch({ "vwap.multiplier": v }), {
           label: (v) => `${v}\u03C3`,
           labelInTrigger: true
         })
       );
-      bar.appendChild(this.colorButton("Upper band color", BRUSH_ICON, vwap.upperColor, (v) => actions.patch({ "vwap.upperColor": v })));
-      bar.appendChild(this.colorButton("Lower band color", BRUSH_ICON, vwap.lowerColor, (v) => actions.patch({ "vwap.lowerColor": v })));
-      bar.appendChild(this.colorButton("Band fill", BUCKET_ICON, vwap.bandFill, (v) => actions.patch({ "vwap.bandFill": v })));
+      bar.appendChild(this.colorButton("Upper band color", BRUSH_ICON, vwap2.upperColor, (v) => actions.patch({ "vwap.upperColor": v })));
+      bar.appendChild(this.colorButton("Lower band color", BRUSH_ICON, vwap2.lowerColor, (v) => actions.patch({ "vwap.lowerColor": v })));
+      bar.appendChild(this.colorButton("Band fill", BUCKET_ICON, vwap2.bandFill, (v) => actions.patch({ "vwap.bandFill": v })));
     }
     if (paths.has("maxCurvature")) {
       const cur = drawing.maxCurvature ?? 24;
@@ -14680,8 +14680,8 @@ var UserDrawingController = class {
     this.toolbar.setFavorites(types);
   }
   /** Core push: per-tool shortcut hints (display strings) shown in the toolbar flyouts. */
-  setToolShortcuts(map) {
-    this.toolbar.setShortcuts(map);
+  setToolShortcuts(map2) {
+    this.toolbar.setShortcuts(map2);
   }
   /** Core push: set the sticky magnet mode. Applies to the renderer + reflects on the
    *  in-chart toolbar WITHOUT notifying back (the caller already holds the value). */
@@ -14799,7 +14799,7 @@ var UserDrawingController = class {
       this.render();
     }
   }
-  pointerDown(x, y, snap = "off", shift = false) {
+  pointerDown(x, y, snap = "off", shift2 = false) {
     if (this.eraserMode) {
       this.erasing = true;
       this.deleteAt(x, y);
@@ -14819,9 +14819,9 @@ var UserDrawingController = class {
         return;
       }
     }
-    this.interaction.down(x, y, snap, shift);
+    this.interaction.down(x, y, snap, shift2);
   }
-  pointerMove(x, y, snap = "off", shift = false) {
+  pointerMove(x, y, snap = "off", shift2 = false) {
     if (this.eraserMode) {
       if (this.erasing) this.deleteAt(x, y);
       return;
@@ -14832,7 +14832,7 @@ var UserDrawingController = class {
       this.render();
       return;
     }
-    this.interaction.move(x, y, snap, shift);
+    this.interaction.move(x, y, snap, shift2);
     this.updateHover(x, y);
   }
   /** Track which drawing is hovered so its handles appear on hover (and only then). */
@@ -15509,14 +15509,14 @@ function layoutTable(ctx, t, args) {
   }
   for (const { box, w: w2, h: h2 } of spanning) {
     if (box.cs > 1) {
-      let sum = 0;
-      for (let c = box.c; c < box.c + box.cs; c += 1) sum += colW[c];
-      if (w2 > sum) for (let c = box.c; c < box.c + box.cs; c += 1) colW[c] += (w2 - sum) / box.cs;
+      let sum2 = 0;
+      for (let c = box.c; c < box.c + box.cs; c += 1) sum2 += colW[c];
+      if (w2 > sum2) for (let c = box.c; c < box.c + box.cs; c += 1) colW[c] += (w2 - sum2) / box.cs;
     }
     if (box.rs > 1) {
-      let sum = 0;
-      for (let r = box.r; r < box.r + box.rs; r += 1) sum += rowH[r];
-      if (h2 > sum) for (let r = box.r; r < box.r + box.rs; r += 1) rowH[r] += (h2 - sum) / box.rs;
+      let sum2 = 0;
+      for (let r = box.r; r < box.r + box.rs; r += 1) sum2 += rowH[r];
+      if (h2 > sum2) for (let r = box.r; r < box.r + box.rs; r += 1) rowH[r] += (h2 - sum2) / box.rs;
     }
   }
   let w = 0;
@@ -16213,24 +16213,24 @@ function rasterizeOverlay(ctx, root, frame) {
         drawSvgShapes(el, alpha);
         continue;
       }
-      const num3 = (name) => parseFloat(el.getAttribute(name) ?? "0") || 0;
+      const num4 = (name) => parseFloat(el.getAttribute(name) ?? "0") || 0;
       let path = null;
       if (tag === "path") {
         const d = el.getAttribute("d");
         if (d) path = new Path2D(d);
       } else if (tag === "circle") {
         path = new Path2D();
-        path.arc(num3("cx"), num3("cy"), num3("r"), 0, Math.PI * 2);
+        path.arc(num4("cx"), num4("cy"), num4("r"), 0, Math.PI * 2);
       } else if (tag === "ellipse") {
         path = new Path2D();
-        path.ellipse(num3("cx"), num3("cy"), num3("rx"), num3("ry"), 0, 0, Math.PI * 2);
+        path.ellipse(num4("cx"), num4("cy"), num4("rx"), num4("ry"), 0, 0, Math.PI * 2);
       } else if (tag === "rect") {
         path = new Path2D();
-        path.rect(num3("x"), num3("y"), num3("width"), num3("height"));
+        path.rect(num4("x"), num4("y"), num4("width"), num4("height"));
       } else if (tag === "line") {
         path = new Path2D();
-        path.moveTo(num3("x1"), num3("y1"));
-        path.lineTo(num3("x2"), num3("y2"));
+        path.moveTo(num4("x1"), num4("y1"));
+        path.lineTo(num4("x2"), num4("y2"));
       } else if (tag === "polyline" || tag === "polygon") {
         const pts = (el.getAttribute("points") ?? "").trim().split(/[\s,]+/).map(Number);
         if (pts.length < 4 || pts.some(Number.isNaN)) continue;
@@ -17647,8 +17647,8 @@ var NativeRenderer = class {
       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),
+      drawingsPointerDown: (x, y, snap, shift2) => this.userDrawings?.pointerDown(x, y, snap, shift2),
+      drawingsPointerMove: (x, y, snap, shift2) => this.userDrawings?.pointerMove(x, y, snap, shift2),
       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,
@@ -17965,18 +17965,18 @@ var NativeRenderer = class {
     for (const model of this.scene.indicators.values()) this.refreshAnchorOffset(model);
     if (opts?.preserveView === true && prevHeadTime != null && this.bars.length > 0) {
       const newHeadTime = this.bars[0].time;
-      let shift = 0;
+      let shift2 = 0;
       if (newHeadTime !== prevHeadTime) {
         const prepended = this.bars.findIndex((b) => b.time === prevHeadTime);
-        if (prepended > 0) shift = prepended;
+        if (prepended > 0) shift2 = prepended;
         else {
           const trimmed = prevBars.findIndex((b) => b.time === newHeadTime);
-          if (trimmed > 0) shift = -trimmed;
+          if (trimmed > 0) shift2 = -trimmed;
         }
       }
-      if (shift !== 0) {
-        this.zoomAnchorLogical += shift;
-        if (this.hoverLogical != null) this.hoverLogical += shift;
+      if (shift2 !== 0) {
+        this.zoomAnchorLogical += shift2;
+        if (this.hoverLogical != null) this.hoverLogical += shift2;
       }
     }
     const skipFit = opts?.preserveView === true && this.didInitialFit;
@@ -19582,15 +19582,15 @@ var NativeRenderer = class {
   /** For each collapsed pane, the master (master-scale) indicator id whose legend row stays in the
    *  strip — merged own-scale indicators are hidden while collapsed. */
   collapsedMasterMap() {
-    const map = /* @__PURE__ */ new Map();
+    const map2 = /* @__PURE__ */ new Map();
     for (const pane of this.scene.panes.values()) {
       if (!pane.collapsed) continue;
       const models = this.scene.orderedIndicatorsForPane(pane.id);
       const merged = new Set(this.scene.ownScaleIndicatorsForPane(pane.id).map((m) => m.id));
       const master = models.find((m) => !merged.has(m.id)) ?? models[0];
-      map.set(pane.id, master?.id ?? null);
+      map2.set(pane.id, master?.id ?? null);
     }
-    return map;
+    return map2;
   }
   /** Reserve `px` of left gutter for the docked drawings toolbar (0 releases it) + re-lay-out the plot. */
   setToolbarGutter(px) {
@@ -19862,7 +19862,7 @@ var LiveSession = class {
 
 // src/core/engine/IndicatorHandleImpl.ts
 var IndicatorHandleImpl = class {
-  constructor(id, title, controller, source) {
+  constructor(id, title, controller, source, nativeType) {
     this.controller = controller;
     this.schema = [];
     this.propsSchema = [];
@@ -19871,6 +19871,7 @@ var IndicatorHandleImpl = class {
     this.id = id;
     this.title = title;
     if (source !== void 0) this.source = source;
+    if (nativeType !== void 0) this.nativeType = nativeType;
   }
   get inputs() {
     return this.schema;
@@ -19961,24 +19962,24 @@ function summarizeModel(model) {
 }
 function inspectModels(models) {
   const indicators = models.map(summarizeModel);
-  const sum = (pick) => indicators.reduce((n, s) => n + pick(s), 0);
+  const sum2 = (pick) => indicators.reduce((n, s) => n + pick(s), 0);
   return {
     indicators,
     totals: {
       panes: new Set(indicators.map((s) => s.paneId ?? "price")).size,
-      series: sum((s) => Object.values(s.series).reduce((a, b) => a + b, 0)),
-      fills: sum((s) => s.fills),
-      backgrounds: sum((s) => s.backgrounds),
-      priceLines: sum((s) => s.priceLines),
-      lines: sum((s) => s.lines),
-      boxes: sum((s) => s.boxes),
-      labels: sum((s) => s.labels),
-      polylines: sum((s) => s.polylines),
-      linefills: sum((s) => s.linefills),
-      tables: sum((s) => s.tables),
-      barColors: sum((s) => s.barColors),
-      trades: sum((s) => s.trades),
-      forcedOverlay: sum((s) => s.forcedOverlay)
+      series: sum2((s) => Object.values(s.series).reduce((a, b) => a + b, 0)),
+      fills: sum2((s) => s.fills),
+      backgrounds: sum2((s) => s.backgrounds),
+      priceLines: sum2((s) => s.priceLines),
+      lines: sum2((s) => s.lines),
+      boxes: sum2((s) => s.boxes),
+      labels: sum2((s) => s.labels),
+      polylines: sum2((s) => s.polylines),
+      linefills: sum2((s) => s.linefills),
+      tables: sum2((s) => s.tables),
+      barColors: sum2((s) => s.barColors),
+      trades: sum2((s) => s.trades),
+      forcedOverlay: sum2((s) => s.forcedOverlay)
     }
   };
 }
@@ -21035,16 +21036,20 @@ var EngineOrchestrator = class _EngineOrchestrator {
   /**
    * Add a NATIVE (core-computed, no Pine engine) indicator by registered type — a first-class
    * indicator that shares the registry, handle, legend, settings, and lifecycle events. SINGLE
-   * INSTANCE per type: a second add returns the existing handle. Unknown type ⇒ a fail-soft handle
-   * that never mounts (mirrors addIndicator). Built-in types: `'volume'`, `'vpvr'`.
+   * INSTANCE per type unless the descriptor opts into `multiInstance`: a second add of a
+   * single-instance type returns the existing handle; a multi-instance type gets a fresh
+   * instance every time. Unknown type ⇒ a fail-soft handle that never mounts (mirrors
+   * addIndicator). Built-in single-instance types: `'volume'`, `'vpvr'`.
    */
   addNativeIndicator(type, options = {}) {
-    const existing = this.registry.all().find((r) => r.native?.type === type);
-    if (existing) return this.handles.get(existing.id) ?? new IndicatorHandleImpl(existing.id, existing.title, this);
     const descriptor = getNativeIndicator(type);
+    if (!descriptor?.multiInstance) {
+      const existing = this.registry.all().find((r) => r.native?.type === type);
+      if (existing) return this.handles.get(existing.id) ?? new IndicatorHandleImpl(existing.id, existing.title, this, void 0, type);
+    }
     const id = this.registry.nextId("native");
     const title = descriptor?.title ?? type;
-    const handle = new IndicatorHandleImpl(id, title, this);
+    const handle = new IndicatorHandleImpl(id, title, this, void 0, type);
     this.handles.set(id, handle);
     if (!descriptor) {
       console.warn(`[vela] addNativeIndicator("${type}") \u2014 no native indicator registered for this type.`);
@@ -21056,16 +21061,18 @@ var EngineOrchestrator = class _EngineOrchestrator {
     void this.startNativeIndicator(id, handle);
     return handle;
   }
-  /**
-   * The catalog of registered native-indicator types with their live state on THIS chart: each
-   * entry's `supported` (applies to the current symbol) and `present` (already added — a second
-   * add is a no-op). Powers a host "add native indicator" menu that can gate + de-duplicate. Async
-   * because a descriptor's `isSupported` may probe the provider for a required capability.
-   */
-  /** The native types present on the chart — SYNC (registry state; no support probe). */
+  /** The native types present on the chart, one entry per INSTANCE in registry order (a
+   *  multi-instance type repeats) — SYNC (registry state; no support probe). */
   presentNativeIndicators() {
     return this.registry.all().map((r) => r.native?.type).filter((t) => !!t);
   }
+  /**
+   * The catalog of registered native-indicator types with their live state on THIS chart: each
+   * entry's `supported` (applies to the current symbol) and `present` (at least one instance
+   * added — a second add of a single-instance type is a no-op). Powers a host "add native
+   * indicator" menu that can gate + de-duplicate. Async because a descriptor's `isSupported` may
+   * probe the provider for a required capability.
+   */
   async availableNativeIndicators() {
     const symbol = this.qualifiedSymbol();
     const present = new Set(this.presentNativeIndicators());
@@ -21075,7 +21082,8 @@ var EngineOrchestrator = class _EngineOrchestrator {
         title: d.title,
         supported: await this.isNativeSupported(d, symbol),
         present: present.has(d.type),
-        beta: d.beta
+        beta: d.beta,
+        ...d.multiInstance ? { multiInstance: true } : {}
       }))
     );
   }
@@ -22015,12 +22023,2322 @@ function registerVpvr() {
   registerNativeIndicator(vpvrDescriptor);
 }
 
+// src/core/native-indicators/classics/define.ts
+function num3(inputs, key, fallback) {
+  const v = inputs[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function str3(inputs, key, fallback) {
+  const v = inputs[key];
+  return typeof v === "string" && v !== "" ? v : fallback;
+}
+function toPoints(bars, values, colors) {
+  const pts = new Array(bars.length);
+  for (let i = 0; i < bars.length; i++) {
+    const v = values[i];
+    const p = { time: bars[i].time, value: v != null && Number.isFinite(v) ? v : null };
+    const c = colors?.[i];
+    if (c != null) p.color = c;
+    pts[i] = p;
+  }
+  return pts;
+}
+var ClassicIndicator = class {
+  constructor(spec) {
+    this.spec = spec;
+    this.inputs = {};
+  }
+  start(ctx, inputs) {
+    this.ctx = ctx;
+    this.inputs = inputs;
+    this.recompute();
+  }
+  onBars() {
+    this.recompute();
+  }
+  onViewport() {
+  }
+  setInputs(inputs) {
+    this.inputs = inputs;
+    this.recompute();
+  }
+  /** Nothing to free — the compute reads the live bar accessor on demand. */
+  suspend() {
+  }
+  resume() {
+    this.recompute();
+  }
+  stop() {
+  }
+  recompute() {
+    const bars = this.ctx.bars();
+    const out = this.spec.compute(bars, this.inputs);
+    const instanceId = this.spec.type;
+    const series = [];
+    const idsByKey = /* @__PURE__ */ new Map();
+    out.plots.forEach((plot, ordinal) => {
+      const kind = plot.kind ?? "line";
+      const id = stableSeriesId({ instanceId, kind, title: plot.title, ordinal });
+      idsByKey.set(plot.key, id);
+      series.push({
+        id,
+        title: plot.title,
+        paneId: "",
+        // stamped by the orchestrator
+        kind,
+        points: toPoints(bars, plot.values, plot.colors),
+        style: {
+          color: plot.color,
+          width: plot.width ?? 1,
+          lineStyle: plot.lineStyle ?? "solid",
+          ...plot.base != null ? { base: plot.base } : {}
+        },
+        ...plot.overlay ? { overlay: true } : {}
+      });
+    });
+    if (out.markers && out.markers.length > 0) {
+      series.push({
+        id: stableSeriesId({ instanceId, kind: "markers", title: "markers", ordinal: 0 }),
+        title: this.spec.shortTitle ?? this.spec.title,
+        paneId: "",
+        kind: "markers",
+        markers: out.markers
+      });
+    }
+    const fills = (out.bands ?? []).flatMap((band, ordinal) => {
+      const from = idsByKey.get(band.from);
+      const to = idsByKey.get(band.to);
+      if (!from || !to) return [];
+      return [
+        {
+          id: stableSeriesId({ instanceId, kind: "fill", title: band.key, ordinal }),
+          paneId: "",
+          fromSeriesId: from,
+          toSeriesId: to,
+          color: band.color
+        }
+      ];
+    });
+    const priceLines = (out.levels ?? []).map((level, ordinal) => ({
+      id: stableSeriesId({ instanceId, kind: "hline", title: level.key, ordinal }),
+      paneId: "",
+      price: level.price,
+      ...level.color != null ? { color: level.color } : {},
+      lineStyle: level.lineStyle ?? "dashed",
+      width: 1,
+      ...level.title != null ? { title: level.title } : {}
+    }));
+    const polylines = (out.polylines ?? []).map((poly, ordinal) => {
+      const { key, ...rest } = poly;
+      return {
+        id: stableSeriesId({ instanceId, kind: "polyline", title: key, ordinal }),
+        paneId: "",
+        ...rest
+      };
+    });
+    this.ctx.emit({ series, fills, priceLines, polylines });
+    this.ctx.setStatus("idle");
+  }
+};
+function classicDescriptor(spec) {
+  return {
+    type: spec.type,
+    title: spec.title,
+    ...spec.shortTitle != null ? { shortTitle: spec.shortTitle } : {},
+    paneHint: spec.overlay ? "price" : "new",
+    overlay: spec.overlay,
+    // Studies stack (a 20 and a 200 moving average side by side) — unlike the layer-backed natives.
+    multiInstance: true,
+    inputsSchema: () => spec.inputs,
+    defaultInputs: () => Object.fromEntries(spec.inputs.map((i) => [i.key, i.defval])),
+    create: () => new ClassicIndicator(spec)
+  };
+}
+
+// src/core/native-indicators/classics/math.ts
+var SOURCES2 = ["Close", "Open", "High", "Low", "HL2", "HLC3", "OHLC4", "HLCC4"];
+function sourceValues(bars, source) {
+  const out = new Array(bars.length);
+  for (let i = 0; i < bars.length; i++) {
+    const b = bars[i];
+    switch (source) {
+      case "Open":
+        out[i] = b.open;
+        break;
+      case "High":
+        out[i] = b.high;
+        break;
+      case "Low":
+        out[i] = b.low;
+        break;
+      case "HL2":
+        out[i] = (b.high + b.low) / 2;
+        break;
+      case "HLC3":
+        out[i] = (b.high + b.low + b.close) / 3;
+        break;
+      case "OHLC4":
+        out[i] = (b.open + b.high + b.low + b.close) / 4;
+        break;
+      case "HLCC4":
+        out[i] = (b.high + b.low + b.close + b.close) / 4;
+        break;
+      default:
+        out[i] = b.close;
+    }
+  }
+  return out;
+}
+function volumes(bars) {
+  return bars.map((b) => b.volume != null && Number.isFinite(b.volume) ? b.volume : Number.NaN);
+}
+function highs(bars) {
+  return bars.map((b) => b.high);
+}
+function lows(bars) {
+  return bars.map((b) => b.low);
+}
+function closes(bars) {
+  return bars.map((b) => b.close);
+}
+function opens(bars) {
+  return bars.map((b) => b.open);
+}
+function zip(a, b, f) {
+  const out = new Array(a.length);
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    out[i] = Number.isFinite(x) && Number.isFinite(y) ? f(x, y) : Number.NaN;
+  }
+  return out;
+}
+function map(a, f) {
+  const out = new Array(a.length);
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    out[i] = Number.isFinite(x) ? f(x) : Number.NaN;
+  }
+  return out;
+}
+function sub(a, b) {
+  return zip(a, b, (x, y) => x - y);
+}
+function windowed(v, len, fold) {
+  const out = new Array(v.length).fill(Number.NaN);
+  if (len <= 0) return out;
+  let run = 0;
+  for (let i = 0; i < v.length; i++) {
+    run = Number.isFinite(v[i]) ? run + 1 : 0;
+    if (run >= len) out[i] = fold(v, i - len + 1, i);
+  }
+  return out;
+}
+function sum(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let s = 0;
+    for (let k = from; k <= to; k++) s += w[k];
+    return s;
+  });
+}
+function sma(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let s = 0;
+    for (let k = from; k <= to; k++) s += w[k];
+    return s / len;
+  });
+}
+function wma(v, len) {
+  const norm = len * (len + 1) / 2;
+  return windowed(v, len, (w, from, to) => {
+    let s = 0;
+    for (let k = from; k <= to; k++) s += w[k] * (k - from + 1);
+    return s / norm;
+  });
+}
+function vwma(src, vol, len) {
+  const pv = zip(src, vol, (p, q) => p * q);
+  return zip(sum(pv, len), sum(vol, len), (a, b) => b > 0 ? a / b : Number.NaN);
+}
+function stdev(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let s = 0;
+    for (let k = from; k <= to; k++) s += w[k];
+    const mean = s / len;
+    let sq = 0;
+    for (let k = from; k <= to; k++) {
+      const d = w[k] - mean;
+      sq += d * d;
+    }
+    return Math.sqrt(sq / len);
+  });
+}
+function highest(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let m = -Infinity;
+    for (let k = from; k <= to; k++) if (w[k] > m) m = w[k];
+    return m;
+  });
+}
+function lowest(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let m = Infinity;
+    for (let k = from; k <= to; k++) if (w[k] < m) m = w[k];
+    return m;
+  });
+}
+function barsSinceHighest(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let m = -Infinity;
+    let at = to;
+    for (let k = from; k <= to; k++) {
+      if (w[k] >= m) {
+        m = w[k];
+        at = k;
+      }
+    }
+    return to - at;
+  });
+}
+function barsSinceLowest(v, len) {
+  return windowed(v, len, (w, from, to) => {
+    let m = Infinity;
+    let at = to;
+    for (let k = from; k <= to; k++) {
+      if (w[k] <= m) {
+        m = w[k];
+        at = k;
+      }
+    }
+    return to - at;
+  });
+}
+function recursive(v, len, alpha) {
+  const out = new Array(v.length).fill(Number.NaN);
+  let run = 0;
+  let prev2 = Number.NaN;
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i];
+    if (!Number.isFinite(x)) {
+      run = 0;
+      prev2 = Number.NaN;
+      continue;
+    }
+    run += 1;
+    if (Number.isFinite(prev2)) {
+      prev2 = alpha * x + (1 - alpha) * prev2;
+      out[i] = prev2;
+    } else if (run >= len) {
+      let s = 0;
+      for (let k = i - len + 1; k <= i; k++) s += v[k];
+      prev2 = s / len;
+      out[i] = prev2;
+    }
+  }
+  return out;
+}
+function ema(v, len) {
+  return recursive(v, len, 2 / (len + 1));
+}
+function rma(v, len) {
+  return recursive(v, len, 1 / len);
+}
+function change(v, n = 1) {
+  const out = new Array(v.length).fill(Number.NaN);
+  for (let i = n; i < v.length; i++) {
+    const a = v[i];
+    const b = v[i - n];
+    if (Number.isFinite(a) && Number.isFinite(b)) out[i] = a - b;
+  }
+  return out;
+}
+function roc(v, len) {
+  const out = new Array(v.length).fill(Number.NaN);
+  for (let i = len; i < v.length; i++) {
+    const a = v[i];
+    const b = v[i - len];
+    if (Number.isFinite(a) && Number.isFinite(b) && b !== 0) out[i] = 100 * (a - b) / b;
+  }
+  return out;
+}
+function shift(v, n) {
+  const out = new Array(v.length).fill(Number.NaN);
+  for (let i = 0; i < v.length; i++) {
+    const j = i - n;
+    if (j >= 0 && j < v.length) out[i] = v[j];
+  }
+  return out;
+}
+function trueRange(bars) {
+  const out = new Array(bars.length).fill(Number.NaN);
+  for (let i = 0; i < bars.length; i++) {
+    const b = bars[i];
+    if (i === 0) {
+      out[i] = b.high - b.low;
+      continue;
+    }
+    const pc = bars[i - 1].close;
+    out[i] = Math.max(b.high - b.low, Math.abs(b.high - pc), Math.abs(b.low - pc));
+  }
+  return out;
+}
+function atr(bars, len) {
+  return rma(trueRange(bars), len);
+}
+function rsi(v, len) {
+  const d = change(v);
+  const up = map(d, (x) => Math.max(x, 0));
+  const dn = map(d, (x) => Math.max(-x, 0));
+  return zip(rma(up, len), rma(dn, len), (u, w) => w === 0 ? 100 : 100 - 100 / (1 + u / w));
+}
+function stoch(v, hi, lo, len) {
+  const hh = highest(hi, len);
+  const ll = lowest(lo, len);
+  const out = new Array(v.length).fill(Number.NaN);
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i];
+    const h = hh[i];
+    const l = ll[i];
+    if (!Number.isFinite(x) || !Number.isFinite(h) || !Number.isFinite(l)) continue;
+    out[i] = h === l ? 50 : 100 * (x - l) / (h - l);
+  }
+  return out;
+}
+function linreg(v, len) {
+  const sx = (len - 1) * len / 2;
+  const sxx = (len - 1) * len * (2 * len - 1) / 6;
+  const denom = len * sxx - sx * sx;
+  return windowed(v, len, (w, from, to) => {
+    let sy = 0;
+    let sxy = 0;
+    for (let k = from; k <= to; k++) {
+      const x = k - from;
+      sy += w[k];
+      sxy += x * w[k];
+    }
+    const slope = denom === 0 ? 0 : (len * sxy - sx * sy) / denom;
+    const intercept = (sy - slope * sx) / len;
+    return intercept + slope * (len - 1);
+  });
+}
+function swma(v) {
+  const out = new Array(v.length).fill(Number.NaN);
+  for (let i = 3; i < v.length; i++) {
+    const a = v[i - 3];
+    const b = v[i - 2];
+    const c = v[i - 1];
+    const d = v[i];
+    if (Number.isFinite(a) && Number.isFinite(b) && Number.isFinite(c) && Number.isFinite(d)) {
+      out[i] = (a + 2 * b + 2 * c + d) / 6;
+    }
+  }
+  return out;
+}
+function percentRank(v, len) {
+  const out = new Array(v.length).fill(Number.NaN);
+  for (let i = len; i < v.length; i++) {
+    const x = v[i];
+    if (!Number.isFinite(x)) continue;
+    let below = 0;
+    let count = 0;
+    for (let k = i - len; k < i; k++) {
+      const y = v[k];
+      if (!Number.isFinite(y)) {
+        count = -1;
+        break;
+      }
+      count += 1;
+      if (y <= x) below += 1;
+    }
+    if (count === len) out[i] = 100 * below / len;
+  }
+  return out;
+}
+function cumSum(v) {
+  const out = new Array(v.length).fill(Number.NaN);
+  let acc = 0;
+  let seen = false;
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i];
+    if (Number.isFinite(x)) {
+      acc += x;
+      seen = true;
+    }
+    if (seen) out[i] = acc;
+  }
+  return out;
+}
+
+// src/core/native-indicators/classics/shared.ts
+function lengthInput(defval, key = "length", title = "Length", max = 5e3) {
+  return { key, title, type: "int", defval, min: 1, max, step: 1 };
+}
+function sourceInput(defval = "Close") {
+  return { key: "source", title: "Source", type: "string", defval, options: SOURCES2 };
+}
+function colorInput(defval = SERIES_LINE, title = "Color", key = "color") {
+  return { key, title, type: "color", defval };
+}
+function withAlpha2(hex, alpha = 0.08) {
+  const m = /^#([0-9a-f]{6})$/i.exec(hex.trim());
+  if (!m) return hex;
+  const a = Math.round(alpha * 255).toString(16).padStart(2, "0");
+  return `#${m[1]}${a}`;
+}
+
+// src/core/native-indicators/classics/averages.ts
+var MA_KINDS = ["SMA", "EMA", "WMA", "RMA", "VWMA"];
+var offsetInput = { key: "offset", title: "Offset", type: "int", defval: 0, min: -500, max: 500, step: 1 };
+function fixedAverage(type, title, shortTitle, smooth) {
+  return {
+    type,
+    title,
+    shortTitle,
+    overlay: true,
+    inputs: [lengthInput(20), sourceInput(), offsetInput, colorInput()],
+    compute: (bars, inputs) => {
+      const len = num3(inputs, "length", 20);
+      let values = smooth(sourceValues(bars, str3(inputs, "source", "Close")), len);
+      const offset = Math.trunc(num3(inputs, "offset", 0));
+      if (offset !== 0) values = shift(values, offset);
+      return { plots: [{ key: shortTitle.toLowerCase(), title: shortTitle, values, color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+    }
+  };
+}
+var simpleMa = fixedAverage("sma", "Simple Moving Average", "SMA", sma);
+var exponentialMa = fixedAverage("ema", "Exponential Moving Average", "EMA", ema);
+var movingAverage = {
+  type: "moving-average",
+  title: "Moving Average",
+  shortTitle: "MA",
+  overlay: true,
+  inputs: [
+    { key: "maType", title: "Type", type: "string", defval: "SMA", options: MA_KINDS },
+    lengthInput(20),
+    sourceInput(),
+    offsetInput,
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const kind = str3(inputs, "maType", "SMA");
+    let values;
+    switch (kind) {
+      case "EMA":
+        values = ema(src, len);
+        break;
+      case "WMA":
+        values = wma(src, len);
+        break;
+      case "RMA":
+        values = rma(src, len);
+        break;
+      case "VWMA":
+        values = vwma(src, volumes(bars), len);
+        break;
+      default:
+        values = sma(src, len);
+    }
+    const offset = Math.trunc(num3(inputs, "offset", 0));
+    if (offset !== 0) values = shift(values, offset);
+    return { plots: [{ key: "ma", title: kind, values, color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var smoothedMa = {
+  type: "rma",
+  title: "Smoothed Moving Average",
+  shortTitle: "RMA",
+  overlay: true,
+  inputs: [lengthInput(14), sourceInput(), colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [
+      {
+        key: "rma",
+        title: "RMA",
+        values: rma(sourceValues(bars, str3(inputs, "source", "Close")), num3(inputs, "length", 14)),
+        color: str3(inputs, "color", SERIES_LINE),
+        width: 2
+      }
+    ]
+  })
+};
+var zlema = {
+  type: "zlema",
+  title: "Zero-Lag Exponential Moving Average",
+  shortTitle: "ZLEMA",
+  overlay: true,
+  inputs: [lengthInput(14), sourceInput(), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const lag = Math.floor((len - 1) / 2);
+    const lagged = shift(src, lag);
+    const delagged = zip(src, lagged, (a, b) => 2 * a - b);
+    return { plots: [{ key: "zlema", title: "ZLEMA", values: ema(delagged, len), color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var vidya = {
+  type: "vidya",
+  title: "Variable Index Dynamic Average",
+  shortTitle: "VIDYA",
+  overlay: true,
+  inputs: [lengthInput(14), { key: "cmoLength", title: "Momentum length", type: "int", defval: 9, min: 1, max: 500, step: 1 }, sourceInput(), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const cmoLen = num3(inputs, "cmoLength", 9);
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const d = change(src);
+    const su = new Array(src.length).fill(Number.NaN);
+    const sd = new Array(src.length).fill(Number.NaN);
+    for (let i = cmoLen; i < src.length; i++) {
+      let u = 0;
+      let w = 0;
+      let ok = true;
+      for (let k = i - cmoLen + 1; k <= i; k++) {
+        const x = d[k];
+        if (!Number.isFinite(x)) {
+          ok = false;
+          break;
+        }
+        if (x > 0) u += x;
+        else w -= x;
+      }
+      if (ok) {
+        su[i] = u;
+        sd[i] = w;
+      }
+    }
+    const alpha = 2 / (len + 1);
+    const out = new Array(src.length).fill(Number.NaN);
+    let prev2 = Number.NaN;
+    for (let i = 0; i < src.length; i++) {
+      const x = src[i];
+      const u = su[i];
+      const w = sd[i];
+      if (!Number.isFinite(x) || !Number.isFinite(u) || !Number.isFinite(w)) continue;
+      const total = u + w;
+      const k = total === 0 ? 0 : Math.abs((u - w) / total);
+      prev2 = Number.isFinite(prev2) ? alpha * k * x + (1 - alpha * k) * prev2 : x;
+      out[i] = prev2;
+    }
+    return { plots: [{ key: "vidya", title: "VIDYA", values: out, color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var maEnvelope = {
+  type: "ma-envelope",
+  title: "Moving Average Envelope",
+  shortTitle: "MA Env",
+  overlay: true,
+  inputs: [
+    { key: "maType", title: "Type", type: "string", defval: "SMA", options: ["SMA", "EMA"] },
+    lengthInput(20),
+    sourceInput(),
+    { key: "percent", title: "Percent", type: "float", defval: 2.5, min: 0.01, max: 50, step: 0.1 },
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const basis = str3(inputs, "maType", "SMA") === "EMA" ? ema(src, len) : sma(src, len);
+    const k = num3(inputs, "percent", 2.5) / 100;
+    const ink = str3(inputs, "color", SERIES_LINE);
+    return {
+      plots: [
+        { key: "basis", title: "Basis", values: basis, color: ink, width: 2 },
+        { key: "upper", title: "Upper", values: map(basis, (x) => x * (1 + k)), color: ink },
+        { key: "lower", title: "Lower", values: map(basis, (x) => x * (1 - k)), color: ink }
+      ],
+      bands: [{ key: "envelope", from: "upper", to: "lower", color: withAlpha2(ink) }]
+    };
+  }
+};
+var linearRegression = {
+  type: "linear-regression",
+  title: "Linear Regression Curve",
+  shortTitle: "LinReg",
+  overlay: true,
+  inputs: [lengthInput(14), sourceInput(), colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [
+      {
+        key: "linreg",
+        title: "LinReg",
+        values: linreg(sourceValues(bars, str3(inputs, "source", "Close")), num3(inputs, "length", 14)),
+        color: str3(inputs, "color", SERIES_LINE),
+        width: 2
+      }
+    ]
+  })
+};
+var averageSpecs = [simpleMa, exponentialMa, movingAverage, smoothedMa, zlema, vidya, maEnvelope, linearRegression];
+
+// src/core/native-indicators/classics/bands.ts
+function bollinger(bars, inputs) {
+  const len = num3(inputs, "length", 20);
+  const mult = num3(inputs, "mult", 2);
+  const src = sourceValues(bars, str3(inputs, "source", "Close"));
+  const basis = sma(src, len);
+  const dev = map(stdev(src, len), (x) => x * mult);
+  return { basis, upper: zip(basis, dev, (b, d) => b + d), lower: zip(basis, dev, (b, d) => b - d) };
+}
+var BB_INPUTS = [lengthInput(20), sourceInput(), { key: "mult", title: "StdDev", type: "float", defval: 2, min: 0.1, max: 50, step: 0.1 }];
+var bollingerBands = {
+  type: "bollinger-bands",
+  title: "Bollinger Bands",
+  shortTitle: "BB",
+  overlay: true,
+  inputs: [...BB_INPUTS, colorInput()],
+  compute: (bars, inputs) => {
+    const { basis, upper, lower } = bollinger(bars, inputs);
+    const ink = str3(inputs, "color", SERIES_LINE);
+    return {
+      plots: [
+        { key: "basis", title: "Basis", values: basis, color: WARNING },
+        { key: "upper", title: "Upper", values: upper, color: ink },
+        { key: "lower", title: "Lower", values: lower, color: ink }
+      ],
+      bands: [{ key: "bb", from: "upper", to: "lower", color: withAlpha2(ink) }]
+    };
+  }
+};
+var percentB = {
+  type: "percent-b",
+  title: "Bollinger Bands %B",
+  shortTitle: "%B",
+  overlay: false,
+  inputs: [...BB_INPUTS, colorInput()],
+  compute: (bars, inputs) => {
+    const { upper, lower } = bollinger(bars, inputs);
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const values = src.map((x, i) => {
+      const u = upper[i];
+      const l = lower[i];
+      return Number.isFinite(u) && Number.isFinite(l) && u !== l ? (x - l) / (u - l) : Number.NaN;
+    });
+    return {
+      plots: [{ key: "pb", title: "%B", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [
+        { key: "upper", price: 1, color: NEUTRAL },
+        { key: "middle", price: 0.5, color: NEUTRAL, lineStyle: "dotted" },
+        { key: "lower", price: 0, color: NEUTRAL }
+      ]
+    };
+  }
+};
+var bandwidth = {
+  type: "bandwidth",
+  title: "Bollinger Bands Width",
+  shortTitle: "BandWidth",
+  overlay: false,
+  inputs: [...BB_INPUTS, colorInput()],
+  compute: (bars, inputs) => {
+    const { basis, upper, lower } = bollinger(bars, inputs);
+    const values = basis.map((b, i) => {
+      const u = upper[i];
+      const l = lower[i];
+      return Number.isFinite(b) && b !== 0 && Number.isFinite(u) && Number.isFinite(l) ? (u - l) / b * 100 : Number.NaN;
+    });
+    return { plots: [{ key: "bbw", title: "BBW", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var keltner = {
+  type: "keltner-channels",
+  title: "Keltner Channels",
+  shortTitle: "KC",
+  overlay: true,
+  inputs: [
+    lengthInput(20),
+    { key: "mult", title: "Multiplier", type: "float", defval: 2, min: 0.1, max: 50, step: 0.1 },
+    { key: "atrLength", title: "ATR length", type: "int", defval: 10, min: 1, max: 500, step: 1 },
+    sourceInput(),
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const mult = num3(inputs, "mult", 2);
+    const basis = ema(sourceValues(bars, str3(inputs, "source", "Close")), len);
+    const range = map(atr(bars, num3(inputs, "atrLength", 10)), (x) => x * mult);
+    const ink = str3(inputs, "color", SERIES_LINE);
+    return {
+      plots: [
+        { key: "basis", title: "Basis", values: basis, color: WARNING },
+        { key: "upper", title: "Upper", values: zip(basis, range, (b, r) => b + r), color: ink },
+        { key: "lower", title: "Lower", values: zip(basis, range, (b, r) => b - r), color: ink }
+      ],
+      bands: [{ key: "kc", from: "upper", to: "lower", color: withAlpha2(ink) }]
+    };
+  }
+};
+var donchian = {
+  type: "donchian-channels",
+  title: "Donchian Channels",
+  shortTitle: "DC",
+  overlay: true,
+  inputs: [lengthInput(20), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const upper = highest(highs(bars), len);
+    const lower = lowest(lows(bars), len);
+    const ink = str3(inputs, "color", SERIES_LINE);
+    return {
+      plots: [
+        { key: "basis", title: "Basis", values: zip(upper, lower, (u, l) => (u + l) / 2), color: WARNING },
+        { key: "upper", title: "Upper", values: upper, color: ink },
+        { key: "lower", title: "Lower", values: lower, color: ink }
+      ],
+      bands: [{ key: "dc", from: "upper", to: "lower", color: withAlpha2(ink) }]
+    };
+  }
+};
+var chandelier = {
+  type: "chandelier-exit",
+  title: "Chandelier Exit",
+  shortTitle: "CE",
+  overlay: true,
+  inputs: [lengthInput(22), { key: "mult", title: "ATR multiplier", type: "float", defval: 3, min: 0.1, max: 50, step: 0.1 }],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 22);
+    const range = map(atr(bars, len), (x) => x * num3(inputs, "mult", 3));
+    const long = zip(highest(highs(bars), len), range, (h, r) => h - r);
+    const short = zip(lowest(lows(bars), len), range, (l, r) => l + r);
+    return {
+      plots: [
+        { key: "long", title: "Long stop", values: long, color: BULLISH },
+        { key: "short", title: "Short stop", values: short, color: BEARISH }
+      ]
+    };
+  }
+};
+var chandeKroll = {
+  type: "chande-kroll-stop",
+  title: "Chande Kroll Stop",
+  shortTitle: "CKS",
+  overlay: true,
+  inputs: [
+    { key: "p", title: "ATR length", type: "int", defval: 10, min: 1, max: 500, step: 1 },
+    { key: "x", title: "ATR multiplier", type: "float", defval: 1, min: 0.1, max: 50, step: 0.1 },
+    { key: "q", title: "Stop length", type: "int", defval: 9, min: 1, max: 500, step: 1 }
+  ],
+  compute: (bars, inputs) => {
+    const p = num3(inputs, "p", 10);
+    const x = num3(inputs, "x", 1);
+    const q = num3(inputs, "q", 9);
+    const range = map(atr(bars, p), (v) => v * x);
+    const firstHigh = zip(highest(highs(bars), p), range, (h, r) => h - r);
+    const firstLow = zip(lowest(lows(bars), p), range, (l, r) => l + r);
+    return {
+      plots: [
+        { key: "stopShort", title: "Stop short", values: highest(firstHigh, q), color: BEARISH },
+        { key: "stopLong", title: "Stop long", values: lowest(firstLow, q), color: BULLISH }
+      ]
+    };
+  }
+};
+var supertrend = {
+  type: "supertrend",
+  title: "SuperTrend",
+  shortTitle: "SuperTrend",
+  overlay: true,
+  inputs: [
+    { key: "atrLength", title: "ATR length", type: "int", defval: 10, min: 1, max: 500, step: 1 },
+    { key: "mult", title: "Factor", type: "float", defval: 3, min: 0.1, max: 50, step: 0.1 }
+  ],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "atrLength", 10);
+    const mult = num3(inputs, "mult", 3);
+    const range = atr(bars, len);
+    const n = bars.length;
+    const st = new Array(n).fill(Number.NaN);
+    const dir = new Array(n).fill(1);
+    let up = Number.NaN;
+    let dn = Number.NaN;
+    let trend = 1;
+    for (let i = 0; i < n; i++) {
+      const r = range[i];
+      if (!Number.isFinite(r)) continue;
+      const b = bars[i];
+      const mid = (b.high + b.low) / 2;
+      const basicUp = mid - mult * r;
+      const basicDn = mid + mult * r;
+      const prevClose = i > 0 ? bars[i - 1].close : b.close;
+      up = Number.isFinite(up) && prevClose > up ? Math.max(basicUp, up) : basicUp;
+      dn = Number.isFinite(dn) && prevClose < dn ? Math.min(basicDn, dn) : basicDn;
+      if (trend === 1 && b.close < up) trend = -1;
+      else if (trend === -1 && b.close > dn) trend = 1;
+      dir[i] = trend;
+      st[i] = trend === 1 ? up : dn;
+    }
+    const colors = dir.map((d, i) => Number.isFinite(st[i]) ? d === 1 ? BULLISH : BEARISH : null);
+    return { plots: [{ key: "st", title: "SuperTrend", values: st, color: BULLISH, width: 2, colors }] };
+  }
+};
+var alligator = {
+  type: "williams-alligator",
+  title: "Williams Alligator",
+  shortTitle: "Alligator",
+  overlay: true,
+  inputs: [
+    { key: "jawLength", title: "Jaw length", type: "int", defval: 13, min: 1, max: 500, step: 1 },
+    { key: "teethLength", title: "Teeth length", type: "int", defval: 8, min: 1, max: 500, step: 1 },
+    { key: "lipsLength", title: "Lips length", type: "int", defval: 5, min: 1, max: 500, step: 1 },
+    { key: "jawOffset", title: "Jaw offset", type: "int", defval: 8, min: 0, max: 100, step: 1 },
+    { key: "teethOffset", title: "Teeth offset", type: "int", defval: 5, min: 0, max: 100, step: 1 },
+    { key: "lipsOffset", title: "Lips offset", type: "int", defval: 3, min: 0, max: 100, step: 1 }
+  ],
+  compute: (bars, inputs) => {
+    const hl2 = sourceValues(bars, "HL2");
+    const jaw = shift(rma(hl2, num3(inputs, "jawLength", 13)), num3(inputs, "jawOffset", 8));
+    const teeth = shift(rma(hl2, num3(inputs, "teethLength", 8)), num3(inputs, "teethOffset", 5));
+    const lips = shift(rma(hl2, num3(inputs, "lipsLength", 5)), num3(inputs, "lipsOffset", 3));
+    return {
+      plots: [
+        { key: "jaw", title: "Jaw", values: jaw, color: SERIES_LINE },
+        { key: "teeth", title: "Teeth", values: teeth, color: BEARISH },
+        { key: "lips", title: "Lips", values: lips, color: BULLISH }
+      ]
+    };
+  }
+};
+var gator = {
+  type: "gator-oscillator",
+  title: "Gator Oscillator",
+  shortTitle: "Gator Oscillator",
+  overlay: false,
+  inputs: [],
+  compute: (bars) => {
+    const hl2 = sourceValues(bars, "HL2");
+    const jaw = shift(rma(hl2, 13), 8);
+    const teeth = shift(rma(hl2, 8), 5);
+    const lips = shift(rma(hl2, 5), 3);
+    const upper = map(sub(jaw, teeth), Math.abs);
+    const lower = map(sub(teeth, lips), (x) => -Math.abs(x));
+    const colorByExpansion = (v) => v.map((x, i) => {
+      if (!Number.isFinite(x)) return null;
+      const prev2 = i > 0 ? v[i - 1] : Number.NaN;
+      return Number.isFinite(prev2) && Math.abs(x) > Math.abs(prev2) ? BULLISH : BEARISH;
+    });
+    return {
+      plots: [
+        { key: "upper", title: "Upper", values: upper, kind: "histogram", color: BULLISH, colors: colorByExpansion(upper), base: 0 },
+        { key: "lower", title: "Lower", values: lower, kind: "histogram", color: BEARISH, colors: colorByExpansion(lower), base: 0 }
+      ]
+    };
+  }
+};
+var bandSpecs = [bollingerBands, percentB, bandwidth, keltner, donchian, chandelier, chandeKroll, supertrend, alligator, gator];
+
+// src/core/native-indicators/classics/oscillators.ts
+function guideLevels(low, high, mid) {
+  const levels = [
+    { key: "upper", price: high, color: NEUTRAL },
+    { key: "lower", price: low, color: NEUTRAL }
+  ];
+  if (mid != null) levels.splice(1, 0, { key: "middle", price: mid, color: NEUTRAL, lineStyle: "dotted" });
+  return levels;
+}
+var ZERO_LEVEL = [{ key: "zero", price: 0, color: NEUTRAL }];
+function histColors(values) {
+  return values.map((x, i) => {
+    if (!Number.isFinite(x)) return null;
+    const prev2 = i > 0 ? values[i - 1] : Number.NaN;
+    const rising = Number.isFinite(prev2) ? x >= prev2 : true;
+    if (x >= 0) return rising ? BULLISH : `${BULLISH}80`;
+    return rising ? `${BEARISH}80` : BEARISH;
+  });
+}
+var rsiSpec = {
+  type: "rsi",
+  title: "Relative Strength Index",
+  shortTitle: "RSI",
+  overlay: false,
+  inputs: [lengthInput(14), sourceInput(), colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [
+      {
+        key: "rsi",
+        title: "RSI",
+        values: rsi(sourceValues(bars, str3(inputs, "source", "Close")), num3(inputs, "length", 14)),
+        color: str3(inputs, "color", SERIES_LINE),
+        width: 2
+      }
+    ],
+    levels: guideLevels(30, 70, 50)
+  })
+};
+var stochastic = {
+  type: "stochastic",
+  title: "Stochastic",
+  shortTitle: "Stoch",
+  overlay: false,
+  inputs: [
+    lengthInput(14, "kLength", "%K length"),
+    lengthInput(1, "kSmoothing", "%K smoothing", 500),
+    lengthInput(3, "dLength", "%D smoothing", 500)
+  ],
+  compute: (bars, inputs) => {
+    const k = sma(stoch(closes(bars), highs(bars), lows(bars), num3(inputs, "kLength", 14)), num3(inputs, "kSmoothing", 1));
+    const d = sma(k, num3(inputs, "dLength", 3));
+    return {
+      plots: [
+        { key: "k", title: "%K", values: k, color: SERIES_LINE, width: 2 },
+        { key: "d", title: "%D", values: d, color: WARNING }
+      ],
+      levels: guideLevels(20, 80)
+    };
+  }
+};
+var stochasticRsi = {
+  type: "stochastic-rsi",
+  title: "Stochastic RSI",
+  shortTitle: "Stoch RSI",
+  overlay: false,
+  inputs: [
+    lengthInput(14, "rsiLength", "RSI length"),
+    lengthInput(14, "stochLength", "Stochastic length"),
+    lengthInput(3, "kSmoothing", "%K smoothing", 500),
+    lengthInput(3, "dLength", "%D smoothing", 500),
+    sourceInput()
+  ],
+  compute: (bars, inputs) => {
+    const r = rsi(sourceValues(bars, str3(inputs, "source", "Close")), num3(inputs, "rsiLength", 14));
+    const k = sma(stoch(r, r, r, num3(inputs, "stochLength", 14)), num3(inputs, "kSmoothing", 3));
+    const d = sma(k, num3(inputs, "dLength", 3));
+    return {
+      plots: [
+        { key: "k", title: "%K", values: k, color: SERIES_LINE, width: 2 },
+        { key: "d", title: "%D", values: d, color: WARNING }
+      ],
+      levels: guideLevels(20, 80)
+    };
+  }
+};
+var macd = {
+  type: "macd",
+  title: "MACD",
+  overlay: false,
+  inputs: [
+    lengthInput(12, "fastLength", "Fast length"),
+    lengthInput(26, "slowLength", "Slow length"),
+    lengthInput(9, "signalLength", "Signal smoothing", 500),
+    sourceInput()
+  ],
+  compute: (bars, inputs) => {
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const line = sub(ema(src, num3(inputs, "fastLength", 12)), ema(src, num3(inputs, "slowLength", 26)));
+    const signal = ema(line, num3(inputs, "signalLength", 9));
+    const hist = sub(line, signal);
+    return {
+      plots: [
+        { key: "hist", title: "Histogram", values: hist, kind: "histogram", color: BULLISH, colors: histColors(hist), base: 0 },
+        { key: "macd", title: "MACD", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: signal, color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var ppo = {
+  type: "ppo",
+  title: "Percentage Price Oscillator",
+  shortTitle: "PPO",
+  overlay: false,
+  inputs: [
+    lengthInput(12, "fastLength", "Fast length"),
+    lengthInput(26, "slowLength", "Slow length"),
+    lengthInput(9, "signalLength", "Signal smoothing", 500),
+    sourceInput()
+  ],
+  compute: (bars, inputs) => {
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const fast = ema(src, num3(inputs, "fastLength", 12));
+    const slow = ema(src, num3(inputs, "slowLength", 26));
+    const line = zip(fast, slow, (f, s) => s === 0 ? Number.NaN : (f - s) / s * 100);
+    const signal = ema(line, num3(inputs, "signalLength", 9));
+    const hist = sub(line, signal);
+    return {
+      plots: [
+        { key: "hist", title: "Histogram", values: hist, kind: "histogram", color: BULLISH, colors: histColors(hist), base: 0 },
+        { key: "ppo", title: "PPO", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: signal, color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var awesome = {
+  type: "awesome-oscillator",
+  title: "Awesome Oscillator",
+  shortTitle: "AO",
+  overlay: false,
+  inputs: [],
+  compute: (bars) => {
+    const hl2 = sourceValues(bars, "HL2");
+    const ao = sub(sma(hl2, 5), sma(hl2, 34));
+    const colors = ao.map((x, i) => {
+      if (!Number.isFinite(x)) return null;
+      const prev2 = i > 0 ? ao[i - 1] : Number.NaN;
+      return Number.isFinite(prev2) && x < prev2 ? BEARISH : BULLISH;
+    });
+    return {
+      plots: [{ key: "ao", title: "AO", values: ao, kind: "histogram", color: BULLISH, colors, base: 0 }],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var cci = {
+  type: "commodity-channel-index",
+  title: "Commodity Channel Index",
+  shortTitle: "CCI",
+  overlay: false,
+  inputs: [lengthInput(20), sourceInput("HLC3"), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const src = sourceValues(bars, str3(inputs, "source", "HLC3"));
+    const basis = sma(src, len);
+    const dev = new Array(src.length).fill(Number.NaN);
+    for (let i = len - 1; i < src.length; i++) {
+      const mean = basis[i];
+      if (!Number.isFinite(mean)) continue;
+      let d = 0;
+      for (let k = i - len + 1; k <= i; k++) d += Math.abs(src[k] - mean);
+      dev[i] = d / len;
+    }
+    const values = src.map((x, i) => {
+      const b = basis[i];
+      const d = dev[i];
+      return Number.isFinite(b) && Number.isFinite(d) && d !== 0 ? (x - b) / (0.015 * d) : Number.NaN;
+    });
+    return {
+      plots: [{ key: "cci", title: "CCI", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: guideLevels(-100, 100, 0)
+    };
+  }
+};
+var williamsR = {
+  type: "williams-percent-r",
+  title: "Williams %R",
+  shortTitle: "%R",
+  overlay: false,
+  inputs: [lengthInput(14), colorInput()],
+  compute: (bars, inputs) => {
+    const values = map(stoch(closes(bars), highs(bars), lows(bars), num3(inputs, "length", 14)), (x) => x - 100);
+    return {
+      plots: [{ key: "wr", title: "%R", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: guideLevels(-80, -20)
+    };
+  }
+};
+var cmo = {
+  type: "chande-momentum-oscillator",
+  title: "Chande Momentum Oscillator",
+  shortTitle: "CMO",
+  overlay: false,
+  inputs: [lengthInput(9), sourceInput(), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 9);
+    const d = change(sourceValues(bars, str3(inputs, "source", "Close")));
+    const su = sum(map(d, (x) => Math.max(x, 0)), len);
+    const sd = sum(map(d, (x) => Math.max(-x, 0)), len);
+    const values = zip(su, sd, (u, w) => u + w === 0 ? 0 : 100 * (u - w) / (u + w));
+    return {
+      plots: [{ key: "cmo", title: "CMO", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: guideLevels(-50, 50, 0)
+    };
+  }
+};
+var connorsRsi = {
+  type: "connors-rsi",
+  title: "Connors RSI",
+  shortTitle: "CRSI",
+  overlay: false,
+  inputs: [
+    lengthInput(3, "rsiLength", "RSI length"),
+    lengthInput(2, "streakLength", "Streak RSI length"),
+    lengthInput(100, "rankLength", "Percent-rank length"),
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const c = closes(bars);
+    const streak = new Array(c.length).fill(0);
+    for (let i = 1; i < c.length; i++) {
+      const d = c[i] - c[i - 1];
+      streak[i] = d > 0 ? Math.max(streak[i - 1], 0) + 1 : d < 0 ? Math.min(streak[i - 1], 0) - 1 : 0;
+    }
+    const a = rsi(c, num3(inputs, "rsiLength", 3));
+    const b = rsi(streak, num3(inputs, "streakLength", 2));
+    const r = percentRank(roc(c, 1), num3(inputs, "rankLength", 100));
+    const values = c.map((_, i) => {
+      const x = a[i];
+      const y = b[i];
+      const z = r[i];
+      return Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z) ? (x + y + z) / 3 : Number.NaN;
+    });
+    return {
+      plots: [{ key: "crsi", title: "CRSI", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: guideLevels(20, 80, 50)
+    };
+  }
+};
+var fisher = {
+  type: "fisher-transform",
+  title: "Fisher Transform",
+  shortTitle: "Fisher",
+  overlay: false,
+  inputs: [lengthInput(9)],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 9);
+    const hl2 = sourceValues(bars, "HL2");
+    const hi = highest(hl2, len);
+    const lo = lowest(hl2, len);
+    const n = bars.length;
+    const out = new Array(n).fill(Number.NaN);
+    let value = 0;
+    let fish = 0;
+    for (let i = 0; i < n; i++) {
+      const h = hi[i];
+      const l = lo[i];
+      if (!Number.isFinite(h) || !Number.isFinite(l)) continue;
+      const norm = h === l ? 0 : (hl2[i] - l) / (h - l) - 0.5;
+      value = Math.max(-0.999, Math.min(0.999, 0.66 * norm + 0.67 * value));
+      fish = 0.5 * Math.log((1 + value) / (1 - value)) + 0.5 * fish;
+      out[i] = fish;
+    }
+    return {
+      plots: [
+        { key: "fisher", title: "Fisher", values: out, color: SERIES_LINE, width: 2 },
+        { key: "trigger", title: "Trigger", values: shift(out, 1), color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var trix = {
+  type: "trix",
+  title: "TRIX",
+  overlay: false,
+  inputs: [lengthInput(18), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 18);
+    const logClose = map(closes(bars), Math.log);
+    const smooth = ema(ema(ema(logClose, len), len), len);
+    const values = map(change(smooth), (x) => x * 1e4);
+    return {
+      plots: [{ key: "trix", title: "TRIX", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+function tsiLine(src, long, short) {
+  const mom = change(src);
+  const numer = ema(ema(mom, long), short);
+  const denom = ema(ema(map(mom, Math.abs), long), short);
+  return zip(numer, denom, (a, b) => b === 0 ? 0 : 100 * a / b);
+}
+var tsi = {
+  type: "true-strength-index",
+  title: "True Strength Index",
+  shortTitle: "TSI",
+  overlay: false,
+  inputs: [lengthInput(25, "longLength", "Long length"), lengthInput(13, "shortLength", "Short length"), lengthInput(13, "signalLength", "Signal length")],
+  compute: (bars, inputs) => {
+    const line = tsiLine(closes(bars), num3(inputs, "longLength", 25), num3(inputs, "shortLength", 13));
+    return {
+      plots: [
+        { key: "tsi", title: "TSI", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: ema(line, num3(inputs, "signalLength", 13)), color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var smiErgodic = {
+  type: "smi-ergodic",
+  title: "SMI Ergodic Oscillator",
+  shortTitle: "SMIE",
+  overlay: false,
+  inputs: [lengthInput(5, "shortLength", "Short length"), lengthInput(20, "longLength", "Long length"), lengthInput(5, "signalLength", "Signal length")],
+  compute: (bars, inputs) => {
+    const line = tsiLine(closes(bars), num3(inputs, "longLength", 20), num3(inputs, "shortLength", 5));
+    const signal = ema(line, num3(inputs, "signalLength", 5));
+    const osc = sub(line, signal);
+    return {
+      plots: [
+        { key: "osc", title: "Oscillator", values: osc, kind: "histogram", color: BULLISH, colors: histColors(osc), base: 0 },
+        { key: "smi", title: "SMI", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: signal, color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var stc = {
+  type: "schaff-trend-cycle",
+  title: "Schaff Trend Cycle",
+  shortTitle: "Schaff Trend Cycle",
+  overlay: false,
+  inputs: [lengthInput(10, "cycleLength", "Cycle length"), lengthInput(23, "fastLength", "Fast length"), lengthInput(50, "slowLength", "Slow length")],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "cycleLength", 10);
+    const src = closes(bars);
+    const macdLine = sub(ema(src, num3(inputs, "fastLength", 23)), ema(src, num3(inputs, "slowLength", 50)));
+    const stochOf = (v) => {
+      const lo = lowest(v, len);
+      const hi = highest(v, len);
+      const out = new Array(v.length).fill(Number.NaN);
+      let prevRaw = Number.NaN;
+      let smoothed = Number.NaN;
+      for (let i = 0; i < v.length; i++) {
+        const x = v[i];
+        const l = lo[i];
+        const h = hi[i];
+        if (!Number.isFinite(x) || !Number.isFinite(l) || !Number.isFinite(h)) continue;
+        const raw = h > l ? (x - l) / (h - l) * 100 : Number.isFinite(prevRaw) ? prevRaw : 50;
+        prevRaw = raw;
+        smoothed = Number.isFinite(smoothed) ? smoothed + 0.5 * (raw - smoothed) : raw;
+        out[i] = smoothed;
+      }
+      return out;
+    };
+    const values = stochOf(stochOf(macdLine));
+    return {
+      plots: [{ key: "stc", title: "STC", values, color: SERIES_LINE, width: 2 }],
+      levels: guideLevels(25, 75)
+    };
+  }
+};
+var kst = {
+  type: "know-sure-thing",
+  title: "Know Sure Thing",
+  shortTitle: "KST",
+  overlay: false,
+  inputs: [sourceInput(), lengthInput(9, "signalLength", "Signal length")],
+  compute: (bars, inputs) => {
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const line = [
+      sma(roc(src, 10), 10),
+      sma(roc(src, 15), 10),
+      sma(roc(src, 20), 10),
+      sma(roc(src, 30), 15)
+    ].reduce((acc, r, i) => zip(acc, r, (a, b) => a + b * (i + 1)), new Array(src.length).fill(0));
+    return {
+      plots: [
+        { key: "kst", title: "KST", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: sma(line, num3(inputs, "signalLength", 9)), color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var coppock = {
+  type: "coppock-curve",
+  title: "Coppock Curve",
+  shortTitle: "Coppock",
+  overlay: false,
+  inputs: [
+    lengthInput(10, "wmaLength", "WMA length"),
+    lengthInput(14, "longRoc", "Long RoC length"),
+    lengthInput(11, "shortRoc", "Short RoC length"),
+    sourceInput(),
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const values = wma(zip(roc(src, num3(inputs, "longRoc", 14)), roc(src, num3(inputs, "shortRoc", 11)), (a, b) => a + b), num3(inputs, "wmaLength", 10));
+    return {
+      plots: [{ key: "coppock", title: "Coppock", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var dpo = {
+  type: "detrended-price-oscillator",
+  title: "Detrended Price Oscillator",
+  shortTitle: "DPO",
+  overlay: false,
+  inputs: [lengthInput(21), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 21);
+    const barsback = Math.floor(len / 2) + 1;
+    const values = sub(closes(bars), shift(sma(closes(bars), len), barsback));
+    return {
+      plots: [{ key: "dpo", title: "DPO", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var rocSpec = {
+  type: "rate-of-change",
+  title: "Rate of Change",
+  shortTitle: "ROC",
+  overlay: false,
+  inputs: [lengthInput(9), sourceInput(), colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [
+      {
+        key: "roc",
+        title: "RoC",
+        values: roc(sourceValues(bars, str3(inputs, "source", "Close")), num3(inputs, "length", 9)),
+        color: str3(inputs, "color", SERIES_LINE),
+        width: 2
+      }
+    ],
+    levels: ZERO_LEVEL
+  })
+};
+var ultimate = {
+  type: "ultimate-oscillator",
+  title: "Ultimate Oscillator",
+  shortTitle: "UO",
+  overlay: false,
+  inputs: [lengthInput(7, "fastLength", "Fast length"), lengthInput(14, "middleLength", "Middle length"), lengthInput(28, "slowLength", "Slow length"), colorInput()],
+  compute: (bars, inputs) => {
+    const n = bars.length;
+    const bp = new Array(n).fill(Number.NaN);
+    const tr = new Array(n).fill(Number.NaN);
+    for (let i = 0; i < n; i++) {
+      const b = bars[i];
+      const pc = i > 0 ? bars[i - 1].close : b.close;
+      const lo = Math.min(b.low, pc);
+      const hi = Math.max(b.high, pc);
+      bp[i] = b.close - lo;
+      tr[i] = hi - lo;
+    }
+    const avg = (len) => zip(sum(bp, len), sum(tr, len), (a, b) => b === 0 ? Number.NaN : a / b);
+    const a7 = avg(num3(inputs, "fastLength", 7));
+    const a14 = avg(num3(inputs, "middleLength", 14));
+    const a28 = avg(num3(inputs, "slowLength", 28));
+    const values = a7.map((x, i) => {
+      const y = a14[i];
+      const z = a28[i];
+      return Number.isFinite(x) && Number.isFinite(y) && Number.isFinite(z) ? 100 * (4 * x + 2 * y + z) / 7 : Number.NaN;
+    });
+    return {
+      plots: [{ key: "uo", title: "UO", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: guideLevels(30, 70, 50)
+    };
+  }
+};
+var rvgi = {
+  type: "relative-vigor-index",
+  title: "Relative Vigor Index",
+  shortTitle: "RVGI",
+  overlay: false,
+  inputs: [lengthInput(10)],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 10);
+    const co = swma(sub(closes(bars), opens(bars)));
+    const hl = swma(sub(highs(bars), lows(bars)));
+    const line = zip(sum(co, len), sum(hl, len), (a, b) => b === 0 ? 0 : a / b);
+    return {
+      plots: [
+        { key: "rvgi", title: "RVGI", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: swma(line), color: WARNING }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var relVolatility = {
+  type: "relative-volatility-index",
+  title: "Relative Volatility Index",
+  shortTitle: "RVI",
+  overlay: false,
+  inputs: [lengthInput(10, "stdevLength", "StdDev length"), lengthInput(14, "smoothLength", "Smoothing length"), sourceInput(), colorInput()],
+  compute: (bars, inputs) => {
+    const smoothLen = num3(inputs, "smoothLength", 14);
+    const src = sourceValues(bars, str3(inputs, "source", "Close"));
+    const dev = stdev(src, num3(inputs, "stdevLength", 10));
+    const d = change(src);
+    const up = rma(zip(dev, d, (s, x) => x > 0 ? s : 0), smoothLen);
+    const dn = rma(zip(dev, d, (s, x) => x <= 0 ? s : 0), smoothLen);
+    const values = zip(up, dn, (u, w) => u + w === 0 ? 50 : 100 * u / (u + w));
+    return {
+      plots: [{ key: "rvi", title: "RVI", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: guideLevels(20, 80, 50)
+    };
+  }
+};
+var bop = {
+  type: "balance-of-power",
+  title: "Balance of Power",
+  shortTitle: "BOP",
+  overlay: false,
+  inputs: [colorInput()],
+  compute: (bars, inputs) => {
+    const values = bars.map((b) => b.high === b.low ? 0 : (b.close - b.open) / (b.high - b.low));
+    return {
+      plots: [{ key: "bop", title: "BOP", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var elderRay = {
+  type: "elder-ray",
+  title: "Elder Ray",
+  overlay: false,
+  inputs: [lengthInput(13)],
+  compute: (bars, inputs) => {
+    const basis = ema(closes(bars), num3(inputs, "length", 13));
+    return {
+      plots: [
+        { key: "bull", title: "Bull power", values: sub(highs(bars), basis), kind: "histogram", color: BULLISH, base: 0 },
+        { key: "bear", title: "Bear power", values: sub(lows(bars), basis), kind: "histogram", color: BEARISH, base: 0 }
+      ],
+      levels: ZERO_LEVEL
+    };
+  }
+};
+var ttmSqueeze = {
+  type: "ttm-squeeze",
+  title: "TTM Squeeze",
+  overlay: false,
+  inputs: [
+    lengthInput(20),
+    { key: "bbMult", title: "Bollinger multiplier", type: "float", defval: 2, min: 0.1, max: 50, step: 0.1 },
+    { key: "kcMult", title: "Keltner multiplier", type: "float", defval: 1.5, min: 0.1, max: 50, step: 0.1 }
+  ],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const c = closes(bars);
+    const basis = sma(c, len);
+    const dev = map(stdev(c, len), (x) => x * num3(inputs, "bbMult", 2));
+    const kcRange = map(rma(trueRange(bars), len), (x) => x * num3(inputs, "kcMult", 1.5));
+    const donchianMid = zip(highest(highs(bars), len), lowest(lows(bars), len), (h, l) => (h + l) / 2);
+    const anchor = zip(donchianMid, basis, (d, b) => (d + b) / 2);
+    const mom = linreg(sub(c, anchor), len);
+    const squeezed = c.map((_, i) => {
+      const d = dev[i];
+      const r = kcRange[i];
+      return Number.isFinite(d) && Number.isFinite(r) ? d < r : false;
+    });
+    const stateColors = squeezed.map((s, i) => Number.isFinite(mom[i]) ? s ? BEARISH : BULLISH : null);
+    return {
+      plots: [
+        { key: "mom", title: "Momentum", values: mom, kind: "histogram", color: BULLISH, colors: histColors(mom), base: 0 },
+        { key: "squeeze", title: "Squeeze", values: mom.map((x) => Number.isFinite(x) ? 0 : Number.NaN), kind: "cross", color: INFO, colors: stateColors }
+      ]
+    };
+  }
+};
+var oscillatorSpecs = [
+  rsiSpec,
+  stochastic,
+  stochasticRsi,
+  macd,
+  ppo,
+  awesome,
+  cci,
+  williamsR,
+  cmo,
+  connorsRsi,
+  fisher,
+  trix,
+  tsi,
+  smiErgodic,
+  stc,
+  kst,
+  coppock,
+  dpo,
+  rocSpec,
+  ultimate,
+  rvgi,
+  relVolatility,
+  bop,
+  elderRay,
+  ttmSqueeze
+];
+
+// src/core/native-indicators/classics/trend.ts
+var aroon = {
+  type: "aroon",
+  title: "Aroon",
+  overlay: false,
+  inputs: [lengthInput(14)],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const up = map(barsSinceHighest(highs(bars), len + 1), (x) => 100 * (len - x) / len);
+    const down = map(barsSinceLowest(lows(bars), len + 1), (x) => 100 * (len - x) / len);
+    return {
+      plots: [
+        { key: "up", title: "Aroon up", values: up, color: BULLISH, width: 2 },
+        { key: "down", title: "Aroon down", values: down, color: BEARISH, width: 2 }
+      ],
+      levels: [
+        { key: "upper", price: 100, color: NEUTRAL, lineStyle: "dotted" },
+        { key: "lower", price: 0, color: NEUTRAL, lineStyle: "dotted" }
+      ]
+    };
+  }
+};
+var adx = {
+  type: "average-directional-index",
+  title: "Average Directional Index",
+  shortTitle: "ADX",
+  overlay: false,
+  inputs: [lengthInput(14, "diLength", "DI length"), lengthInput(14, "adxLength", "ADX smoothing")],
+  compute: (bars, inputs) => {
+    const diLen = num3(inputs, "diLength", 14);
+    const adxLen = num3(inputs, "adxLength", 14);
+    const n = bars.length;
+    const plusDm = new Array(n).fill(Number.NaN);
+    const minusDm = new Array(n).fill(Number.NaN);
+    for (let i = 1; i < n; i++) {
+      const up = bars[i].high - bars[i - 1].high;
+      const dn = bars[i - 1].low - bars[i].low;
+      plusDm[i] = up > dn && up > 0 ? up : 0;
+      minusDm[i] = dn > up && dn > 0 ? dn : 0;
+    }
+    const atrLine = rma(trueRange(bars), diLen);
+    const plusDi = zip(rma(plusDm, diLen), atrLine, (d, a) => a === 0 ? 0 : 100 * d / a);
+    const minusDi = zip(rma(minusDm, diLen), atrLine, (d, a) => a === 0 ? 0 : 100 * d / a);
+    const dx = zip(plusDi, minusDi, (p, m) => p + m === 0 ? 0 : 100 * Math.abs(p - m) / (p + m));
+    return {
+      plots: [
+        { key: "adx", title: "ADX", values: rma(dx, adxLen), color: SERIES_LINE, width: 2 },
+        { key: "plusDi", title: "+DI", values: plusDi, color: BULLISH },
+        { key: "minusDi", title: "-DI", values: minusDi, color: BEARISH }
+      ],
+      levels: [{ key: "threshold", price: 25, color: NEUTRAL, lineStyle: "dotted" }]
+    };
+  }
+};
+var vortex = {
+  type: "vortex-indicator",
+  title: "Vortex Indicator",
+  shortTitle: "VI",
+  overlay: false,
+  inputs: [lengthInput(14)],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const n = bars.length;
+    const vmPlus = new Array(n).fill(Number.NaN);
+    const vmMinus = new Array(n).fill(Number.NaN);
+    for (let i = 1; i < n; i++) {
+      vmPlus[i] = Math.abs(bars[i].high - bars[i - 1].low);
+      vmMinus[i] = Math.abs(bars[i].low - bars[i - 1].high);
+    }
+    const trSum = sum(trueRange(bars), len);
+    return {
+      plots: [
+        { key: "viPlus", title: "VI+", values: zip(sum(vmPlus, len), trSum, (v, t) => t === 0 ? Number.NaN : v / t), color: BULLISH, width: 2 },
+        { key: "viMinus", title: "VI-", values: zip(sum(vmMinus, len), trSum, (v, t) => t === 0 ? Number.NaN : v / t), color: BEARISH, width: 2 }
+      ],
+      levels: [{ key: "one", price: 1, color: NEUTRAL, lineStyle: "dotted" }]
+    };
+  }
+};
+var trendSpecs = [aroon, adx, vortex];
+
+// src/core/native-indicators/classics/volatility.ts
+var atrSpec = {
+  type: "average-true-range",
+  title: "Average True Range",
+  shortTitle: "ATR",
+  overlay: false,
+  inputs: [lengthInput(14), colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [{ key: "atr", title: "ATR", values: atr(bars, num3(inputs, "length", 14)), color: str3(inputs, "color", SERIES_LINE), width: 2 }]
+  })
+};
+var historicalVolatility = {
+  type: "historical-volatility",
+  title: "Historical Volatility",
+  shortTitle: "HV",
+  overlay: false,
+  inputs: [
+    lengthInput(10),
+    { key: "annual", title: "Periods per year", type: "int", defval: 365, min: 1, max: 1e5, step: 1, tooltip: "Annualization factor (365 for daily crypto bars, 252 for stock sessions)" },
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const logReturns = map(change(map(closes(bars), Math.log)), (x) => x);
+    const values = map(stdev(logReturns, num3(inputs, "length", 10)), (x) => x * Math.sqrt(num3(inputs, "annual", 365)) * 100);
+    return { plots: [{ key: "hv", title: "HV", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var chaikinVolatility = {
+  type: "chaikin-volatility",
+  title: "Chaikin Volatility",
+  shortTitle: "CHV",
+  overlay: false,
+  inputs: [lengthInput(10, "emaLength", "EMA length"), lengthInput(10, "rocLength", "RoC length"), colorInput()],
+  compute: (bars, inputs) => {
+    const range = ema(sub(highs(bars), lows(bars)), num3(inputs, "emaLength", 10));
+    return {
+      plots: [{ key: "cv", title: "Chaikin Vol", values: roc(range, num3(inputs, "rocLength", 10)), color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var massIndex = {
+  type: "mass-index",
+  title: "Mass Index",
+  shortTitle: "MI",
+  overlay: false,
+  inputs: [lengthInput(25), colorInput()],
+  compute: (bars, inputs) => {
+    const range = sub(highs(bars), lows(bars));
+    const single = ema(range, 9);
+    const ratio = zip(single, ema(single, 9), (a, b) => b === 0 ? Number.NaN : a / b);
+    return {
+      plots: [{ key: "mi", title: "Mass Index", values: sum(ratio, num3(inputs, "length", 25)), color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "reversal", price: 27, color: NEUTRAL, lineStyle: "dotted" }]
+    };
+  }
+};
+var standardDeviation = {
+  type: "standard-deviation",
+  title: "Standard Deviation",
+  shortTitle: "StdDev",
+  overlay: false,
+  inputs: [lengthInput(20), sourceInput(), colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [
+      {
+        key: "stdev",
+        title: "StdDev",
+        values: stdev(sourceValues(bars, str3(inputs, "source", "Close")), num3(inputs, "length", 20)),
+        color: str3(inputs, "color", SERIES_LINE),
+        width: 2
+      }
+    ]
+  })
+};
+var ulcerIndex = {
+  type: "ulcer-index",
+  title: "Ulcer Index",
+  overlay: false,
+  inputs: [lengthInput(14), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const c = closes(bars);
+    const drawdown = zip(c, highest(c, len), (x, h) => h === 0 ? 0 : 100 * (x - h) / h);
+    const values = map(sma(map(drawdown, (d) => d * d), len), Math.sqrt);
+    return { plots: [{ key: "ui", title: "Ulcer", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var choppiness = {
+  type: "choppiness-index",
+  title: "Choppiness Index",
+  shortTitle: "CHOP",
+  overlay: false,
+  inputs: [lengthInput(14), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const trSum = sum(trueRange(bars), len);
+    const span = zip(highest(highs(bars), len), lowest(lows(bars), len), (h, l) => h - l);
+    const values = zip(trSum, span, (t, s) => s > 0 && t > 0 ? 100 * Math.log10(t / s) / Math.log10(len) : Number.NaN);
+    return {
+      plots: [{ key: "chop", title: "CHOP", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [
+        { key: "upper", price: 61.8, color: NEUTRAL },
+        { key: "lower", price: 38.2, color: NEUTRAL }
+      ]
+    };
+  }
+};
+var volatilitySpecs = [atrSpec, historicalVolatility, chaikinVolatility, massIndex, standardDeviation, ulcerIndex, choppiness];
+
+// src/core/native-indicators/classics/volume.ts
+function moneyFlowVolume(bars) {
+  return bars.map((b) => {
+    if (b.volume == null || !Number.isFinite(b.volume)) return Number.NaN;
+    if (b.high === b.low) return 0;
+    return (2 * b.close - b.high - b.low) / (b.high - b.low) * b.volume;
+  });
+}
+var obv = {
+  type: "on-balance-volume",
+  title: "On Balance Volume",
+  shortTitle: "OBV",
+  overlay: false,
+  inputs: [colorInput()],
+  compute: (bars, inputs) => {
+    const vol = volumes(bars);
+    const d = change(closes(bars));
+    const signed2 = zip(vol, d, (v, x) => x > 0 ? v : x < 0 ? -v : 0);
+    return { plots: [{ key: "obv", title: "OBV", values: cumSum(signed2), color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var accDist = {
+  type: "accumulation-distribution",
+  title: "Accumulation / Distribution",
+  shortTitle: "A/D",
+  overlay: false,
+  inputs: [colorInput()],
+  compute: (bars, inputs) => ({
+    plots: [{ key: "ad", title: "A/D", values: cumSum(moneyFlowVolume(bars)), color: str3(inputs, "color", SERIES_LINE), width: 2 }]
+  })
+};
+var cmf = {
+  type: "chaikin-money-flow",
+  title: "Chaikin Money Flow",
+  shortTitle: "CMF",
+  overlay: false,
+  inputs: [lengthInput(20), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 20);
+    const values = zip(sum(moneyFlowVolume(bars), len), sum(volumes(bars), len), (m, v) => v === 0 ? 0 : m / v);
+    return {
+      plots: [{ key: "cmf", title: "CMF", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var chaikinOscillator = {
+  type: "chaikin-oscillator",
+  title: "Chaikin Oscillator",
+  shortTitle: "Chaikin Osc",
+  overlay: false,
+  inputs: [lengthInput(3, "fastLength", "Fast length"), lengthInput(10, "slowLength", "Slow length"), colorInput()],
+  compute: (bars, inputs) => {
+    const ad = cumSum(moneyFlowVolume(bars));
+    const values = sub(ema(ad, num3(inputs, "fastLength", 3)), ema(ad, num3(inputs, "slowLength", 10)));
+    return {
+      plots: [{ key: "co", title: "Chaikin Osc", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var eom = {
+  type: "ease-of-movement",
+  title: "Ease of Movement",
+  shortTitle: "EOM",
+  overlay: false,
+  inputs: [lengthInput(14), { key: "divisor", title: "Divisor", type: "int", defval: 1e4, min: 1, max: 1e9, step: 1 }, colorInput()],
+  compute: (bars, inputs) => {
+    const div = num3(inputs, "divisor", 1e4);
+    const hl2 = sourceValues(bars, "HL2");
+    const move = change(hl2);
+    const raw = bars.map((b, i) => {
+      const m = move[i];
+      if (b.volume == null || !Number.isFinite(b.volume) || b.volume === 0 || !Number.isFinite(m)) return Number.NaN;
+      return div * m * (b.high - b.low) / b.volume;
+    });
+    return {
+      plots: [{ key: "eom", title: "EOM", values: sma(raw, num3(inputs, "length", 14)), color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var forceIndex = {
+  type: "force-index",
+  title: "Force Index",
+  shortTitle: "FI",
+  overlay: false,
+  inputs: [lengthInput(13), colorInput()],
+  compute: (bars, inputs) => {
+    const raw = zip(change(closes(bars)), volumes(bars), (d, v) => d * v);
+    return {
+      plots: [{ key: "force", title: "Force", values: ema(raw, num3(inputs, "length", 13)), color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var klinger = {
+  type: "klinger-oscillator",
+  title: "Klinger Oscillator",
+  shortTitle: "KVO",
+  overlay: false,
+  inputs: [lengthInput(34, "fastLength", "Fast length"), lengthInput(55, "slowLength", "Slow length"), lengthInput(13, "signalLength", "Signal length")],
+  compute: (bars, inputs) => {
+    const hlc3 = sourceValues(bars, "HLC3");
+    const trend = change(hlc3);
+    const signedVolume = zip(volumes(bars), trend, (v, t) => t >= 0 ? v : -v);
+    const line = sub(ema(signedVolume, num3(inputs, "fastLength", 34)), ema(signedVolume, num3(inputs, "slowLength", 55)));
+    return {
+      plots: [
+        { key: "kvo", title: "KVO", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: ema(line, num3(inputs, "signalLength", 13)), color: WARNING }
+      ],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var mfi = {
+  type: "money-flow-index",
+  title: "Money Flow Index",
+  shortTitle: "MFI",
+  overlay: false,
+  inputs: [lengthInput(14), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 14);
+    const tp = sourceValues(bars, "HLC3");
+    const rawFlow = zip(tp, volumes(bars), (p, v) => p * v);
+    const d = change(tp);
+    const pos = sum(zip(rawFlow, d, (f, x) => x > 0 ? f : 0), len);
+    const neg = sum(zip(rawFlow, d, (f, x) => x < 0 ? f : 0), len);
+    const values = zip(pos, neg, (p, n) => n === 0 ? 100 : 100 - 100 / (1 + p / n));
+    return {
+      plots: [{ key: "mfi", title: "MFI", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [
+        { key: "upper", price: 80, color: NEUTRAL },
+        { key: "lower", price: 20, color: NEUTRAL }
+      ]
+    };
+  }
+};
+function volumeIndex(bars, when) {
+  const out = new Array(bars.length).fill(Number.NaN);
+  let index = 1e3;
+  let started = false;
+  for (let i = 1; i < bars.length; i++) {
+    const v = bars[i].volume;
+    const pv = bars[i - 1].volume;
+    const pc = bars[i - 1].close;
+    if (v == null || pv == null || !Number.isFinite(v) || !Number.isFinite(pv) || pc === 0) {
+      if (started) out[i] = index;
+      continue;
+    }
+    started = true;
+    if (when(v, pv)) index += (bars[i].close - pc) / pc * index;
+    out[i] = index;
+  }
+  return out;
+}
+var nvi = {
+  type: "negative-volume-index",
+  title: "Negative Volume Index",
+  shortTitle: "Negative Volume Index",
+  overlay: false,
+  inputs: [lengthInput(255, "signalLength", "Signal length"), colorInput()],
+  compute: (bars, inputs) => {
+    const line = volumeIndex(bars, (v, pv) => v < pv);
+    return {
+      plots: [
+        { key: "nvi", title: "NVI", values: line, color: str3(inputs, "color", SERIES_LINE), width: 2 },
+        { key: "signal", title: "Signal", values: ema(line, num3(inputs, "signalLength", 255)), color: WARNING }
+      ]
+    };
+  }
+};
+var pvi = {
+  type: "positive-volume-index",
+  title: "Positive Volume Index",
+  shortTitle: "Positive Volume Index",
+  overlay: false,
+  inputs: [lengthInput(255, "signalLength", "Signal length"), colorInput()],
+  compute: (bars, inputs) => {
+    const line = volumeIndex(bars, (v, pv) => v > pv);
+    return {
+      plots: [
+        { key: "pvi", title: "PVI", values: line, color: str3(inputs, "color", SERIES_LINE), width: 2 },
+        { key: "signal", title: "Signal", values: ema(line, num3(inputs, "signalLength", 255)), color: WARNING }
+      ]
+    };
+  }
+};
+var pvt = {
+  type: "price-volume-trend",
+  title: "Price Volume Trend",
+  shortTitle: "PVT",
+  overlay: false,
+  inputs: [colorInput()],
+  compute: (bars, inputs) => {
+    const c = closes(bars);
+    const raw = bars.map((b, i) => {
+      if (i === 0 || b.volume == null || !Number.isFinite(b.volume)) return Number.NaN;
+      const pc = c[i - 1];
+      return pc === 0 ? 0 : (c[i] - pc) / pc * b.volume;
+    });
+    return { plots: [{ key: "pvt", title: "PVT", values: cumSum(raw), color: str3(inputs, "color", SERIES_LINE), width: 2 }] };
+  }
+};
+var volumeOscillator = {
+  type: "volume-oscillator",
+  title: "Volume Oscillator",
+  shortTitle: "Vol Osc",
+  overlay: false,
+  inputs: [lengthInput(5, "fastLength", "Fast length"), lengthInput(10, "slowLength", "Slow length"), colorInput()],
+  compute: (bars, inputs) => {
+    const vol = volumes(bars);
+    const fast = ema(vol, num3(inputs, "fastLength", 5));
+    const slow = ema(vol, num3(inputs, "slowLength", 10));
+    const values = zip(fast, slow, (f, s) => s === 0 ? Number.NaN : 100 * (f - s) / s);
+    return {
+      plots: [{ key: "vo", title: "Volume Osc", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var pvo = {
+  type: "pvo",
+  title: "Percentage Volume Oscillator",
+  shortTitle: "PVO",
+  overlay: false,
+  inputs: [lengthInput(12, "fastLength", "Fast length"), lengthInput(26, "slowLength", "Slow length"), lengthInput(9, "signalLength", "Signal length")],
+  compute: (bars, inputs) => {
+    const vol = volumes(bars);
+    const fast = ema(vol, num3(inputs, "fastLength", 12));
+    const slow = ema(vol, num3(inputs, "slowLength", 26));
+    const line = zip(fast, slow, (f, s) => s === 0 ? Number.NaN : 100 * (f - s) / s);
+    const signal = ema(line, num3(inputs, "signalLength", 9));
+    const hist = sub(line, signal);
+    return {
+      plots: [
+        { key: "hist", title: "Histogram", values: hist, kind: "histogram", color: BULLISH, colors: hist.map((x) => Number.isFinite(x) ? x >= 0 ? BULLISH : BEARISH : null), base: 0 },
+        { key: "pvo", title: "PVO", values: line, color: SERIES_LINE, width: 2 },
+        { key: "signal", title: "Signal", values: signal, color: WARNING }
+      ],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var vfi = {
+  type: "volume-flow-indicator",
+  title: "Volume Flow Indicator",
+  shortTitle: "Volume Flow Indicator",
+  overlay: false,
+  inputs: [
+    lengthInput(130),
+    { key: "coef", title: "Cutoff coefficient", type: "float", defval: 0.2, min: 0.01, max: 10, step: 0.01 },
+    { key: "volCoef", title: "Volume cap", type: "float", defval: 2.5, min: 0.1, max: 50, step: 0.1 },
+    lengthInput(3, "smoothLength", "Smoothing length")
+  ],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 130);
+    const coef = num3(inputs, "coef", 0.2);
+    const volCoef = num3(inputs, "volCoef", 2.5);
+    const typical = map(sourceValues(bars, "HLC3"), Math.log);
+    const inter = change(typical);
+    const vInter = stdev(inter, 30);
+    const vol = volumes(bars);
+    const vAve = sma(vol, len);
+    const mf = change(sourceValues(bars, "HLC3"));
+    const raw = bars.map((b, i) => {
+      const cutoff = Number.isFinite(vInter[i]) ? coef * vInter[i] * b.close : Number.NaN;
+      const v = vol[i];
+      const ave = i > 0 ? vAve[i - 1] : Number.NaN;
+      const m = mf[i];
+      if (!Number.isFinite(cutoff) || !Number.isFinite(v) || !Number.isFinite(ave) || !Number.isFinite(m)) return Number.NaN;
+      const capped = Math.min(v, ave * volCoef);
+      return m > cutoff ? capped : m < -cutoff ? -capped : 0;
+    });
+    const values = bars.map((_, i) => {
+      const ave = i > 0 ? vAve[i - 1] : Number.NaN;
+      return Number.isFinite(ave) && ave !== 0 ? ave : Number.NaN;
+    });
+    const flowSum = sum(raw, len);
+    const line = zip(flowSum, values, (f, a) => f / a);
+    return {
+      plots: [{ key: "vfi", title: "VFI", values: sma(line, num3(inputs, "smoothLength", 3)), color: SERIES_LINE, width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var intradayIntensity = {
+  type: "intraday-intensity",
+  title: "Intraday Intensity",
+  shortTitle: "Intraday Intensity",
+  overlay: false,
+  inputs: [lengthInput(21), colorInput()],
+  compute: (bars, inputs) => {
+    const len = num3(inputs, "length", 21);
+    const values = zip(sum(moneyFlowVolume(bars), len), sum(volumes(bars), len), (m, v) => v === 0 ? 0 : 100 * m / v);
+    return {
+      plots: [{ key: "ii", title: "II%", values, color: str3(inputs, "color", SERIES_LINE), width: 2 }],
+      levels: [{ key: "zero", price: 0, color: NEUTRAL }]
+    };
+  }
+};
+var volumeSpecs = [
+  obv,
+  accDist,
+  cmf,
+  chaikinOscillator,
+  eom,
+  forceIndex,
+  klinger,
+  mfi,
+  nvi,
+  pvi,
+  pvt,
+  volumeOscillator,
+  pvo,
+  vfi,
+  intradayIntensity
+];
+
+// src/core/native-indicators/classics/overlays.ts
+var DAY_MS2 = 864e5;
+function periodKey(anchor, time) {
+  if (anchor === "Week") return Math.floor((Math.floor(time / DAY_MS2) + 3) / 7);
+  if (anchor === "Month") {
+    const d = new Date(time);
+    return d.getUTCFullYear() * 12 + d.getUTCMonth();
+  }
+  return Math.floor(time / DAY_MS2);
+}
+var parabolicSar = {
+  type: "parabolic-sar",
+  title: "Parabolic SAR",
+  shortTitle: "SAR",
+  overlay: true,
+  inputs: [
+    { key: "start", title: "Start", type: "float", defval: 0.02, min: 1e-3, max: 1, step: 1e-3 },
+    { key: "increment", title: "Increment", type: "float", defval: 0.02, min: 1e-3, max: 1, step: 1e-3 },
+    { key: "maximum", title: "Max value", type: "float", defval: 0.2, min: 0.01, max: 1, step: 0.01 }
+  ],
+  compute: (bars, inputs) => {
+    const start = num3(inputs, "start", 0.02);
+    const inc = num3(inputs, "increment", 0.02);
+    const max = num3(inputs, "maximum", 0.2);
+    const n = bars.length;
+    const values = new Array(n).fill(Number.NaN);
+    const colors = new Array(n).fill(null);
+    if (n >= 2) {
+      let long = bars[1].close >= bars[0].close;
+      let sar = long ? bars[0].low : bars[0].high;
+      let ep = long ? bars[0].high : bars[0].low;
+      let af = start;
+      for (let i = 1; i < n; i++) {
+        const b = bars[i];
+        sar += af * (ep - sar);
+        if (long) sar = Math.min(sar, bars[i - 1].low, i >= 2 ? bars[i - 2].low : bars[i - 1].low);
+        else sar = Math.max(sar, bars[i - 1].high, i >= 2 ? bars[i - 2].high : bars[i - 1].high);
+        const reversed = long ? b.low < sar : b.high > sar;
+        if (reversed) {
+          long = !long;
+          sar = ep;
+          ep = long ? b.high : b.low;
+          af = start;
+        } else if (long && b.high > ep) {
+          ep = b.high;
+          af = Math.min(max, af + inc);
+        } else if (!long && b.low < ep) {
+          ep = b.low;
+          af = Math.min(max, af + inc);
+        }
+        values[i] = sar;
+        colors[i] = long ? BULLISH : BEARISH;
+      }
+    }
+    return { plots: [{ key: "sar", title: "PSAR", values, kind: "circles", color: SERIES_LINE, colors }] };
+  }
+};
+var vwap = {
+  type: "vwap",
+  title: "Volume Weighted Average Price",
+  shortTitle: "VWAP",
+  overlay: true,
+  inputs: [
+    { key: "anchor", title: "Anchor", type: "string", defval: "Day", options: ["Day", "Week", "Month"], tooltip: "Where the accumulation resets (UTC periods)" },
+    { key: "source", title: "Source", type: "string", defval: "HLC3", options: ["HLC3", "OHLC4", "Close"] },
+    colorInput(INFO)
+  ],
+  compute: (bars, inputs) => {
+    const anchor = str3(inputs, "anchor", "Day");
+    const source = str3(inputs, "source", "HLC3");
+    const values = new Array(bars.length).fill(Number.NaN);
+    let period = Number.NaN;
+    let cumPV = 0;
+    let cumV = 0;
+    for (let i = 0; i < bars.length; i++) {
+      const b = bars[i];
+      const key = periodKey(anchor, b.time);
+      if (key !== period) {
+        period = key;
+        cumPV = 0;
+        cumV = 0;
+      }
+      const v = b.volume;
+      if (v != null && Number.isFinite(v) && v > 0) {
+        const tp = source === "Close" ? b.close : source === "OHLC4" ? (b.open + b.high + b.low + b.close) / 4 : (b.high + b.low + b.close) / 3;
+        cumPV += tp * v;
+        cumV += v;
+      }
+      if (cumV > 0) values[i] = cumPV / cumV;
+    }
+    return { plots: [{ key: "vwap", title: "VWAP", values, color: str3(inputs, "color", INFO), width: 2 }] };
+  }
+};
+var pivotPoints = {
+  type: "pivot-points",
+  title: "Pivot Points",
+  shortTitle: "Pivots",
+  overlay: true,
+  inputs: [{ key: "anchor", title: "Period", type: "string", defval: "Day", options: ["Day", "Week", "Month"] }],
+  compute: (bars, inputs) => {
+    const anchor = str3(inputs, "anchor", "Day");
+    const aggs = /* @__PURE__ */ new Map();
+    for (const b of bars) {
+      const key = periodKey(anchor, b.time);
+      const a = aggs.get(key);
+      if (!a) aggs.set(key, { high: b.high, low: b.low, close: b.close });
+      else {
+        a.high = Math.max(a.high, b.high);
+        a.low = Math.min(a.low, b.low);
+        a.close = b.close;
+      }
+    }
+    const n = bars.length;
+    const mk = () => new Array(n).fill(Number.NaN);
+    const levels = { p: mk(), r1: mk(), s1: mk(), r2: mk(), s2: mk(), r3: mk(), s3: mk() };
+    for (let i = 0; i < n; i++) {
+      const prev2 = aggs.get(periodKey(anchor, bars[i].time) - 1);
+      if (!prev2) continue;
+      const p = (prev2.high + prev2.low + prev2.close) / 3;
+      levels.p[i] = p;
+      levels.r1[i] = 2 * p - prev2.low;
+      levels.s1[i] = 2 * p - prev2.high;
+      levels.r2[i] = p + (prev2.high - prev2.low);
+      levels.s2[i] = p - (prev2.high - prev2.low);
+      levels.r3[i] = prev2.high + 2 * (p - prev2.low);
+      levels.s3[i] = prev2.low - 2 * (prev2.high - p);
+    }
+    const plot = (key, title, color) => ({ key, title, kind: "step", values: levels[key], color });
+    return {
+      plots: [
+        plot("p", "P", WARNING),
+        plot("r1", "R1", BEARISH),
+        plot("s1", "S1", BULLISH),
+        plot("r2", "R2", BEARISH),
+        plot("s2", "S2", BULLISH),
+        plot("r3", "R3", BEARISH),
+        plot("s3", "S3", BULLISH)
+      ]
+    };
+  }
+};
+var fiftyTwoWeek = {
+  type: "52-week-high-low",
+  title: "52 Week High/Low",
+  shortTitle: "52W H/L",
+  overlay: true,
+  inputs: [{ key: "weeks", title: "Weeks", type: "int", defval: 52, min: 1, max: 520, step: 1 }],
+  compute: (bars, inputs) => {
+    const span = num3(inputs, "weeks", 52) * 7 * DAY_MS2;
+    const n = bars.length;
+    const hi = new Array(n).fill(Number.NaN);
+    const lo = new Array(n).fill(Number.NaN);
+    const maxIdx = [];
+    const minIdx = [];
+    let from = 0;
+    for (let i = 0; i < n; i++) {
+      const b = bars[i];
+      while (maxIdx.length > 0 && bars[maxIdx[maxIdx.length - 1]].high <= b.high) maxIdx.pop();
+      maxIdx.push(i);
+      while (minIdx.length > 0 && bars[minIdx[minIdx.length - 1]].low >= b.low) minIdx.pop();
+      minIdx.push(i);
+      while (bars[from].time < b.time - span) from += 1;
+      while (maxIdx[0] < from) maxIdx.shift();
+      while (minIdx[0] < from) minIdx.shift();
+      hi[i] = bars[maxIdx[0]].high;
+      lo[i] = bars[minIdx[0]].low;
+    }
+    return {
+      plots: [
+        { key: "high", title: "52W high", values: hi, kind: "step", color: BULLISH },
+        { key: "low", title: "52W low", values: lo, kind: "step", color: BEARISH }
+      ]
+    };
+  }
+};
+var zigzag = {
+  type: "zigzag",
+  title: "ZigZag",
+  overlay: true,
+  inputs: [
+    { key: "deviation", title: "Deviation %", type: "float", defval: 5, min: 0.01, max: 100, step: 0.1 },
+    { key: "depth", title: "Depth", type: "int", defval: 10, min: 1, max: 500, step: 1 },
+    colorInput()
+  ],
+  compute: (bars, inputs) => {
+    const dev = num3(inputs, "deviation", 5) / 100;
+    const depth = num3(inputs, "depth", 10);
+    const pivots = [];
+    if (bars.length > 1) {
+      let up = bars[1].close >= bars[0].close;
+      let ext = up ? { i: 0, price: bars[0].high } : { i: 0, price: bars[0].low };
+      for (let i = 1; i < bars.length; i++) {
+        const b = bars[i];
+        if (up) {
+          if (b.high >= ext.price) ext = { i, price: b.high };
+          else if (b.low <= ext.price * (1 - dev) && i - (pivots[pivots.length - 1]?.i ?? -depth) >= depth) {
+            pivots.push(ext);
+            up = false;
+            ext = { i, price: b.low };
+          }
+        } else if (b.low <= ext.price) {
+          ext = { i, price: b.low };
+        } else if (b.high >= ext.price * (1 + dev) && i - (pivots[pivots.length - 1]?.i ?? -depth) >= depth) {
+          pivots.push(ext);
+          up = true;
+          ext = { i, price: b.high };
+        }
+      }
+      pivots.push(ext);
+    }
+    return {
+      plots: [],
+      polylines: [
+        {
+          key: "zigzag",
+          points: pivots.map((p) => ({ xloc: "bar_time", x: bars[p.i].time, price: p.price })),
+          curved: false,
+          closed: false,
+          lineColor: str3(inputs, "color", SERIES_LINE),
+          lineWidth: 2,
+          lineStyle: "solid",
+          arrowLeft: false,
+          arrowRight: false
+        }
+      ]
+    };
+  }
+};
+var williamsFractal = {
+  type: "williams-fractal",
+  title: "Williams Fractal",
+  shortTitle: "Fractals",
+  overlay: true,
+  inputs: [{ key: "periods", title: "Periods", type: "int", defval: 2, min: 1, max: 50, step: 1 }],
+  compute: (bars, inputs) => {
+    const p = num3(inputs, "periods", 2);
+    const markers = [];
+    const isExtreme = (i, pick, better) => {
+      const v = pick(bars[i]);
+      for (let k = i - p; k <= i + p; k++) {
+        if (k === i) continue;
+        if (!better(v, pick(bars[k]))) return false;
+      }
+      return true;
+    };
+    for (let i = p; i < bars.length - p; i++) {
+      if (isExtreme(i, (b) => b.high, (a, b) => a >= b)) {
+        markers.push({ time: bars[i].time, position: "aboveBar", shape: "triangleup", color: BULLISH });
+      }
+      if (isExtreme(i, (b) => b.low, (a, b) => a <= b)) {
+        markers.push({ time: bars[i].time, position: "belowBar", shape: "triangledown", color: BEARISH });
+      }
+    }
+    return { plots: [], markers };
+  }
+};
+var overlaySpecs = [parabolicSar, vwap, pivotPoints, fiftyTwoWeek, zigzag, williamsFractal];
+
+// src/core/native-indicators/classics/index.ts
+var classicSpecs = [
+  ...averageSpecs,
+  ...bandSpecs,
+  ...oscillatorSpecs,
+  ...trendSpecs,
+  ...volatilitySpecs,
+  ...volumeSpecs,
+  ...overlaySpecs
+];
+function registerClassicIndicators() {
+  for (const spec of classicSpecs) registerNativeIndicator(classicDescriptor(spec));
+}
+
 // src/Vela.ts
 var Vela = class {
   constructor(container, options = {}, deps = {}) {
     registerBuiltinChartTypes();
     registerVolume();
     registerVpvr();
+    registerClassicIndicators();
     const element = resolveElement(container);
     const theme = resolveTheme(options.theme);
     let animZoom = true;
@@ -22095,25 +24413,28 @@ var Vela = class {
   }
   /**
    * Add a built-in NATIVE indicator (core-computed, no scripting engine) by registered `type` —
-   * e.g. `'vpvr'`. It becomes a first-class indicator (legend row, settings, hide, remove,
-   * events) and is single-instance per type (a second call returns the existing handle). Returns
-   * a fail-soft handle for an unregistered type. Native renderer only.
+   * e.g. `'vpvr'` or `'sma'`. It becomes a first-class indicator (legend row, settings, hide,
+   * remove, events). Layer-backed types (`'volume'`, `'vpvr'`) are single-instance — a second
+   * call returns the existing handle; the classic studies allow several instances, so each call
+   * adds one more. Returns a fail-soft handle for an unregistered type. Native renderer only.
    */
   addNativeIndicator(type, options) {
     return this.orchestrator.addNativeIndicator(type, options);
   }
   /**
    * The catalog of built-in native indicators with their live state on this chart — each entry's
-   * `type`, `title`, whether it `supported`s the current symbol, and whether it's already `present`
-   * (native indicators are single-instance per type, so a second `addNativeIndicator` is a no-op).
-   * Lets a host "add indicator" UI list them, gate unsupported ones, and avoid duplicates. Async
-   * because support may probe the provider (a type may need data the symbol lacks).
+   * `type`, `title`, whether it `supported`s the current symbol, whether it's already `present`,
+   * and whether it allows several instances (`multiInstance`; otherwise a second
+   * `addNativeIndicator` is a no-op). Lets a host "add indicator" UI list them, gate unsupported
+   * ones, and de-duplicate the single-instance ones. Async because support may probe the
+   * provider (a type may need data the symbol lacks).
    */
   availableNativeIndicators() {
     return this.orchestrator.availableNativeIndicators();
   }
   /**
-   * The native-indicator types PRESENT on the chart right now — the synchronous slice of
+   * The native-indicator types PRESENT on the chart right now, one entry per instance (a
+   * multi-instance type repeats) — the synchronous slice of
    * {@link availableNativeIndicators} (only support probing is async; presence never is).
    * Persistence snapshots read this: an unload-time flush must see an add/remove that
    * happened microseconds ago, which an async catalog mirror cannot guarantee.