@hoox-sh/pynets 0.6.0 → 0.8.0

package/dist/index.js

@@ -40534,6 +40534,10 @@ class TaEngine {
   marketConditionSites = new Map;
   orderFlowSites = new Map;
   liquiditySites = new Map;
+  emaCrossSites = new Map;
+  historySites = new Map;
+  momentumFilterSites = new Map;
+  volatilityRegimeSites = new Map;
   sma(site, source, period) {
     const n = pinePeriod(period);
     if (n === null)
@@ -42865,6 +42869,39 @@ class TaEngine {
     const v = buf[-i - 1];
     return v === undefined ? null : v;
   }
+  hist(site, value) {
+    let h = this.historySites.get(site);
+    if (h === undefined) {
+      h = [];
+      this.historySites.set(site, h);
+    }
+    h.unshift(finiteCell2(value));
+    if (h.length > 1000)
+      h.pop();
+    return h;
+  }
+  windowFor(site, value) {
+    if (Array.isArray(value)) {
+      return value.map((v) => typeof v === "number" ? finiteCell2(v) : null);
+    }
+    if (value != null && typeof value === "object" && typeof value.size === "function" && typeof value.get === "function") {
+      const arr = value;
+      const out = [];
+      const n = arr.size();
+      for (let i = 0;i < n; i++) {
+        const v = arr.get(i);
+        out.push(typeof v === "number" ? finiteCell2(v) : null);
+      }
+      return out;
+    }
+    return this.hist(site, typeof value === "number" ? value : null);
+  }
+  static oldest(h) {
+    return h.length === 0 ? null : h[h.length - 1];
+  }
+  static secondOldest(h) {
+    return h.length < 2 ? null : h[h.length - 2];
+  }
   voi(buy, sell) {
     const b = buy !== null && Number.isFinite(buy) ? buy : 0;
     const s = sell !== null && Number.isFinite(sell) ? sell : 0;
@@ -43508,9 +43545,42 @@ class TaEngine {
       move_required_percent: finiteOut2(move) ?? 0
     });
   }
-  marketStructurePivot(close) {
-    const c = finiteCell2(close) ?? 0;
-    return taRec({ pivot_price: c, structure: "fractal", type: "high" });
+  marketStructurePivot(site, high, low, period, mode) {
+    const hh = this.windowFor(`${site}:high`, high);
+    const ll = this.windowFor(`${site}:low`, low);
+    const n = this.coerceTaInt(period, "ta.market_structure_pivot() requires 5 arguments");
+    const m = this.coerceTaInt(mode, "ta.market_structure_pivot() requires 5 arguments");
+    const off = taRec({ pivot_price: 100, strength: 50, structure: "neutral" });
+    if (hh.length === 0 || ll.length === 0 || hh.length < n || n <= 0)
+      return off;
+    const hVals = hh.slice(-n).filter((v) => v !== null);
+    const lVals = ll.slice(-n).filter((v) => v !== null);
+    if (hVals.length === 0 || lVals.length === 0)
+      return off;
+    let pivotHigh = hVals[0];
+    let pivotLow = lVals[0];
+    for (const v of hVals)
+      if (v > pivotHigh)
+        pivotHigh = v;
+    for (const v of lVals)
+      if (v < pivotLow)
+        pivotLow = v;
+    const price = (pivotHigh + pivotLow) / 2;
+    const range = pivotHigh - pivotLow;
+    let structure = "block";
+    let strength = Math.min(100, range * 0.5);
+    if (m === 0) {
+      structure = "fractal";
+      strength = Math.min(100, range * 2);
+    } else if (m === 1) {
+      structure = "swing";
+      strength = Math.min(100, range * 1.5);
+    }
+    return taRec({
+      pivot_price: finiteOut2(price) ?? 0,
+      strength: finiteOut2(strength) ?? 0,
+      structure
+    });
   }
   positionSizingScore(risk, volatility, conviction, correlation) {
     const r = finiteCell2(risk) ?? 0;
@@ -43539,8 +43609,9 @@ class TaEngine {
       risk_reward_current: a > 0 ? finiteOut2(Math.abs(c - e) / a) ?? 0 : 0
     });
   }
-  optimalEntryZone(close) {
-    const c = finiteCell2(close) ?? 0;
+  optimalEntryZone(site, close) {
+    const h = this.windowFor(`${site}:close`, close);
+    const c = TaEngine.oldest(h) ?? 0;
     return taRec({
       min: finiteOut2(c * 0.99) ?? 0,
       max: finiteOut2(c * 1.01) ?? 0,
@@ -43551,10 +43622,13 @@ class TaEngine {
       zone_strength: 85
     });
   }
-  meanReversionEntry(price, sma, stdev, threshold) {
-    const p = finiteCell2(price) ?? 0;
-    const s = finiteCell2(sma) ?? 0;
-    const sd = finiteCell2(stdev) ?? 1;
+  meanReversionEntry(site, price, sma, stdev, threshold) {
+    const ph = this.windowFor(`${site}:price`, price);
+    const sh = this.windowFor(`${site}:sma`, sma);
+    const dh = this.windowFor(`${site}:stdev`, stdev);
+    const p = TaEngine.oldest(ph) ?? 0;
+    const s = TaEngine.oldest(sh) ?? 0;
+    const sd = TaEngine.oldest(dh) ?? 1;
     const th = finiteCell2(threshold) ?? 0;
     const z = sd !== 0 ? (p - s) / sd : 0;
     return taRec({
@@ -43652,6 +43726,613 @@ class TaEngine {
     }
     return taRec({ is_breakout: false, breakout_type: "none", breakout_strength: 0 });
   }
+  emaCrossSignal(site, fast, slow, threshold) {
+    const off = taRec({ signal: "neutral", strength: 0, trend_direction: 0 });
+    let st = this.emaCrossSites.get(site);
+    if (st === undefined) {
+      st = { prevFast: null, prevSlow: null, count: 0 };
+      this.emaCrossSites.set(site, st);
+    }
+    const f = finiteCell2(fast) ?? 0;
+    const s = finiteCell2(slow) ?? 0;
+    const th = finiteCell2(threshold) ?? 0;
+    st.count += 1;
+    const prevFast = st.prevFast;
+    const prevSlow = st.prevSlow;
+    if (st.count < 2 || prevFast === null || prevSlow === null) {
+      st.prevFast = f;
+      st.prevSlow = s;
+      return off;
+    }
+    const diff = f - s;
+    const prevDiff = prevFast - prevSlow;
+    const crossover = prevDiff <= 0 && diff > 0;
+    const crossunder = prevDiff >= 0 && diff < 0;
+    const strength = Math.abs(diff);
+    const trend = diff > 0 ? 1 : -1;
+    let signal = "neutral";
+    if (crossover && strength > th)
+      signal = "buy";
+    else if (crossunder && strength > th)
+      signal = "sell";
+    st.prevFast = f;
+    st.prevSlow = s;
+    return taRec({ signal, strength: finiteOut2(strength) ?? 0, trend_direction: trend });
+  }
+  momentumFilter(site, momentum, volume, period) {
+    const n = this.coerceTaInt(period, "ta.momentum_filter() requires 3 arguments");
+    if (n <= 0)
+      return 0;
+    let st = this.momentumFilterSites.get(`${site}:${n}`);
+    if (st === undefined) {
+      st = { momentum: [], volume: [] };
+      this.momentumFilterSites.set(`${site}:${n}`, st);
+    }
+    pushCap(st.momentum, finiteCell2(momentum), n);
+    pushCap(st.volume, finiteCell2(volume), n);
+    if (st.momentum.length < n || st.volume.length < n)
+      return 0;
+    let volSum = 0;
+    for (const v of st.volume)
+      if (v !== null)
+        volSum += v;
+    if (volSum === 0)
+      return 0;
+    let numerator = 0;
+    let paired = false;
+    for (let i = 0;i < n; i++) {
+      const m = st.momentum[i];
+      const v = st.volume[i];
+      if (m !== null && v !== null) {
+        numerator += m * v;
+        paired = true;
+      }
+    }
+    if (!paired)
+      return 0;
+    return finiteOut2(numerator / volSum) ?? 0;
+  }
+  volatilityRegime(site, atr, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    if (n < 1)
+      return "medium";
+    let w = this.volatilityRegimeSites.get(`${site}:${n}`);
+    if (w === undefined) {
+      w = [];
+      this.volatilityRegimeSites.set(`${site}:${n}`, w);
+    }
+    pushCap(w, finiteCell2(atr), n);
+    if (w.length < n)
+      return "medium";
+    const recent = [];
+    for (const v of w)
+      if (v !== null)
+        recent.push(v);
+    if (recent.length === 0)
+      return "medium";
+    const current = recent[recent.length - 1];
+    let sum = 0;
+    for (const v of recent)
+      sum += v;
+    const avg = sum / recent.length;
+    if (current < avg * 0.5)
+      return "low";
+    if (current > avg * 2)
+      return "extreme";
+    if (current > avg * 1.3)
+      return "high";
+    return "medium";
+  }
+  economicImpactScore(priceChange, volatility, volumeChange) {
+    const pc = finiteCell2(priceChange) ?? 0;
+    const vol = finiteCell2(volatility) ?? 0;
+    const vc = finiteCell2(volumeChange) ?? 0;
+    const pcScore = Math.min(100, Math.abs(pc) * 20);
+    const volScore = Math.min(100, vol * 30);
+    const vcScore = Math.min(100, vc * 25);
+    return Math.max(0, Math.min(100, (pcScore + volScore + vcScore) / 3));
+  }
+  contrarianSignal(sentiment, volatility, timeSinceExtreme) {
+    const sent = finiteCell2(sentiment) ?? 50;
+    const vol = finiteCell2(volatility) ?? 1;
+    const time = finiteCell2(timeSinceExtreme) ?? 10;
+    let signal = "neutral";
+    let strength = 0.5;
+    let confidence = 0.5;
+    if ((sent > 80 || sent < 20) && vol > 2 && time < 5) {
+      signal = "strong_contrarian";
+      strength = 0.9;
+      confidence = 0.8;
+    } else if (sent > 65 || sent < 35) {
+      signal = "mild_contrarian";
+      strength = 0.6;
+      confidence = 0.6;
+    } else if (sent > 45 && sent < 55) {
+      signal = "follow_crowd";
+      strength = 0.3;
+      confidence = 0.4;
+    }
+    return taRec({ signal, strength, confidence });
+  }
+  drawdownRecoveryLevel(peak, current, factor, period) {
+    const p = finiteCell2(peak) ?? 0;
+    const c = finiteCell2(current) ?? 0;
+    const f = finiteCell2(factor) ?? 0;
+    const n = this.coerceTaInt(period, "ta.drawdown_recovery_level() requires 4 arguments");
+    const drawdown = p > 0 ? (p - c) / p : 0;
+    const recovery = drawdown < 1 ? drawdown / (1 - drawdown) : 0;
+    return taRec({
+      recovery_level: p,
+      percent_needed: finiteOut2(recovery * 100) ?? 0,
+      estimated_time: finiteOut2(n * f) ?? 0,
+      confidence: 80,
+      drawdown_percent: finiteOut2(drawdown * 100) ?? 0,
+      recovery_timeframe: finiteOut2(n * f) ?? 0,
+      recovery_confidence: 0.8
+    });
+  }
+  pivotPointLevels(high, low, close, traditional) {
+    const h = finiteCell2(high) ?? 0;
+    const l = finiteCell2(low) ?? 0;
+    const c = finiteCell2(close) ?? 0;
+    const pivot = (h + l + c) / 3;
+    let r1;
+    let s1;
+    let r2;
+    let s2;
+    let r3;
+    let s3;
+    if (traditional) {
+      r1 = 2 * pivot - l;
+      s1 = 2 * pivot - h;
+      r2 = pivot + (h - l);
+      s2 = pivot - (h - l);
+      r3 = h + 2 * (pivot - l);
+      s3 = l - 2 * (h - pivot);
+    } else {
+      const diff = h - l;
+      r1 = pivot + 0.382 * diff;
+      s1 = pivot - 0.382 * diff;
+      r2 = pivot + 0.618 * diff;
+      s2 = pivot - 0.618 * diff;
+      r3 = pivot + diff;
+      s3 = pivot - diff;
+    }
+    return taRec({
+      pivot: finiteOut2(pivot) ?? 0,
+      r1: finiteOut2(r1) ?? 0,
+      s1: finiteOut2(s1) ?? 0,
+      r2: finiteOut2(r2) ?? 0,
+      s2: finiteOut2(s2) ?? 0,
+      r3: finiteOut2(r3) ?? 0,
+      s3: finiteOut2(s3) ?? 0
+    });
+  }
+  volatilityRegimeScore(site, atr, volatility, vix, threshold) {
+    const a = this.windowFor(`${site}:atr`, atr);
+    const v = this.windowFor(`${site}:vol`, volatility);
+    const x = this.windowFor(`${site}:vix`, vix);
+    const th = finiteCell2(threshold) ?? 50;
+    if (a.length === 0 || v.length === 0 || x.length === 0) {
+      return taRec({ regime: "normal", volatility_score: 50, momentum: "stable" });
+    }
+    const atrVal = TaEngine.oldest(a) ?? 2;
+    const volVal = TaEngine.oldest(v) ?? 0.02;
+    const vixVal = TaEngine.oldest(x) ?? 15;
+    const atrScore = Math.min(100, atrVal * 20);
+    const volScore = Math.min(100, volVal * 100);
+    const vixScore = Math.min(100, vixVal * 2);
+    const score = atrScore * 0.4 + volScore * 0.3 + vixScore * 0.3;
+    let regime;
+    if (score < th * 0.5)
+      regime = "low";
+    else if (score < th)
+      regime = "normal";
+    else if (score < th * 1.5)
+      regime = "high";
+    else
+      regime = "extreme";
+    let momentum = "stable";
+    const prevAtr = TaEngine.secondOldest(a);
+    if (a.length > 1 && prevAtr !== null) {
+      if (atrVal > prevAtr * 1.05)
+        momentum = "accelerating";
+      else if (atrVal < prevAtr * 0.95)
+        momentum = "decelerating";
+    }
+    return taRec({ regime, volatility_score: finiteOut2(score) ?? 0, momentum });
+  }
+  correlationFilter(site, s1, s2, s3, threshold) {
+    const h1 = this.windowFor(`${site}:s1`, s1);
+    const h2 = this.windowFor(`${site}:s2`, s2);
+    const h3 = this.windowFor(`${site}:s3`, s3);
+    const histories = [h1, h2, h3].filter((h) => h.length > 0);
+    const off = taRec({ is_correlated: false, signal_agreement: 0, divergence_count: 0 });
+    if (histories.length < 2)
+      return off;
+    const lastVals = [];
+    for (const h of histories) {
+      const v = TaEngine.oldest(h);
+      if (v !== null)
+        lastVals.push(v);
+    }
+    if (lastVals.length === 0)
+      return off;
+    let agreement = 0;
+    let divergence = 0;
+    for (let i = 0;i < lastVals.length - 1; i++) {
+      for (let j = i + 1;j < lastVals.length; j++) {
+        if (lastVals[i] * lastVals[j] > 0)
+          agreement += 1;
+        else
+          divergence += 1;
+      }
+    }
+    const pairs = lastVals.length * (lastVals.length - 1) / 2;
+    const pct = pairs > 0 ? agreement / pairs * 100 : 0;
+    const th = finiteCell2(threshold) ?? 0.7;
+    return taRec({
+      is_correlated: pct / 100 >= th,
+      signal_agreement: finiteOut2(pct) ?? 0,
+      divergence_count: divergence
+    });
+  }
+  advancedBreakoutDetector(site, price, volume, level, lookback, volumeMultiplier) {
+    const ph = this.windowFor(`${site}:price`, price);
+    const vh = this.windowFor(`${site}:vol`, volume);
+    const lvl = finiteCell2(level) ?? 100;
+    const n = this.coerceTaInt(lookback, "ta.advanced_breakout_detector() requires 5 arguments");
+    const mult = finiteCell2(volumeMultiplier) ?? 0.5;
+    const off = taRec({ breakout_detected: false, breakout_type: "none", pullback_probability: 0.5 });
+    if (ph.length === 0 || vh.length === 0 || ph.length < 2 || n <= 0)
+      return off;
+    const currentPrice = TaEngine.oldest(ph) ?? 100;
+    const prevPrice = TaEngine.secondOldest(ph) ?? 100;
+    const currentVol = TaEngine.oldest(vh) ?? 1000;
+    const recentVol = vh.slice(-n).filter((v) => v !== null);
+    const avgVol = recentVol.length > 0 ? recentVol.reduce((a, b) => a + b, 0) / recentVol.length : 1000;
+    const gap = currentPrice > lvl && prevPrice <= lvl;
+    const closeBreak = currentPrice > lvl && Math.abs(currentPrice - lvl) < 0.5;
+    const volumeBreak = currentVol > avgVol * (1 + mult);
+    const detected = gap || closeBreak || volumeBreak;
+    let type = "none";
+    if (gap)
+      type = "gap";
+    else if (closeBreak && volumeBreak)
+      type = "volume_break";
+    else if (closeBreak)
+      type = "close_above";
+    const pullback = avgVol !== 0 ? Math.max(0.1, 0.8 - (currentVol / avgVol - 1) * 0.3) : 0.8;
+    return taRec({
+      breakout_detected: detected,
+      breakout_type: type,
+      pullback_probability: finiteOut2(pullback) ?? 0.5
+    });
+  }
+  pullbackBounceLevel(site, high, low, trendDirection, lookback) {
+    const hh = this.windowFor(`${site}:high`, high);
+    const ll = this.windowFor(`${site}:low`, low);
+    const trend = this.coerceTaInt(trendDirection, "trend direction must be integer");
+    const n = this.coerceTaInt(lookback, "ta.pullback_bounce_level() requires 5 arguments");
+    const off = taRec({ primary_level: 100, bounce_probability: 0.5, support_strength: 50 });
+    if (hh.length === 0 || ll.length === 0 || n <= 0)
+      return off;
+    const hVals = hh.slice(-n).filter((v) => v !== null);
+    const lVals = ll.slice(-n).filter((v) => v !== null);
+    if (hVals.length === 0 || lVals.length === 0)
+      return off;
+    let swingHigh = hVals[0];
+    let swingLow = lVals[0];
+    for (const v of hVals)
+      if (v > swingHigh)
+        swingHigh = v;
+    for (const v of lVals)
+      if (v < swingLow)
+        swingLow = v;
+    const range = swingHigh - swingLow;
+    const fib = trend > 0 ? swingLow + range * 0.382 : swingHigh - range * 0.382;
+    const bounce = swingHigh !== 0 ? Math.min(0.95, 0.5 + range / swingHigh * 1) : 0.5;
+    const strength = swingHigh !== 0 ? Math.min(100, range / swingHigh * 100) : 0;
+    return taRec({
+      primary_level: finiteOut2(fib) ?? 0,
+      bounce_probability: finiteOut2(bounce) ?? 0.5,
+      support_strength: finiteOut2(strength) ?? 0
+    });
+  }
+  divergenceDetector(site, price, indicator, lookback) {
+    const ph = this.windowFor(`${site}:price`, price);
+    const ih = this.windowFor(`${site}:ind`, indicator);
+    const n = this.coerceTaInt(lookback, "lookback must be integer");
+    const off = taRec({ is_bullish: false, is_bearish: false, strength: 0 });
+    if (ph.length < n || ih.length < n)
+      return off;
+    const pv = ph.slice(-n).filter((v) => v !== null);
+    const iv = ih.slice(-n).filter((v) => v !== null);
+    if (pv.length < 2 || iv.length < 2)
+      return off;
+    const priceLower = pv[pv.length - 1] < pv[0];
+    const indHigher = iv[iv.length - 1] > iv[0];
+    const bullish = priceLower && indHigher;
+    const priceHigher = pv[pv.length - 1] > pv[0];
+    const indLower = iv[iv.length - 1] < iv[0];
+    const bearish = priceHigher && indLower;
+    const strength = Math.min(1, Math.abs(iv[iv.length - 1] - iv[0]) / 100);
+    return taRec({
+      is_bullish: bullish,
+      is_bearish: bearish,
+      strength: finiteOut2(strength) ?? 0
+    });
+  }
+  momentumDivergence(site, price, momentumFast, momentumSlow) {
+    const ph = this.windowFor(`${site}:price`, price);
+    const fh = this.windowFor(`${site}:fast`, momentumFast);
+    const sh = this.windowFor(`${site}:slow`, momentumSlow);
+    const off = taRec({ divergence_type: "none", strength: 0, bars_since: 0 });
+    if (ph.length < 2 || fh.length < 2 || sh.length < 2)
+      return off;
+    const pv = ph.slice(-2).filter((v) => v !== null);
+    const fv = fh.slice(-2).filter((v) => v !== null);
+    const sv = sh.slice(-2).filter((v) => v !== null);
+    if (pv.length < 2 || fv.length < 2 || sv.length < 2)
+      return off;
+    const priceLower = pv[1] < pv[0];
+    const fastHigher = fv[1] > fv[0];
+    const slowHigher = sv[1] > sv[0];
+    const bullish = priceLower && fastHigher && slowHigher;
+    const bearish = !priceLower && !fastHigher && !slowHigher;
+    const type = bullish ? "bullish" : bearish ? "bearish" : "none";
+    const strength = Math.min(1, Math.abs(fv[1] - fv[0]) / 100);
+    return taRec({ divergence_type: type, strength: finiteOut2(strength) ?? 0, bars_since: 1 });
+  }
+  spreadAnalysis(site, bid, ask, period) {
+    const bh = this.windowFor(`${site}:bid`, bid);
+    const ah = this.windowFor(`${site}:ask`, ask);
+    const n = this.coerceTaInt(period, "ta.spread_analysis() requires 3 arguments");
+    const off = taRec({ avg_spread: 0, spread_percent: 0, spread_trend: "stable" });
+    if (bh.length < n || ah.length < n || n <= 0)
+      return off;
+    const bSlice = bh.slice(-n);
+    const aSlice = ah.slice(-n);
+    const spreads = [];
+    for (let i = 0;i < n; i++) {
+      const b = bSlice[i] ?? 0;
+      const a = aSlice[i] ?? 0;
+      if (a > b && b > 0)
+        spreads.push(a - b);
+    }
+    if (spreads.length === 0)
+      return off;
+    const avg = spreads.reduce((a, b) => a + b, 0) / spreads.length;
+    const askOld = TaEngine.oldest(ah);
+    const bidOld = TaEngine.oldest(bh);
+    const mid = askOld !== null && bidOld !== null ? (askOld + bidOld) / 2 : 100;
+    const pct = mid > 0 ? avg / mid * 100 : 0;
+    let trend = "stable";
+    if (spreads.length >= 2) {
+      const first = spreads[0];
+      const last = spreads[spreads.length - 1];
+      if (last > first * 1.1)
+        trend = "increasing";
+      else if (last < first * 0.9)
+        trend = "decreasing";
+    }
+    return taRec({
+      avg_spread: finiteOut2(avg) ?? 0,
+      spread_percent: finiteOut2(pct) ?? 0,
+      spread_trend: trend
+    });
+  }
+  employmentCycleIndicator(site, cyclical, defensive, unemployment) {
+    const ch = this.windowFor(`${site}:cyc`, cyclical);
+    const dh = this.windowFor(`${site}:def`, defensive);
+    const uh = this.windowFor(`${site}:unemp`, unemployment);
+    if (ch.length === 0 || dh.length === 0 || uh.length === 0)
+      return "mid_cycle";
+    const cNew = ch[0];
+    const cOld = TaEngine.oldest(ch);
+    const dNew = dh[0];
+    const dOld = TaEngine.oldest(dh);
+    const cycPerf = cNew !== null && cOld !== null && cNew !== 0 ? (cOld - cNew) / cNew : 0;
+    const defPerf = dNew !== null && dOld !== null && dNew !== 0 ? (dOld - dNew) / dNew : 0;
+    const unemp = TaEngine.oldest(uh) ?? 0.05;
+    if (cycPerf > defPerf && unemp < 0.04)
+      return "early_cycle";
+    if (cycPerf > defPerf && unemp < 0.06)
+      return "mid_cycle";
+    if (cycPerf < defPerf && unemp > 0.05)
+      return "late_cycle";
+    return "recession";
+  }
+  gdpGrowthProxy(site, breadth, volume, momentum) {
+    const bh = this.windowFor(`${site}:breadth`, breadth);
+    const vh = this.windowFor(`${site}:volume`, volume);
+    const mh = this.windowFor(`${site}:momentum`, momentum);
+    if (bh.length === 0 || vh.length === 0 || mh.length === 0)
+      return 0;
+    const b = TaEngine.oldest(bh) ?? 0.5;
+    const bScore = b * 2 - 1;
+    const vNew = vh[0];
+    const vOld = TaEngine.oldest(vh);
+    const vChange = vNew !== null && vOld !== null && vNew !== 0 ? (vOld - vNew) / vNew * 100 : 0;
+    const m = TaEngine.oldest(mh) ?? 0;
+    const gdp = bScore * 1.5 + vChange / 100 + m / 100;
+    return Math.max(-2, Math.min(4, gdp));
+  }
+  inflationProxyIndicator(site, usdIndex, commodities, bondYields) {
+    const uh = this.windowFor(`${site}:usd`, usdIndex);
+    const ch = this.windowFor(`${site}:comm`, commodities);
+    const yh = this.windowFor(`${site}:yield`, bondYields);
+    if (uh.length === 0 || ch.length === 0 || yh.length === 0)
+      return 0;
+    const uNew = uh[0];
+    const uOld = TaEngine.oldest(uh);
+    const usdChange = uNew !== null && uOld !== null && uNew !== 0 ? -((uOld - uNew) / uNew) * 100 : 0;
+    const cNew = ch[0];
+    const cOld = TaEngine.oldest(ch);
+    const commChange = cNew !== null && cOld !== null && cNew !== 0 ? (cOld - cNew) / cNew * 100 : 0;
+    const yNew = yh[0];
+    const yOld = TaEngine.oldest(yh);
+    const yieldsChange = yNew !== null && yOld !== null ? yOld - yNew : 0;
+    const pressure = usdChange * 0.3 + commChange * 0.4 + yieldsChange * 0.3;
+    return Math.max(-100, Math.min(100, pressure * 10));
+  }
+  expectedValue(returns, probabilities) {
+    if (returns.length !== probabilities.length)
+      return 0;
+    let totalProb = 0;
+    for (const p of probabilities)
+      totalProb += p;
+    if (totalProb === 0)
+      return 0;
+    let ev = 0;
+    for (let i = 0;i < returns.length; i++)
+      ev += returns[i] * probabilities[i];
+    return finiteOut2(ev / totalProb) ?? 0;
+  }
+  gammaLevels(volatility, currentPrice, period) {
+    const v = finiteCell2(volatility) ?? 0.02;
+    const p = finiteCell2(currentPrice) ?? 100;
+    const n = this.coerceTaInt(period, "period must be integer");
+    const volAdjusted = v * Math.sqrt(n);
+    const distance = p * volAdjusted;
+    const out = new PineArray;
+    out.push(finiteOut2(p + distance));
+    out.push(finiteOut2(p - distance));
+    return out;
+  }
+  intelligentStrategySynthesizer(site, trend, momentum, volatility, volume, marketCondition, riskProfile) {
+    const th = this.windowFor(`${site}:trend`, trend);
+    const mh = this.windowFor(`${site}:momentum`, momentum);
+    const vh = this.windowFor(`${site}:volatility`, volatility);
+    const volh = this.windowFor(`${site}:volume`, volume);
+    const regime = typeof marketCondition === "string" ? marketCondition : "ranging";
+    const profile = typeof riskProfile === "string" ? riskProfile : "balanced";
+    const nums = (h) => h.filter((v) => v !== null);
+    const trendVals = nums(th);
+    const momentumVals = nums(mh);
+    const volatilityVals = nums(vh);
+    const volumeVals = nums(volh);
+    const avg = (vals, fallback) => vals.length === 0 ? fallback : vals.reduce((a, b) => a + b, 0) / vals.length;
+    const trendAvg = avg(trendVals, 0);
+    const momentumAvg = avg(momentumVals, 0);
+    const volatilityAvg = avg(volatilityVals, 0.5);
+    const volumeAvg = avg(volumeVals, 0);
+    const volatilityNormalized = Math.max(0, Math.min(1, volatilityAvg));
+    const composite = trendAvg * 0.4 + momentumAvg * 0.35 + volumeAvg * 0.25;
+    const compositeSignal = Math.max(-1, Math.min(1, composite));
+    let agreement = 0;
+    if (Math.abs(trendAvg) > 0.3)
+      agreement += 1;
+    if (Math.abs(momentumAvg) > 0.3)
+      agreement += 1;
+    if (Math.abs(volumeAvg) > 0.3)
+      agreement += 1;
+    const baseConfidence = agreement / 3;
+    const confidence = Math.max(0.1, Math.min(0.99, baseConfidence - volatilityNormalized * 0.3));
+    let recommendation;
+    if (compositeSignal > 0.6) {
+      recommendation = profile === "aggressive" ? "aggressive_long" : "conservative_long";
+    } else if (compositeSignal > 0.2) {
+      recommendation = "conservative_long";
+    } else if (compositeSignal < -0.6) {
+      recommendation = profile === "aggressive" ? "aggressive_short" : "conservative_short";
+    } else if (compositeSignal < -0.2) {
+      recommendation = "conservative_short";
+    } else {
+      recommendation = "hold";
+    }
+    const riskMult = profile === "conservative" ? 0.5 : profile === "aggressive" ? 1.5 : 1;
+    const riskLevel = volatilityNormalized * 50 * riskMult;
+    const absSignal = Math.abs(compositeSignal);
+    const expectedReturn = absSignal * 3;
+    let holdingPeriod;
+    if (volatilityNormalized > 0.7)
+      holdingPeriod = "scalp";
+    else if (volatilityNormalized > 0.5)
+      holdingPeriod = "day_trade";
+    else if (absSignal > 0.5)
+      holdingPeriod = "swing";
+    else
+      holdingPeriod = "position";
+    const shortRec = recommendation === "aggressive_short" || recommendation === "conservative_short";
+    const longRec = recommendation === "aggressive_long" || recommendation === "conservative_long";
+    const stopLoss = shortRec ? -0.7 : longRec ? -0.2 : -0.15;
+    const takeProfit = recommendation === "aggressive_long" || recommendation === "aggressive_short" ? 1.5 : longRec || shortRec ? 1 : 0.5;
+    let alignment = 50;
+    if (regime === "trending_up") {
+      if (compositeSignal > 0)
+        alignment = 90;
+      else if (compositeSignal > -0.3)
+        alignment = 60;
+      else
+        alignment = 30;
+    } else if (regime === "trending_down") {
+      if (compositeSignal < 0)
+        alignment = 90;
+      else if (compositeSignal < 0.3)
+        alignment = 60;
+      else
+        alignment = 30;
+    } else if (regime === "ranging") {
+      alignment = 50 + (1 - absSignal) * 30;
+    } else if (regime === "volatile") {
+      alignment = 30 + absSignal * 40;
+    } else {
+      alignment = 40;
+    }
+    return taRec({
+      composite_signal: finiteOut2(compositeSignal) ?? 0,
+      confidence_level: finiteOut2(confidence) ?? 0,
+      strategy_recommendation: recommendation,
+      risk_level: finiteOut2(Math.max(0, Math.min(100, riskLevel))) ?? 0,
+      expected_return: finiteOut2(expectedReturn) ?? 0,
+      holding_period: holdingPeriod,
+      stop_loss_priority: stopLoss,
+      take_profit_priority: takeProfit,
+      regime_alignment: finiteOut2(Math.max(0, Math.min(100, alignment))) ?? 0
+    });
+  }
+  signalConfluence(signals) {
+    let vals = [];
+    if (signals != null && typeof signals === "object") {
+      const obj = signals;
+      if (typeof obj.values === "function") {
+        const got = obj.values();
+        vals = Array.isArray(got) ? got : [];
+      } else if (!Array.isArray(signals)) {
+        vals = Object.entries(signals).filter(([k]) => k !== "__taRecord").map(([, v]) => v);
+      }
+    }
+    let signalCount = 0;
+    let bullish = 0;
+    let bearish = 0;
+    for (const v of vals) {
+      if (typeof v === "boolean") {
+        if (v) {
+          bullish += 1;
+          signalCount += 1;
+        }
+        continue;
+      }
+      if (typeof v === "number" && Number.isFinite(v)) {
+        if (v > 0) {
+          bullish += 1;
+          signalCount += 1;
+        } else if (v < 0) {
+          bearish += 1;
+          signalCount += 1;
+        }
+      }
+    }
+    const total = vals.length > 0 ? vals.length : 1;
+    const confluence = signalCount / total;
+    const primary = bullish > bearish ? "buy" : bearish > bullish ? "sell" : "neutral";
+    return taRec({
+      signal_count: signalCount,
+      confluence_level: finiteOut2(confluence) ?? 0,
+      primary_signal: primary
+    });
+  }
   volumeProfileHigh(prices, volumes) {
     if (prices.length === 0 || volumes.length === 0 || prices.length !== volumes.length)
       return 0;
@@ -44275,7 +44956,28 @@ var TA_METHODS = new Set([
   "market_timing_index",
   "regime_adaptive_signal",
   "strategy_score",
-  "breakout_detection"
+  "breakout_detection",
+  "ema_cross_signal",
+  "momentum_filter",
+  "volatility_regime",
+  "economic_impact_score",
+  "contrarian_signal",
+  "drawdown_recovery_level",
+  "pivot_point_levels",
+  "volatility_regime_score",
+  "correlation_filter",
+  "advanced_breakout_detector",
+  "pullback_bounce_level",
+  "divergence_detector",
+  "momentum_divergence",
+  "spread_analysis",
+  "employment_cycle_indicator",
+  "gdp_growth_proxy",
+  "inflation_proxy_indicator",
+  "expected_value",
+  "gamma_levels",
+  "intelligent_strategy_synthesizer",
+  "signal_confluence"
 ]);
 var TA_BARE_ATTRS = new Set([
   "accdist",
@@ -44463,6 +45165,13 @@ function emitCall2(ctx, node, visit) {
     ctx.needsHeikinashi = true;
     return `"__HEIKINASHI__"`;
   }
+  if (name === "ticker_inherit") {
+    const fallback = pick(args, 0, ["ticker", "tickerid", "from", "source"], `"SYMBOL"`);
+    return pick(args, 1, ["symbol", "ticker"], fallback);
+  }
+  if (name === "renko" || name === "kagi" || name === "linebreak" || name === "pointfigure") {
+    return pick(args, 0, ["ticker", "tickerid", "symbol"], `"SYMBOL"`);
+  }
   if (name.startsWith("ticker_")) {
     return pick(args, 0, ["symbol", "ticker", "tickerid"], `"SYMBOL"`);
   }
@@ -44637,6 +45346,9 @@ function hasSeriesArg(args) {
   const isSeries = (n) => n.kind === "Name" && BARE_SERIES_NAMES.has(n.id);
   return args.posNodes.some(isSeries) || Object.values(args.kwNodes).some(isSeries);
 }
+function isSeriesNode(n) {
+  return n != null && n.kind === "Name" && BARE_SERIES_NAMES.has(n.id);
+}
 function hasAnyKw(args, names) {
   return names.some((n) => Object.hasOwn(args.kw, n));
 }
@@ -44649,6 +45361,9 @@ function finiteOr2(expr, fb) {
 function cellOf(expr) {
   return `((__c) => (__c == null ? null : typeof __c === "boolean" ? (__c ? 1 : 0) : (typeof __c === "number" && Number.isFinite(__c) ? __c : null)))(${expr})`;
 }
+function arrOrCell(expr) {
+  return `((__v) => (__v != null && typeof __v === "object" ? __v : (__v == null ? null : typeof __v === "boolean" ? (__v ? 1 : 0) : (typeof __v === "number" && Number.isFinite(__v) ? __v : null))))(${expr})`;
+}
 function cellList(expr) {
   return `(() => { const __v = ${expr}; const __cell = (e) => (e == null ? null : typeof e === "boolean" ? (e ? 1 : 0) : (typeof e === "number" && Number.isFinite(e) ? e : null)); if (__v != null && typeof __v.size === "function" && typeof __v.get === "function") { const __n = __v.size(); const __o = []; for (let __i = 0; __i < __n; __i++) __o.push(__cell(__v.get(__i))); return __o; } return [__cell(__v)]; })()`;
 }
@@ -46317,8 +47032,11 @@ function emitTa(ctx, method, args) {
     ]);
   }
   if (method === "market_structure_pivot") {
-    return taPure("marketStructurePivot", [
-      cellOf(pick(args, 2, ["close"], "null"))
+    return taCall("marketStructurePivot", site, [
+      arrOrCell(pick(args, 0, ["high_list", "high"], "null")),
+      arrOrCell(pick(args, 1, ["low_list", "low"], "null")),
+      cellOf(pick(args, 3, ["period", "left", "left_bars"], "null")),
+      cellOf(pick(args, 4, ["mode", "right", "right_bars"], "null"))
     ]);
   }
   if (method === "position_sizing_score") {
@@ -46339,13 +47057,13 @@ function emitTa(ctx, method, args) {
     ]);
   }
   if (method === "optimal_entry_zone") {
-    return taPure("optimalEntryZone", [cellOf(pick(args, 2, ["close"], "null"))]);
+    return taCall("optimalEntryZone", site, [arrOrCell(pick(args, 2, ["close"], "null"))]);
   }
   if (method === "mean_reversion_entry") {
-    return taPure("meanReversionEntry", [
-      cellOf(pick(args, 0, ["price", "source"], "null")),
-      cellOf(pick(args, 1, ["sma"], "null")),
-      cellOf(pick(args, 2, ["stdev", "std_dev"], "null")),
+    return taCall("meanReversionEntry", site, [
+      arrOrCell(pick(args, 0, ["price", "source"], "null")),
+      arrOrCell(pick(args, 1, ["sma"], "null")),
+      arrOrCell(pick(args, 2, ["stdev", "std_dev"], "null")),
       cellOf(pick(args, 4, ["threshold"], "null"))
     ]);
   }
@@ -46383,12 +47101,159 @@ function emitTa(ctx, method, args) {
     ]);
   }
   if (method === "breakout_detection") {
+    const arg = (i, names) => isSeriesNode(args.posNodes[i]) ? "null" : cellOf(pick(args, i, names, "null"));
     return taPure("breakoutDetection", [
-      cellOf(pick(args, 0, ["close", "source"], "null")),
-      cellOf(pick(args, 1, ["resistance"], "null")),
-      cellOf(pick(args, 2, ["support"], "null"))
+      arg(0, ["close", "source"]),
+      arg(1, ["resistance"]),
+      arg(2, ["support"])
     ]);
   }
+  if (method === "ema_cross_signal") {
+    return taCall("emaCrossSignal", site, [
+      cellOf(pick(args, 0, ["fast_ema", "fast"], "null")),
+      cellOf(pick(args, 1, ["slow_ema", "slow"], "null")),
+      cellOf(pick(args, 2, ["threshold"], "null"))
+    ]);
+  }
+  if (method === "momentum_filter") {
+    return taCall("momentumFilter", site, [
+      cellOf(pick(args, 0, ["momentum_raw", "momentum"], "null")),
+      cellOf(pick(args, 1, ["volume"], "null")),
+      cellOf(pick(args, 2, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "volatility_regime") {
+    return taCall("volatilityRegime", site, [
+      cellOf(pick(args, 0, ["atr_series", "atr", "source"], "null")),
+      cellOf(pick(args, 1, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "economic_impact_score") {
+    return taPure("economicImpactScore", [
+      cellOf(pick(args, 0, ["price_change"], "null")),
+      cellOf(pick(args, 1, ["volatility"], "null")),
+      cellOf(pick(args, 2, ["volume_change"], "null"))
+    ]);
+  }
+  if (method === "contrarian_signal") {
+    return taPure("contrarianSignal", [
+      cellOf(pick(args, 0, ["sentiment"], "null")),
+      cellOf(pick(args, 1, ["volatility"], "null")),
+      cellOf(pick(args, 2, ["time_since_extreme", "time_extreme"], "null"))
+    ]);
+  }
+  if (method === "drawdown_recovery_level") {
+    return taPure("drawdownRecoveryLevel", [
+      cellOf(pick(args, 0, ["peak"], "null")),
+      cellOf(pick(args, 1, ["current", "current_price"], "null")),
+      cellOf(pick(args, 2, ["recovery_factor", "factor"], "null")),
+      cellOf(pick(args, 3, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "pivot_point_levels") {
+    return taPure("pivotPointLevels", [
+      cellOf(pick(args, 0, ["high"], "null")),
+      cellOf(pick(args, 1, ["low"], "null")),
+      cellOf(pick(args, 2, ["close"], "null")),
+      pick(args, 3, ["traditional"], "true")
+    ]);
+  }
+  if (method === "volatility_regime_score") {
+    return taCall("volatilityRegimeScore", site, [
+      arrOrCell(pick(args, 0, ["atr_list", "atr"], "null")),
+      arrOrCell(pick(args, 1, ["volatility_list", "volatility"], "null")),
+      arrOrCell(pick(args, 2, ["vix_list", "vix"], "null")),
+      cellOf(pick(args, 3, ["threshold"], "null"))
+    ]);
+  }
+  if (method === "correlation_filter") {
+    return taCall("correlationFilter", site, [
+      arrOrCell(pick(args, 0, ["signal1_list", "signal1", "s1"], "null")),
+      arrOrCell(pick(args, 1, ["signal2_list", "signal2", "s2"], "null")),
+      arrOrCell(pick(args, 2, ["signal3_list", "signal3", "s3"], "null")),
+      cellOf(pick(args, 4, ["threshold"], "null"))
+    ]);
+  }
+  if (method === "advanced_breakout_detector") {
+    return taCall("advancedBreakoutDetector", site, [
+      arrOrCell(pick(args, 0, ["price_list", "price"], "null")),
+      arrOrCell(pick(args, 1, ["volume_list", "volume"], "null")),
+      cellOf(pick(args, 2, ["level"], "null")),
+      cellOf(pick(args, 3, ["lookback"], "null")),
+      cellOf(pick(args, 4, ["volume_multiplier", "vol_mult"], "null"))
+    ]);
+  }
+  if (method === "pullback_bounce_level") {
+    return taCall("pullbackBounceLevel", site, [
+      arrOrCell(pick(args, 0, ["high_list", "high"], "null")),
+      arrOrCell(pick(args, 1, ["low_list", "low"], "null")),
+      cellOf(pick(args, 3, ["trend_direction", "trend_dir"], "null")),
+      cellOf(pick(args, 4, ["lookback"], "null"))
+    ]);
+  }
+  if (method === "divergence_detector") {
+    return taCall("divergenceDetector", site, [
+      arrOrCell(pick(args, 0, ["price_list", "price"], "null")),
+      arrOrCell(pick(args, 1, ["indicator_list", "indicator"], "null")),
+      cellOf(pick(args, 2, ["lookback"], "null"))
+    ]);
+  }
+  if (method === "momentum_divergence") {
+    return taCall("momentumDivergence", site, [
+      arrOrCell(pick(args, 0, ["price"], "null")),
+      arrOrCell(pick(args, 1, ["momentum_fast", "mom_fast"], "null")),
+      arrOrCell(pick(args, 2, ["momentum_slow", "mom_slow"], "null"))
+    ]);
+  }
+  if (method === "spread_analysis") {
+    return taCall("spreadAnalysis", site, [
+      arrOrCell(pick(args, 0, ["bid"], "null")),
+      arrOrCell(pick(args, 1, ["ask"], "null")),
+      cellOf(pick(args, 2, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "employment_cycle_indicator") {
+    return taCall("employmentCycleIndicator", site, [
+      arrOrCell(pick(args, 0, ["cyclical_stocks", "cyclical"], "null")),
+      arrOrCell(pick(args, 1, ["defensive_stocks", "defensive"], "null")),
+      arrOrCell(pick(args, 2, ["unemployment_proxy", "unemployment"], "null"))
+    ]);
+  }
+  if (method === "gdp_growth_proxy") {
+    return taCall("gdpGrowthProxy", site, [
+      arrOrCell(pick(args, 0, ["market_breadth", "breadth"], "null")),
+      arrOrCell(pick(args, 1, ["market_volume", "volume"], "null")),
+      arrOrCell(pick(args, 2, ["price_momentum", "momentum"], "null"))
+    ]);
+  }
+  if (method === "inflation_proxy_indicator") {
+    return taCall("inflationProxyIndicator", site, [
+      arrOrCell(pick(args, 0, ["usd_index", "usd"], "null")),
+      arrOrCell(pick(args, 1, ["commodity_prices", "commodities"], "null")),
+      arrOrCell(pick(args, 2, ["bond_yields", "yields"], "null"))
+    ]);
+  }
+  if (method === "expected_value") {
+    return `__h.ta.expectedValue(${cellList(pick(args, 0, ["returns"], "null"))}, ${cellList(pick(args, 1, ["probabilities", "probs"], "null"))})`;
+  }
+  if (method === "gamma_levels") {
+    const vol = isSeriesNode(args.posNodes[0]) ? "null" : cellOf(pick(args, 0, ["volatility"], "null"));
+    const price = isSeriesNode(args.posNodes[1]) ? "null" : cellOf(pick(args, 1, ["current_price", "price"], "null"));
+    return taPure("gammaLevels", [vol, price, cellOf(pick(args, 2, ["period", "length"], "null"))]);
+  }
+  if (method === "intelligent_strategy_synthesizer") {
+    return taCall("intelligentStrategySynthesizer", site, [
+      arrOrCell(pick(args, 0, ["trend_indicators", "trend"], "null")),
+      arrOrCell(pick(args, 1, ["momentum_indicators", "momentum"], "null")),
+      arrOrCell(pick(args, 2, ["volatility_indicators", "volatility"], "null")),
+      arrOrCell(pick(args, 3, ["volume_indicators", "volume"], "null")),
+      pick(args, 4, ["market_condition", "market_regime"], '"ranging"'),
+      pick(args, 5, ["risk_profile"], '"balanced"')
+    ]);
+  }
+  if (method === "signal_confluence") {
+    return taPure("signalConfluence", [pick(args, 0, ["signals"], "null")]);
+  }
   return "null";
 }
 
@@ -51723,6 +52588,33 @@ function evalCall(node, env) {
       adjust: evalAsString(callArg(node.args, 3, ["adjust", "adjustment"]), env) ?? undefined
     });
   }
+  if (fname === "ticker.inherit") {
+    const first = evalExpr(callArg(node.args, 0, ["ticker", "tickerid", "from", "source"]), env);
+    const secondArg = callArg(node.args, 1, ["symbol", "ticker"]);
+    if (secondArg != null) {
+      const target = evalExpr(secondArg, env);
+      const sym = target instanceof TickerId ? target.symbol : typeof target === "string" ? target : env.symbol;
+      if (first instanceof TickerId)
+        return tickerNew(sym, first.session, first.adjust);
+      return tickerNew(sym);
+    }
+    if (first instanceof TickerId) {
+      return tickerNew(first.symbol, first.session, first.adjust);
+    }
+    const sym = typeof first === "string" ? first : env.symbol;
+    return tickerNew(sym);
+  }
+  if (fname === "renko" || fname === "kagi" || fname === "linebreak" || fname === "pointfigure") {
+    const raw = evalExpr(callArg(node.args, 0, ["ticker", "tickerid", "symbol"]), env);
+    const sym = raw instanceof TickerId ? raw.symbol : typeof raw === "string" ? raw : env.symbol;
+    if (fname === "renko")
+      return tickerRenko(sym);
+    if (fname === "kagi")
+      return tickerKagi(sym);
+    if (fname === "linebreak")
+      return tickerLinebreak(sym);
+    return tickerPointfigure(sym);
+  }
   const mapVal = evalMapCall(fname, node, env);
   if (mapVal !== undefined)
     return mapVal;
@@ -53043,12 +53935,12 @@ function evalExtraTa(fname, node, env, site) {
       return NA;
     return ta.percentrank.call(env.ta, site, srcArg(node, env), lenArg(node, env, 1));
   }
-  if (fname === "ta.percentile_nearest_rank") {
+  if (fname === "ta.percentile_nearest_rank" || fname === "percentile_nearest_rank") {
     if (typeof ta.percentileNearest !== "function")
       return NA;
     return ta.percentileNearest.call(env.ta, site, srcArg(node, env), lenArg(node, env, 1), lenOrDefault(node, env, 2, ["percentage", "percent"], 50));
   }
-  if (fname === "ta.percentile_linear_interpolation") {
+  if (fname === "ta.percentile_linear_interpolation" || fname === "percentile_linear_interpolation") {
     if (typeof ta.percentileLinear !== "function")
       return NA;
     return ta.percentileLinear.call(env.ta, site, srcArg(node, env), lenArg(node, env, 1), lenOrDefault(node, env, 2, ["percentage", "percent"], 50));
@@ -53163,12 +54055,6 @@ function evalExtraTa(fname, node, env, site) {
     const r = env.ta.aroon(site, num2(env.ctx.high), num2(env.ctx.low), length ?? 14);
     return tupleOf([r.down, r.up]);
   }
-  if (fname === "ta.pivot_point_levels") {
-    if (typeof ta.pivotPoints !== "function")
-      return NA;
-    const r = ta.pivotPoints.call(env.ta, site, num2(env.ctx.high), num2(env.ctx.low), num2(env.ctx.close));
-    return tupleOf([r.pp, r.r1, r.s1, r.r2, r.s2]);
-  }
   if (fname === "ta.uo" || fname === "uo") {
     return env.ta.uo(site, num2(env.ctx.high), num2(env.ctx.low), num2(env.ctx.close), lenArg(node, env, 0), lenArg(node, env, 1), lenArg(node, env, 2));
   }
@@ -53304,6 +54190,7 @@ function evalExtraTa(fname, node, env, site) {
   }
   const wave11 = (index, names, message) => unwrap2(evalExpr(wave10aArg(index, names, message), env));
   const wave11n = (index, names, message) => num2(wave11(index, names, message));
+  const wave13v = (index, names, message) => evalExpr(wave10aArg(index, names, message), env);
   if (fname === "ta.sma_weighted" || fname === "sma_weighted") {
     const msg = "ta.sma_weighted() requires at least 2 arguments: series, period";
     const weightArg = callArg(node.args, 2, ["weight_type", "weight"]);
@@ -53433,12 +54320,12 @@ function evalExtraTa(fname, node, env, site) {
   }
   if (fname === "ta.market_structure_pivot" || fname === "market_structure_pivot") {
     const msg = "ta.market_structure_pivot() requires 5 arguments";
-    wave11n(0, ["high"], msg);
-    wave11n(1, ["low"], msg);
-    const close = wave11n(2, ["close"], msg);
-    wave11n(3, ["left", "left_bars"], msg);
-    wave11n(4, ["right", "right_bars"], msg);
-    return env.ta.marketStructurePivot(close);
+    const high = wave13v(0, ["high_list", "high"], msg);
+    const low = wave13v(1, ["low_list", "low"], msg);
+    wave13v(2, ["close_list", "close"], msg);
+    const period = wave11n(3, ["period", "left", "left_bars"], msg);
+    const mode = wave11n(4, ["mode", "right", "right_bars"], msg);
+    return env.ta.marketStructurePivot(site, high, low, period, mode);
   }
   if (fname === "ta.position_sizing_score" || fname === "position_sizing_score") {
     const msg = "ta.position_sizing_score() requires 4 arguments";
@@ -53452,13 +54339,13 @@ function evalExtraTa(fname, node, env, site) {
     const msg = "ta.optimal_entry_zone() requires 4 arguments";
     wave11n(0, ["high"], msg);
     wave11n(1, ["low"], msg);
-    const close = wave11n(2, ["close"], msg);
+    const close = wave13v(2, ["close"], msg);
     wave11n(3, ["period", "length"], msg);
-    return env.ta.optimalEntryZone(close);
+    return env.ta.optimalEntryZone(site, close);
   }
   if (fname === "ta.mean_reversion_entry" || fname === "mean_reversion_entry") {
     const msg = "ta.mean_reversion_entry() requires 5 arguments";
-    return env.ta.meanReversionEntry(wave11n(0, ["price", "source"], msg), wave11n(1, ["sma"], msg), wave11n(2, ["stdev", "std_dev"], msg), wave11n(4, ["threshold"], msg));
+    return env.ta.meanReversionEntry(site, wave13v(0, ["price", "source"], msg), wave13v(1, ["sma"], msg), wave13v(2, ["stdev", "std_dev"], msg), wave11n(4, ["threshold"], msg));
   }
   if (fname === "ta.multi_timeframe_signal" || fname === "multi_timeframe_signal") {
     const msg = "ta.multi_timeframe_signal() requires 6 arguments";
@@ -53482,7 +54369,119 @@ function evalExtraTa(fname, node, env, site) {
   }
   if (fname === "ta.breakout_detection" || fname === "breakout_detection") {
     const msg = "ta.breakout_detection() requires 3 arguments";
-    return env.ta.breakoutDetection(wave11n(0, ["close", "source"], msg), wave11n(1, ["resistance"], msg), wave11n(2, ["support"], msg));
+    const arg = (i, names) => {
+      const e = wave10aArg(i, names, msg);
+      return isSeriesExpr(e, env) ? NA : num2(evalExpr(e, env));
+    };
+    return env.ta.breakoutDetection(arg(0, ["close", "source"]), arg(1, ["resistance"]), arg(2, ["support"]));
+  }
+  if (fname === "ta.ema_cross_signal" || fname === "ema_cross_signal") {
+    const msg = "ta.ema_cross_signal() requires 3 arguments";
+    return env.ta.emaCrossSignal(site, wave11n(0, ["fast_ema", "fast"], msg), wave11n(1, ["slow_ema", "slow"], msg), wave11n(2, ["threshold"], msg));
+  }
+  if (fname === "ta.momentum_filter" || fname === "momentum_filter") {
+    const msg = "ta.momentum_filter() requires 3 arguments";
+    return env.ta.momentumFilter(site, wave11n(0, ["momentum_raw", "momentum"], msg), wave11n(1, ["volume"], msg), wave11n(2, ["period", "length"], msg));
+  }
+  if (fname === "ta.volatility_regime" || fname === "volatility_regime") {
+    const msg = "ta.volatility_regime() requires 2 arguments";
+    return env.ta.volatilityRegime(site, wave11n(0, ["atr_series", "atr", "source"], msg), wave11n(1, ["period", "length"], msg));
+  }
+  if (fname === "ta.economic_impact_score" || fname === "economic_impact_score") {
+    const msg = "ta.economic_impact_score() requires 3 arguments";
+    return env.ta.economicImpactScore(wave11n(0, ["price_change"], msg), wave11n(1, ["volatility"], msg), wave11n(2, ["volume_change"], msg));
+  }
+  if (fname === "ta.contrarian_signal" || fname === "contrarian_signal") {
+    const msg = "ta.contrarian_signal() requires 3 arguments";
+    return env.ta.contrarianSignal(wave11n(0, ["sentiment"], msg), wave11n(1, ["volatility"], msg), wave11n(2, ["time_since_extreme", "time_extreme"], msg));
+  }
+  if (fname === "ta.drawdown_recovery_level" || fname === "drawdown_recovery_level") {
+    const msg = "ta.drawdown_recovery_level() requires 4 arguments";
+    return env.ta.drawdownRecoveryLevel(wave11n(0, ["peak"], msg), wave11n(1, ["current", "current_price"], msg), wave11n(2, ["recovery_factor", "factor"], msg), wave11n(3, ["period", "length"], msg));
+  }
+  if (fname === "ta.pivot_point_levels" || fname === "pivot_point_levels") {
+    const msg = "ta.pivot_point_levels() requires type+anchor or high, low, close";
+    const first = wave11(0, ["type", "high"], msg);
+    if (typeof first === "string") {
+      if (typeof env.ta.pivotPoints !== "function")
+        return NA;
+      const r = env.ta.pivotPoints.call(env.ta, site, num2(env.ctx.high), num2(env.ctx.low), num2(env.ctx.close));
+      return tupleOf([r.pp, r.r1, r.s1, r.r2, r.s2]);
+    }
+    const tradArg = callArg(node.args, 3, ["traditional"]);
+    const traditional = tradArg == null ? true : unwrap2(evalExpr(tradArg, env)) !== 0;
+    return env.ta.pivotPointLevels(num2(first), wave11n(1, ["low"], msg), wave11n(2, ["close"], msg), traditional);
+  }
+  if (fname === "ta.volatility_regime_score" || fname === "volatility_regime_score") {
+    const msg = "ta.volatility_regime_score() requires 4 arguments";
+    return env.ta.volatilityRegimeScore(site, wave13v(0, ["atr_list", "atr"], msg), wave13v(1, ["volatility_list", "volatility"], msg), wave13v(2, ["vix_list", "vix"], msg), wave11n(3, ["threshold"], msg));
+  }
+  if (fname === "ta.correlation_filter" || fname === "correlation_filter") {
+    const msg = "ta.correlation_filter() requires 5 arguments";
+    const s1 = wave13v(0, ["signal1_list", "signal1", "s1"], msg);
+    const s2 = wave13v(1, ["signal2_list", "signal2", "s2"], msg);
+    const s3 = wave13v(2, ["signal3_list", "signal3", "s3"], msg);
+    wave11n(3, ["num_signals"], msg);
+    return env.ta.correlationFilter(site, s1, s2, s3, wave11n(4, ["threshold"], msg));
+  }
+  if (fname === "ta.advanced_breakout_detector" || fname === "advanced_breakout_detector") {
+    const msg = "ta.advanced_breakout_detector() requires 5 arguments";
+    return env.ta.advancedBreakoutDetector(site, wave13v(0, ["price_list", "price"], msg), wave13v(1, ["volume_list", "volume"], msg), wave11n(2, ["level"], msg), wave11n(3, ["lookback"], msg), wave11n(4, ["volume_multiplier", "vol_mult"], msg));
+  }
+  if (fname === "ta.pullback_bounce_level" || fname === "pullback_bounce_level") {
+    const msg = "ta.pullback_bounce_level() requires 5 arguments";
+    const high = wave13v(0, ["high_list", "high"], msg);
+    const low = wave13v(1, ["low_list", "low"], msg);
+    wave13v(2, ["close_list", "close"], msg);
+    return env.ta.pullbackBounceLevel(site, high, low, wave11n(3, ["trend_direction", "trend_dir"], msg), wave11n(4, ["lookback"], msg));
+  }
+  if (fname === "ta.divergence_detector" || fname === "divergence_detector") {
+    const msg = "ta.divergence_detector() requires 3 arguments";
+    return env.ta.divergenceDetector(site, wave13v(0, ["price_list", "price"], msg), wave13v(1, ["indicator_list", "indicator"], msg), wave11n(2, ["lookback"], msg));
+  }
+  if (fname === "ta.momentum_divergence" || fname === "momentum_divergence") {
+    const msg = "ta.momentum_divergence() requires 3 arguments";
+    return env.ta.momentumDivergence(site, wave13v(0, ["price"], msg), wave13v(1, ["momentum_fast", "mom_fast"], msg), wave13v(2, ["momentum_slow", "mom_slow"], msg));
+  }
+  if (fname === "ta.spread_analysis" || fname === "spread_analysis") {
+    const msg = "ta.spread_analysis() requires 3 arguments";
+    return env.ta.spreadAnalysis(site, wave13v(0, ["bid"], msg), wave13v(1, ["ask"], msg), wave11n(2, ["period", "length"], msg));
+  }
+  if (fname === "ta.employment_cycle_indicator" || fname === "employment_cycle_indicator") {
+    const msg = "ta.employment_cycle_indicator() requires 3 arguments";
+    return env.ta.employmentCycleIndicator(site, wave13v(0, ["cyclical_stocks", "cyclical"], msg), wave13v(1, ["defensive_stocks", "defensive"], msg), wave13v(2, ["unemployment_proxy", "unemployment"], msg));
+  }
+  if (fname === "ta.gdp_growth_proxy" || fname === "gdp_growth_proxy") {
+    const msg = "ta.gdp_growth_proxy() requires 3 arguments";
+    return env.ta.gdpGrowthProxy(site, wave13v(0, ["market_breadth", "breadth"], msg), wave13v(1, ["market_volume", "volume"], msg), wave13v(2, ["price_momentum", "momentum"], msg));
+  }
+  if (fname === "ta.inflation_proxy_indicator" || fname === "inflation_proxy_indicator") {
+    const msg = "ta.inflation_proxy_indicator() requires 3 arguments";
+    return env.ta.inflationProxyIndicator(site, wave13v(0, ["usd_index", "usd"], msg), wave13v(1, ["commodity_prices", "commodities"], msg), wave13v(2, ["bond_yields", "yields"], msg));
+  }
+  if (fname === "ta.expected_value" || fname === "expected_value") {
+    const msg = "ta.expected_value() requires 2 arguments: returns, probabilities";
+    const returns = numericList(evalExpr(wave10aArg(0, ["returns"], msg), env));
+    const probs = numericList(evalExpr(wave10aArg(1, ["probabilities", "probs"], msg), env));
+    if (returns.length !== probs.length)
+      runtimeError("Returns and probabilities must have same length");
+    return env.ta.expectedValue(returns, probs);
+  }
+  if (fname === "ta.gamma_levels" || fname === "gamma_levels") {
+    const msg = "ta.gamma_levels() requires 3 arguments";
+    const volArg = wave10aArg(0, ["volatility"], msg);
+    const priceArg = wave10aArg(1, ["current_price", "price"], msg);
+    const vol = isSeriesExpr(volArg, env) ? NA : num2(evalExpr(volArg, env));
+    const price = isSeriesExpr(priceArg, env) ? NA : num2(evalExpr(priceArg, env));
+    return env.ta.gammaLevels(vol, price, wave11n(2, ["period", "length"], msg));
+  }
+  if (fname === "ta.intelligent_strategy_synthesizer" || fname === "intelligent_strategy_synthesizer") {
+    const msg = "ta.intelligent_strategy_synthesizer() requires 6 arguments";
+    return env.ta.intelligentStrategySynthesizer(site, wave13v(0, ["trend_indicators", "trend"], msg), wave13v(1, ["momentum_indicators", "momentum"], msg), wave13v(2, ["volatility_indicators", "volatility"], msg), wave13v(3, ["volume_indicators", "volume"], msg), wave13v(4, ["market_condition", "market_regime"], msg), wave13v(5, ["risk_profile"], msg));
+  }
+  if (fname === "ta.signal_confluence" || fname === "signal_confluence") {
+    const msg = "ta.signal_confluence() requires 1 argument";
+    return env.ta.signalConfluence(wave13v(0, ["signals"], msg));
   }
   return;
 }
@@ -53502,6 +54501,20 @@ function seriesLastCell(value) {
   const v = unwrap2(value);
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
+function numericList(value) {
+  const arr = asArray2(value);
+  if (arr == null) {
+    const v = unwrap2(value);
+    return typeof v === "number" && Number.isFinite(v) ? [v] : [];
+  }
+  const out = [];
+  for (let i = 0;i < arr.size(); i++) {
+    const v = arr.get(i);
+    if (typeof v === "number" && Number.isFinite(v))
+      out.push(v);
+  }
+  return out;
+}
 function asArray2(value) {
   if (value instanceof PineArray)
     return value;