@tradejs/core 2.0.18 → 2.0.20

package/dist/strategies.js

@@ -6407,7 +6407,7 @@ var calculateRecentRangeExpansionSeries = (candles, lookback) => calculateRecent
   (index) => calculateRangeExpansionAt(candles, index)
 );
 
-// src/utils/indicatorBaseContext.ts
+// src/utils/indicatorBaseContextRelative.ts
 var SESSION_WINDOWS = [
   { name: "asia", startMinuteUtc: 0, endMinuteUtc: 8 * 60 },
   { name: "europe", startMinuteUtc: 7 * 60, endMinuteUtc: 16 * 60 },
@@ -6416,28 +6416,24 @@ var SESSION_WINDOWS = [
 var FUNDING_WINDOW_STEP_MINUTES = 8 * 60;
 var FUNDING_WINDOW_NEARBY_MINUTES = 60;
 var SESSION_WINDOW_EDGE_MINUTES = 60;
-var BASE_INTERVAL_MS = 15 * 6e4;
 var PSYCHOLOGICAL_LEVEL_WINDOWS = {
-  m15: BASE_INTERVAL_MS,
+  m15: 15 * 6e4,
   h1: 60 * 6e4,
   h4: 4 * 60 * 6e4
 };
-var isInsideSession = (minuteUtc, startMinuteUtc, endMinuteUtc) => startMinuteUtc <= endMinuteUtc ? minuteUtc >= startMinuteUtc && minuteUtc < endMinuteUtc : minuteUtc >= startMinuteUtc || minuteUtc < endMinuteUtc;
 var buildSessionContext = (timestamp) => {
   const date = new Date(timestamp);
-  const utcHour = date.getUTCHours();
-  const utcMinute = date.getUTCMinutes();
-  const minuteUtc = utcHour * 60 + utcMinute;
+  const minuteUtc = date.getUTCHours() * 60 + date.getUTCMinutes();
   const dayOfWeekUtc = date.getUTCDay() || 7;
   const activeSessions = SESSION_WINDOWS.filter(
-    (session) => isInsideSession(minuteUtc, session.startMinuteUtc, session.endMinuteUtc)
-  ).map((session) => session.name);
+    ({ startMinuteUtc, endMinuteUtc }) => startMinuteUtc <= endMinuteUtc ? minuteUtc >= startMinuteUtc && minuteUtc < endMinuteUtc : minuteUtc >= startMinuteUtc || minuteUtc < endMinuteUtc
+  ).map(({ name }) => name);
   const sessionPhase = activeSessions.includes("us") ? "us" : activeSessions.includes("europe") ? "europe" : activeSessions.includes("asia") ? "asia" : "off_hours";
   const primaryWindow = SESSION_WINDOWS.find(
-    (session) => session.name === sessionPhase
+    ({ name }) => name === sessionPhase
   );
-  const minutesFromSessionOpen = primaryWindow != null ? minuteUtc - primaryWindow.startMinuteUtc : null;
-  const minutesToSessionClose = primaryWindow != null ? primaryWindow.endMinuteUtc - minuteUtc : null;
+  const minutesFromSessionOpen = primaryWindow ? minuteUtc - primaryWindow.startMinuteUtc : null;
+  const minutesToSessionClose = primaryWindow ? primaryWindow.endMinuteUtc - minuteUtc : null;
   const sessionWindowPhase = primaryWindow == null || minutesFromSessionOpen == null ? "off_hours" : minutesFromSessionOpen < SESSION_WINDOW_EDGE_MINUTES ? "opening" : minutesToSessionClose != null && minutesToSessionClose <= SESSION_WINDOW_EDGE_MINUTES ? "closing" : "active";
   const minutesToFundingWindow = (FUNDING_WINDOW_STEP_MINUTES - minuteUtc % FUNDING_WINDOW_STEP_MINUTES) % FUNDING_WINDOW_STEP_MINUTES;
   return {
@@ -6453,7 +6449,7 @@ var buildSessionContext = (timestamp) => {
     isWeekendUtc: dayOfWeekUtc >= 6
   };
 };
-var buildUnavailablePsychologicalLevelWindow = () => ({
+var unavailablePsychologicalLevelWindow = () => ({
   crossed: null,
   direction: "unknown",
   level: null,
@@ -6462,7 +6458,7 @@ var buildUnavailablePsychologicalLevelWindow = () => ({
 });
 var buildPsychologicalLevelWindow = (startPrice, endPrice, stepUsd) => {
   if (!Number.isFinite(startPrice) || !Number.isFinite(endPrice) || !Number.isFinite(stepUsd) || startPrice <= 0 || endPrice <= 0 || stepUsd <= 0) {
-    return buildUnavailablePsychologicalLevelWindow();
+    return unavailablePsychologicalLevelWindow();
   }
   if (endPrice === startPrice) {
     return {
@@ -6486,21 +6482,17 @@ var buildPsychologicalLevelWindow = (startPrice, endPrice, stepUsd) => {
       distanceBeyondLevelBps: null
     };
   }
-  const levelsCrossed = Math.round(Math.abs(lastCrossedLevel - firstCrossedLevel) / stepUsd) + 1;
-  const distanceBeyondLevelBps = Math.abs(endPrice - lastCrossedLevel) / lastCrossedLevel * 1e4;
   return {
     crossed: true,
     direction: movingUp ? "up" : "down",
     level: lastCrossedLevel,
-    levelsCrossed,
-    distanceBeyondLevelBps
+    levelsCrossed: Math.round(Math.abs(lastCrossedLevel - firstCrossedLevel) / stepUsd) + 1,
+    distanceBeyondLevelBps: Math.abs(endPrice - lastCrossedLevel) / lastCrossedLevel * 1e4
   };
 };
 var buildPsychologicalLevelAssetContext = (candles, stepUsd) => {
   const endCandle = candles[candles.length - 1];
-  if (!endCandle) {
-    return null;
-  }
+  if (!endCandle) return null;
   const candlesByTimestamp = new Map(
     candles.map((item) => [item.timestamp, item])
   );
@@ -6515,104 +6507,70 @@ var buildPsychologicalLevelAssetContext = (candles, stepUsd) => {
           startCandle.close,
           endCandle.close,
           stepUsd
-        ) : buildUnavailablePsychologicalLevelWindow()
+        ) : unavailablePsychologicalLevelWindow()
       ];
     })
   );
-  return {
-    source: "aligned_15m_ohlcv",
-    stepUsd,
-    windows
-  };
+  return { source: "aligned_15m_ohlcv", stepUsd, windows };
 };
-var STRUCTURE_LOOKBACK = 80;
-var BASE_CONTEXT_CANDLE_WINDOW = 256;
-var PIVOT_LEFT_RIGHT = 2;
-var ZONE_ATR_FACTOR = 0.5;
-var PROFILE_BIN_COUNT = 24;
-var SR_ZONE_PIVOT_PERIOD = 9;
-var SR_ZONE_MIN_STRENGTH = 2;
-var SR_ZONE_MAX_PIVOTS = 15;
-var SR_ZONE_CHANNEL_WIDTH_PCT = 8;
-var SR_ZONE_MAX_LEVELS = 6;
-var VOLUME_STRUCTURE_CALC_BARS = 180;
-var VOLUME_STRUCTURE_ROW_COUNT = 20;
-var LIQUIDITY_ZONE_LOOKBACK = 15;
-var LIQUIDITY_ZONE_MAX_AGE = 120;
-var LIQUIDITY_TAIL_ATR_LENGTH = 14;
-var LIQUIDITY_TAIL_ATR_MULT = 0.8;
-var LIQUIDITY_TAIL_MIN_WICK_RATIO = 1.3;
-var LIQUIDITY_TAIL_WICK_DOMINANCE = 1.2;
-var LIQUIDITY_TAIL_MIN_GAP = 5;
-var LIQUIDITY_TAIL_MAX_AGE = 120;
-var TREND_FOLLOW_PIVOT_LENGTH = 10;
-var TREND_FOLLOW_ATR_LENGTH = 14;
-var TREND_FOLLOW_ATR_MULT = 4;
-var ADAPTIVE_CHANNEL_REGRESSION_BARS = 7;
-var ADAPTIVE_CHANNEL_ENVELOPE_BARS = 2;
-var ADAPTIVE_CHANNEL_ATR_STRETCH = 2;
-var ADAPTIVE_CHANNEL_VOLATILITY_LOOKBACK = 100;
-var ADAPTIVE_CHANNEL_CALC_LOOKBACK = 220;
-var STRUCTURE_ZONES_ZONE_WIDTH_ATR = 0.5;
-var STRUCTURE_ZONES_ACCEPT_BARS = 2;
-var calculateReturnPctFromCandles = (candles) => {
+var returnPct = (candles) => {
   if (candles.length < 2) return null;
-  const previous = candles[candles.length - 2];
-  const current = candles[candles.length - 1];
-  return percentChange(current.close, previous.close);
-};
-var calculateRatioReturnPct = (coinCandles, btcCandles) => {
-  if (coinCandles.length < 2 || btcCandles.length < 2) return null;
-  const currentCoin = coinCandles[coinCandles.length - 1];
-  const previousCoin = coinCandles[coinCandles.length - 2];
-  const currentBtc = btcCandles[btcCandles.length - 1];
-  const previousBtc = btcCandles[btcCandles.length - 2];
-  if (currentBtc.close <= 0 || previousBtc.close <= 0) return null;
   return percentChange(
-    currentCoin.close / currentBtc.close,
-    previousCoin.close / previousBtc.close
+    candles[candles.length - 1].close,
+    candles[candles.length - 2].close
   );
 };
-var alignRecentCandlesByTimestamp = (coinCandles, btcCandles) => {
-  const alignedCoinCandles = [];
-  const alignedBtcCandles = [];
-  let coinIndex = Math.max(0, coinCandles.length - 80);
-  let btcIndex = Math.max(0, btcCandles.length - 80);
-  while (coinIndex < coinCandles.length && btcIndex < btcCandles.length) {
-    const coinTimestamp = coinCandles[coinIndex].timestamp;
-    const btcTimestamp = btcCandles[btcIndex].timestamp;
-    if (coinTimestamp === btcTimestamp) {
-      alignedCoinCandles.push(coinCandles[coinIndex]);
-      alignedBtcCandles.push(btcCandles[btcIndex]);
-      coinIndex += 1;
-      btcIndex += 1;
-    } else if (coinTimestamp < btcTimestamp) {
-      coinIndex += 1;
+var ratioReturnPct = (target, reference) => {
+  if (target.length < 2 || reference.length < 2) return null;
+  const targetCurrent = target[target.length - 1];
+  const targetPrevious = target[target.length - 2];
+  const referenceCurrent = reference[reference.length - 1];
+  const referencePrevious = reference[reference.length - 2];
+  if (referenceCurrent.close <= 0 || referencePrevious.close <= 0) return null;
+  return percentChange(
+    targetCurrent.close / referenceCurrent.close,
+    targetPrevious.close / referencePrevious.close
+  );
+};
+var alignRecentCandles = (target, reference) => {
+  const alignedTarget = [];
+  const alignedReference = [];
+  let targetIndex = Math.max(0, target.length - 80);
+  let referenceIndex = Math.max(0, reference.length - 80);
+  while (targetIndex < target.length && referenceIndex < reference.length) {
+    const targetTimestamp = target[targetIndex].timestamp;
+    const referenceTimestamp = reference[referenceIndex].timestamp;
+    if (targetTimestamp === referenceTimestamp) {
+      alignedTarget.push(target[targetIndex]);
+      alignedReference.push(reference[referenceIndex]);
+      targetIndex += 1;
+      referenceIndex += 1;
+    } else if (targetTimestamp < referenceTimestamp) {
+      targetIndex += 1;
     } else {
-      btcIndex += 1;
+      referenceIndex += 1;
     }
   }
-  return { alignedCoinCandles, alignedBtcCandles };
+  return { alignedTarget, alignedReference };
 };
-var buildReturnPctSeries = (candles, limit) => {
+var returnSeries = (candles, limit) => {
   const returns = [];
-  const startIndex = Math.max(1, candles.length - limit);
-  for (let index = startIndex; index < candles.length; index += 1) {
+  for (let index = Math.max(1, candles.length - limit); index < candles.length; index += 1) {
     const previous = candles[index - 1];
     const current = candles[index];
     if (previous.close <= 0) continue;
-    const ret = percentChange(current.close, previous.close);
-    if (ret != null && Number.isFinite(ret)) returns.push(ret);
+    const value = percentChange(current.close, previous.close);
+    if (value != null && Number.isFinite(value)) returns.push(value);
   }
   return returns;
 };
-var calculateBetaToReference = (targetReturns, referenceReturns) => {
+var beta = (targetReturns, referenceReturns) => {
   const length = Math.min(targetReturns.length, referenceReturns.length);
   if (length < 2) return null;
   const target = targetReturns.slice(-length);
   const reference = referenceReturns.slice(-length);
-  const referenceMean = reference.reduce((sum2, value) => sum2 + value, 0) / reference.length;
-  const targetMean = target.reduce((sum2, value) => sum2 + value, 0) / target.length;
+  const referenceMean = reference.reduce((sum2, value) => sum2 + value, 0) / length;
+  const targetMean = target.reduce((sum2, value) => sum2 + value, 0) / length;
   let covariance = 0;
   let referenceVariance = 0;
   for (let index = 0; index < length; index += 1) {
@@ -6629,16 +6587,6 @@ var classifyRatioTrend = (ratioReturn24h, ratioReturn4h) => {
   if (value < -0.15) return "down";
   return "flat";
 };
-var hasDistinctReferenceCandles = (coinCandles, referenceCandles) => {
-  const coinLast = coinCandles[coinCandles.length - 1];
-  const referenceLast = referenceCandles[referenceCandles.length - 1];
-  const coinPrev = coinCandles[coinCandles.length - 2];
-  const referencePrev = referenceCandles[referenceCandles.length - 2];
-  if (!coinLast || !referenceLast || !coinPrev || !referencePrev) {
-    return false;
-  }
-  return coinLast.timestamp !== referenceLast.timestamp || coinLast.close !== referenceLast.close || coinPrev.timestamp !== referencePrev.timestamp || coinPrev.close !== referencePrev.close;
-};
 var buildTargetVsBtcContext = ({
   coin1h,
   btc1h,
@@ -6649,19 +6597,21 @@ var buildTargetVsBtcContext = ({
   coinCandles,
   btcCandles
 }) => {
-  const ratioReturn1h = calculateRatioReturnPct(coin1h, btc1h);
-  const ratioReturn4h = calculateRatioReturnPct(coin4h, btc4h);
-  const ratioReturn24h = calculateRatioReturnPct(coin1d, btc1d);
-  const coinReturn1h = calculateReturnPctFromCandles(coin1h);
-  const coinReturn4h = calculateReturnPctFromCandles(coin4h);
-  const coinReturn24h = calculateReturnPctFromCandles(coin1d);
-  const btcReturn1h = calculateReturnPctFromCandles(btc1h);
-  const btcReturn4h = calculateReturnPctFromCandles(btc4h);
-  const btcReturn24h = calculateReturnPctFromCandles(btc1d);
-  const { alignedCoinCandles, alignedBtcCandles } = alignRecentCandlesByTimestamp(coinCandles, btcCandles);
-  const coinReturns20 = buildReturnPctSeries(alignedCoinCandles, 21).slice(-20);
-  const btcReturns20 = buildReturnPctSeries(alignedBtcCandles, 21).slice(-20);
-  const correlationToBtc20 = coinReturns20.length === btcReturns20.length && coinReturns20.length >= 2 ? calculatePearsonCorrelation(coinReturns20, btcReturns20) : null;
+  const ratioReturn1h = ratioReturnPct(coin1h, btc1h);
+  const ratioReturn4h = ratioReturnPct(coin4h, btc4h);
+  const ratioReturn24h = ratioReturnPct(coin1d, btc1d);
+  const coinReturn1h = returnPct(coin1h);
+  const coinReturn4h = returnPct(coin4h);
+  const coinReturn24h = returnPct(coin1d);
+  const btcReturn1h = returnPct(btc1h);
+  const btcReturn4h = returnPct(btc4h);
+  const btcReturn24h = returnPct(btc1d);
+  const { alignedTarget, alignedReference } = alignRecentCandles(
+    coinCandles,
+    btcCandles
+  );
+  const coinReturns20 = returnSeries(alignedTarget, 21).slice(-20);
+  const btcReturns20 = returnSeries(alignedReference, 21).slice(-20);
   return {
     source: "aligned_ohlcv",
     ratioReturn1h,
@@ -6670,11 +6620,21 @@ var buildTargetVsBtcContext = ({
     alphaVsBtc1h: coinReturn1h == null || btcReturn1h == null ? null : coinReturn1h - btcReturn1h,
     alphaVsBtc4h: coinReturn4h == null || btcReturn4h == null ? null : coinReturn4h - btcReturn4h,
     alphaVsBtc24h: coinReturn24h == null || btcReturn24h == null ? null : coinReturn24h - btcReturn24h,
-    betaToBtc20: calculateBetaToReference(coinReturns20, btcReturns20),
-    correlationToBtc20,
+    betaToBtc20: beta(coinReturns20, btcReturns20),
+    correlationToBtc20: coinReturns20.length === btcReturns20.length && coinReturns20.length >= 2 ? calculatePearsonCorrelation(coinReturns20, btcReturns20) : null,
     ratioTrend: classifyRatioTrend(ratioReturn24h, ratioReturn4h)
   };
 };
+var hasDistinctReferenceCandles = (target, reference) => {
+  const targetLast = target[target.length - 1];
+  const referenceLast = reference[reference.length - 1];
+  const targetPrevious = target[target.length - 2];
+  const referencePrevious = reference[reference.length - 2];
+  if (!targetLast || !referenceLast || !targetPrevious || !referencePrevious) {
+    return false;
+  }
+  return targetLast.timestamp !== referenceLast.timestamp || targetLast.close !== referenceLast.close || targetPrevious.timestamp !== referencePrevious.timestamp || targetPrevious.close !== referencePrevious.close;
+};
 var buildTargetVsEthContext = ({
   coin1h,
   eth1h,
@@ -6685,9 +6645,7 @@ var buildTargetVsEthContext = ({
   coinCandles,
   ethCandles
 }) => {
-  if (!hasDistinctReferenceCandles(coinCandles, ethCandles)) {
-    return null;
-  }
+  if (!hasDistinctReferenceCandles(coinCandles, ethCandles)) return null;
   const context = buildTargetVsBtcContext({
     coin1h,
     btc1h: eth1h,
@@ -6711,6 +6669,38 @@ var buildTargetVsEthContext = ({
     ratioTrend: context.ratioTrend
   };
 };
+
+// src/utils/indicatorBaseContext.ts
+var STRUCTURE_LOOKBACK = 80;
+var BASE_CONTEXT_CANDLE_WINDOW = 256;
+var PIVOT_LEFT_RIGHT = 2;
+var ZONE_ATR_FACTOR = 0.5;
+var PROFILE_BIN_COUNT = 24;
+var SR_ZONE_PIVOT_PERIOD = 9;
+var SR_ZONE_MIN_STRENGTH = 2;
+var SR_ZONE_MAX_PIVOTS = 15;
+var SR_ZONE_CHANNEL_WIDTH_PCT = 8;
+var SR_ZONE_MAX_LEVELS = 6;
+var VOLUME_STRUCTURE_CALC_BARS = 180;
+var VOLUME_STRUCTURE_ROW_COUNT = 20;
+var LIQUIDITY_ZONE_LOOKBACK = 15;
+var LIQUIDITY_ZONE_MAX_AGE = 120;
+var LIQUIDITY_TAIL_ATR_LENGTH = 14;
+var LIQUIDITY_TAIL_ATR_MULT = 0.8;
+var LIQUIDITY_TAIL_MIN_WICK_RATIO = 1.3;
+var LIQUIDITY_TAIL_WICK_DOMINANCE = 1.2;
+var LIQUIDITY_TAIL_MIN_GAP = 5;
+var LIQUIDITY_TAIL_MAX_AGE = 120;
+var TREND_FOLLOW_PIVOT_LENGTH = 10;
+var TREND_FOLLOW_ATR_LENGTH = 14;
+var TREND_FOLLOW_ATR_MULT = 4;
+var ADAPTIVE_CHANNEL_REGRESSION_BARS = 7;
+var ADAPTIVE_CHANNEL_ENVELOPE_BARS = 2;
+var ADAPTIVE_CHANNEL_ATR_STRETCH = 2;
+var ADAPTIVE_CHANNEL_VOLATILITY_LOOKBACK = 100;
+var ADAPTIVE_CHANNEL_CALC_LOOKBACK = 220;
+var STRUCTURE_ZONES_ZONE_WIDTH_ATR = 0.5;
+var STRUCTURE_ZONES_ACCEPT_BARS = 2;
 var BASE_CONTEXT_MA_LAYER_PERIODS = [
   [5, 12],
   [9, 13],
@@ -10701,13 +10691,12 @@ var buildIndicatorSeriesByTimeframes = (candles, periods, sourcePrefix = "") =>
 
 // src/utils/timestamp.ts
 var import_date_fns = require("date-fns");
-var import_date_fns2 = require("date-fns");
 var RUNTIME_STORAGE_DAY_OFFSET_MS = 6 * 60 * 60 * 1e3;
 var getTimestamp = (days = 0) => {
   if (days > 0) {
-    return (0, import_date_fns2.getUnixTime)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
+    return (0, import_date_fns.getUnixTime)((0, import_date_fns.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
   }
-  return (0, import_date_fns2.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
+  return (0, import_date_fns.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
 };
 
 // src/utils/strategyHelpers/indicators.ts
@@ -11076,23 +11065,46 @@ var getDirectionalTpSlPrices = ({
 };
 
 // src/utils/strategyHelpers/state.ts
-var createLastTradeController = ({
+var resolveLastTradeControllerParams = ({
   env,
   enabled = env ? env === "BACKTEST" : true,
   cooldownMs = 864e5
+}) => ({
+  enabled,
+  cooldownMs
+});
+var createStateBackedLastTradeController = ({
+  state,
+  enabled,
+  cooldownMs
 }) => {
-  let lastTradeTimestamp = null;
+  const getLastTradeTimestamp = () => state.get().lastTradeTimestamp;
   return {
-    isInCooldown: (timestamp) => Boolean(
-      enabled && lastTradeTimestamp != null && timestamp <= lastTradeTimestamp + cooldownMs
-    ),
+    isInCooldown: (timestamp) => {
+      const lastTradeTimestamp = getLastTradeTimestamp();
+      return Boolean(
+        enabled && lastTradeTimestamp != null && timestamp <= lastTradeTimestamp + cooldownMs
+      );
+    },
     markTrade: (timestamp) => {
       if (!enabled) return;
-      lastTradeTimestamp = timestamp;
+      state.update((current) => {
+        current.lastTradeTimestamp = timestamp;
+      });
     },
-    getLastTradeTimestamp: () => lastTradeTimestamp
+    getLastTradeTimestamp
   };
 };
+var createLastTradeController = (params) => {
+  const state = { lastTradeTimestamp: null };
+  return createStateBackedLastTradeController({
+    ...resolveLastTradeControllerParams(params),
+    state: {
+      get: () => state,
+      update: (fn) => fn(state)
+    }
+  });
+};
 var stableStringify = (value, seen = /* @__PURE__ */ new WeakSet()) => {
   if (value == null) {
     return String(value);
@@ -11234,11 +11246,14 @@ var createStrategyStateControllerFactory = ({
 };
 
 // src/utils/uuid.ts
-var import_node_crypto = require("crypto");
-var uuid = (len = 12) => {
-  const uuid2 = (0, import_node_crypto.randomUUID)();
-  return uuid2.slice(-len);
+var randomUuid = () => {
+  if (!globalThis.crypto?.randomUUID) {
+    throw new Error("crypto.randomUUID is not available in this runtime");
+  }
+  return globalThis.crypto.randomUUID();
 };
+var createIdGenerator = (generateUuid = randomUuid) => (length = 12) => generateUuid().slice(-length);
+var uuid = createIdGenerator();
 
 // src/utils/strategyHelpers/signalBuilders.ts
 var COMPACT_MTF_CANDLE_LIMIT = 3;
@@ -11922,13 +11937,14 @@ var buildEntrySignalDecision = ({
   additionalIndicators,
   signalId,
   orderPlan,
-  runtime
+  runtime,
+  generateId = uuid
 }) => ({
   kind: "entry",
   code,
   entryContext,
   signal: buildStrategySignal({
-    signalId: signalId ?? uuid(),
+    signalId: signalId ?? generateId(),
     strategy: entryContext.strategy,
     symbol: entryContext.symbol,
     interval: entryContext.interval,
@@ -11943,7 +11959,7 @@ var buildEntrySignalDecision = ({
   orderPlan,
   runtime
 });
-var isFiniteNumber3 = (value) => typeof value === "number" && Number.isFinite(value);
+var isFiniteNumber2 = (value) => typeof value === "number" && Number.isFinite(value);
 var toDefaultEntryCode = (strategy, direction) => `${strategy.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_${direction}_ENTRY`;
 var toDefaultExitCode = (strategy, direction) => `${strategy.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_${direction}_EXIT`;
 var toDefaultProtectCode = (strategy, direction) => `${strategy.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_${direction}_PROTECT`;
@@ -11954,7 +11970,7 @@ var resolveTakeProfitPrice = ({
   if (!Array.isArray(takeProfits) || takeProfits.length === 0) {
     throw new Error("strategyApi.entry requires at least one takeProfit");
   }
-  const prices = takeProfits.map((tp) => tp?.price).filter((price) => isFiniteNumber3(price));
+  const prices = takeProfits.map((tp) => tp?.price).filter((price) => isFiniteNumber2(price));
   if (prices.length === 0) {
     throw new Error("strategyApi.entry requires finite takeProfit prices");
   }
@@ -11971,6 +11987,7 @@ var createStrategyAPI = ({
   isConfigFromBacktest,
   sharedReplayKey,
   getSharedReplayState,
+  generateId,
   loadDecisionBaseContext
 }) => {
   const isBacktestEnv = env === "BACKTEST";
@@ -12028,6 +12045,7 @@ var createStrategyAPI = ({
     sharedReplayKey,
     getSharedReplayState
   });
+  let lastTradeControllerIndex = 0;
   const getBaseContextFromIndicators = (indicators) => isRecordLike(indicators) && isRecordLike(indicators.baseContext) ? indicators.baseContext : void 0;
   const getCurrentIndicatorsContext = () => {
     ensureBarCache();
@@ -12088,7 +12106,7 @@ var createStrategyAPI = ({
   };
   const resolveDecisionPriceContext = () => {
     const candle = cachedData[cachedData.length - 1];
-    if (!candle || !isFiniteNumber3(candle.timestamp) || !isFiniteNumber3(candle.close)) {
+    if (!candle || !isFiniteNumber2(candle.timestamp) || !isFiniteNumber2(candle.close)) {
       throw new Error(
         "strategyApi.getDecisionPriceContext requires a current closed candle"
       );
@@ -12120,7 +12138,7 @@ var createStrategyAPI = ({
         direction,
         takeProfits: orderPlan.takeProfits
       });
-      if (!isFiniteNumber3(stopLossPrice)) {
+      if (!isFiniteNumber2(stopLossPrice)) {
         throw new Error(
           "strategyApi.entry requires finite orderPlan.stopLossPrice"
         );
@@ -12153,7 +12171,8 @@ var createStrategyAPI = ({
         additionalIndicators,
         signalId,
         orderPlan,
-        runtime
+        runtime,
+        generateId
       });
     },
     exit: async ({ code, direction }) => {
@@ -12179,10 +12198,26 @@ var createStrategyAPI = ({
     getDecisionPriceContext,
     getCurrentPosition,
     getDirectionalTpSlPrices: (params) => getDirectionalTpSlPrices(params),
-    createLastTradeController: (params) => createLastTradeController({
-      env,
-      ...params
-    }),
+    createLastTradeController: (params) => {
+      const resolvedParams = resolveLastTradeControllerParams({
+        env,
+        ...params
+      });
+      const controllerIndex = lastTradeControllerIndex;
+      lastTradeControllerIndex += 1;
+      const state = createStateController(
+        `__tradejs:last-trade:${controllerIndex}`,
+        () => ({ lastTradeTimestamp: null }),
+        {
+          configKey: JSON.stringify(resolvedParams),
+          sharedReplay: env === "CRON"
+        }
+      );
+      return createStateBackedLastTradeController({
+        ...resolvedParams,
+        state
+      });
+    },
     createStateController
   };
 };