@hoox-sh/pynets 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoox-sh/pynets",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "module",
   "license": "AGPL-3.0-or-later",
   "author": "jango_blockchained",

package/src/cli/rich.ts

@@ -12,7 +12,7 @@ const MUTED = [203, 204, 189] as const;
 const FAIL = [231, 0, 11] as const;
 const WARN = [235, 169, 65] as const;
 
-export const VERSION = "0.6.0";
+export const VERSION = "0.8.0";
 
 type Rgb = readonly [number, number, number];
 

package/src/runtime/compile/emit_call.ts

@@ -193,6 +193,27 @@ const TA_METHODS = new Set([
   "regime_adaptive_signal",
   "strategy_score",
   "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",
 ]);
 
 /**
@@ -405,6 +426,13 @@ export function emitCall(ctx: EmitCtx, node: Call, visit: VisitFn): string {
     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"`);
+  }
   // ticker.new / standard / modify / renko / kagi / linebreak / pointfigure → first arg or "SYMBOL"
   if (name.startsWith("ticker_")) {
     return pick(args, 0, ["symbol", "ticker", "tickerid"], `"SYMBOL"`);
@@ -588,6 +616,10 @@ function hasSeriesArg(args: CallArgs): boolean {
   return args.posNodes.some(isSeries) || Object.values(args.kwNodes).some(isSeries);
 }
 
+function isSeriesNode(n: expr | undefined): boolean {
+  return n != null && n.kind === "Name" && BARE_SERIES_NAMES.has(n.id);
+}
+
 /** True when a keyword argument named one of *names* is present (interpret hasKwarg). */
 function hasAnyKw(args: CallArgs, names: string[]): boolean {
   return names.some((n) => Object.hasOwn(args.kw, n));
@@ -617,6 +649,11 @@ function cellOf(expr: string): string {
   return `((__c) => (__c == null ? null : typeof __c === "boolean" ? (__c ? 1 : 0) : (typeof __c === "number" && Number.isFinite(__c) ? __c : null)))(${expr})`;
 }
 
+/** Cell or array/object (history-based TA args keep arrays intact). */
+function arrOrCell(expr: string): string {
+  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})`;
+}
+
 /**
  * Interpret `wave10bList`: a Pine array becomes its cells; a scalar is a
  * one-element list. Bar-mode series stay one element.
@@ -2394,8 +2431,11 @@ function emitTa(ctx: EmitCtx, method: string, args: CallArgs): string {
     ]);
   }
   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") {
@@ -2416,13 +2456,13 @@ function emitTa(ctx: EmitCtx, method: string, args: CallArgs): string {
     ]);
   }
   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")),
     ]);
   }
@@ -2460,11 +2500,163 @@ function emitTa(ctx: EmitCtx, method: string, args: CallArgs): string {
     ]);
   }
   if (method === "breakout_detection") {
+    const arg = (i: number, names: string[]): string =>
+      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";
 }

package/src/runtime/interpret.ts

@@ -2105,6 +2105,39 @@ function evalCall(node: Call, env: Env): Value {
         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;
   const matrixVal = evalMatrixCall(fname, node, env);
@@ -3841,7 +3874,7 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
       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 as TaEngine["percentileNearest"]).call(
       env.ta,
@@ -3851,7 +3884,7 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
       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 as TaEngine["percentileLinear"]).call(
       env.ta,
@@ -4049,17 +4082,6 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
     const r = env.ta.aroon(site, num(env.ctx.high), num(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 as TaEngine["pivotPoints"]).call(
-      env.ta,
-      site,
-      num(env.ctx.high),
-      num(env.ctx.low),
-      num(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,
@@ -4300,6 +4322,8 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
     unwrap(evalExpr(wave10aArg(index, names, message), env));
   const wave11n = (index: number, names: string[], message: string): Cell =>
     num(wave11(index, names, message));
+  const wave13v = (index: number, names: string[], message: string): Value =>
+    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"]);
@@ -4566,12 +4590,12 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   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";
@@ -4596,16 +4620,17 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
     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),
+      site,
+      wave13v(0, ["price", "source"], msg),
+      wave13v(1, ["sma"], msg),
+      wave13v(2, ["stdev", "std_dev"], msg),
       wave11n(4, ["threshold"], msg),
     );
   }
@@ -4648,13 +4673,226 @@ function evalExtraTa(fname: string | null, node: Call, env: Env, site: string):
   }
   if (fname === "ta.breakout_detection" || fname === "breakout_detection") {
     const msg = "ta.breakout_detection() requires 3 arguments";
+    const arg = (i: number, names: string[]): Cell => {
+      const e = wave10aArg(i, names, msg);
+      return isSeriesExpr(e, env) ? NA : num(evalExpr(e, env));
+    };
     return env.ta.breakoutDetection(
-      wave11n(0, ["close", "source"], msg),
-      wave11n(1, ["resistance"], msg),
-      wave11n(2, ["support"], msg),
+      arg(0, ["close", "source"]),
+      arg(1, ["resistance"]),
+      arg(2, ["support"]),
     );
   }
   // wave12-end
+  // wave13-start — history / sentiment / macro analytics
+  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") {
+      // Reference Pine type+anchor form → context pivot-point tuple.
+      if (typeof env.ta.pivotPoints !== "function") return NA;
+      const r = (env.ta.pivotPoints as TaEngine["pivotPoints"]).call(
+        env.ta,
+        site,
+        num(env.ctx.high),
+        num(env.ctx.low),
+        num(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 : unwrap(evalExpr(tradArg, env)) !== 0;
+    return env.ta.pivotPointLevels(
+      num(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);
+  }
+  // wave13-end
+  // wave14-start — list-return + capstone synthesis
+  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 : num(evalExpr(volArg, env));
+    const price = isSeriesExpr(priceArg, env) ? NA : num(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));
+  }
+  // wave14-end
   return undefined;
 }
 
@@ -4676,6 +4914,21 @@ function seriesLastCell(value: Value): number | null {
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
 
+/** Python `_expect_list` for array-valued args: numeric cells only. */
+function numericList(value: Value): number[] {
+  const arr = asArray(value);
+  if (arr == null) {
+    const v = unwrap(value);
+    return typeof v === "number" && Number.isFinite(v) ? [v] : [];
+  }
+  const out: number[] = [];
+  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 asArray(value: Value): PineArray | null {
   if (value instanceof PineArray) return value;
   if (value && typeof value === "object" && "__array" in value) {