@tradejs/node 1.0.9 → 1.0.11

package/dist/backtest.js

@@ -31,19 +31,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/backtest.ts
 var backtest_exports = {};
 __export(backtest_exports, {
+  canRunTestsInSharedCandleLoop: () => canRunTestsInSharedCandleLoop,
   createTestConnector: () => createTestConnector,
+  releaseTestingSymbolCache: () => releaseTestingSymbolCache,
   resetTestingKlineCache: () => resetTestingKlineCache,
-  testing: () => testing
+  resolveExecutionCosts: () => resolveExecutionCosts,
+  testing: () => testing,
+  testingGroupInSharedCandleLoop: () => testingGroupInSharedCandleLoop
 });
 module.exports = __toCommonJS(backtest_exports);
 __reExport(backtest_exports, require("@tradejs/core/backtest"), module.exports);
 
 // src/testing.ts
 var import_indicators3 = require("@tradejs/core/indicators");
+var import_constants4 = require("@tradejs/core/constants");
+var import_strategies4 = require("@tradejs/core/strategies");
 var import_time = require("@tradejs/core/time");
 var import_ai2 = require("@tradejs/infra/ai");
 var import_ml2 = require("@tradejs/infra/ml");
-var import_logger5 = require("@tradejs/infra/logger");
+var import_logger7 = require("@tradejs/infra/logger");
 
 // src/ai.ts
 var import_aiLanguages = require("@tradejs/infra/aiLanguages");
@@ -52,6 +58,10 @@ var import_userSettings = require("@tradejs/infra/userSettings");
 
 // src/aiShared.ts
 var MAX_AI_SERIES_POINTS = 5;
+var COMPACT_INDICATORS_SNAPSHOT_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "tradejs.indicators.compactSnapshot"
+);
+var COMPACT_INDICATORS_SNAPSHOT_KEY = "__tradejsCompactIndicatorsSnapshot";
 var trimSeriesDeep = (value) => {
   if (Array.isArray(value)) {
     const trimmed = value.slice(-MAX_AI_SERIES_POINTS);
@@ -73,13 +83,15 @@ var trimSeriesDeep = (value) => {
   }
   return value;
 };
+var buildCompactAiIndicatorsSnapshot = (value) => {
+  const compactSnapshot = value && typeof value === "object" ? value[COMPACT_INDICATORS_SNAPSHOT_SYMBOL] ?? value[COMPACT_INDICATORS_SNAPSHOT_KEY] : void 0;
+  if (typeof compactSnapshot === "function") {
+    return compactSnapshot({ limit: MAX_AI_SERIES_POINTS });
+  }
+  return trimSeriesDeep(value);
+};
 
 // src/aiMarketContext.ts
-var SESSION_WINDOWS = [
-  { name: "asia", startMinuteUtc: 0, endMinuteUtc: 8 * 60 },
-  { name: "europe", startMinuteUtc: 7 * 60, endMinuteUtc: 16 * 60 },
-  { name: "us", startMinuteUtc: 13 * 60, endMinuteUtc: 22 * 60 }
-];
 var toRecord = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -90,92 +102,485 @@ var toFiniteNumber = (value) => {
   const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
   return Number.isFinite(numeric) ? numeric : null;
 };
-var getLastFiniteNumber = (value) => {
-  const numeric = toFiniteNumber(value);
-  if (numeric != null) {
-    return numeric;
-  }
-  if (!Array.isArray(value)) {
-    return null;
-  }
-  for (let i = value.length - 1; i >= 0; i -= 1) {
-    const nested = getLastFiniteNumber(value[i]);
-    if (nested != null) {
-      return nested;
-    }
-  }
-  return null;
-};
 var roundTo = (value, decimals) => {
   const factor = 10 ** decimals;
   return Math.round(value * factor) / factor;
 };
-var isInsideSession = (minuteUtc, startMinuteUtc, endMinuteUtc) => startMinuteUtc <= endMinuteUtc ? minuteUtc >= startMinuteUtc && minuteUtc < endMinuteUtc : minuteUtc >= startMinuteUtc || minuteUtc < endMinuteUtc;
-var buildTradingSessionContext = (timestamp) => {
-  const date = new Date(timestamp);
-  const utcHour = date.getUTCHours();
-  const utcMinute = date.getUTCMinutes();
-  const minuteUtc = utcHour * 60 + utcMinute;
-  const activeSessions = SESSION_WINDOWS.filter(
-    (session) => isInsideSession(minuteUtc, session.startMinuteUtc, session.endMinuteUtc)
-  ).map((session) => session.name);
-  const primarySession = activeSessions.includes("us") ? "us" : activeSessions.includes("europe") ? "europe" : activeSessions.includes("asia") ? "asia" : "off_hours";
-  return {
-    timezone: "UTC",
-    utcHour,
-    utcMinute,
-    primarySession,
-    activeSessions,
-    isOverlap: activeSessions.length > 1,
-    overlap: activeSessions.length > 1 ? `${activeSessions.join("_")}_overlap` : null
-  };
-};
 var buildMissingSpreadContext = () => ({
-  source: "binance_coinbase_btc",
-  indicatorKey: "payload.indicators.spread",
+  source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+  indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
   available: false,
   value: null,
+  zScore: null,
   bps: null,
   absBps: null,
   bias: null,
   severity: null
 });
-var buildSpreadContextFromValue = (spread) => {
+var buildSpreadContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const execution = toRecord(relative?.execution);
+  const spread = toFiniteNumber(execution?.venueSpread);
+  const zScore = toFiniteNumber(execution?.venueSpreadZScore);
+  if (spread == null) {
+    return buildMissingSpreadContext();
+  }
   const value = roundTo(spread, 8);
   const bps = roundTo(value * 1e4, 2);
   const absBps = Math.abs(bps);
-  const bias = Math.abs(bps) < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
+  const bias = absBps < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
   const severity = absBps >= 20 ? "wide" : absBps >= 5 ? "elevated" : "normal";
   return {
-    source: "binance_coinbase_btc",
-    indicatorKey: "payload.indicators.spread",
+    source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
     available: true,
     value,
+    zScore,
     bps,
     absBps,
     bias,
     severity
   };
 };
-var readSpreadFromSignal = (signal) => {
-  const indicatorSpread = getLastFiniteNumber(signal.indicators?.spread);
-  if (indicatorSpread != null) {
-    return indicatorSpread;
+var buildTrueDeltaContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const participation = toRecord(baseContext?.participation);
+  const delta = toRecord(participation?.delta);
+  const source = String(delta?.source ?? "");
+  const isTrueDeltaSource = source === "kline_taker_volume" || source === "agg_trades" || source === "trades";
+  if (!delta || !isTrueDeltaSource) {
+    return {
+      source: source || null,
+      available: false,
+      buyPressurePct: null,
+      buyVolume: null,
+      sellVolume: null,
+      netDelta: null,
+      deltaPct: null,
+      signedVolumeZScore: null
+    };
   }
-  return getLastFiniteNumber(signal.additionalIndicators?.spread);
+  return {
+    source,
+    available: true,
+    buyPressurePct: toFiniteNumber(delta.buyPressurePct),
+    buyVolume: toFiniteNumber(delta.buyVolume),
+    sellVolume: toFiniteNumber(delta.sellVolume),
+    netDelta: toFiniteNumber(delta.netDelta),
+    deltaPct: toFiniteNumber(delta.deltaPct),
+    signedVolumeZScore: toFiniteNumber(delta.signedVolumeZScore)
+  };
 };
-var buildAiMarketContext = (signal) => {
-  const existingMarketContext = toRecord(
-    signal.additionalIndicators?.marketContext
-  );
-  const existingSpread = toRecord(existingMarketContext?.binanceCoinbaseSpread);
-  const spread = readSpreadFromSignal(signal);
+var buildTradeFlowContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const participation = toRecord(baseContext?.participation);
+  const tradeFlow = toRecord(participation?.tradeFlow);
+  if (!tradeFlow) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      stale: null,
+      trades: null,
+      buyPressurePct: null,
+      netBaseDelta: null,
+      netQuoteDelta: null
+    };
+  }
+  return {
+    source: String(tradeFlow.source ?? ""),
+    available: true,
+    interval: String(tradeFlow.interval ?? ""),
+    stale: typeof tradeFlow.stale === "boolean" ? tradeFlow.stale : null,
+    trades: toFiniteNumber(tradeFlow.trades),
+    buyPressurePct: toFiniteNumber(tradeFlow.buyPressurePct),
+    netBaseDelta: toFiniteNumber(tradeFlow.netBaseDelta),
+    netQuoteDelta: toFiniteNumber(tradeFlow.netQuoteDelta)
+  };
+};
+var buildMarketBreadthContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const breadth = toRecord(relative?.marketBreadth);
+  if (!breadth) {
+    return {
+      source: null,
+      available: false,
+      universe: null,
+      interval: null,
+      stale: null,
+      symbolsCount: null,
+      advanceDeclineRatio: null,
+      pctAboveMa20: null,
+      pctAboveMa50: null,
+      equalWeightedReturn: null,
+      volumeWeightedReturn: null,
+      dispersion: null
+    };
+  }
+  return {
+    source: String(breadth.source ?? ""),
+    available: true,
+    universe: String(breadth.universe ?? ""),
+    interval: String(breadth.interval ?? ""),
+    stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
+    symbolsCount: toFiniteNumber(breadth.symbolsCount),
+    advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
+    pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
+    pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
+    equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
+    volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
+    dispersion: toFiniteNumber(breadth.dispersion)
+  };
+};
+var buildTargetVsBtcContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const targetVsBtc = toRecord(relative?.targetVsBtc);
+  if (!targetVsBtc) {
+    return {
+      source: null,
+      available: false,
+      ratioReturn1h: null,
+      ratioReturn4h: null,
+      ratioReturn24h: null,
+      alphaVsBtc1h: null,
+      alphaVsBtc4h: null,
+      alphaVsBtc24h: null,
+      betaToBtc20: null,
+      correlationToBtc20: null,
+      ratioTrend: null
+    };
+  }
+  return {
+    source: String(targetVsBtc.source ?? ""),
+    available: true,
+    ratioReturn1h: toFiniteNumber(targetVsBtc.ratioReturn1h),
+    ratioReturn4h: toFiniteNumber(targetVsBtc.ratioReturn4h),
+    ratioReturn24h: toFiniteNumber(targetVsBtc.ratioReturn24h),
+    alphaVsBtc1h: toFiniteNumber(targetVsBtc.alphaVsBtc1h),
+    alphaVsBtc4h: toFiniteNumber(targetVsBtc.alphaVsBtc4h),
+    alphaVsBtc24h: toFiniteNumber(targetVsBtc.alphaVsBtc24h),
+    betaToBtc20: toFiniteNumber(targetVsBtc.betaToBtc20),
+    correlationToBtc20: toFiniteNumber(targetVsBtc.correlationToBtc20),
+    ratioTrend: typeof targetVsBtc.ratioTrend === "string" ? targetVsBtc.ratioTrend : null
+  };
+};
+var buildBtcAltRegimeContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const btcAltRegime = toRecord(relative?.btcAltRegime);
+  if (!btcAltRegime) {
+    return {
+      source: null,
+      available: false,
+      universe: null,
+      interval: null,
+      stale: null,
+      regime: null,
+      btcReturn24h: null,
+      altBasketReturn24h: null,
+      btcVsAltReturn24h: null,
+      btcTurnoverShare24h: null,
+      btcTurnoverShareChange24h: null,
+      altVolToBtcVol24h: null,
+      altDispersion24h: null
+    };
+  }
+  return {
+    source: String(btcAltRegime.source ?? ""),
+    available: true,
+    universe: String(btcAltRegime.universe ?? ""),
+    interval: String(btcAltRegime.interval ?? ""),
+    stale: typeof btcAltRegime.stale === "boolean" ? btcAltRegime.stale : null,
+    regime: typeof btcAltRegime.regime === "string" ? btcAltRegime.regime : null,
+    btcReturn24h: toFiniteNumber(btcAltRegime.btcReturn24h),
+    altBasketReturn24h: toFiniteNumber(btcAltRegime.altBasketReturn24h),
+    btcVsAltReturn24h: toFiniteNumber(btcAltRegime.btcVsAltReturn24h),
+    btcTurnoverShare24h: toFiniteNumber(btcAltRegime.btcTurnoverShare24h),
+    btcTurnoverShareChange24h: toFiniteNumber(
+      btcAltRegime.btcTurnoverShareChange24h
+    ),
+    altVolToBtcVol24h: toFiniteNumber(btcAltRegime.altVolToBtcVol24h),
+    altDispersion24h: toFiniteNumber(btcAltRegime.altDispersion24h)
+  };
+};
+var buildCmcGlobalContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcGlobal = toRecord(relative?.cmcGlobal);
+  if (!cmcGlobal) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      totalMarketCapUsd: null,
+      totalVolumeUsd: null,
+      totalVolumeReportedUsd: null,
+      altMarketCapUsd: null,
+      altVolumeUsd: null,
+      altVolumeReportedUsd: null,
+      btcDominancePct: null,
+      ethDominancePct: null,
+      btcDominanceChange24hPct: null,
+      ethDominanceChange24hPct: null,
+      altMarketCapChange24hPct: null,
+      altVolumeChange24hPct: null,
+      activeCryptocurrencies: null,
+      activeExchanges: null,
+      activeMarketPairs: null,
+      altLiquidityRegime: null
+    };
+  }
+  return {
+    source: String(cmcGlobal.source ?? ""),
+    available: true,
+    interval: typeof cmcGlobal.interval === "string" ? cmcGlobal.interval : null,
+    asOfTs: toFiniteNumber(cmcGlobal.asOfTs),
+    stale: typeof cmcGlobal.stale === "boolean" ? cmcGlobal.stale : null,
+    totalMarketCapUsd: toFiniteNumber(cmcGlobal.totalMarketCapUsd),
+    totalVolumeUsd: toFiniteNumber(cmcGlobal.totalVolumeUsd),
+    totalVolumeReportedUsd: toFiniteNumber(cmcGlobal.totalVolumeReportedUsd),
+    altMarketCapUsd: toFiniteNumber(cmcGlobal.altMarketCapUsd),
+    altVolumeUsd: toFiniteNumber(cmcGlobal.altVolumeUsd),
+    altVolumeReportedUsd: toFiniteNumber(cmcGlobal.altVolumeReportedUsd),
+    btcDominancePct: toFiniteNumber(cmcGlobal.btcDominancePct),
+    ethDominancePct: toFiniteNumber(cmcGlobal.ethDominancePct),
+    btcDominanceChange24hPct: toFiniteNumber(
+      cmcGlobal.btcDominanceChange24hPct
+    ),
+    ethDominanceChange24hPct: toFiniteNumber(
+      cmcGlobal.ethDominanceChange24hPct
+    ),
+    altMarketCapChange24hPct: toFiniteNumber(
+      cmcGlobal.altMarketCapChange24hPct
+    ),
+    altVolumeChange24hPct: toFiniteNumber(cmcGlobal.altVolumeChange24hPct),
+    activeCryptocurrencies: toFiniteNumber(cmcGlobal.activeCryptocurrencies),
+    activeExchanges: toFiniteNumber(cmcGlobal.activeExchanges),
+    activeMarketPairs: toFiniteNumber(cmcGlobal.activeMarketPairs),
+    altLiquidityRegime: typeof cmcGlobal.altLiquidityRegime === "string" ? cmcGlobal.altLiquidityRegime : null
+  };
+};
+var buildCmcReferenceAssetsContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcReferenceAssets = toRecord(relative?.cmcReferenceAssets);
+  if (!cmcReferenceAssets) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      btcMarketCapUsd: null,
+      ethMarketCapUsd: null,
+      btcVolumeUsd: null,
+      ethVolumeUsd: null,
+      btcVolumeToMarketCap: null,
+      ethVolumeToMarketCap: null,
+      ethBtcMarketCapRatio: null,
+      ethBtcMarketCapRatioChange24hPct: null,
+      ethVsBtcVolumeRatio: null,
+      referenceLiquidityRegime: null
+    };
+  }
+  return {
+    source: String(cmcReferenceAssets.source ?? ""),
+    available: true,
+    interval: typeof cmcReferenceAssets.interval === "string" ? cmcReferenceAssets.interval : null,
+    asOfTs: toFiniteNumber(cmcReferenceAssets.asOfTs),
+    stale: typeof cmcReferenceAssets.stale === "boolean" ? cmcReferenceAssets.stale : null,
+    btcMarketCapUsd: toFiniteNumber(cmcReferenceAssets.btcMarketCapUsd),
+    ethMarketCapUsd: toFiniteNumber(cmcReferenceAssets.ethMarketCapUsd),
+    btcVolumeUsd: toFiniteNumber(cmcReferenceAssets.btcVolumeUsd),
+    ethVolumeUsd: toFiniteNumber(cmcReferenceAssets.ethVolumeUsd),
+    btcVolumeToMarketCap: toFiniteNumber(
+      cmcReferenceAssets.btcVolumeToMarketCap
+    ),
+    ethVolumeToMarketCap: toFiniteNumber(
+      cmcReferenceAssets.ethVolumeToMarketCap
+    ),
+    ethBtcMarketCapRatio: toFiniteNumber(
+      cmcReferenceAssets.ethBtcMarketCapRatio
+    ),
+    ethBtcMarketCapRatioChange24hPct: toFiniteNumber(
+      cmcReferenceAssets.ethBtcMarketCapRatioChange24hPct
+    ),
+    ethVsBtcVolumeRatio: toFiniteNumber(cmcReferenceAssets.ethVsBtcVolumeRatio),
+    referenceLiquidityRegime: typeof cmcReferenceAssets.referenceLiquidityRegime === "string" ? cmcReferenceAssets.referenceLiquidityRegime : null
+  };
+};
+var buildCmcExchangeLiquidityContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcExchangeLiquidity = toRecord(relative?.cmcExchangeLiquidity);
+  if (!cmcExchangeLiquidity) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      exchangesCount: null,
+      totalVolumeUsd: null,
+      totalVolumeChange24hPct: null,
+      binanceVolumeUsd: null,
+      binanceVolumeShare: null,
+      topExchangeVolumeShare: null,
+      liquidityRegime: null
+    };
+  }
+  return {
+    source: String(cmcExchangeLiquidity.source ?? ""),
+    available: true,
+    interval: typeof cmcExchangeLiquidity.interval === "string" ? cmcExchangeLiquidity.interval : null,
+    asOfTs: toFiniteNumber(cmcExchangeLiquidity.asOfTs),
+    stale: typeof cmcExchangeLiquidity.stale === "boolean" ? cmcExchangeLiquidity.stale : null,
+    exchangesCount: toFiniteNumber(cmcExchangeLiquidity.exchangesCount),
+    totalVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.totalVolumeUsd),
+    totalVolumeChange24hPct: toFiniteNumber(
+      cmcExchangeLiquidity.totalVolumeChange24hPct
+    ),
+    binanceVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeUsd),
+    binanceVolumeShare: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeShare),
+    topExchangeVolumeShare: toFiniteNumber(
+      cmcExchangeLiquidity.topExchangeVolumeShare
+    ),
+    liquidityRegime: typeof cmcExchangeLiquidity.liquidityRegime === "string" ? cmcExchangeLiquidity.liquidityRegime : null
+  };
+};
+var buildCmcFearGreedContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcFearGreed = toRecord(relative?.cmcFearGreed);
+  if (!cmcFearGreed) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      value: null,
+      valueChange24h: null,
+      valueChange7d: null,
+      classification: null,
+      sentimentRegime: null
+    };
+  }
+  return {
+    source: String(cmcFearGreed.source ?? ""),
+    available: true,
+    interval: typeof cmcFearGreed.interval === "string" ? cmcFearGreed.interval : null,
+    asOfTs: toFiniteNumber(cmcFearGreed.asOfTs),
+    stale: typeof cmcFearGreed.stale === "boolean" ? cmcFearGreed.stale : null,
+    value: toFiniteNumber(cmcFearGreed.value),
+    valueChange24h: toFiniteNumber(cmcFearGreed.valueChange24h),
+    valueChange7d: toFiniteNumber(cmcFearGreed.valueChange7d),
+    classification: typeof cmcFearGreed.classification === "string" ? cmcFearGreed.classification : null,
+    sentimentRegime: typeof cmcFearGreed.sentimentRegime === "string" ? cmcFearGreed.sentimentRegime : null
+  };
+};
+var buildCmcIndexesContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcIndexes = toRecord(relative?.cmcIndexes);
+  if (!cmcIndexes) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      cmc100Value: null,
+      cmc100Change24hPct: null,
+      cmc100TopConstituentSymbol: null,
+      cmc100TopConstituentWeightPct: null,
+      cmc20Value: null,
+      cmc20Change24hPct: null,
+      cmc20TopConstituentSymbol: null,
+      cmc20TopConstituentWeightPct: null,
+      cmc20ToCmc100Ratio: null,
+      cmc20ToCmc100RatioChange24hPct: null,
+      indexRegime: null
+    };
+  }
+  return {
+    source: String(cmcIndexes.source ?? ""),
+    available: true,
+    interval: typeof cmcIndexes.interval === "string" ? cmcIndexes.interval : null,
+    asOfTs: toFiniteNumber(cmcIndexes.asOfTs),
+    stale: typeof cmcIndexes.stale === "boolean" ? cmcIndexes.stale : null,
+    cmc100Value: toFiniteNumber(cmcIndexes.cmc100Value),
+    cmc100Change24hPct: toFiniteNumber(cmcIndexes.cmc100Change24hPct),
+    cmc100TopConstituentSymbol: typeof cmcIndexes.cmc100TopConstituentSymbol === "string" ? cmcIndexes.cmc100TopConstituentSymbol : null,
+    cmc100TopConstituentWeightPct: toFiniteNumber(
+      cmcIndexes.cmc100TopConstituentWeightPct
+    ),
+    cmc20Value: toFiniteNumber(cmcIndexes.cmc20Value),
+    cmc20Change24hPct: toFiniteNumber(cmcIndexes.cmc20Change24hPct),
+    cmc20TopConstituentSymbol: typeof cmcIndexes.cmc20TopConstituentSymbol === "string" ? cmcIndexes.cmc20TopConstituentSymbol : null,
+    cmc20TopConstituentWeightPct: toFiniteNumber(
+      cmcIndexes.cmc20TopConstituentWeightPct
+    ),
+    cmc20ToCmc100Ratio: toFiniteNumber(cmcIndexes.cmc20ToCmc100Ratio),
+    cmc20ToCmc100RatioChange24hPct: toFiniteNumber(
+      cmcIndexes.cmc20ToCmc100RatioChange24hPct
+    ),
+    indexRegime: typeof cmcIndexes.indexRegime === "string" ? cmcIndexes.indexRegime : null
+  };
+};
+var buildReferenceTradeFlowContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const refs = toRecord(relative?.referenceTradeFlow);
+  const primaryReferenceSymbol = typeof refs?.primaryReferenceSymbol === "string" ? refs.primaryReferenceSymbol : null;
+  const tradeFlowBySymbol = toRecord(refs?.tradeFlowBySymbol);
+  const primaryTradeFlow = primaryReferenceSymbol != null ? toRecord(tradeFlowBySymbol?.[primaryReferenceSymbol]) : null;
+  if (!refs) {
+    return {
+      source: null,
+      available: false,
+      primaryReferenceSymbol: null,
+      referenceSymbols: [],
+      primaryTradeFlowBuyPressurePct: null,
+      primaryTradeFlowStale: null
+    };
+  }
   return {
-    ...existingMarketContext ?? {},
-    tradingSession: buildTradingSessionContext(signal.timestamp),
-    binanceCoinbaseSpread: spread != null ? buildSpreadContextFromValue(spread) : existingSpread ?? buildMissingSpreadContext()
+    source: String(refs.source ?? ""),
+    available: true,
+    primaryReferenceSymbol,
+    referenceSymbols: Array.isArray(refs.referenceSymbols) ? refs.referenceSymbols.map(String) : [],
+    primaryTradeFlowBuyPressurePct: toFiniteNumber(
+      primaryTradeFlow?.buyPressurePct
+    ),
+    primaryTradeFlowStale: typeof primaryTradeFlow?.stale === "boolean" ? primaryTradeFlow.stale : null
   };
 };
