@luxalgo/vela 0.6.15 → 0.6.16

package/dist/vela.global.js

@@ -111,7 +111,7 @@ var Vela = (function (exports) {
 
   // 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 = [];
@@ -120,6 +120,7 @@ var Vela = (function (exports) {
       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;
@@ -210,24 +211,24 @@ var Vela = (function (exports) {
   }
   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)
       }
     };
   }
@@ -6707,8 +6708,8 @@ var Vela = (function (exports) {
       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 = {}) {
@@ -8432,16 +8433,20 @@ var Vela = (function (exports) {
     /**
      * 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.`);
@@ -8453,16 +8458,18 @@ var Vela = (function (exports) {
       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());
@@ -8472,7 +8479,8 @@ var Vela = (function (exports) {
           title: d.title,
           supported: await this.isNativeSupported(d, symbol),
           present: present.has(d.type),
-          beta: d.beta
+          beta: d.beta,
+          ...d.multiInstance ? { multiInstance: true } : {}
         }))
       );
     }
@@ -9756,7 +9764,7 @@ var Vela = (function (exports) {
 
   // src/data/MultiProviderFeed.ts
   function intervalMs(timeframe) {
-    const map = {
+    const map2 = {
       "1m": 6e4,
       "3m": 18e4,
       "5m": 3e5,
@@ -9778,7 +9786,7 @@ var Vela = (function (exports) {
       W: 6048e5,
       M: 2592e6
     };
-    return map[timeframe] ?? 36e5;
+    return map2[timeframe] ?? 36e5;
   }
   var MultiProviderFeed = class {
     constructor(store = sharedBarStore) {
@@ -10165,8 +10173,8 @@ var Vela = (function (exports) {
     /** 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
@@ -10631,7 +10639,7 @@ var Vela = (function (exports) {
   }
 
   // node_modules/@zag-js/core/dist/merge-props.mjs
-  var clsx = (...args) => args.map((str3) => str3?.trim?.()).filter(Boolean).join(" ");
+  var clsx = (...args) => args.map((str4) => str4?.trim?.()).filter(Boolean).join(" ");
   var CSS_REGEX = /((?:--)?(?:\w+-?)+)\s*:\s*([^;]*)/g;
   var serialize = (style) => {
     const res = {};
@@ -10855,12 +10863,12 @@ var Vela = (function (exports) {
     return {
       and: (...guards) => {
         return function andGuard(params) {
-          return guards.every((str3) => params.guard(str3));
+          return guards.every((str4) => params.guard(str4));
         };
       },
       or: (...guards) => {
         return function orGuard(params) {
-          return guards.some((str3) => params.guard(str3));
+          return guards.some((str4) => params.guard(str4));
         };
       },
       not: (guard) => {
@@ -11421,9 +11429,9 @@ var Vela = (function (exports) {
     const { attributes, callback: fn } = options;
     const win = node.ownerDocument.defaultView || window;
     const obs = new win.MutationObserver((changes) => {
-      for (const change of changes) {
-        if (change.type === "attributes" && change.attributeName && attributes.includes(change.attributeName)) {
-          fn(change);
+      for (const change2 of changes) {
+        if (change2.type === "attributes" && change2.attributeName && attributes.includes(change2.attributeName)) {
+          fn(change2);
         }
       }
     });
@@ -11497,7 +11505,7 @@ var Vela = (function (exports) {
   }
 
   // node_modules/@zag-js/dom-query/dist/searchable.mjs
-  var sanitize = (str3) => str3.split("").map((char) => {
+  var sanitize = (str4) => str4.split("").map((char) => {
     const code = char.charCodeAt(0);
     if (code > 0 && code < 128) return char;
     if (code >= 128 && code <= 255) return `/x${code.toString(16)}`.replace("/", "\\");
@@ -12197,10 +12205,10 @@ var Vela = (function (exports) {
           fn?.(this.getParams());
         }
       });
-      __publicField(this, "guard", (str3) => {
-        if (isFunction(str3)) return str3(this.getParams());
-        const fn = this.machine.implementations?.guards?.[str3];
-        if (!fn) warn(`[zag-js] No implementation found for guard "${JSON.stringify(str3)}"`);
+      __publicField(this, "guard", (str4) => {
+        if (isFunction(str4)) return str4(this.getParams());
+        const fn = this.machine.implementations?.guards?.[str4];
+        if (!fn) warn(`[zag-js] No implementation found for guard "${JSON.stringify(str4)}"`);
         return fn?.(this.getParams());
       });
       __publicField(this, "effect", (keys) => {
@@ -16978,19 +16986,19 @@ var Vela = (function (exports) {
     }
     setItems(items) {
       this.items = items;
-      for (const sub of this.subs.values()) sub.destroy();
+      for (const sub2 of this.subs.values()) sub2.destroy();
       this.subs.clear();
       this.build();
       const api = this.api;
-      for (const sub of this.subs.values()) {
-        api.setChild(sub.handle.service);
-        sub.api.setParent(this.handle.service);
+      for (const sub2 of this.subs.values()) {
+        api.setChild(sub2.handle.service);
+        sub2.api.setParent(this.handle.service);
       }
       this.handle.flush();
       if (this.subs.size > 0) queueMicrotask(() => this.handle.flush());
     }
     destroy() {
-      for (const sub of this.subs.values()) sub.destroy();
+      for (const sub2 of this.subs.values()) sub2.destroy();
       this.subs.clear();
       this.handle.stop();
       this.positioner.remove();
@@ -17004,9 +17012,9 @@ var Vela = (function (exports) {
       for (const li of this.list.children) {
         const id = li.dataset.veiId;
         if (!id) continue;
-        const sub = this.subs.get(id);
-        if (sub) {
-          spreadProps(li, api.getTriggerItemProps(sub.api), this.mid);
+        const sub2 = this.subs.get(id);
+        if (sub2) {
+          spreadProps(li, api.getTriggerItemProps(sub2.api), this.mid);
           continue;
         }
         const item = this.byId(id);
@@ -17083,7 +17091,7 @@ var Vela = (function (exports) {
           const arrow3 = iconEl("chevron-right", doc);
           arrow3.classList.add("vela-menu-arrow");
           li.appendChild(arrow3);
-          const sub = new _Surface(doc, {
+          const sub2 = new _Surface(doc, {
             host: this.host,
             placement: "right-start",
             onSelect: this.onSelect,
@@ -17091,8 +17099,8 @@ var Vela = (function (exports) {
             checkmarks: this.checkmarks,
             id: `${this.mid}--${item.id}`
           });
-          sub.setItems(item.submenu ?? []);
-          this.subs.set(item.id, sub);
+          sub2.setItems(item.submenu ?? []);
+          this.subs.set(item.id, sub2);
         }
         this.list.appendChild(li);
       }
@@ -20047,8 +20055,21 @@ ${overlayScrollbarCss(".vela-dialog *")}
     };
     const recentRow = document.createElement("div");
     recentRow.style.cssText = "display:flex;align-items:center;gap:5px;flex-wrap:wrap;border-top:1px solid var(--vela-border);padding-top:9px;";
+    const recentSwatches = document.createElement("div");
+    recentSwatches.style.cssText = "display:contents;";
+    const add = document.createElement("label");
+    add.style.cssText = `width:17px;height:17px;border-radius:var(--vela-radius-sm);border:1px dashed var(--vela-border-strong);cursor:pointer;display:flex;align-items:center;justify-content:center;color:${theme.textColor};font:14px ${theme.fontFamily};position:relative;`;
+    add.textContent = "+";
+    const customInput = document.createElement("input");
+    customInput.type = "color";
+    customInput.value = curHex;
+    customInput.style.cssText = "position:absolute;inset:0;opacity:0;cursor:pointer;";
+    customInput.addEventListener("input", () => previewHex(customInput.value));
+    customInput.addEventListener("change", () => pickHex(customInput.value, true));
+    add.appendChild(customInput);
+    recentRow.append(recentSwatches, add);
     const renderRecents = () => {
-      recentRow.replaceChildren();
+      recentSwatches.replaceChildren();
       for (const c of recents) {
         const sw = document.createElement("button");
         sw.type = "button";
@@ -20057,18 +20078,8 @@ ${overlayScrollbarCss(".vela-dialog *")}
           e.stopPropagation();
           pickHex(c);
         });
-        recentRow.appendChild(sw);
+        recentSwatches.appendChild(sw);
       }
-      const add = document.createElement("label");
-      add.style.cssText = `width:17px;height:17px;border-radius:var(--vela-radius-sm);border:1px dashed var(--vela-border-strong);cursor:pointer;display:flex;align-items:center;justify-content:center;color:${theme.textColor};font:14px ${theme.fontFamily};position:relative;`;
-      add.textContent = "+";
-      const input = document.createElement("input");
-      input.type = "color";
-      input.value = curHex;
-      input.style.cssText = "position:absolute;inset:0;opacity:0;cursor:pointer;";
-      input.addEventListener("input", () => pickHex(input.value, true));
-      add.appendChild(input);
-      recentRow.appendChild(add);
     };
     const opLabel = document.createElement("div");
     opLabel.textContent = "Opacity";
@@ -20108,14 +20119,18 @@ ${overlayScrollbarCss(".vela-dialog *")}
     function emit() {
       onChange(combineColor(curHex, curAlpha));
     }
-    function pickHex(hex, custom = false) {
+    function previewHex(hex) {
       curHex = splitColor(hex).hex6;
-      addRecent(curHex);
       paintSelection();
       paintOpacity();
-      if (custom) renderRecents();
       emit();
     }
+    function pickHex(hex, custom = false) {
+      previewHex(hex);
+      addRecent(curHex);
+      customInput.value = curHex;
+      if (custom) renderRecents();
+    }
     renderRecents();
     paintSelection();
     paintOpacity();
@@ -22021,8 +22036,8 @@ ${overlayScrollbarCss(".vela-dialog.vela-ind-dialog *", 9)}
       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
@@ -22985,9 +23000,9 @@ ${overlayScrollbarCss(".vela-dialog.vela-ind-dialog *", 9)}
         if (inst.enableKey) defaults2[inst.enableKey] = false;
         addRows(inst.rows);
       }
-      for (const sub of section.subsections ?? []) {
-        if (sub.enableKey) defaults2[sub.enableKey] = false;
-        addRows(sub.rows);
+      for (const sub2 of section.subsections ?? []) {
+        if (sub2.enableKey) defaults2[sub2.enableKey] = false;
+        addRows(sub2.rows);
       }
       if (!section.instances) addRows(section.rows);
       bag[t.id] = defaults2;
@@ -24316,11 +24331,11 @@ void main() {
       }
     }
     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
@@ -24617,9 +24632,9 @@ void main() {
   function wheelPanRightOffset(rightOffset, deltaX, barSpacing) {
     return rightOffset + deltaX / barSpacing;
   }
-  function wheelPanDelta(deltaX, deltaY, shift3) {
+  function wheelPanDelta(deltaX, deltaY, shift4) {
     if (isHorizontalWheel(deltaX, deltaY)) return deltaX;
-    if (shift3) return deltaY;
+    if (shift4) return deltaY;
     return null;
   }
   function effectiveSnapMode(momentaryOverride, sticky) {
@@ -26241,11 +26256,11 @@ void main() {
       }
     }
     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
@@ -27961,9 +27976,9 @@ void main() {
       };
       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) {
@@ -28522,14 +28537,14 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       };
       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) => {
@@ -28546,16 +28561,16 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         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();
     }
@@ -30663,11 +30678,11 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     /** 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", shift3 = false) {
+    down(x, y, mode = "off", shift4 = false) {
       const proj = this.deps.projector();
       if (this.state.kind === "placing") {
         if (this.state.draft.placementMode() !== "click") return;
-        const pivot = shift3 ? this.placingPivot(this.state.draft) : null;
+        const pivot = shift4 ? 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();
@@ -30686,7 +30701,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       }
       const hit = this.hitAt(x, y);
       if (hit) {
-        if (shift3) {
+        if (shift4) {
           this.deps.emit({ kind: "select", ids: [hit.id], additive: true });
           return;
         }
@@ -30696,7 +30711,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     }
     /** 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", shift3 = false) {
+    move(x, y, mode = "off", shift4 = false) {
       if (this.state.kind === "idle") {
         const tool = this.deps.activeTool();
         const had = this.snapAt != null;
@@ -30710,7 +30725,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
           this.captureFreehand(x, y);
           return;
         }
-        const pivot = shift3 ? this.placingPivot(this.state.draft) : null;
+        const pivot = shift4 ? 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;
@@ -30723,7 +30738,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       if (this.state.handle >= 0) {
         const a = d.anchors[this.state.handle];
         if (a) {
-          const pivot = shift3 && ANGLE_SNAP_TYPES.has(d.type) && d.anchors.length === 2 ? d.anchors[1 - this.state.handle] : void 0;
+          const pivot = shift4 && 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");
         }
@@ -31421,21 +31436,21 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         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;
@@ -32181,8 +32196,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     }
     /** 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) {
@@ -33084,8 +33099,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       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). */
@@ -33203,7 +33218,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         this.render();
       }
     }
-    pointerDown(x, y, snap = "off", shift3 = false) {
+    pointerDown(x, y, snap = "off", shift4 = false) {
       if (this.eraserMode) {
         this.erasing = true;
         this.deleteAt(x, y);
@@ -33223,9 +33238,9 @@ ${overlayScrollbarCss(".vela-sd-pane")}
           return;
         }
       }
-      this.interaction.down(x, y, snap, shift3);
+      this.interaction.down(x, y, snap, shift4);
     }
-    pointerMove(x, y, snap = "off", shift3 = false) {
+    pointerMove(x, y, snap = "off", shift4 = false) {
       if (this.eraserMode) {
         if (this.erasing) this.deleteAt(x, y);
         return;
@@ -33236,7 +33251,7 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         this.render();
         return;
       }
-      this.interaction.move(x, y, snap, shift3);
+      this.interaction.move(x, y, snap, shift4);
       this.updateHover(x, y);
     }
     /** Track which drawing is hovered so its handles appear on hover (and only then). */
@@ -33913,14 +33928,14 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     }
     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;
@@ -34643,24 +34658,24 @@ ${overlayScrollbarCss(".vela-sd-pane")}
           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;
@@ -36077,8 +36092,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         drawingsDeleteAt: (x, y) => this.userDrawings?.deleteAt(x, y) ?? false,
         drawingsCancelPlacement: () => this.userDrawings?.cancelPlacement() ?? false,
         drawingsSnapMode: () => this.snapMode,
-        drawingsPointerDown: (x, y, snap, shift3) => this.userDrawings?.pointerDown(x, y, snap, shift3),
-        drawingsPointerMove: (x, y, snap, shift3) => this.userDrawings?.pointerMove(x, y, snap, shift3),
+        drawingsPointerDown: (x, y, snap, shift4) => this.userDrawings?.pointerDown(x, y, snap, shift4),
+        drawingsPointerMove: (x, y, snap, shift4) => this.userDrawings?.pointerMove(x, y, snap, shift4),
         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,
@@ -36395,18 +36410,18 @@ ${overlayScrollbarCss(".vela-sd-pane")}
       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 shift3 = 0;
+        let shift4 = 0;
         if (newHeadTime !== prevHeadTime) {
           const prepended = this.bars.findIndex((b) => b.time === prevHeadTime);
-          if (prepended > 0) shift3 = prepended;
+          if (prepended > 0) shift4 = prepended;
           else {
             const trimmed = prevBars.findIndex((b) => b.time === newHeadTime);
-            if (trimmed > 0) shift3 = -trimmed;
+            if (trimmed > 0) shift4 = -trimmed;
           }
         }
-        if (shift3 !== 0) {
-          this.zoomAnchorLogical += shift3;
-          if (this.hoverLogical != null) this.hoverLogical += shift3;
+        if (shift4 !== 0) {
+          this.zoomAnchorLogical += shift4;
+          if (this.hoverLogical != null) this.hoverLogical += shift4;
         }
       }
       const skipFit = opts?.preserveView === true && this.didInitialFit;
@@ -38012,15 +38027,15 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     /** 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) {
@@ -38416,12 +38431,2328 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     registerNativeIndicator(vpvrDescriptor);
   }
 
+  // src/core/model/identity.ts
+  function stableSeriesId(parts3) {
+    const normTitle = parts3.title.trim().toLowerCase().replace(/\s+/g, "-");
+    return `${parts3.instanceId}:${parts3.kind}:${normTitle}#${parts3.ordinal}`;
+  }
+
+  // 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 prev3 = Number.NaN;
+    for (let i = 0; i < v.length; i++) {
+      const x = v[i];
+      if (!Number.isFinite(x)) {
+        run = 0;
+        prev3 = Number.NaN;
+        continue;
+      }
+      run += 1;
+      if (Number.isFinite(prev3)) {
+        prev3 = alpha * x + (1 - alpha) * prev3;
+        out[i] = prev3;
+      } else if (run >= len) {
+        let s = 0;
+        for (let k = i - len + 1; k <= i; k++) s += v[k];
+        prev3 = s / len;
+        out[i] = prev3;
+      }
+    }
+    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 shift3(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", max2 = 5e3) {
+    return { key, title, type: "int", defval, min: 1, max: max2, 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 offset3 = Math.trunc(num3(inputs, "offset", 0));
+        if (offset3 !== 0) values = shift3(values, offset3);
+        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 offset3 = Math.trunc(num3(inputs, "offset", 0));
+      if (offset3 !== 0) values = shift3(values, offset3);
+      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 = shift3(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 prev3 = 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);
+        prev3 = Number.isFinite(prev3) ? alpha * k * x + (1 - alpha * k) * prev3 : x;
+        out[i] = prev3;
+      }
+      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 = shift3(rma(hl2, num3(inputs, "jawLength", 13)), num3(inputs, "jawOffset", 8));
+      const teeth = shift3(rma(hl2, num3(inputs, "teethLength", 8)), num3(inputs, "teethOffset", 5));
+      const lips = shift3(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 = shift3(rma(hl2, 13), 8);
+      const teeth = shift3(rma(hl2, 8), 5);
+      const lips = shift3(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 prev3 = i > 0 ? v[i - 1] : Number.NaN;
+        return Number.isFinite(prev3) && Math.abs(x) > Math.abs(prev3) ? 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 prev3 = i > 0 ? values[i - 1] : Number.NaN;
+      const rising = Number.isFinite(prev3) ? x >= prev3 : 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 prev3 = i > 0 ? ao[i - 1] : Number.NaN;
+        return Number.isFinite(prev3) && x < prev3 ? 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: shift3(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), shift3(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 signed3 = zip(vol, d, (v, x) => x > 0 ? v : x < 0 ? -v : 0);
+      return { plots: [{ key: "obv", title: "OBV", values: cumSum(signed3), 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 max2 = 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(max2, af + inc);
+          } else if (!long && b.low < ep) {
+            ep = b.low;
+            af = Math.min(max2, 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 prev3 = aggs.get(periodKey(anchor, bars[i].time) - 1);
+        if (!prev3) continue;
+        const p = (prev3.high + prev3.low + prev3.close) / 3;
+        levels.p[i] = p;
+        levels.r1[i] = 2 * p - prev3.low;
+        levels.s1[i] = 2 * p - prev3.high;
+        levels.r2[i] = p + (prev3.high - prev3.low);
+        levels.s2[i] = p - (prev3.high - prev3.low);
+        levels.r3[i] = prev3.high + 2 * (p - prev3.low);
+        levels.s3[i] = prev3.low - 2 * (prev3.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;
@@ -38496,25 +40827,28 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     }
     /**
      * 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.
@@ -38881,12 +41215,6 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     return Math.round(Math.min(Math.max(px, lo), hi));
   }
 
-  // src/core/model/identity.ts
-  function stableSeriesId(parts3) {
-    const normTitle = parts3.title.trim().toLowerCase().replace(/\s+/g, "-");
-    return `${parts3.instanceId}:${parts3.kind}:${normTitle}#${parts3.ordinal}`;
-  }
-
   // src/data/symbol-base.ts
   function baseOf(d) {
     const fromDesc = d.description?.split("/")[0]?.trim();
@@ -38988,9 +41316,9 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     for (const b of bars) byTime.set(b.time, b);
     return [...byTime.values()].sort((a, b) => a.time - b.time);
   }
-  function aggregate(sub, bucketMs) {
+  function aggregate(sub2, bucketMs) {
     const buckets = /* @__PURE__ */ new Map();
-    for (const b of sub) {
+    for (const b of sub2) {
       const key = Math.floor(b.time / bucketMs) * bucketMs;
       const cur = buckets.get(key);
       if (!cur) {
@@ -39042,8 +41370,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         }
         const ratio = targetMin / subMin;
         const subRange = { ...range, limit: range.limit != null ? range.limit * ratio + ratio : void 0 };
-        const sub = klinesToOHLCV(await this.fetchKlines(base, apiSymbol, MIN_TO_INTERVAL[subMin], subRange));
-        const agg = aggregate(sub, targetMin * 6e4);
+        const sub2 = klinesToOHLCV(await this.fetchKlines(base, apiSymbol, MIN_TO_INTERVAL[subMin], subRange));
+        const agg = aggregate(sub2, targetMin * 6e4);
         return range.limit != null && agg.length > range.limit ? agg.slice(-range.limit) : agg;
       } catch (e) {
         console.warn(`[vela] Binance: failed to fetch ${ticker} ${timeframe} \u2014 ${e instanceof Error ? e.message : String(e)}`);
@@ -39374,9 +41702,9 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     for (const b of bars) byTime.set(b.time, b);
     return [...byTime.values()].sort((a, b) => a.time - b.time);
   }
-  function aggregate2(sub, bucketMs) {
+  function aggregate2(sub2, bucketMs) {
     const buckets = /* @__PURE__ */ new Map();
-    for (const b of sub) {
+    for (const b of sub2) {
       const key = Math.floor(b.time / bucketMs) * bucketMs;
       const cur = buckets.get(key);
       if (!cur) {
@@ -39427,8 +41755,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         }
         const ratio = targetMin / subMin;
         const subRange = { ...range, limit: range.limit != null ? range.limit * ratio + ratio : void 0 };
-        const sub = (await this.fetchCandles(coin, MIN_TO_INTERVAL2[subMin], subMin * 6e4, subRange)).map(candleToOHLCV);
-        const agg = aggregate2(sub, targetMin * 6e4);
+        const sub2 = (await this.fetchCandles(coin, MIN_TO_INTERVAL2[subMin], subMin * 6e4, subRange)).map(candleToOHLCV);
+        const agg = aggregate2(sub2, targetMin * 6e4);
         return range.limit != null && agg.length > range.limit ? agg.slice(-range.limit) : agg;
       } catch (e) {
         console.warn(`[vela] Hyperliquid: failed to fetch ${ticker} ${timeframe} \u2014 ${e instanceof Error ? e.message : String(e)}`);
@@ -39780,15 +42108,15 @@ ${overlayScrollbarCss(".vela-sd-pane")}
     for (const b of bars) byTime.set(b.time, b);
     return [...byTime.values()].sort((a, b) => a.time - b.time);
   }
-  function aggregate3(sub, bucketMs) {
-    return aggregateBy(sub, (t) => Math.floor(t / bucketMs) * bucketMs);
+  function aggregate3(sub2, bucketMs) {
+    return aggregateBy(sub2, (t) => Math.floor(t / bucketMs) * bucketMs);
   }
-  function aggregateCalendar(sub, unit) {
-    return aggregateBy(sub, unit === "W" ? weekStartUTC : monthStartUTC);
+  function aggregateCalendar(sub2, unit) {
+    return aggregateBy(sub2, unit === "W" ? weekStartUTC : monthStartUTC);
   }
-  function aggregateBy(sub, keyMs) {
+  function aggregateBy(sub2, keyMs) {
     const buckets = /* @__PURE__ */ new Map();
-    for (const b of sub) {
+    for (const b of sub2) {
       const key = keyMs(b.time);
       const cur = buckets.get(key);
       if (!cur) {
@@ -39842,8 +42170,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         if (tf === "W" || tf === "M") {
           const span = tf === "W" ? 7 * MS_PER_DAY : 31 * MS_PER_DAY;
           const subRange2 = range.from != null ? range : { ...range, limit: range.limit != null ? Math.ceil(range.limit * span / MS_PER_DAY) + 31 : void 0 };
-          const sub2 = await this.fetchCandles(product, 86400, subRange2);
-          return clampLimit(aggregateCalendar(sub2, tf), range.limit);
+          const sub3 = await this.fetchCandles(product, 86400, subRange2);
+          return clampLimit(aggregateCalendar(sub3, tf), range.limit);
         }
         const targetMin = /^\d+$/.test(tf) ? parseInt(tf, 10) : null;
         const subMin = targetMin != null ? selectSubTf3(targetMin) : null;
@@ -39853,8 +42181,8 @@ ${overlayScrollbarCss(".vela-sd-pane")}
         }
         const ratio = targetMin / subMin;
         const subRange = { ...range, limit: range.limit != null ? range.limit * ratio + ratio : void 0 };
-        const sub = await this.fetchCandles(product, MIN_TO_GRAN[subMin], subRange);
-        return clampLimit(aggregate3(sub, targetMin * 6e4), range.limit);
+        const sub2 = await this.fetchCandles(product, MIN_TO_GRAN[subMin], subRange);
+        return clampLimit(aggregate3(sub2, targetMin * 6e4), range.limit);
       } catch (e) {
         console.warn(`[vela] Coinbase: failed to fetch ${ticker} ${timeframe} \u2014 ${e instanceof Error ? e.message : String(e)}`);
         return [];