@hoox-sh/pynets 0.5.0 → 0.7.0

package/dist/index.js

@@ -6287,6 +6287,7 @@ class PinescriptLexerBase extends cn {
   _lastPendingTokenType = 0;
   _lastPendingTokenTypeFromDefaultChannel = 0;
   _numOpens = 0;
+  _numSqBrackets = 0;
   _indentLengthStack = [];
   _inputStarted = false;
   constructor(input) {
@@ -6340,6 +6341,7 @@ class PinescriptLexerBase extends cn {
     this._lastPendingTokenType = 0;
     this._lastPendingTokenTypeFromDefaultChannel = 0;
     this._numOpens = 0;
+    this._numSqBrackets = 0;
     this._indentLengthStack = [];
     this._inputStarted = false;
   }
@@ -6356,11 +6358,17 @@ class PinescriptLexerBase extends cn {
     const tok = this._currentToken;
     const tokType = tok.type;
     const C = this.C;
-    if (tokType === C.LPAR || tokType === C.LSQB) {
+    if (tokType === C.LPAR) {
       this._numOpens += 1;
       this._addPendingToken(tok);
-    } else if (tokType === C.RPAR || tokType === C.RSQB) {
-      this._numOpens -= 1;
+    } else if (tokType === C.LSQB) {
+      this._numSqBrackets += 1;
+      this._addPendingToken(tok);
+    } else if (tokType === C.RPAR) {
+      this._numOpens = Math.max(0, this._numOpens - 1);
+      this._addPendingToken(tok);
+    } else if (tokType === C.RSQB) {
+      this._numSqBrackets = Math.max(0, this._numSqBrackets - 1);
       this._addPendingToken(tok);
     } else if (tokType === C.NEWLINE) {
       this._handleNEWLINEToken();
@@ -6452,7 +6460,7 @@ class PinescriptLexerBase extends cn {
     return tok;
   }
   _handleNEWLINEToken() {
-    if (this._numOpens > 0 || this._operators.has(this._lastPendingTokenTypeFromDefaultChannel)) {
+    if (this._numOpens > 0 || this._numSqBrackets > 0 || this._operators.has(this._lastPendingTokenTypeFromDefaultChannel)) {
       this._hideAndAddPendingToken(this._currentToken);
       return;
     }
@@ -36320,6 +36328,13 @@ function mathRandom(a, b, rng = Math.random) {
 // src/runtime/time.ts
 var MIN_T = -62167219200;
 var MAX_T = 253402300799;
+function timestampToMs(ts) {
+  if (ts == null || !Number.isFinite(ts))
+    return null;
+  if (Math.abs(ts) < 100000000000)
+    return ts * 1000;
+  return ts;
+}
 function utcPartsFromMs(ms) {
   let t = Number.isFinite(ms) ? Math.trunc(ms / 1000) : 0;
   if (t < MIN_T)
@@ -37176,8 +37191,7 @@ function coerceFormatTimeMs(time) {
   if (typeof raw !== "number" || !Number.isFinite(raw))
     return null;
   let ts = Math.trunc(raw);
-  if (ts > 0 && ts < 10000000000)
-    ts *= 1000;
+  ts = timestampToMs(ts) ?? ts;
   return ts;
 }
 function formatOffsetHours(offsetHours) {
@@ -37930,6 +37944,48 @@ class StrategyBook {
       bar: isFiniteNumber2(bar) ? bar : 0
     });
   }
+  placeClose(bar, id, price, opts) {
+    const b = isFiniteNumber2(bar) ? bar : 0;
+    const oid = String(id ?? "");
+    this.ensureSanePosition();
+    if (this.position.qty !== 0) {
+      const absPos = Math.abs(this.position.qty);
+      const rawQty = opts?.qty;
+      const q = isFiniteNumber2(rawQty) && rawQty >= 0 ? Math.min(Math.abs(rawQty), absPos) : absPos;
+      if (q > 0) {
+        this.upsertPending({
+          id: `${oid}:close`,
+          direction: this.position.qty > 0 ? "short" : "long",
+          qty: q,
+          limit: null,
+          stop: null,
+          bar: b,
+          kind: "close",
+          deferred: true,
+          comment: opts?.comment
+        });
+      }
+    }
+    this.close(b, oid);
+  }
+  placeCloseAll(bar, price, opts) {
+    const b = isFiniteNumber2(bar) ? bar : 0;
+    this.ensureSanePosition();
+    if (this.position.qty !== 0) {
+      this.upsertPending({
+        id: "close_all",
+        direction: this.position.qty > 0 ? "short" : "long",
+        qty: Math.abs(this.position.qty),
+        limit: null,
+        stop: null,
+        bar: b,
+        kind: "close_all",
+        deferred: true,
+        comment: opts?.comment
+      });
+    }
+    this.events.push({ type: "close_all", id: "", bar: b });
+  }
   exit(bar, id, qty) {
     const event = {
       type: "exit",
@@ -37967,10 +38023,46 @@ class StrategyBook {
   placeEntry(bar, id, direction, qty, opts) {
     const limit = optLevel(opts?.limit);
     const stop = optLevel(opts?.stop);
+    const b = isFiniteNumber2(bar) ? bar : 0;
+    const oid = String(id ?? "");
     if (limit == null && stop == null) {
+      if (opts?.deferMarket === true) {
+        const dir = mapDirection(direction);
+        const absQty = isFiniteNumber2(qty) ? Math.abs(qty) : Number.NaN;
+        if (!isFiniteNumber2(absQty) || absQty <= 0)
+          return;
+        const t = isFiniteNumber2(opts?.time) ? opts.time : b;
+        if (!this.riskAllowsEntry(dir, t))
+          return;
+        const mark = isFiniteNumber2(opts?.price) ? opts.price : 0;
+        const capped = this.capQtyByMaxPosition(absQty, mark);
+        if (!isFiniteNumber2(capped) || capped <= 0)
+          return;
+        const signed = dir === "long" ? capped : -capped;
+        if (this.position.qty !== 0 && Math.sign(this.position.qty) === Math.sign(signed)) {
+          const maxEntries = this.pyramiding !== undefined ? this.pyramiding + 1 : 1;
+          const allowed = this.pyramiding !== undefined && this.pyramiding > 0 && this.opentrades < maxEntries;
+          if (!allowed)
+            return;
+        }
+        this.upsertPending({
+          id: oid,
+          direction: dir,
+          qty: capped,
+          limit: null,
+          stop: null,
+          bar: b,
+          kind: "entry",
+          is_entry: true,
+          deferred: true,
+          comment: opts?.comment
+        });
+        this.events.push({ type: "order", id: oid, direction: dir, qty: capped, bar: b });
+        return;
+      }
       if (isFiniteNumber2(opts?.price)) {
         const dir = mapDirection(direction);
-        const t = isFiniteNumber2(opts?.time) ? opts.time : bar;
+        const t = isFiniteNumber2(opts?.time) ? opts.time : b;
         this.updateEquityExtremes(opts.price);
         if (!this.riskAllowsEntry(dir, t))
           return;
@@ -37981,8 +38073,6 @@ class StrategyBook {
     }
     const dir = mapDirection(direction);
     const absQty = isFiniteNumber2(qty) ? Math.abs(qty) : Number.NaN;
-    const b = isFiniteNumber2(bar) ? bar : 0;
-    const oid = String(id ?? "");
     this.entry(b, oid, dir, isFiniteNumber2(absQty) ? absQty : qty);
     if (!isFiniteNumber2(absQty) || absQty === 0)
       return;
@@ -38032,6 +38122,23 @@ class StrategyBook {
       return;
     const t = isFiniteNumber2(opts?.time) ? opts.time : b;
     if (limitP == null && stopP == null && !hasTrail) {
+      if (opts?.deferMarket === true) {
+        const closeDir = isLong ? "short" : "long";
+        this.upsertPending({
+          id: `${oid}:close`,
+          direction: closeDir,
+          qty,
+          limit: null,
+          stop: null,
+          bar: b,
+          kind: "exit",
+          from_entry: fromEntry,
+          deferred: true,
+          comment: opts?.comment
+        });
+        this.events.push({ type: "order", id: oid, direction: closeDir, qty, bar: b });
+        return;
+      }
       if (!isFiniteNumber2(opts?.price))
         return;
       this.reducePosition(b, oid, opts.price, qty, fromEntry, t, opts?.comment);
@@ -38102,13 +38209,24 @@ class StrategyBook {
     for (const order of this.pending.slice()) {
       if (!this.pending.some((p) => p.id === order.id))
         continue;
+      if (order.bar === b)
+        continue;
       if (order.kind === "exit" && isTrailOrder(order))
         updateTrailStop(order, high, low);
-      const px = triggerPrice(order, open, high, low);
+      let px;
+      if (order.limit == null && order.stop == null)
+        px = open;
+      else
+        px = triggerPrice(order, open, high, low);
       if (px == null)
         continue;
       this.dropPending(order.id);
-      const applied = order.kind === "exit" ? this.applyExitFill(b, order, px) : this.applyEntryFill(b, order.id, order.direction, order.qty, px, false);
+      const emitEntry = order.kind === "entry" || order.deferred === true;
+      const barTime = isFiniteNumber2(ohlc.time) ? ohlc.time : undefined;
+      const applied = order.kind === "exit" ? this.applyExitFill(b, order, px, barTime) : order.kind === "close" || order.kind === "close_all" ? this.applyCloseFill(b, order, px, barTime) : this.applyEntryFill(b, order.id, order.direction, order.qty, px, emitEntry, {
+        comment: order.comment,
+        time: barTime
+      });
       if (applied) {
         const q = Math.abs(this.fills.at(-1)?.qty ?? order.qty);
         this.ocaAfterFill(order, q, b);
@@ -38124,6 +38242,22 @@ class StrategyBook {
     }
     return filled;
   }
+  applyCloseFill(bar, order, price, time) {
+    this.ensureSanePosition();
+    if (this.position.qty === 0 || !isFiniteNumber2(price))
+      return false;
+    const absPos = Math.abs(this.position.qty);
+    const rawQty = order.qty;
+    const q = isFiniteNumber2(rawQty) && rawQty > 0 ? Math.min(Math.abs(rawQty), absPos) : absPos;
+    if (!(q > 0))
+      return false;
+    if (q < absPos - 0.000000000001) {
+      this.reducePosition(bar, order.id, price, q, order.from_entry ?? null, time, order.comment);
+    } else {
+      this.flattenAt(bar, order.id, price, time, order.comment);
+    }
+    return true;
+  }
   fillEntry(bar, id, direction, qty, price, opts) {
     this.applyEntryFill(bar, id, direction, qty, price, true, opts);
   }
@@ -38246,9 +38380,9 @@ class StrategyBook {
       return { status: "invalid", qty: 0 };
     return { status: "ok", qty: Math.min(rawQty, target) };
   }
-  applyExitFill(bar, order, price) {
+  applyExitFill(bar, order, price, time) {
     const t = isFiniteNumber2(bar) ? bar : 0;
-    return this.reducePosition(t, order.id, price, order.qty, order.from_entry ?? null, t);
+    return this.reducePosition(t, order.id, price, order.qty, order.from_entry ?? null, time);
   }
   closeLeg(ot, bar, exitPrice, qty, profit, commission, exitTime, exitComment) {
     const closed = {
@@ -40255,6 +40389,37 @@ function pushCap(window2, value, cap) {
 function finiteOut2(value) {
   return Number.isFinite(value) ? value : null;
 }
+function smaOf(series, period) {
+  if (period <= 0 || series.length < period)
+    return null;
+  const window2 = series.slice(series.length - period);
+  let sum = 0;
+  for (const v of window2) {
+    if (v === null)
+      return null;
+    sum += v;
+  }
+  return sum / period;
+}
+function stdevOf(series, period) {
+  if (period <= 1 || series.length < period)
+    return null;
+  const window2 = series.slice(series.length - period);
+  const vals = [];
+  for (const v of window2) {
+    if (v === null)
+      return null;
+    vals.push(v);
+  }
+  let mean = 0;
+  for (const v of vals)
+    mean += v;
+  mean /= period;
+  let sumSq = 0;
+  for (const v of vals)
+    sumSq += (v - mean) ** 2;
+  return Math.sqrt(sumSq / period);
+}
 var PERIOD_INT_EPS = 0.000000001;
 function pinePeriod(period) {
   if (!Number.isFinite(period) || period <= 0)
@@ -40353,6 +40518,26 @@ class TaEngine {
   emvSites = new Map;
   fractalSites = new Map;
   zigzagSites = new Map;
+  engulfingSites = new Map;
+  insideBarSites = new Map;
+  doubleTopBottomSites = new Map;
+  rsiDivergenceSites = new Map;
+  stochSmoothSites = new Map;
+  smaWeightedSites = new Map;
+  betaSites = new Map;
+  rSquaredSites = new Map;
+  comovementSites = new Map;
+  skewnessSites = new Map;
+  kurtosisSites = new Map;
+  vwmSites = new Map;
+  meanReversionSites = new Map;
+  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)
@@ -40427,18 +40612,24 @@ class TaEngine {
       st = {
         period: n,
         prevClose: null,
+        started: false,
         rma: { period: n, rma: null, seeded: false, started: false, seedBuf: [] }
       };
       this.atrSites.set(site, st);
     }
-    const prev = st.prevClose;
-    st.prevClose = finiteCell2(close);
-    if (prev === null)
-      return null;
     const h = finiteCell2(high);
     const l = finiteCell2(low);
     const c = finiteCell2(close);
-    if (h === null || l === null || c === null)
+    if (!st.started) {
+      st.started = true;
+      st.prevClose = c;
+      if (h === null || l === null)
+        return null;
+      return rmaStep(st.rma, h - l, n);
+    }
+    const prev = st.prevClose;
+    st.prevClose = c;
+    if (prev === null || h === null || l === null || c === null)
       return null;
     const tr = Math.max(h - l, Math.abs(h - prev), Math.abs(l - prev));
     return rmaStep(st.rma, tr, n);
@@ -40604,7 +40795,7 @@ class TaEngine {
     }
     if (st.window.length < n || st.count !== n)
       return null;
-    let v = (st.sumsq - st.sum * st.sum / n) / (n - 1);
+    let v = (st.sumsq - st.sum * st.sum / n) / n;
     if (v < 0)
       v = 0;
     return Math.sqrt(v);
@@ -41810,7 +42001,7 @@ class TaEngine {
     }
     if (st.window.length < n || st.count !== n)
       return null;
-    let v = (st.sumsq - st.sum * st.sum / n) / (n - 1);
+    let v = (st.sumsq - st.sum * st.sum / n) / n;
     if (v < 0)
       v = 0;
     return v;
@@ -42414,20 +42605,17 @@ class TaEngine {
       st = { samples: [] };
       this.zigzagSites.set(site, st);
     }
-    pushCap(st.samples, finiteCell2(source), 1000);
-    const finite = [];
-    for (const v of st.samples) {
-      if (v !== null)
-        finite.push(v);
-    }
-    if (finite.length < 2)
+    const x = finiteCell2(source);
+    if (x !== null)
+      pushCap(st.samples, x, 2);
+    if (st.samples.length < 2)
       return { high: null, low: null, dir: 0 };
-    const oldest = finite[0];
-    const second = finite[1];
-    const recentHigh = Math.max(oldest, second);
-    const recentLow = Math.min(oldest, second);
+    const oldest = st.samples[0];
+    const newest = st.samples[1];
+    const recentHigh = Math.max(oldest, newest);
+    const recentLow = Math.min(oldest, newest);
     const pct = recentLow !== 0 ? (recentHigh - recentLow) / recentLow * 100 : 0;
-    const direction = recentHigh === oldest ? 1 : -1;
+    const direction = recentHigh === newest ? 1 : -1;
     return { high: recentHigh, low: recentLow, dir: pct > th ? 1 : direction };
   }
   accelSites = new Map;
@@ -42494,30 +42682,31 @@ class TaEngine {
   }
   accelerationFactor(site, source, period) {
     const p = this.coerceTaInt(period, "ta.acceleration_factor() requires 2 arguments");
-    let samples = this.accelSites.get(site);
+    if (p <= 0)
+      return 0;
+    const key = `${site}:${p}`;
+    let samples = this.accelSites.get(key);
     if (samples === undefined) {
       samples = [];
-      this.accelSites.set(site, samples);
+      this.accelSites.set(key, samples);
     }
-    pushCap(samples, finiteCell2(source), 1000);
-    if (samples.length < p + 1 || p <= 0)
+    pushCap(samples, finiteCell2(source), p + 1);
+    if (samples.length < p + 1)
       return 0;
-    const oldest = samples.slice(0, p + 1);
-    const newestFirst = [];
-    for (let i = oldest.length - 1;i >= 0; i--) {
-      const v = oldest[i];
+    const clean = [];
+    for (const v of samples) {
       if (v !== null)
-        newestFirst.push(v);
+        clean.push(v);
     }
-    if (newestFirst.length < 2)
+    if (clean.length < 2)
       return 0;
     let oldSum = 0;
-    for (let i = 0;i < newestFirst.length - 1; i++)
-      oldSum += newestFirst[i];
-    const oldMom = oldSum / (newestFirst.length - 1);
+    for (let i = 0;i < clean.length - 1; i++)
+      oldSum += clean[i];
+    const oldMom = oldSum / (clean.length - 1);
+    const newMom = clean[clean.length - 1];
     if (Math.abs(oldMom) < 0.0000000001)
       return 0;
-    const newMom = newestFirst[newestFirst.length - 1];
     let acc = (newMom - oldMom) / oldMom;
     if (acc < -2)
       acc = -2;
@@ -42525,32 +42714,141 @@ class TaEngine {
       acc = 2;
     return finiteOut2(acc);
   }
-  stochSmooth(high, low, close, period, smoothK, smoothD) {
+  stochSmooth(site, high, low, close, period, smoothK, smoothD) {
     const p = this.coerceTaInt(period, "ta.stoch_smooth period must be integer");
     const k = this.coerceTaInt(smoothK, "ta.stoch_smooth smooth_k must be integer");
     const d = this.coerceTaInt(smoothD, "ta.stoch_smooth smooth_d must be integer");
-    if (p <= 0)
-      throw new Error("max() iterable argument is empty");
-    if (high === null || low === null || close === null) {
-      throw new Error("unsupported operand type(s) for /: 'float' and 'NoneType'");
-    }
-    if (k !== 1 || d !== 1)
+    if (p < 1 || k < 1 || d < 1)
       return null;
-    const span = high - low;
-    const stoch = span !== 0 ? 100 * (close - low) / span : 50;
-    return finiteOut2(stoch);
-  }
-  engulfing() {
-    return taRec({ is_bullish: false, is_bearish: false, pattern_strength: 0 });
-  }
-  insideBarPattern() {
-    return false;
+    const key = `${site}:${p}:${k}:${d}`;
+    let st = this.stochSmoothSites.get(key);
+    if (st === undefined) {
+      st = { highs: [], lows: [] };
+      this.stochSmoothSites.set(key, st);
+    }
+    pushCap(st.highs, finiteCell2(high), p);
+    pushCap(st.lows, finiteCell2(low), p);
+    const c = finiteCell2(close);
+    let stoch = null;
+    if (c !== null && !st.highs.includes(null) && !st.lows.includes(null)) {
+      let hh = -Infinity;
+      let ll = Infinity;
+      for (const v of st.highs) {
+        if (v > hh)
+          hh = v;
+      }
+      for (const v of st.lows) {
+        if (v < ll)
+          ll = v;
+      }
+      stoch = hh === ll ? 50 : 100 * (c - ll) / (hh - ll);
+    }
+    const kVal = this.ema(`${site}:k`, stoch, k);
+    return this.ema(`${site}:d`, kVal, d);
+  }
+  engulfing(site, open, close) {
+    const off = taRec({ is_bullish: false, is_bearish: false, pattern_strength: 0 });
+    let st = this.engulfingSites.get(site);
+    if (st === undefined) {
+      st = { prevOpen: null, prevClose: null, count: 0 };
+      this.engulfingSites.set(site, st);
+    }
+    const o = finiteCell2(open);
+    const c = finiteCell2(close);
+    st.count += 1;
+    const prevO = st.prevOpen;
+    const prevC = st.prevClose;
+    if (st.count < 2 || prevO === null || prevC === null || o === null || c === null) {
+      st.prevOpen = o;
+      st.prevClose = c;
+      return off;
+    }
+    const isBullish = o < prevC && c > prevO && c > o;
+    const isBearish = o > prevC && c < prevO && c < o;
+    let engulf = 0;
+    if (isBullish) {
+      engulf = Math.max(0, Math.min(1, (c - prevO) / Math.abs(prevO - prevC + 0.0001)));
+    } else if (isBearish) {
+      engulf = Math.max(0, Math.min(1, (prevO - c) / Math.abs(prevC - prevO + 0.0001)));
+    }
+    st.prevOpen = o;
+    st.prevClose = c;
+    return taRec({
+      is_bullish: isBullish,
+      is_bearish: isBearish,
+      pattern_strength: finiteOut2(engulf) ?? 0
+    });
   }
-  doubleTopBottom(period) {
-    if (period === null || !Number.isFinite(period)) {
-      throw new Error("period must be integer. Got: na");
+  insideBarPattern(site, high, low) {
+    let st = this.insideBarSites.get(site);
+    if (st === undefined) {
+      st = { prevHigh: null, prevLow: null, count: 0 };
+      this.insideBarSites.set(site, st);
+    }
+    const currH = high !== null && Number.isFinite(high) ? high : 0;
+    const currL = low !== null && Number.isFinite(low) ? low : 0;
+    st.count += 1;
+    const prevH = st.prevHigh;
+    const prevL = st.prevLow;
+    if (st.count < 2 || prevH === null || prevL === null) {
+      st.prevHigh = currH;
+      st.prevLow = currL;
+      return false;
+    }
+    const val = currH < prevH && currL > prevL;
+    st.prevHigh = currH;
+    st.prevLow = currL;
+    return val;
+  }
+  doubleTopBottom(site, high, low, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    const off = taRec({ pattern_type: "none", strength: 0, breakout_level: 0 });
+    if (n < 1)
+      return off;
+    const key = `${site}:${n}`;
+    let st = this.doubleTopBottomSites.get(key);
+    if (st === undefined) {
+      st = { highs: [], lows: [], count: 0 };
+      this.doubleTopBottomSites.set(key, st);
+    }
+    pushCap(st.highs, finiteCell2(high), n);
+    pushCap(st.lows, finiteCell2(low), n);
+    st.count += 1;
+    if (st.count < n)
+      return off;
+    const recentHigh = [];
+    for (const v of st.highs) {
+      if (v !== null)
+        recentHigh.push(v);
+    }
+    const recentLow = [];
+    for (const v of st.lows) {
+      if (v !== null)
+        recentLow.push(v);
+    }
+    if (recentHigh.length < 3 || recentLow.length === 0)
+      return off;
+    const peaks = [recentHigh[0]];
+    for (let i = 1;i < recentHigh.length - 1; i++) {
+      if (recentHigh[i] > recentHigh[i - 1] && recentHigh[i] > recentHigh[i + 1]) {
+        peaks.push(recentHigh[i]);
+      }
+    }
+    if (peaks.length < 2)
+      return off;
+    const peakDiff = Math.abs(peaks[peaks.length - 1] - peaks[peaks.length - 2]);
+    const avgPeak = (peaks[peaks.length - 1] + peaks[peaks.length - 2]) / 2;
+    const strength = avgPeak > 0 ? 1 - Math.min(1, peakDiff / avgPeak) : 0;
+    let minLow = recentLow[0];
+    for (const v of recentLow) {
+      if (v < minLow)
+        minLow = v;
     }
-    return taRec({ pattern_type: "none", strength: 0, breakout_level: 0 });
+    return taRec({
+      pattern_type: "double_top",
+      strength: finiteOut2(strength) ?? 0,
+      breakout_level: finiteOut2(minLow - avgPeak * 0.1) ?? 0
+    });
   }
   cumDeltaSites = new Map;
   volMomSites = new Map;
@@ -42571,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;
@@ -42603,96 +42934,91 @@ class TaEngine {
     }
     return taRec({ is_oversold: rsi < os, is_overbought: rsi > ob, rsi });
   }
-  rsiDivergence(series, period) {
+  rsiDivergence(site, value, period) {
     const p = this.asCount(period);
-    if (p === null || series.length === 0)
-      return null;
-    let last = 0;
-    for (let i = 0;i < series.length; i++) {
-      if (i < p) {
-        last = 0;
-        continue;
-      }
-      const start = Math.max(0, i - p);
-      const vals = [];
-      for (let j = start;j <= i; j++) {
-        const v = series[j];
-        if (v !== null && Number.isFinite(v))
-          vals.push(v);
-      }
-      if (vals.length < 2) {
-        last = 0;
-        continue;
-      }
-      let rsiMin = vals[0];
-      let rsiMax = vals[0];
-      for (const v of vals) {
-        if (v < rsiMin)
-          rsiMin = v;
-        if (v > rsiMax)
-          rsiMax = v;
-      }
-      const cur = series[i];
-      const range = rsiMax - rsiMin;
-      if (cur === null || !Number.isFinite(cur) || range <= 0) {
-        last = 0;
-        continue;
-      }
-      last = (cur - rsiMin) / range * 2 - 1;
+    if (p === null || p < 1)
+      return 0;
+    let st = this.rsiDivergenceSites.get(`${site}:${p}`);
+    if (st === undefined) {
+      st = { window: [], count: 0 };
+      this.rsiDivergenceSites.set(`${site}:${p}`, st);
+    }
+    const x = finiteCell2(value);
+    pushCap(st.window, x, p + 1);
+    st.count += 1;
+    if (st.count <= p)
+      return 0;
+    const vals = [];
+    for (const v of st.window) {
+      if (v !== null)
+        vals.push(v);
     }
-    return finiteOut2(last);
+    if (vals.length < 2 || x === null)
+      return 0;
+    let lo = vals[0];
+    let hi = vals[0];
+    for (const v of vals) {
+      if (v < lo)
+        lo = v;
+      if (v > hi)
+        hi = v;
+    }
+    const range = hi - lo;
+    return range > 0 ? finiteOut2((x - lo) / range * 2 - 1) : 0;
   }
   cumulativeDelta(site, close, volume, period) {
     const n = this.asCount(period);
-    let st = this.cumDeltaSites.get(site);
+    if (n === null || n <= 0)
+      return 0;
+    let st = this.cumDeltaSites.get(`${site}:${n}`);
     if (st === undefined) {
-      st = { close: [], volume: [] };
-      this.cumDeltaSites.set(site, st);
+      st = { closes: [], volumes: [], count: 0 };
+      this.cumDeltaSites.set(`${site}:${n}`, st);
     }
-    this.pushChrono(st.close, close);
-    this.pushChrono(st.volume, volume);
-    if (n === null || n <= 0 || st.close.length < n || st.volume.length < n)
+    const c = finiteCell2(close);
+    const v = volume !== null && Number.isFinite(volume) ? volume : 0;
+    pushCap(st.closes, c, n + 1);
+    pushCap(st.volumes, v, n);
+    st.count += 1;
+    if (st.count < n)
       return 0;
     let delta = 0;
-    for (let i = -n;i < 0; i++) {
-      const cRaw = this.nf(st.close, i);
-      const vRaw = this.nf(st.volume, i);
-      const c = cRaw !== null && Number.isFinite(cRaw) ? cRaw : 0;
-      const v = vRaw !== null && Number.isFinite(vRaw) ? vRaw : 0;
-      if (i > -n) {
-        const prevRaw = this.nf(st.close, i - 1);
-        const prev = prevRaw !== null && Number.isFinite(prevRaw) ? prevRaw : c;
-        if (c > prev)
-          delta += v;
-        else if (c < prev)
-          delta -= v;
-      }
+    const offset = st.closes.length - st.volumes.length;
+    for (let j = 0;j < st.volumes.length; j++) {
+      const idx = offset + j;
+      const cRaw = st.closes[idx] ?? null;
+      const cur = cRaw ?? 0;
+      const prevRaw = idx === 0 ? null : st.closes[idx - 1] ?? null;
+      const prev = prevRaw ?? cur;
+      const vol = st.volumes[j];
+      if (cur > prev)
+        delta += vol;
+      else if (cur < prev)
+        delta -= vol;
     }
     return finiteOut2(delta);
   }
   volumeMomentum(site, volume, period) {
     const n = this.asCount(period);
-    let st = this.volMomSites.get(site);
-    if (st === undefined) {
-      st = { volume: [] };
-      this.volMomSites.set(site, st);
-    }
-    this.pushChrono(st.volume, volume);
-    if (n === null || n <= 0 || st.volume.length < n + 1)
+    if (n === null || n <= 0)
       return 0;
-    const clean = [];
-    for (let i = 0;i < n + 1; i++) {
-      const v = st.volume[i];
-      if (v !== null && Number.isFinite(v))
-        clean.push(v);
+    let st = this.volMomSites.get(`${site}:${n}`);
+    if (st === undefined) {
+      st = { window: [] };
+      this.volMomSites.set(`${site}:${n}`, st);
     }
-    if (clean.length < 2)
+    if (volume !== null && Number.isFinite(volume))
+      pushCap(st.window, volume, n + 1);
+    if (st.window.length < n + 1)
       return 0;
-    const newVol = clean[0];
-    let sum = 0;
-    for (let i = 1;i < clean.length; i++)
-      sum += clean[i];
-    const oldVol = sum / (clean.length - 1);
+    let oldSum = 0;
+    for (let i = 0;i < n; i++)
+      oldSum += st.window[i];
+    let newSum = 0;
+    for (let i = 1;i <= n; i++)
+      newSum += st.window[i];
+    const oldVol = oldSum / n;
+    const newVol = newSum / n;
     if (oldVol === 0)
       return 0;
     let momentum = (newVol - oldVol) / oldVol * 100;
@@ -42702,6 +43028,1167 @@ class TaEngine {
       momentum = -100;
     return finiteOut2(momentum);
   }
+  smaWeighted(site, source, period, weightType) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    const kind = typeof weightType === "string" ? weightType : "linear";
+    if (n < 1)
+      return null;
+    const key = `${site}:${n}:${kind}`;
+    let st = this.smaWeightedSites.get(key);
+    if (st === undefined) {
+      const weights = [];
+      for (let i = 0;i < n; i++) {
+        if (kind === "quadratic")
+          weights.push((i + 1) ** 2);
+        else if (kind === "sqrt")
+          weights.push((i + 1) ** 0.5);
+        else
+          weights.push(i + 1);
+      }
+      st = { window: [], weights, wsum: weights.reduce((a, b) => a + b, 0) };
+      this.smaWeightedSites.set(key, st);
+    }
+    pushCap(st.window, finiteCell2(source), n);
+    if (st.window.length < n || st.window.includes(null) || st.wsum <= 0)
+      return null;
+    let total = 0;
+    for (let i = 0;i < n; i++)
+      total += st.window[i] * st.weights[i];
+    return finiteOut2(total / st.wsum);
+  }
+  apo(site, source, fast, slow) {
+    const f = this.coerceTaInt(fast, "ta.apo fast_period must be integer");
+    const s = this.coerceTaInt(slow, "ta.apo slow_period must be integer");
+    const fastV = this.ema(`${site}:fast`, source, f);
+    const slowV = this.ema(`${site}:slow`, source, s);
+    if (fastV === null || slowV === null)
+      return null;
+    return finiteOut2(fastV - slowV);
+  }
+  atrNormalized(site, high, low, close, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    const atr = this.atr(`${site}:atr`, high, low, close, n);
+    const c = finiteCell2(close);
+    if (c === null || c === 0 || atr === null)
+      return null;
+    return finiteOut2(atr / c * 100);
+  }
+  pairWindow(sites, site, a, b, length) {
+    const n = this.coerceTaInt(length, "length must be integer");
+    if (n < 1)
+      return null;
+    const key = `${site}:${n}`;
+    let st = sites.get(key);
+    if (st === undefined) {
+      st = { a: [], b: [] };
+      sites.set(key, st);
+    }
+    pushCap(st.a, finiteCell2(a), n);
+    pushCap(st.b, finiteCell2(b), n);
+    if (st.a.length < n || st.b.length < n)
+      return null;
+    const left = [];
+    const right = [];
+    for (let i = 0;i < n; i++) {
+      const av = st.a[i];
+      const bv = st.b[i];
+      if (av === null || bv === null)
+        return null;
+      left.push(av);
+      right.push(bv);
+    }
+    return { a: left, b: right };
+  }
+  beta(site, a, b, length) {
+    const pair = this.pairWindow(this.betaSites, site, a, b, length);
+    if (pair === null)
+      return null;
+    const n = pair.a.length;
+    let meanA = 0;
+    let meanB = 0;
+    for (let i = 0;i < n; i++) {
+      meanA += pair.a[i];
+      meanB += pair.b[i];
+    }
+    meanA /= n;
+    meanB /= n;
+    let covariance = 0;
+    let varianceB = 0;
+    for (let i = 0;i < n; i++) {
+      covariance += (pair.a[i] - meanA) * (pair.b[i] - meanB);
+      varianceB += (pair.b[i] - meanB) ** 2;
+    }
+    covariance /= n;
+    varianceB /= n;
+    if (varianceB === 0)
+      return 0;
+    return finiteOut2(covariance / varianceB);
+  }
+  rSquared(site, a, b, length) {
+    const pair = this.pairWindow(this.rSquaredSites, site, a, b, length);
+    if (pair === null)
+      return null;
+    const n = pair.a.length;
+    let meanA = 0;
+    let meanB = 0;
+    for (let i = 0;i < n; i++) {
+      meanA += pair.a[i];
+      meanB += pair.b[i];
+    }
+    meanA /= n;
+    meanB /= n;
+    let covariance = 0;
+    let varA = 0;
+    let varB = 0;
+    for (let i = 0;i < n; i++) {
+      covariance += (pair.a[i] - meanA) * (pair.b[i] - meanB);
+      varA += (pair.a[i] - meanA) ** 2;
+      varB += (pair.b[i] - meanB) ** 2;
+    }
+    covariance /= n;
+    varA /= n;
+    varB /= n;
+    if (varA === 0 || varB === 0)
+      return 0;
+    const corr = covariance / Math.sqrt(varA * varB);
+    return finiteOut2(Math.max(0, Math.min(1, corr ** 2)));
+  }
+  comovement(site, a, b, length) {
+    const pair = this.pairWindow(this.comovementSites, site, a, b, length);
+    if (pair === null)
+      return null;
+    const n = pair.a.length;
+    if (n <= 1)
+      return 0;
+    let same = 0;
+    for (let i = 1;i < n; i++) {
+      if ((pair.a[i] - pair.a[i - 1]) * (pair.b[i] - pair.b[i - 1]) > 0)
+        same += 1;
+    }
+    return finiteOut2(same / (n - 1) * 100);
+  }
+  skewness(site, source, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    if (n < 1)
+      return null;
+    const key = `${site}:${n}`;
+    let st = this.skewnessSites.get(key);
+    if (st === undefined) {
+      st = { window: [] };
+      this.skewnessSites.set(key, st);
+    }
+    pushCap(st.window, finiteCell2(source), n);
+    if (st.window.length < n || st.window.includes(null))
+      return null;
+    const vals = st.window;
+    let mean = 0;
+    for (const v of vals)
+      mean += v;
+    mean /= n;
+    let variance = 0;
+    for (const v of vals)
+      variance += (v - mean) ** 2;
+    variance /= n;
+    const std = Math.sqrt(variance);
+    if (std === 0)
+      return 0;
+    let third = 0;
+    for (const v of vals)
+      third += (v - mean) ** 3;
+    return finiteOut2(third / (n * std ** 3));
+  }
+  kurtosis(site, source, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    if (n < 1)
+      return null;
+    const key = `${site}:${n}`;
+    let st = this.kurtosisSites.get(key);
+    if (st === undefined) {
+      st = { window: [] };
+      this.kurtosisSites.set(key, st);
+    }
+    pushCap(st.window, finiteCell2(source), n);
+    if (st.window.length < n || st.window.includes(null))
+      return null;
+    const vals = st.window;
+    let mean = 0;
+    for (const v of vals)
+      mean += v;
+    mean /= n;
+    let variance = 0;
+    for (const v of vals)
+      variance += (v - mean) ** 2;
+    variance /= n;
+    const std = Math.sqrt(variance);
+    if (std === 0)
+      return 0;
+    let fourth = 0;
+    for (const v of vals)
+      fourth += (v - mean) ** 4;
+    fourth /= n;
+    return finiteOut2(fourth / std ** 4 - 3);
+  }
+  volumeWeightedMomentum(site, source, volume, length) {
+    const n = this.coerceTaInt(length, "length must be integer");
+    if (n < 1)
+      return null;
+    const key = `${site}:${n}`;
+    let st = this.vwmSites.get(key);
+    if (st === undefined) {
+      st = { prices: [], volumes: [] };
+      this.vwmSites.set(key, st);
+    }
+    pushCap(st.prices, finiteCell2(source), n + 1);
+    pushCap(st.volumes, finiteCell2(volume), n);
+    if (st.volumes.length < n)
+      return null;
+    const ps = st.prices;
+    const vs = st.volumes;
+    let momentumSum = 0;
+    let volumeSum = 0;
+    for (let i = 0;i < n; i++) {
+      const pEnd = ps.length - 1 - i;
+      const pPrev = pEnd - 1;
+      if (pPrev < 0)
+        break;
+      const pv = ps[pEnd] ?? null;
+      const pp = ps[pPrev] ?? null;
+      if (pv === null || pp === null)
+        return null;
+      const vol = vs[vs.length - 1 - i] ?? 0;
+      momentumSum += (pv - pp) * vol;
+      volumeSum += vol;
+    }
+    return finiteOut2(volumeSum > 0 ? momentumSum / volumeSum : 0);
+  }
+  parkinson(high, low) {
+    const h = finiteCell2(high);
+    const l = finiteCell2(low);
+    if (h === null || l === null || h <= l)
+      return null;
+    const ratio = h / l;
+    if (ratio <= 0)
+      return null;
+    return finiteOut2(Math.sqrt(Math.log(ratio) ** 2 / (4 * Math.log(2))));
+  }
+  garmanKlass(high, low, close, open) {
+    const h = finiteCell2(high);
+    const l = finiteCell2(low);
+    const c = finiteCell2(close);
+    const o = finiteCell2(open);
+    if (h === null || l === null || c === null || o === null)
+      return null;
+    if (h <= l || h <= 0 || c <= 0)
+      return null;
+    const term1 = 0.5 * Math.log(h / l) ** 2;
+    const term2 = (2 * Math.log(2) - 1) * Math.log(c / o) ** 2;
+    return finiteOut2(Math.sqrt(term1 - term2));
+  }
+  meanReversionScore(site, close, sma, stdev, period) {
+    const n = this.coerceTaInt(period, "ta.mean_reversion_score() requires 4 arguments");
+    if (n <= 0)
+      return 50;
+    let st = this.meanReversionSites.get(`${site}:${n}`);
+    if (st === undefined) {
+      st = { countClose: 0, countSma: 0 };
+      this.meanReversionSites.set(`${site}:${n}`, st);
+    }
+    st.countClose += 1;
+    st.countSma += 1;
+    if (st.countClose < n || st.countSma < n)
+      return 50;
+    const c = finiteCell2(close) ?? 100;
+    const s = finiteCell2(sma) ?? 100;
+    const sd = finiteCell2(stdev) ?? 1;
+    if (sd === 0)
+      return 50;
+    return Math.max(0, Math.min(100, Math.min(100, Math.abs(c - s) / sd * 20)));
+  }
+  marketCondition(site, close, atr, smaPeriod, stdevPeriod) {
+    const smaN = this.coerceTaInt(smaPeriod, "sma period must be integer");
+    const stdevN = this.coerceTaInt(stdevPeriod, "stdev period must be integer");
+    if (smaN <= 0 || stdevN <= 0)
+      return "ranging";
+    const win = Math.max(smaN, stdevN);
+    const key = `${site}:${smaN}:${stdevN}`;
+    let st = this.marketConditionSites.get(key);
+    if (st === undefined) {
+      st = { window: [], atr: null };
+      this.marketConditionSites.set(key, st);
+    }
+    pushCap(st.window, finiteCell2(close), win);
+    st.atr = finiteCell2(atr);
+    if (st.window.length < win)
+      return "ranging";
+    const cLast = st.window[st.window.length - 1] ?? null;
+    const currentClose = cLast ?? 0;
+    const currentAtr = st.atr ?? 1;
+    const currentSma = smaOf(st.window, smaN) ?? currentClose;
+    const stdevVal = stdevOf(st.window, stdevN);
+    if (stdevVal !== null && stdevVal > currentAtr * 1.5)
+      return "volatile";
+    if (currentClose > currentSma && currentAtr > 0.5)
+      return "trending_up";
+    if (currentClose < currentSma && currentAtr > 0.5)
+      return "trending_down";
+    return "ranging";
+  }
+  orderFlowImbalance(site, high, low, close, volume, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    if (n <= 0)
+      return 0;
+    const key = `${site}:${n}`;
+    let st = this.orderFlowSites.get(key);
+    if (st === undefined) {
+      st = { highs: [], lows: [], closes: [], volumes: [] };
+      this.orderFlowSites.set(key, st);
+    }
+    pushCap(st.highs, finiteCell2(high), n);
+    pushCap(st.lows, finiteCell2(low), n);
+    pushCap(st.closes, finiteCell2(close), n);
+    pushCap(st.volumes, finiteCell2(volume), n);
+    if (st.highs.length < n || st.lows.length < n)
+      return 0;
+    let buy = 0;
+    let sell = 0;
+    for (let i = 0;i < n; i++) {
+      const h = st.highs[i] ?? 0;
+      const l = st.lows[i] ?? 0;
+      const c = st.closes[i] ?? 0;
+      const v = st.volumes[i] ?? 0;
+      if (h > l) {
+        const mid = (h + l) / 2;
+        if (c > mid)
+          buy += v;
+        else
+          sell += v;
+      }
+    }
+    const total = buy + sell;
+    if (total === 0)
+      return 0;
+    return finiteOut2((buy - sell) / total) ?? 0;
+  }
+  liquidityScore(site, volume, volatility, spread, period) {
+    const n = this.coerceTaInt(period, "period must be integer");
+    if (n <= 0)
+      return 50;
+    const key = `${site}:${n}`;
+    let st = this.liquiditySites.get(key);
+    if (st === undefined) {
+      st = { volume: [], volatility: [], spread: [] };
+      this.liquiditySites.set(key, st);
+    }
+    pushCap(st.volume, finiteCell2(volume), n);
+    pushCap(st.volatility, finiteCell2(volatility), n);
+    pushCap(st.spread, finiteCell2(spread), n);
+    if (st.volume.length < n || st.volatility.length < n || st.spread.length < n)
+      return 50;
+    let volSum = 0;
+    for (const v of st.volume)
+      if (v !== null)
+        volSum += v;
+    let volaSum = 0;
+    for (const v of st.volatility)
+      if (v !== null)
+        volaSum += v;
+    let spreadSum = 0;
+    for (const v of st.spread)
+      if (v !== null)
+        spreadSum += v;
+    const volScore = Math.min(100, volSum / n / 100);
+    const volatilityScore = Math.max(0, 100 - volaSum / n * 50);
+    const spreadScore = Math.max(0, 100 - spreadSum / n * 100);
+    const liquidity = volScore * 0.4 + volatilityScore * 0.3 + spreadScore * 0.3;
+    return Math.max(0, Math.min(100, liquidity));
+  }
+  fearGreedIndex(rsi, vix, putCall, breadth) {
+    const r = finiteCell2(rsi) ?? 50;
+    const v = finiteCell2(vix) ?? 2;
+    const pc = finiteCell2(putCall) ?? 1;
+    const b = finiteCell2(breadth) ?? 0.5;
+    const index = ((r - 50) * 1 + (v - 2) * 10 + (1 - pc) * 50 + (b - 0.5) * 100) / 4;
+    return Math.max(-100, Math.min(100, index));
+  }
+  crowdSentiment(priceAgreement, volumeAgreement, timeAgreement) {
+    const p = finiteCell2(priceAgreement) ?? 0.5;
+    const v = finiteCell2(volumeAgreement) ?? 0.5;
+    const t = finiteCell2(timeAgreement) ?? 0.5;
+    return Math.max(0, Math.min(100, (p + v + t) / 3 * 100));
+  }
+  smartMoneyFlow(priceChange, volume, timeHigh, timeLow) {
+    const p = finiteCell2(priceChange) ?? 0;
+    const v = finiteCell2(volume) ?? 1000;
+    const th = finiteCell2(timeHigh) ?? 10;
+    const tl = finiteCell2(timeLow) ?? 10;
+    const volFactor = Math.min(1, v / 5000);
+    let flow = 0;
+    if (p > 0 && th < tl)
+      flow = volFactor * 0.8;
+    else if (p < 0 && tl < th)
+      flow = -volFactor * 0.8;
+    return Math.max(-1, Math.min(1, flow));
+  }
+  trendConfirmationScore(momentum, trendAlignment, strength, rsi, rsiAlignment) {
+    const m = finiteCell2(momentum) ?? 0;
+    const t = finiteCell2(trendAlignment) ?? 0;
+    const s = finiteCell2(strength) ?? 1;
+    const r = finiteCell2(rsi) ?? 50;
+    const a = finiteCell2(rsiAlignment) ?? 0;
+    const momentumScore = Math.min(100, Math.abs(m) * 20);
+    const trendScore = Math.max(0, (t + 1) / 2 * 100);
+    const strengthScore = Math.min(100, s * 50);
+    const rsiScore = Math.abs(r - 50) > 10 ? Math.min(100, Math.abs(r - 50) * 2) : 40;
+    const alignmentBonus = Math.abs(a) > 0.5 ? 20 : 0;
+    const total = momentumScore * 0.25 + trendScore * 0.3 + strengthScore * 0.25 + rsiScore * 0.15 + alignmentBonus;
+    return Math.max(0, Math.min(100, total));
+  }
+  maxLossLevel(entry, account, maxLossPct) {
+    const e = finiteCell2(entry) ?? 100;
+    const a = finiteCell2(account) ?? 1e4;
+    const p = finiteCell2(maxLossPct) ?? 1;
+    const maxLossAmount = a * (p / 100);
+    if (e <= 0)
+      return 0;
+    const shares = a / e;
+    const stop = shares > 0 ? e - maxLossAmount / shares : 0;
+    return Math.max(0, stop);
+  }
+  profitLockLevel(entry, current, trailPct, direction) {
+    const e = finiteCell2(entry) ?? 100;
+    const c = finiteCell2(current) ?? 100;
+    const t = Math.max(0, Math.min(1, finiteCell2(trailPct) ?? 0.05));
+    const d = finiteCell2(direction) ?? 1;
+    return d > 0 ? Math.max(e * 0.9, c - c * t) : Math.min(e * 1.1, c + c * t);
+  }
+  positionSizing(account, riskPct, entry, stop) {
+    const a = finiteCell2(account) ?? 1e4;
+    const r = finiteCell2(riskPct) ?? 0.01;
+    const e = finiteCell2(entry) ?? 100;
+    const s = finiteCell2(stop) ?? 95;
+    const riskAmount = a * (r / 100);
+    const distance = e - s;
+    if (Math.abs(distance) < 0.0000000001)
+      return 0;
+    return Math.max(0, riskAmount / Math.abs(distance));
+  }
+  kellyCriterion(winRate, avgWin, avgLoss) {
+    const wr = Math.max(0, Math.min(1, finiteCell2(winRate) ?? 0.5));
+    const win = finiteCell2(avgWin) ?? 1;
+    const loss = finiteCell2(avgLoss) ?? 1;
+    if (Math.abs(win) < 0.0000000001)
+      return 0;
+    const kelly = (wr * win - (1 - wr) * loss) / win;
+    return Math.max(0, kelly);
+  }
+  riskRewardRatio(entry, stop, target) {
+    const e = finiteCell2(entry) ?? 0;
+    const s = finiteCell2(stop) ?? 0;
+    const t = finiteCell2(target) ?? 0;
+    const risk = e - s;
+    if (Math.abs(risk) < 0.0000000001)
+      return null;
+    return finiteOut2((t - e) / risk);
+  }
+  riskRewardAsymmetry(entry, stop, target, winRate) {
+    const e = finiteCell2(entry) ?? 0;
+    const s = finiteCell2(stop) ?? 0;
+    const t = finiteCell2(target) ?? 0;
+    const wr = finiteCell2(winRate) ?? 0.5;
+    const risk = Math.abs(e - s);
+    const reward = Math.abs(t - e);
+    const ratio = risk > 0 ? reward / risk : 0;
+    const ev = wr * reward - (1 - wr) * risk;
+    const kelly = ratio > 0 ? wr - (1 - wr) / ratio : 0;
+    return taRec({
+      ratio: finiteOut2(ratio) ?? 0,
+      expected_value: finiteOut2(ev) ?? 0,
+      kelly_percent: finiteOut2(kelly * 100) ?? 0,
+      is_favorable: ev > 0,
+      risk_reward_ratio: finiteOut2(ratio) ?? 0,
+      kelly_percentage: finiteOut2(kelly * 100) ?? 0
+    });
+  }
+  probabilityOfMovement(current, target, atr, period) {
+    const c = finiteCell2(current) ?? 100;
+    const t = finiteCell2(target) ?? 100;
+    const a = finiteCell2(atr) ?? 1;
+    const n = this.coerceTaInt(period, "period must be integer");
+    if (Math.abs(c) < 0.0000000001 || Math.abs(a) < 0.0000000001)
+      return 0.5;
+    const distance = Math.abs(t - c);
+    const expected = a * Math.sqrt(n);
+    if (expected === 0)
+      return 0.5;
+    return Math.max(0, Math.min(1, Math.min(1, distance / expected) * 0.8 + 0.1));
+  }
+  trendStrength(price, adx, rsi) {
+    const a = finiteCell2(adx) ?? 20;
+    const r = finiteCell2(rsi) ?? 50;
+    const adxNorm = Math.min(100, Math.max(0, a));
+    const rsiExtremeness = Math.abs(r - 50) / 50;
+    return Math.min(100, Math.max(0, adxNorm * 0.6 + rsiExtremeness * 40));
+  }
+  breakevenLevel(entry, qty, commission, slippage, direction) {
+    const e = finiteCell2(entry) ?? 0;
+    const q = finiteCell2(qty) ?? 0;
+    const comm = finiteCell2(commission) ?? 0;
+    const slip = finiteCell2(slippage) ?? 0;
+    const d = finiteCell2(direction) ?? 1;
+    const cost = comm + slip * q;
+    const impact = q > 0 ? cost / q : 0;
+    const breakeven = d >= 0 ? e + impact : e - impact;
+    const move = e > 0 ? Math.abs(breakeven - e) / e * 100 : 0;
+    return taRec({
+      breakeven_price: finiteOut2(breakeven) ?? 0,
+      total_cost: finiteOut2(cost) ?? 0,
+      move_required_percent: finiteOut2(move) ?? 0
+    });
+  }
+  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;
+    const v = finiteCell2(volatility) ?? 0;
+    const c = finiteCell2(conviction) ?? 0;
+    const corr = finiteCell2(correlation) ?? 0;
+    let score = r / (v + 0.1) * c * (1 - corr);
+    score = Math.max(0, Math.min(1, score * 0.1));
+    return taRec({
+      score: finiteOut2(score * 100) ?? 0,
+      position_size_ratio: finiteOut2(score) ?? 0,
+      kelly_fraction: finiteOut2(score * 0.5) ?? 0,
+      correlation_adjustment: finiteOut2(1 - corr) ?? 0
+    });
+  }
+  trailingExitLevel(entry, current, atr, mult, step) {
+    const e = finiteCell2(entry) ?? 0;
+    const c = finiteCell2(current) ?? 0;
+    const a = finiteCell2(atr) ?? 0;
+    const m = finiteCell2(mult) ?? 0;
+    finiteCell2(step);
+    const trail = c > e ? Math.max(e * 1.001, c - a * m) : c + a * m;
+    return taRec({
+      trail_stop: finiteOut2(trail) ?? 0,
+      protected_profit: c > e ? finiteOut2(Math.max(0, c - e)) ?? 0 : 0,
+      risk_reward_current: a > 0 ? finiteOut2(Math.abs(c - e) / a) ?? 0 : 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,
+      optimal: c,
+      entry_zone_low: finiteOut2(c * 0.99) ?? 0,
+      entry_zone_high: finiteOut2(c * 1.01) ?? 0,
+      best_entry: c,
+      zone_strength: 85
+    });
+  }
+  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({
+      entry_price: 100,
+      stop_loss: 95,
+      take_profit: 105,
+      probability: 0.7,
+      reversion_probability: 0.75,
+      target_price: 105,
+      z_score: finiteOut2(z) ?? 0,
+      is_mean_reversion_setup: Math.abs(z) > th
+    });
+  }
+  multiTimeframeSignal(s1, s2, s3, w1, w2, w3) {
+    const score = (finiteCell2(s1) ?? 0) * (finiteCell2(w1) ?? 0) + (finiteCell2(s2) ?? 0) * (finiteCell2(w2) ?? 0) + (finiteCell2(s3) ?? 0) * (finiteCell2(w3) ?? 0);
+    return taRec({ score: finiteOut2(score) ?? 0, signal: score > 0.5 ? "buy" : "sell", agreement: true });
+  }
+  marketTimingIndex(trend, momentum, volatility, sentiment) {
+    const t = finiteCell2(trend) ?? 0;
+    const m = finiteCell2(momentum) ?? 0;
+    const v = finiteCell2(volatility) ?? 0;
+    const s = finiteCell2(sentiment) ?? 0;
+    const score = t * 0.3 + m * 0.3 + v * 0.2 + s * 0.2;
+    let recommendation = "hold";
+    if (score > 80)
+      recommendation = "strong_buy";
+    else if (score > 60)
+      recommendation = "buy";
+    else if (score < 20)
+      recommendation = "strong_sell";
+    else if (score < 40)
+      recommendation = "sell";
+    return taRec({
+      score: finiteOut2(score) ?? 0,
+      recommendation,
+      regime: Math.abs(t) > 50 ? "trending" : "ranging",
+      timing_index: finiteOut2(score) ?? 0,
+      market_condition: score > 80 ? "optimal_long" : "neutral",
+      confidence: 0.85
+    });
+  }
+  regimeAdaptiveSignal(strength, volRegime, trendRegime) {
+    const vol = typeof volRegime === "string" ? volRegime : "";
+    const trend = typeof trendRegime === "string" ? trendRegime : "";
+    let adapted = finiteCell2(strength) ?? 0;
+    let fit = 1;
+    if (vol === "high") {
+      adapted *= 0.8;
+      fit *= 0.8;
+    }
+    if (trend === "ranging") {
+      adapted *= 0.5;
+      fit *= 0.5;
+    }
+    return taRec({
+      signal: adapted > 0.5 ? "buy" : "sell",
+      strength: finiteOut2(adapted) ?? 0,
+      confidence: finiteOut2(adapted * 100) ?? 0,
+      adapted_signal: finiteOut2(adapted) ?? 0,
+      regime_fit: finiteOut2(fit) ?? 0,
+      strategy_recommendation: trend === "trending" ? "trend_following" : "mean_reversion",
+      signal_confidence: finiteOut2(adapted) ?? 0
+    });
+  }
+  strategyScore(rsi, macd, emaCross, trend) {
+    const r = finiteCell2(rsi) ?? 50;
+    const m = finiteCell2(macd) ?? 0;
+    const cross = emaCross != null && emaCross !== 0;
+    const t = finiteCell2(trend) ?? 50;
+    const rsiNorm = (r - 50) / 50 * 25;
+    const macdNorm = Math.max(-25, Math.min(25, m * 50));
+    const emaBonus = cross ? 25 : -25;
+    const trendNorm = (t - 50) / 50 * 25;
+    return Math.max(-100, Math.min(100, rsiNorm + macdNorm + emaBonus + trendNorm));
+  }
+  breakoutDetection(close, resistance, support) {
+    const c = finiteCell2(close) ?? 0;
+    const r = finiteCell2(resistance) ?? 0;
+    const s = finiteCell2(support) ?? 0;
+    if (c > r) {
+      const strength = r > 0 ? (c - r) / r * 100 : 0;
+      return taRec({
+        is_breakout: true,
+        breakout_type: "resistance",
+        breakout_strength: finiteOut2(strength) ?? 0
+      });
+    }
+    if (c < s) {
+      const strength = s > 0 ? (s - c) / s * 100 : 0;
+      return taRec({
+        is_breakout: true,
+        breakout_type: "support",
+        breakout_strength: finiteOut2(strength) ?? 0
+      });
+    }
+    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;
+  }
   volumeProfileHigh(prices, volumes) {
     if (prices.length === 0 || volumes.length === 0 || prices.length !== volumes.length)
       return 0;
@@ -42774,19 +44261,27 @@ class TaEngine {
     const sens = Number.isFinite(sensitivity) ? sensitivity : 0.3;
     let st = this.volThrustSites.get(site);
     if (st === undefined) {
-      st = { close: [], volume: [], sma: [] };
+      st = { closes: [], volume: null, sma: null, nClose: 0, nVolume: 0, nSma: 0 };
       this.volThrustSites.set(site, st);
     }
-    this.pushChrono(st.close, close);
-    this.pushChrono(st.volume, volume);
-    this.pushChrono(st.sma, volSma);
-    if (st.close.length === 0 || st.volume.length === 0 || st.sma.length === 0)
+    if (!(close === null && st.nClose === 0)) {
+      pushCap(st.closes, finiteCell2(close), 2);
+      st.nClose += 1;
+    }
+    if (!(volume === null && st.nVolume === 0)) {
+      st.volume = finiteCell2(volume);
+      st.nVolume += 1;
+    }
+    if (!(volSma === null && st.nSma === 0)) {
+      st.sma = finiteCell2(volSma);
+      st.nSma += 1;
+    }
+    if (st.nClose < 1 || st.nVolume < 1 || st.nSma < 1)
       return 0;
-    const numOr = (v, fallback) => v !== null && Number.isFinite(v) ? v : fallback;
-    const cVal = numOr(this.nf(st.close, -1), 100);
-    const cPrev = st.close.length > 1 ? numOr(this.nf(st.close, -2), 100) : 100;
-    const vVal = numOr(this.nf(st.volume, -1), 1000);
-    const vsVal = numOr(this.nf(st.sma, -1), 1000);
+    const cVal = st.closes[st.closes.length - 1] ?? 100;
+    const cPrev = st.closes.length > 1 ? st.closes[st.closes.length - 2] ?? 100 : 100;
+    const vVal = st.volume ?? 1000;
+    const vsVal = st.sma ?? 1000;
     const spike = vVal > vsVal * (1 + sens);
     const move = cPrev !== 0 ? Math.abs(cVal - cPrev) / cPrev > 0.01 : false;
     return spike && move ? 1 : 0;
@@ -43279,7 +44774,63 @@ var TA_METHODS = new Set([
   "volume_momentum",
   "volume_profile_high",
   "volume_profile_low",
-  "volume_thrust"
+  "volume_thrust",
+  "sma_weighted",
+  "apo",
+  "atr_normalized",
+  "beta",
+  "r_squared",
+  "comovement",
+  "skewness",
+  "kurtosis",
+  "volume_weighted_momentum",
+  "parkinson",
+  "garman_klass",
+  "mean_reversion_score",
+  "market_condition",
+  "order_flow_imbalance",
+  "liquidity_score",
+  "fear_greed_index",
+  "crowd_sentiment",
+  "smart_money_flow",
+  "trend_confirmation_score",
+  "max_loss_level",
+  "profit_lock_level",
+  "position_sizing",
+  "kelly_criterion",
+  "risk_reward_ratio",
+  "risk_reward_asymmetry",
+  "probability_of_movement",
+  "trend_strength",
+  "breakeven_level",
+  "market_structure_pivot",
+  "position_sizing_score",
+  "trailing_exit_level",
+  "optimal_entry_zone",
+  "mean_reversion_entry",
+  "multi_timeframe_signal",
+  "market_timing_index",
+  "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"
 ]);
 var TA_BARE_ATTRS = new Set([
   "accdist",
@@ -43467,6 +45018,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"`);
   }
@@ -43624,6 +45182,23 @@ function hasArg(args, index, names) {
   }
   return index >= 0 && index < args.pos.length;
 }
+var BARE_SERIES_NAMES = new Set([
+  "open",
+  "high",
+  "low",
+  "close",
+  "volume",
+  "hl2",
+  "hlc3",
+  "ohlc4",
+  "hlcc4",
+  "time",
+  "time_close"
+]);
+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 hasAnyKw(args, names) {
   return names.some((n) => Object.hasOwn(args.kw, n));
 }
@@ -43636,9 +45211,15 @@ 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)]; })()`;
 }
+function cellLast(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(); return __n === 0 ? null : __cell(__v.get(__n - 1)); } return __cell(__v); })()`;
+}
 var DRAW_KINDS = new Set(["label", "line", "box", "table", "polyline", "linefill"]);
 var ARRAY_SIGS = {
   new: [["size"], ["initial_value", "initial"]],
@@ -44018,6 +45599,8 @@ function emitDraw(ctx, name, methodSrc, args) {
       code = `__h.draw.box_new(__bar_idx, ${pick(args, 0, ["left"], "0")}, ${pick(args, 1, ["top"], "0")}, ${pick(args, 2, ["right"], "0")}, ${pick(args, 3, ["bottom"], "0")})`;
     } else if (kind === "polyline") {
       code = `__h.draw.polyline_new(__bar_idx, ${pick(args, 0, ["points"], "null")})`;
+    } else if (kind === "table") {
+      code = `__h.draw.table_new(__bar_idx, ${pick(args, 0, ["position"], "null")}, ${pick(args, 1, ["columns"], "null")}, ${pick(args, 2, ["rows"], "null")}, ${pick(args, 3, ["bgcolor"], "null")}, ${pick(args, 4, ["frame_color"], "null")}, ${pick(args, 5, ["frame_width"], "null")}, ${pick(args, 6, ["border_color"], "null")}, ${pick(args, 7, ["border_width"], "null")}, ${pick(args, 8, ["force_overlay"], "null")})`;
     } else if (kind === "linefill") {
       const color = hasArg(args, 2, ["color"]) ? pick(args, 2, ["color"], "null") : "null";
       code = `__h.draw.linefill_new(__bar_idx, ${pick(args, 0, ["id1", "line1"], "null")}, ${pick(args, 1, ["id2", "line2"], "null")}, ${color})`;
@@ -44640,6 +46223,9 @@ function allocSite(ctx) {
 function taCall(method, site, parts) {
   return `__h.ta.${method}(${site}, ${parts.join(", ")})`;
 }
+function taPure(method, parts) {
+  return `__h.ta.${method}(${parts.join(", ")})`;
+}
 function emitTa(ctx, method, args) {
   if (!TA_METHODS.has(method))
     return "null";
@@ -45063,16 +46649,30 @@ function emitTa(ctx, method, args) {
     ]);
   }
   if (method === "stoch_smooth") {
-    return `__h.ta.stochSmooth(${cellOf(pick(args, 0, ["high"], "null"))}, ${cellOf(pick(args, 1, ["low"], "null"))}, ${cellOf(pick(args, 2, ["close"], "null"))}, ${cellOf(pick(args, 3, ["period", "length"], "null"))}, ${cellOf(pick(args, 4, ["smooth_k", "k"], "null"))}, ${cellOf(pick(args, 5, ["smooth_d", "d"], "null"))})`;
+    return taCall("stochSmooth", site, [
+      cellOf(pick(args, 0, ["high"], "null")),
+      cellOf(pick(args, 1, ["low"], "null")),
+      cellOf(pick(args, 2, ["close"], "null")),
+      cellOf(pick(args, 3, ["period", "length"], "null")),
+      cellOf(pick(args, 4, ["smooth_k", "k"], "null")),
+      cellOf(pick(args, 5, ["smooth_d", "d"], "null"))
+    ]);
   }
   if (method === "engulfing") {
-    return `(() => { ${cellOf(pick(args, 0, ["open"], "null"))}; ${cellOf(pick(args, 1, ["high"], "null"))}; ${cellOf(pick(args, 2, ["low"], "null"))}; ${cellOf(pick(args, 3, ["close"], "null"))}; return __h.ta.engulfing(); })()`;
+    return `(() => { const __o = ${cellOf(pick(args, 0, ["open"], "null"))}; ${cellOf(pick(args, 1, ["high"], "null"))}; ${cellOf(pick(args, 2, ["low"], "null"))}; const __c = ${cellOf(pick(args, 3, ["close"], "null"))}; return __h.ta.engulfing(${site}, __o, __c); })()`;
   }
   if (method === "inside_bar_pattern") {
-    return `(() => { ${cellOf(pick(args, 0, ["high"], "null"))}; ${cellOf(pick(args, 1, ["low"], "null"))}; return __h.ta.insideBarPattern(); })()`;
+    return taCall("insideBarPattern", site, [
+      cellOf(pick(args, 0, ["high"], "null")),
+      cellOf(pick(args, 1, ["low"], "null"))
+    ]);
   }
   if (method === "double_top_bottom") {
-    return `(() => { ${cellOf(pick(args, 0, ["high"], "null"))}; ${cellOf(pick(args, 1, ["low"], "null"))}; return __h.ta.doubleTopBottom(${cellOf(pick(args, 2, ["period", "length"], "null"))}); })()`;
+    return taCall("doubleTopBottom", site, [
+      cellOf(pick(args, 0, ["high"], "null")),
+      cellOf(pick(args, 1, ["low"], "null")),
+      cellOf(pick(args, 2, ["period", "length"], "null"))
+    ]);
   }
   if (method === "voi") {
     return `__h.ta.voi(${cellOf(pick(args, 0, ["buy_volume", "buy"], "null"))}, ${cellOf(pick(args, 1, ["sell_volume", "sell"], "null"))})`;
@@ -45085,7 +46685,10 @@ function emitTa(ctx, method, args) {
   }
   if (method === "rsi_divergence") {
     const period = `((__n) => (__n == null ? 0 : __n))(${cellOf(pick(args, 1, ["period", "length"], "null"))})`;
-    return `__h.ta.rsiDivergence(${cellList(pick(args, 0, ["rsi_series", "series", "source"], "null"))}, ${period})`;
+    return taCall("rsiDivergence", site, [
+      cellLast(pick(args, 0, ["rsi_series", "series", "source"], "null")),
+      period
+    ]);
   }
   if (method === "cumulative_delta") {
     return taCall("cumulativeDelta", site, [
@@ -45120,6 +46723,368 @@ function emitTa(ctx, method, args) {
       `((__n) => (__n == null ? 0.3 : __n))(${sens})`
     ]);
   }
+  if (method === "sma_weighted") {
+    return taCall("smaWeighted", site, [
+      cellOf(pick(args, 0, ["series", "source"], "null")),
+      cellOf(pick(args, 1, ["period", "length"], "null")),
+      pick(args, 2, ["weight_type", "weight"], '"linear"')
+    ]);
+  }
+  if (method === "apo") {
+    return taCall("apo", site, [
+      cellOf(pick(args, 0, ["series", "source"], "null")),
+      cellOf(pick(args, 1, ["fast_period", "fast"], "null")),
+      cellOf(pick(args, 2, ["slow_period", "slow"], "null"))
+    ]);
+  }
+  if (method === "atr_normalized") {
+    return taCall("atrNormalized", site, [
+      cellOf(pick(args, 0, ["high"], "null")),
+      cellOf(pick(args, 1, ["low"], "null")),
+      cellOf(pick(args, 2, ["close"], "null")),
+      cellOf(pick(args, 3, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "beta" || method === "r_squared" || method === "comovement") {
+    const fn = method === "beta" ? "beta" : method === "r_squared" ? "rSquared" : "comovement";
+    return taCall(fn, site, [
+      cellOf(pick(args, 0, ["series1", "series", "source"], "null")),
+      cellOf(pick(args, 1, ["series2", "series_b", "other"], "null")),
+      cellOf(pick(args, 2, ["length", "period"], "null"))
+    ]);
+  }
+  if (method === "skewness" || method === "kurtosis") {
+    return taCall(method, site, [
+      cellOf(pick(args, 0, ["series", "source"], "null")),
+      cellOf(pick(args, 1, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "volume_weighted_momentum") {
+    return taCall("volumeWeightedMomentum", site, [
+      cellOf(pick(args, 0, ["series", "source"], "null")),
+      cellOf(pick(args, 1, ["volume"], "null")),
+      cellOf(pick(args, 2, ["length", "period"], "null"))
+    ]);
+  }
+  if (method === "parkinson") {
+    if (hasSeriesArg(args))
+      return "null";
+    return `__h.ta.parkinson(${cellOf(pick(args, 0, ["high"], "null"))}, ${cellOf(pick(args, 1, ["low"], "null"))})`;
+  }
+  if (method === "garman_klass") {
+    if (hasSeriesArg(args))
+      return "null";
+    return `__h.ta.garmanKlass(${cellOf(pick(args, 0, ["high"], "null"))}, ${cellOf(pick(args, 1, ["low"], "null"))}, ${cellOf(pick(args, 2, ["close"], "null"))}, ${cellOf(pick(args, 3, ["open"], "null"))})`;
+  }
+  if (method === "mean_reversion_score") {
+    return taCall("meanReversionScore", site, [
+      cellOf(pick(args, 0, ["close", "source"], "null")),
+      cellOf(pick(args, 1, ["sma"], "null")),
+      cellOf(pick(args, 2, ["stdev", "std_dev"], "null")),
+      cellOf(pick(args, 3, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "market_condition") {
+    return taCall("marketCondition", site, [
+      cellOf(pick(args, 0, ["close", "source"], "null")),
+      cellOf(pick(args, 1, ["atr"], "null")),
+      cellOf(pick(args, 2, ["sma_period", "sma_length"], "null")),
+      cellOf(pick(args, 3, ["stdev_period", "stdev_length"], "null"))
+    ]);
+  }
+  if (method === "order_flow_imbalance") {
+    return taCall("orderFlowImbalance", site, [
+      cellOf(pick(args, 0, ["high"], "null")),
+      cellOf(pick(args, 1, ["low"], "null")),
+      cellOf(pick(args, 2, ["close"], "null")),
+      cellOf(pick(args, 3, ["volume"], "null")),
+      cellOf(pick(args, 4, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "liquidity_score") {
+    return taCall("liquidityScore", site, [
+      cellOf(pick(args, 0, ["volume"], "null")),
+      cellOf(pick(args, 1, ["volatility"], "null")),
+      cellOf(pick(args, 2, ["spread"], "null")),
+      cellOf(pick(args, 3, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "fear_greed_index") {
+    return `__h.ta.fearGreedIndex(${cellOf(pick(args, 0, ["rsi"], "null"))}, ${cellOf(pick(args, 1, ["vix"], "null"))}, ${cellOf(pick(args, 2, ["put_call", "put_call_ratio"], "null"))}, ${cellOf(pick(args, 3, ["breadth"], "null"))})`;
+  }
+  if (method === "crowd_sentiment") {
+    return `__h.ta.crowdSentiment(${cellOf(pick(args, 0, ["price_agreement", "price"], "null"))}, ${cellOf(pick(args, 1, ["volume_agreement", "volume"], "null"))}, ${cellOf(pick(args, 2, ["time_agreement", "time"], "null"))})`;
+  }
+  if (method === "smart_money_flow") {
+    return `__h.ta.smartMoneyFlow(${cellOf(pick(args, 0, ["price_change"], "null"))}, ${cellOf(pick(args, 1, ["volume"], "null"))}, ${cellOf(pick(args, 2, ["time_since_high", "time_high"], "null"))}, ${cellOf(pick(args, 3, ["time_since_low", "time_low"], "null"))})`;
+  }
+  if (method === "trend_confirmation_score") {
+    return `__h.ta.trendConfirmationScore(${cellOf(pick(args, 0, ["momentum"], "null"))}, ${cellOf(pick(args, 1, ["trend_alignment"], "null"))}, ${cellOf(pick(args, 2, ["strength"], "null"))}, ${cellOf(pick(args, 3, ["rsi"], "null"))}, ${cellOf(pick(args, 4, ["rsi_alignment"], "null"))})`;
+  }
+  if (method === "max_loss_level") {
+    return `__h.ta.maxLossLevel(${cellOf(pick(args, 0, ["entry", "entry_price"], "null"))}, ${cellOf(pick(args, 1, ["account", "account_size"], "null"))}, ${cellOf(pick(args, 2, ["max_loss_pct", "max_loss_percent"], "null"))})`;
+  }
+  if (method === "profit_lock_level") {
+    return `__h.ta.profitLockLevel(${cellOf(pick(args, 0, ["entry", "entry_price"], "null"))}, ${cellOf(pick(args, 1, ["current", "current_price"], "null"))}, ${cellOf(pick(args, 2, ["trail_pct", "trail_percent"], "null"))}, ${cellOf(pick(args, 3, ["direction"], "null"))})`;
+  }
+  if (method === "position_sizing") {
+    return taPure("positionSizing", [
+      cellOf(pick(args, 0, ["account", "account_size"], "null")),
+      cellOf(pick(args, 1, ["risk_pct", "risk_percent"], "null")),
+      cellOf(pick(args, 2, ["entry", "entry_price"], "null")),
+      cellOf(pick(args, 3, ["stop", "stop_price"], "null"))
+    ]);
+  }
+  if (method === "kelly_criterion") {
+    return taPure("kellyCriterion", [
+      cellOf(pick(args, 0, ["win_rate"], "null")),
+      cellOf(pick(args, 1, ["avg_win"], "null")),
+      cellOf(pick(args, 2, ["avg_loss"], "null"))
+    ]);
+  }
+  if (method === "risk_reward_ratio") {
+    return taPure("riskRewardRatio", [
+      cellOf(pick(args, 0, ["entry", "entry_price"], "null")),
+      cellOf(pick(args, 1, ["stop", "stop_price"], "null")),
+      cellOf(pick(args, 2, ["target", "target_price"], "null"))
+    ]);
+  }
+  if (method === "risk_reward_asymmetry") {
+    return taPure("riskRewardAsymmetry", [
+      cellOf(pick(args, 0, ["entry", "entry_price"], "null")),
+      cellOf(pick(args, 1, ["stop", "stop_price"], "null")),
+      cellOf(pick(args, 2, ["target", "target_price"], "null")),
+      cellOf(pick(args, 3, ["win_rate"], "null"))
+    ]);
+  }
+  if (method === "probability_of_movement") {
+    return taPure("probabilityOfMovement", [
+      cellOf(pick(args, 0, ["current", "current_price"], "null")),
+      cellOf(pick(args, 1, ["target", "target_price"], "null")),
+      cellOf(pick(args, 2, ["atr"], "null")),
+      cellOf(pick(args, 3, ["period", "length"], "null"))
+    ]);
+  }
+  if (method === "trend_strength") {
+    return taPure("trendStrength", [
+      cellOf(pick(args, 0, ["price", "source"], "null")),
+      cellOf(pick(args, 1, ["adx"], "null")),
+      cellOf(pick(args, 2, ["rsi"], "null"))
+    ]);
+  }
+  if (method === "breakeven_level") {
+    return taPure("breakevenLevel", [
+      cellOf(pick(args, 0, ["entry", "entry_price"], "null")),
+      cellOf(pick(args, 1, ["quantity", "qty"], "null")),
+      cellOf(pick(args, 2, ["commission"], "null")),
+      cellOf(pick(args, 3, ["slippage"], "null")),
+      cellOf(pick(args, 4, ["direction"], "null"))
+    ]);
+  }
+  if (method === "market_structure_pivot") {
+    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") {
+    return taPure("positionSizingScore", [
+      cellOf(pick(args, 0, ["account_risk", "risk"], "null")),
+      cellOf(pick(args, 1, ["volatility"], "null")),
+      cellOf(pick(args, 2, ["conviction"], "null")),
+      cellOf(pick(args, 3, ["correlation"], "null"))
+    ]);
+  }
+  if (method === "trailing_exit_level") {
+    return taPure("trailingExitLevel", [
+      cellOf(pick(args, 0, ["entry", "entry_price"], "null")),
+      cellOf(pick(args, 1, ["current", "current_price"], "null")),
+      cellOf(pick(args, 2, ["atr"], "null")),
+      cellOf(pick(args, 3, ["multiplier", "mult"], "null")),
+      cellOf(pick(args, 4, ["step"], "null"))
+    ]);
+  }
+  if (method === "optimal_entry_zone") {
+    return taCall("optimalEntryZone", site, [arrOrCell(pick(args, 2, ["close"], "null"))]);
+  }
+  if (method === "mean_reversion_entry") {
+    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"))
+    ]);
+  }
+  if (method === "multi_timeframe_signal") {
+    return taPure("multiTimeframeSignal", [
+      cellOf(pick(args, 0, ["s1", "signal1"], "null")),
+      cellOf(pick(args, 1, ["s2", "signal2"], "null")),
+      cellOf(pick(args, 2, ["s3", "signal3"], "null")),
+      cellOf(pick(args, 3, ["w1", "weight1"], "null")),
+      cellOf(pick(args, 4, ["w2", "weight2"], "null")),
+      cellOf(pick(args, 5, ["w3", "weight3"], "null"))
+    ]);
+  }
+  if (method === "market_timing_index") {
+    return taPure("marketTimingIndex", [
+      cellOf(pick(args, 0, ["trend"], "null")),
+      cellOf(pick(args, 1, ["momentum"], "null")),
+      cellOf(pick(args, 2, ["volatility"], "null")),
+      cellOf(pick(args, 3, ["sentiment"], "null"))
+    ]);
+  }
+  if (method === "regime_adaptive_signal") {
+    return taPure("regimeAdaptiveSignal", [
+      cellOf(pick(args, 0, ["signal_strength", "strength"], "null")),
+      pick(args, 1, ["volatility_regime", "vol_regime"], '""'),
+      pick(args, 2, ["trend_regime"], '""')
+    ]);
+  }
+  if (method === "strategy_score") {
+    return taPure("strategyScore", [
+      cellOf(pick(args, 0, ["rsi"], "null")),
+      cellOf(pick(args, 1, ["macd"], "null")),
+      cellOf(pick(args, 2, ["ema_cross"], "null")),
+      cellOf(pick(args, 3, ["trend"], "null"))
+    ]);
+  }
+  if (method === "breakout_detection") {
+    return taPure("breakoutDetection", [
+      cellOf(pick(args, 0, ["close", "source"], "null")),
+      cellOf(pick(args, 1, ["resistance"], "null")),
+      cellOf(pick(args, 2, ["support"], "null"))
+    ]);
+  }
+  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"))})`;
+  }
   return "null";
 }
 
@@ -46588,6 +48553,8 @@ function naNum(v) {
 function hold(v) {
   if (v != null && typeof v === "object")
     return v;
+  if (typeof v === "string")
+    return v;
   return naNum(v);
 }
 function pineEq(a, b) {
@@ -47280,8 +49247,23 @@ class CompileDraw {
     putNum(extra, "bottom", bottom);
     return this.book.boxNew(n3(bar, 0), Object.keys(extra).length ? extra : undefined);
   }
-  table_new(bar) {
-    return this.book.tableNew(n3(bar, 0));
+  table_new(bar, position, columns, rows, bgcolor, frameColor, frameWidth, borderColor, borderWidth, forceOverlay) {
+    const extra = {};
+    if (position != null)
+      extra.position = position;
+    putNum(extra, "columns", columns);
+    putNum(extra, "rows", rows);
+    if (bgcolor != null)
+      extra.bgcolor = bgcolor;
+    if (frameColor != null)
+      extra.frame_color = frameColor;
+    putNum(extra, "frame_width", frameWidth);
+    if (borderColor != null)
+      extra.border_color = borderColor;
+    putNum(extra, "border_width", borderWidth);
+    if (forceOverlay != null)
+      extra.force_overlay = forceOverlay;
+    return this.book.tableNew(n3(bar, 0), Object.keys(extra).length ? extra : undefined);
   }
   polyline_new(bar, points) {
     const pts = pointsOf(points);
@@ -47915,7 +49897,8 @@ class CompileStrategy {
       open: num(open, this.mark),
       high: num(high, this.mark),
       low: num(low, this.mark),
-      close: this.mark
+      close: this.mark,
+      time: this.time
     };
     this.ohlc = ohlc;
     this.book.processPending(this.bar, ohlc);
@@ -47931,17 +49914,18 @@ class CompileStrategy {
       stop: opts?.stop,
       comment: opts?.comment,
       oca_name: opts?.oca_name,
-      oca_type: opts?.oca_type
+      oca_type: opts?.oca_type,
+      deferMarket: true
     });
   }
   close(id, qty) {
-    this.book.fillClose(this.bar, str(id, ""), this.mark, {
+    this.book.placeClose(this.bar, str(id, ""), this.mark, {
       time: this.time,
       qty: optNum(qty)
     });
   }
   close_all(_comment) {
-    this.book.closeAll(this.bar, this.mark);
+    this.book.placeCloseAll(this.bar, this.mark);
   }
   order(id, direction, qty, opts) {
     this.entry(id, direction, qty, opts);
@@ -47958,7 +49942,8 @@ class CompileStrategy {
       ...parsed,
       price: this.mark,
       time: this.time,
-      ohlc: this.ohlc
+      ohlc: this.ohlc,
+      deferMarket: true
     });
   }
   position_size() {
@@ -48326,8 +50311,8 @@ function createCompileHelpers(opts) {
     second: calendarSecond,
     dayofweek: calendarDayofweek,
     timestamp,
-    weekOfYear,
-    timeTradingDay,
+    weekOfYear: calendarWeekOfYear,
+    timeTradingDay: calendarTimeTradingDay,
     timeframeInSeconds: timeframeInSecondsOrDaily,
     timeframeChange,
     timeClose,
@@ -48451,7 +50436,20 @@ function NA_FN(v) {
 function utcPart(t, key) {
   if (typeof t !== "number" || !Number.isFinite(t))
     return null;
-  return utcPartsFromMs(t)[key];
+  const ms = timestampToMs(t);
+  return ms == null ? null : utcPartsFromMs(ms)[key];
+}
+function calendarWeekOfYear(t) {
+  if (typeof t !== "number" || !Number.isFinite(t))
+    return null;
+  const ms = timestampToMs(t);
+  return ms == null ? null : weekOfYear(ms);
+}
+function calendarTimeTradingDay(t) {
+  if (typeof t !== "number" || !Number.isFinite(t))
+    return null;
+  const ms = timestampToMs(t);
+  return ms == null ? null : timeTradingDay(ms);
 }
 function calendarYear(t) {
   return utcPart(t, "year");
@@ -48885,7 +50883,8 @@ function interpretTree(tree, ohlcv, host) {
         open: num2(env.ctx.open) ?? undefined,
         high: num2(env.ctx.high) ?? undefined,
         low: num2(env.ctx.low) ?? undefined,
-        close: num2(env.ctx.close) ?? undefined
+        close: num2(env.ctx.close) ?? undefined,
+        time: num2(env.ctx.time) ?? undefined
       });
       env.book.markOpenTrades(num2(env.ctx.high) ?? num2(env.ctx.close) ?? 0, num2(env.ctx.low) ?? num2(env.ctx.close) ?? 0, num2(env.ctx.close) ?? 0);
       try {
@@ -49216,6 +51215,27 @@ function seriesGet(env, id) {
   }
   return env.series.get(id);
 }
+var BARE_SERIES_NAMES2 = new Set([
+  "open",
+  "high",
+  "low",
+  "close",
+  "volume",
+  "hl2",
+  "hlc3",
+  "ohlc4",
+  "hlcc4",
+  "time",
+  "time_close"
+]);
+function isSeriesExpr(value, env) {
+  if (value.kind === "Name") {
+    if (BARE_SERIES_NAMES2.has(value.id))
+      return true;
+    return seriesGet(env, value.id) != null;
+  }
+  return false;
+}
 function bindName(env, id, value) {
   const stored = typeof value === "number" && !Number.isFinite(value) ? NA : value;
   const frame = activeFrame(env);
@@ -50399,6 +52419,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;
@@ -50433,7 +52480,8 @@ function evalCall(node, env) {
       price: mark == null || !Number.isFinite(mark) ? undefined : mark,
       time: num2(env.ctx.time) ?? undefined,
       oca_name: evalAsString(callArg(node.args, -1, ["oca_name"]), env),
-      oca_type: evalAsString(callArg(node.args, -1, ["oca_type"]), env)
+      oca_type: evalAsString(callArg(node.args, -1, ["oca_type"]), env),
+      deferMarket: true
     });
     return NA;
   }
@@ -50442,13 +52490,10 @@ function evalCall(node, env) {
     const mark = num2(env.ctx.close);
     const qtyExpr = callArg(node.args, 1, ["qty"]);
     const qtyRaw = qtyExpr == null ? undefined : unwrap2(evalExpr(qtyExpr, env));
-    if (env.book.position.qty !== 0 && mark != null) {
-      env.book.fillClose(env.barIndex, id, mark, {
-        time: num2(env.ctx.time) ?? undefined,
-        qty: qtyRaw ?? undefined
-      });
-    } else
-      env.book.close(env.barIndex, id);
+    env.book.placeClose(env.barIndex, id, mark ?? undefined, {
+      time: num2(env.ctx.time) ?? undefined,
+      qty: qtyRaw ?? undefined
+    });
     return NA;
   }
   if (fname === "strategy.exit") {
@@ -50468,17 +52513,12 @@ function evalCall(node, env) {
       trail_offset: unwrap2(evalExpr(callArg(node.args, 10, ["trail_offset"]), env)),
       price: num2(env.ctx.close) ?? undefined,
       time: num2(env.ctx.time) ?? undefined,
-      ohlc: {
-        open: num2(env.ctx.open) ?? undefined,
-        high: num2(env.ctx.high) ?? undefined,
-        low: num2(env.ctx.low) ?? undefined,
-        close: num2(env.ctx.close) ?? undefined
-      }
+      deferMarket: true
     });
     return NA;
   }
   if (fname === "strategy.close_all") {
-    env.book.closeAll(env.barIndex, num2(env.ctx.close) ?? undefined);
+    env.book.placeCloseAll(env.barIndex, num2(env.ctx.close) ?? undefined);
     return NA;
   }
   if (fname === "strategy.cancel") {
@@ -50500,7 +52540,8 @@ function evalCall(node, env) {
       price: num2(env.ctx.close) ?? undefined,
       time: num2(env.ctx.time) ?? undefined,
       oca_name: evalAsString(callArg(node.args, -1, ["oca_name"]), env),
-      oca_type: evalAsString(callArg(node.args, -1, ["oca_type"]), env)
+      oca_type: evalAsString(callArg(node.args, -1, ["oca_type"]), env),
+      deferMarket: true
     });
     return NA;
   }
@@ -51725,12 +53766,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));
@@ -51845,12 +53886,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));
   }
@@ -51905,11 +53940,11 @@ function evalExtraTa(fname, node, env, site) {
   }
   if (fname === "ta.engulfing" || fname === "engulfing") {
     const msg = "ta.engulfing() requires 4 arguments: open, high, low, close";
-    unwrap2(evalExpr(wave10aArg(0, ["open"], msg), env));
+    const open = unwrap2(evalExpr(wave10aArg(0, ["open"], msg), env));
     unwrap2(evalExpr(wave10aArg(1, ["high"], msg), env));
     unwrap2(evalExpr(wave10aArg(2, ["low"], msg), env));
-    unwrap2(evalExpr(wave10aArg(3, ["close"], msg), env));
-    return env.ta.engulfing();
+    const close = unwrap2(evalExpr(wave10aArg(3, ["close"], msg), env));
+    return env.ta.engulfing(site, open, close);
   }
   if (fname === "ta.gap_detector" || fname === "gap_detector") {
     const msg = "ta.gap_detector() requires 3 arguments: high, low, prev_close";
@@ -51917,15 +53952,15 @@ function evalExtraTa(fname, node, env, site) {
   }
   if (fname === "ta.double_top_bottom" || fname === "double_top_bottom") {
     const msg = "ta.double_top_bottom() requires 3 arguments";
-    unwrap2(evalExpr(wave10aArg(0, ["high"], msg), env));
-    unwrap2(evalExpr(wave10aArg(1, ["low"], msg), env));
-    return env.ta.doubleTopBottom(unwrap2(evalExpr(wave10aArg(2, ["period", "length"], msg), env)));
+    const high = unwrap2(evalExpr(wave10aArg(0, ["high"], msg), env));
+    const low = unwrap2(evalExpr(wave10aArg(1, ["low"], msg), env));
+    return env.ta.doubleTopBottom(site, high, low, unwrap2(evalExpr(wave10aArg(2, ["period", "length"], msg), env)));
   }
   if (fname === "ta.inside_bar_pattern" || fname === "inside_bar_pattern") {
     const msg = "ta.inside_bar_pattern() requires 2 arguments";
-    unwrap2(evalExpr(wave10aArg(0, ["high"], msg), env));
-    unwrap2(evalExpr(wave10aArg(1, ["low"], msg), env));
-    return env.ta.insideBarPattern();
+    const high = unwrap2(evalExpr(wave10aArg(0, ["high"], msg), env));
+    const low = unwrap2(evalExpr(wave10aArg(1, ["low"], msg), env));
+    return env.ta.insideBarPattern(site, high, low);
   }
   if (fname === "ta.macd_signal" || fname === "macd_signal") {
     const msg = "ta.macd_signal() requires 2 arguments: macd_line, signal_line";
@@ -51937,7 +53972,7 @@ function evalExtraTa(fname, node, env, site) {
   }
   if (fname === "ta.stoch_smooth" || fname === "stoch_smooth") {
     const msg = "ta.stoch_smooth() requires 6 arguments: high, low, close, period, smooth_k, smooth_d";
-    return env.ta.stochSmooth(unwrap2(evalExpr(wave10aArg(0, ["high"], msg), env)), unwrap2(evalExpr(wave10aArg(1, ["low"], msg), env)), unwrap2(evalExpr(wave10aArg(2, ["close"], msg), env)), unwrap2(evalExpr(wave10aArg(3, ["period", "length"], msg), env)), unwrap2(evalExpr(wave10aArg(4, ["smooth_k", "k"], msg), env)), unwrap2(evalExpr(wave10aArg(5, ["smooth_d", "d"], msg), env)));
+    return env.ta.stochSmooth(site, unwrap2(evalExpr(wave10aArg(0, ["high"], msg), env)), unwrap2(evalExpr(wave10aArg(1, ["low"], msg), env)), unwrap2(evalExpr(wave10aArg(2, ["close"], msg), env)), unwrap2(evalExpr(wave10aArg(3, ["period", "length"], msg), env)), unwrap2(evalExpr(wave10aArg(4, ["smooth_k", "k"], msg), env)), unwrap2(evalExpr(wave10aArg(5, ["smooth_d", "d"], msg), env)));
   }
   const wave10bList = (index, names) => {
     const raw = evalExpr(callArg(node.args, index, names), env);
@@ -51962,7 +53997,7 @@ function evalExtraTa(fname, node, env, site) {
   }
   if (fname === "ta.rsi_divergence" || fname === "rsi_divergence") {
     const period = unwrap2(evalExpr(callArg(node.args, 1, ["period", "length"]), env));
-    return env.ta.rsiDivergence(wave10bList(0, ["rsi_series", "series", "source"]), period ?? 0);
+    return env.ta.rsiDivergence(site, seriesLastCell(evalExpr(callArg(node.args, 0, ["rsi_series", "series", "source"]), env)), period ?? 0);
   }
   if (fname === "ta.cumulative_delta" || fname === "cumulative_delta") {
     const period = unwrap2(evalExpr(callArg(node.args, 2, ["period", "length"]), env));
@@ -51984,6 +54019,281 @@ function evalExtraTa(fname, node, env, site) {
     const sens = unwrap2(evalExpr(callArg(node.args, 3, ["sensitivity"]), env));
     return env.ta.volumeThrust(site, unwrap2(evalExpr(callArg(node.args, 0, ["close", "source"]), env)), unwrap2(evalExpr(callArg(node.args, 1, ["volume"]), env)), unwrap2(evalExpr(callArg(node.args, 2, ["volume_sma", "vol_sma", "sma"]), env)), sens ?? 0.3);
   }
+  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"]);
+    return env.ta.smaWeighted(site, wave11n(0, ["series", "source"], msg), wave11n(1, ["period", "length"], msg), weightArg == null ? "linear" : evalExpr(weightArg, env));
+  }
+  if (fname === "ta.apo" || fname === "apo") {
+    const msg = "ta.apo() requires 3 arguments: series, fast_period, slow_period";
+    return env.ta.apo(site, wave11n(0, ["series", "source"], msg), wave11n(1, ["fast_period", "fast"], msg), wave11n(2, ["slow_period", "slow"], msg));
+  }
+  if (fname === "ta.atr_normalized" || fname === "atr_normalized") {
+    const msg = "ta.atr_normalized() requires 4 arguments: high, low, close, period";
+    return env.ta.atrNormalized(site, wave11n(0, ["high"], msg), wave11n(1, ["low"], msg), wave11n(2, ["close"], msg), wave11n(3, ["period", "length"], msg));
+  }
+  if (fname === "ta.beta" || fname === "beta") {
+    const msg = "ta.beta() requires 3 arguments: series1, series2, length";
+    return env.ta.beta(site, wave11n(0, ["series1", "series", "source"], msg), wave11n(1, ["series2", "series_b", "other"], msg), wave11n(2, ["length", "period"], msg));
+  }
+  if (fname === "ta.r_squared" || fname === "r_squared") {
+    const msg = "ta.r_squared() requires 3 arguments: series1, series2, length";
+    return env.ta.rSquared(site, wave11n(0, ["series1", "series", "source"], msg), wave11n(1, ["series2", "series_b", "other"], msg), wave11n(2, ["length", "period"], msg));
+  }
+  if (fname === "ta.comovement" || fname === "comovement") {
+    const msg = "ta.comovement() requires 3 arguments: series1, series2, length";
+    return env.ta.comovement(site, wave11n(0, ["series1", "series", "source"], msg), wave11n(1, ["series2", "series_b", "other"], msg), wave11n(2, ["length", "period"], msg));
+  }
+  if (fname === "ta.skewness" || fname === "skewness") {
+    const msg = "ta.skewness() requires 2 arguments: series, period";
+    return env.ta.skewness(site, wave11n(0, ["series", "source"], msg), wave11n(1, ["period", "length"], msg));
+  }
+  if (fname === "ta.kurtosis" || fname === "kurtosis") {
+    const msg = "ta.kurtosis() requires 2 arguments: series, period";
+    return env.ta.kurtosis(site, wave11n(0, ["series", "source"], msg), wave11n(1, ["period", "length"], msg));
+  }
+  if (fname === "ta.volume_weighted_momentum" || fname === "volume_weighted_momentum") {
+    const msg = "ta.volume_weighted_momentum() requires 3 arguments: series, volume, length";
+    return env.ta.volumeWeightedMomentum(site, wave11n(0, ["series", "source"], msg), wave11n(1, ["volume"], msg), wave11n(2, ["length", "period"], msg));
+  }
+  if (fname === "ta.parkinson" || fname === "parkinson") {
+    const msg = "ta.parkinson() requires 2 arguments: high, low";
+    const highArg = wave10aArg(0, ["high"], msg);
+    const lowArg = wave10aArg(1, ["low"], msg);
+    if (isSeriesExpr(highArg, env) || isSeriesExpr(lowArg, env))
+      return NA;
+    return env.ta.parkinson(num2(evalExpr(highArg, env)), num2(evalExpr(lowArg, env)));
+  }
+  if (fname === "ta.garman_klass" || fname === "garman_klass") {
+    const msg = "ta.garman_klass() requires 4 arguments: high, low, close, open";
+    const argsExpr = [
+      wave10aArg(0, ["high"], msg),
+      wave10aArg(1, ["low"], msg),
+      wave10aArg(2, ["close"], msg),
+      wave10aArg(3, ["open"], msg)
+    ];
+    if (argsExpr.some((a) => isSeriesExpr(a, env)))
+      return NA;
+    return env.ta.garmanKlass(num2(evalExpr(argsExpr[0], env)), num2(evalExpr(argsExpr[1], env)), num2(evalExpr(argsExpr[2], env)), num2(evalExpr(argsExpr[3], env)));
+  }
+  if (fname === "ta.mean_reversion_score" || fname === "mean_reversion_score") {
+    const msg = "ta.mean_reversion_score() requires 4 arguments";
+    return env.ta.meanReversionScore(site, wave11n(0, ["close", "source"], msg), wave11n(1, ["sma"], msg), wave11n(2, ["stdev", "std_dev"], msg), wave11n(3, ["period", "length"], msg));
+  }
+  if (fname === "ta.market_condition" || fname === "market_condition") {
+    const msg = "ta.market_condition() requires 4 arguments";
+    return env.ta.marketCondition(site, wave11n(0, ["close", "source"], msg), wave11n(1, ["atr"], msg), wave11n(2, ["sma_period", "sma_length"], msg), wave11n(3, ["stdev_period", "stdev_length"], msg));
+  }
+  if (fname === "ta.order_flow_imbalance" || fname === "order_flow_imbalance") {
+    const msg = "ta.order_flow_imbalance() requires 5 arguments";
+    return env.ta.orderFlowImbalance(site, wave11n(0, ["high"], msg), wave11n(1, ["low"], msg), wave11n(2, ["close"], msg), wave11n(3, ["volume"], msg), wave11n(4, ["period", "length"], msg));
+  }
+  if (fname === "ta.liquidity_score" || fname === "liquidity_score") {
+    const msg = "ta.liquidity_score() requires 4 arguments";
+    return env.ta.liquidityScore(site, wave11n(0, ["volume"], msg), wave11n(1, ["volatility"], msg), wave11n(2, ["spread"], msg), wave11n(3, ["period", "length"], msg));
+  }
+  if (fname === "ta.fear_greed_index" || fname === "fear_greed_index") {
+    const msg = "ta.fear_greed_index() requires 4 arguments";
+    return env.ta.fearGreedIndex(wave11n(0, ["rsi"], msg), wave11n(1, ["vix"], msg), wave11n(2, ["put_call", "put_call_ratio"], msg), wave11n(3, ["breadth"], msg));
+  }
+  if (fname === "ta.crowd_sentiment" || fname === "crowd_sentiment") {
+    const msg = "ta.crowd_sentiment() requires 3 arguments";
+    return env.ta.crowdSentiment(wave11n(0, ["price_agreement", "price"], msg), wave11n(1, ["volume_agreement", "volume"], msg), wave11n(2, ["time_agreement", "time"], msg));
+  }
+  if (fname === "ta.smart_money_flow" || fname === "smart_money_flow") {
+    const msg = "ta.smart_money_flow() requires 4 arguments";
+    return env.ta.smartMoneyFlow(wave11n(0, ["price_change"], msg), wave11n(1, ["volume"], msg), wave11n(2, ["time_since_high", "time_high"], msg), wave11n(3, ["time_since_low", "time_low"], msg));
+  }
+  if (fname === "ta.trend_confirmation_score" || fname === "trend_confirmation_score") {
+    const msg = "ta.trend_confirmation_score() requires 6 arguments";
+    wave11n(5, ["support_distance"], msg);
+    return env.ta.trendConfirmationScore(wave11n(0, ["momentum"], msg), wave11n(1, ["trend_alignment"], msg), wave11n(2, ["strength"], msg), wave11n(3, ["rsi"], msg), wave11n(4, ["rsi_alignment"], msg));
+  }
+  if (fname === "ta.max_loss_level" || fname === "max_loss_level") {
+    const msg = "ta.max_loss_level() requires 3 arguments";
+    return env.ta.maxLossLevel(wave11n(0, ["entry", "entry_price"], msg), wave11n(1, ["account", "account_size"], msg), wave11n(2, ["max_loss_pct", "max_loss_percent"], msg));
+  }
+  if (fname === "ta.profit_lock_level" || fname === "profit_lock_level") {
+    const msg = "ta.profit_lock_level() requires 4 arguments";
+    return env.ta.profitLockLevel(wave11n(0, ["entry", "entry_price"], msg), wave11n(1, ["current", "current_price"], msg), wave11n(2, ["trail_pct", "trail_percent"], msg), wave11n(3, ["direction"], msg));
+  }
+  const wave12s = (index, names, message) => evalExpr(wave10aArg(index, names, message), env);
+  if (fname === "ta.position_sizing" || fname === "position_sizing") {
+    const msg = "ta.position_sizing() requires 4 arguments";
+    return env.ta.positionSizing(wave11n(0, ["account", "account_size"], msg), wave11n(1, ["risk_pct", "risk_percent"], msg), wave11n(2, ["entry", "entry_price"], msg), wave11n(3, ["stop", "stop_price"], msg));
+  }
+  if (fname === "ta.kelly_criterion" || fname === "kelly_criterion") {
+    const msg = "ta.kelly_criterion() requires 3 arguments";
+    return env.ta.kellyCriterion(wave11n(0, ["win_rate"], msg), wave11n(1, ["avg_win"], msg), wave11n(2, ["avg_loss"], msg));
+  }
+  if (fname === "ta.risk_reward_ratio" || fname === "risk_reward_ratio") {
+    const msg = "ta.risk_reward_ratio() requires 3 arguments";
+    return env.ta.riskRewardRatio(wave11n(0, ["entry", "entry_price"], msg), wave11n(1, ["stop", "stop_price"], msg), wave11n(2, ["target", "target_price"], msg));
+  }
+  if (fname === "ta.risk_reward_asymmetry" || fname === "risk_reward_asymmetry") {
+    const msg = "ta.risk_reward_asymmetry() requires 4 arguments";
+    return env.ta.riskRewardAsymmetry(wave11n(0, ["entry", "entry_price"], msg), wave11n(1, ["stop", "stop_price"], msg), wave11n(2, ["target", "target_price"], msg), wave11n(3, ["win_rate"], msg));
+  }
+  if (fname === "ta.probability_of_movement" || fname === "probability_of_movement") {
+    const msg = "ta.probability_of_movement() requires 4 arguments";
+    return env.ta.probabilityOfMovement(wave11n(0, ["current", "current_price"], msg), wave11n(1, ["target", "target_price"], msg), wave11n(2, ["atr"], msg), wave11n(3, ["period", "length"], msg));
+  }
+  if (fname === "ta.trend_strength" || fname === "trend_strength") {
+    const msg = "ta.trend_strength() requires 3 arguments";
+    return env.ta.trendStrength(wave11n(0, ["price", "source"], msg), wave11n(1, ["adx"], msg), wave11n(2, ["rsi"], msg));
+  }
+  if (fname === "ta.breakeven_level" || fname === "breakeven_level") {
+    const msg = "ta.breakeven_level() requires 5 arguments";
+    return env.ta.breakevenLevel(wave11n(0, ["entry", "entry_price"], msg), wave11n(1, ["quantity", "qty"], msg), wave11n(2, ["commission"], msg), wave11n(3, ["slippage"], msg), wave11n(4, ["direction"], msg));
+  }
+  if (fname === "ta.market_structure_pivot" || fname === "market_structure_pivot") {
+    const msg = "ta.market_structure_pivot() 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);
+    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";
+    return env.ta.positionSizingScore(wave11n(0, ["account_risk", "risk"], msg), wave11n(1, ["volatility"], msg), wave11n(2, ["conviction"], msg), wave11n(3, ["correlation"], msg));
+  }
+  if (fname === "ta.trailing_exit_level" || fname === "trailing_exit_level") {
+    const msg = "ta.trailing_exit_level() requires 5 arguments";
+    return env.ta.trailingExitLevel(wave11n(0, ["entry", "entry_price"], msg), wave11n(1, ["current", "current_price"], msg), wave11n(2, ["atr"], msg), wave11n(3, ["multiplier", "mult"], msg), wave11n(4, ["step"], msg));
+  }
+  if (fname === "ta.optimal_entry_zone" || fname === "optimal_entry_zone") {
+    const msg = "ta.optimal_entry_zone() requires 4 arguments";
+    wave11n(0, ["high"], msg);
+    wave11n(1, ["low"], msg);
+    const close = wave13v(2, ["close"], msg);
+    wave11n(3, ["period", "length"], msg);
+    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(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";
+    return env.ta.multiTimeframeSignal(wave11n(0, ["s1", "signal1"], msg), wave11n(1, ["s2", "signal2"], msg), wave11n(2, ["s3", "signal3"], msg), wave11n(3, ["w1", "weight1"], msg), wave11n(4, ["w2", "weight2"], msg), wave11n(5, ["w3", "weight3"], msg));
+  }
+  if (fname === "ta.market_timing_index" || fname === "market_timing_index") {
+    const msg = "ta.market_timing_index() requires 4 arguments";
+    return env.ta.marketTimingIndex(wave11n(0, ["trend"], msg), wave11n(1, ["momentum"], msg), wave11n(2, ["volatility"], msg), wave11n(3, ["sentiment"], msg));
+  }
+  if (fname === "ta.regime_adaptive_signal" || fname === "regime_adaptive_signal") {
+    const msg = "ta.regime_adaptive_signal() requires 4 arguments";
+    const strength = wave11n(0, ["signal_strength", "strength"], msg);
+    const volRegime = wave12s(1, ["volatility_regime", "vol_regime"], msg);
+    const trendRegime = wave12s(2, ["trend_regime"], msg);
+    wave11n(3, ["period", "length"], msg);
+    return env.ta.regimeAdaptiveSignal(strength, volRegime, trendRegime);
+  }
+  if (fname === "ta.strategy_score" || fname === "strategy_score") {
+    const msg = "ta.strategy_score() requires 4 arguments";
+    return env.ta.strategyScore(wave11n(0, ["rsi"], msg), wave11n(1, ["macd"], msg), wave11n(2, ["ema_cross"], msg), wave11n(3, ["trend"], msg));
+  }
+  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));
+  }
+  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);
+  }
   return;
 }
 function hlc3(env) {
@@ -51994,6 +54304,28 @@ function hlc3(env) {
     return c ?? h ?? l;
   return (h + l + c) / 3;
 }
+function seriesLastCell(value) {
+  if (value instanceof PineArray) {
+    const n = value.size();
+    return n > 0 ? value.get(n - 1) : null;
+  }
+  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;
@@ -52892,8 +55224,22 @@ function evalDrawingCall(fname, node, env) {
     const position = drawRaw(node, env, 0, ["position"]);
     if (position !== undefined)
       extra.position = position;
-    putFinite(extra, "rows", drawNum(node, env, 1, ["rows"]));
-    putFinite(extra, "columns", drawNum(node, env, 2, ["columns"]));
+    putFinite(extra, "columns", drawNum(node, env, 1, ["columns"]));
+    putFinite(extra, "rows", drawNum(node, env, 2, ["rows"]));
+    const bgcolor = drawRaw(node, env, 3, ["bgcolor"]);
+    if (bgcolor !== undefined)
+      extra.bgcolor = bgcolor;
+    const frameColor = drawRaw(node, env, 4, ["frame_color"]);
+    if (frameColor !== undefined)
+      extra.frame_color = frameColor;
+    putFinite(extra, "frame_width", drawNum(node, env, 5, ["frame_width"]));
+    const borderColor = drawRaw(node, env, 6, ["border_color"]);
+    if (borderColor !== undefined)
+      extra.border_color = borderColor;
+    putFinite(extra, "border_width", drawNum(node, env, 7, ["border_width"]));
+    const forceOverlay = drawRaw(node, env, 8, ["force_overlay"]);
+    if (forceOverlay !== undefined)
+      extra.force_overlay = forceOverlay;
     return book.tableNew(env.barIndex, extra);
   }
   if (fname === "polyline.new") {
@@ -53940,8 +56286,8 @@ function syminfoPrefix2(node, env) {
 function calendarMs(node, env) {
   const arg = callArg(node.args, 0, ["time", "timestamp"]);
   if (arg == null)
-    return num2(env.ctx.time);
-  return unwrap2(evalExpr(arg, env));
+    return timestampToMs(num2(env.ctx.time));
+  return timestampToMs(unwrap2(evalExpr(arg, env)));
 }
 function evalLibraryMemberCall(mod, attr, node, env) {
   const exp = mod.get(attr);