+var buildAiMarketContext = (signal) => ({
+  execution: {
+    binanceCoinbaseSpread: buildSpreadContextFromSignal(signal)
+  },
+  participation: {
+    trueDelta: buildTrueDeltaContextFromSignal(signal),
+    tradeFlow: buildTradeFlowContextFromSignal(signal)
+  },
+  relative: {
+    marketBreadth: buildMarketBreadthContextFromSignal(signal),
+    targetVsBtc: buildTargetVsBtcContextFromSignal(signal),
+    btcAltRegime: buildBtcAltRegimeContextFromSignal(signal),
+    cmcGlobal: buildCmcGlobalContextFromSignal(signal),
+    cmcReferenceAssets: buildCmcReferenceAssetsContextFromSignal(signal),
+    cmcExchangeLiquidity: buildCmcExchangeLiquidityContextFromSignal(signal),
+    cmcFearGreed: buildCmcFearGreedContextFromSignal(signal),
+    cmcIndexes: buildCmcIndexesContextFromSignal(signal),
+    referenceTradeFlow: buildReferenceTradeFlowContextFromSignal(signal)
+  }
+});
 
 // src/strategy/manifests.ts
 var import_indicators = require("@tradejs/core/indicators");
@@ -184,7 +589,6 @@ var import_logger2 = require("@tradejs/infra/logger");
 // src/tradejsConfig.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var import_module = require("module");
 var import_url = require("url");
 var import_config = require("@tradejs/core/config");
 var import_logger = require("@tradejs/infra/logger");
@@ -200,6 +604,7 @@ var cachedByCwd = /* @__PURE__ */ new Map();
 var announcedConfigFile = /* @__PURE__ */ new Set();
 var tsNodeRegistered = false;
 var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
