tradelab 1.0.1 → 1.1.0

package/dist/cjs/index.cjs

@@ -30,16 +30,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.js
 var index_exports = {};
 __export(index_exports, {
+  BIG_NUMBER: () => BIG_NUMBER,
+  LlmSignal: () => LlmSignal,
   atr: () => atr,
   backtest: () => backtest,
+  backtestAsync: () => backtestAsync,
   backtestHistorical: () => backtestHistorical,
   backtestPortfolio: () => backtestPortfolio,
   backtestTicks: () => backtestTicks,
+  benchmarkStats: () => benchmarkStats,
   bpsOf: () => bpsOf,
   buildMetrics: () => buildMetrics,
   cachedCandlesPath: () => cachedCandlesPath,
   calculatePositionSize: () => calculatePositionSize,
   candleStats: () => candleStats,
+  clampFinite: () => clampFinite,
   detectFVG: () => detectFVG,
   ema: () => ema,
   exportBacktestArtifacts: () => exportBacktestArtifacts,
@@ -49,18 +54,25 @@ __export(index_exports, {
   fetchHistorical: () => fetchHistorical,
   fetchLatestCandle: () => fetchLatestCandle,
   getHistoricalCandles: () => getHistoricalCandles,
+  getStrategy: () => getStrategy,
+  grid: () => grid,
   inWindowsET: () => inWindowsET,
   isSession: () => isSession,
   lastSwing: () => lastSwing,
+  listStrategies: () => listStrategies,
   loadCandlesFromCSV: () => loadCandlesFromCSV,
   loadCandlesFromCache: () => loadCandlesFromCache,
   mergeCandles: () => mergeCandles,
   minutesET: () => minutesET,
   normalizeCandles: () => normalizeCandles,
   offsetET: () => offsetET,
+  optimize: () => optimize,
   parseWindowsCSV: () => parseWindowsCSV,
   pct: () => pct,
+  periodsPerYear: () => periodsPerYear,
+  registerStrategy: () => registerStrategy,
   renderHtmlReport: () => renderHtmlReport,
+  research: () => research_exports,
   saveCandlesToCache: () => saveCandlesToCache,
   structureState: () => structureState,
   swingHigh: () => swingHigh,
@@ -221,22 +233,93 @@ function calculatePositionSize({
   return quantity >= minQty ? quantity : 0;
 }
 
+// src/metrics/finite.js
+var BIG_NUMBER = 1e9;
+function clampFinite(value, fallback = 0) {
+  if (value === Infinity) return BIG_NUMBER;
+  if (value === -Infinity) return -BIG_NUMBER;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return fallback;
+}
+
+// src/metrics/annualize.js
+var TRADING_DAYS = 252;
+var RTH_HOURS = 6.5;
+var MS_PER_YEAR = 365 * 24 * 60 * 60 * 1e3;
+var INTERVAL_PERIODS = {
+  "1m": TRADING_DAYS * RTH_HOURS * 60,
+  "2m": TRADING_DAYS * RTH_HOURS * 30,
+  "5m": TRADING_DAYS * RTH_HOURS * 12,
+  "15m": TRADING_DAYS * RTH_HOURS * 4,
+  "30m": TRADING_DAYS * RTH_HOURS * 2,
+  "1h": TRADING_DAYS * RTH_HOURS,
+  "60m": TRADING_DAYS * RTH_HOURS,
+  "1d": TRADING_DAYS,
+  "1wk": 52,
+  "1mo": 12
+};
+function periodsPerYear(interval, estBarMs) {
+  if (interval && INTERVAL_PERIODS[interval]) return INTERVAL_PERIODS[interval];
+  if (Number.isFinite(estBarMs) && estBarMs > 0) {
+    return Math.round(MS_PER_YEAR / estBarMs);
+  }
+  return TRADING_DAYS;
+}
+
+// src/metrics/benchmark.js
+function mean(xs) {
+  return xs.length ? xs.reduce((a, b) => a + b, 0) / xs.length : 0;
+}
+function benchmarkStats(strategyReturns, benchmarkReturns) {
+  const nullStats = {
+    alpha: null,
+    beta: null,
+    correlation: null,
+    informationRatio: null,
+    trackingError: null
+  };
+  if (!Array.isArray(strategyReturns) || !Array.isArray(benchmarkReturns) || strategyReturns.length === 0 || strategyReturns.length !== benchmarkReturns.length) {
+    return nullStats;
+  }
+  const meanStrat = mean(strategyReturns);
+  const meanBench = mean(benchmarkReturns);
+  let covar = 0;
+  let varBench = 0;
+  let varStrat = 0;
+  for (let i = 0; i < strategyReturns.length; i += 1) {
+    const ds = strategyReturns[i] - meanStrat;
+    const db = benchmarkReturns[i] - meanBench;
+    covar += ds * db;
+    varBench += db * db;
+    varStrat += ds * ds;
+  }
+  const beta = varBench === 0 ? 0 : covar / varBench;
+  const alpha = meanStrat - beta * meanBench;
+  const denom = Math.sqrt(varStrat * varBench);
+  const correlation = denom === 0 ? 0 : covar / denom;
+  const active = strategyReturns.map((r, i) => r - benchmarkReturns[i]);
+  const meanActive = mean(active);
+  const trackingError = Math.sqrt(mean(active.map((a) => (a - meanActive) ** 2)));
+  const informationRatio = trackingError === 0 ? 0 : meanActive / trackingError;
+  return { alpha, beta, correlation, informationRatio, trackingError };
+}
+
 // src/metrics/buildMetrics.js
 function sum(values) {
   return values.reduce((total, value) => total + value, 0);
 }
-function mean(values) {
+function mean2(values) {
   return values.length ? sum(values) / values.length : 0;
 }
 function stddev(values) {
   if (values.length <= 1) return 0;
-  const avg = mean(values);
-  return Math.sqrt(mean(values.map((value) => (value - avg) ** 2)));
+  const avg = mean2(values);
+  return Math.sqrt(mean2(values.map((value) => (value - avg) ** 2)));
 }
 function sortino(values) {
   const losses = values.filter((value) => value < 0);
   const downsideDeviation = stddev(losses.length ? losses : [0]);
-  const avg = mean(values);
+  const avg = mean2(values);
   return downsideDeviation === 0 ? avg > 0 ? Infinity : 0 : avg / downsideDeviation;
 }
 function dayKeyUTC(timeMs) {
@@ -322,14 +405,22 @@ function percentile(values, percentileRank) {
   const index = Math.floor((sorted.length - 1) * percentileRank);
   return sorted[index];
 }
-var PROFIT_FACTOR_CAP = 1e6;
 function finiteProfitFactor(grossProfit, grossLoss) {
   if (grossLoss === 0) {
-    return grossProfit > 0 ? PROFIT_FACTOR_CAP : 0;
+    return grossProfit > 0 ? BIG_NUMBER : 0;
   }
   return grossProfit / grossLoss;
 }
-function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqSeries }) {
+function buildMetrics({
+  closed,
+  equityStart,
+  equityFinal,
+  candles,
+  estBarMs,
+  eqSeries,
+  interval,
+  benchmarkReturns
+}) {
   const legs = [...closed].sort((left, right) => left.exit.time - right.exit.time);
   const completedTrades = [];
   const tradeRs = [];
@@ -399,11 +490,11 @@ function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqS
       if (pnl > 0) shortTradeWins += 1;
     }
   }
-  const avgR = mean(tradeRs);
+  const avgR = mean2(tradeRs);
   const { maxWin, maxLoss } = streaks(labels);
-  const expectancy = mean(tradePnls);
+  const expectancy = mean2(tradePnls);
   const tradeReturnStd = stddev(tradeReturns);
-  const sharpePerTrade = tradeReturnStd === 0 ? tradeReturns.length ? Infinity : 0 : mean(tradeReturns) / tradeReturnStd;
+  const sharpePerTrade = tradeReturnStd === 0 ? tradeReturns.length ? Infinity : 0 : mean2(tradeReturns) / tradeReturnStd;
   const sortinoPerTrade = sortino(tradeReturns);
   const profitFactorPositions = finiteProfitFactor(grossProfitPositions, grossLossPositions);
   const profitFactorLegs = finiteProfitFactor(grossProfitLegs, grossLossLegs);
@@ -411,11 +502,11 @@ function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqS
   const calmar = maxDrawdown === 0 ? returnPct > 0 ? Infinity : 0 : returnPct / maxDrawdown;
   const totalBars = Math.max(1, candles.length);
   const exposurePct = openBars / totalBars;
-  const avgHoldMin = mean(holdDurationsMinutes);
+  const avgHoldMin = mean2(holdDurationsMinutes);
   const equitySeries = eqSeries && eqSeries.length ? eqSeries : buildEquitySeriesFromLegs({ legs, equityStart });
   const dailyReturnsSeries = dailyReturns(equitySeries);
   const dailyStd = stddev(dailyReturnsSeries);
-  const sharpeDaily = dailyStd === 0 ? dailyReturnsSeries.length ? Infinity : 0 : mean(dailyReturnsSeries) / dailyStd;
+  const sharpeDaily = dailyStd === 0 ? dailyReturnsSeries.length ? Infinity : 0 : mean2(dailyReturnsSeries) / dailyStd;
   const sortinoDaily = sortino(dailyReturnsSeries);
   const dailyWinRate = dailyReturnsSeries.length ? dailyReturnsSeries.filter((value) => value > 0).length / dailyReturnsSeries.length : 0;
   const rDistribution = {
@@ -437,28 +528,36 @@ function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqS
       trades: longTradesCount,
       winRate: longTradesCount ? longTradeWins / longTradesCount : 0,
       avgPnL: longTradesCount ? longPnLSum / longTradesCount : 0,
-      avgR: mean(longRs)
+      avgR: mean2(longRs)
     },
     short: {
       trades: shortTradesCount,
       winRate: shortTradesCount ? shortTradeWins / shortTradesCount : 0,
       avgPnL: shortTradesCount ? shortPnLSum / shortTradesCount : 0,
-      avgR: mean(shortRs)
+      avgR: mean2(shortRs)
     }
   };
+  const periods = periodsPerYear(interval, estBarMs);
+  const sqrtPeriods = Math.sqrt(periods);
+  const sharpeAnnualized = clampFinite(clampFinite(sharpeDaily) * sqrtPeriods);
+  const sortinoAnnualized = clampFinite(clampFinite(sortinoDaily) * sqrtPeriods);
+  const benchmark = benchmarkStats(dailyReturnsSeries, benchmarkReturns ?? []);
   return {
     trades: completedTrades.length,
     winRate: completedTrades.length ? winningTradeCount / completedTrades.length : 0,
-    profitFactor: profitFactorPositions,
+    profitFactor: clampFinite(profitFactorPositions),
     expectancy,
     totalR,
     avgR,
-    sharpe: sharpeDaily,
-    sharpePerTrade,
-    sortinoPerTrade,
+    sharpe: clampFinite(sharpeDaily),
+    sharpeAnnualized,
+    sortinoAnnualized,
+    sharpePerTrade: clampFinite(sharpePerTrade),
+    sortinoPerTrade: clampFinite(sortinoPerTrade),
+    annualizationPeriods: periods,
     maxDrawdown,
     maxDrawdownPct: maxDrawdown,
-    calmar,
+    calmar: clampFinite(calmar),
     maxConsecWins: maxWin,
     maxConsecLosses: maxLoss,
     avgHold: avgHoldMin,
@@ -468,12 +567,13 @@ function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqS
     returnPct,
     finalEquity: equityFinal,
     startEquity: equityStart,
-    profitFactor_pos: profitFactorPositions,
-    profitFactor_leg: profitFactorLegs,
+    profitFactor_pos: clampFinite(profitFactorPositions),
+    profitFactor_leg: clampFinite(profitFactorLegs),
     winRate_pos: completedTrades.length ? winningTradeCount / completedTrades.length : 0,
     winRate_leg: legs.length ? winningLegCount / legs.length : 0,
-    sharpeDaily,
-    sortinoDaily,
+    sharpeDaily: clampFinite(sharpeDaily),
+    sortinoDaily: clampFinite(sortinoDaily),
+    benchmark,
     sideBreakdown,
     long: sideBreakdown.long,
     short: sideBreakdown.short,
@@ -482,7 +582,7 @@ function buildMetrics({ closed, equityStart, equityFinal, candles, estBarMs, eqS
     daily: {
       count: dailyReturnsSeries.length,
       winRate: dailyWinRate,
-      avgReturn: mean(dailyReturnsSeries)
+      avgReturn: mean2(dailyReturnsSeries)
     }
   };
 }
@@ -939,6 +1039,30 @@ function dayKeyET(timeMs) {
   const pseudoEtTime = anchor.getTime() + hoursET * 60 * 60 * 1e3 + minutesETDay * 60 * 1e3;
   return dayKeyUTC2(pseudoEtTime);
 }
+var MS_PER_YEAR2 = 365 * 24 * 60 * 60 * 1e3;
+function fundingEvents(fromMs, toMs, intervalMs, anchorMs = 0) {
+  if (!(intervalMs > 0) || toMs <= fromMs) return 0;
+  const firstK = Math.floor((fromMs - anchorMs) / intervalMs) + 1;
+  const lastK = Math.floor((toMs - anchorMs) / intervalMs);
+  return Math.max(0, lastK - firstK + 1);
+}
+function financingCost({ side, notional, fromMs, toMs, costs }) {
+  const model = costs || {};
+  const absNotional = Math.abs(notional);
+  let cost = 0;
+  if (model.carry) {
+    const annualBps = side === "long" ? model.carry.longAnnualBps ?? 0 : model.carry.shortAnnualBps ?? 0;
+    const years = Math.max(0, toMs - fromMs) / MS_PER_YEAR2;
+    cost += absNotional * (annualBps / 1e4) * years;
+  }
+  const funding = model.funding;
+  if (funding && funding.intervalMs > 0 && Number.isFinite(funding.rateBps)) {
+    const count = fundingEvents(fromMs, toMs, funding.intervalMs, funding.anchorMs ?? 0);
+    const perEvent = absNotional * (funding.rateBps / 1e4);
+    cost += (side === "long" ? 1 : -1) * perEvent * count;
+  }
+  return cost;
+}
 
 // src/engine/backtest.js
 function asNumber(value) {
@@ -1070,6 +1194,7 @@ function mergeOptions(options) {
     maxSlipROnFill: options.maxSlipROnFill ?? 0.4,
     collectEqSeries: options.collectEqSeries ?? true,
     collectReplay: options.collectReplay ?? true,
+    benchmarkReturns: Array.isArray(options.benchmarkReturns) ? options.benchmarkReturns : null,
     strict: options.strict ?? false
   };
 }
@@ -1192,7 +1317,14 @@ function backtest(rawOptions) {
     const entryFill = openPos.entryFill;
     const grossPnl = (exitPx - entryFill) * direction * qty;
     const entryFeePortion = (openPos.entryFeeTotal || 0) * (qty / openPos.initSize);
-    const pnl = grossPnl - entryFeePortion - exitFeeTotal;
+    const financing = financingCost({
+      side: openPos.side,
+      notional: entryFill * qty,
+      fromMs: openPos.openTime,
+      toMs: time,
+      costs
+    });
+    const pnl = grossPnl - entryFeePortion - exitFeeTotal - financing;
     currentEquity += pnl;
     dayPnl += pnl;
     if (wantEqSeries) {
@@ -1220,6 +1352,7 @@ function backtest(rawOptions) {
         time,
         reason,
         pnl,
+        financing,
         exitATR: openPos._lastATR ?? void 0
       },
       mfeR: openPos._mfeR ?? 0,
@@ -1622,7 +1755,9 @@ function backtest(rawOptions) {
     equityFinal: currentEquity,
     candles,
     estBarMs: estimatedBarMs,
-    eqSeries
+    eqSeries,
+    interval: options.interval,
+    benchmarkReturns: options.benchmarkReturns
   });
   const positions = closed.filter((trade) => trade.exit.reason !== "SCALE");
   const lastPrice = asNumber(candles[candles.length - 1]?.close);
@@ -1643,11 +1778,31 @@ function backtest(rawOptions) {
   };
 }
 
-// src/engine/backtestTicks.js
+// src/engine/barSystemRunner.js
 function asNumber2(value) {
   const numeric = Number(value);
   return Number.isFinite(numeric) ? numeric : null;
 }
+function equityPoint2(time, equity, extra = {}) {
+  return { time, timestamp: time, equity, ...extra };
+}
+function isArrayIndexKey2(property) {
+  if (typeof property !== "string") return false;
+  const numeric = Number(property);
+  return Number.isInteger(numeric) && numeric >= 0;
+}
+function strictHistoryView2(candles, currentIndex) {
+  return new Proxy(candles, {
+    get(target, property, receiver) {
+      if (isArrayIndexKey2(property) && Number(property) >= target.length) {
+        throw new Error(
+          `strict mode: signal() tried to access candles[${String(property)}] beyond current index ${currentIndex}`
+        );
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
 function describeValue2(value) {
   if (Array.isArray(value)) return `array(length=${value.length})`;
   if (value === null) return "null";
@@ -1666,38 +1821,45 @@ function callSignalWithContext2({ signal, context, index, bar, symbol }) {
     );
   }
 }
+async function callSignalWithContextAsync({ signal, context, index, bar, symbol }) {
+  try {
+    return await signal(context);
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `signal() threw at index=${index}, time=${formatIsoTime2(bar?.time)}, symbol=${symbol}: ${cause}`
+    );
+  }
+}
+function snapshotOpenPosition2(open, markPrice) {
+  if (!open) return null;
+  const entryPrice = open.entryFill ?? open.entry;
+  const direction = open.side === "long" ? 1 : -1;
+  const unrealizedPnl = (markPrice - entryPrice) * direction * open.size;
+  return {
+    id: open.id,
+    symbol: open.symbol,
+    side: open.side,
+    size: open.size,
+    entry: open.entry,
+    entryFill: open.entryFill,
+    stop: open.stop,
+    takeProfit: open.takeProfit,
+    openTime: open.openTime,
+    markPrice,
+    unrealizedPnl,
+    _initRisk: open._initRisk
+  };
+}
 function normalizeSide2(value) {
   if (value === "long" || value === "buy") return "long";
   if (value === "short" || value === "sell") return "short";
   return null;
 }
-function normalizeTick(tick) {
-  const time = Number(tick?.time);
-  const bid = asNumber2(tick?.bid);
-  const ask = asNumber2(tick?.ask);
-  const last = asNumber2(tick?.price ?? tick?.last ?? tick?.close);
-  const mid = bid !== null && ask !== null ? (bid + ask) / 2 : last ?? bid ?? ask;
-  if (!Number.isFinite(time) || !Number.isFinite(mid)) return null;
-  const prices = [asNumber2(tick?.low), asNumber2(tick?.high), bid, ask, last, mid].filter(
-    Number.isFinite
-  );
-  const low = prices.length ? Math.min(...prices) : mid;
-  const high = prices.length ? Math.max(...prices) : mid;
-  return {
-    ...tick,
-    time,
-    open: mid,
-    high,
-    low,
-    close: mid,
-    volume: asNumber2(tick?.size ?? tick?.volume) ?? void 0
-  };
-}
 function normalizeSignal2(signal, bar, fallbackR) {
   if (!signal) return null;
   const side = normalizeSide2(signal.side ?? signal.direction ?? signal.action);
   if (!side) return null;
-  const hasExplicitEntry = signal.entry !== void 0 || signal.limit !== void 0 || signal.price !== void 0;
   const entry = asNumber2(signal.entry ?? signal.limit ?? signal.price) ?? asNumber2(bar?.close);
   const stop = asNumber2(signal.stop ?? signal.stopLoss ?? signal.sl);
   if (entry === null || stop === null) return null;
@@ -1719,804 +1881,376 @@ function normalizeSignal2(signal, bar, fallbackR) {
     qty: asNumber2(signal.qty ?? signal.size),
     riskPct: asNumber2(signal.riskPct),
     riskFraction: asNumber2(signal.riskFraction),
-    orderType: hasExplicitEntry ? "limit" : "market"
-  };
-}
-function equityPoint2(time, equity) {
-  return { time, timestamp: time, equity };
-}
-function xmur3(seed) {
-  let hash = 1779033703 ^ seed.length;
-  for (let index = 0; index < seed.length; index += 1) {
-    hash = Math.imul(hash ^ seed.charCodeAt(index), 3432918353);
-    hash = hash << 13 | hash >>> 19;
-  }
-  return () => {
-    hash = Math.imul(hash ^ hash >>> 16, 2246822507);
-    hash = Math.imul(hash ^ hash >>> 13, 3266489909);
-    return (hash ^= hash >>> 16) >>> 0;
+    _rr: rrHint ?? signal._rr,
+    _initRisk: asNumber2(signal._initRisk) ?? signal._initRisk
   };
 }
-function mulberry32(seed) {
-  let state = seed >>> 0;
-  return () => {
-    state = state + 1831565813 >>> 0;
-    let value = Math.imul(state ^ state >>> 15, state | 1);
-    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
-    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+function mergeOptions2(options) {
+  const normalizedRiskPct = Number.isFinite(options.riskFraction) ? options.riskFraction * 100 : options.riskPct;
+  return {
+    candles: normalizeCandles(options.candles ?? []),
+    symbol: options.symbol ?? "UNKNOWN",
+    equity: options.equity ?? 1e4,
+    riskPct: normalizedRiskPct ?? 1,
+    signal: options.signal,
+    interval: options.interval,
+    range: options.range,
+    warmupBars: options.warmupBars ?? 200,
+    slippageBps: options.slippageBps ?? 1,
+    feeBps: options.feeBps ?? 0,
+    costs: options.costs ?? null,
+    scaleOutAtR: options.scaleOutAtR ?? 1,
+    scaleOutFrac: options.scaleOutFrac ?? 0.5,
+    finalTP_R: options.finalTP_R ?? 3,
+    maxDailyLossPct: options.maxDailyLossPct ?? 2,
+    atrTrailMult: options.atrTrailMult ?? 0,
+    atrTrailPeriod: options.atrTrailPeriod ?? 14,
+    oco: {
+      mode: "intrabar",
+      tieBreak: "pessimistic",
+      clampStops: true,
+      clampEpsBps: 0.25,
+      ...options.oco || {}
+    },
+    triggerMode: options.triggerMode,
+    flattenAtClose: options.flattenAtClose ?? true,
+    dailyMaxTrades: options.dailyMaxTrades ?? 0,
+    postLossCooldownBars: options.postLossCooldownBars ?? 0,
+    mfeTrail: {
+      enabled: false,
+      armR: 1,
+      givebackR: 0.5,
+      ...options.mfeTrail || {}
+    },
+    pyramiding: {
+      enabled: false,
+      addAtR: 1,
+      addFrac: 0.25,
+      maxAdds: 1,
+      onlyAfterBreakEven: true,
+      ...options.pyramiding || {}
+    },
+    volScale: {
+      enabled: false,
+      atrPeriod: options.atrTrailPeriod ?? 14,
+      cutIfAtrX: 1.3,
+      cutFrac: 0.33,
+      noCutAboveR: 1.5,
+      ...options.volScale || {}
+    },
+    qtyStep: options.qtyStep ?? 1e-3,
+    minQty: options.minQty ?? 1e-3,
+    maxLeverage: options.maxLeverage ?? 2,
+    entryChase: {
+      enabled: true,
+      afterBars: 2,
+      maxSlipR: 0.2,
+      convertOnExpiry: false,
+      ...options.entryChase || {}
+    },
+    reanchorStopOnFill: options.reanchorStopOnFill ?? true,
+    maxSlipROnFill: options.maxSlipROnFill ?? 0.4,
+    collectEqSeries: options.collectEqSeries ?? true,
+    collectReplay: options.collectReplay ?? true,
+    strict: options.strict ?? false
   };
 }
-function seededUnitInterval(seedParts) {
-  const seed = seedParts.map((part) => String(part)).join("|");
-  const seedFn = xmur3(seed);
-  return mulberry32(seedFn())();
-}
-function deterministicFill(probability, seedParts) {
-  if (probability >= 1) return true;
-  if (probability <= 0) return false;
-  const normalized = seededUnitInterval(seedParts);
-  return normalized <= probability;
+function capitalForSize(entryPrice, size, maxLeverage) {
+  const leverage = Math.max(1, Number(maxLeverage) || 1);
+  return Math.abs(entryPrice) * Math.max(0, size) / leverage;
 }
-function backtestTicks({
-  ticks = [],
-  symbol = "UNKNOWN",
-  equity = 1e4,
-  riskPct = 1,
-  signal,
-  interval,
-  range,
-  slippageBps = 1,
-  feeBps = 0,
-  costs = null,
-  finalTP_R = 3,
-  maxDailyLossPct = 0,
-  dailyMaxTrades = 0,
-  qtyStep = 1e-3,
-  minQty = 1e-3,
-  maxLeverage = 2,
-  collectEqSeries = true,
-  collectReplay = true,
-  queueFillProbability = 1,
-  oco = {}
-} = {}) {
-  if (!Array.isArray(ticks) || ticks.length === 0) {
-    throw new Error(
-      `backtestTicks() requires a non-empty ticks array, got ${describeValue2(ticks)}`
-    );
-  }
-  if (typeof signal !== "function") {
-    throw new Error(`backtestTicks() requires a signal function, got ${describeValue2(signal)}`);
-  }
-  const normalizedTicks = ticks.map(normalizeTick).filter(Boolean);
-  if (!normalizedTicks.length) {
-    throw new Error(
-      `backtestTicks() could not normalize any ticks from ${ticks.length} input rows`
-    );
-  }
-  const ocoOptions = {
-    mode: "intrabar",
-    tieBreak: "pessimistic",
-    ...oco
-  };
-  const trades = [];
-  const eqSeries = collectEqSeries ? [equityPoint2(normalizedTicks[0].time, equity)] : [];
-  const replayFrames = collectReplay ? [] : [];
-  const replayEvents = collectReplay ? [] : [];
-  const history = [];
-  let open = null;
-  let pending = null;
-  let currentEquity = equity;
-  let dayKey = null;
-  let dayStartEquity = equity;
-  let dayPnl = 0;
-  let dayTrades = 0;
-  let tradeIdCounter = 0;
-  function markedEquity(tick) {
-    if (!open) return currentEquity;
-    const direction = open.side === "long" ? 1 : -1;
-    return currentEquity + (tick.close - open.entryFill) * direction * open.size;
-  }
-  function recordFrame(tick) {
-    const equityNow = markedEquity(tick);
-    if (collectEqSeries) {
-      eqSeries.push(equityPoint2(tick.time, equityNow));
-    }
-    if (collectReplay) {
-      replayFrames.push({
-        t: new Date(tick.time).toISOString(),
-        price: tick.close,
-        equity: equityNow,
-        posSide: open?.side ?? null,
-        posSize: open?.size ?? 0
+var BarSystemRunner = class {
+  constructor(rawOptions = {}) {
+    this.options = mergeOptions2(rawOptions);
+    const { candles, signal } = this.options;
+    if (!Array.isArray(candles) || candles.length === 0) {
+      throw new Error(
+        `backtestPortfolio() requires each system to include non-empty candles, got ${describeValue2(
+          candles
+        )} for ${this.options.symbol}`
+      );
+    }
+    if (typeof signal !== "function") {
+      throw new Error(
+        `backtestPortfolio() requires each system to include a signal function, got ${describeValue2(
+          signal
+        )} for ${this.options.symbol}`
+      );
+    }
+    this.symbol = this.options.symbol;
+    this.candles = candles;
+    this.closed = [];
+    this.currentEquity = this.options.equity;
+    this.open = null;
+    this.cooldown = 0;
+    this.pending = null;
+    this.currentDay = null;
+    this.dayPnl = 0;
+    this.dayTrades = 0;
+    this.dayEquityStart = this.options.equity;
+    this.tradeIdCounter = 0;
+    this.estimatedBarMs = estimateBarMs(candles);
+    const atrSourcePeriod = this.options.volScale.enabled ? this.options.volScale.atrPeriod : this.options.atrTrailPeriod;
+    const needAtr = this.options.atrTrailMult > 0 || this.options.volScale.enabled;
+    this.atrValues = needAtr ? atr(candles, atrSourcePeriod) : null;
+    this.wantEqSeries = Boolean(this.options.collectEqSeries);
+    this.wantReplay = Boolean(this.options.collectReplay);
+    this.eqSeries = this.wantEqSeries ? [equityPoint2(candles[0].time, this.currentEquity)] : [];
+    this.replayFrames = this.wantReplay ? [] : [];
+    this.replayEvents = this.wantReplay ? [] : [];
+    this.startIndex = Math.min(Math.max(1, this.options.warmupBars), candles.length);
+    this.history = candles.slice(0, this.startIndex);
+    this.index = this.startIndex;
+    this.lastBar = this.history.length ? this.history[this.history.length - 1] : null;
+  }
+  hasNext() {
+    return this.index < this.candles.length;
+  }
+  peekTime() {
+    return this.hasNext() ? this.candles[this.index].time : Infinity;
+  }
+  getLockedCapital() {
+    if (!this.open) return 0;
+    return capitalForSize(
+      this.open.entryFill ?? this.open.entry,
+      this.open.size,
+      this.options.maxLeverage
+    );
+  }
+  getMarkPrice() {
+    return this.lastBar?.close ?? null;
+  }
+  getMarkedEquity() {
+    if (!this.open || !this.lastBar) return this.currentEquity;
+    const direction = this.open.side === "long" ? 1 : -1;
+    const markPnl = (this.lastBar.close - (this.open.entryFill ?? this.open.entry)) * direction * this.open.size;
+    return this.currentEquity + markPnl;
+  }
+  recordFrame(bar, extraFrame = {}) {
+    if (this.wantEqSeries) {
+      this.eqSeries.push(equityPoint2(bar.time, this.currentEquity));
+    }
+    if (this.wantReplay) {
+      this.replayFrames.push({
+        t: new Date(bar.time).toISOString(),
+        price: bar.close,
+        equity: this.currentEquity,
+        posSide: this.open ? this.open.side : null,
+        posSize: this.open ? this.open.size : 0,
+        ...extraFrame
       });
     }
   }
-  function closePosition(tick, reason, rawPrice, fillKind) {
-    if (!open) return;
-    const exitSide = open.side === "long" ? "short" : "long";
-    const { price, feeTotal } = applyFill(rawPrice, exitSide, {
-      slippageBps,
-      feeBps,
-      kind: fillKind,
-      qty: open.size,
-      costs
+  closeLeg({ openPos, qty, exitPx, exitFeeTotal = 0, time, reason }) {
+    const direction = openPos.side === "long" ? 1 : -1;
+    const entryFill = openPos.entryFill;
+    const grossPnl = (exitPx - entryFill) * direction * qty;
+    const entryFeePortion = (openPos.entryFeeTotal || 0) * (qty / openPos.initSize);
+    const financing = financingCost({
+      side: openPos.side,
+      notional: entryFill * qty,
+      fromMs: openPos.openTime,
+      toMs: time,
+      costs: this.options.costs
     });
-    const direction = open.side === "long" ? 1 : -1;
-    const grossPnl = (price - open.entryFill) * direction * open.size;
-    const pnl = grossPnl - (open.entryFeeTotal || 0) - feeTotal;
-    currentEquity += pnl;
-    dayPnl += pnl;
-    const trade = {
-      ...open,
-      exit: {
-        price,
-        time: tick.time,
-        reason,
-        pnl
-      }
-    };
-    trades.push(trade);
-    if (collectReplay) {
-      replayEvents.push({
-        t: new Date(tick.time).toISOString(),
-        price,
-        type: reason === "TP" ? "tp" : reason === "SL" ? "sl" : "exit",
-        side: open.side,
-        size: open.size,
-        tradeId: open.id,
+    const pnl = grossPnl - entryFeePortion - exitFeeTotal - financing;
+    this.currentEquity += pnl;
+    this.dayPnl += pnl;
+    if (this.wantEqSeries) {
+      this.eqSeries.push(equityPoint2(time, this.currentEquity));
+    }
+    const remaining = openPos.size - qty;
+    const eventType = reason === "SCALE" ? "scale-out" : reason === "TP" ? "tp" : reason === "SL" ? "sl" : reason === "EOD" ? "eod" : remaining <= 0 ? "exit" : "scale-out";
+    if (this.wantReplay) {
+      this.replayEvents.push({
+        t: new Date(time).toISOString(),
+        price: exitPx,
+        type: eventType,
+        side: openPos.side,
+        size: qty,
+        tradeId: openPos.id,
         reason,
-        pnl
+        pnl,
+        symbol: this.symbol
       });
     }
-    open = null;
+    const record = {
+      ...openPos,
+      size: qty,
+      exit: {
+        price: exitPx,
+        time,
+        reason,
+        pnl,
+        financing,
+        exitATR: openPos._lastATR ?? void 0
+      },
+      mfeR: openPos._mfeR ?? 0,
+      maeR: openPos._maeR ?? 0,
+      adds: openPos._adds ?? 0
+    };
+    this.closed.push(record);
+    openPos.size -= qty;
+    openPos._realized = (openPos._realized || 0) + pnl;
+    return record;
   }
-  for (let index = 0; index < normalizedTicks.length; index += 1) {
-    const tick = normalizedTicks[index];
-    history.push(tick);
-    const currentDayKey = dayKeyUTC2(tick.time);
-    if (dayKey === null || currentDayKey !== dayKey) {
-      dayKey = currentDayKey;
-      dayStartEquity = currentEquity;
-      dayPnl = 0;
-      dayTrades = 0;
+  tightenStopToNetBreakeven(openPos, lastClose) {
+    if (!openPos || openPos.size <= 0) return;
+    const realized = openPos._realized || 0;
+    if (realized <= 0) return;
+    const direction = openPos.side === "long" ? 1 : -1;
+    const breakevenDelta = Math.abs(realized / openPos.size);
+    const breakevenPrice = direction === 1 ? openPos.entryFill - breakevenDelta : openPos.entryFill + breakevenDelta;
+    const tightened = direction === 1 ? Math.max(openPos.stop, breakevenPrice) : Math.min(openPos.stop, breakevenPrice);
+    openPos.stop = this.options.oco.clampStops ? clampStop(lastClose, tightened, openPos.side, this.options.oco) : tightened;
+  }
+  forceExit(reason, bar, overridePrice = null) {
+    if (!this.open || !bar) return;
+    const exitSide = this.open.side === "long" ? "short" : "long";
+    const exitBasePrice = overridePrice ?? bar.close;
+    const { price: filled, feeTotal: exitFeeTotal } = applyFill(exitBasePrice, exitSide, {
+      slippageBps: this.options.slippageBps,
+      feeBps: this.options.feeBps,
+      kind: "market",
+      qty: this.open.size,
+      costs: this.options.costs
+    });
+    this.closeLeg({
+      openPos: this.open,
+      qty: this.open.size,
+      exitPx: filled,
+      exitFeeTotal,
+      time: bar.time,
+      reason
+    });
+    this.cooldown = this.open?._cooldownBars || 0;
+    this.open = null;
+  }
+  cancelPending() {
+    this.pending = null;
+  }
+  openFromPending(bar, signalEquity, entryPrice, fillKind = "limit", resolveEntrySize) {
+    if (!this.pending) return false;
+    const plannedRisk = Math.max(
+      1e-8,
+      this.pending.plannedRiskAbs ?? Math.abs(this.pending.entry - this.pending.stop)
+    );
+    const slipR = Math.abs(entryPrice - this.pending.entry) / plannedRisk;
+    if (slipR > this.options.maxSlipROnFill) return false;
+    let stopPrice = this.pending.stop;
+    if (this.options.reanchorStopOnFill) {
+      const direction = this.pending.side === "long" ? 1 : -1;
+      stopPrice = direction === 1 ? entryPrice - plannedRisk : entryPrice + plannedRisk;
     }
-    if (open) {
-      const { hit, px } = ocoExitCheck({
-        side: open.side,
-        stop: open.stop,
-        tp: open.takeProfit,
-        bar: tick,
-        mode: "intrabar",
-        tieBreak: ocoOptions.tieBreak
-      });
-      if (hit) {
-        closePosition(tick, hit, px, hit === "TP" ? "limit" : "stop");
+    let takeProfit = this.pending.tp;
+    const immediateRisk = Math.abs(entryPrice - stopPrice) || 1e-8;
+    const rrHint = this.pending.meta?._rr;
+    if (this.options.reanchorStopOnFill && Number.isFinite(rrHint)) {
+      const plannedTarget = this.pending.side === "long" ? this.pending.entry + rrHint * plannedRisk : this.pending.entry - rrHint * plannedRisk;
+      const closeEnough = Math.abs((this.pending.tp ?? plannedTarget) - plannedTarget) <= Math.max(1e-8, plannedRisk * 1e-6);
+      if (closeEnough) {
+        takeProfit = this.pending.side === "long" ? entryPrice + rrHint * immediateRisk : entryPrice - rrHint * immediateRisk;
       }
     }
-    if (!open && pending && index > pending.createdAtIndex) {
-      if (pending.orderType === "market") {
-        const rawSize = pending.fixedQty ?? calculatePositionSize({
-          equity: currentEquity,
-          entry: tick.close,
-          stop: pending.stop,
-          riskFraction: pending.riskFrac,
-          qtyStep,
-          minQty,
-          maxLeverage
-        });
-        const size = roundStep2(rawSize, qtyStep);
-        if (size >= minQty) {
-          const { price, feeTotal } = applyFill(tick.close, pending.side, {
-            slippageBps,
-            feeBps,
-            kind: "market",
-            qty: size,
-            costs
-          });
-          open = {
-            symbol,
-            id: ++tradeIdCounter,
-            side: pending.side,
-            entry: tick.close,
-            stop: pending.stop,
-            takeProfit: pending.takeProfit,
-            size,
-            openTime: tick.time,
-            entryFill: price,
-            entryFeeTotal: feeTotal,
-            _initRisk: Math.abs(tick.close - pending.stop)
-          };
-          dayTrades += 1;
-          if (collectReplay) {
-            replayEvents.push({
-              t: new Date(tick.time).toISOString(),
-              price,
-              type: "entry",
-              side: open.side,
-              size,
-              tradeId: open.id
-            });
-          }
-        }
-        pending = null;
-      } else {
-        const touched = pending.side === "long" ? tick.low <= pending.entry : tick.high >= pending.entry;
-        if (touched && deterministicFill(queueFillProbability, [
-          symbol,
-          tick.time,
-          pending.entry,
-          pending.stop,
-          pending.side
-        ])) {
-          const rawSize = pending.fixedQty ?? calculatePositionSize({
-            equity: currentEquity,
-            entry: pending.entry,
-            stop: pending.stop,
-            riskFraction: pending.riskFrac,
-            qtyStep,
-            minQty,
-            maxLeverage
-          });
-          const size = roundStep2(rawSize, qtyStep);
-          if (size >= minQty) {
-            const { price, feeTotal } = applyFill(pending.entry, pending.side, {
-              slippageBps,
-              feeBps,
-              kind: "limit",
-              qty: size,
-              costs
-            });
-            open = {
-              symbol,
-              id: ++tradeIdCounter,
-              side: pending.side,
-              entry: pending.entry,
-              stop: pending.stop,
-              takeProfit: pending.takeProfit,
-              size,
-              openTime: tick.time,
-              entryFill: price,
-              entryFeeTotal: feeTotal,
-              _initRisk: Math.abs(pending.entry - pending.stop)
-            };
-            dayTrades += 1;
-            if (collectReplay) {
-              replayEvents.push({
-                t: new Date(tick.time).toISOString(),
-                price,
-                type: "entry",
-                side: open.side,
-                size,
-                tradeId: open.id
-              });
-            }
-          }
-          pending = null;
-        }
-      }
+    const desiredSize = this.pending.fixedQty ?? calculatePositionSize({
+      equity: signalEquity,
+      entry: entryPrice,
+      stop: stopPrice,
+      riskFraction: this.pending.riskFrac,
+      qtyStep: this.options.qtyStep,
+      minQty: this.options.minQty,
+      maxLeverage: this.options.maxLeverage
+    });
+    const approvedSize = typeof resolveEntrySize === "function" ? resolveEntrySize({
+      runner: this,
+      desiredSize,
+      entryPrice,
+      stopPrice,
+      pending: this.pending,
+      fillKind
+    }) : desiredSize;
+    const size = roundStep2(approvedSize, this.options.qtyStep);
+    if (size < this.options.minQty) return false;
+    const { price: entryFill, feeTotal: entryFeeTotal } = applyFill(entryPrice, this.pending.side, {
+      slippageBps: this.options.slippageBps,
+      feeBps: this.options.feeBps,
+      kind: fillKind,
+      qty: size,
+      costs: this.options.costs
+    });
+    this.open = {
+      symbol: this.symbol,
+      ...this.pending.meta,
+      id: ++this.tradeIdCounter,
+      side: this.pending.side,
+      entry: entryPrice,
+      stop: stopPrice,
+      takeProfit,
+      size,
+      openTime: bar.time,
+      entryFill,
+      entryFeeTotal,
+      initSize: size,
+      baseSize: size,
+      _mfeR: 0,
+      _maeR: 0,
+      _adds: 0,
+      _initRisk: Math.abs(entryPrice - stopPrice) || 1e-8
+    };
+    if (this.atrValues && this.atrValues[this.index] !== void 0) {
+      this.open.entryATR = this.atrValues[this.index];
+      this.open._lastATR = this.atrValues[this.index];
     }
-    const maxLossDollars = Math.abs(maxDailyLossPct) / 100 * dayStartEquity;
-    const dailyLossHit = maxDailyLossPct > 0 && dayPnl <= -maxLossDollars;
-    const dailyTradeCapHit = dailyMaxTrades > 0 && dayTrades >= dailyMaxTrades;
-    if (!open && !pending && !dailyLossHit && !dailyTradeCapHit) {
-      const nextSignal = normalizeSignal2(
-        callSignalWithContext2({
-          signal,
-          context: {
-            candles: history,
-            index,
-            bar: tick,
-            equity: markedEquity(tick),
-            openPosition: open,
-            pendingOrder: pending
-          },
-          index,
-          bar: tick,
-          symbol
-        }),
-        tick,
-        finalTP_R
-      );
-      if (nextSignal) {
-        pending = {
-          side: nextSignal.side,
-          entry: nextSignal.entry,
-          stop: nextSignal.stop,
-          takeProfit: nextSignal.takeProfit,
-          fixedQty: nextSignal.qty,
-          riskFrac: Number.isFinite(nextSignal.riskFraction) ? nextSignal.riskFraction : Number.isFinite(nextSignal.riskPct) ? nextSignal.riskPct / 100 : riskPct / 100,
-          orderType: nextSignal.orderType,
-          createdAtIndex: index
-        };
-      }
+    this.dayTrades += 1;
+    this.pending = null;
+    if (this.wantReplay) {
+      this.replayEvents.push({
+        t: new Date(bar.time).toISOString(),
+        price: entryFill,
+        type: "entry",
+        side: this.open.side,
+        size,
+        tradeId: this.open.id,
+        symbol: this.symbol
+      });
     }
-    recordFrame(tick);
+    return true;
   }
-  if (open) {
-    const lastTick = normalizedTicks[normalizedTicks.length - 1];
-    closePosition(lastTick, "EOT", lastTick.close, "market");
-    recordFrame(lastTick);
+  buildSignalContext(index, bar, signalEquity) {
+    if (this.options.strict && this.history.length !== index + 1) {
+      throw new Error(
+        `strict mode: signal() received ${this.history.length} candles at index ${index}`
+      );
+    }
+    return {
+      candles: this.options.strict ? strictHistoryView2(this.history, index) : this.history,
+      index,
+      bar,
+      equity: signalEquity,
+      openPosition: this.open,
+      pendingOrder: this.pending
+    };
   }
-  const positions = trades;
-  const metrics = buildMetrics({
-    closed: trades,
-    equityStart: equity,
-    equityFinal: currentEquity,
-    candles: normalizedTicks,
-    estBarMs: normalizedTicks.length > 1 ? Math.max(1, normalizedTicks[1].time - normalizedTicks[0].time) : 1,
-    eqSeries
-  });
-  return {
-    symbol,
-    interval,
-    range,
-    trades,
-    positions,
-    openPositions: [],
-    metrics,
-    eqSeries,
-    replay: {
-      frames: replayFrames,
-      events: replayEvents
+  _preSignal({ signalEquity, canTrade = true, resolveEntrySize } = {}) {
+    if (!this.hasNext()) return { handled: true, bar: null };
+    const bar = this.candles[this.index];
+    this.history.push(bar);
+    this.lastBar = bar;
+    const trigger = this.options.triggerMode || this.options.oco.mode || "intrabar";
+    const dayKey = this.options.flattenAtClose || trigger === "close" ? dayKeyET(bar.time) : dayKeyUTC2(bar.time);
+    if (this.currentDay === null || dayKey !== this.currentDay) {
+      this.currentDay = dayKey;
+      this.dayPnl = 0;
+      this.dayTrades = 0;
+      this.dayEquityStart = this.currentEquity;
     }
-  };
-}
-
-// src/engine/barSystemRunner.js
-function asNumber3(value) {
-  const numeric = Number(value);
-  return Number.isFinite(numeric) ? numeric : null;
-}
-function equityPoint3(time, equity, extra = {}) {
-  return { time, timestamp: time, equity, ...extra };
-}
-function isArrayIndexKey2(property) {
-  if (typeof property !== "string") return false;
-  const numeric = Number(property);
-  return Number.isInteger(numeric) && numeric >= 0;
-}
-function strictHistoryView2(candles, currentIndex) {
-  return new Proxy(candles, {
-    get(target, property, receiver) {
-      if (isArrayIndexKey2(property) && Number(property) >= target.length) {
-        throw new Error(
-          `strict mode: signal() tried to access candles[${String(property)}] beyond current index ${currentIndex}`
-        );
-      }
-      return Reflect.get(target, property, receiver);
-    }
-  });
-}
-function describeValue3(value) {
-  if (Array.isArray(value)) return `array(length=${value.length})`;
-  if (value === null) return "null";
-  return typeof value;
-}
-function formatIsoTime3(time) {
-  return Number.isFinite(time) ? new Date(time).toISOString() : "invalid-time";
-}
-function callSignalWithContext3({ signal, context, index, bar, symbol }) {
-  try {
-    return signal(context);
-  } catch (error) {
-    const cause = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `signal() threw at index=${index}, time=${formatIsoTime3(bar?.time)}, symbol=${symbol}: ${cause}`
-    );
-  }
-}
-function snapshotOpenPosition2(open, markPrice) {
-  if (!open) return null;
-  const entryPrice = open.entryFill ?? open.entry;
-  const direction = open.side === "long" ? 1 : -1;
-  const unrealizedPnl = (markPrice - entryPrice) * direction * open.size;
-  return {
-    id: open.id,
-    symbol: open.symbol,
-    side: open.side,
-    size: open.size,
-    entry: open.entry,
-    entryFill: open.entryFill,
-    stop: open.stop,
-    takeProfit: open.takeProfit,
-    openTime: open.openTime,
-    markPrice,
-    unrealizedPnl,
-    _initRisk: open._initRisk
-  };
-}
-function normalizeSide3(value) {
-  if (value === "long" || value === "buy") return "long";
-  if (value === "short" || value === "sell") return "short";
-  return null;
-}
-function normalizeSignal3(signal, bar, fallbackR) {
-  if (!signal) return null;
-  const side = normalizeSide3(signal.side ?? signal.direction ?? signal.action);
-  if (!side) return null;
-  const entry = asNumber3(signal.entry ?? signal.limit ?? signal.price) ?? asNumber3(bar?.close);
-  const stop = asNumber3(signal.stop ?? signal.stopLoss ?? signal.sl);
-  if (entry === null || stop === null) return null;
-  const risk = Math.abs(entry - stop);
-  if (!(risk > 0)) return null;
-  let takeProfit = asNumber3(signal.takeProfit ?? signal.target ?? signal.tp);
-  const rrHint = asNumber3(signal._rr ?? signal.rr);
-  const targetR = rrHint ?? fallbackR;
-  if (takeProfit === null && Number.isFinite(targetR) && targetR > 0) {
-    takeProfit = side === "long" ? entry + risk * targetR : entry - risk * targetR;
-  }
-  if (takeProfit === null) return null;
-  return {
-    ...signal,
-    side,
-    entry,
-    stop,
-    takeProfit,
-    qty: asNumber3(signal.qty ?? signal.size),
-    riskPct: asNumber3(signal.riskPct),
-    riskFraction: asNumber3(signal.riskFraction),
-    _rr: rrHint ?? signal._rr,
-    _initRisk: asNumber3(signal._initRisk) ?? signal._initRisk
-  };
-}
-function mergeOptions2(options) {
-  const normalizedRiskPct = Number.isFinite(options.riskFraction) ? options.riskFraction * 100 : options.riskPct;
-  return {
-    candles: normalizeCandles(options.candles ?? []),
-    symbol: options.symbol ?? "UNKNOWN",
-    equity: options.equity ?? 1e4,
-    riskPct: normalizedRiskPct ?? 1,
-    signal: options.signal,
-    interval: options.interval,
-    range: options.range,
-    warmupBars: options.warmupBars ?? 200,
-    slippageBps: options.slippageBps ?? 1,
-    feeBps: options.feeBps ?? 0,
-    costs: options.costs ?? null,
-    scaleOutAtR: options.scaleOutAtR ?? 1,
-    scaleOutFrac: options.scaleOutFrac ?? 0.5,
-    finalTP_R: options.finalTP_R ?? 3,
-    maxDailyLossPct: options.maxDailyLossPct ?? 2,
-    atrTrailMult: options.atrTrailMult ?? 0,
-    atrTrailPeriod: options.atrTrailPeriod ?? 14,
-    oco: {
-      mode: "intrabar",
-      tieBreak: "pessimistic",
-      clampStops: true,
-      clampEpsBps: 0.25,
-      ...options.oco || {}
-    },
-    triggerMode: options.triggerMode,
-    flattenAtClose: options.flattenAtClose ?? true,
-    dailyMaxTrades: options.dailyMaxTrades ?? 0,
-    postLossCooldownBars: options.postLossCooldownBars ?? 0,
-    mfeTrail: {
-      enabled: false,
-      armR: 1,
-      givebackR: 0.5,
-      ...options.mfeTrail || {}
-    },
-    pyramiding: {
-      enabled: false,
-      addAtR: 1,
-      addFrac: 0.25,
-      maxAdds: 1,
-      onlyAfterBreakEven: true,
-      ...options.pyramiding || {}
-    },
-    volScale: {
-      enabled: false,
-      atrPeriod: options.atrTrailPeriod ?? 14,
-      cutIfAtrX: 1.3,
-      cutFrac: 0.33,
-      noCutAboveR: 1.5,
-      ...options.volScale || {}
-    },
-    qtyStep: options.qtyStep ?? 1e-3,
-    minQty: options.minQty ?? 1e-3,
-    maxLeverage: options.maxLeverage ?? 2,
-    entryChase: {
-      enabled: true,
-      afterBars: 2,
-      maxSlipR: 0.2,
-      convertOnExpiry: false,
-      ...options.entryChase || {}
-    },
-    reanchorStopOnFill: options.reanchorStopOnFill ?? true,
-    maxSlipROnFill: options.maxSlipROnFill ?? 0.4,
-    collectEqSeries: options.collectEqSeries ?? true,
-    collectReplay: options.collectReplay ?? true,
-    strict: options.strict ?? false
-  };
-}
-function capitalForSize(entryPrice, size, maxLeverage) {
-  const leverage = Math.max(1, Number(maxLeverage) || 1);
-  return Math.abs(entryPrice) * Math.max(0, size) / leverage;
-}
-var BarSystemRunner = class {
-  constructor(rawOptions = {}) {
-    this.options = mergeOptions2(rawOptions);
-    const { candles, signal } = this.options;
-    if (!Array.isArray(candles) || candles.length === 0) {
-      throw new Error(
-        `backtestPortfolio() requires each system to include non-empty candles, got ${describeValue3(
-          candles
-        )} for ${this.options.symbol}`
-      );
-    }
-    if (typeof signal !== "function") {
-      throw new Error(
-        `backtestPortfolio() requires each system to include a signal function, got ${describeValue3(
-          signal
-        )} for ${this.options.symbol}`
-      );
-    }
-    this.symbol = this.options.symbol;
-    this.candles = candles;
-    this.closed = [];
-    this.currentEquity = this.options.equity;
-    this.open = null;
-    this.cooldown = 0;
-    this.pending = null;
-    this.currentDay = null;
-    this.dayPnl = 0;
-    this.dayTrades = 0;
-    this.dayEquityStart = this.options.equity;
-    this.tradeIdCounter = 0;
-    this.estimatedBarMs = estimateBarMs(candles);
-    const atrSourcePeriod = this.options.volScale.enabled ? this.options.volScale.atrPeriod : this.options.atrTrailPeriod;
-    const needAtr = this.options.atrTrailMult > 0 || this.options.volScale.enabled;
-    this.atrValues = needAtr ? atr(candles, atrSourcePeriod) : null;
-    this.wantEqSeries = Boolean(this.options.collectEqSeries);
-    this.wantReplay = Boolean(this.options.collectReplay);
-    this.eqSeries = this.wantEqSeries ? [equityPoint3(candles[0].time, this.currentEquity)] : [];
-    this.replayFrames = this.wantReplay ? [] : [];
-    this.replayEvents = this.wantReplay ? [] : [];
-    this.startIndex = Math.min(Math.max(1, this.options.warmupBars), candles.length);
-    this.history = candles.slice(0, this.startIndex);
-    this.index = this.startIndex;
-    this.lastBar = this.history.length ? this.history[this.history.length - 1] : null;
-  }
-  hasNext() {
-    return this.index < this.candles.length;
-  }
-  peekTime() {
-    return this.hasNext() ? this.candles[this.index].time : Infinity;
-  }
-  getLockedCapital() {
-    if (!this.open) return 0;
-    return capitalForSize(
-      this.open.entryFill ?? this.open.entry,
-      this.open.size,
-      this.options.maxLeverage
-    );
-  }
-  getMarkPrice() {
-    return this.lastBar?.close ?? null;
-  }
-  getMarkedEquity() {
-    if (!this.open || !this.lastBar) return this.currentEquity;
-    const direction = this.open.side === "long" ? 1 : -1;
-    const markPnl = (this.lastBar.close - (this.open.entryFill ?? this.open.entry)) * direction * this.open.size;
-    return this.currentEquity + markPnl;
-  }
-  recordFrame(bar, extraFrame = {}) {
-    if (this.wantEqSeries) {
-      this.eqSeries.push(equityPoint3(bar.time, this.currentEquity));
-    }
-    if (this.wantReplay) {
-      this.replayFrames.push({
-        t: new Date(bar.time).toISOString(),
-        price: bar.close,
-        equity: this.currentEquity,
-        posSide: this.open ? this.open.side : null,
-        posSize: this.open ? this.open.size : 0,
-        ...extraFrame
-      });
-    }
-  }
-  closeLeg({ openPos, qty, exitPx, exitFeeTotal = 0, time, reason }) {
-    const direction = openPos.side === "long" ? 1 : -1;
-    const entryFill = openPos.entryFill;
-    const grossPnl = (exitPx - entryFill) * direction * qty;
-    const entryFeePortion = (openPos.entryFeeTotal || 0) * (qty / openPos.initSize);
-    const pnl = grossPnl - entryFeePortion - exitFeeTotal;
-    this.currentEquity += pnl;
-    this.dayPnl += pnl;
-    if (this.wantEqSeries) {
-      this.eqSeries.push(equityPoint3(time, this.currentEquity));
-    }
-    const remaining = openPos.size - qty;
-    const eventType = reason === "SCALE" ? "scale-out" : reason === "TP" ? "tp" : reason === "SL" ? "sl" : reason === "EOD" ? "eod" : remaining <= 0 ? "exit" : "scale-out";
-    if (this.wantReplay) {
-      this.replayEvents.push({
-        t: new Date(time).toISOString(),
-        price: exitPx,
-        type: eventType,
-        side: openPos.side,
-        size: qty,
-        tradeId: openPos.id,
-        reason,
-        pnl,
-        symbol: this.symbol
-      });
-    }
-    const record = {
-      ...openPos,
-      size: qty,
-      exit: {
-        price: exitPx,
-        time,
-        reason,
-        pnl,
-        exitATR: openPos._lastATR ?? void 0
-      },
-      mfeR: openPos._mfeR ?? 0,
-      maeR: openPos._maeR ?? 0,
-      adds: openPos._adds ?? 0
-    };
-    this.closed.push(record);
-    openPos.size -= qty;
-    openPos._realized = (openPos._realized || 0) + pnl;
-    return record;
-  }
-  tightenStopToNetBreakeven(openPos, lastClose) {
-    if (!openPos || openPos.size <= 0) return;
-    const realized = openPos._realized || 0;
-    if (realized <= 0) return;
-    const direction = openPos.side === "long" ? 1 : -1;
-    const breakevenDelta = Math.abs(realized / openPos.size);
-    const breakevenPrice = direction === 1 ? openPos.entryFill - breakevenDelta : openPos.entryFill + breakevenDelta;
-    const tightened = direction === 1 ? Math.max(openPos.stop, breakevenPrice) : Math.min(openPos.stop, breakevenPrice);
-    openPos.stop = this.options.oco.clampStops ? clampStop(lastClose, tightened, openPos.side, this.options.oco) : tightened;
-  }
-  forceExit(reason, bar, overridePrice = null) {
-    if (!this.open || !bar) return;
-    const exitSide = this.open.side === "long" ? "short" : "long";
-    const exitBasePrice = overridePrice ?? bar.close;
-    const { price: filled, feeTotal: exitFeeTotal } = applyFill(exitBasePrice, exitSide, {
-      slippageBps: this.options.slippageBps,
-      feeBps: this.options.feeBps,
-      kind: "market",
-      qty: this.open.size,
-      costs: this.options.costs
-    });
-    this.closeLeg({
-      openPos: this.open,
-      qty: this.open.size,
-      exitPx: filled,
-      exitFeeTotal,
-      time: bar.time,
-      reason
-    });
-    this.cooldown = this.open?._cooldownBars || 0;
-    this.open = null;
-  }
-  cancelPending() {
-    this.pending = null;
-  }
-  openFromPending(bar, signalEquity, entryPrice, fillKind = "limit", resolveEntrySize) {
-    if (!this.pending) return false;
-    const plannedRisk = Math.max(
-      1e-8,
-      this.pending.plannedRiskAbs ?? Math.abs(this.pending.entry - this.pending.stop)
-    );
-    const slipR = Math.abs(entryPrice - this.pending.entry) / plannedRisk;
-    if (slipR > this.options.maxSlipROnFill) return false;
-    let stopPrice = this.pending.stop;
-    if (this.options.reanchorStopOnFill) {
-      const direction = this.pending.side === "long" ? 1 : -1;
-      stopPrice = direction === 1 ? entryPrice - plannedRisk : entryPrice + plannedRisk;
-    }
-    let takeProfit = this.pending.tp;
-    const immediateRisk = Math.abs(entryPrice - stopPrice) || 1e-8;
-    const rrHint = this.pending.meta?._rr;
-    if (this.options.reanchorStopOnFill && Number.isFinite(rrHint)) {
-      const plannedTarget = this.pending.side === "long" ? this.pending.entry + rrHint * plannedRisk : this.pending.entry - rrHint * plannedRisk;
-      const closeEnough = Math.abs((this.pending.tp ?? plannedTarget) - plannedTarget) <= Math.max(1e-8, plannedRisk * 1e-6);
-      if (closeEnough) {
-        takeProfit = this.pending.side === "long" ? entryPrice + rrHint * immediateRisk : entryPrice - rrHint * immediateRisk;
-      }
-    }
-    const desiredSize = this.pending.fixedQty ?? calculatePositionSize({
-      equity: signalEquity,
-      entry: entryPrice,
-      stop: stopPrice,
-      riskFraction: this.pending.riskFrac,
-      qtyStep: this.options.qtyStep,
-      minQty: this.options.minQty,
-      maxLeverage: this.options.maxLeverage
-    });
-    const approvedSize = typeof resolveEntrySize === "function" ? resolveEntrySize({
-      runner: this,
-      desiredSize,
-      entryPrice,
-      stopPrice,
-      pending: this.pending,
-      fillKind
-    }) : desiredSize;
-    const size = roundStep2(approvedSize, this.options.qtyStep);
-    if (size < this.options.minQty) return false;
-    const { price: entryFill, feeTotal: entryFeeTotal } = applyFill(entryPrice, this.pending.side, {
-      slippageBps: this.options.slippageBps,
-      feeBps: this.options.feeBps,
-      kind: fillKind,
-      qty: size,
-      costs: this.options.costs
-    });
-    this.open = {
-      symbol: this.symbol,
-      ...this.pending.meta,
-      id: ++this.tradeIdCounter,
-      side: this.pending.side,
-      entry: entryPrice,
-      stop: stopPrice,
-      takeProfit,
-      size,
-      openTime: bar.time,
-      entryFill,
-      entryFeeTotal,
-      initSize: size,
-      baseSize: size,
-      _mfeR: 0,
-      _maeR: 0,
-      _adds: 0,
-      _initRisk: Math.abs(entryPrice - stopPrice) || 1e-8
-    };
-    if (this.atrValues && this.atrValues[this.index] !== void 0) {
-      this.open.entryATR = this.atrValues[this.index];
-      this.open._lastATR = this.atrValues[this.index];
-    }
-    this.dayTrades += 1;
-    this.pending = null;
-    if (this.wantReplay) {
-      this.replayEvents.push({
-        t: new Date(bar.time).toISOString(),
-        price: entryFill,
-        type: "entry",
-        side: this.open.side,
-        size,
-        tradeId: this.open.id,
-        symbol: this.symbol
-      });
-    }
-    return true;
-  }
-  buildSignalContext(index, bar, signalEquity) {
-    if (this.options.strict && this.history.length !== index + 1) {
-      throw new Error(
-        `strict mode: signal() received ${this.history.length} candles at index ${index}`
-      );
-    }
-    return {
-      candles: this.options.strict ? strictHistoryView2(this.history, index) : this.history,
-      index,
-      bar,
-      equity: signalEquity,
-      openPosition: this.open,
-      pendingOrder: this.pending
-    };
-  }
-  step({ signalEquity, canTrade = true, resolveEntrySize } = {}) {
-    if (!this.hasNext()) return null;
-    const bar = this.candles[this.index];
-    this.history.push(bar);
-    this.lastBar = bar;
-    const trigger = this.options.triggerMode || this.options.oco.mode || "intrabar";
-    const dayKey = this.options.flattenAtClose || trigger === "close" ? dayKeyET(bar.time) : dayKeyUTC2(bar.time);
-    if (this.currentDay === null || dayKey !== this.currentDay) {
-      this.currentDay = dayKey;
-      this.dayPnl = 0;
-      this.dayTrades = 0;
-      this.dayEquityStart = this.currentEquity;
-    }
-    if (this.open && this.open._maxBarsInTrade > 0) {
-      const barsHeld = Math.max(
-        1,
-        Math.round((bar.time - this.open.openTime) / this.estimatedBarMs)
-      );
-      if (barsHeld >= this.open._maxBarsInTrade) {
-        this.forceExit("TIME", bar);
+    if (this.open && this.open._maxBarsInTrade > 0) {
+      const barsHeld = Math.max(
+        1,
+        Math.round((bar.time - this.open.openTime) / this.estimatedBarMs)
+      );
+      if (barsHeld >= this.open._maxBarsInTrade) {
+        this.forceExit("TIME", bar);
       }
     }
     if (this.open && Number.isFinite(this.open._maxHoldMin) && this.open._maxHoldMin > 0) {
@@ -2641,205 +2375,706 @@ var BarSystemRunner = class {
           }
         }
       }
-      if (!addedThisBar && !this.open._scaled && this.options.scaleOutAtR > 0) {
-        const triggerPrice = this.open.side === "long" ? this.open.entry + this.options.scaleOutAtR * risk : this.open.entry - this.options.scaleOutAtR * risk;
-        const touched = this.open.side === "long" ? trigger === "intrabar" ? bar.high >= triggerPrice : bar.close >= triggerPrice : trigger === "intrabar" ? bar.low <= triggerPrice : bar.close <= triggerPrice;
-        if (touched) {
-          const exitSide2 = this.open.side === "long" ? "short" : "long";
-          const qty = roundStep2(this.open.size * this.options.scaleOutFrac, this.options.qtyStep);
-          if (qty >= this.options.minQty && qty < this.open.size) {
-            const { price: filled, feeTotal: exitFeeTotal } = applyFill(triggerPrice, exitSide2, {
-              slippageBps: this.options.slippageBps,
-              feeBps: this.options.feeBps,
-              kind: "limit",
-              qty,
-              costs: this.options.costs
-            });
-            this.closeLeg({
-              openPos: this.open,
-              qty,
-              exitPx: filled,
-              exitFeeTotal,
-              time: bar.time,
-              reason: "SCALE"
-            });
-            this.open._scaled = true;
-            this.open.takeProfit = this.open.side === "long" ? this.open.entry + this.options.finalTP_R * risk : this.open.entry - this.options.finalTP_R * risk;
-            this.tightenStopToNetBreakeven(this.open, bar.close);
-            this.open._beArmed = true;
-          }
+      if (!addedThisBar && !this.open._scaled && this.options.scaleOutAtR > 0) {
+        const triggerPrice = this.open.side === "long" ? this.open.entry + this.options.scaleOutAtR * risk : this.open.entry - this.options.scaleOutAtR * risk;
+        const touched = this.open.side === "long" ? trigger === "intrabar" ? bar.high >= triggerPrice : bar.close >= triggerPrice : trigger === "intrabar" ? bar.low <= triggerPrice : bar.close <= triggerPrice;
+        if (touched) {
+          const exitSide2 = this.open.side === "long" ? "short" : "long";
+          const qty = roundStep2(this.open.size * this.options.scaleOutFrac, this.options.qtyStep);
+          if (qty >= this.options.minQty && qty < this.open.size) {
+            const { price: filled, feeTotal: exitFeeTotal } = applyFill(triggerPrice, exitSide2, {
+              slippageBps: this.options.slippageBps,
+              feeBps: this.options.feeBps,
+              kind: "limit",
+              qty,
+              costs: this.options.costs
+            });
+            this.closeLeg({
+              openPos: this.open,
+              qty,
+              exitPx: filled,
+              exitFeeTotal,
+              time: bar.time,
+              reason: "SCALE"
+            });
+            this.open._scaled = true;
+            this.open.takeProfit = this.open.side === "long" ? this.open.entry + this.options.finalTP_R * risk : this.open.entry - this.options.finalTP_R * risk;
+            this.tightenStopToNetBreakeven(this.open, bar.close);
+            this.open._beArmed = true;
+          }
+        }
+      }
+      const exitSide = this.open.side === "long" ? "short" : "long";
+      const { hit, px } = ocoExitCheck({
+        side: this.open.side,
+        stop: this.open.stop,
+        tp: this.open.takeProfit,
+        bar,
+        mode: this.options.oco.mode,
+        tieBreak: this.options.oco.tieBreak
+      });
+      if (hit) {
+        const exitKind = hit === "TP" ? "limit" : "stop";
+        const { price: filled, feeTotal: exitFeeTotal } = applyFill(px, exitSide, {
+          slippageBps: this.options.slippageBps,
+          feeBps: this.options.feeBps,
+          kind: exitKind,
+          qty: this.open.size,
+          costs: this.options.costs
+        });
+        const localCooldown = this.open._cooldownBars || 0;
+        this.closeLeg({
+          openPos: this.open,
+          qty: this.open.size,
+          exitPx: filled,
+          exitFeeTotal,
+          time: bar.time,
+          reason: hit
+        });
+        this.cooldown = (hit === "SL" ? Math.max(this.cooldown, this.options.postLossCooldownBars) : this.cooldown) || localCooldown;
+        this.open = null;
+      }
+    }
+    const maxLossDollars = this.options.maxDailyLossPct / 100 * this.dayEquityStart;
+    const dailyLossHit = this.dayPnl <= -Math.abs(maxLossDollars);
+    const dailyTradeCapHit = this.options.dailyMaxTrades > 0 && this.dayTrades >= this.options.dailyMaxTrades;
+    if (!this.open && this.pending) {
+      if (!canTrade) {
+        this.pending = null;
+      } else if (this.index > this.pending.expiresAt || dailyLossHit || dailyTradeCapHit) {
+        if (this.options.entryChase.enabled && this.options.entryChase.convertOnExpiry) {
+          const riskAtEdge = Math.abs(
+            this.pending.meta._initRisk ?? this.pending.entry - this.pending.stop
+          );
+          const priceNow = bar.close;
+          const direction = this.pending.side === "long" ? 1 : -1;
+          const slippedR = Math.max(
+            0,
+            direction === 1 ? priceNow - this.pending.entry : this.pending.entry - priceNow
+          ) / Math.max(1e-8, riskAtEdge);
+          if (slippedR > this.options.maxSlipROnFill) {
+            this.pending = null;
+          } else if (!this.openFromPending(bar, signalEquity, priceNow, "market", resolveEntrySize)) {
+            this.pending = null;
+          }
+        } else {
+          this.pending = null;
+        }
+      } else if (touchedLimit(this.pending.side, this.pending.entry, bar, trigger)) {
+        if (!this.openFromPending(bar, signalEquity, this.pending.entry, "limit", resolveEntrySize)) {
+          this.pending = null;
+        }
+      } else if (this.options.entryChase.enabled) {
+        const elapsedBars = this.index - (this.pending.startedAtIndex ?? this.index);
+        const midpoint = asNumber2(this.pending.meta?._imb?.mid);
+        if (!this.pending._chasedCE && midpoint !== null && elapsedBars >= Math.max(1, this.options.entryChase.afterBars)) {
+          this.pending.entry = midpoint;
+          this.pending._chasedCE = true;
+        }
+        if (this.pending._chasedCE) {
+          const riskRef = Math.abs(
+            this.pending.meta?._initRisk ?? this.pending.entry - this.pending.stop
+          );
+          const priceNow = bar.close;
+          const direction = this.pending.side === "long" ? 1 : -1;
+          const slippedR = Math.max(
+            0,
+            direction === 1 ? priceNow - this.pending.entry : this.pending.entry - priceNow
+          ) / Math.max(1e-8, riskRef);
+          if (slippedR > this.options.maxSlipROnFill) {
+            this.pending = null;
+          } else if (slippedR > 0 && slippedR <= this.options.entryChase.maxSlipR) {
+            if (!this.openFromPending(bar, signalEquity, priceNow, "market", resolveEntrySize)) {
+              this.pending = null;
+            }
+          }
+        }
+      }
+    }
+    if (this.open || this.cooldown > 0) {
+      if (this.cooldown > 0) this.cooldown -= 1;
+      this.recordFrame(bar);
+      this.index += 1;
+      return { handled: true, bar };
+    }
+    if (!canTrade || dailyLossHit || dailyTradeCapHit) {
+      this.pending = null;
+      this.recordFrame(bar);
+      this.index += 1;
+      return { handled: true, bar };
+    }
+    if (this.pending) {
+      this.recordFrame(bar);
+      this.index += 1;
+      return { handled: true, bar };
+    }
+    return {
+      handled: false,
+      bar,
+      trigger,
+      signalEquity,
+      resolveEntrySize
+    };
+  }
+  _applyRawSignal(rawSignal, pre) {
+    const { bar, trigger, signalEquity, resolveEntrySize } = pre;
+    const nextSignal = normalizeSignal2(rawSignal, bar, this.options.finalTP_R);
+    if (nextSignal) {
+      const signalRiskFraction = Number.isFinite(nextSignal.riskFraction) ? nextSignal.riskFraction : Number.isFinite(nextSignal.riskPct) ? nextSignal.riskPct / 100 : this.options.riskPct / 100;
+      const expiryBars = nextSignal._entryExpiryBars ?? 5;
+      this.pending = {
+        side: nextSignal.side,
+        entry: nextSignal.entry,
+        stop: nextSignal.stop,
+        tp: nextSignal.takeProfit,
+        riskFrac: signalRiskFraction,
+        fixedQty: nextSignal.qty,
+        expiresAt: this.index + Math.max(1, expiryBars),
+        startedAtIndex: this.index,
+        meta: nextSignal,
+        plannedRiskAbs: Math.abs(nextSignal._initRisk ?? nextSignal.entry - nextSignal.stop)
+      };
+      if (touchedLimit(this.pending.side, this.pending.entry, bar, trigger)) {
+        if (!this.openFromPending(bar, signalEquity, this.pending.entry, "limit", resolveEntrySize)) {
+          this.pending = null;
         }
       }
-      const exitSide = this.open.side === "long" ? "short" : "long";
+    }
+    this.recordFrame(bar);
+    this.index += 1;
+    return bar;
+  }
+  step(options = {}) {
+    const pre = this._preSignal(options);
+    if (pre.handled) return pre.bar;
+    const rawSignal = callSignalWithContext2({
+      signal: this.options.signal,
+      context: this.buildSignalContext(this.index, pre.bar, pre.signalEquity),
+      index: this.index,
+      bar: pre.bar,
+      symbol: this.symbol
+    });
+    return this._applyRawSignal(rawSignal, pre);
+  }
+  async stepAsync(options = {}) {
+    const pre = this._preSignal(options);
+    if (pre.handled) return pre.bar;
+    const rawSignal = await callSignalWithContextAsync({
+      signal: this.options.signal,
+      context: this.buildSignalContext(this.index, pre.bar, pre.signalEquity),
+      index: this.index,
+      bar: pre.bar,
+      symbol: this.symbol
+    });
+    return this._applyRawSignal(rawSignal, pre);
+  }
+  buildResult() {
+    const metrics = buildMetrics({
+      closed: this.closed,
+      equityStart: this.options.equity,
+      equityFinal: this.currentEquity,
+      candles: this.candles,
+      estBarMs: this.estimatedBarMs,
+      eqSeries: this.eqSeries,
+      interval: this.options.interval
+    });
+    const positions = this.closed.filter((trade) => trade.exit.reason !== "SCALE");
+    const lastPrice = asNumber2(this.candles[this.candles.length - 1]?.close);
+    const openPositions = this.open ? [snapshotOpenPosition2(this.open, lastPrice ?? this.open.entryFill ?? this.open.entry)] : [];
+    return {
+      symbol: this.options.symbol,
+      interval: this.options.interval,
+      range: this.options.range,
+      trades: this.closed,
+      positions,
+      openPositions,
+      metrics,
+      eqSeries: this.eqSeries,
+      replay: {
+        frames: this.replayFrames,
+        events: this.replayEvents
+      }
+    };
+  }
+};
+function defaultSystemCap(totalEquity, capPct, maxAllocation, maxAllocationPct) {
+  const limits = [];
+  if (Number.isFinite(capPct) && capPct > 0) limits.push(totalEquity * capPct);
+  if (Number.isFinite(maxAllocation) && maxAllocation > 0) limits.push(maxAllocation);
+  if (Number.isFinite(maxAllocationPct) && maxAllocationPct > 0) {
+    limits.push(totalEquity * maxAllocationPct);
+  }
+  return limits.length ? Math.min(...limits) : Math.max(0, totalEquity);
+}
+
+// src/engine/asyncSignal.js
+var BudgetExceededError = class extends Error {
+  constructor(ms) {
+    super(`signal() exceeded its ${ms}ms per-bar budget`);
+    this.name = "BudgetExceededError";
+    this.budgetMs = ms;
+  }
+};
+function withBudget(promise, budgetMs) {
+  if (!budgetMs || budgetMs <= 0) return Promise.resolve(promise);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new BudgetExceededError(budgetMs)), budgetMs);
+    Promise.resolve(promise).then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+
+// src/engine/backtestAsync.js
+async function backtestAsync(rawOptions = {}) {
+  const budgetMs = rawOptions.signalBudgetMs ?? 0;
+  const userSignal = rawOptions.signal;
+  const budgetedSignal = (context) => withBudget(
+    Promise.resolve().then(() => userSignal(context)),
+    budgetMs
+  );
+  const runner = new BarSystemRunner({ ...rawOptions, signal: budgetedSignal });
+  while (runner.hasNext()) {
+    await runner.stepAsync({ signalEquity: runner.getMarkedEquity() });
+  }
+  return runner.buildResult();
+}
+
+// src/engine/backtestTicks.js
+function asNumber3(value) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function describeValue3(value) {
+  if (Array.isArray(value)) return `array(length=${value.length})`;
+  if (value === null) return "null";
+  return typeof value;
+}
+function formatIsoTime3(time) {
+  return Number.isFinite(time) ? new Date(time).toISOString() : "invalid-time";
+}
+function callSignalWithContext3({ signal, context, index, bar, symbol }) {
+  try {
+    return signal(context);
+  } catch (error) {
+    const cause = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `signal() threw at index=${index}, time=${formatIsoTime3(bar?.time)}, symbol=${symbol}: ${cause}`
+    );
+  }
+}
+function normalizeSide3(value) {
+  if (value === "long" || value === "buy") return "long";
+  if (value === "short" || value === "sell") return "short";
+  return null;
+}
+function normalizeTick(tick) {
+  const time = Number(tick?.time);
+  const bid = asNumber3(tick?.bid);
+  const ask = asNumber3(tick?.ask);
+  const last = asNumber3(tick?.price ?? tick?.last ?? tick?.close);
+  const mid = bid !== null && ask !== null ? (bid + ask) / 2 : last ?? bid ?? ask;
+  if (!Number.isFinite(time) || !Number.isFinite(mid)) return null;
+  const prices = [asNumber3(tick?.low), asNumber3(tick?.high), bid, ask, last, mid].filter(
+    Number.isFinite
+  );
+  const low = prices.length ? Math.min(...prices) : mid;
+  const high = prices.length ? Math.max(...prices) : mid;
+  return {
+    ...tick,
+    time,
+    open: mid,
+    high,
+    low,
+    close: mid,
+    volume: asNumber3(tick?.size ?? tick?.volume) ?? void 0
+  };
+}
+function normalizeSignal3(signal, bar, fallbackR) {
+  if (!signal) return null;
+  const side = normalizeSide3(signal.side ?? signal.direction ?? signal.action);
+  if (!side) return null;
+  const hasExplicitEntry = signal.entry !== void 0 || signal.limit !== void 0 || signal.price !== void 0;
+  const entry = asNumber3(signal.entry ?? signal.limit ?? signal.price) ?? asNumber3(bar?.close);
+  const stop = asNumber3(signal.stop ?? signal.stopLoss ?? signal.sl);
+  if (entry === null || stop === null) return null;
+  const risk = Math.abs(entry - stop);
+  if (!(risk > 0)) return null;
+  let takeProfit = asNumber3(signal.takeProfit ?? signal.target ?? signal.tp);
+  const rrHint = asNumber3(signal._rr ?? signal.rr);
+  const targetR = rrHint ?? fallbackR;
+  if (takeProfit === null && Number.isFinite(targetR) && targetR > 0) {
+    takeProfit = side === "long" ? entry + risk * targetR : entry - risk * targetR;
+  }
+  if (takeProfit === null) return null;
+  return {
+    ...signal,
+    side,
+    entry,
+    stop,
+    takeProfit,
+    qty: asNumber3(signal.qty ?? signal.size),
+    riskPct: asNumber3(signal.riskPct),
+    riskFraction: asNumber3(signal.riskFraction),
+    orderType: hasExplicitEntry ? "limit" : "market"
+  };
+}
+function equityPoint3(time, equity) {
+  return { time, timestamp: time, equity };
+}
+function xmur3(seed) {
+  let hash = 1779033703 ^ seed.length;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash = Math.imul(hash ^ seed.charCodeAt(index), 3432918353);
+    hash = hash << 13 | hash >>> 19;
+  }
+  return () => {
+    hash = Math.imul(hash ^ hash >>> 16, 2246822507);
+    hash = Math.imul(hash ^ hash >>> 13, 3266489909);
+    return (hash ^= hash >>> 16) >>> 0;
+  };
+}
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let value = Math.imul(state ^ state >>> 15, state | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+function seededUnitInterval(seedParts) {
+  const seed = seedParts.map((part) => String(part)).join("|");
+  const seedFn = xmur3(seed);
+  return mulberry32(seedFn())();
+}
+function deterministicFill(probability, seedParts) {
+  if (probability >= 1) return true;
+  if (probability <= 0) return false;
+  const normalized = seededUnitInterval(seedParts);
+  return normalized <= probability;
+}
+function backtestTicks({
+  ticks = [],
+  symbol = "UNKNOWN",
+  equity = 1e4,
+  riskPct = 1,
+  signal,
+  interval,
+  range,
+  slippageBps = 1,
+  feeBps = 0,
+  costs = null,
+  finalTP_R = 3,
+  maxDailyLossPct = 0,
+  dailyMaxTrades = 0,
+  qtyStep = 1e-3,
+  minQty = 1e-3,
+  maxLeverage = 2,
+  collectEqSeries = true,
+  collectReplay = true,
+  queueFillProbability = 1,
+  seed = "tradelab-ticks",
+  oco = {}
+} = {}) {
+  if (!Array.isArray(ticks) || ticks.length === 0) {
+    throw new Error(
+      `backtestTicks() requires a non-empty ticks array, got ${describeValue3(ticks)}`
+    );
+  }
+  if (typeof signal !== "function") {
+    throw new Error(`backtestTicks() requires a signal function, got ${describeValue3(signal)}`);
+  }
+  const normalizedTicks = ticks.map(normalizeTick).filter(Boolean);
+  if (!normalizedTicks.length) {
+    throw new Error(
+      `backtestTicks() could not normalize any ticks from ${ticks.length} input rows`
+    );
+  }
+  const ocoOptions = {
+    mode: "intrabar",
+    tieBreak: "pessimistic",
+    ...oco
+  };
+  const trades = [];
+  const eqSeries = collectEqSeries ? [equityPoint3(normalizedTicks[0].time, equity)] : [];
+  const replayFrames = collectReplay ? [] : [];
+  const replayEvents = collectReplay ? [] : [];
+  const history = [];
+  let open = null;
+  let pending = null;
+  let currentEquity = equity;
+  let dayKey = null;
+  let dayStartEquity = equity;
+  let dayPnl = 0;
+  let dayTrades = 0;
+  let tradeIdCounter = 0;
+  function markedEquity(tick) {
+    if (!open) return currentEquity;
+    const direction = open.side === "long" ? 1 : -1;
+    return currentEquity + (tick.close - open.entryFill) * direction * open.size;
+  }
+  function recordFrame(tick) {
+    const equityNow = markedEquity(tick);
+    if (collectEqSeries) {
+      eqSeries.push(equityPoint3(tick.time, equityNow));
+    }
+    if (collectReplay) {
+      replayFrames.push({
+        t: new Date(tick.time).toISOString(),
+        price: tick.close,
+        equity: equityNow,
+        posSide: open?.side ?? null,
+        posSize: open?.size ?? 0
+      });
+    }
+  }
+  function closePosition(tick, reason, rawPrice, fillKind) {
+    if (!open) return;
+    const exitSide = open.side === "long" ? "short" : "long";
+    const { price, feeTotal } = applyFill(rawPrice, exitSide, {
+      slippageBps,
+      feeBps,
+      kind: fillKind,
+      qty: open.size,
+      costs
+    });
+    const direction = open.side === "long" ? 1 : -1;
+    const grossPnl = (price - open.entryFill) * direction * open.size;
+    const financing = financingCost({
+      side: open.side,
+      notional: open.entryFill * open.size,
+      fromMs: open.openTime,
+      toMs: tick.time,
+      costs
+    });
+    const pnl = grossPnl - (open.entryFeeTotal || 0) - feeTotal - financing;
+    currentEquity += pnl;
+    dayPnl += pnl;
+    const trade = {
+      ...open,
+      exit: {
+        price,
+        time: tick.time,
+        reason,
+        pnl,
+        financing
+      }
+    };
+    trades.push(trade);
+    if (collectReplay) {
+      replayEvents.push({
+        t: new Date(tick.time).toISOString(),
+        price,
+        type: reason === "TP" ? "tp" : reason === "SL" ? "sl" : "exit",
+        side: open.side,
+        size: open.size,
+        tradeId: open.id,
+        reason,
+        pnl
+      });
+    }
+    open = null;
+  }
+  for (let index = 0; index < normalizedTicks.length; index += 1) {
+    const tick = normalizedTicks[index];
+    history.push(tick);
+    const currentDayKey = dayKeyUTC2(tick.time);
+    if (dayKey === null || currentDayKey !== dayKey) {
+      dayKey = currentDayKey;
+      dayStartEquity = currentEquity;
+      dayPnl = 0;
+      dayTrades = 0;
+    }
+    if (open) {
       const { hit, px } = ocoExitCheck({
-        side: this.open.side,
-        stop: this.open.stop,
-        tp: this.open.takeProfit,
-        bar,
-        mode: this.options.oco.mode,
-        tieBreak: this.options.oco.tieBreak
+        side: open.side,
+        stop: open.stop,
+        tp: open.takeProfit,
+        bar: tick,
+        mode: "intrabar",
+        tieBreak: ocoOptions.tieBreak
       });
       if (hit) {
-        const exitKind = hit === "TP" ? "limit" : "stop";
-        const { price: filled, feeTotal: exitFeeTotal } = applyFill(px, exitSide, {
-          slippageBps: this.options.slippageBps,
-          feeBps: this.options.feeBps,
-          kind: exitKind,
-          qty: this.open.size,
-          costs: this.options.costs
-        });
-        const localCooldown = this.open._cooldownBars || 0;
-        this.closeLeg({
-          openPos: this.open,
-          qty: this.open.size,
-          exitPx: filled,
-          exitFeeTotal,
-          time: bar.time,
-          reason: hit
-        });
-        this.cooldown = (hit === "SL" ? Math.max(this.cooldown, this.options.postLossCooldownBars) : this.cooldown) || localCooldown;
-        this.open = null;
+        closePosition(tick, hit, px, hit === "TP" ? "limit" : "stop");
       }
     }
-    const maxLossDollars = this.options.maxDailyLossPct / 100 * this.dayEquityStart;
-    const dailyLossHit = this.dayPnl <= -Math.abs(maxLossDollars);
-    const dailyTradeCapHit = this.options.dailyMaxTrades > 0 && this.dayTrades >= this.options.dailyMaxTrades;
-    if (!this.open && this.pending) {
-      if (!canTrade) {
-        this.pending = null;
-      } else if (this.index > this.pending.expiresAt || dailyLossHit || dailyTradeCapHit) {
-        if (this.options.entryChase.enabled && this.options.entryChase.convertOnExpiry) {
-          const riskAtEdge = Math.abs(
-            this.pending.meta._initRisk ?? this.pending.entry - this.pending.stop
-          );
-          const priceNow = bar.close;
-          const direction = this.pending.side === "long" ? 1 : -1;
-          const slippedR = Math.max(
-            0,
-            direction === 1 ? priceNow - this.pending.entry : this.pending.entry - priceNow
-          ) / Math.max(1e-8, riskAtEdge);
-          if (slippedR > this.options.maxSlipROnFill) {
-            this.pending = null;
-          } else if (!this.openFromPending(bar, signalEquity, priceNow, "market", resolveEntrySize)) {
-            this.pending = null;
+    if (!open && pending && index > pending.createdAtIndex) {
+      if (pending.orderType === "market") {
+        const rawSize = pending.fixedQty ?? calculatePositionSize({
+          equity: currentEquity,
+          entry: tick.close,
+          stop: pending.stop,
+          riskFraction: pending.riskFrac,
+          qtyStep,
+          minQty,
+          maxLeverage
+        });
+        const size = roundStep2(rawSize, qtyStep);
+        if (size >= minQty) {
+          const { price, feeTotal } = applyFill(tick.close, pending.side, {
+            slippageBps,
+            feeBps,
+            kind: "market",
+            qty: size,
+            costs
+          });
+          open = {
+            symbol,
+            id: ++tradeIdCounter,
+            side: pending.side,
+            entry: tick.close,
+            stop: pending.stop,
+            takeProfit: pending.takeProfit,
+            size,
+            openTime: tick.time,
+            entryFill: price,
+            entryFeeTotal: feeTotal,
+            _initRisk: Math.abs(tick.close - pending.stop)
+          };
+          dayTrades += 1;
+          if (collectReplay) {
+            replayEvents.push({
+              t: new Date(tick.time).toISOString(),
+              price,
+              type: "entry",
+              side: open.side,
+              size,
+              tradeId: open.id
+            });
           }
-        } else {
-          this.pending = null;
-        }
-      } else if (touchedLimit(this.pending.side, this.pending.entry, bar, trigger)) {
-        if (!this.openFromPending(bar, signalEquity, this.pending.entry, "limit", resolveEntrySize)) {
-          this.pending = null;
-        }
-      } else if (this.options.entryChase.enabled) {
-        const elapsedBars = this.index - (this.pending.startedAtIndex ?? this.index);
-        const midpoint = asNumber3(this.pending.meta?._imb?.mid);
-        if (!this.pending._chasedCE && midpoint !== null && elapsedBars >= Math.max(1, this.options.entryChase.afterBars)) {
-          this.pending.entry = midpoint;
-          this.pending._chasedCE = true;
         }
-        if (this.pending._chasedCE) {
-          const riskRef = Math.abs(
-            this.pending.meta?._initRisk ?? this.pending.entry - this.pending.stop
-          );
-          const priceNow = bar.close;
-          const direction = this.pending.side === "long" ? 1 : -1;
-          const slippedR = Math.max(
-            0,
-            direction === 1 ? priceNow - this.pending.entry : this.pending.entry - priceNow
-          ) / Math.max(1e-8, riskRef);
-          if (slippedR > this.options.maxSlipROnFill) {
-            this.pending = null;
-          } else if (slippedR > 0 && slippedR <= this.options.entryChase.maxSlipR) {
-            if (!this.openFromPending(bar, signalEquity, priceNow, "market", resolveEntrySize)) {
-              this.pending = null;
+        pending = null;
+      } else {
+        const touched = pending.side === "long" ? tick.low <= pending.entry : tick.high >= pending.entry;
+        if (touched && deterministicFill(queueFillProbability, [
+          seed,
+          symbol,
+          tick.time,
+          pending.entry,
+          pending.stop,
+          pending.side
+        ])) {
+          const rawSize = pending.fixedQty ?? calculatePositionSize({
+            equity: currentEquity,
+            entry: pending.entry,
+            stop: pending.stop,
+            riskFraction: pending.riskFrac,
+            qtyStep,
+            minQty,
+            maxLeverage
+          });
+          const size = roundStep2(rawSize, qtyStep);
+          if (size >= minQty) {
+            const { price, feeTotal } = applyFill(pending.entry, pending.side, {
+              slippageBps,
+              feeBps,
+              kind: "limit",
+              qty: size,
+              costs
+            });
+            open = {
+              symbol,
+              id: ++tradeIdCounter,
+              side: pending.side,
+              entry: pending.entry,
+              stop: pending.stop,
+              takeProfit: pending.takeProfit,
+              size,
+              openTime: tick.time,
+              entryFill: price,
+              entryFeeTotal: feeTotal,
+              _initRisk: Math.abs(pending.entry - pending.stop)
+            };
+            dayTrades += 1;
+            if (collectReplay) {
+              replayEvents.push({
+                t: new Date(tick.time).toISOString(),
+                price,
+                type: "entry",
+                side: open.side,
+                size,
+                tradeId: open.id
+              });
             }
           }
+          pending = null;
         }
       }
     }
-    if (this.open || this.cooldown > 0) {
-      if (this.cooldown > 0) this.cooldown -= 1;
-      this.recordFrame(bar);
-      this.index += 1;
-      return bar;
-    }
-    if (!canTrade || dailyLossHit || dailyTradeCapHit) {
-      this.pending = null;
-      this.recordFrame(bar);
-      this.index += 1;
-      return bar;
-    }
-    if (!this.pending) {
-      const rawSignal = callSignalWithContext3({
-        signal: this.options.signal,
-        context: this.buildSignalContext(this.index, bar, signalEquity),
-        index: this.index,
-        bar,
-        symbol: this.symbol
-      });
-      const nextSignal = normalizeSignal3(rawSignal, bar, this.options.finalTP_R);
+    const maxLossDollars = Math.abs(maxDailyLossPct) / 100 * dayStartEquity;
+    const dailyLossHit = maxDailyLossPct > 0 && dayPnl <= -maxLossDollars;
+    const dailyTradeCapHit = dailyMaxTrades > 0 && dayTrades >= dailyMaxTrades;
+    if (!open && !pending && !dailyLossHit && !dailyTradeCapHit) {
+      const nextSignal = normalizeSignal3(
+        callSignalWithContext3({
+          signal,
+          context: {
+            candles: history,
+            index,
+            bar: tick,
+            equity: markedEquity(tick),
+            openPosition: open,
+            pendingOrder: pending
+          },
+          index,
+          bar: tick,
+          symbol
+        }),
+        tick,
+        finalTP_R
+      );
       if (nextSignal) {
-        const signalRiskFraction = Number.isFinite(nextSignal.riskFraction) ? nextSignal.riskFraction : Number.isFinite(nextSignal.riskPct) ? nextSignal.riskPct / 100 : this.options.riskPct / 100;
-        const expiryBars = nextSignal._entryExpiryBars ?? 5;
-        this.pending = {
+        pending = {
           side: nextSignal.side,
           entry: nextSignal.entry,
           stop: nextSignal.stop,
-          tp: nextSignal.takeProfit,
-          riskFrac: signalRiskFraction,
+          takeProfit: nextSignal.takeProfit,
           fixedQty: nextSignal.qty,
-          expiresAt: this.index + Math.max(1, expiryBars),
-          startedAtIndex: this.index,
-          meta: nextSignal,
-          plannedRiskAbs: Math.abs(nextSignal._initRisk ?? nextSignal.entry - nextSignal.stop)
+          riskFrac: Number.isFinite(nextSignal.riskFraction) ? nextSignal.riskFraction : Number.isFinite(nextSignal.riskPct) ? nextSignal.riskPct / 100 : riskPct / 100,
+          orderType: nextSignal.orderType,
+          createdAtIndex: index
         };
-        if (touchedLimit(this.pending.side, this.pending.entry, bar, trigger)) {
-          if (!this.openFromPending(bar, signalEquity, this.pending.entry, "limit", resolveEntrySize)) {
-            this.pending = null;
-          }
-        }
       }
     }
-    this.recordFrame(bar);
-    this.index += 1;
-    return bar;
-  }
-  buildResult() {
-    const metrics = buildMetrics({
-      closed: this.closed,
-      equityStart: this.options.equity,
-      equityFinal: this.currentEquity,
-      candles: this.candles,
-      estBarMs: this.estimatedBarMs,
-      eqSeries: this.eqSeries
-    });
-    const positions = this.closed.filter((trade) => trade.exit.reason !== "SCALE");
-    const lastPrice = asNumber3(this.candles[this.candles.length - 1]?.close);
-    const openPositions = this.open ? [snapshotOpenPosition2(this.open, lastPrice ?? this.open.entryFill ?? this.open.entry)] : [];
-    return {
-      symbol: this.options.symbol,
-      interval: this.options.interval,
-      range: this.options.range,
-      trades: this.closed,
-      positions,
-      openPositions,
-      metrics,
-      eqSeries: this.eqSeries,
-      replay: {
-        frames: this.replayFrames,
-        events: this.replayEvents
-      }
-    };
+    recordFrame(tick);
   }
-};
-function defaultSystemCap(totalEquity, capPct, maxAllocation, maxAllocationPct) {
-  const limits = [];
-  if (Number.isFinite(capPct) && capPct > 0) limits.push(totalEquity * capPct);
-  if (Number.isFinite(maxAllocation) && maxAllocation > 0) limits.push(maxAllocation);
-  if (Number.isFinite(maxAllocationPct) && maxAllocationPct > 0) {
-    limits.push(totalEquity * maxAllocationPct);
+  if (open) {
+    const lastTick = normalizedTicks[normalizedTicks.length - 1];
+    closePosition(lastTick, "EOT", lastTick.close, "market");
+    recordFrame(lastTick);
   }
-  return limits.length ? Math.min(...limits) : Math.max(0, totalEquity);
+  const positions = trades;
+  const metrics = buildMetrics({
+    closed: trades,
+    equityStart: equity,
+    equityFinal: currentEquity,
+    candles: normalizedTicks,
+    estBarMs: normalizedTicks.length > 1 ? Math.max(1, normalizedTicks[1].time - normalizedTicks[0].time) : 1,
+    eqSeries,
+    interval
+  });
+  return {
+    symbol,
+    interval,
+    range,
+    trades,
+    positions,
+    openPositions: [],
+    metrics,
+    eqSeries,
+    replay: {
+      frames: replayFrames,
+      events: replayEvents
+    }
+  };
 }
 
 // src/engine/portfolio.js
@@ -3114,6 +3349,74 @@ function backtestPortfolio({
   };
 }
 
+// src/engine/llmSignal.js
+function isArrayIndexKey3(property) {
+  if (typeof property !== "string") return false;
+  const n = Number(property);
+  return Number.isInteger(n) && n >= 0;
+}
+function noLookaheadView(candles, index) {
+  return new Proxy(candles, {
+    get(target, property, receiver) {
+      if (isArrayIndexKey3(property) && Number(property) > index) {
+        throw new Error(
+          `LlmSignal: lookahead access to candles[${String(property)}] (current index ${index})`
+        );
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
+var LlmSignal = class {
+  constructor({ resolve, budgetMs = 0, onError = "skip" } = {}) {
+    if (typeof resolve !== "function") {
+      throw new Error("LlmSignal requires a resolve(context) function");
+    }
+    this.resolve = resolve;
+    this.budgetMs = budgetMs;
+    this.onError = onError;
+    this.log = [];
+    this._cache = /* @__PURE__ */ new Map();
+    this.signal = this.signal.bind(this);
+  }
+  async signal(context) {
+    const key = context.bar?.time ?? context.index;
+    if (this._cache.has(key)) return this._cache.get(key);
+    const safeContext = {
+      ...context,
+      candles: noLookaheadView(context.candles, context.index)
+    };
+    const startedAt = Date.now();
+    try {
+      const result = await withBudget(
+        Promise.resolve().then(() => this.resolve(safeContext)),
+        this.budgetMs
+      );
+      this._cache.set(key, result ?? null);
+      this.log.push({
+        index: context.index,
+        time: context.bar?.time,
+        close: context.bar?.close,
+        latencyMs: Date.now() - startedAt,
+        result: result ?? null
+      });
+      return result ?? null;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.log.push({
+        index: context.index,
+        time: context.bar?.time,
+        close: context.bar?.close,
+        latencyMs: Date.now() - startedAt,
+        error: message
+      });
+      this._cache.set(key, null);
+      if (this.onError === "throw") throw error;
+      return null;
+    }
+  }
+};
+
 // src/engine/walkForward.js
 function scoreOf(metrics, scoreBy) {
   const value = metrics?.[scoreBy];
@@ -3306,7 +3609,8 @@ function walkForwardOptimize({
     equityFinal: rollingEquity,
     candles,
     estBarMs: estimateBarMs(candles),
-    eqSeries
+    eqSeries,
+    interval: backtestOptions.interval
   });
   const bestParamsSummary = summarizeBestParams(windows);
   return {
@@ -3325,6 +3629,580 @@ function walkForwardOptimize({
   };
 }
 
+// src/engine/optimize.js
+var import_node_worker_threads = require("node:worker_threads");
+var import_node_os = __toESM(require("node:os"), 1);
+var import_meta = {};
+function defaultConcurrency() {
+  return Math.max(1, (import_node_os.default.cpus()?.length ?? 2) - 1);
+}
+function scoreValue(metrics, scoreBy) {
+  const v = metrics?.[scoreBy];
+  return Number.isFinite(v) ? v : -Infinity;
+}
+function optimize({
+  candles,
+  signalModulePath,
+  parameterSets,
+  interval,
+  backtestOptions = {},
+  concurrency,
+  scoreBy = "profitFactor"
+}) {
+  if (!Array.isArray(parameterSets) || parameterSets.length === 0) {
+    return Promise.resolve({ results: [], leaderboard: [], best: null });
+  }
+  return new Promise((resolve, reject) => {
+    const poolSize = Math.min(concurrency || defaultConcurrency(), parameterSets.length);
+    const results = new Array(parameterSets.length);
+    const workers = [];
+    let nextIndex = 0;
+    let completed = 0;
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      for (const w of workers) w.terminate();
+      const ranked = results.filter((r) => r && r.metrics).sort((a, b) => scoreValue(b.metrics, scoreBy) - scoreValue(a.metrics, scoreBy));
+      resolve({ results, leaderboard: ranked, best: ranked[0] ?? null });
+    };
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      for (const w of workers) w.terminate();
+      reject(error);
+    };
+    const dispatch = (worker) => {
+      if (nextIndex >= parameterSets.length) {
+        worker.postMessage({ type: "stop" });
+        return;
+      }
+      const index = nextIndex;
+      nextIndex += 1;
+      worker.postMessage({ type: "run", index, params: parameterSets[index] });
+    };
+    for (let i = 0; i < poolSize; i += 1) {
+      const worker = new import_node_worker_threads.Worker(new URL("./optimizeWorker.js", import_meta.url), {
+        workerData: { candles, signalModulePath, interval, backtestOptions }
+      });
+      workers.push(worker);
+      worker.on("message", (msg) => {
+        if (msg.type === "ready") {
+          dispatch(worker);
+          return;
+        }
+        if (msg.type === "result" || msg.type === "error") {
+          results[msg.index] = msg.type === "result" ? { params: msg.params, metrics: msg.metrics } : { params: msg.params, error: msg.error };
+          completed += 1;
+          if (completed === parameterSets.length) finish();
+          else dispatch(worker);
+        }
+      });
+      worker.on("error", fail);
+    }
+  });
+}
+
+// src/engine/grid.js
+function grid(spec = {}) {
+  const keys = Object.keys(spec);
+  if (!keys.length) return [{}];
+  return keys.reduce(
+    (acc, key) => {
+      const values = Array.isArray(spec[key]) ? spec[key] : [spec[key]];
+      return acc.flatMap((base) => values.map((v) => ({ ...base, [key]: v })));
+    },
+    [{}]
+  );
+}
+
+// src/ta/oscillators.js
+function rsi(closes, period = 14) {
+  const out = new Array(closes.length).fill(void 0);
+  if (closes.length <= period) return out;
+  let gainSum = 0;
+  let lossSum = 0;
+  for (let i = 1; i <= period; i += 1) {
+    const change = closes[i] - closes[i - 1];
+    if (change >= 0) gainSum += change;
+    else lossSum -= change;
+  }
+  let avgGain = gainSum / period;
+  let avgLoss = lossSum / period;
+  out[period] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  for (let i = period + 1; i < closes.length; i += 1) {
+    const change = closes[i] - closes[i - 1];
+    const gain = change > 0 ? change : 0;
+    const loss = change < 0 ? -change : 0;
+    avgGain = (avgGain * (period - 1) + gain) / period;
+    avgLoss = (avgLoss * (period - 1) + loss) / period;
+    out[i] = avgLoss === 0 ? 100 : 100 - 100 / (1 + avgGain / avgLoss);
+  }
+  return out;
+}
+
+// src/ta/channels.js
+function donchian(bars, period = 20) {
+  const upper = new Array(bars.length).fill(void 0);
+  const lower = new Array(bars.length).fill(void 0);
+  const middle = new Array(bars.length).fill(void 0);
+  for (let i = period - 1; i < bars.length; i += 1) {
+    let hh = -Infinity;
+    let ll = Infinity;
+    for (let j = i - period + 1; j <= i; j += 1) {
+      if (bars[j].high > hh) hh = bars[j].high;
+      if (bars[j].low < ll) ll = bars[j].low;
+    }
+    upper[i] = hh;
+    lower[i] = ll;
+    middle[i] = (hh + ll) / 2;
+  }
+  return { upper, lower, middle };
+}
+
+// src/strategies/builtins.js
+var BUILTINS = {
+  "ema-cross": {
+    description: "Long when fast EMA crosses above slow EMA; stop at recent swing low.",
+    params: {
+      fast: { type: "number", default: 10, description: "fast EMA period" },
+      slow: { type: "number", default: 30, description: "slow EMA period" },
+      rr: { type: "number", default: 2, description: "reward:risk target" },
+      lookback: { type: "number", default: 15, description: "swing-low lookback for stop" }
+    },
+    factory({ fast = 10, slow = 30, rr = 2, lookback = 15 } = {}) {
+      return ({ candles, bar }) => {
+        if (candles.length < slow + 2) return null;
+        const closes = candles.map((c) => c.close);
+        const f = ema(closes, fast);
+        const s = ema(closes, slow);
+        const last = closes.length - 1;
+        if (f[last - 1] <= s[last - 1] && f[last] > s[last]) {
+          const stop = Math.min(...candles.slice(-lookback).map((c) => c.low));
+          if (stop >= bar.close) return null;
+          return { side: "long", entry: bar.close, stop, rr };
+        }
+        return null;
+      };
+    }
+  },
+  "rsi-reversion": {
+    description: "Long when RSI dips below `oversold`; stop a fixed pct below entry.",
+    params: {
+      period: { type: "number", default: 14, description: "RSI period" },
+      oversold: { type: "number", default: 30, description: "RSI entry threshold" },
+      stopPct: { type: "number", default: 2, description: "stop distance in percent" },
+      rr: { type: "number", default: 1.5, description: "reward:risk target" }
+    },
+    factory({ period = 14, oversold = 30, stopPct = 2, rr = 1.5 } = {}) {
+      return ({ candles, bar }) => {
+        if (candles.length < period + 2) return null;
+        const values = rsi(
+          candles.map((c) => c.close),
+          period
+        );
+        const r = values[values.length - 1];
+        if (r === void 0 || r > oversold) return null;
+        return { side: "long", entry: bar.close, stop: bar.close * (1 - stopPct / 100), rr };
+      };
+    }
+  },
+  "donchian-breakout": {
+    description: "Long on a close above the prior Donchian upper channel.",
+    params: {
+      period: { type: "number", default: 20, description: "channel lookback" },
+      rr: { type: "number", default: 2, description: "reward:risk target" }
+    },
+    factory({ period = 20, rr = 2 } = {}) {
+      return ({ candles, bar }) => {
+        if (candles.length < period + 2) return null;
+        const ch = donchian(candles, period);
+        const i = candles.length - 1;
+        const priorUpper = ch.upper[i - 1];
+        const priorLower = ch.lower[i - 1];
+        if (priorUpper === void 0) return null;
+        if (bar.close > priorUpper) {
+          return { side: "long", entry: bar.close, stop: priorLower, rr };
+        }
+        return null;
+      };
+    }
+  },
+  "buy-hold": {
+    description: "Enter once at the first eligible bar and hold for `holdBars`.",
+    params: {
+      holdBars: { type: "number", default: 5, description: "bars to hold before exit" },
+      stopPct: { type: "number", default: 10, description: "protective stop distance in percent" }
+    },
+    factory({ holdBars = 5, stopPct = 10 } = {}) {
+      let entered = false;
+      return ({ bar }) => {
+        if (entered) return null;
+        entered = true;
+        return {
+          side: "long",
+          entry: bar.close,
+          stop: bar.close * (1 - stopPct / 100),
+          rr: 5,
+          _maxBarsInTrade: holdBars
+        };
+      };
+    }
+  }
+};
+
+// src/strategies/index.js
+var registry = new Map(Object.entries(BUILTINS));
+function registerStrategy(name, def) {
+  if (typeof def?.factory !== "function") {
+    throw new Error(`registerStrategy("${name}") requires a factory function`);
+  }
+  registry.set(name, def);
+}
+function listStrategies() {
+  return [...registry.entries()].map(([name, def]) => ({
+    name,
+    description: def.description,
+    params: def.params
+  }));
+}
+function getStrategy(name) {
+  const def = registry.get(name);
+  if (!def) {
+    const available = [...registry.keys()].join(", ");
+    throw new Error(`Unknown strategy "${name}". Available: ${available}`);
+  }
+  return def.factory;
+}
+
+// src/research/index.js
+var research_exports = {};
+__export(research_exports, {
+  combinations: () => combinations,
+  combinatorialPurgedSplits: () => combinatorialPurgedSplits,
+  deflatedSharpe: () => deflatedSharpe,
+  moments: () => moments,
+  monteCarlo: () => monteCarlo,
+  normalCdf: () => normalCdf,
+  normalPpf: () => normalPpf,
+  probabilityOfBacktestOverfitting: () => probabilityOfBacktestOverfitting,
+  sweepHaircut: () => sweepHaircut
+});
+
+// src/utils/random.js
+function xmur32(str) {
+  let h = 1779033703 ^ str.length;
+  for (let i = 0; i < str.length; i += 1) {
+    h = Math.imul(h ^ str.charCodeAt(i), 3432918353);
+    h = h << 13 | h >>> 19;
+  }
+  return () => {
+    h = Math.imul(h ^ h >>> 16, 2246822507);
+    h = Math.imul(h ^ h >>> 13, 3266489909);
+    return (h ^= h >>> 16) >>> 0;
+  };
+}
+function mulberry322(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = Math.imul(state ^ state >>> 15, state | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function makeRng(seed = "tradelab") {
+  const seedFn = xmur32(String(seed));
+  return mulberry322(seedFn());
+}
+function randInt(rng, maxExclusive) {
+  return Math.floor(rng() * maxExclusive);
+}
+
+// src/research/monteCarlo.js
+function percentile2(sorted, p) {
+  if (!sorted.length) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.floor((sorted.length - 1) * p)));
+  return sorted[idx];
+}
+function maxDrawdownOf(equityPath) {
+  let peak = equityPath[0];
+  let maxDd = 0;
+  for (const e of equityPath) {
+    if (e > peak) peak = e;
+    const dd = peak > 0 ? (peak - e) / peak : 0;
+    if (dd > maxDd) maxDd = dd;
+  }
+  return maxDd;
+}
+function monteCarlo({
+  tradePnls,
+  equityStart = 1e4,
+  iterations = 1e3,
+  blockSize = 1,
+  seed = "tradelab-mc"
+}) {
+  if (!Array.isArray(tradePnls) || tradePnls.length === 0) {
+    throw new Error("monteCarlo() requires a non-empty tradePnls array");
+  }
+  const rng = makeRng(seed);
+  const n = tradePnls.length;
+  const block = Math.max(1, Math.floor(blockSize));
+  const finals = [];
+  const drawdowns = [];
+  const pathSamples = Array.from({ length: n + 1 }, () => []);
+  for (let it = 0; it < iterations; it += 1) {
+    const path6 = [equityStart];
+    let equity = equityStart;
+    let filled = 0;
+    while (filled < n) {
+      const start = randInt(rng, n);
+      for (let k = 0; k < block && filled < n; k += 1) {
+        equity += tradePnls[(start + k) % n];
+        path6.push(equity);
+        filled += 1;
+      }
+    }
+    for (let step = 0; step < path6.length; step += 1) {
+      pathSamples[step].push(path6[step]);
+    }
+    finals.push(equity);
+    drawdowns.push(maxDrawdownOf(path6));
+  }
+  const sortedFinals = [...finals].sort((a, b) => a - b);
+  const sortedDd = [...drawdowns].sort((a, b) => a - b);
+  const pathBands = pathSamples.map((samples) => {
+    const s = [...samples].sort((a, b) => a - b);
+    return { p5: percentile2(s, 0.05), p50: percentile2(s, 0.5), p95: percentile2(s, 0.95) };
+  });
+  const bands = (sorted) => ({
+    p5: percentile2(sorted, 0.05),
+    p25: percentile2(sorted, 0.25),
+    p50: percentile2(sorted, 0.5),
+    p75: percentile2(sorted, 0.75),
+    p95: percentile2(sorted, 0.95)
+  });
+  return {
+    iterations,
+    blockSize: block,
+    finalEquity: bands(sortedFinals),
+    maxDrawdown: bands(sortedDd),
+    pathBands,
+    probProfit: finals.filter((f) => f > equityStart).length / iterations
+  };
+}
+
+// src/research/stats.js
+function normalCdf(x) {
+  const sign = x < 0 ? -1 : 1;
+  const ax = Math.abs(x) / Math.SQRT2;
+  const t = 1 / (1 + 0.3275911 * ax);
+  const y = 1 - ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * Math.exp(-ax * ax);
+  return 0.5 * (1 + sign * y);
+}
+function normalPpf(p) {
+  if (p <= 0) return -Infinity;
+  if (p >= 1) return Infinity;
+  const a = [
+    -39.69683028665376,
+    220.9460984245205,
+    -275.9285104469687,
+    138.357751867269,
+    -30.66479806614716,
+    2.506628277459239
+  ];
+  const b = [
+    -54.47609879822406,
+    161.5858368580409,
+    -155.6989798598866,
+    66.80131188771972,
+    -13.28068155288572
+  ];
+  const c = [
+    -0.007784894002430293,
+    -0.3223964580411365,
+    -2.400758277161838,
+    -2.549732539343734,
+    4.374664141464968,
+    2.938163982698783
+  ];
+  const d = [0.007784695709041462, 0.3224671290700398, 2.445134137142996, 3.754408661907416];
+  const plow = 0.02425;
+  const phigh = 1 - plow;
+  let q;
+  let r;
+  if (p < plow) {
+    q = Math.sqrt(-2 * Math.log(p));
+    return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+  }
+  if (p <= phigh) {
+    q = p - 0.5;
+    r = q * q;
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+  }
+  q = Math.sqrt(-2 * Math.log(1 - p));
+  return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+}
+function moments(values) {
+  const n = values.length;
+  if (n < 2) return { mean: values[0] ?? 0, std: 0, skew: 0, kurtosis: 3 };
+  const mean3 = values.reduce((a, b) => a + b, 0) / n;
+  let m2 = 0;
+  let m3 = 0;
+  let m4 = 0;
+  for (const v of values) {
+    const d = v - mean3;
+    m2 += d * d;
+    m3 += d * d * d;
+    m4 += d * d * d * d;
+  }
+  m2 /= n;
+  m3 /= n;
+  m4 /= n;
+  const std = Math.sqrt(m2);
+  const skew = std === 0 ? 0 : m3 / std ** 3;
+  const kurtosis = m2 === 0 ? 3 : m4 / m2 ** 2;
+  return { mean: mean3, std, skew, kurtosis };
+}
+
+// src/research/deflatedSharpe.js
+var EULER_MASCHERONI = 0.5772156649015329;
+function sweepHaircut({ numTrials, sharpeStd }) {
+  const N = Math.max(1, numTrials);
+  const a = normalPpf(1 - 1 / N);
+  const b = normalPpf(1 - 1 / (N * Math.E));
+  const expectedMaxSharpe = sharpeStd * ((1 - EULER_MASCHERONI) * a + EULER_MASCHERONI * b);
+  return { expectedMaxSharpe, numTrials: N };
+}
+function deflatedSharpe({
+  sharpe,
+  sampleSize,
+  numTrials = 1,
+  sharpeStd = 0,
+  skew = 0,
+  kurtosis = 3
+}) {
+  const sr0 = sweepHaircut({ numTrials, sharpeStd }).expectedMaxSharpe;
+  const denom = Math.sqrt(
+    Math.max(1e-12, 1 - skew * sharpe + (kurtosis - 1) / 4 * sharpe * sharpe)
+  );
+  const z = (sharpe - sr0) * Math.sqrt(Math.max(1, sampleSize - 1)) / denom;
+  return normalCdf(z);
+}
+
+// src/research/combinations.js
+function combinations(n, k) {
+  const result = [];
+  const combo = [];
+  function recurse(start) {
+    if (combo.length === k) {
+      result.push([...combo]);
+      return;
+    }
+    for (let i = start; i < n; i += 1) {
+      combo.push(i);
+      recurse(i + 1);
+      combo.pop();
+    }
+  }
+  recurse(0);
+  return result;
+}
+
+// src/research/pbo.js
+function sharpeOf(returns) {
+  const n = returns.length;
+  if (n < 2) return 0;
+  const mean3 = returns.reduce((a, b) => a + b, 0) / n;
+  let variance = 0;
+  for (const r of returns) variance += (r - mean3) ** 2;
+  variance /= n - 1;
+  const std = Math.sqrt(variance);
+  if (std === 0) {
+    if (mean3 > 0) return Infinity;
+    if (mean3 < 0) return -Infinity;
+    return 0;
+  }
+  return mean3 / std;
+}
+function probabilityOfBacktestOverfitting(performanceMatrix, { groups = 16 } = {}) {
+  const nStrategies = performanceMatrix.length;
+  if (nStrategies < 2) throw new Error("PBO needs at least 2 strategies");
+  const nObs = performanceMatrix[0].length;
+  const S = Math.min(groups, nObs);
+  if (S % 2 !== 0) throw new Error("groups must be even");
+  const groupIdx = Array.from({ length: S }, () => []);
+  for (let i = 0; i < nObs; i += 1) groupIdx[Math.floor(i * S / nObs)].push(i);
+  const isCombos = combinations(S, S / 2);
+  const logits = [];
+  let overfitCount = 0;
+  for (const isGroups of isCombos) {
+    const isSet = new Set(isGroups);
+    const isIndices = [];
+    const osIndices = [];
+    for (let g = 0; g < S; g += 1) {
+      (isSet.has(g) ? isIndices : osIndices).push(...groupIdx[g]);
+    }
+    const isScores = performanceMatrix.map((row) => sharpeOf(isIndices.map((i) => row[i])));
+    const osScores = performanceMatrix.map((row) => sharpeOf(osIndices.map((i) => row[i])));
+    let bestStrategy = 0;
+    for (let s = 1; s < nStrategies; s += 1) {
+      if (isScores[s] > isScores[bestStrategy]) bestStrategy = s;
+    }
+    const winnerOs = osScores[bestStrategy];
+    let rank = 1;
+    for (let s = 0; s < nStrategies; s += 1) {
+      if (s !== bestStrategy && osScores[s] < winnerOs) rank += 1;
+    }
+    const relativeRank = rank / (nStrategies + 1);
+    const logit = Math.log(relativeRank / (1 - relativeRank));
+    logits.push(logit);
+    if (relativeRank <= 0.5) overfitCount += 1;
+  }
+  return {
+    pbo: overfitCount / isCombos.length,
+    combos: isCombos.length,
+    medianLogit: [...logits].sort((a, b) => a - b)[Math.floor(logits.length / 2)]
+  };
+}
+
+// src/research/cpcv.js
+function combinatorialPurgedSplits({
+  nObservations,
+  nGroups = 6,
+  nTestGroups = 2,
+  embargo = 0
+}) {
+  if (!(nObservations > 0)) throw new Error("nObservations must be positive");
+  if (nTestGroups >= nGroups) throw new Error("nTestGroups must be < nGroups");
+  const bounds = [];
+  for (let g = 0; g < nGroups; g += 1) {
+    bounds.push([
+      Math.floor(g * nObservations / nGroups),
+      Math.floor((g + 1) * nObservations / nGroups)
+    ]);
+  }
+  const splits = [];
+  for (const testGroups of combinations(nGroups, nTestGroups)) {
+    const testSet = /* @__PURE__ */ new Set();
+    const purgeZones = [];
+    for (const g of testGroups) {
+      const [start, end] = bounds[g];
+      for (let i = start; i < end; i += 1) testSet.add(i);
+      purgeZones.push([start - embargo, end + embargo]);
+    }
+    const inPurge = (i) => purgeZones.some(([lo, hi]) => i >= lo && i < hi);
+    const train = [];
+    const testIdx = [];
+    for (let i = 0; i < nObservations; i += 1) {
+      if (testSet.has(i)) testIdx.push(i);
+      else if (!inPurge(i)) train.push(i);
+    }
+    splits.push({ train, test: testIdx, testGroups });
+  }
+  return splits;
+}
+
 // src/data/index.js
 var import_path2 = __toESM(require("path"), 1);
 
@@ -4025,16 +4903,21 @@ function exportBacktestArtifacts({
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BIG_NUMBER,
+  LlmSignal,
   atr,
   backtest,
+  backtestAsync,
   backtestHistorical,
   backtestPortfolio,
   backtestTicks,
+  benchmarkStats,
   bpsOf,
   buildMetrics,
   cachedCandlesPath,
   calculatePositionSize,
   candleStats,
+  clampFinite,
   detectFVG,
   ema,
   exportBacktestArtifacts,
@@ -4044,18 +4927,25 @@ function exportBacktestArtifacts({
   fetchHistorical,
   fetchLatestCandle,
   getHistoricalCandles,
+  getStrategy,
+  grid,
   inWindowsET,
   isSession,
   lastSwing,
+  listStrategies,
   loadCandlesFromCSV,
   loadCandlesFromCache,
   mergeCandles,
   minutesET,
   normalizeCandles,
   offsetET,
+  optimize,
   parseWindowsCSV,
   pct,
+  periodsPerYear,
+  registerStrategy,
   renderHtmlReport,
+  research,
   saveCandlesToCache,
   structureState,
   swingHigh,