+var tsconfigPathMatchersByCwd = /* @__PURE__ */ new Map();
 var getTradejsProjectCwd = (cwd) => {
   const explicit = String(cwd ?? "").trim();
   if (explicit) {
@@ -229,7 +634,14 @@ var normalizeConfig = (rawConfig) => {
     ...hooks ? { hooks } : {}
   };
 };
-var getRequireFn = (cwd = getTradejsProjectCwd()) => (0, import_module.createRequire)(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
+var getNodeCreateRequire = () => {
+  const builtinModule = process.getBuiltinModule?.("module");
+  if (typeof builtinModule?.createRequire === "function") {
+    return builtinModule.createRequire;
+  }
+  throw new TypeError("module.createRequire is not available");
+};
+var getRequireFn = (cwd = getTradejsProjectCwd()) => getNodeCreateRequire()(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
 var ensureTsNodeRegistered = async () => {
   if (tsNodeRegistered) {
     return;
@@ -239,8 +651,8 @@ var ensureTsNodeRegistered = async () => {
   tsNode.register?.({
     transpileOnly: true,
     compilerOptions: {
-      module: "commonjs",
-      moduleResolution: "node"
+      module: "Node16",
+      moduleResolution: "node16"
     }
   });
   tsNodeRegistered = true;
@@ -267,6 +679,42 @@ var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
   });
   tsconfigPathsRegisteredByCwd.add(projectRoot);
 };
+var resolveTsconfigPathModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  const cachedMatcher = tsconfigPathMatchersByCwd.get(projectRoot);
+  if (cachedMatcher) {
+    const resolved2 = cachedMatcher(moduleName);
+    return resolved2 || null;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const createMatchPath = tsconfigPathsModule.createMatchPath;
+  if (typeof loadConfig !== "function" || typeof createMatchPath !== "function") {
+    return null;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return null;
+  }
+  const matchPath = createMatchPath(
+    loadedConfig.absoluteBaseUrl,
+    loadedConfig.paths
+  );
+  const matcher = (requestedModule) => matchPath(requestedModule, void 0, import_fs.default.existsSync, [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json"
+  ]) || "";
+  tsconfigPathMatchersByCwd.set(projectRoot, matcher);
+  const resolved = matcher(moduleName);
+  return resolved || null;
+};
 var toImportSpecifier = (moduleName) => {
   if (moduleName.startsWith("file://")) {
     return moduleName;
@@ -325,7 +773,18 @@ var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   }
   if (isBareModuleSpecifier(normalized)) {
     await ensureTsconfigPathsRegistered(cwd);
-    return requireFn(normalized);
+    try {
+      return requireFn(normalized);
+    } catch (error) {
+      const resolvedByTsconfig = await resolveTsconfigPathModule(
+        normalized,
+        cwd
+      );
+      if (resolvedByTsconfig && resolvedByTsconfig !== normalized) {
+        return requireFn(resolvedByTsconfig);
+      }
+      throw error;
+    }
   }
   try {
     return await import(
@@ -600,6 +1059,10 @@ var strategies = new Proxy(
   }
 );
 
+// src/strategy/policyProfiles.ts
+var getStrategyProfileAiAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.aiAdapter ?? manifest?.aiAdapter;
+var getStrategyProfileMlAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.mlAdapter ?? manifest?.mlAdapter;
+
 // src/strategyAdapters/ai.ts
 var toRecord2 = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -627,13 +1090,13 @@ var buildBaseAiPayload = (signal) => {
       }
     },
     figures: trimSeriesDeep(signal.figures ?? {}),
-    indicators: trimSeriesDeep(signal.indicators),
+    indicators: buildCompactAiIndicatorsSnapshot(signal.indicators),
     additionalIndicators: trimSeriesDeep(additionalIndicators)
   };
 };
 var defaultAiAdapter = {};
-var getStrategyAiAdapter = (strategy) => getStrategyManifest(strategy)?.aiAdapter ?? defaultAiAdapter;
-var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy);
+var getStrategyAiAdapter = (strategy, profileId) => getStrategyProfileAiAdapter(getStrategyManifest(strategy), profileId) ?? defaultAiAdapter;
+var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy, signal.policyProfileId);
 var buildAiPayloadByStrategy = (signal) => {
   const basePayload = buildBaseAiPayload(signal);
   const adapter = getSignalAiAdapter(signal);
@@ -643,165 +1106,1034 @@ var buildAiPayloadByStrategy = (signal) => {
 // src/ai.ts
 var buildAiPayload = (signal) => buildAiPayloadByStrategy(signal);
 
-// src/strategyHelpers/derivativesContext.ts
-var import_indicators2 = require("@tradejs/core/indicators");
-var import_constants = require("@tradejs/core/constants");
+// src/strategyHelpers/binanceMarketContext.ts
 var import_timescale = require("@tradejs/infra/timescale");
 var import_logger3 = require("@tradejs/infra/logger");
-var DEFAULT_INTERVALS = ["15m", "1h"];
-var DEFAULT_LOOKBACK_HOURS = 48;
-var derivativesContextUnavailable = false;
+var import_strategies = require("@tradejs/core/strategies");
+var DEFAULT_MAX_AGE_BY_INTERVAL = {
+  "1m": 3 * 6e4,
+  "5m": 10 * 6e4,
+  "15m": 30 * 6e4,
+  "1h": 2 * 60 * 6e4
+};
+var binanceMarketContextUnavailable = false;
+var referenceRowsCache = /* @__PURE__ */ new Map();
+var breadthCache = /* @__PURE__ */ new Map();
 var parseEnabledFlag = (value, env) => {
   const normalized = String(value ?? "").trim().toLowerCase();
-  if (!normalized) return false;
+  if (!normalized)
+    return env === "BACKTEST" || env === "CRON" || env === "PARITY";
   if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
   if (normalized === "backtest") return env === "BACKTEST";
   if (normalized === "live") return env !== "BACKTEST";
   return false;
 };
-var parseLookbackMs = () => {
-  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
-  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
-  return normalizedHours * 60 * 60 * 1e3;
+var toFiniteNumberOrNull = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
 };
-var parseIntervals = () => {
-  const fromEnv = (0, import_indicators2.normalizeDerivativesIntervals)(
-    process.env.DERIVATIVES_CONTEXT_INTERVALS
-  );
-  return fromEnv.length ? fromEnv : DEFAULT_INTERVALS;
+var signalIntervalToMarketInterval = (value) => {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "5" || normalized === "5m") return "5m";
+  if (normalized === "60" || normalized === "1h") return "1h";
+  return "15m";
+};
+var resolveMarketInterval = (signal, override) => override ?? signalIntervalToMarketInterval(signal.interval);
+var resolveBreadthUniverse = () => (process.env.BINANCE_MARKET_CONTEXT_BREADTH_UNIVERSE || "binance_top30_usdt").trim().toLowerCase();
+var getReferenceSymbols = () => {
+  const symbols = (process.env.BINANCE_MARKET_CONTEXT_REFERENCE_SYMBOLS || "BTCUSDT,ETHUSDT").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+  return symbols.length ? [...new Set(symbols)] : ["BTCUSDT", "ETHUSDT"];
 };
-var getDerivativesContextReferenceSymbols = () => [
-  ...import_constants.DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS
-];
-var normalizeSymbol = (symbol) => String(symbol || "").trim().toUpperCase();
 var resolvePrimaryReferenceSymbol = (signalSymbol) => {
-  const symbol = normalizeSymbol(signalSymbol);
-  const referenceSymbols = getDerivativesContextReferenceSymbols();
-  return referenceSymbols.some((referenceSymbol) => referenceSymbol === symbol) ? symbol : referenceSymbols[0];
+  const symbol = signalSymbol.trim().toUpperCase();
+  const referenceSymbols = getReferenceSymbols();
+  return referenceSymbols.includes(symbol) ? symbol : referenceSymbols[0];
 };
-var buildReferenceDerivativesContext = (params) => {
-  const { targetSymbol, primaryReferenceSymbol, referenceContexts } = params;
-  const primaryContext = referenceContexts[primaryReferenceSymbol] ?? referenceContexts[getDerivativesContextReferenceSymbols()[0]];
-  if (!primaryContext) {
-    throw new Error("No derivatives reference contexts built");
-  }
-  return {
-    ...primaryContext,
-    targetSymbol,
-    primaryReferenceSymbol: primaryContext.symbol,
-    referenceSymbols: getDerivativesContextReferenceSymbols(),
-    referenceContexts
-  };
+var hasBaseContext = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var isBinanceMarketContextEnabled = (env) => parseEnabledFlag(process.env.BINANCE_MARKET_CONTEXT_ENABLED, env);
+var toTradeFlowContext = (row, interval) => row ? {
+  source: "binance_agg_trades",
+  interval,
+  asOfTs: row.ts.getTime(),
+  ageMs: row.ageMs,
+  stale: row.stale,
+  trades: toFiniteNumberOrNull(row.trades),
+  buyPressurePct: toFiniteNumberOrNull(row.buyPressurePct),
+  buyBaseVolume: toFiniteNumberOrNull(row.buyBaseVolume),
+  sellBaseVolume: toFiniteNumberOrNull(row.sellBaseVolume),
+  buyQuoteVolume: toFiniteNumberOrNull(row.buyQuoteVolume),
+  sellQuoteVolume: toFiniteNumberOrNull(row.sellQuoteVolume),
+  netBaseDelta: toFiniteNumberOrNull(row.netBaseDelta),
+  netQuoteDelta: toFiniteNumberOrNull(row.netQuoteDelta)
+} : null;
+var getCachedReferenceRows = ({
+  referenceSymbols,
+  interval,
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${referenceSymbols.join(",")}:${interval}:${timestamp}:${maxAgeMs}`;
+  const cached = referenceRowsCache.get(key);
+  if (cached) return cached;
+  const promise = Promise.all(
+    referenceSymbols.map(async (symbol) => {
+      const tradeFlow = await (0, import_timescale.getLatestMarketTradeFlow)({
+        symbol,
+        interval,
+        atMs: timestamp,
+        maxAgeMs
+      });
+      return {
+        symbol,
+        tradeFlow: toTradeFlowContext(tradeFlow, interval)
+      };
+    })
+  );
+  referenceRowsCache.set(key, promise);
+  return promise;
 };
-var isDerivativesContextEnabled = (env) => parseEnabledFlag(process.env.DERIVATIVES_CONTEXT_ENABLED, env);
-var enrichSignalWithDerivativesContext = async (params) => {
-  const { signal, env, enabled = isDerivativesContextEnabled(env) } = params;
-  if (!enabled || derivativesContextUnavailable) {
+var getCachedBreadth = ({
+  breadthUniverse,
+  interval,
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${breadthUniverse}:${interval}:${timestamp}:${maxAgeMs}`;
+  const cached = breadthCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_timescale.getLatestMarketBreadth)({
+    universe: breadthUniverse,
+    interval,
+    atMs: timestamp,
+    maxAgeMs
+  });
+  breadthCache.set(key, promise);
+  return promise;
+};
+var enrichSignalWithBinanceMarketContext = async (params) => {
+  const {
+    signal,
+    env,
+    enabled = isBinanceMarketContextEnabled(env),
+    interval = resolveMarketInterval(signal, params.interval),
+    breadthUniverse = resolveBreadthUniverse(),
+    maxAgeMs = DEFAULT_MAX_AGE_BY_INTERVAL[interval]
+  } = params;
+  if (signal.universe === "tradfi" || !enabled || binanceMarketContextUnavailable || !hasBaseContext(signal)) {
     return false;
   }
   try {
-    const intervals = parseIntervals();
-    const referenceSymbols = getDerivativesContextReferenceSymbols();
-    const lookbackMs = parseLookbackMs();
-    const contexts = await Promise.all(
-      referenceSymbols.map(async (symbol) => {
-        const rowsByInterval = await (0, import_timescale.getDerivativesWindow)({
-          symbol,
-          intervals,
-          endMs: signal.timestamp,
-          lookbackMs
-        });
-        return [
-          symbol,
-          (0, import_indicators2.buildDerivativesContext)({
-            symbol,
-            direction: signal.direction,
-            timestamp: signal.timestamp,
-            rowsByInterval,
-            intervals
-          })
-        ];
+    const referenceSymbols = getReferenceSymbols();
+    const primaryReferenceSymbol = resolvePrimaryReferenceSymbol(signal.symbol);
+    const [referenceRows, breadth] = await Promise.all([
+      getCachedReferenceRows({
+        referenceSymbols,
+        interval,
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedBreadth({
+        breadthUniverse,
+        interval,
+        timestamp: signal.timestamp,
+        maxAgeMs
       })
+    ]);
+    const tradeFlowBySymbol = Object.fromEntries(
+      referenceRows.filter((row) => row.tradeFlow).map((row) => [row.symbol, row.tradeFlow])
     );
-    const referenceContexts = Object.fromEntries(contexts);
-    const derivativesContext = buildReferenceDerivativesContext({
-      targetSymbol: signal.symbol,
-      primaryReferenceSymbol: resolvePrimaryReferenceSymbol(signal.symbol),
-      referenceContexts
-    });
+    const targetReferenceSymbol = signal.symbol.trim().toUpperCase();
+    const targetTradeFlow = tradeFlowBySymbol[targetReferenceSymbol];
+    if (!Object.keys(tradeFlowBySymbol).length && !breadth) {
+      return false;
+    }
+    const baseContext = signal.additionalIndicators.baseContext;
     signal.additionalIndicators = {
-      ...signal.additionalIndicators ?? {},
-      derivativesContext
+      ...signal.additionalIndicators,
+      baseContext: {
+        ...baseContext,
+        participation: {
+          ...baseContext.participation,
+          ...targetTradeFlow ? {
+            tradeFlow: targetTradeFlow
+          } : {}
+        },
+        relative: {
+          ...baseContext.relative,
+          execution: {
+            ...baseContext.relative.execution
+          },
+          ...Object.keys(tradeFlowBySymbol).length ? {
+            referenceTradeFlow: {
+              source: "binance_reference_market",
+              primaryReferenceSymbol,
+              referenceSymbols,
+              tradeFlowBySymbol
+            }
+          } : {},
+          ...breadth ? {
+            marketBreadth: {
+              source: "binance_klines",
+              universe: breadth.universe,
+              interval,
+              asOfTs: breadth.ts.getTime(),
+              ageMs: breadth.ageMs,
+              stale: breadth.stale,
+              symbolsCount: toFiniteNumberOrNull(breadth.symbolsCount),
+              advancers: toFiniteNumberOrNull(breadth.advancers),
+              decliners: toFiniteNumberOrNull(breadth.decliners),
+              unchanged: toFiniteNumberOrNull(breadth.unchanged),
+              advanceDeclineRatio: toFiniteNumberOrNull(
+                breadth.advanceDeclineRatio
+              ),
+              pctAboveMa20: toFiniteNumberOrNull(breadth.pctAboveMa20),
+              pctAboveMa50: toFiniteNumberOrNull(breadth.pctAboveMa50),
+              equalWeightedReturn: toFiniteNumberOrNull(
+                breadth.equalWeightedReturn
+              ),
+              volumeWeightedReturn: toFiniteNumberOrNull(
+                breadth.volumeWeightedReturn
+              ),
+              dispersion: toFiniteNumberOrNull(breadth.dispersion)
+            },
+            btcAltRegime: {
+              source: "binance_klines",
+              universe: breadth.universe,
+              interval,
+              asOfTs: breadth.ts.getTime(),
+              ageMs: breadth.ageMs,
+              stale: breadth.stale,
+              btcReturn1h: toFiniteNumberOrNull(breadth.btcReturn1h),
+              btcReturn4h: toFiniteNumberOrNull(breadth.btcReturn4h),
+              btcReturn24h: toFiniteNumberOrNull(breadth.btcReturn24h),
+              altBasketReturn1h: toFiniteNumberOrNull(
+                breadth.altBasketReturn1h
+              ),
+              altBasketReturn4h: toFiniteNumberOrNull(
+                breadth.altBasketReturn4h
+              ),
+              altBasketReturn24h: toFiniteNumberOrNull(
+                breadth.altBasketReturn24h
+              ),
+              btcVsAltReturn1h: toFiniteNumberOrNull(
+                breadth.btcVsAltReturn1h
+              ),
+              btcVsAltReturn4h: toFiniteNumberOrNull(
+                breadth.btcVsAltReturn4h
+              ),
+              btcVsAltReturn24h: toFiniteNumberOrNull(
+                breadth.btcVsAltReturn24h
+              ),
+              btcTurnoverShare1h: toFiniteNumberOrNull(
+                breadth.btcTurnoverShare1h
+              ),
+              btcTurnoverShare24h: toFiniteNumberOrNull(
+                breadth.btcTurnoverShare24h
+              ),
+              btcTurnoverShareChange24h: toFiniteNumberOrNull(
+                breadth.btcTurnoverShareChange24h
+              ),
+              altVolToBtcVol24h: toFiniteNumberOrNull(
+                breadth.altVolToBtcVol24h
+              ),
+              altDispersion24h: toFiniteNumberOrNull(
+                breadth.altDispersion24h
+              ),
+              regime: breadth.btcAltRegime ?? "unknown"
+            }
+          } : {}
+        }
+      }
     };
+    (0, import_strategies.refreshSignalBaseContextGateFeatures)(signal);
     return true;
   } catch (error) {
-    derivativesContextUnavailable = true;
+    binanceMarketContextUnavailable = true;
     import_logger3.logger.warn(
-      "Derivatives context disabled after Timescale read failure: %s",
+      "Binance market context disabled after Timescale read failure: %s",
       String(error)
     );
     return false;
   }
 };
 
-// src/strategyAdapters/ml.ts
-var defaultMlAdapter = {
-  normalizeStrategyConfig: (strategyConfig) => strategyConfig
+// src/strategyHelpers/coinMarketCapContext.ts
+var import_strategies2 = require("@tradejs/core/strategies");
+var import_logger4 = require("@tradejs/infra/logger");
+var import_timescale2 = require("@tradejs/infra/timescale");
+var DEFAULT_MAX_AGE_MS = 48 * 60 * 6e4;
+var SOURCE_GLOBAL_DAILY = "coinmarketcap_global";
+var SOURCE_REFERENCE = "coinmarketcap_reference_asset";
+var SOURCE_EXCHANGE_LIQUIDITY = "coinmarketcap_exchange_liquidity";
+var SOURCE_FEAR_GREED = "coinmarketcap_fear_greed";
+var SOURCE_INDEX = "coinmarketcap_index";
+var DAY_MS = 864e5;
+var coinMarketCapContextUnavailable = false;
+var globalContextCache = /* @__PURE__ */ new Map();
+var referenceContextCache = /* @__PURE__ */ new Map();
+var exchangeLiquidityContextCache = /* @__PURE__ */ new Map();
+var fearGreedContextCache = /* @__PURE__ */ new Map();
+var indexContextCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag2 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return env === "BACKTEST" || env === "PARITY" || env === "CRON";
+  }
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
 };
-var getStrategyMlAdapter = (strategy) => {
-  const strategyAdapter = getStrategyManifest(strategy)?.mlAdapter;
-  if (!strategyAdapter) return defaultMlAdapter;
-  return {
-    ...defaultMlAdapter,
-    ...strategyAdapter
-  };
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 };
-
-// src/mlPayload.ts
-var normalizeStrategyConfig = (strategyConfig, strategyName) => {
-  return getStrategyMlAdapter(strategyName).normalizeStrategyConfig?.(
-    strategyConfig
-  );
+var toFiniteNumberOrNull2 = (value) => {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(numeric) ? numeric : null;
 };
-var buildMlPayload = (payload) => {
-  const strategyName = payload.signal?.strategy ?? payload.context?.strategyName;
-  const mlAdapter = getStrategyMlAdapter(strategyName);
-  const normalizedSignal = mlAdapter.normalizeSignal?.(payload.signal) ?? payload.signal;
-  const nextSignal = {
-    ...normalizedSignal,
-    indicators: {
-      ...normalizedSignal?.indicators ?? {}
-    }
-  };
-  const nextContext = payload.context ? {
-    ...payload.context,
-    strategyConfig: normalizeStrategyConfig(
-      payload.context.strategyConfig,
-      strategyName
-    )
-  } : void 0;
-  return {
-    signal: nextSignal,
-    context: nextContext
-  };
+var safeDivide = (numerator, denominator) => numerator != null && denominator != null && denominator > 0 ? numerator / denominator : null;
+var hasBaseContext2 = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var resolveMaxAgeMs = () => asInt(process.env.COINMARKETCAP_CONTEXT_MAX_AGE_MS, DEFAULT_MAX_AGE_MS);
+var toAltLiquidityRegime = ({
+  stale,
+  btcDominanceChange24hPct,
+  altMarketCapChange24hPct,
+  altVolumeChange24hPct
+}) => {
+  if (stale) return "unknown";
+  if (altMarketCapChange24hPct != null && altMarketCapChange24hPct <= -0.03 || altVolumeChange24hPct != null && altVolumeChange24hPct <= -0.15) {
+    return "risk_off";
+  }
+  if (btcDominanceChange24hPct != null && btcDominanceChange24hPct >= 0.25) {
+    return "btc_favored";
+  }
+  if (btcDominanceChange24hPct != null && btcDominanceChange24hPct <= -0.25 && (altMarketCapChange24hPct == null || altMarketCapChange24hPct >= 0)) {
+    return "alt_friendly";
+  }
+  return "neutral";
 };
-
-// src/connectorsRegistry.ts
-var import_logger4 = require("@tradejs/infra/logger");
-var createConnectorRegistryState = () => ({
-  connectorCreators: /* @__PURE__ */ new Map(),
-  providerToConnectorName: /* @__PURE__ */ new Map(),
-  pluginsLoadPromise: null
-});
-var registryStateByProjectRoot2 = /* @__PURE__ */ new Map();
-var getConnectorRegistryState = (cwd = getTradejsProjectCwd()) => {
-  const projectRoot = getTradejsProjectCwd(cwd);
-  let state = registryStateByProjectRoot2.get(projectRoot);
-  if (!state) {
-    state = createConnectorRegistryState();
-    registryStateByProjectRoot2.set(projectRoot, state);
+var toReferenceLiquidityRegime = ({
+  stale,
+  ethBtcMarketCapRatioChange24hPct,
+  ethVsBtcVolumeRatio
+}) => {
+  if (stale) return "unknown";
+  if (ethVsBtcVolumeRatio != null && ethVsBtcVolumeRatio < 0.15) return "thin";
+  if (ethBtcMarketCapRatioChange24hPct != null && ethBtcMarketCapRatioChange24hPct >= 0.01) {
+    return "eth_led";
   }
-  return {
+  if (ethBtcMarketCapRatioChange24hPct != null && ethBtcMarketCapRatioChange24hPct <= -0.01) {
+    return "btc_led";
+  }
+  return "balanced";
+};
+var toExchangeLiquidityRegime = ({
+  stale,
+  totalVolumeChange24hPct,
+  fallback
+}) => {
+  if (stale) return "unknown";
+  if (totalVolumeChange24hPct != null && totalVolumeChange24hPct >= 0.15) {
+    return "expanding";
+  }
+  if (totalVolumeChange24hPct != null && totalVolumeChange24hPct <= -0.15) {
+    return "contracting";
+  }
+  return fallback;
+};
+var toIndexRegime = ({
+  stale,
+  cmc100Change24hPct,
+  cmc20Change24hPct,
+  cmc20ToCmc100RatioChange24hPct
+}) => {
+  if (stale) return "unknown";
+  if (cmc100Change24hPct == null && cmc20Change24hPct == null) {
+    return "unknown";
+  }
+  if ((cmc100Change24hPct ?? 0) <= -0.02 && (cmc20Change24hPct ?? 0) <= -0.02) {
+    return "risk_off";
+  }
+  if ((cmc20ToCmc100RatioChange24hPct ?? 0) >= 5e-3) {
+    return "top20_led";
+  }
+  if ((cmc20ToCmc100RatioChange24hPct ?? 0) <= -5e-3) {
+    return "large_cap_led";
+  }
+  return "balanced";
+};
+var getCachedGlobalContext = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_GLOBAL_DAILY}:${timestamp}:${maxAgeMs}`;
+  const cached = globalContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_timescale2.getLatestMarketGlobalContext)({
+    source: SOURCE_GLOBAL_DAILY,
+    atMs: timestamp,
+    maxAgeMs
+  });
+  globalContextCache.set(key, promise);
+  return promise;
+};
+var getCachedReferenceContexts = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_REFERENCE}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = referenceContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_timescale2.getLatestMarketReferenceAssetContexts)({
+    source: SOURCE_REFERENCE,
+    symbols: ["BTCUSDT", "ETHUSDT"],
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  referenceContextCache.set(key, promise);
+  return promise;
+};
+var getCachedExchangeLiquidityContext = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_EXCHANGE_LIQUIDITY}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = exchangeLiquidityContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_timescale2.getLatestMarketCmcExchangeLiquidityContext)({
+    source: SOURCE_EXCHANGE_LIQUIDITY,
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  exchangeLiquidityContextCache.set(key, promise);
+  return promise;
+};
+var getCachedFearGreedContext = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_FEAR_GREED}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = fearGreedContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_timescale2.getLatestMarketCmcFearGreedContext)({
+    source: SOURCE_FEAR_GREED,
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  fearGreedContextCache.set(key, promise);
+  return promise;
+};
+var getCachedIndexContexts = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_INDEX}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = indexContextCache.get(key);
+  if (cached) return cached;
+  const promise = (0, import_timescale2.getLatestMarketCmcIndexContexts)({
+    source: SOURCE_INDEX,
+    indexSlugs: ["cmc100", "cmc20"],
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  indexContextCache.set(key, promise);
+  return promise;
+};
+var isCoinMarketCapContextEnabled = (env) => parseEnabledFlag2(process.env.COINMARKETCAP_CONTEXT_ENABLED, env);
+var enrichSignalWithCoinMarketCapContext = async (params) => {
+  const {
+    signal,
+    env,
+    enabled = isCoinMarketCapContextEnabled(env),
+    maxAgeMs = resolveMaxAgeMs()
+  } = params;
+  if (signal.universe === "tradfi" || !enabled || coinMarketCapContextUnavailable || !hasBaseContext2(signal)) {
+    return false;
+  }
+  try {
+    const [
+      globalDailyRow,
+      dailyReferences,
+      previousDailyReferences,
+      exchangeLiquidityRow,
+      fearGreedRow,
+      indexRows
+    ] = await Promise.all([
+      getCachedGlobalContext({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedReferenceContexts({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedReferenceContexts({
+        timestamp: signal.timestamp - DAY_MS,
+        maxAgeMs: maxAgeMs + DAY_MS
+      }),
+      getCachedExchangeLiquidityContext({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedFearGreedContext({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedIndexContexts({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      })
+    ]);
+    const globalRow = globalDailyRow;
+    const references = dailyReferences;
+    const previousReferences = previousDailyReferences;
+    if (!globalRow && !references.size && !exchangeLiquidityRow && !fearGreedRow && !indexRows.size) {
+      return false;
+    }
+    const btcRow = references.get("BTCUSDT") ?? null;
+    const ethRow = references.get("ETHUSDT") ?? null;
+    const previousBtcRow = previousReferences.get("BTCUSDT") ?? null;
+    const previousEthRow = previousReferences.get("ETHUSDT") ?? null;
+    const btcMarketCapUsd = toFiniteNumberOrNull2(btcRow?.marketCapUsd);
+    const ethMarketCapUsd = toFiniteNumberOrNull2(ethRow?.marketCapUsd);
+    const previousBtcMarketCapUsd = toFiniteNumberOrNull2(
+      previousBtcRow?.marketCapUsd
+    );
+    const previousEthMarketCapUsd = toFiniteNumberOrNull2(
+      previousEthRow?.marketCapUsd
+    );
+    const ethBtcMarketCapRatio = safeDivide(ethMarketCapUsd, btcMarketCapUsd);
+    const previousEthBtcMarketCapRatio = safeDivide(
+      previousEthMarketCapUsd,
+      previousBtcMarketCapUsd
+    );
+    const ethBtcMarketCapRatioChange24hPct = ethBtcMarketCapRatio != null && previousEthBtcMarketCapRatio != null && previousEthBtcMarketCapRatio > 0 ? (ethBtcMarketCapRatio - previousEthBtcMarketCapRatio) / previousEthBtcMarketCapRatio : null;
+    const btcVolumeUsd = toFiniteNumberOrNull2(btcRow?.volumeUsd);
+    const ethVolumeUsd = toFiniteNumberOrNull2(ethRow?.volumeUsd);
+    const referenceStale = btcRow?.stale === true || ethRow?.stale === true || !btcRow || !ethRow;
+    const btcDominanceChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.btcDominanceChange24hPct
+    );
+    const altMarketCapChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.altMarketCapChange24hPct
+    );
+    const altVolumeChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.altVolumeChange24hPct
+    );
+    const altLiquidityRegime = globalRow ? toAltLiquidityRegime({
+      stale: globalRow.stale,
+      btcDominanceChange24hPct,
+      altMarketCapChange24hPct,
+      altVolumeChange24hPct
+    }) : "unknown";
+    const exchangeLiquidityRegime = exchangeLiquidityRow ? toExchangeLiquidityRegime({
+      stale: exchangeLiquidityRow.stale,
+      totalVolumeChange24hPct: toFiniteNumberOrNull2(
+        exchangeLiquidityRow.totalVolumeChange24hPct
+      ),
+      fallback: exchangeLiquidityRow.liquidityRegime ?? "unknown"
+    }) : "unknown";
+    const cmc100Row = indexRows.get("cmc100") ?? null;
+    const cmc20Row = indexRows.get("cmc20") ?? null;
+    const cmc100Value = toFiniteNumberOrNull2(cmc100Row?.value);
+    const cmc20Value = toFiniteNumberOrNull2(cmc20Row?.value);
+    const cmc100Change24hPct = toFiniteNumberOrNull2(
+      cmc100Row?.valueChange24hPct
+    );
+    const cmc20Change24hPct = toFiniteNumberOrNull2(cmc20Row?.valueChange24hPct);
+    const cmc20ToCmc100Ratio = safeDivide(cmc20Value, cmc100Value);
+    const cmc20ToCmc100RatioChange24hPct = cmc20Change24hPct != null && cmc100Change24hPct != null ? (1 + cmc20Change24hPct) / (1 + cmc100Change24hPct) - 1 : null;
+    const indexStale = cmc100Row?.stale === true || cmc20Row?.stale === true || !cmc100Row || !cmc20Row;
+    const indexRegime = toIndexRegime({
+      stale: indexStale,
+      cmc100Change24hPct,
+      cmc20Change24hPct,
+      cmc20ToCmc100RatioChange24hPct
+    });
+    const baseContext = signal.additionalIndicators.baseContext;
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators,
+      baseContext: {
+        ...baseContext,
+        relative: {
+          ...baseContext.relative,
+          ...globalRow ? {
+            cmcGlobal: {
+              source: globalRow.source,
+              interval: "1d",
+              asOfTs: globalRow.ts.getTime(),
+              ageMs: globalRow.ageMs,
+              stale: globalRow.stale,
+              totalMarketCapUsd: toFiniteNumberOrNull2(
+                globalRow.totalMarketCapUsd
+              ),
+              totalVolumeUsd: toFiniteNumberOrNull2(
+                globalRow.totalVolumeUsd
+              ),
+              totalVolumeReportedUsd: toFiniteNumberOrNull2(
+                globalRow.totalVolumeReportedUsd
+              ),
+              altMarketCapUsd: toFiniteNumberOrNull2(
+                globalRow.altMarketCapUsd
+              ),
+              altVolumeUsd: toFiniteNumberOrNull2(globalRow.altVolumeUsd),
+              altVolumeReportedUsd: toFiniteNumberOrNull2(
+                globalRow.altVolumeReportedUsd
+              ),
+              btcDominancePct: toFiniteNumberOrNull2(
+                globalRow.btcDominancePct
+              ),
+              ethDominancePct: toFiniteNumberOrNull2(
+                globalRow.ethDominancePct
+              ),
+              btcDominanceChange24hPct,
+              ethDominanceChange24hPct: toFiniteNumberOrNull2(
+                globalRow.ethDominanceChange24hPct
+              ),
+              altMarketCapChange24hPct,
+              altVolumeChange24hPct,
+              activeCryptocurrencies: toFiniteNumberOrNull2(
+                globalRow.activeCryptocurrencies
+              ),
+              activeExchanges: toFiniteNumberOrNull2(
+                globalRow.activeExchanges
+              ),
+              activeMarketPairs: toFiniteNumberOrNull2(
+                globalRow.activeMarketPairs
+              ),
+              altLiquidityRegime
+            }
+          } : {},
+          ...btcRow || ethRow ? {
+            cmcReferenceAssets: {
+              source: SOURCE_REFERENCE,
+              interval: "1d",
+              asOfTs: Math.max(
+                btcRow?.ts.getTime() ?? 0,
+                ethRow?.ts.getTime() ?? 0
+              ),
+              ageMs: btcRow?.ageMs != null && ethRow?.ageMs != null ? Math.max(btcRow.ageMs, ethRow.ageMs) : btcRow?.ageMs ?? ethRow?.ageMs ?? null,
+              stale: referenceStale,
+              btcMarketCapUsd,
+              ethMarketCapUsd,
+              btcVolumeUsd,
+              ethVolumeUsd,
+              btcVolumeToMarketCap: safeDivide(
+                btcVolumeUsd,
+                btcMarketCapUsd
+              ),
+              ethVolumeToMarketCap: safeDivide(
+                ethVolumeUsd,
+                ethMarketCapUsd
+              ),
+              ethBtcMarketCapRatio,
+              ethBtcMarketCapRatioChange24hPct,
+              ethVsBtcVolumeRatio: safeDivide(ethVolumeUsd, btcVolumeUsd),
+              referenceLiquidityRegime: toReferenceLiquidityRegime({
+                stale: referenceStale,
+                ethBtcMarketCapRatioChange24hPct,
+                ethVsBtcVolumeRatio: safeDivide(ethVolumeUsd, btcVolumeUsd)
+              })
+            }
+          } : {},
+          ...exchangeLiquidityRow ? {
+            cmcExchangeLiquidity: {
+              source: SOURCE_EXCHANGE_LIQUIDITY,
+              interval: exchangeLiquidityRow.interval,
+              asOfTs: exchangeLiquidityRow.ts.getTime(),
+              ageMs: exchangeLiquidityRow.ageMs,
+              stale: exchangeLiquidityRow.stale,
+              exchangesCount: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.exchangesCount
+              ),
+              totalVolumeUsd: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.totalVolumeUsd
+              ),
+              totalVolumeChange24hPct: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.totalVolumeChange24hPct
+              ),
+              binanceVolumeUsd: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.binanceVolumeUsd
+              ),
+              binanceVolumeShare: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.binanceVolumeShare
+              ),
+              topExchangeVolumeShare: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.topExchangeVolumeShare
+              ),
+              liquidityRegime: exchangeLiquidityRegime
+            }
+          } : {},
+          ...fearGreedRow ? {
+            cmcFearGreed: {
+              source: SOURCE_FEAR_GREED,
+              interval: "1d",
+              asOfTs: fearGreedRow.ts.getTime(),
+              ageMs: fearGreedRow.ageMs,
+              stale: fearGreedRow.stale,
+              value: toFiniteNumberOrNull2(fearGreedRow.value),
+              valueChange24h: toFiniteNumberOrNull2(
+                fearGreedRow.valueChange24h
+              ),
+              valueChange7d: toFiniteNumberOrNull2(
+                fearGreedRow.valueChange7d
+              ),
+              classification: fearGreedRow.classification ?? "Unknown",
+              sentimentRegime: fearGreedRow.sentimentRegime ?? "unknown"
+            }
+          } : {},
+          ...cmc100Row || cmc20Row ? {
+            cmcIndexes: {
+              source: SOURCE_INDEX,
+              interval: "1d",
+              asOfTs: Math.max(
+                cmc100Row?.ts.getTime() ?? 0,
+                cmc20Row?.ts.getTime() ?? 0
+              ),
+              ageMs: cmc100Row?.ageMs != null && cmc20Row?.ageMs != null ? Math.max(cmc100Row.ageMs, cmc20Row.ageMs) : cmc100Row?.ageMs ?? cmc20Row?.ageMs ?? null,
+              stale: indexStale,
+              cmc100Value,
+              cmc100Change24hPct,
+              cmc100TopConstituentSymbol: cmc100Row?.topConstituentSymbol ?? null,
+              cmc100TopConstituentWeightPct: toFiniteNumberOrNull2(
+                cmc100Row?.topConstituentWeightPct
+              ),
+              cmc20Value,
+              cmc20Change24hPct,
+              cmc20TopConstituentSymbol: cmc20Row?.topConstituentSymbol ?? null,
+              cmc20TopConstituentWeightPct: toFiniteNumberOrNull2(
+                cmc20Row?.topConstituentWeightPct
+              ),
+              cmc20ToCmc100Ratio,
+              cmc20ToCmc100RatioChange24hPct,
+              indexRegime
+            }
+          } : {}
+        }
+      }
+    };
+    (0, import_strategies2.refreshSignalBaseContextGateFeatures)(signal);
+    return true;
+  } catch (error) {
+    coinMarketCapContextUnavailable = true;
+    import_logger4.logger.warn(
+      "CoinMarketCap context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyHelpers/derivativesContext.ts
+var import_indicators2 = require("@tradejs/core/indicators");
+var import_strategies3 = require("@tradejs/core/strategies");
+var import_constants = require("@tradejs/core/constants");
+var import_timescale3 = require("@tradejs/infra/timescale");
+var import_logger5 = require("@tradejs/infra/logger");
+var DEFAULT_INTERVALS = ["15m", "1h"];
+var DEFAULT_LOOKBACK_HOURS = 48;
+var PRIMARY_DERIVATIVES_REFERENCE_SYMBOL = import_constants.DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[0];
+var SECONDARY_DERIVATIVES_REFERENCE_SYMBOL = import_constants.DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[1];
+var derivativesContextUnavailable = false;
+var parseEnabledFlag3 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return true;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var parseBooleanFlag = (value, fallback = false) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+};
+var parseLookbackMs = () => {
+  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
+  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
+  return normalizedHours * 60 * 60 * 1e3;
+};
+var parseIntervals = () => {
+  const fromEnv = (0, import_indicators2.normalizeDerivativesIntervals)(
+    process.env.DERIVATIVES_CONTEXT_INTERVALS
+  );
+  return fromEnv.length ? fromEnv : DEFAULT_INTERVALS;
+};
+var getDerivativesContextReferenceSymbols = () => [
+  ...(0, import_constants.resolveDerivativesContextReferenceSymbols)(
+    process.env.DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS
+  )
+];
+var normalizeSymbol = (symbol) => String(symbol || "").trim().toUpperCase();
+var getSignalPriceChangePct1h = (signal) => {
+  const baseContext = signal.additionalIndicators?.baseContext;
+  if (!baseContext || typeof baseContext !== "object" || Array.isArray(baseContext)) {
+    return null;
+  }
+  const raw = typeof baseContext.raw === "object" && baseContext.raw && !Array.isArray(baseContext.raw) ? baseContext.raw : null;
+  const price = raw && typeof raw.price === "object" && raw.price && !Array.isArray(raw.price) ? raw.price : null;
+  const value = price?.price1hPct;
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var resolvePrimaryReferenceSymbol2 = () => PRIMARY_DERIVATIVES_REFERENCE_SYMBOL;
+var resolveSecondaryReferenceSymbol = () => SECONDARY_DERIVATIVES_REFERENCE_SYMBOL;
+var getPrimaryIntervalContext = (context) => context?.intervals["15m"] ?? context?.intervals["1h"] ?? null;
+var hasDerivativesSymbolData = (context) => Object.keys(context.intervals).length > 0 && !context.summary.riskFlags.includes("missing_derivatives");
+var toFiniteNumberOrNull3 = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var roundNullable = (value, digits = 4) => {
+  if (value == null || !Number.isFinite(value)) return null;
+  const multiplier = 10 ** digits;
+  return Math.round(value * multiplier) / multiplier;
+};
+var deltaNullable = (targetValue, referenceValue) => {
+  const target = toFiniteNumberOrNull3(targetValue);
+  const reference = toFiniteNumberOrNull3(referenceValue);
+  return target == null || reference == null ? null : roundNullable(target - reference);
+};
+var buildTargetDerivedContext = (params) => {
+  const { targetContext, primaryReferenceContext } = params;
+  const targetPrimary = getPrimaryIntervalContext(targetContext);
+  const referencePrimary = getPrimaryIntervalContext(primaryReferenceContext);
+  const targetDirectionAligned = targetContext.summary.directionAligned;
+  const referenceDirectionAligned = primaryReferenceContext?.summary.directionAligned ?? null;
+  return {
+    available: hasDerivativesSymbolData(targetContext),
+    stale: targetContext.summary.riskFlags.includes("stale_derivatives") || targetPrimary?.stale === true ? true : targetPrimary == null ? null : false,
+    sourceSymbol: targetContext.symbol,
+    referenceSymbol: primaryReferenceContext?.symbol ?? null,
+    directionAligned: targetDirectionAligned,
+    referenceDirectionAligned,
+    pressure: targetContext.summary.pressure ?? null,
+    referencePressure: primaryReferenceContext?.summary.pressure ?? null,
+    riskFlags: targetContext.summary.riskFlags,
+    oiChangePct1h: targetPrimary?.oiChangePct1h ?? null,
+    oiAcceleration: targetContext.summary.oiAcceleration ?? null,
+    fundingRate: targetPrimary?.fundingRate ?? null,
+    fundingZScore: targetPrimary?.fundingZScore ?? null,
+    fundingChange1h: targetContext.summary.fundingChange1h ?? null,
+    liqSpikeRatio: targetPrimary?.liqSpikeRatio ?? null,
+    liqImbalance: targetPrimary?.liqImbalance ?? null,
+    targetVsPrimaryOiChangePct1hDelta: deltaNullable(
+      targetPrimary?.oiChangePct1h,
+      referencePrimary?.oiChangePct1h
+    ),
+    targetVsPrimaryFundingZScoreDelta: deltaNullable(
+      targetPrimary?.fundingZScore,
+      referencePrimary?.fundingZScore
+    ),
+    targetReferenceConflict: targetDirectionAligned == null || referenceDirectionAligned == null ? null : targetDirectionAligned !== referenceDirectionAligned
+  };
+};
+var buildReferenceDerivativesContext = (params) => {
+  const {
+    targetSymbol,
+    primaryReferenceSymbol,
+    secondaryReferenceSymbol,
+    referenceSymbols,
+    referenceContexts,
+    targetContext
+  } = params;
+  const primaryContext = referenceContexts[primaryReferenceSymbol] ?? referenceContexts[referenceSymbols[0]];
+  if (!primaryContext) {
+    throw new Error("No derivatives reference contexts built");
+  }
+  const referenceSymbolsMetadata = [
+    .../* @__PURE__ */ new Set([
+      primaryReferenceSymbol,
+      secondaryReferenceSymbol,
+      ...referenceSymbols,
+      ...Object.keys(referenceContexts)
+    ])
+  ];
+  const targetDerived = targetContext && hasDerivativesSymbolData(targetContext) ? buildTargetDerivedContext({
+    targetContext,
+    primaryReferenceContext: primaryContext
+  }) : void 0;
+  return {
+    ...primaryContext,
+    targetSymbol,
+    primaryReferenceSymbol: primaryContext.symbol,
+    secondaryReferenceSymbol: referenceContexts[secondaryReferenceSymbol]?.symbol ?? secondaryReferenceSymbol,
+    referenceSymbols: referenceSymbolsMetadata,
+    referenceContexts,
+    ...targetContext && targetDerived ? {
+      targetContext,
+      targetDerived
+    } : {}
+  };
+};
+var isDerivativesContextEnabled = (env) => parseEnabledFlag3(process.env.DERIVATIVES_CONTEXT_ENABLED, env);
+var isDerivativesTargetContextEnabled = () => parseBooleanFlag(process.env.DERIVATIVES_CONTEXT_TARGET_ENABLED, false);
+var enrichSignalWithDerivativesContext = async (params) => {
+  const { signal, env, enabled = isDerivativesContextEnabled(env) } = params;
+  if (signal.universe === "tradfi" || !enabled || derivativesContextUnavailable) {
+    return false;
+  }
+  try {
+    const intervals = parseIntervals();
+    const referenceSymbols = getDerivativesContextReferenceSymbols();
+    const targetSymbol = normalizeSymbol(signal.symbol);
+    const lookbackMs = parseLookbackMs();
+    const contexts = await Promise.all(
+      referenceSymbols.map(async (symbol) => {
+        const rowsByInterval = await (0, import_timescale3.getDerivativesWindow)({
+          symbol,
+          intervals,
+          endMs: signal.timestamp,
+          lookbackMs
+        });
+        return [
+          symbol,
+          (0, import_indicators2.buildDerivativesContext)({
+            symbol,
+            direction: signal.direction,
+            timestamp: signal.timestamp,
+            rowsByInterval,
+            priceChangePct1h: getSignalPriceChangePct1h(signal),
+            intervals
+          })
+        ];
+      })
+    );
+    const referenceContexts = Object.fromEntries(contexts);
+    const primaryReferenceSymbol = resolvePrimaryReferenceSymbol2();
+    const secondaryReferenceSymbol = resolveSecondaryReferenceSymbol();
+    const targetContextEnabled = isDerivativesTargetContextEnabled();
+    const referenceTargetContext = targetContextEnabled && targetSymbol !== primaryReferenceSymbol ? referenceContexts[targetSymbol] : void 0;
+    const shouldFetchTargetContext = targetContextEnabled && targetSymbol.length > 0 && !referenceSymbols.some(
+      (referenceSymbol) => referenceSymbol === targetSymbol
+    );
+    const fetchedTargetContext = shouldFetchTargetContext ? await (async () => {
+      const rowsByInterval = await (0, import_timescale3.getDerivativesWindow)({
+        symbol: targetSymbol,
+        intervals,
+        endMs: signal.timestamp,
+        lookbackMs
+      });
+      const context = (0, import_indicators2.buildDerivativesContext)({
+        symbol: targetSymbol,
+        direction: signal.direction,
+        timestamp: signal.timestamp,
+        rowsByInterval,
+        priceChangePct1h: getSignalPriceChangePct1h(signal),
+        intervals
+      });
+      return hasDerivativesSymbolData(context) ? context : void 0;
+    })() : void 0;
+    const targetContext = referenceTargetContext && hasDerivativesSymbolData(referenceTargetContext) ? referenceTargetContext : fetchedTargetContext;
+    const derivativesContext = buildReferenceDerivativesContext({
+      targetSymbol: targetSymbol || signal.symbol,
+      primaryReferenceSymbol,
+      secondaryReferenceSymbol,
+      referenceSymbols,
+      referenceContexts,
+      targetContext
+    });
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators ?? {},
+      baseContext: signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext) ? {
+        ...signal.additionalIndicators.baseContext,
+        derivatives: derivativesContext
+      } : signal.additionalIndicators?.baseContext
+    };
+    (0, import_strategies3.refreshSignalBaseContextGateFeatures)(signal);
+    return true;
+  } catch (error) {
+    derivativesContextUnavailable = true;
+    import_logger5.logger.warn(
+      "Derivatives context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyAdapters/ml.ts
+var defaultMlAdapter = {
+  normalizeStrategyConfig: (strategyConfig) => strategyConfig
+};
+var getStrategyMlAdapter = (strategy, profileId) => {
+  const strategyAdapter = getStrategyProfileMlAdapter(
+    getStrategyManifest(strategy),
+    profileId
+  );
+  if (!strategyAdapter) return defaultMlAdapter;
+  return {
+    ...defaultMlAdapter,
+    ...strategyAdapter
+  };
+};
+
+// src/mlPayload.ts
+var normalizeStrategyConfig = (strategyConfig, strategyName, profileId) => {
+  return getStrategyMlAdapter(
+    strategyName,
+    profileId
+  ).normalizeStrategyConfig?.(strategyConfig);
+};
+var buildMlPayload = (payload) => {
+  const strategyName = payload.signal?.strategy ?? payload.context?.strategyName;
+  const profileId = payload.signal?.policyProfileId;
+  const mlAdapter = getStrategyMlAdapter(strategyName, profileId);
+  const normalizedSignal = mlAdapter.normalizeSignal?.(payload.signal) ?? payload.signal;
+  const nextSignal = {
+    ...normalizedSignal,
+    indicators: {
+      ...normalizedSignal?.indicators ?? {}
+    }
+  };
+  const nextContext = payload.context ? {
+    ...payload.context,
+    strategyConfig: normalizeStrategyConfig(
+      payload.context.strategyConfig,
+      strategyName,
+      profileId
+    )
+  } : void 0;
+  return {
+    signal: nextSignal,
+    context: nextContext
+  };
+};
+
+// src/connectorsRegistry.ts
+var import_logger6 = require("@tradejs/infra/logger");
+var createConnectorRegistryState = () => ({
+  connectorCreators: /* @__PURE__ */ new Map(),
+  providerToConnectorName: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot2 = /* @__PURE__ */ new Map();
+var getConnectorRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot2.get(projectRoot);
+  if (!state) {
+    state = createConnectorRegistryState();
+    registryStateByProjectRoot2.set(projectRoot, state);
+  }
+  return {
     projectRoot,
     state
   };
@@ -839,7 +2171,7 @@ var normalizeProviders = (providers, connectorName) => {
 var registerProvider = (provider, connectorName, source, providerToConnectorName) => {
   const existing = providerToConnectorName.get(provider);
   if (existing && existing !== connectorName) {
-    import_logger4.logger.warn(
+    import_logger6.logger.warn(
       'Skip duplicate connector provider "%s" from %s: already mapped to %s',
       provider,
       source,
@@ -852,11 +2184,11 @@ var registerProvider = (provider, connectorName, source, providerToConnectorName
 var registerEntry = (entry, source, state) => {
   const connectorName = String(entry?.name ?? "").trim();
   if (!connectorName) {
-    import_logger4.logger.warn("Skip connector entry without name from %s", source);
+    import_logger6.logger.warn("Skip connector entry without name from %s", source);
     return;
   }
   if (typeof entry.creator !== "function") {
-    import_logger4.logger.warn(
+    import_logger6.logger.warn(
       'Skip connector entry "%s" from %s: creator must be a function',
       connectorName,
       source
@@ -868,7 +2200,7 @@ var registerEntry = (entry, source, state) => {
     state.connectorCreators
   );
   if (existingByName) {
-    import_logger4.logger.warn(
+    import_logger6.logger.warn(
       'Skip duplicate connector "%s" from %s: already registered as %s',
       connectorName,
       source,
@@ -940,7 +2272,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           );
           const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
           if (!pluginDefinition) {
-            import_logger4.logger.warn(
+            import_logger6.logger.warn(
               'Skip connector plugin "%s": export { connectorEntries } is missing',
               moduleName
             );
@@ -948,7 +2280,7 @@ var ensureConnectorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
           }
           registerEntries2(pluginDefinition.connectorEntries, moduleName, state);
         } catch (error) {
-          import_logger4.logger.warn(
+          import_logger6.logger.warn(
             'Failed to load connector plugin "%s": %s',
             moduleName,
             String(error)
@@ -980,19 +2312,31 @@ var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
 
 // src/testConnector.ts
 var import_node_crypto = require("crypto");
+var import_constants2 = require("@tradejs/core/constants");
+var import_backtest = require("@tradejs/core/backtest");
+var import_trade = require("@tradejs/core/trade");
 var import_math = require("@tradejs/core/math");
-var FEE = 5e-3;
-var INITIAL_AMOUNT = 100;
+var PRICE_PRECISION = 8;
 var createTestConnector = (connector, context) => {
   let state = {};
   const orderLog = [];
   const positionLog = [];
+  const fastMode = Boolean(context?.fastMode);
+  const executionCostModel = context?.executionCostModel;
+  const makerFeeRate = executionCostModel?.fees.makerRate ?? import_constants2.FEE_PERCENT;
+  const takerFeeRate = executionCostModel?.fees.takerRate ?? import_constants2.FEE_PERCENT;
+  const fundingRates = [...context?.fundingRates ?? []].sort(
+    (left, right) => left.timestamp - right.timestamp
+  );
+  const processedFundingTimestamps = /* @__PURE__ */ new Set();
   let currentPosition = null;
-  let amount = INITIAL_AMOUNT;
+  let amount = import_constants2.INITIAL_BACKTEST_AMOUNT;
   let originalQty = 0;
   let currentPositionProfit = 0;
+  let currentSignalId = null;
   let takeProfits = [];
   let stopLossPrice = null;
+  let currentTradeResult = null;
   const closedSignalResults = [];
   const logOrder = (data) => {
     const nextEntry = {
@@ -1003,10 +2347,157 @@ var createTestConnector = (connector, context) => {
       index: orderLog.length
     };
     if (nextEntry.signal) {
-      const { indicators: _indicators, ...signalWithoutIndicators } = nextEntry.signal;
-      nextEntry.signal = signalWithoutIndicators;
+      const {
+        additionalIndicators: _additionalIndicators,
+        indicators: _indicators,
+        ...signalWithoutHeavyContext
+      } = nextEntry.signal;
+      nextEntry.signal = signalWithoutHeavyContext;
+    }
+    if (!fastMode) {
+      orderLog.push(nextEntry);
     }
-    orderLog.push(nextEntry);
+  };
+  const roundNullable2 = (value) => value == null ? null : (0, import_math.round)(value);
+  const roundPrice = (value) => (0, import_math.round)(value, PRICE_PRECISION);
+  const roundNullablePrice = (value) => value == null ? null : roundPrice(value);
+  const getSlippageCost = ({
+    requestedPrice,
+    executionPrice,
+    direction,
+    stage,
+    qty
+  }) => {
+    if (direction === "LONG") {
+      return stage === "entry" ? Math.max(0, executionPrice - requestedPrice) * qty : Math.max(0, requestedPrice - executionPrice) * qty;
+    }
+    return stage === "entry" ? Math.max(0, requestedPrice - executionPrice) * qty : Math.max(0, executionPrice - requestedPrice) * qty;
+  };
+  const getSlippageBps = (requestedPrice, executionPrice) => requestedPrice ? (executionPrice - requestedPrice) / requestedPrice * 1e4 : 0;
+  const getWeightedAverage = (previousValue, previousQty, nextValue, nextQty) => {
+    if (previousValue == null || previousQty <= 0) {
+      return nextValue;
+    }
+    return (previousValue * previousQty + nextValue * nextQty) / (previousQty + nextQty);
+  };
+  const finalizeTradeResult = (tradeResult, timestamp) => {
+    if (!tradeResult.exitReason) {
+      return void 0;
+    }
+    return {
+      ...tradeResult,
+      exitTimestamp: tradeResult.exitTimestamp ?? timestamp,
+      exitReason: tradeResult.exitReason,
+      requestedEntryPrice: roundPrice(tradeResult.requestedEntryPrice),
+      entryPrice: roundPrice(tradeResult.entryPrice),
+      requestedExitPrice: roundNullablePrice(tradeResult.requestedExitPrice),
+      exitPrice: roundNullablePrice(tradeResult.exitPrice),
+      grossProfit: (0, import_math.round)(tradeResult.grossProfit),
+      netProfit: (0, import_math.round)(tradeResult.netProfit),
+      openFee: (0, import_math.round)(tradeResult.openFee),
+      closeFee: (0, import_math.round)(tradeResult.closeFee),
+      fundingFee: roundNullable2(tradeResult.fundingFee),
+      totalFee: (0, import_math.round)(tradeResult.totalFee),
+      entrySlippagePrice: (0, import_math.round)(tradeResult.entrySlippagePrice),
+      entrySlippageBps: (0, import_math.round)(tradeResult.entrySlippageBps),
+      entryBaseSlippageBps: (0, import_math.round)(tradeResult.entryBaseSlippageBps),
+      entrySpreadBps: (0, import_math.round)(tradeResult.entrySpreadBps),
+      entrySpreadSlippageBps: (0, import_math.round)(tradeResult.entrySpreadSlippageBps),
+      entryMarketImpactBps: (0, import_math.round)(tradeResult.entryMarketImpactBps),
+      entryDelayRiskBps: roundNullable2(tradeResult.entryDelayRiskBps),
+      entrySlippageCost: (0, import_math.round)(tradeResult.entrySlippageCost),
+      exitSlippagePrice: roundNullable2(tradeResult.exitSlippagePrice),
+      exitSlippageBps: roundNullable2(tradeResult.exitSlippageBps),
+      exitBaseSlippageBps: roundNullable2(tradeResult.exitBaseSlippageBps),
+      exitSpreadBps: roundNullable2(tradeResult.exitSpreadBps),
+      exitSpreadSlippageBps: roundNullable2(tradeResult.exitSpreadSlippageBps),
+      exitMarketImpactBps: roundNullable2(tradeResult.exitMarketImpactBps),
+      exitDelayRiskBps: roundNullable2(tradeResult.exitDelayRiskBps),
+      exitSlippageCost: (0, import_math.round)(tradeResult.exitSlippageCost),
+      totalSlippageCost: (0, import_math.round)(tradeResult.totalSlippageCost),
+      qty: (0, import_math.round)(tradeResult.qty),
+      closedQty: (0, import_math.round)(tradeResult.closedQty)
+    };
+  };
+  const recordExitResult = ({
+    timestamp,
+    reason,
+    requestedPrice,
+    executionPrice,
+    qty,
+    grossProfit,
+    fee,
+    slippageBreakdown
+  }) => {
+    if (!currentTradeResult || !currentPosition) {
+      return;
+    }
+    const previousClosedQty = currentTradeResult.closedQty;
+    const requestedExitPrice = getWeightedAverage(
+      currentTradeResult.requestedExitPrice,
+      previousClosedQty,
+      requestedPrice,
+      qty
+    );
+    const exitPrice = getWeightedAverage(
+      currentTradeResult.exitPrice,
+      previousClosedQty,
+      executionPrice,
+      qty
+    );
+    const exitBaseSlippageBps = getWeightedAverage(
+      currentTradeResult.exitBaseSlippageBps,
+      previousClosedQty,
+      slippageBreakdown.baseSlippageBps,
+      qty
+    );
+    const exitSpreadBps = getWeightedAverage(
+      currentTradeResult.exitSpreadBps,
+      previousClosedQty,
+      slippageBreakdown.spreadBps,
+      qty
+    );
+    const exitSpreadSlippageBps = getWeightedAverage(
+      currentTradeResult.exitSpreadSlippageBps,
+      previousClosedQty,
+      slippageBreakdown.spreadSlippageBps,
+      qty
+    );
+    const exitMarketImpactBps = getWeightedAverage(
+      currentTradeResult.exitMarketImpactBps,
+      previousClosedQty,
+      slippageBreakdown.marketImpactBps,
+      qty
+    );
+    const exitDelayRiskBps = null;
+    const exitSlippageCost = currentTradeResult.exitSlippageCost + getSlippageCost({
+      requestedPrice,
+      executionPrice,
+      direction: currentPosition.direction,
+      stage: "exit",
+      qty
+    });
+    currentTradeResult = {
+      ...currentTradeResult,
+      closedQty: previousClosedQty + qty,
+      exitTimestamp: timestamp,
+      exitReason: reason,
+      requestedExitPrice,
+      exitPrice,
+      grossProfit: currentTradeResult.grossProfit + grossProfit,
+      netProfit: currentTradeResult.netProfit + grossProfit - fee,
+      closeFee: currentTradeResult.closeFee + fee,
+      totalFee: currentTradeResult.openFee + currentTradeResult.closeFee + fee + (currentTradeResult.fundingFee ?? 0),
+      exitSlippagePrice: exitPrice - requestedExitPrice,
+      exitSlippageBps: getSlippageBps(requestedExitPrice, exitPrice),
+      exitBaseSlippageBps,
+      exitSpreadBps,
+      exitSpreadSlippageBps,
+      exitMarketImpactBps,
+      exitDelayRiskBps,
+      exitSlippageCost,
+      totalSlippageCost: currentTradeResult.entrySlippageCost + exitSlippageCost
+    };
   };
   const clearPosition = (timestamp) => {
     takeProfits = [];
@@ -1016,11 +2507,12 @@ var createTestConnector = (connector, context) => {
       return;
     }
     if (context?.mlEnabled || context?.aiEnabled) {
-      const signalId = currentPosition.signal?.signalId;
-      if (signalId) {
+      if (currentSignalId) {
+        const tradeResult = currentTradeResult ? finalizeTradeResult(currentTradeResult, timestamp) : void 0;
         closedSignalResults.push({
-          signalId,
-          profit: currentPositionProfit
+          signalId: currentSignalId,
+          profit: (0, import_math.round)(currentPositionProfit),
+          ...tradeResult ? { tradeResult } : {}
         });
       }
     }
@@ -1036,29 +2528,117 @@ var createTestConnector = (connector, context) => {
       }
     });
     currentPosition = null;
+    currentSignalId = null;
+    currentTradeResult = null;
     currentPositionProfit = 0;
   };
-  return {
-    __tradejsTestConnector: true,
-    getState: async () => state,
-    setState: async (newState) => {
-      state = {
-        ...state,
-        ...newState
-      };
-    },
-    kline: async (options) => connector.kline(options),
-    getResult: async () => {
-      const orderLogId = (0, import_node_crypto.randomUUID)().slice(-12);
+  const getNetProfit = ({
+    grossProfit,
+    price,
+    qty,
+    feeRate = takerFeeRate
+  }) => {
+    const fee = price * qty * feeRate;
+    return {
+      fee,
+      profit: grossProfit - fee
+    };
+  };
+  const applyFunding = (candle) => {
+    if (!executionCostModel?.funding.enabled || !currentPosition) {
+      return;
+    }
+    for (const point of fundingRates) {
+      if (processedFundingTimestamps.has(point.timestamp) || point.symbol.toUpperCase() !== currentPosition.symbol.toUpperCase() || point.timestamp <= currentPosition.timestamp || point.timestamp > candle.timestamp) {
+        continue;
+      }
+      processedFundingTimestamps.add(point.timestamp);
+      const notional = candle.close * currentPosition.qty;
+      const fundingCost = notional * point.rate * (currentPosition.direction === "LONG" ? 1 : -1);
+      amount -= fundingCost;
+      currentPositionProfit -= fundingCost;
+      if (currentTradeResult) {
+        currentTradeResult.fundingFee = (currentTradeResult.fundingFee ?? 0) + fundingCost;
+        currentTradeResult.netProfit -= fundingCost;
+        currentTradeResult.totalFee += fundingCost;
+      }
+    }
+  };
+  const getExitTimestamp = (candle) => currentPosition ? Math.max(candle.timestamp, currentPosition.timestamp) : candle.timestamp;
+  const applyExecutionSlippage = ({
+    price,
+    direction,
+    stage,
+    signal
+  }) => {
+    const modelParams = {
+      baseSlippageBps: executionCostModel?.slippage.baseBps,
+      spreadBps: (0, import_trade.extractExecutionSpreadBps)(signal),
+      spreadMultiplier: executionCostModel?.slippage.spreadMultiplier,
+      marketImpactBps: (0, import_trade.extractExecutionMarketImpactBps)(signal) ?? executionCostModel?.slippage.marketImpactBps,
+      delayRiskBps: stage === "entry" ? ((0, import_trade.extractExecutionDelayRiskBps)(signal) ?? 0) * (executionCostModel?.slippage.delayRiskMultiplier ?? 1) : null
+    };
+    return (0, import_trade.applyExecutionSlippage)({
+      price,
+      direction,
+      stage,
+      ...modelParams
+    });
+  };
+  const getExecutionSlippageBreakdown = ({
+    stage,
+    signal
+  }) => (0, import_trade.calculateExecutionSlippageBreakdown)({
+    baseSlippageBps: executionCostModel?.slippage.baseBps,
+    spreadBps: (0, import_trade.extractExecutionSpreadBps)(signal),
+    spreadMultiplier: executionCostModel?.slippage.spreadMultiplier,
+    marketImpactBps: (0, import_trade.extractExecutionMarketImpactBps)(signal) ?? executionCostModel?.slippage.marketImpactBps,
+    delayRiskBps: stage === "entry" ? ((0, import_trade.extractExecutionDelayRiskBps)(signal) ?? 0) * (executionCostModel?.slippage.delayRiskMultiplier ?? 1) : null
+  });
+  const getExecutionSlippageLogData = (slippageBreakdown, stage) => ({
+    executionSlippageStage: stage,
+    executionSlippageBps: (0, import_math.round)(slippageBreakdown.effectiveSlippageBps),
+    executionBaseSlippageBps: (0, import_math.round)(slippageBreakdown.baseSlippageBps),
+    executionSpreadBps: (0, import_math.round)(slippageBreakdown.spreadBps),
+    executionSpreadSlippageBps: (0, import_math.round)(slippageBreakdown.spreadSlippageBps),
+    executionMarketImpactBps: (0, import_math.round)(slippageBreakdown.marketImpactBps),
+    executionDelayRiskBps: stage === "entry" ? (0, import_math.round)(slippageBreakdown.delayRiskBps) : null
+  });
+  return {
+    __tradejsTestConnector: true,
+    capabilities: connector.capabilities,
+    universe: connector.universe,
+    accountId: connector.accountId,
+    deploymentId: connector.deploymentId,
+    listInstruments: (query) => connector.listInstruments(query),
+    getFundingRateHistory: connector.getFundingRateHistory ? (request) => connector.getFundingRateHistory(request) : void 0,
+    getTradingFeeRate: connector.getTradingFeeRate ? (symbol) => connector.getTradingFeeRate(symbol) : void 0,
+    getState: async () => state,
+    setState: async (newState) => {
+      state = {
+        ...state,
+        ...newState
+      };
+    },
+    kline: async (options) => connector.kline(options),
+    getResult: async () => {
+      const orderLogId = (0, import_node_crypto.randomUUID)().slice(-12);
+      const fullStat = fastMode ? (0, import_backtest.calculateStatsFull)(positionLog) : null;
       return {
-        stat: {
-          amount,
-          profit: amount - INITIAL_AMOUNT,
+        stat: fullStat ? {
+          ...fullStat,
+          profit: fullStat.netProfit
+        } : {
+          amount: (0, import_math.round)(amount),
+          profit: (0, import_math.round)(amount - import_constants2.INITIAL_BACKTEST_AMOUNT),
           orders: positionLog.length
         },
         orderLogId,
-        inlineOrderLog: [...orderLog],
-        inlinePositionLog: [...positionLog]
+        ...executionCostModel ? { executionCostModel } : {},
+        ...fastMode ? {} : {
+          inlineOrderLog: orderLog,
+          inlinePositionLog: positionLog
+        }
       };
     },
     getPosition: async () => currentPosition || null,
@@ -1084,6 +2664,7 @@ var createTestConnector = (connector, context) => {
       if (!candle || !currentPosition || !currentPosition.qty) {
         return;
       }
+      applyFunding(candle);
       const isLong = currentPosition.direction === "LONG";
       const entryPrice = currentPosition.price;
       const high = candle.high;
@@ -1093,47 +2674,217 @@ var createTestConnector = (connector, context) => {
         const targetPrice = tp.price;
         const reached = isLong ? high >= targetPrice : low <= targetPrice;
         if (reached) {
+          const exitTimestamp = getExitTimestamp(candle);
           const qty = originalQty * tp.rate;
-          const profit = isLong ? (targetPrice - entryPrice) * qty : (entryPrice - targetPrice) * qty;
+          const slippageBreakdown = getExecutionSlippageBreakdown({
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const executionPrice = applyExecutionSlippage({
+            price: targetPrice,
+            direction: currentPosition.direction,
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const grossProfit = isLong ? (executionPrice - entryPrice) * qty : (entryPrice - executionPrice) * qty;
+          const { fee, profit } = getNetProfit({
+            grossProfit,
+            price: executionPrice,
+            qty
+          });
+          recordExitResult({
+            timestamp: exitTimestamp,
+            reason: "take_profit",
+            requestedPrice: targetPrice,
+            executionPrice,
+            qty,
+            grossProfit,
+            fee,
+            slippageBreakdown
+          });
           amount += profit;
           currentPositionProfit += profit;
           currentPosition.qty = parseFloat(
             (currentPosition.qty - qty).toFixed(8)
           );
           logOrder({
-            timestamp: candle.timestamp,
+            timestamp: exitTimestamp,
             qty,
-            price: targetPrice,
+            price: executionPrice,
             profit,
-            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT"
+            fee,
+            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT",
+            ...getExecutionSlippageLogData(slippageBreakdown, "exit")
           });
           tp.done = true;
         }
       }
       takeProfits = takeProfits.filter(({ done }) => !done);
       if (currentPosition && currentPosition.qty <= 0) {
-        clearPosition(candle.timestamp);
+        clearPosition(getExitTimestamp(candle));
       }
     },
     checkSl: async (candle) => {
       if (!stopLossPrice || !currentPosition || !candle) {
         return;
       }
+      applyFunding(candle);
       const isLong = currentPosition.direction === "LONG";
       const hitStop = isLong ? candle.low <= stopLossPrice : candle.high >= stopLossPrice;
       if (hitStop) {
+        const exitTimestamp = getExitTimestamp(candle);
         const qty = currentPosition.qty;
-        const profit = isLong ? (stopLossPrice - currentPosition.price) * qty : (currentPosition.price - stopLossPrice) * qty;
+        const slippageBreakdown = getExecutionSlippageBreakdown({
+          stage: "exit",
+          signal: currentPosition.signal
+        });
+        const executionPrice = applyExecutionSlippage({
+          price: stopLossPrice,
+          direction: currentPosition.direction,
+          stage: "exit",
+          signal: currentPosition.signal
+        });
+        const grossProfit = isLong ? (executionPrice - currentPosition.price) * qty : (currentPosition.price - executionPrice) * qty;
+        const { fee, profit } = getNetProfit({
+          grossProfit,
+          price: executionPrice,
+          qty
+        });
+        recordExitResult({
+          timestamp: exitTimestamp,
+          reason: "stop_loss",
+          requestedPrice: stopLossPrice,
+          executionPrice,
+          qty,
+          grossProfit,
+          fee,
+          slippageBreakdown
+        });
         amount += profit;
         currentPositionProfit += profit;
         logOrder({
-          timestamp: candle.timestamp,
+          timestamp: exitTimestamp,
           qty,
           profit,
-          price: stopLossPrice,
-          type: isLong ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT"
+          price: executionPrice,
+          fee,
+          type: isLong ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT",
+          ...getExecutionSlippageLogData(slippageBreakdown, "exit")
         });
-        clearPosition(candle.timestamp);
+        clearPosition(exitTimestamp);
+      }
+    },
+    checkExits: async (candle) => {
+      if (!candle || !currentPosition) {
+        return;
+      }
+      applyFunding(candle);
+      if (stopLossPrice) {
+        const isLong2 = currentPosition.direction === "LONG";
+        const hitStop = isLong2 ? candle.low <= stopLossPrice : candle.high >= stopLossPrice;
+        if (hitStop) {
+          const exitTimestamp = getExitTimestamp(candle);
+          const qty = currentPosition.qty;
+          const slippageBreakdown = getExecutionSlippageBreakdown({
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const executionPrice = applyExecutionSlippage({
+            price: stopLossPrice,
+            direction: currentPosition.direction,
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const grossProfit = isLong2 ? (executionPrice - currentPosition.price) * qty : (currentPosition.price - executionPrice) * qty;
+          const { fee, profit } = getNetProfit({
+            grossProfit,
+            price: executionPrice,
+            qty
+          });
+          recordExitResult({
+            timestamp: exitTimestamp,
+            reason: "stop_loss",
+            requestedPrice: stopLossPrice,
+            executionPrice,
+            qty,
+            grossProfit,
+            fee,
+            slippageBreakdown
+          });
+          amount += profit;
+          currentPositionProfit += profit;
+          logOrder({
+            timestamp: exitTimestamp,
+            qty,
+            profit,
+            price: executionPrice,
+            fee,
+            type: isLong2 ? "STOP_LOSS_LONG" : "STOP_LOSS_SHORT",
+            ...getExecutionSlippageLogData(slippageBreakdown, "exit")
+          });
+          clearPosition(exitTimestamp);
+        }
+      }
+      if (!currentPosition || !currentPosition.qty) {
+        return;
+      }
+      const isLong = currentPosition.direction === "LONG";
+      const entryPrice = currentPosition.price;
+      const high = candle.high;
+      const low = candle.low;
+      for (const tp of takeProfits) {
+        if (!currentPosition || currentPosition.qty <= 0) break;
+        const targetPrice = tp.price;
+        const reached = isLong ? high >= targetPrice : low <= targetPrice;
+        if (reached) {
+          const exitTimestamp = getExitTimestamp(candle);
+          const qty = originalQty * tp.rate;
+          const slippageBreakdown = getExecutionSlippageBreakdown({
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const executionPrice = applyExecutionSlippage({
+            price: targetPrice,
+            direction: currentPosition.direction,
+            stage: "exit",
+            signal: currentPosition.signal
+          });
+          const grossProfit = isLong ? (executionPrice - entryPrice) * qty : (entryPrice - executionPrice) * qty;
+          const { fee, profit } = getNetProfit({
+            grossProfit,
+            price: executionPrice,
+            qty
+          });
+          recordExitResult({
+            timestamp: exitTimestamp,
+            reason: "take_profit",
+            requestedPrice: targetPrice,
+            executionPrice,
+            qty,
+            grossProfit,
+            fee,
+            slippageBreakdown
+          });
+          amount += profit;
+          currentPositionProfit += profit;
+          currentPosition.qty = parseFloat(
+            (currentPosition.qty - qty).toFixed(8)
+          );
+          logOrder({
+            timestamp: exitTimestamp,
+            qty,
+            price: executionPrice,
+            profit,
+            fee,
+            type: isLong ? "TAKE_PROFIT_LONG" : "TAKE_PROFIT_SHORT",
+            ...getExecutionSlippageLogData(slippageBreakdown, "exit")
+          });
+          tp.done = true;
+        }
+      }
+      takeProfits = takeProfits.filter(({ done }) => !done);
+      if (currentPosition && currentPosition.qty <= 0) {
+        clearPosition(getExitTimestamp(candle));
       }
     },
     placeOrder: async (order) => {
@@ -1141,17 +2892,77 @@ var createTestConnector = (connector, context) => {
         return false;
       }
       const isLong = order.direction === "LONG";
-      currentPosition = { ...order, amount };
+      const entrySlippageBreakdown = getExecutionSlippageBreakdown({
+        stage: "entry",
+        signal: order.signal
+      });
+      const entryPrice = applyExecutionSlippage({
+        price: order.price,
+        direction: order.direction,
+        stage: "entry",
+        signal: order.signal
+      });
+      currentPosition = { ...order, price: entryPrice, amount };
+      currentSignalId = typeof order.signal?.signalId === "string" && order.signal.signalId ? order.signal.signalId : null;
       originalQty = order.qty;
-      const fee = order.price * order.qty * FEE;
-      const profit = fee * -1;
+      const { fee, profit } = getNetProfit({
+        grossProfit: 0,
+        price: entryPrice,
+        qty: order.qty,
+        feeRate: order.isLimit ? makerFeeRate : takerFeeRate
+      });
+      const entrySlippageCost = getSlippageCost({
+        requestedPrice: order.price,
+        executionPrice: entryPrice,
+        direction: order.direction,
+        stage: "entry",
+        qty: order.qty
+      });
       amount += profit;
       currentPositionProfit = profit;
+      currentTradeResult = currentSignalId ? {
+        signalId: currentSignalId,
+        direction: order.direction,
+        qty: order.qty,
+        closedQty: 0,
+        entryTimestamp: order.timestamp,
+        exitTimestamp: null,
+        exitReason: null,
+        requestedEntryPrice: order.price,
+        entryPrice,
+        requestedExitPrice: null,
+        exitPrice: null,
+        grossProfit: 0,
+        netProfit: profit,
+        openFee: fee,
+        closeFee: 0,
+        fundingFee: executionCostModel?.funding.enabled ? 0 : null,
+        totalFee: fee,
+        entrySlippagePrice: entryPrice - order.price,
+        entrySlippageBps: getSlippageBps(order.price, entryPrice),
+        entryBaseSlippageBps: entrySlippageBreakdown.baseSlippageBps,
+        entrySpreadBps: entrySlippageBreakdown.spreadBps,
+        entrySpreadSlippageBps: entrySlippageBreakdown.spreadSlippageBps,
+        entryMarketImpactBps: entrySlippageBreakdown.marketImpactBps,
+        entryDelayRiskBps: entrySlippageBreakdown.delayRiskBps,
+        entrySlippageCost,
+        exitSlippagePrice: null,
+        exitSlippageBps: null,
+        exitBaseSlippageBps: null,
+        exitSpreadBps: null,
+        exitSpreadSlippageBps: null,
+        exitMarketImpactBps: null,
+        exitDelayRiskBps: null,
+        exitSlippageCost: 0,
+        totalSlippageCost: entrySlippageCost
+      } : null;
       logOrder({
         ...order,
+        price: entryPrice,
         profit,
         fee,
-        type: isLong ? "OPEN_LONG" : "OPEN_SHORT"
+        type: isLong ? "OPEN_LONG" : "OPEN_SHORT",
+        ...getExecutionSlippageLogData(entrySlippageBreakdown, "entry")
       });
       return true;
     },
@@ -1178,14 +2989,42 @@ var createTestConnector = (connector, context) => {
         return false;
       }
       const isLong = currentPosition.direction === "LONG";
-      const profit = isLong ? (order.price - currentPosition.price) * currentPosition.qty : (currentPosition.price - order.price) * currentPosition.qty;
+      const slippageBreakdown = getExecutionSlippageBreakdown({
+        stage: "exit",
+        signal: currentPosition.signal
+      });
+      const executionPrice = applyExecutionSlippage({
+        price: order.price,
+        direction: currentPosition.direction,
+        stage: "exit",
+        signal: currentPosition.signal
+      });
+      const grossProfit = isLong ? (executionPrice - currentPosition.price) * currentPosition.qty : (currentPosition.price - executionPrice) * currentPosition.qty;
+      const { fee, profit } = getNetProfit({
+        grossProfit,
+        price: executionPrice,
+        qty: currentPosition.qty
+      });
+      recordExitResult({
+        timestamp: order.timestamp,
+        reason: "exit",
+        requestedPrice: order.price,
+        executionPrice,
+        qty: currentPosition.qty,
+        grossProfit,
+        fee,
+        slippageBreakdown
+      });
       amount += profit;
       currentPositionProfit += profit;
       logOrder({
         ...order,
+        price: executionPrice,
         qty: currentPosition.qty,
         profit,
-        type: isLong ? "CLOSE_LONG" : "CLOSE_SHORT"
+        fee,
+        type: isLong ? "CLOSE_LONG" : "CLOSE_SHORT",
+        ...getExecutionSlippageLogData(slippageBreakdown, "exit")
       });
       clearPosition(order.timestamp);
       return true;
@@ -1196,10 +3035,194 @@ var createTestConnector = (connector, context) => {
   };
 };
 
+// src/executionCosts.ts
+var import_constants3 = require("@tradejs/core/constants");
+var finiteOr = (value, fallback) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+var feeCache = /* @__PURE__ */ new WeakMap();
+var fundingCache = /* @__PURE__ */ new WeakMap();
+var loadTradingFee = async (connector, symbol) => {
+  if (!connector.getTradingFeeRate) return null;
+  let cache = feeCache.get(connector);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    feeCache.set(connector, cache);
+  }
+  const key = symbol.toUpperCase();
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const rate = await connector.getTradingFeeRate(symbol);
+  cache.set(key, rate);
+  return rate;
+};
+var loadFundingRates = (connector, symbol, startTime, endTime) => {
+  if (!connector.getFundingRateHistory) return Promise.resolve([]);
+  let cache = fundingCache.get(connector);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    fundingCache.set(connector, cache);
+  }
+  const key = `${symbol.toUpperCase()}:${startTime}:${endTime}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const pending = connector.getFundingRateHistory({ symbol, startTime, endTime }).catch(() => []);
+  cache.set(key, pending);
+  return pending;
+};
+var resolveExecutionCosts = async (params) => {
+  const { connector, symbol, config, startTime, endTime, instrument } = params;
+  const cacheOnly = config.EXECUTION_COSTS_CACHE_ONLY === true;
+  const hasConfiguredFees = Number.isFinite(Number(config.MAKER_FEE_RATE)) && Number.isFinite(Number(config.TAKER_FEE_RATE));
+  const exchangeFees = !cacheOnly && !hasConfiguredFees && connector.getTradingFeeRate ? await loadTradingFee(connector, symbol).catch(() => null) : null;
+  const makerRate = hasConfiguredFees ? Number(config.MAKER_FEE_RATE) : exchangeFees?.makerRate ?? import_constants3.FEE_PERCENT;
+  const takerRate = hasConfiguredFees ? Number(config.TAKER_FEE_RATE) : exchangeFees?.takerRate ?? import_constants3.FEE_PERCENT;
+  const fundingEnabled = config.FUNDING_ENABLED !== false && !cacheOnly && typeof connector.getFundingRateHistory === "function";
+  const fundingRates = fundingEnabled ? await loadFundingRates(connector, symbol, startTime, endTime) : [];
+  const requestedLeverage = Math.max(1, finiteOr(config.LEVERAGE, 10));
+  const venueMaxLeverage = Number(instrument?.venueMetadata?.maxLeverage);
+  const maxAllowed = Number.isFinite(venueMaxLeverage) ? venueMaxLeverage : null;
+  const effectiveLeverage = maxAllowed == null ? requestedLeverage : Math.min(requestedLeverage, maxAllowed);
+  const feeSource = hasConfiguredFees ? "config" : exchangeFees?.source ?? "fallback";
+  const fundingSource = !fundingEnabled ? cacheOnly ? "fallback" : "disabled" : fundingRates.length ? "historical" : "unavailable";
+  const usesFallback = feeSource === "fallback" || fundingEnabled && fundingSource === "unavailable" || config.SLIPPAGE_BASE_BPS == null && config.SLIPPAGE_SPREAD_MULTIPLIER == null && config.SLIPPAGE_MARKET_IMPACT_BPS == null;
+  return {
+    model: {
+      fees: { makerRate, takerRate, source: feeSource },
+      funding: {
+        enabled: fundingEnabled,
+        source: fundingSource,
+        points: fundingRates.length,
+        fromTimestamp: fundingRates[0]?.timestamp ?? null,
+        toTimestamp: fundingRates.at(-1)?.timestamp ?? null
+      },
+      slippage: {
+        baseBps: finiteOr(config.SLIPPAGE_BASE_BPS, import_constants3.BACKTEST_BASE_SLIPPAGE_BPS),
+        spreadMultiplier: finiteOr(
+          config.SLIPPAGE_SPREAD_MULTIPLIER,
+          import_constants3.BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER
+        ),
+        marketImpactBps: finiteOr(
+          config.SLIPPAGE_MARKET_IMPACT_BPS,
+          import_constants3.BACKTEST_MARKET_IMPACT_BPS
+        ),
+        delayRiskMultiplier: finiteOr(
+          config.SLIPPAGE_DELAY_RISK_MULTIPLIER,
+          import_constants3.BACKTEST_DELAY_RISK_MULTIPLIER
+        ),
+        source: config.SLIPPAGE_BASE_BPS != null || config.SLIPPAGE_SPREAD_MULTIPLIER != null || config.SLIPPAGE_MARKET_IMPACT_BPS != null ? "config" : "fallback"
+      },
+      leverage: {
+        requested: requestedLeverage,
+        effective: effectiveLeverage,
+        maxAllowed
+      },
+      quality: usesFallback ? "fallback" : fundingEnabled && fundingRates.length ? "full" : "partial",
+      capturedAt: Date.now()
+    },
+    fundingRates
+  };
+};
+
 // src/testing.ts
+var isBacktestEntryDelayControlCode = (value) => typeof value === "string" && value.startsWith("BACKTEST_ENTRY_DELAY_");
+var CLOSED_RESULT_FLUSH_INTERVAL = 500;
+var DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS = 6e4;
+var resolvePositiveInt = (value, fallback) => {
+  const parsed = parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var getStrategyCandleTimeoutMs = () => resolvePositiveInt(
+  process.env.BACKTEST_STRATEGY_CANDLE_TIMEOUT_MS,
+  DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS
+);
+var getEffectiveTimeoutMs = (baseTimeoutMs, stageTimeoutMs) => {
+  const base = baseTimeoutMs && baseTimeoutMs > 0 ? Math.trunc(baseTimeoutMs) : null;
+  const stage = stageTimeoutMs && stageTimeoutMs > 0 ? Math.trunc(stageTimeoutMs) : null;
+  if (base == null) return stage;
+  if (stage == null) return base;
+  return Math.min(base, stage);
+};
+var buildCandleByTimestamp = (candles) => new Map(
+  (candles ?? []).filter((candle) => typeof candle?.timestamp === "number").map((candle) => [candle.timestamp, candle])
+);
+var buildBacktestDatasetMetadata = ({
+  backtestRunId,
+  backtestTestKey,
+  chunkId
+}) => {
+  if (!backtestRunId || !backtestTestKey || !chunkId) {
+    return {};
+  }
+  return {
+    backtestRunId,
+    backtestTestKey,
+    backtestChunkId: chunkId
+  };
+};
+var cloneAiPayloadSignal = (signal) => {
+  const cloneValue = (value) => {
+    if (value == null) {
+      return value;
+    }
+    if (typeof structuredClone === "function") {
+      return structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+  };
+  return {
+    ...signal,
+    figures: cloneValue(signal.figures),
+    indicators: cloneValue(signal.indicators),
+    additionalIndicators: cloneValue(signal.additionalIndicators)
+  };
+};
+var buildReplaySignalEvaluationRecord = ({
+  signal,
+  testId,
+  userName,
+  strategyName,
+  symbol,
+  interval,
+  candle
+}) => {
+  if (!signal || typeof signal === "string") {
+    return {
+      evaluationId: `${testId}:${strategyName}:${symbol}:${candle.timestamp}`,
+      userName,
+      strategy: strategyName,
+      symbol,
+      interval,
+      timestamp: candle.timestamp,
+      evaluatedAt: candle.timestamp,
+      status: "skip",
+      reason: typeof signal === "string" && signal.trim() ? signal : "NO_SIGNAL"
+    };
+  }
+  const signalTimestamp = typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : candle.timestamp;
+  return {
+    evaluationId: `${signal.signalId || testId}:${strategyName}:${symbol}:${signalTimestamp}`,
+    userName,
+    strategy: signal.strategy || strategyName,
+    symbol: signal.symbol || symbol,
+    interval: signal.interval || interval,
+    timestamp: signalTimestamp,
+    evaluatedAt: candle.timestamp,
+    status: "signal",
+    reason: signal.orderSkipReason || signal.orderStatus,
+    signalId: signal.signalId,
+    direction: signal.direction,
+    orderStatus: signal.orderStatus,
+    orderSkipReason: signal.orderSkipReason,
+    aiAnalysis: signal.aiAnalysis ?? null,
+    ml: signal.ml
+  };
+};
 var createTestingKlineCacheState = () => ({
   coinKlineCache: /* @__PURE__ */ new Map(),
   btcKlineCache: /* @__PURE__ */ new Map(),
+  ethKlineCache: /* @__PURE__ */ new Map(),
   btcBinanceKlineCache: /* @__PURE__ */ new Map(),
   btcCoinbaseKlineCache: /* @__PURE__ */ new Map(),
   preparedDataCache: /* @__PURE__ */ new Map(),
@@ -1226,11 +3249,15 @@ var getKlineCacheKey = (params) => {
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe,
+    accountId
   } = params;
   return [
     userName,
     connectorName,
+    universe ?? "crypto",
+    accountId ?? "default",
     symbol,
     preloadStart,
     end,
@@ -1248,21 +3275,47 @@ var getPreparedDataCacheKey = (params) => {
     end,
     interval,
     btcBinanceConnectorName,
-    btcCoinbaseConnectorName
+    btcCoinbaseConnectorName,
+    backtestExecutionInterval,
+    universe,
+    accountId
   } = params;
   return [
     userName,
     connectorName,
+    universe ?? "crypto",
+    accountId ?? "default",
     symbol,
     preloadStart,
     start,
     end,
     interval,
+    backtestExecutionInterval,
     btcBinanceConnectorName,
     btcCoinbaseConnectorName
   ].join(":");
 };
-var getConnectorCacheKey = (params) => [params.userName, params.connectorName].join(":");
+var getConnectorCacheKey = (params) => [
+  params.userName,
+  params.connectorName,
+  params.universe ?? "crypto",
+  params.accountId ?? "default"
+].join(":");
+var BACKTEST_INTERVAL = "15";
+var resolveBacktestExecutionInterval = (interval) => {
+  const normalized = String(interval);
+  if (normalized === "15") {
+    return import_constants4.BACKTEST_EXECUTION_INTERVAL;
+  }
+  if (normalized === "60") {
+    return "15";
+  }
+  return null;
+};
+var resolveIntervalMs = (interval) => {
+  const intervalMinutes = Number(interval);
+  return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 6e4 : Number(BACKTEST_INTERVAL) * 6e4;
+};
 var splitCandlesForTesting = (candles, start, preloadStart) => {
   const prevData = [];
   const testData = [];
@@ -1276,9 +3329,56 @@ var splitCandlesForTesting = (candles, start, preloadStart) => {
   }
   return { prevData, testData };
 };
+var getCurrentOpenTimestamp = (interval) => {
+  const intervalMs = resolveIntervalMs(interval);
+  return Math.floor(Date.now() / intervalMs) * intervalMs;
+};
+var filterClosedAlignedCandles = (data, btcData, interval) => {
+  const currentOpenTimestamp = getCurrentOpenTimestamp(interval);
+  const closedData = [];
+  const closedBtcData = [];
+  for (let index = 0; index < data.length; index += 1) {
+    const candle = data[index];
+    const btcCandle = btcData[index];
+    if (!candle || !btcCandle || candle.timestamp >= currentOpenTimestamp) {
+      continue;
+    }
+    closedData.push(candle);
+    closedBtcData.push(btcCandle);
+  }
+  return {
+    data: closedData,
+    btcData: closedBtcData
+  };
+};
+var shouldLoadBacktestExecutionCandles = (interval) => {
+  if (!import_constants4.BACKTEST_LOWER_TIMEFRAME_EXECUTION_ENABLED) {
+    return false;
+  }
+  const executionInterval = resolveBacktestExecutionInterval(interval);
+  if (!executionInterval) {
+    return false;
+  }
+  const primaryMs = resolveIntervalMs(interval);
+  const executionMs = resolveIntervalMs(executionInterval);
+  return executionMs > 0 && executionMs < primaryMs;
+};
 var getCachedConnector = async (params) => {
-  const { state, projectRoot, userName, connectorName } = params;
-  const cacheKey = getConnectorCacheKey({ userName, connectorName });
+  const {
+    state,
+    projectRoot,
+    userName,
+    connectorName,
+    universe,
+    accountId,
+    deploymentId
+  } = params;
+  const cacheKey = getConnectorCacheKey({
+    userName,
+    connectorName,
+    universe,
+    accountId
+  });
   const cachedConnector = state.connectorCache.get(cacheKey);
   if (cachedConnector) {
     return cachedConnector;
@@ -1291,7 +3391,10 @@ var getCachedConnector = async (params) => {
     return void 0;
   }
   const connector = await connectorCreator({
-    userName
+    userName,
+    universe,
+    accountId,
+    deploymentId
   });
   state.connectorCache.set(cacheKey, connector);
   return connector;
@@ -1306,107 +3409,64 @@ var resetTestingKlineCache = (cwd) => {
     getTradejsProjectCwd(normalizedCwd)
   );
 };
-var testing = async ({
-  userName,
-  symbol,
-  options: { start, end },
-  name,
-  testId,
-  testSuiteId,
-  strategyName,
-  strategyConfig,
-  connectorName,
-  ml = false,
-  ai = false,
-  chunkId = "single",
-  timeoutMs
-}) => {
-  if (!start) {
-    throw new Error("no start");
-  }
-  const preloadStart = (0, import_time.getBacktestPreloadStart)(start);
-  const startedAt = Date.now();
-  const formatTimeoutMessage = (stage) => `Test ${name} (${symbol}) timed out after ${timeoutMs}ms during ${stage}`;
-  const getRemainingTimeoutMs = (stage) => {
-    if (!timeoutMs || timeoutMs <= 0) {
-      return null;
-    }
-    const remainingMs = timeoutMs - (Date.now() - startedAt);
-    if (remainingMs <= 0) {
-      throw new Error(formatTimeoutMessage(stage));
-    }
-    return remainingMs;
-  };
-  const throwIfTimedOut = (stage) => {
-    getRemainingTimeoutMs(stage);
-  };
-  const withTimeout = async (stage, promise) => {
-    const remainingMs = getRemainingTimeoutMs(stage);
-    if (remainingMs == null) {
-      return promise;
+var releaseTestingSymbolCache = (params) => {
+  const { cwd, userName, connectorName, symbol } = params;
+  const { state } = getTestingKlineCacheState(cwd);
+  const connectorPrefix = [userName, connectorName].join(":") + ":";
+  for (const cache of [state.coinKlineCache, state.preparedDataCache]) {
+    for (const key of cache.keys()) {
+      if (key.startsWith(connectorPrefix) && key.split(":").includes(symbol)) {
+        cache.delete(key);
+      }
     }
-    return await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error(formatTimeoutMessage(stage)));
-      }, remainingMs);
-      promise.then(
-        (value) => {
-          clearTimeout(timer);
-          resolve(value);
-        },
-        (error) => {
-          clearTimeout(timer);
-          reject(error);
-        }
-      );
-    });
-  };
-  const { projectRoot, state } = getTestingKlineCacheState();
-  const connector = await withTimeout(
-    "connector init",
-    getCachedConnector({
-      state,
-      projectRoot,
-      userName,
-      connectorName
-    })
-  );
+  }
+};
+var prepareTestingData = async (params) => {
+  const {
+    state,
+    projectRoot,
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    start,
+    end,
+    interval,
+    universe = "crypto",
+    accountId,
+    deploymentId
+  } = params;
+  const binanceConnector = universe === "crypto" ? await getCachedConnector({
+    state,
+    projectRoot,
+    userName,
+    connectorName: BUILTIN_CONNECTOR_NAMES.Binance
+  }) : void 0;
+  const coinbaseConnector = universe === "crypto" ? await getCachedConnector({
+    state,
+    projectRoot,
+    userName,
+    connectorName: BUILTIN_CONNECTOR_NAMES.Coinbase
+  }) : void 0;
+  const cacheOnly = true;
+  const connector = await getCachedConnector({
+    state,
+    projectRoot,
+    userName,
+    connectorName,
+    universe,
+    accountId,
+    deploymentId
+  });
   if (!connector) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
-  const strategyCreator = await withTimeout(
-    "strategy lookup",
-    getStrategyCreator(strategyName, projectRoot)
-  );
-  if (!strategyCreator) {
-    throw new Error(`Unknown strategy: ${strategyName}`);
+  if (!binanceConnector || !coinbaseConnector) {
+    import_logger7.logger.warn(
+      "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
+      connectorName
+    );
   }
-  const binanceConnector = await withTimeout(
-    "binance connector init",
-    getCachedConnector({
-      state,
-      projectRoot,
-      userName,
-      connectorName: BUILTIN_CONNECTOR_NAMES.Binance
-    })
-  );
-  const coinbaseConnector = await withTimeout(
-    "coinbase connector init",
-    getCachedConnector({
-      state,
-      projectRoot,
-      userName,
-      connectorName: BUILTIN_CONNECTOR_NAMES.Coinbase
-    })
-  );
-  if (!binanceConnector || !coinbaseConnector) {
-    import_logger5.logger.warn(
-      "Binance/Coinbase connectors are unavailable. Reusing %s for BTC references.",
-      connectorName
-    );
-  }
-  const interval = "15";
-  const cacheOnly = true;
   const coinCacheKey = getKlineCacheKey({
     userName,
     connectorName,
@@ -1414,7 +3474,9 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe,
+    accountId
   });
   const btcCacheKey = getKlineCacheKey({
     userName,
@@ -1423,12 +3485,23 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe,
+    accountId
+  });
+  const ethCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol: "ETHUSDT",
+    preloadStart,
+    end,
+    interval,
+    cacheOnly,
+    universe,
+    accountId
   });
   const btcBinanceConnectorName = binanceConnector ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName;
   const btcCoinbaseConnectorName = coinbaseConnector ? BUILTIN_CONNECTOR_NAMES.Coinbase : connectorName;
-  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
-  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
   const btcBinanceCacheKey = getKlineCacheKey({
     userName,
     connectorName: btcBinanceConnectorName,
@@ -1436,7 +3509,8 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe: "crypto"
   });
   const btcCoinbaseCacheKey = getKlineCacheKey({
     userName,
@@ -1445,10 +3519,41 @@ var testing = async ({
     preloadStart,
     end,
     interval,
-    cacheOnly
+    cacheOnly,
+    universe: "crypto"
   });
+  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
+  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
+  const cachedEthData = state.ethKlineCache.get(ethCacheKey);
   const cachedBtcBinanceData = state.btcBinanceKlineCache.get(btcBinanceCacheKey);
   const cachedBtcCoinbaseData = state.btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
+  const backtestExecutionInterval = resolveBacktestExecutionInterval(interval);
+  const backtestExecutionCacheInterval = backtestExecutionInterval ?? interval;
+  const shouldLoadExecutionCandles = backtestExecutionInterval != null && shouldLoadBacktestExecutionCandles(interval);
+  const executionCoinCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol,
+    preloadStart,
+    end,
+    interval: backtestExecutionCacheInterval,
+    cacheOnly,
+    universe,
+    accountId
+  });
+  const executionBtcCacheKey = getKlineCacheKey({
+    userName,
+    connectorName,
+    symbol: "BTCUSDT",
+    preloadStart,
+    end,
+    interval: backtestExecutionCacheInterval,
+    cacheOnly,
+    universe,
+    accountId
+  });
+  const cachedExecutionCoinData = shouldLoadExecutionCandles ? state.coinKlineCache.get(executionCoinCacheKey) : void 0;
+  const cachedExecutionBtcData = shouldLoadExecutionCandles ? state.btcKlineCache.get(executionBtcCacheKey) : void 0;
   const preparedDataCacheKey = getPreparedDataCacheKey({
     userName,
     connectorName,
@@ -1457,118 +3562,407 @@ var testing = async ({
     start,
     end,
     interval,
+    backtestExecutionInterval: backtestExecutionCacheInterval,
     btcBinanceConnectorName,
-    btcCoinbaseConnectorName
+    btcCoinbaseConnectorName,
+    universe,
+    accountId
   });
-  let preparedData = state.preparedDataCache.get(preparedDataCacheKey);
-  if (!preparedData) {
-    const [data, btcData, btcBinanceData, btcCoinbaseData] = await withTimeout(
-      "kline preload",
-      Promise.all([
-        cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
-          symbol,
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        }),
-        cachedBtcData ? Promise.resolve(cachedBtcData) : connector.kline({
-          symbol: "BTCUSDT",
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        }),
-        cachedBtcBinanceData ? Promise.resolve(cachedBtcBinanceData) : (binanceConnector ?? connector).kline({
-          symbol: "BTCUSDT",
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        }),
-        cachedBtcCoinbaseData ? Promise.resolve(cachedBtcCoinbaseData) : (coinbaseConnector ?? connector).kline({
-          symbol: "BTCUSDT",
-          start: preloadStart,
-          end,
-          interval,
-          silent: true,
-          cacheOnly
-        })
-      ])
-    );
-    if (!cachedCoinData) {
-      state.coinKlineCache.set(coinCacheKey, data);
-    }
-    if (!cachedBtcData) {
-      state.btcKlineCache.set(btcCacheKey, btcData);
+  const cachedPreparedData = state.preparedDataCache.get(preparedDataCacheKey);
+  if (cachedPreparedData) {
+    return cachedPreparedData;
+  }
+  const btcDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedBtcData ? Promise.resolve(cachedBtcData) : connector.kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const ethDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedEthData ? Promise.resolve(cachedEthData) : connector.kline({
+    symbol: "ETHUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const btcBinanceDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedBtcBinanceData ? Promise.resolve(cachedBtcBinanceData) : btcBinanceCacheKey === btcCacheKey ? btcDataPromise : (binanceConnector ?? connector).kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const btcCoinbaseDataPromise = universe === "tradfi" ? Promise.resolve([]) : cachedBtcCoinbaseData ? Promise.resolve(cachedBtcCoinbaseData) : btcCoinbaseCacheKey === btcCacheKey ? btcDataPromise : (coinbaseConnector ?? connector).kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval,
+    silent: true,
+    cacheOnly
+  });
+  const executionDataPromise = !shouldLoadExecutionCandles ? Promise.resolve([]) : cachedExecutionCoinData ? Promise.resolve(cachedExecutionCoinData) : connector.kline({
+    symbol,
+    start: preloadStart,
+    end,
+    interval: backtestExecutionInterval,
+    silent: true,
+    cacheOnly
+  });
+  const executionBtcDataPromise = universe === "tradfi" || !shouldLoadExecutionCandles ? Promise.resolve([]) : cachedExecutionBtcData ? Promise.resolve(cachedExecutionBtcData) : connector.kline({
+    symbol: "BTCUSDT",
+    start: preloadStart,
+    end,
+    interval: backtestExecutionInterval,
+    silent: true,
+    cacheOnly
+  });
+  const [
+    dataRaw,
+    btcDataRaw,
+    ethDataRaw,
+    btcBinanceDataRaw,
+    btcCoinbaseDataRaw,
+    executionDataRaw,
+    executionBtcDataRaw
+  ] = await Promise.all([
+    cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
+      symbol,
+      start: preloadStart,
+      end,
+      interval,
+      silent: true,
+      cacheOnly
+    }),
+    btcDataPromise,
+    ethDataPromise,
+    btcBinanceDataPromise,
+    btcCoinbaseDataPromise,
+    executionDataPromise,
+    executionBtcDataPromise
+  ]);
+  if (!cachedCoinData) {
+    state.coinKlineCache.set(coinCacheKey, dataRaw);
+  }
+  if (!cachedBtcData) {
+    state.btcKlineCache.set(btcCacheKey, btcDataRaw);
+  }
+  if (!cachedEthData) {
+    state.ethKlineCache.set(ethCacheKey, ethDataRaw);
+  }
+  if (!cachedBtcBinanceData) {
+    state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceDataRaw);
+  }
+  if (!cachedBtcCoinbaseData) {
+    state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseDataRaw);
+  }
+  if (shouldLoadExecutionCandles && !cachedExecutionCoinData) {
+    state.coinKlineCache.set(executionCoinCacheKey, executionDataRaw);
+  }
+  if (shouldLoadExecutionCandles && !cachedExecutionBtcData) {
+    state.btcKlineCache.set(executionBtcCacheKey, executionBtcDataRaw);
+  }
+  const aligned = universe === "tradfi" ? { alignedCoinCandles: dataRaw, alignedBtcCandles: dataRaw } : (0, import_indicators3.alignSortedCandlesByTimestamp)(dataRaw, btcDataRaw);
+  const { data, btcData } = filterClosedAlignedCandles(
+    aligned.alignedCoinCandles,
+    aligned.alignedBtcCandles,
+    interval
+  );
+  const btcBinanceData = universe === "tradfi" ? [] : (0, import_indicators3.alignSortedCandlesByTimestamp)(data, btcBinanceDataRaw).alignedBtcCandles;
+  const btcCoinbaseData = universe === "tradfi" ? [] : (0, import_indicators3.alignSortedCandlesByTimestamp)(data, btcCoinbaseDataRaw).alignedBtcCandles;
+  const ethData = universe === "tradfi" ? [] : (0, import_indicators3.alignSortedCandlesByTimestamp)(data, ethDataRaw).alignedBtcCandles;
+  const alignedExecution = shouldLoadExecutionCandles ? universe === "tradfi" ? {
+    alignedCoinCandles: executionDataRaw,
+    alignedBtcCandles: executionDataRaw
+  } : (0, import_indicators3.alignSortedCandlesByTimestamp)(executionDataRaw, executionBtcDataRaw) : { alignedCoinCandles: [], alignedBtcCandles: [] };
+  const { data: backtestExecutionData, btcData: backtestExecutionBtcData } = filterClosedAlignedCandles(
+    alignedExecution.alignedCoinCandles,
+    alignedExecution.alignedBtcCandles,
+    backtestExecutionCacheInterval
+  );
+  const backtestExecutionDataByTimestamp = buildCandleByTimestamp(
+    backtestExecutionData
+  );
+  const backtestExecutionBtcDataByTimestamp = buildCandleByTimestamp(
+    backtestExecutionBtcData
+  );
+  const { prevData, testData } = splitCandlesForTesting(
+    data,
+    start,
+    preloadStart
+  );
+  const { prevData: btcPrevData, testData: btcTestData } = splitCandlesForTesting(btcData, start, preloadStart);
+  const { prevData: ethPrevData, testData: ethTestData } = splitCandlesForTesting(ethData, start, preloadStart);
+  const preparedData = {
+    data,
+    btcData,
+    ethData,
+    prevData,
+    btcPrevData,
+    ethPrevData,
+    testData,
+    btcTestData,
+    ethTestData,
+    btcBinanceData,
+    btcCoinbaseData,
+    backtestExecutionInterval: backtestExecutionCacheInterval,
+    backtestExecutionData,
+    backtestExecutionBtcData,
+    backtestExecutionDataByTimestamp,
+    backtestExecutionBtcDataByTimestamp
+  };
+  state.preparedDataCache.set(preparedDataCacheKey, preparedData);
+  return preparedData;
+};
+var canRunTestsInSharedCandleLoop = (tests) => {
+  if (tests.length <= 1) {
+    return false;
+  }
+  const first = tests[0];
+  const firstStart = first.options?.start;
+  const firstEnd = first.options?.end;
+  return tests.every(
+    (test) => test.userName === first.userName && test.connectorName === first.connectorName && (test.universe ?? "crypto") === (first.universe ?? "crypto") && (test.accountId ?? null) === (first.accountId ?? null) && (test.deploymentId ?? null) === (first.deploymentId ?? null) && test.symbol === first.symbol && test.strategyName === first.strategyName && test.options?.start === firstStart && test.options?.end === firstEnd && Boolean(test.ml) === Boolean(first.ml) && Boolean(test.ai) === Boolean(first.ai) && Boolean(test.fast) === Boolean(first.fast) && Boolean(test.collectReplaySignalEvaluations) === Boolean(first.collectReplaySignalEvaluations) && (test.interval ?? BACKTEST_INTERVAL) === (first.interval ?? BACKTEST_INTERVAL) && (test.timeoutMs ?? null) === (first.timeoutMs ?? null)
+  );
+};
+var testing = async ({
+  userName,
+  symbol,
+  options: { start, end },
+  name,
+  testId,
+  testSuiteId,
+  configId,
+  strategyName,
+  strategyConfig,
+  connectorName,
+  universe = "crypto",
+  assetClass,
+  instrument: requestedInstrument,
+  accountId,
+  deploymentId,
+  policyProfileId,
+  interval = BACKTEST_INTERVAL,
+  ml = false,
+  ai = false,
+  fast = false,
+  collectReplaySignalEvaluations = false,
+  chunkId = "single",
+  backtestRunId,
+  backtestTestKey,
+  timeoutMs
+}) => {
+  if (!start) {
+    throw new Error("no start");
+  }
+  const preloadStart = (0, import_time.getBacktestPreloadStart)(start);
+  const startedAt = Date.now();
+  let activeStageStartedAt = startedAt;
+  let lastProgressSentAt = 0;
+  let lastProgressSignature = "";
+  let currentCandleIndex = 0;
+  let totalCandles = 0;
+  const strategyCandleTimeoutMs = getStrategyCandleTimeoutMs();
+  const formatTimeoutMessage = (stage, stageTimeoutMs) => `Test ${name} (${symbol}) timed out after ${stageTimeoutMs}ms during ${stage}`;
+  const emitProgress = (stage, options = {}) => {
+    const now = Date.now();
+    const candleIndex = typeof options.candleIndex === "number" ? options.candleIndex : currentCandleIndex;
+    const candleTotal = typeof options.candleTotal === "number" ? options.candleTotal : totalCandles;
+    const signature = [
+      stage,
+      candleIndex,
+      candleTotal,
+      Math.floor((now - activeStageStartedAt) / 5e3)
+    ].join(":");
+    if (!options.force) {
+      if (signature === lastProgressSignature) {
+        return;
+      }
+      if (now - lastProgressSentAt < 4e3) {
+        return;
+      }
     }
-    if (!cachedBtcBinanceData) {
-      state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+    lastProgressSentAt = now;
+    lastProgressSignature = signature;
+    process.send?.({
+      progress: true,
+      testName: name,
+      symbol,
+      strategyName,
+      stage,
+      candleIndex,
+      candleTotal,
+      elapsedMs: now - startedAt,
+      stageElapsedMs: now - activeStageStartedAt
+    });
+  };
+  const getStageTimeoutMs = () => {
+    if (!timeoutMs || timeoutMs <= 0) {
+      return null;
     }
-    if (!cachedBtcCoinbaseData) {
-      state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+    return timeoutMs;
+  };
+  const throwIfTimedOut = (stage) => {
+    if (getStageTimeoutMs() == null) {
+      return;
     }
-    const { prevData: prevDataRaw, testData: testDataRaw } = splitCandlesForTesting(data, start, preloadStart);
-    const { prevData: btcPrevDataRaw, testData: btcTestDataRaw } = splitCandlesForTesting(btcData, start, preloadStart);
-    const { prevData: btcBinancePrevDataRaw } = splitCandlesForTesting(
-      btcBinanceData,
-      start,
-      preloadStart
-    );
-    const { prevData: btcCoinbasePrevDataRaw } = splitCandlesForTesting(
-      btcCoinbaseData,
-      start,
-      preloadStart
+    emitProgress(stage);
+  };
+  const withTimeout = async (stage, promise, stageTimeoutOverrideMs = null) => {
+    const stageTimeoutMs = getEffectiveTimeoutMs(
+      getStageTimeoutMs() ?? void 0,
+      stageTimeoutOverrideMs
     );
-    const { alignedCoinCandles: prevData2, alignedBtcCandles: btcPrevData2 } = (0, import_indicators3.alignSortedCandlesByTimestamp)(prevDataRaw, btcPrevDataRaw);
-    const { alignedCoinCandles: testData2, alignedBtcCandles: btcTestData2 } = (0, import_indicators3.alignSortedCandlesByTimestamp)(testDataRaw, btcTestDataRaw);
-    const { alignedBtcCandles: btcBinancePrevData2 } = (0, import_indicators3.alignSortedCandlesByTimestamp)(prevDataRaw, btcBinancePrevDataRaw);
-    const { alignedBtcCandles: btcCoinbasePrevData2 } = (0, import_indicators3.alignSortedCandlesByTimestamp)(prevDataRaw, btcCoinbasePrevDataRaw);
-    preparedData = {
-      prevData: prevData2,
-      btcPrevData: btcPrevData2,
-      testData: testData2,
-      btcTestData: btcTestData2,
-      btcBinancePrevData: btcBinancePrevData2,
-      btcCoinbasePrevData: btcCoinbasePrevData2
-    };
-    state.preparedDataCache.set(preparedDataCacheKey, preparedData);
+    if (stageTimeoutMs == null) {
+      return promise;
+    }
+    activeStageStartedAt = Date.now();
+    emitProgress(stage, { force: true });
+    return await new Promise((resolve, reject) => {
+      const heartbeat = setInterval(() => {
+        emitProgress(stage);
+      }, 5e3);
+      const timer = setTimeout(() => {
+        clearInterval(heartbeat);
+        reject(new Error(formatTimeoutMessage(stage, stageTimeoutMs)));
+      }, stageTimeoutMs);
+      promise.then(
+        (value) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  };
+  const runStage = (stage, fn) => {
+    if (getStageTimeoutMs() == null) {
+      return fn();
+    }
+    return withTimeout(stage, fn());
+  };
+  const runStrategyCandleStage = (stage, fn) => withTimeout(stage, fn(), strategyCandleTimeoutMs);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connector = await withTimeout(
+    "connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
+  if (!connector) {
+    throw new Error(`Unknown connector: ${connectorName}`);
+  }
+  const strategyCreator = await withTimeout(
+    "strategy lookup",
+    getStrategyCreator(strategyName, projectRoot)
+  );
+  if (!strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
   }
+  const preparedData = await withTimeout(
+    "kline preload",
+    prepareTestingData({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      symbol,
+      preloadStart,
+      start,
+      end,
+      interval,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
   if (!preparedData) {
     throw new Error("Prepared backtest data not available");
   }
   const {
     prevData,
     btcPrevData,
+    ethPrevData,
+    ethTestData,
     testData,
     btcTestData,
-    btcBinancePrevData,
-    btcCoinbasePrevData
+    btcBinanceData,
+    btcCoinbaseData,
+    backtestExecutionInterval,
+    backtestExecutionData,
+    backtestExecutionBtcData,
+    backtestExecutionDataByTimestamp,
+    backtestExecutionBtcDataByTimestamp
   } = preparedData;
+  const runtimePrevData = prevData.slice();
+  const runtimeBtcPrevData = btcPrevData.slice();
+  const runtimeEthData = [...ethPrevData, ...ethTestData];
+  totalCandles = testData.length;
+  const instrument = requestedInstrument;
+  const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
+    connector,
+    symbol,
+    config: strategyConfig,
+    startTime: start,
+    endTime: end,
+    instrument
+  });
   const testConnector = createTestConnector(connector, {
     userName,
     mlEnabled: ml,
-    aiEnabled: ai
+    aiEnabled: ai,
+    fastMode: fast,
+    executionCostModel,
+    fundingRates
   });
   const strategy = await withTimeout(
     "strategy init",
     strategyCreator({
       userName,
-      config: strategyConfig,
+      connectorName,
+      universe,
+      assetClass: assetClass ?? instrument?.assetClass,
+      instrument,
+      accountId,
+      deploymentId,
+      policyProfileId,
+      config: {
+        ...strategyConfig,
+        INTERVAL: interval
+      },
       symbol,
-      data: prevData,
-      btcData: btcPrevData,
-      btcBinanceData: btcBinancePrevData,
-      btcCoinbaseData: btcCoinbasePrevData,
+      data: runtimePrevData,
+      btcData: runtimeBtcPrevData,
+      ethData: runtimeEthData,
+      btcBinanceData,
+      btcCoinbaseData,
+      backtestExecutionMarketData: {
+        interval: backtestExecutionInterval,
+        data: backtestExecutionData,
+        btcData: backtestExecutionBtcData,
+        dataByTimestamp: backtestExecutionDataByTimestamp,
+        btcDataByTimestamp: backtestExecutionBtcDataByTimestamp
+      },
       connector: testConnector
     })
   );
   const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
   const pendingAiRowBySignalId = /* @__PURE__ */ new Map();
-  const replaySignalEvaluations = [];
+  const replaySignalEvaluations = collectReplaySignalEvaluations ? [] : null;
   const flushClosedResultsBatch = async () => {
     if (!ml && !ai) return;
     const batch = await testConnector.drainMlResultsBatch();
@@ -1580,7 +3974,14 @@ var testing = async ({
         const fullRow = (0, import_ml2.buildMlTrainingRow)(payload, {
           profit: resultRecord.profit
         });
-        const row = (0, import_ml2.trimMlTrainingRowWindows)(fullRow, 5);
+        const row = {
+          ...(0, import_ml2.trimMlTrainingRowWindows)(fullRow, 5),
+          ...buildBacktestDatasetMetadata({
+            backtestRunId,
+            backtestTestKey,
+            chunkId
+          })
+        };
         await (0, import_ml2.appendMlDatasetRow)({
           strategyName,
           chunkId,
@@ -1590,62 +3991,54 @@ var testing = async ({
       const aiRowBase = pendingAiRowBySignalId.get(resultRecord.signalId);
       if (aiRowBase) {
         pendingAiRowBySignalId.delete(resultRecord.signalId);
+        const { signal: aiSignal, ...rowBase } = aiRowBase;
         await (0, import_ai2.appendAiDatasetRow)({
           strategyName,
           chunkId,
           row: {
-            ...aiRowBase,
-            profit: resultRecord.profit
+            ...rowBase,
+            payload: buildAiPayload(aiSignal),
+            profit: resultRecord.profit,
+            tradeResult: resultRecord.tradeResult
           }
         });
       }
     }
   };
-  for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
-    if (candleIndex % 25 === 0) {
-      throwIfTimedOut("candle loop");
+  const processSignal = async (signal, candle) => {
+    if (isBacktestEntryDelayControlCode(signal)) {
+      return;
     }
-    const candle = testData[candleIndex];
-    const btcCandle = btcTestData[candleIndex];
-    await withTimeout("stop-loss check", testConnector.checkSl(candle));
-    await withTimeout("take-profit check", testConnector.checkTp(candle));
-    const signal = await withTimeout(
-      "strategy signal",
-      strategy(candle, btcCandle)
-    );
-    if (!signal || typeof signal === "string") {
-      replaySignalEvaluations.push({
-        evaluationId: `${testId}:${strategyName}:${symbol}:${candle.timestamp}`,
-        userName,
-        strategy: strategyName,
-        symbol,
-        interval,
-        timestamp: candle.timestamp,
-        evaluatedAt: candle.timestamp,
-        status: "skip",
-        reason: typeof signal === "string" && signal.trim() ? signal : "NO_SIGNAL"
-      });
-    } else {
-      replaySignalEvaluations.push({
-        evaluationId: `${signal.signalId || testId}:${strategyName}:${symbol}:${signal.timestamp || candle.timestamp}`,
-        userName,
-        strategy: signal.strategy || strategyName,
-        symbol: signal.symbol || symbol,
-        interval: signal.interval || interval,
-        timestamp: typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : candle.timestamp,
-        evaluatedAt: candle.timestamp,
-        status: "signal",
-        reason: signal.orderSkipReason || signal.orderStatus,
-        signalId: signal.signalId,
-        direction: signal.direction,
-        orderStatus: signal.orderStatus,
-        orderSkipReason: signal.orderSkipReason,
-        aiAnalysis: signal.aiAnalysis ?? null,
-        ml: signal.ml
-      });
+    if (replaySignalEvaluations) {
+      replaySignalEvaluations.push(
+        buildReplaySignalEvaluationRecord({
+          signal,
+          testId,
+          userName,
+          strategyName,
+          symbol,
+          interval,
+          candle
+        })
+      );
     }
     const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (ml || ai);
     if (shouldCapturePayload) {
+      await withTimeout(
+        "binance market context",
+        enrichSignalWithBinanceMarketContext({
+          signal,
+          env: "BACKTEST"
+        })
+      );
+      await withTimeout(
+        "coinmarketcap context",
+        enrichSignalWithCoinMarketCapContext({
+          signal,
+          env: "BACKTEST",
+          enabled: Boolean(ml || ai)
+        })
+      );
       await withTimeout(
         "derivatives context",
         enrichSignalWithDerivativesContext({
@@ -1662,6 +4055,7 @@ var testing = async ({
           testId,
           testSuiteId,
           testName: name,
+          configId,
           symbol,
           strategyName,
           strategyConfig,
@@ -1677,25 +4071,517 @@ var testing = async ({
         symbol: signal.symbol || symbol,
         direction: signal.direction,
         timestamp: signal.timestamp,
-        payload: buildAiPayload(signal),
+        signal: cloneAiPayloadSignal(signal),
         testId,
         testSuiteId,
         testName: name,
-        connectorName
+        configId,
+        connectorName,
+        ...buildBacktestDatasetMetadata({
+          backtestRunId,
+          backtestTestKey,
+          chunkId
+        })
       });
     }
+  };
+  for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
+    if (candleIndex % 25 === 0) {
+      throwIfTimedOut("candle loop");
+    }
+    currentCandleIndex = candleIndex + 1;
+    emitProgress("candle loop", {
+      force: candleIndex === 0 || currentCandleIndex === totalCandles
+    });
+    const candle = testData[candleIndex];
+    const btcCandle = btcTestData[candleIndex];
+    const delayedSignal = await runStrategyCandleStage(
+      "delayed entry",
+      async () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle)
+    );
+    if (delayedSignal && typeof delayedSignal !== "string") {
+      await processSignal(delayedSignal, candle);
+    }
+    await runStage("exit checks", () => testConnector.checkExits(candle));
+    const signal = await runStrategyCandleStage(
+      "strategy signal",
+      () => strategy(candle, btcCandle)
+    );
+    await processSignal(signal, candle);
+    if ((candleIndex + 1) % CLOSED_RESULT_FLUSH_INTERVAL === 0) {
+      await withTimeout("flush closed results", flushClosedResultsBatch());
+    }
   }
   await withTimeout("flush closed results", flushClosedResultsBatch());
   const result = await withTimeout("collect result", testConnector.getResult());
-  return {
+  return replaySignalEvaluations ? {
     ...result,
     inlineReplaySignalEvaluations: replaySignalEvaluations
+  } : result;
+};
+var testingGroupInSharedCandleLoop = async (tests) => {
+  if (!canRunTestsInSharedCandleLoop(tests)) {
+    const results = [];
+    for (const test of tests) {
+      const result = await testing(test);
+      if (result) {
+        results.push({ test, result });
+      }
+    }
+    return results;
+  }
+  const first = tests[0];
+  const {
+    userName,
+    symbol,
+    options: { start, end },
+    strategyName,
+    connectorName,
+    universe = "crypto",
+    accountId,
+    deploymentId,
+    interval = BACKTEST_INTERVAL,
+    ml = false,
+    ai = false,
+    fast = false,
+    collectReplaySignalEvaluations = false,
+    chunkId = "single",
+    timeoutMs
+  } = first;
+  if (!start) {
+    throw new Error("no start");
+  }
+  const preloadStart = (0, import_time.getBacktestPreloadStart)(start);
+  const startedAt = Date.now();
+  let activeStageStartedAt = startedAt;
+  let lastProgressSentAt = 0;
+  let lastProgressSignature = "";
+  let currentCandleIndex = 0;
+  let totalCandles = 0;
+  const strategyCandleTimeoutMs = getStrategyCandleTimeoutMs();
+  const formatTimeoutMessage = (stage, stageTimeoutMs) => `Test group ${strategyName}/${symbol} timed out after ${stageTimeoutMs}ms during ${stage}`;
+  const emitProgress = (stage, options = {}) => {
+    const now = Date.now();
+    const candleIndex = typeof options.candleIndex === "number" ? options.candleIndex : currentCandleIndex;
+    const candleTotal = typeof options.candleTotal === "number" ? options.candleTotal : totalCandles;
+    const signature = [
+      stage,
+      candleIndex,
+      candleTotal,
+      Math.floor((now - activeStageStartedAt) / 5e3)
+    ].join(":");
+    if (!options.force) {
+      if (signature === lastProgressSignature) {
+        return;
+      }
+      if (now - lastProgressSentAt < 4e3) {
+        return;
+      }
+    }
+    lastProgressSentAt = now;
+    lastProgressSignature = signature;
+    process.send?.({
+      progress: true,
+      testName: first.name,
+      symbol,
+      strategyName,
+      stage,
+      candleIndex,
+      candleTotal,
+      elapsedMs: now - startedAt,
+      stageElapsedMs: now - activeStageStartedAt
+    });
+  };
+  const getStageTimeoutMs = () => {
+    if (!timeoutMs || timeoutMs <= 0) {
+      return null;
+    }
+    return timeoutMs;
+  };
+  const throwIfTimedOut = (stage) => {
+    if (getStageTimeoutMs() == null) {
+      return;
+    }
+    emitProgress(stage);
+  };
+  const withTimeout = async (stage, promise, stageTimeoutOverrideMs = null) => {
+    const stageTimeoutMs = getEffectiveTimeoutMs(
+      getStageTimeoutMs() ?? void 0,
+      stageTimeoutOverrideMs
+    );
+    if (stageTimeoutMs == null) {
+      return promise;
+    }
+    activeStageStartedAt = Date.now();
+    emitProgress(stage, { force: true });
+    return await new Promise((resolve, reject) => {
+      const heartbeat = setInterval(() => {
+        emitProgress(stage);
+      }, 5e3);
+      const timer = setTimeout(() => {
+        clearInterval(heartbeat);
+        reject(new Error(formatTimeoutMessage(stage, stageTimeoutMs)));
+      }, stageTimeoutMs);
+      promise.then(
+        (value) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          resolve(value);
+        },
+        (error) => {
+          clearInterval(heartbeat);
+          clearTimeout(timer);
+          reject(error);
+        }
+      );
+    });
+  };
+  const runStage = (stage, fn) => {
+    if (getStageTimeoutMs() == null) {
+      return fn();
+    }
+    return withTimeout(stage, fn());
   };
+  const runStrategyCandleStage = (stage, fn) => withTimeout(stage, fn(), strategyCandleTimeoutMs);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connector = await withTimeout(
+    "connector init",
+    getCachedConnector({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
+  if (!connector) {
+    throw new Error(`Unknown connector: ${connectorName}`);
+  }
+  const strategyCreator = await withTimeout(
+    "strategy lookup",
+    getStrategyCreator(strategyName, projectRoot)
+  );
+  if (!strategyCreator) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
+  }
+  const preparedData = await withTimeout(
+    "kline preload",
+    prepareTestingData({
+      state,
+      projectRoot,
+      userName,
+      connectorName,
+      symbol,
+      preloadStart,
+      start,
+      end,
+      interval,
+      universe,
+      accountId,
+      deploymentId
+    })
+  );
+  if (!preparedData) {
+    throw new Error("Prepared backtest data not available");
+  }
+  const {
+    prevData,
+    btcPrevData,
+    ethPrevData,
+    ethTestData,
+    testData,
+    btcTestData,
+    btcBinanceData,
+    btcCoinbaseData,
+    backtestExecutionInterval,
+    backtestExecutionData,
+    backtestExecutionBtcData,
+    backtestExecutionDataByTimestamp,
+    backtestExecutionBtcDataByTimestamp
+  } = preparedData;
+  totalCandles = testData.length;
+  const sharedIndicatorsReplayKey = [
+    "shared",
+    userName,
+    connectorName,
+    strategyName,
+    symbol,
+    interval,
+    start,
+    end,
+    chunkId
+  ].join(":");
+  const runners = [];
+  try {
+    for (const test of tests) {
+      const instrument = test.instrument;
+      const { model: executionCostModel, fundingRates } = await resolveExecutionCosts({
+        connector,
+        symbol: test.symbol,
+        config: test.strategyConfig,
+        startTime: start,
+        endTime: end,
+        instrument
+      });
+      const testConnector = createTestConnector(connector, {
+        userName: test.userName,
+        mlEnabled: test.ml,
+        aiEnabled: test.ai,
+        fastMode: test.fast,
+        executionCostModel,
+        fundingRates
+      });
+      const strategy = await withTimeout(
+        "strategy init",
+        strategyCreator({
+          userName: test.userName,
+          connectorName: test.connectorName,
+          universe: test.universe ?? universe,
+          assetClass: test.assetClass ?? instrument?.assetClass,
+          instrument,
+          accountId: test.accountId ?? accountId,
+          deploymentId: test.deploymentId ?? deploymentId,
+          policyProfileId: test.policyProfileId,
+          config: {
+            ...test.strategyConfig,
+            INTERVAL: test.interval ?? interval
+          },
+          symbol: test.symbol,
+          data: prevData.slice(),
+          btcData: btcPrevData.slice(),
+          ethData: [...ethPrevData, ...ethTestData],
+          btcBinanceData,
+          btcCoinbaseData,
+          backtestExecutionMarketData: {
+            interval: backtestExecutionInterval,
+            data: backtestExecutionData,
+            btcData: backtestExecutionBtcData,
+            dataByTimestamp: backtestExecutionDataByTimestamp,
+            btcDataByTimestamp: backtestExecutionBtcDataByTimestamp
+          },
+          connector: testConnector,
+          sharedIndicatorsReplayKey
+        })
+      );
+      runners.push({
+        test,
+        strategy,
+        testConnector,
+        pendingMlPayloadBySignalId: /* @__PURE__ */ new Map(),
+        pendingAiRowBySignalId: /* @__PURE__ */ new Map(),
+        replaySignalEvaluations: collectReplaySignalEvaluations ? [] : null
+      });
+    }
+    const flushClosedResultsBatch = async (runner) => {
+      if (!runner.test.ml && !runner.test.ai) return;
+      const batch = await runner.testConnector.drainMlResultsBatch();
+      if (!batch.length) return;
+      for (const resultRecord of batch) {
+        const payload = runner.pendingMlPayloadBySignalId.get(
+          resultRecord.signalId
+        );
+        if (payload) {
+          runner.pendingMlPayloadBySignalId.delete(resultRecord.signalId);
+          const fullRow = (0, import_ml2.buildMlTrainingRow)(payload, {
+            profit: resultRecord.profit
+          });
+          const resolvedChunkId = runner.test.chunkId ?? "single";
+          const row = {
+            ...(0, import_ml2.trimMlTrainingRowWindows)(fullRow, 5),
+            ...buildBacktestDatasetMetadata({
+              backtestRunId: runner.test.backtestRunId,
+              backtestTestKey: runner.test.backtestTestKey,
+              chunkId: resolvedChunkId
+            })
+          };
+          await (0, import_ml2.appendMlDatasetRow)({
+            strategyName: runner.test.strategyName,
+            chunkId: resolvedChunkId,
+            row
+          });
+        }
+        const aiRowBase = runner.pendingAiRowBySignalId.get(
+          resultRecord.signalId
+        );
+        if (aiRowBase) {
+          runner.pendingAiRowBySignalId.delete(resultRecord.signalId);
+          const { signal: aiSignal, ...rowBase } = aiRowBase;
+          const resolvedChunkId = runner.test.chunkId ?? "single";
+          await (0, import_ai2.appendAiDatasetRow)({
+            strategyName: runner.test.strategyName,
+            chunkId: resolvedChunkId,
+            row: {
+              ...rowBase,
+              payload: buildAiPayload(aiSignal),
+              profit: resultRecord.profit,
+              tradeResult: resultRecord.tradeResult
+            }
+          });
+        }
+      }
+    };
+    const processRunnerSignal = async (runner, signal, candle) => {
+      if (isBacktestEntryDelayControlCode(signal)) {
+        return;
+      }
+      const { test } = runner;
+      if (runner.replaySignalEvaluations) {
+        runner.replaySignalEvaluations.push(
+          buildReplaySignalEvaluationRecord({
+            signal,
+            testId: test.testId,
+            userName: test.userName,
+            strategyName: test.strategyName,
+            symbol: test.symbol,
+            interval: test.interval ?? interval,
+            candle
+          })
+        );
+      }
+      const shouldCapturePayload = signal && typeof signal !== "string" && signal.signalId && (test.ml || test.ai);
+      if (shouldCapturePayload) {
+        await withTimeout(
+          "binance market context",
+          enrichSignalWithBinanceMarketContext({
+            signal,
+            env: "BACKTEST"
+          })
+        );
+        await withTimeout(
+          "coinmarketcap context",
+          enrichSignalWithCoinMarketCapContext({
+            signal,
+            env: "BACKTEST",
+            enabled: Boolean(test.ml || test.ai)
+          })
+        );
+        await withTimeout(
+          "derivatives context",
+          enrichSignalWithDerivativesContext({
+            signal,
+            env: "BACKTEST"
+          })
+        );
+      }
+      if (test.ml && signal && typeof signal !== "string" && signal.signalId) {
+        const payload = buildMlPayload({
+          signal,
+          context: {
+            userName: test.userName,
+            testId: test.testId,
+            testSuiteId: test.testSuiteId,
+            testName: test.name,
+            configId: test.configId,
+            symbol: test.symbol,
+            strategyName: test.strategyName,
+            strategyConfig: test.strategyConfig,
+            connectorName: test.connectorName
+          }
+        });
+        runner.pendingMlPayloadBySignalId.set(signal.signalId, payload);
+      }
+      if (test.ai && signal && typeof signal !== "string" && signal.signalId) {
+        runner.pendingAiRowBySignalId.set(signal.signalId, {
+          signalId: signal.signalId,
+          strategyName: signal.strategy || test.strategyName,
+          symbol: signal.symbol || test.symbol,
+          direction: signal.direction,
+          timestamp: signal.timestamp,
+          signal: cloneAiPayloadSignal(signal),
+          testId: test.testId,
+          testSuiteId: test.testSuiteId,
+          testName: test.name,
+          configId: test.configId,
+          connectorName: test.connectorName,
+          ...buildBacktestDatasetMetadata({
+            backtestRunId: test.backtestRunId,
+            backtestTestKey: test.backtestTestKey,
+            chunkId: test.chunkId ?? "single"
+          })
+        });
+      }
+    };
+    for (let candleIndex = 0; candleIndex < testData.length; candleIndex++) {
+      if (candleIndex % 25 === 0) {
+        throwIfTimedOut("candle loop");
+      }
+      currentCandleIndex = candleIndex + 1;
+      emitProgress("candle loop", {
+        force: candleIndex === 0 || currentCandleIndex === totalCandles
+      });
+      const candle = testData[candleIndex];
+      const btcCandle = btcTestData[candleIndex];
+      const detectorNoSignalByKey = /* @__PURE__ */ new Map();
+      for (const runner of runners) {
+        const { test, testConnector, strategy } = runner;
+        const delayedSignal = await runStrategyCandleStage(
+          "delayed entry",
+          async () => strategy.__tradejsFlushBacktestDelayedEntry?.(candle, btcCandle)
+        );
+        if (delayedSignal && typeof delayedSignal !== "string") {
+          await processRunnerSignal(runner, delayedSignal, candle);
+        }
+        await runStage("exit checks", () => testConnector.checkExits(candle));
+        const detectorFanoutKey = strategy.detectorFanoutKey;
+        const detectorSkipCode = detectorFanoutKey ? detectorNoSignalByKey.get(detectorFanoutKey) : void 0;
+        const signal = await runStrategyCandleStage(
+          detectorSkipCode ? "strategy detector skip" : "strategy signal",
+          () => detectorSkipCode && strategy.canFastAdvanceDetectorNoSignal && strategy.advanceDetectorNoSignal ? strategy.advanceDetectorNoSignal(
+            candle,
+            btcCandle,
+            detectorSkipCode
+          ) : detectorSkipCode && strategy.skipDetectorNoSignal ? strategy.skipDetectorNoSignal(
+            candle,
+            btcCandle,
+            detectorSkipCode
+          ) : strategy(candle, btcCandle)
+        );
+        if (detectorFanoutKey && strategy.detectorNoSignalSkipReason && typeof signal === "string" && signal === strategy.detectorNoSignalSkipReason) {
+          detectorNoSignalByKey.set(detectorFanoutKey, signal);
+        }
+        await processRunnerSignal(runner, signal, candle);
+      }
+      if ((candleIndex + 1) % CLOSED_RESULT_FLUSH_INTERVAL === 0) {
+        await withTimeout(
+          "flush closed results",
+          Promise.all(runners.map((runner) => flushClosedResultsBatch(runner)))
+        );
+      }
+    }
+    const results = [];
+    for (const runner of runners) {
+      await withTimeout(
+        "flush closed results",
+        flushClosedResultsBatch(runner)
+      );
+      const result = await withTimeout(
+        "collect result",
+        runner.testConnector.getResult()
+      );
+      results.push({
+        test: runner.test,
+        result: runner.replaySignalEvaluations ? {
+          ...result,
+          inlineReplaySignalEvaluations: runner.replaySignalEvaluations
+        } : result
+      });
+    }
+    return results;
+  } finally {
+    (0, import_strategies4.releaseStrategyIndicatorsReplayCache)(sharedIndicatorsReplayKey);
+    (0, import_strategies4.releaseStrategyReplayCache)(sharedIndicatorsReplayKey);
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  canRunTestsInSharedCandleLoop,
   createTestConnector,
+  releaseTestingSymbolCache,
   resetTestingKlineCache,
+  resolveExecutionCosts,
   testing,
+  testingGroupInSharedCandleLoop,
   ...require("@tradejs/core/backtest")
 });