@tradejs/core 1.0.9 → 1.0.10

package/dist/strategies.mjs

@@ -1,17 +1,18 @@
+import {
+  createIndicators,
+  getRequiredControllerSeedWindow
+} from "./chunk-7P2KNFD4.mjs";
+import "./chunk-AYC2QVKI.mjs";
+import "./chunk-M7QGVZ3J.mjs";
 import {
   uuid
 } from "./chunk-AJK4NS7Y.mjs";
-import {
-  createIndicators
-} from "./chunk-UK6VTOUX.mjs";
-import "./chunk-AYC2QVKI.mjs";
 import {
   getTimestamp
-} from "./chunk-FNLPYYML.mjs";
+} from "./chunk-PNBS6J3G.mjs";
 import {
   FEE_PERCENT
-} from "./chunk-2ORZC66W.mjs";
-import "./chunk-M7QGVZ3J.mjs";
+} from "./chunk-DXJ4NCFJ.mjs";
 
 // src/utils/strategyHelpers/indicators.ts
 var buildDefaultIndicatorPeriods = (config) => {
@@ -37,85 +38,288 @@ var buildDefaultIndicatorPeriods = (config) => {
   assignIfFinite("levelDelay", config.LEVEL_DELAY);
   return periods;
 };
+var sharedReplayControllers = /* @__PURE__ */ new Map();
+var canUseSharedReplayController = (env, sharedReplayKey) => (env === "BACKTEST" || env === "PARITY") && Boolean(sharedReplayKey);
+var createSnapshotController = (value) => {
+  const nextSnapshot = typeof value.snapshot === "function" ? value.snapshot.bind(value) : value.result.bind(value);
+  return Object.assign(value, {
+    snapshot: nextSnapshot
+  });
+};
+var releaseStrategyIndicatorsReplayCache = (keyPrefix) => {
+  for (const key of sharedReplayControllers.keys()) {
+    if (key === keyPrefix || key.startsWith(`${keyPrefix}:`)) {
+      sharedReplayControllers.delete(key);
+    }
+  }
+};
 var createStrategyIndicatorsState = ({
   env,
   data,
   btcData,
+  ethData = [],
   btcBinanceData,
   btcCoinbaseData,
   periods,
-  pluginRegistryScope
+  pluginRegistryScope,
+  initialRuntimeState,
+  replayStartIndex = 0,
+  sharedReplayKey,
+  useBtcReference = true
 }) => {
-  let controller = env === "BACKTEST" ? createIndicators(data, btcData, {
-    periods,
-    btcBinanceData,
-    btcCoinbaseData,
-    pluginRegistryScope
-  }) : null;
-  let currentBarPair;
-  const withSnapshot = (value) => Object.assign(value, {
-    snapshot: () => value.result()
-  });
-  const applyBar = (candle, btcCandle) => {
-    if (!controller) return;
-    controller.next(candle, btcCandle);
-  };
-  const ensureControllerInitialized = () => {
-    if (controller) return withSnapshot(controller);
-    controller = createIndicators(data.slice(0, -1), btcData.slice(0, -1), {
+  let ethDataByTimestamp = null;
+  const controllerSeedWindow = getRequiredControllerSeedWindow(periods);
+  const createController = (initialDataEnd) => {
+    const endIndex = initialDataEnd == null ? data.length : initialDataEnd;
+    const startIndex = Math.max(
+      replayStartIndex,
+      endIndex - controllerSeedWindow
+    );
+    const resolveEthDataWindow = (fromIndex, toIndex, coinWindow) => coinWindow.every(
+      (candle, offset) => ethData[fromIndex + offset]?.timestamp === candle.timestamp
+    ) ? ethData.slice(fromIndex, toIndex) : (() => {
+      const timestamps = new Set(
+        coinWindow.map((candle) => candle.timestamp)
+      );
+      return ethData.filter((candle) => timestamps.has(candle.timestamp));
+    })();
+    const createControllerWithState = (coinWindow, btcWindow, ethWindow, state) => createIndicators(coinWindow, useBtcReference ? btcWindow : [], {
       periods,
+      ethData: ethWindow,
       btcBinanceData,
       btcCoinbaseData,
-      pluginRegistryScope
+      pluginRegistryScope,
+      initialRuntimeState: state ?? void 0
     });
-    const lastCandle = data[data.length - 1];
-    const lastBtcCandle = btcData[btcData.length - 1];
-    if (lastCandle && lastBtcCandle) {
-      controller.next(lastCandle, lastBtcCandle);
+    if (startIndex <= replayStartIndex) {
+      const dataWindow2 = data.slice(startIndex, endIndex);
+      return createControllerWithState(
+        dataWindow2,
+        btcData.slice(startIndex, endIndex),
+        resolveEthDataWindow(startIndex, endIndex, dataWindow2),
+        initialRuntimeState
+      );
     }
-    return withSnapshot(controller);
+    const warmupData = data.slice(replayStartIndex, startIndex);
+    const warmupController = createControllerWithState(
+      warmupData,
+      btcData.slice(replayStartIndex, startIndex),
+      resolveEthDataWindow(replayStartIndex, startIndex, warmupData),
+      initialRuntimeState
+    );
+    const dataWindow = data.slice(startIndex, endIndex);
+    return createControllerWithState(
+      dataWindow,
+      btcData.slice(startIndex, endIndex),
+      resolveEthDataWindow(startIndex, endIndex, dataWindow),
+      warmupController.checkpointRuntimeState()
+    );
+  };
+  const sharedReplayState = canUseSharedReplayController(env, sharedReplayKey) && sharedReplayKey ? (() => {
+    let existing = sharedReplayControllers.get(sharedReplayKey);
+    if (!existing) {
+      existing = {
+        controller: null,
+        appliedDataEnd: replayStartIndex,
+        lastTimestamp: null,
+        lastResult: void 0
+      };
+      sharedReplayControllers.set(sharedReplayKey, existing);
+    }
+    return existing;
+  })() : null;
+  let controller = null;
+  let appliedDataEnd = replayStartIndex;
+  let currentBarPair;
+  const resolveEthCandle = (index, candle) => {
+    if (currentBarPair?.candle.timestamp === candle.timestamp && currentBarPair.ethCandle) {
+      return currentBarPair.ethCandle;
+    }
+    const alignedEthCandle = ethData[index];
+    if (alignedEthCandle?.timestamp === candle.timestamp) {
+      return alignedEthCandle;
+    }
+    ethDataByTimestamp ??= new Map(
+      ethData.map((item) => [item.timestamp, item])
+    );
+    return ethDataByTimestamp.get(candle.timestamp);
+  };
+  const applyBar = (candle, btcCandle, ethCandle) => {
+    if (sharedReplayState) {
+      if (sharedReplayState.lastTimestamp === candle.timestamp) {
+        return sharedReplayState.lastResult ?? sharedReplayState.controller?.latestSnapshot();
+      }
+      if (sharedReplayState.lastTimestamp != null && candle.timestamp < sharedReplayState.lastTimestamp) {
+        throw new Error(
+          `Shared replay indicators received non-monotonic candle timestamp ${candle.timestamp} after ${sharedReplayState.lastTimestamp}`
+        );
+      }
+      if (!sharedReplayState.controller) {
+        sharedReplayState.controller = createController(
+          sharedReplayState.appliedDataEnd
+        );
+      }
+      sharedReplayState.lastTimestamp = candle.timestamp;
+      sharedReplayState.lastResult = ethCandle == null ? sharedReplayState.controller.next(candle, btcCandle) : sharedReplayState.controller.next(candle, btcCandle, ethCandle);
+      return sharedReplayState.lastResult;
+    }
+    if (!controller) {
+      controller = createController(appliedDataEnd);
+    }
+    const result = ethCandle == null ? controller.next(candle, btcCandle) : controller.next(candle, btcCandle, ethCandle);
+    return result;
+  };
+  const syncDataRange = (targetDataEnd) => {
+    const safeTargetDataEnd = Math.max(replayStartIndex, targetDataEnd);
+    if (sharedReplayState) {
+      if (!sharedReplayState.controller) {
+        sharedReplayState.controller = createController(safeTargetDataEnd);
+        sharedReplayState.appliedDataEnd = safeTargetDataEnd;
+        const lastCandle = data[safeTargetDataEnd - 1];
+        sharedReplayState.lastTimestamp = lastCandle?.timestamp ?? null;
+        sharedReplayState.lastResult = void 0;
+        return;
+      }
+      if (safeTargetDataEnd < sharedReplayState.appliedDataEnd) {
+        throw new Error(
+          `Shared replay indicators cannot rewind from index ${sharedReplayState.appliedDataEnd} to ${safeTargetDataEnd}`
+        );
+      }
+      for (let index = sharedReplayState.appliedDataEnd; index < safeTargetDataEnd; index += 1) {
+        const candle = data[index];
+        const btcCandle = btcData[index];
+        const ethCandle = candle == null ? void 0 : resolveEthCandle(index, candle);
+        if (!candle || useBtcReference && !btcCandle) continue;
+        sharedReplayState.lastTimestamp = candle.timestamp;
+        sharedReplayState.lastResult = ethCandle == null ? sharedReplayState.controller.next(candle, btcCandle) : sharedReplayState.controller.next(candle, btcCandle, ethCandle);
+      }
+      sharedReplayState.appliedDataEnd = safeTargetDataEnd;
+      return;
+    }
+    if (!controller) {
+      controller = createController(safeTargetDataEnd);
+      appliedDataEnd = safeTargetDataEnd;
+      return;
+    }
+    if (safeTargetDataEnd < appliedDataEnd) {
+      throw new Error(
+        `Indicators cannot rewind from index ${appliedDataEnd} to ${safeTargetDataEnd}`
+      );
+    }
+    for (let index = appliedDataEnd; index < safeTargetDataEnd; index += 1) {
+      const candle = data[index];
+      const btcCandle = btcData[index];
+      const ethCandle = candle == null ? void 0 : resolveEthCandle(index, candle);
+      if (!candle || useBtcReference && !btcCandle) continue;
+      if (ethCandle == null) {
+        controller.next(candle, btcCandle);
+      } else {
+        controller.next(candle, btcCandle, ethCandle);
+      }
+    }
+    appliedDataEnd = safeTargetDataEnd;
+  };
+  const syncToCurrentData = () => {
+    syncDataRange(data.length);
+  };
+  const getAppliedDataEnd = () => sharedReplayState ? sharedReplayState.appliedDataEnd : appliedDataEnd;
+  const markAppliedDataEnd = (value) => {
+    if (sharedReplayState) {
+      sharedReplayState.appliedDataEnd = Math.max(
+        sharedReplayState.appliedDataEnd,
+        value
+      );
+    } else {
+      appliedDataEnd = Math.max(appliedDataEnd, value);
+    }
+  };
+  const ensureControllerInitialized = () => {
+    syncToCurrentData();
+    if (sharedReplayState) {
+      if (!sharedReplayState.controller) {
+        sharedReplayState.controller = createController(
+          sharedReplayState.appliedDataEnd
+        );
+      }
+      return createSnapshotController(sharedReplayState.controller);
+    }
+    if (!controller) {
+      controller = createController(appliedDataEnd);
+    }
+    return createSnapshotController(controller);
   };
   return {
-    isInitialized: () => controller != null,
-    setCurrentBar: (candle, btcCandle) => {
-      currentBarPair = { candle, btcCandle };
+    isInitialized: () => sharedReplayState ? sharedReplayState.controller != null : controller != null,
+    setCurrentBar: (candle, btcCandle, ethCandle) => {
+      currentBarPair = {
+        candle,
+        btcCandle: useBtcReference ? btcCandle : void 0,
+        ethCandle: useBtcReference ? ethCandle : void 0
+      };
+    },
+    updateReferenceData: (nextReferenceData) => {
+      btcBinanceData = nextReferenceData.btcBinanceData;
+      btcCoinbaseData = nextReferenceData.btcCoinbaseData;
+      controller?.updateReferenceData(nextReferenceData);
+      sharedReplayState?.controller?.updateReferenceData(nextReferenceData);
     },
-    onBar: (candle, btcCandle) => {
+    onBar: (candle, btcCandle, ethCandle) => {
       const resolvedCandle = candle ?? currentBarPair?.candle;
-      const resolvedBtcCandle = btcCandle ?? currentBarPair?.btcCandle;
-      if (!resolvedCandle || !resolvedBtcCandle) return;
-      applyBar(resolvedCandle, resolvedBtcCandle);
+      const resolvedBtcCandle = useBtcReference ? btcCandle ?? currentBarPair?.btcCandle : void 0;
+      const resolvedEthCandle = ethCandle ?? currentBarPair?.ethCandle ?? (resolvedCandle == null ? void 0 : resolveEthCandle(data.length - 1, resolvedCandle));
+      if (!resolvedCandle || useBtcReference && !resolvedBtcCandle) return;
+      if (data[data.length - 1]?.timestamp === resolvedCandle.timestamp && (!useBtcReference || btcData[btcData.length - 1]?.timestamp === resolvedBtcCandle?.timestamp)) {
+        if (getAppliedDataEnd() >= data.length) {
+          return;
+        }
+        syncDataRange(data.length - 1);
+        applyBar(resolvedCandle, resolvedBtcCandle, resolvedEthCandle);
+        markAppliedDataEnd(data.length);
+        return;
+      }
+      applyBar(resolvedCandle, resolvedBtcCandle, resolvedEthCandle);
     },
-    next: (candle, btcCandle) => {
-      if (!controller) return void 0;
-      return controller.next(candle, btcCandle);
+    next: (candle, btcCandle, ethCandle) => {
+      const resolvedBtcCandle = useBtcReference ? btcCandle : void 0;
+      const resolvedEthCandle = ethCandle ?? resolveEthCandle(data.length - 1, candle);
+      const explicitCurrent = data[data.length - 1]?.timestamp === candle.timestamp && (!useBtcReference || btcData[btcData.length - 1]?.timestamp === resolvedBtcCandle?.timestamp);
+      if (explicitCurrent && getAppliedDataEnd() >= data.length) {
+        return ensureControllerInitialized().latestSnapshot();
+      }
+      const explicitCandleDataEnd = explicitCurrent ? data.length - 1 : data.length;
+      syncDataRange(explicitCandleDataEnd);
+      const result = applyBar(candle, resolvedBtcCandle, resolvedEthCandle);
+      if (explicitCandleDataEnd === data.length - 1) {
+        markAppliedDataEnd(data.length);
+      }
+      return result;
     },
     // Lazy bootstrap for live mode: initialize on history before current bar and then apply current bar once.
     ensureInitializedWithCurrentBar: ensureControllerInitialized,
-    snapshot: () => ensureControllerInitialized().snapshot(),
-    latestNumber: (key) => {
-      const snapshot = ensureControllerInitialized().snapshot();
-      const value = snapshot?.[key];
-      if (!Array.isArray(value) || value.length === 0) {
-        return void 0;
-      }
-      const last = value[value.length - 1];
-      return typeof last === "number" ? last : void 0;
-    }
+    snapshot: (options) => ensureControllerInitialized().snapshot(options),
+    latestNumber: (key) => ensureControllerInitialized().latestNumber(key)
   };
 };
 
 // src/utils/strategyHelpers/market.ts
+var resolveBacktestExecutionPrice = (candle, backtestPriceMode = "open") => {
+  if (backtestPriceMode === "mid") {
+    return (candle.open + candle.close) / 2;
+  }
+  if (backtestPriceMode === "open") {
+    return candle.open;
+  }
+  return candle.close;
+};
 var getStrategyMarketSnapshot = async ({
   env,
   connector,
   symbol,
   interval,
   cachedData,
-  preloadStart,
-  backtestPriceMode = "mid"
+  preloadStart
 }) => {
-  const fullData = env === "BACKTEST" || env === "CRON" ? cachedData : await connector.kline({
+  const fullData = env === "BACKTEST" || env === "CRON" || env === "PARITY" ? cachedData : await connector.kline({
     symbol,
     start: preloadStart,
     end: getTimestamp(),
@@ -123,18 +327,7 @@ var getStrategyMarketSnapshot = async ({
     interval
   });
   const lastCandle = fullData[fullData.length - 1];
-  let currentPrice = lastCandle.close;
-  if (env === "BACKTEST") {
-    if (backtestPriceMode === "mid") {
-      currentPrice = (lastCandle.open + lastCandle.close) / 2;
-    } else if (backtestPriceMode === "open") {
-      currentPrice = lastCandle.open;
-    } else if (backtestPriceMode === "rand") {
-      const min = Math.min(lastCandle.low, lastCandle.high);
-      const max = Math.max(lastCandle.low, lastCandle.high);
-      currentPrice = min + Math.random() * (max - min);
-    }
-  }
+  const currentPrice = lastCandle.close;
   return {
     fullData,
     lastCandle,
@@ -202,8 +395,792 @@ var createLastTradeController = ({
     getLastTradeTimestamp: () => lastTradeTimestamp
   };
 };
+var stableStringify = (value, seen = /* @__PURE__ */ new WeakSet()) => {
+  if (value == null) {
+    return String(value);
+  }
+  const valueType = typeof value;
+  if (valueType === "number") {
+    return Number.isFinite(value) ? String(value) : JSON.stringify(String(value));
+  }
+  if (valueType === "string") {
+    return JSON.stringify(value);
+  }
+  if (valueType === "boolean") {
+    return String(value);
+  }
+  if (valueType === "bigint") {
+    return JSON.stringify(`${String(value)}n`);
+  }
+  if (valueType === "undefined" || valueType === "function") {
+    return JSON.stringify(`[${valueType}]`);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+  }
+  if (value instanceof Date) {
+    return JSON.stringify(value.toISOString());
+  }
+  if (valueType === "object") {
+    const record = value;
+    if (seen.has(record)) {
+      return JSON.stringify("[Circular]");
+    }
+    seen.add(record);
+    const serialized = `{${Object.keys(record).sort().map(
+      (key) => `${JSON.stringify(key)}:${stableStringify(record[key], seen)}`
+    ).join(",")}}`;
+    seen.delete(record);
+    return serialized;
+  }
+  return JSON.stringify(String(value));
+};
+var hashStableValue = (value) => {
+  const serialized = stableStringify(value);
+  let hash = 2166136261;
+  for (let index = 0; index < serialized.length; index += 1) {
+    hash ^= serialized.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+};
+var canUseSharedStrategyState = ({
+  env,
+  sharedReplayKey,
+  getSharedReplayState,
+  sharedReplay
+}) => sharedReplay && (env === "BACKTEST" || env === "PARITY" || env === "CRON") && Boolean(sharedReplayKey && getSharedReplayState);
+var createStrategyStateControllerFactory = ({
+  env,
+  sharedReplayKey,
+  getSharedReplayState
+}) => {
+  const localStores = /* @__PURE__ */ new Map();
+  return (key, createState, options = {}) => {
+    const normalizedKey = String(key ?? "").trim();
+    if (!normalizedKey) {
+      throw new Error("strategyApi.createStateController requires a state key");
+    }
+    const configKey = typeof options.configKey === "string" && options.configKey.trim() ? options.configKey.trim() : null;
+    const controllerKey = configKey ? `${normalizedKey}:${configKey}` : normalizedKey;
+    const createStore = () => ({
+      state: createState(),
+      lastTimestamp: null,
+      lastResult: void 0,
+      hasLastResult: false
+    });
+    const sharedAllowed = canUseSharedStrategyState({
+      env,
+      sharedReplayKey,
+      getSharedReplayState,
+      sharedReplay: options.sharedReplay !== false
+    });
+    const store = sharedAllowed ? getSharedReplayState(
+      `${sharedReplayKey}:state:${controllerKey}`,
+      createStore
+    ) : (() => {
+      const existing = localStores.get(controllerKey);
+      if (existing) {
+        return existing;
+      }
+      const created = createStore();
+      localStores.set(
+        controllerKey,
+        created
+      );
+      return created;
+    })();
+    const snapshot = () => options.snapshot ? options.snapshot(store.state) : store.state;
+    const clearCachedResult = () => {
+      store.lastResult = void 0;
+      store.hasLastResult = false;
+    };
+    return {
+      get: () => store.state,
+      set: (state) => {
+        store.state = state;
+        clearCachedResult();
+      },
+      update: (fn) => {
+        fn(store.state);
+        clearCachedResult();
+        return store.state;
+      },
+      oncePerTimestamp: (timestamp, compute) => {
+        if (!Number.isFinite(timestamp)) {
+          throw new Error(
+            `Strategy state controller "${controllerKey}" received non-finite timestamp ${String(timestamp)}`
+          );
+        }
+        if (store.lastTimestamp === timestamp && store.hasLastResult) {
+          return store.lastResult;
+        }
+        if (options.monotonic !== false && store.lastTimestamp != null && timestamp < store.lastTimestamp) {
+          throw new Error(
+            `Strategy state controller "${controllerKey}" received non-monotonic timestamp ${timestamp} after ${store.lastTimestamp}`
+          );
+        }
+        const result = compute(store.state);
+        store.lastTimestamp = timestamp;
+        store.lastResult = result;
+        store.hasLastResult = true;
+        return result;
+      },
+      snapshot,
+      hash: () => {
+        const currentSnapshot = snapshot();
+        return options.hash ? options.hash(currentSnapshot) : hashStableValue(currentSnapshot);
+      }
+    };
+  };
+};
 
 // src/utils/strategyHelpers/signalBuilders.ts
+var COMPACT_MTF_CANDLE_LIMIT = 3;
+var isRecordLike = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+var asFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var asStringOrNull = (value) => typeof value === "string" && value.trim().length > 0 ? value : null;
+var cloneSignalPayloadDataProperties = (value, seen = /* @__PURE__ */ new WeakMap()) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneSignalPayloadDataProperties(item, seen));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const objectValue = value;
+  const cached = seen.get(objectValue);
+  if (cached) {
+    return cached;
+  }
+  const clone = {};
+  seen.set(objectValue, clone);
+  for (const [key, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(objectValue)
+  )) {
+    if (!descriptor.enumerable || !("value" in descriptor)) {
+      continue;
+    }
+    clone[key] = cloneSignalPayloadDataProperties(descriptor.value, seen);
+  }
+  return clone;
+};
+var copyEnumerableDataPropertiesExcept = (value, excludedKeys) => {
+  const clone = {};
+  for (const [key, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(value)
+  )) {
+    if (excludedKeys.has(key) || !descriptor.enumerable || !("value" in descriptor)) {
+      continue;
+    }
+    clone[key] = descriptor.value;
+  }
+  return clone;
+};
+var cloneCompactArrayTail = (value, limit = COMPACT_MTF_CANDLE_LIMIT) => Array.isArray(value) ? cloneSignalPayloadDataProperties(value.slice(-limit)) : [];
+var cloneCompactMtfContext = (baseContext) => {
+  const descriptor = Object.getOwnPropertyDescriptor(baseContext, "mtf");
+  const mtf = descriptor && "get" in descriptor && typeof descriptor.get === "function" ? descriptor.get.call(baseContext) : descriptor && "value" in descriptor ? descriptor.value : void 0;
+  if (!isRecordLike(mtf)) {
+    return void 0;
+  }
+  const candles = isRecordLike(mtf.candles) ? mtf.candles : {};
+  const benchmarkCandles = isRecordLike(mtf.benchmarkCandles) ? mtf.benchmarkCandles : {};
+  return {
+    compact: true,
+    candles: {
+      m15: cloneCompactArrayTail(candles.m15),
+      h1: cloneCompactArrayTail(candles.h1),
+      h4: cloneCompactArrayTail(candles.h4),
+      d1: cloneCompactArrayTail(candles.d1)
+    },
+    benchmarkCandles: {
+      m15: cloneCompactArrayTail(benchmarkCandles.m15),
+      h1: cloneCompactArrayTail(benchmarkCandles.h1),
+      h4: cloneCompactArrayTail(benchmarkCandles.h4),
+      d1: cloneCompactArrayTail(benchmarkCandles.d1)
+    },
+    ...isRecordLike(mtf.summary) ? { summary: cloneSignalPayloadDataProperties(mtf.summary) } : {}
+  };
+};
+var toRankBucket = (value) => {
+  if (value == null) return "unknown";
+  if (value >= 95) return "extreme";
+  if (value >= 80) return "high";
+  if (value <= 20) return "low";
+  return "normal";
+};
+var toRangePositionBucket = (value) => {
+  if (value == null) return "unknown";
+  if (value <= 0.2) return "low";
+  if (value >= 0.8) return "high";
+  return "middle";
+};
+var toVolumeBucket = (value) => {
+  if (value == null) return "unknown";
+  if (value < 0.8) return "thin";
+  if (value < 1.5) return "normal";
+  if (value < 3) return "elevated";
+  return "spike";
+};
+var toVenueSpreadSeverity = (value) => {
+  if (value == null) return "unknown";
+  const abs = Math.abs(value);
+  if (abs >= 2) return "wide";
+  if (abs >= 1) return "elevated";
+  return "normal";
+};
+var toDirectionalAlignment = ({
+  direction,
+  bullValue,
+  bearValue,
+  value
+}) => {
+  if (!direction || !value) return null;
+  return direction === "LONG" ? value === bullValue : value === bearValue;
+};
+var toMtfAlignmentForDirection = ({
+  direction,
+  mtfAlignment
+}) => {
+  if (!direction || !mtfAlignment || mtfAlignment === "unknown") {
+    return "unknown";
+  }
+  if (mtfAlignment === "mixed") return "mixed";
+  if (mtfAlignment === "neutral") return "neutral";
+  if (direction === "LONG") {
+    return mtfAlignment === "aligned_bull" ? "aligned" : mtfAlignment === "aligned_bear" ? "against" : "unknown";
+  }
+  return mtfAlignment === "aligned_bear" ? "aligned" : mtfAlignment === "aligned_bull" ? "against" : "unknown";
+};
+var toRelativeStrengthBucket = ({
+  direction,
+  value
+}) => {
+  if (!direction || value == null) return "unknown";
+  const signed = direction === "LONG" ? value : -value;
+  if (signed <= -3) return "strong_against";
+  if (signed < -1) return "mild_against";
+  if (signed >= 3) return "strong_with";
+  if (signed > 1) return "mild_with";
+  return "neutral";
+};
+var toPressureBias = (value) => value == null ? "unknown" : value >= 0.55 ? "bull" : value <= 0.45 ? "bear" : "neutral";
+var toBiasAligned = ({
+  direction,
+  bias
+}) => direction == null || bias === "unknown" || bias === "neutral" ? null : direction === "LONG" ? bias === "bull" : bias === "bear";
+var clampScore = (value) => Math.max(0, Math.min(100, Math.round(value)));
+var scoreEvidence = (evidence) => {
+  const known = evidence.filter((item) => typeof item === "boolean");
+  if (known.length === 0) return null;
+  const positives = known.filter(Boolean).length;
+  const negatives = known.length - positives;
+  return clampScore(50 + positives * 12 - negatives * 15);
+};
+var averageScores = (scores) => {
+  const known = scores.filter(
+    (score) => typeof score === "number" && Number.isFinite(score)
+  );
+  if (known.length === 0) return null;
+  return clampScore(
+    known.reduce((sum, score) => sum + score, 0) / known.length
+  );
+};
+var pushWhen = (items, condition, item) => {
+  if (condition) {
+    items.push(item);
+  }
+};
+var buildBaseContextGateFeatures = ({
+  baseContext,
+  direction,
+  prices
+}) => {
+  const mtfSummary = baseContext.mtf?.summary;
+  const mtfAlignmentForDirection = toMtfAlignmentForDirection({
+    direction,
+    mtfAlignment: mtfSummary?.mtfAlignment ?? null
+  });
+  const volatility = baseContext.regime?.volatility;
+  const volatilityPercentiles = volatility?.percentiles;
+  const localRange = baseContext.structure?.localRange;
+  const liquidity = baseContext.structure?.liquidity;
+  const volume = baseContext.participation?.volume;
+  const delta = baseContext.participation?.delta;
+  const tradeFlow = baseContext.participation?.tradeFlow;
+  const volumeStructure = baseContext.participation?.volumeStructure;
+  const relative = baseContext.relative?.benchmark;
+  const marketBreadth = baseContext.relative?.marketBreadth;
+  const cmcGlobal = baseContext.relative?.cmcGlobal;
+  const cmcReferenceAssets = baseContext.relative?.cmcReferenceAssets;
+  const cmcExchangeLiquidity = baseContext.relative?.cmcExchangeLiquidity;
+  const cmcFearGreed = baseContext.relative?.cmcFearGreed;
+  const cmcIndexes = baseContext.relative?.cmcIndexes;
+  const targetVsBtc = baseContext.relative?.targetVsBtc;
+  const targetVsEth = baseContext.relative?.targetVsEth;
+  const btcAltRegime = baseContext.relative?.btcAltRegime;
+  const referenceTradeFlow = baseContext.relative?.referenceTradeFlow;
+  const execution = baseContext.relative?.execution;
+  const primaryReferenceSymbol = referenceTradeFlow?.primaryReferenceSymbol;
+  const primaryReferenceTradeFlow = primaryReferenceSymbol != null ? referenceTradeFlow?.tradeFlowBySymbol?.[primaryReferenceSymbol] : void 0;
+  const atrPctRankBucket = toRankBucket(
+    asFiniteNumberOrNull(volatilityPercentiles?.atrPctRank100)
+  );
+  const bbWidthRankBucket = toRankBucket(
+    asFiniteNumberOrNull(volatilityPercentiles?.bbWidthRank100)
+  );
+  const atrPctZScore = asFiniteNumberOrNull(volatility?.atrPctZScore);
+  const breakoutState = localRange?.breakoutState ?? "unknown";
+  const rangePosition20 = asFiniteNumberOrNull(localRange?.rangePosition20);
+  const rangePositionBucket = toRangePositionBucket(rangePosition20);
+  const breakoutWithDirection = toDirectionalAlignment({
+    direction,
+    bullValue: "above_high_level",
+    bearValue: "below_low_level",
+    value: breakoutState
+  });
+  const failedBreakoutForDirection = toDirectionalAlignment({
+    direction,
+    bullValue: "failed_low_breakout",
+    bearValue: "failed_high_breakout",
+    value: breakoutState
+  });
+  const liquiditySweepForDirection = !liquidity || direction == null ? null : direction === "LONG" ? liquidity?.sweepState === "swept_low" : liquidity?.sweepState === "swept_high";
+  const nearPointOfControl = baseContext.participation?.priceVolumeProfile?.nearPointOfControl ?? null;
+  const volumeRel20 = asFiniteNumberOrNull(volume?.volumeRel20);
+  const buyPressurePct = asFiniteNumberOrNull(delta?.buyPressurePct);
+  const tradeFlowBuyPressurePct = asFiniteNumberOrNull(
+    tradeFlow?.buyPressurePct
+  );
+  const referenceTradeFlowBuyPressurePct = asFiniteNumberOrNull(
+    primaryReferenceTradeFlow?.buyPressurePct
+  );
+  const deltaDivergenceVsPrice = asStringOrNull(delta?.deltaDivergenceVsPrice);
+  const deltaBias = deltaDivergenceVsPrice === "bullish" || deltaDivergenceVsPrice === "bearish" ? deltaDivergenceVsPrice === "bullish" ? "bull" : "bear" : toPressureBias(buyPressurePct);
+  const tradeFlowBias = tradeFlow?.stale ? "unknown" : toPressureBias(tradeFlowBuyPressurePct);
+  const referenceTradeFlowBias = primaryReferenceTradeFlow?.stale ? "unknown" : toPressureBias(referenceTradeFlowBuyPressurePct);
+  const deltaAligned = toBiasAligned({ direction, bias: deltaBias });
+  const tradeFlowAligned = toBiasAligned({
+    direction,
+    bias: tradeFlowBias
+  });
+  const referenceTradeFlowAligned = toBiasAligned({
+    direction,
+    bias: referenceTradeFlowBias
+  });
+  const benchmarkTrendAlignment = relative?.trendAlignment ?? "unknown";
+  const relativeStrength1h = asFiniteNumberOrNull(relative?.relativeStrength1h);
+  const relativeStrengthBucket = toRelativeStrengthBucket({
+    direction,
+    value: relativeStrength1h
+  });
+  const benchmarkAligned = benchmarkTrendAlignment === "against_benchmark" ? false : toDirectionalAlignment({
+    direction,
+    bullValue: "aligned_bull",
+    bearValue: "aligned_bear",
+    value: benchmarkTrendAlignment
+  });
+  const totalUpVolumeShare = asFiniteNumberOrNull(
+    volumeStructure?.totalUpVolumeShare
+  );
+  const totalDownVolumeShare = asFiniteNumberOrNull(
+    volumeStructure?.totalDownVolumeShare
+  );
+  const directionalVolumeShare = direction === "LONG" ? totalUpVolumeShare : direction === "SHORT" ? totalDownVolumeShare : null;
+  const volumeStructureAligned = directionalVolumeShare == null ? null : directionalVolumeShare >= 0.5;
+  const marketBreadthReturn = asFiniteNumberOrNull(
+    marketBreadth?.equalWeightedReturn
+  );
+  const marketBreadthAligned = direction == null || marketBreadthReturn == null || marketBreadth?.stale ? null : direction === "LONG" ? marketBreadthReturn >= 0 : marketBreadthReturn <= 0;
+  const cmcAltLiquidityRegime = cmcGlobal?.altLiquidityRegime ?? "unknown";
+  const cmcAltLiquidityStale = typeof cmcGlobal?.stale === "boolean" ? cmcGlobal.stale : null;
+  const cmcAltLiquidityAligned = direction == null || cmcAltLiquidityStale === true || cmcAltLiquidityRegime === "unknown" || cmcAltLiquidityRegime === "neutral" ? null : direction === "LONG" ? cmcAltLiquidityRegime === "alt_friendly" : cmcAltLiquidityRegime === "btc_favored" || cmcAltLiquidityRegime === "risk_off";
+  const cmcEthBtcReferenceRegime = cmcReferenceAssets?.referenceLiquidityRegime ?? "unknown";
+  const cmcEthBtcStale = typeof cmcReferenceAssets?.stale === "boolean" ? cmcReferenceAssets.stale : null;
+  const cmcEthBtcAligned = direction == null || cmcEthBtcStale === true || cmcEthBtcReferenceRegime === "unknown" || cmcEthBtcReferenceRegime === "balanced" ? null : direction === "LONG" ? cmcEthBtcReferenceRegime === "eth_led" : cmcEthBtcReferenceRegime === "btc_led" || cmcEthBtcReferenceRegime === "thin";
+  const cmcExchangeLiquidityRegime = cmcExchangeLiquidity?.liquidityRegime ?? "unknown";
+  const cmcExchangeLiquidityStale = typeof cmcExchangeLiquidity?.stale === "boolean" ? cmcExchangeLiquidity.stale : null;
+  const cmcExchangeLiquidityVolumeChange24hPct = asFiniteNumberOrNull(
+    cmcExchangeLiquidity?.totalVolumeChange24hPct
+  );
+  const cmcExchangeLiquidityAligned = cmcExchangeLiquidityStale === true || cmcExchangeLiquidityRegime === "unknown" ? null : cmcExchangeLiquidityRegime === "expanding" || cmcExchangeLiquidityRegime === "balanced" || cmcExchangeLiquidityRegime === "binance_led";
+  const cmcFearGreedRegime = cmcFearGreed?.sentimentRegime ?? "unknown";
+  const cmcFearGreedStale = typeof cmcFearGreed?.stale === "boolean" ? cmcFearGreed.stale : null;
+  const cmcFearGreedValue = asFiniteNumberOrNull(cmcFearGreed?.value);
+  const cmcFearGreedValueChange24h = asFiniteNumberOrNull(
+    cmcFearGreed?.valueChange24h
+  );
+  const cmcFearGreedAligned = direction == null || cmcFearGreedStale === true || cmcFearGreedRegime === "unknown" || cmcFearGreedRegime === "neutral" || cmcFearGreedRegime === "euphoric" ? null : direction === "LONG" ? cmcFearGreedRegime === "risk_on" : cmcFearGreedRegime === "risk_off" || cmcFearGreedRegime === "capitulation";
+  const cmcIndexRegime = cmcIndexes?.indexRegime ?? "unknown";
+  const cmcIndexStale = typeof cmcIndexes?.stale === "boolean" ? cmcIndexes.stale : null;
+  const cmc20ToCmc100RatioChange24hPct = asFiniteNumberOrNull(
+    cmcIndexes?.cmc20ToCmc100RatioChange24hPct
+  );
+  const cmcIndexAligned = direction == null || cmcIndexStale === true || cmcIndexRegime === "unknown" || cmcIndexRegime === "balanced" ? null : direction === "LONG" ? cmcIndexRegime === "top20_led" || cmcIndexRegime === "large_cap_led" : cmcIndexRegime === "risk_off";
+  const targetVsBtcRatioReturn24h = asFiniteNumberOrNull(
+    targetVsBtc?.ratioReturn24h
+  );
+  const targetVsBtcAlpha24h = asFiniteNumberOrNull(targetVsBtc?.alphaVsBtc24h);
+  const targetVsBtcBeta20 = asFiniteNumberOrNull(targetVsBtc?.betaToBtc20);
+  const targetVsBtcCorrelation20 = asFiniteNumberOrNull(
+    targetVsBtc?.correlationToBtc20
+  );
+  const targetVsBtcRatioTrend = targetVsBtc?.ratioTrend ?? "unknown";
+  const targetVsBtcDirectionValue = targetVsBtcRatioReturn24h ?? targetVsBtcAlpha24h;
+  const targetVsBtcAligned = direction == null || targetVsBtcDirectionValue == null ? null : direction === "LONG" ? targetVsBtcDirectionValue >= 0 : targetVsBtcDirectionValue <= 0;
+  const targetVsEthRatioReturn24h = asFiniteNumberOrNull(
+    targetVsEth?.ratioReturn24h
+  );
+  const targetVsEthAlpha24h = asFiniteNumberOrNull(targetVsEth?.alphaVsEth24h);
+  const targetVsEthBeta20 = asFiniteNumberOrNull(targetVsEth?.betaToEth20);
+  const targetVsEthCorrelation20 = asFiniteNumberOrNull(
+    targetVsEth?.correlationToEth20
+  );
+  const targetVsEthRatioTrend = targetVsEth?.ratioTrend ?? "unknown";
+  const targetVsEthDirectionValue = targetVsEthRatioReturn24h ?? targetVsEthAlpha24h;
+  const targetVsEthAligned = direction == null || targetVsEthDirectionValue == null ? null : direction === "LONG" ? targetVsEthDirectionValue >= 0 : targetVsEthDirectionValue <= 0;
+  const btcAltRegimeValue = btcAltRegime?.regime ?? "unknown";
+  const btcAltRegimeStale = typeof btcAltRegime?.stale === "boolean" ? btcAltRegime.stale : null;
+  const btcAltRegimeAligned = direction == null || btcAltRegimeStale === true || btcAltRegimeValue === "unknown" || btcAltRegimeValue === "neutral" || btcAltRegimeValue === "mixed" ? null : direction === "LONG" ? btcAltRegimeValue === "alt_lead" || btcAltRegimeValue === "risk_on" : btcAltRegimeValue === "btc_lead" || btcAltRegimeValue === "risk_off";
+  const btcVsAltReturn24h = asFiniteNumberOrNull(
+    btcAltRegime?.btcVsAltReturn24h
+  );
+  const btcTurnoverShare24h = asFiniteNumberOrNull(
+    btcAltRegime?.btcTurnoverShare24h
+  );
+  const venueSpreadZScore = asFiniteNumberOrNull(execution?.venueSpreadZScore);
+  const venueSpreadSeverity = toVenueSpreadSeverity(venueSpreadZScore);
+  const higherTimeframeConflict = mtfAlignmentForDirection === "unknown" ? null : mtfAlignmentForDirection === "against" || mtfAlignmentForDirection === "mixed";
+  const extremeVolatilityRisk = Math.abs(atrPctZScore ?? 0) >= 2 || atrPctRankBucket === "extreme";
+  const compressionBreakoutSupport = (volatility?.state === "compressed" || bbWidthRankBucket === "low") && breakoutState !== "inside_range" && breakoutState !== "unknown";
+  const benchmarkConflict = benchmarkAligned === false || relativeStrengthBucket.endsWith("_against");
+  const derivativesSummary = baseContext.derivatives?.summary;
+  const derivativesDirectionAligned = typeof derivativesSummary?.directionAligned === "boolean" ? derivativesSummary.directionAligned : null;
+  const derivativesRiskFlags = Array.isArray(derivativesSummary?.riskFlags) ? derivativesSummary.riskFlags : [];
+  const derivativesCrowdedForDirection = direction === "LONG" ? derivativesRiskFlags.includes("crowded_long") : direction === "SHORT" ? derivativesRiskFlags.includes("crowded_short") : false;
+  const derivativesCrowdedAny = derivativesRiskFlags.includes("crowded_long") || derivativesRiskFlags.includes("crowded_short");
+  const atr = asFiniteNumberOrNull(baseContext.raw?.volatility?.atr);
+  const currentPrice = asFiniteNumberOrNull(prices?.currentPrice);
+  const takeProfitPrice = asFiniteNumberOrNull(prices?.takeProfitPrice);
+  const stopLossPrice = asFiniteNumberOrNull(prices?.stopLossPrice);
+  const stopDistanceAtr = direction == null || atr == null || atr <= 0 || currentPrice == null || stopLossPrice == null ? null : direction === "LONG" ? (currentPrice - stopLossPrice) / atr : (stopLossPrice - currentPrice) / atr;
+  const tpDistanceAtr = direction == null || atr == null || atr <= 0 || currentPrice == null || takeProfitPrice == null ? null : direction === "LONG" ? (takeProfitPrice - currentPrice) / atr : (currentPrice - takeProfitPrice) / atr;
+  const entryLocation = breakoutWithDirection === true ? direction === "SHORT" ? "breakdown" : "breakout" : rangePosition20 == null ? "unknown" : rangePosition20 <= 0.25 ? "near_support" : rangePosition20 >= 0.75 ? "near_resistance" : "mid_range";
+  const confirmations = [];
+  pushWhen(
+    confirmations,
+    mtfAlignmentForDirection === "aligned",
+    "mtf_aligned"
+  );
+  pushWhen(confirmations, (volumeRel20 ?? 0) >= 1.5, "volume_expansion");
+  pushWhen(confirmations, deltaAligned === true, "delta_aligned");
+  pushWhen(confirmations, tradeFlowAligned === true, "trade_flow_aligned");
+  pushWhen(
+    confirmations,
+    referenceTradeFlowAligned === true,
+    "reference_trade_flow_aligned"
+  );
+  pushWhen(
+    confirmations,
+    marketBreadthAligned === true,
+    "market_breadth_aligned"
+  );
+  pushWhen(
+    confirmations,
+    cmcAltLiquidityAligned === true,
+    "cmc_alt_liquidity_aligned"
+  );
+  pushWhen(confirmations, cmcEthBtcAligned === true, "cmc_eth_btc_aligned");
+  pushWhen(
+    confirmations,
+    cmcExchangeLiquidityAligned === true,
+    "cmc_exchange_liquidity_aligned"
+  );
+  pushWhen(
+    confirmations,
+    cmcFearGreedAligned === true,
+    "cmc_fear_greed_aligned"
+  );
+  pushWhen(confirmations, cmcIndexAligned === true, "cmc_index_aligned");
+  pushWhen(confirmations, targetVsBtcAligned === true, "target_vs_btc_aligned");
+  pushWhen(confirmations, targetVsEthAligned === true, "target_vs_eth_aligned");
+  pushWhen(
+    confirmations,
+    btcAltRegimeAligned === true,
+    "btc_alt_regime_aligned"
+  );
+  pushWhen(confirmations, benchmarkAligned === true, "benchmark_aligned");
+  pushWhen(confirmations, breakoutWithDirection === true, "breakout_confirmed");
+  pushWhen(
+    confirmations,
+    liquiditySweepForDirection === true,
+    "liquidity_sweep_aligned"
+  );
+  pushWhen(
+    confirmations,
+    derivativesDirectionAligned === true,
+    "derivatives_aligned"
+  );
+  const conflicts = [];
+  pushWhen(conflicts, mtfAlignmentForDirection === "against", "mtf_against");
+  pushWhen(conflicts, mtfAlignmentForDirection === "mixed", "mtf_mixed");
+  pushWhen(conflicts, benchmarkAligned === false, "benchmark_against");
+  pushWhen(
+    conflicts,
+    relativeStrengthBucket.endsWith("_against"),
+    "relative_strength_against"
+  );
+  pushWhen(conflicts, marketBreadthAligned === false, "market_breadth_against");
+  pushWhen(
+    conflicts,
+    cmcAltLiquidityAligned === false,
+    "cmc_alt_liquidity_against"
+  );
+  pushWhen(conflicts, cmcEthBtcAligned === false, "cmc_eth_btc_against");
+  pushWhen(
+    conflicts,
+    cmcExchangeLiquidityAligned === false,
+    "cmc_exchange_liquidity_against"
+  );
+  pushWhen(conflicts, cmcFearGreedAligned === false, "cmc_fear_greed_against");
+  pushWhen(conflicts, cmcIndexAligned === false, "cmc_index_against");
+  pushWhen(conflicts, targetVsBtcAligned === false, "target_vs_btc_against");
+  pushWhen(conflicts, targetVsEthAligned === false, "target_vs_eth_against");
+  pushWhen(conflicts, btcAltRegimeAligned === false, "btc_alt_regime_against");
+  pushWhen(conflicts, deltaAligned === false, "delta_against");
+  pushWhen(conflicts, tradeFlowAligned === false, "trade_flow_against");
+  pushWhen(
+    conflicts,
+    referenceTradeFlowAligned === false,
+    "reference_trade_flow_against"
+  );
+  pushWhen(conflicts, failedBreakoutForDirection === true, "failed_breakout");
+  pushWhen(conflicts, extremeVolatilityRisk, "extreme_volatility");
+  pushWhen(conflicts, venueSpreadSeverity === "wide", "wide_spread");
+  pushWhen(
+    conflicts,
+    derivativesDirectionAligned === false,
+    "derivatives_against"
+  );
+  pushWhen(conflicts, derivativesCrowdedForDirection, "derivatives_crowded");
+  const scores = {
+    structure: scoreEvidence([
+      breakoutWithDirection,
+      failedBreakoutForDirection == null ? null : failedBreakoutForDirection === false,
+      liquiditySweepForDirection,
+      nearPointOfControl
+    ]),
+    participation: scoreEvidence([
+      volumeRel20 == null ? null : volumeRel20 >= 1.5,
+      deltaAligned,
+      tradeFlowAligned,
+      referenceTradeFlowAligned,
+      volumeStructureAligned
+    ]),
+    relative: scoreEvidence([
+      benchmarkAligned,
+      marketBreadthAligned,
+      cmcAltLiquidityAligned,
+      cmcEthBtcAligned,
+      cmcFearGreedAligned,
+      cmcIndexAligned,
+      targetVsBtcAligned,
+      targetVsEthAligned,
+      btcAltRegimeAligned,
+      relativeStrengthBucket === "unknown" ? null : !relativeStrengthBucket.endsWith("_against")
+    ]),
+    mtf: scoreEvidence([
+      mtfAlignmentForDirection === "unknown" ? null : mtfAlignmentForDirection === "aligned"
+    ]),
+    execution: scoreEvidence([
+      venueSpreadSeverity === "unknown" ? null : venueSpreadSeverity !== "wide",
+      cmcExchangeLiquidityAligned
+    ]),
+    derivatives: scoreEvidence([derivativesDirectionAligned]),
+    totalContext: null
+  };
+  scores.totalContext = averageScores([
+    scores.structure,
+    scores.participation,
+    scores.relative,
+    scores.mtf,
+    scores.execution,
+    scores.derivatives
+  ]);
+  const volatilityRisk = extremeVolatilityRisk ? "high" : atrPctRankBucket === "high" || bbWidthRankBucket === "high" ? "medium" : atrPctRankBucket === "unknown" && bbWidthRankBucket === "unknown" ? "unknown" : "low";
+  const liquidityRisk = venueSpreadSeverity === "wide" || cmcExchangeLiquidityAligned === false ? "high" : venueSpreadSeverity === "elevated" ? "medium" : venueSpreadSeverity === "unknown" && cmcExchangeLiquidityAligned == null ? "unknown" : "low";
+  const regimeRisk = higherTimeframeConflict === true ? "high" : mtfAlignmentForDirection === "neutral" || mtfAlignmentForDirection === "unknown" ? "medium" : "low";
+  const crowdingRisk = derivativesCrowdedForDirection ? "high" : derivativesCrowdedAny ? "medium" : derivativesSummary ? "low" : "unknown";
+  const chaseRisk = direction === "LONG" && rangePositionBucket === "high" && breakoutWithDirection !== true || direction === "SHORT" && rangePositionBucket === "low" && breakoutWithDirection !== true ? "high" : tpDistanceAtr != null && tpDistanceAtr < 1 || rangePositionBucket === "high" || rangePositionBucket === "low" ? "medium" : rangePositionBucket === "unknown" ? "unknown" : "low";
+  const primaryIssue = derivativesCrowdedForDirection ? "crowded_derivatives" : higherTimeframeConflict === true ? "mtf_conflict" : venueSpreadSeverity === "wide" || cmcExchangeLiquidityAligned === false ? "bad_execution" : extremeVolatilityRisk ? "extreme_volatility" : benchmarkConflict || marketBreadthAligned === false || cmcAltLiquidityAligned === false || cmcEthBtcAligned === false || cmcFearGreedAligned === false || cmcIndexAligned === false || targetVsBtcAligned === false || targetVsEthAligned === false || btcAltRegimeAligned === false ? "market_context_against" : (scores.participation ?? 100) < 45 ? "weak_participation" : (scores.structure ?? 100) < 45 ? "weak_structure" : "none";
+  const needsExtraConfirmation = conflicts.length > 0 || scores.totalContext != null && scores.totalContext < 60;
+  const approveBias = conflicts.length >= 3 || primaryIssue === "crowded_derivatives" || primaryIssue === "bad_execution" || primaryIssue === "mtf_conflict" ? "reject" : confirmations.length >= 3 && conflicts.length === 0 ? "support" : "neutral";
+  const maxReasonableQuality = approveBias === "reject" ? 2 : conflicts.length >= 2 || needsExtraConfirmation ? 3 : approveBias === "support" ? 5 : 4;
+  return {
+    direction,
+    setup: {
+      riskRatio: asFiniteNumberOrNull(prices?.riskRatio),
+      rewardToVolatility: tpDistanceAtr,
+      stopDistanceAtr,
+      tpDistanceAtr,
+      entryLocation
+    },
+    scores,
+    confirmations: {
+      count: confirmations.length,
+      items: confirmations
+    },
+    conflicts: {
+      count: conflicts.length,
+      items: conflicts
+    },
+    risk: {
+      regimeRisk,
+      liquidityRisk,
+      volatilityRisk,
+      crowdingRisk,
+      chaseRisk
+    },
+    decisionHints: {
+      approveBias,
+      maxReasonableQuality,
+      needsExtraConfirmation,
+      primaryIssue
+    },
+    mtf: {
+      alignmentForDirection: mtfAlignmentForDirection,
+      higherTimeframeConflict,
+      h1TrendBias: mtfSummary?.h1TrendBias ?? "unknown",
+      h4TrendBias: mtfSummary?.h4TrendBias ?? "unknown",
+      d1TrendBias: mtfSummary?.d1TrendBias ?? "unknown",
+      h1RangePosition: asFiniteNumberOrNull(mtfSummary?.h1RangePosition),
+      h4VolatilityState: mtfSummary?.h4VolatilityState ?? "unknown"
+    },
+    volatility: {
+      state: volatility?.state ?? "unknown",
+      atrPctZScore,
+      atrPctRankBucket,
+      bbWidthRankBucket,
+      extremeVolatilityRisk,
+      compressionBreakoutSupport
+    },
+    structure: {
+      breakoutState,
+      rangePositionBucket,
+      breakoutWithDirection,
+      failedBreakoutForDirection,
+      liquiditySweepForDirection,
+      nearPointOfControl
+    },
+    participation: {
+      volumeRel20,
+      volumeBucket: toVolumeBucket(volumeRel20),
+      deltaBias,
+      deltaAligned,
+      tradeFlowBuyPressurePct,
+      tradeFlowAligned,
+      referenceTradeFlowBuyPressurePct,
+      referenceTradeFlowAligned,
+      volumeStructureAligned
+    },
+    relative: {
+      benchmarkTrendAlignment,
+      benchmarkAligned,
+      benchmarkConflict,
+      relativeStrength1h,
+      relativeStrengthBucket,
+      marketBreadthReturn,
+      marketBreadthAligned,
+      marketBreadthStale: typeof marketBreadth?.stale === "boolean" ? marketBreadth.stale : null,
+      cmcAltLiquidityRegime,
+      cmcAltLiquidityAligned,
+      cmcAltLiquidityStale,
+      cmcEthBtcReferenceRegime,
+      cmcEthBtcAligned,
+      cmcEthBtcStale,
+      cmcExchangeLiquidityRegime,
+      cmcExchangeLiquidityAligned,
+      cmcExchangeLiquidityStale,
+      cmcExchangeLiquidityVolumeChange24hPct,
+      cmcFearGreedValue,
+      cmcFearGreedValueChange24h,
+      cmcFearGreedRegime,
+      cmcFearGreedAligned,
+      cmcFearGreedStale,
+      cmcIndexRegime,
+      cmcIndexAligned,
+      cmcIndexStale,
+      cmc20ToCmc100RatioChange24hPct,
+      targetVsBtcRatioReturn24h,
+      targetVsBtcAlpha24h,
+      targetVsBtcBeta20,
+      targetVsBtcCorrelation20,
+      targetVsBtcRatioTrend,
+      targetVsBtcAligned,
+      targetVsEthRatioReturn24h,
+      targetVsEthAlpha24h,
+      targetVsEthBeta20,
+      targetVsEthCorrelation20,
+      targetVsEthRatioTrend,
+      targetVsEthAligned,
+      btcAltRegime: btcAltRegimeValue,
+      btcAltRegimeAligned,
+      btcAltRegimeStale,
+      btcVsAltReturn24h,
+      btcTurnoverShare24h
+    },
+    execution: {
+      venueSpreadZScore,
+      venueSpreadSeverity
+    }
+  };
+};
+var cloneBaseContextData = (baseContext, direction, prices) => {
+  const clone = cloneSignalPayloadDataProperties(
+    baseContext
+  );
+  const compactMtf = cloneCompactMtfContext(baseContext);
+  if (compactMtf) {
+    clone.mtf = compactMtf;
+  }
+  clone.gateFeatures = buildBaseContextGateFeatures({
+    baseContext: clone,
+    direction,
+    prices
+  });
+  return clone;
+};
+var normalizeAdditionalIndicatorsBaseContext = (additionalIndicators, direction, prices) => {
+  if (!additionalIndicators || typeof additionalIndicators !== "object" || Array.isArray(additionalIndicators)) {
+    return additionalIndicators;
+  }
+  const baseContext = additionalIndicators.baseContext;
+  if (baseContext == null) {
+    return additionalIndicators;
+  }
+  return {
+    ...additionalIndicators,
+    baseContext: cloneBaseContextData(baseContext, direction, prices)
+  };
+};
+var refreshSignalBaseContextGateFeatures = (signal) => {
+  const baseContext = signal.additionalIndicators?.baseContext;
+  if (!baseContext || typeof baseContext !== "object" || Array.isArray(baseContext)) {
+    return signal;
+  }
+  signal.additionalIndicators = {
+    ...signal.additionalIndicators ?? {},
+    baseContext: {
+      ...baseContext,
+      gateFeatures: buildBaseContextGateFeatures({
+        baseContext,
+        direction: signal.direction,
+        prices: signal.prices
+      })
+    }
+  };
+  return signal;
+};
 var mapAiRuntimeFromConfig = (config, overrides = {}) => ({
   enabled: Boolean(config.AI_ENABLED ?? true),
   mode: config.AI_MODE ?? "llm",
@@ -228,19 +1205,36 @@ var buildStrategySignal = ({
   indicators = {},
   additionalIndicators,
   isConfigFromBacktest
-}) => ({
-  signalId,
-  strategy,
-  symbol,
-  interval,
-  direction,
-  timestamp,
-  figures,
-  prices,
-  indicators,
-  additionalIndicators,
-  isConfigFromBacktest
-});
+}) => {
+  const indicatorsRecord = indicators && typeof indicators === "object" ? indicators : {};
+  const baseContext = indicatorsRecord.baseContext;
+  const normalizedIndicators = baseContext == null ? indicators : copyEnumerableDataPropertiesExcept(
+    indicatorsRecord,
+    /* @__PURE__ */ new Set(["baseContext"])
+  );
+  const mergedAdditionalIndicators = baseContext == null ? additionalIndicators : {
+    ...additionalIndicators ?? {},
+    baseContext: additionalIndicators?.baseContext ?? baseContext
+  };
+  const normalizedAdditionalIndicators = normalizeAdditionalIndicatorsBaseContext(
+    mergedAdditionalIndicators,
+    direction,
+    prices
+  );
+  return {
+    signalId,
+    strategy,
+    symbol,
+    interval,
+    direction,
+    timestamp,
+    figures,
+    prices,
+    indicators: normalizedIndicators,
+    additionalIndicators: normalizedAdditionalIndicators,
+    isConfigFromBacktest
+  };
+};
 var buildEntrySignalDecision = ({
   code,
   entryContext,
@@ -295,33 +1289,98 @@ var createStrategyAPI = ({
   connector,
   cachedData,
   indicatorsState,
-  preloadStart,
-  backtestPriceMode,
-  isConfigFromBacktest
+  isConfigFromBacktest,
+  sharedReplayKey,
+  getSharedReplayState
 }) => {
-  const getCurrentPosition = () => connector.getPosition(symbol);
-  const isPositionExists = async () => {
-    const position = await getCurrentPosition();
-    return Boolean(
-      position && typeof position.qty === "number" && position.qty > 0
-    );
+  const isBacktestEnv = env === "BACKTEST";
+  const barCache = {
+    timestamp: null,
+    currentPosition: void 0
   };
-  const getMarketData = async (params = {}) => {
-    const resolvedPreloadStart = params.preloadStart ?? preloadStart;
-    if (typeof resolvedPreloadStart !== "number") {
-      throw new Error("strategyApi.getMarketData requires preloadStart");
+  let currentIndicatorsContextCache;
+  const getCurrentBarTimestamp = () => {
+    const lastCandle = cachedData[cachedData.length - 1];
+    return typeof lastCandle?.timestamp === "number" ? lastCandle.timestamp : null;
+  };
+  const getCurrentIndicatorsCacheKey = () => {
+    const lastCandle = cachedData[cachedData.length - 1];
+    if (!lastCandle) {
+      return "empty";
     }
-    const snapshot = await getStrategyMarketSnapshot({
-      env,
-      connector,
-      symbol,
-      interval,
-      cachedData,
-      preloadStart: resolvedPreloadStart,
-      backtestPriceMode: params.backtestPriceMode ?? backtestPriceMode
-    });
-    return snapshot;
+    return [
+      cachedData.length,
+      lastCandle.timestamp,
+      lastCandle.open,
+      lastCandle.high,
+      lastCandle.low,
+      lastCandle.close,
+      lastCandle.volume,
+      lastCandle.turnover
+    ].join(":");
+  };
+  const ensureBarCache = () => {
+    if (!isBacktestEnv) {
+      return;
+    }
+    const currentBarTimestamp = getCurrentBarTimestamp();
+    if (barCache.timestamp === currentBarTimestamp) {
+      return;
+    }
+    barCache.timestamp = currentBarTimestamp;
+    barCache.currentPosition = void 0;
+    currentIndicatorsContextCache = void 0;
+  };
+  const getCurrentPosition = () => {
+    if (!isBacktestEnv) {
+      return connector.getPosition(symbol);
+    }
+    ensureBarCache();
+    if (!barCache.currentPosition) {
+      barCache.currentPosition = connector.getPosition(symbol);
+    }
+    return barCache.currentPosition;
+  };
+  const createStateController = createStrategyStateControllerFactory({
+    env,
+    sharedReplayKey,
+    getSharedReplayState
+  });
+  const getBaseContextFromIndicators = (indicators) => isRecordLike(indicators) && isRecordLike(indicators.baseContext) ? indicators.baseContext : void 0;
+  const getCurrentIndicatorsContext = () => {
+    ensureBarCache();
+    const cacheKey = getCurrentIndicatorsCacheKey();
+    if (currentIndicatorsContextCache?.key === cacheKey) {
+      return currentIndicatorsContextCache.context;
+    }
+    indicatorsState?.onBar();
+    const indicators = indicatorsState?.snapshot();
+    const baseContext = getBaseContextFromIndicators(indicators);
+    const context = {
+      indicators,
+      ...baseContext ? { baseContext } : {}
+    };
+    currentIndicatorsContextCache = {
+      key: cacheKey,
+      context
+    };
+    return context;
+  };
+  const getBaseContext = () => getCurrentIndicatorsContext().baseContext;
+  const resolveDecisionPriceContext = () => {
+    const candle = cachedData[cachedData.length - 1];
+    if (!candle || !isFiniteNumber(candle.timestamp) || !isFiniteNumber(candle.close)) {
+      throw new Error(
+        "strategyApi.getDecisionPriceContext requires a current closed candle"
+      );
+    }
+    return {
+      timestamp: candle.timestamp,
+      currentPrice: candle.close,
+      candle
+    };
   };
+  const getDecisionPriceContext = async () => resolveDecisionPriceContext();
   return {
     skip: (code) => ({ kind: "skip", code }),
     entry: async ({
@@ -334,9 +1393,9 @@ var createStrategyAPI = ({
       orderPlan,
       runtime
     }) => {
-      const marketData = await getMarketData();
-      const currentPrice = marketData.currentPrice;
-      const timestamp = marketData.timestamp;
+      const priceContext = resolveDecisionPriceContext();
+      const currentPrice = priceContext.currentPrice;
+      const timestamp = priceContext.timestamp;
       const stopLossPrice = orderPlan.stopLossPrice;
       const takeProfitPrice = resolveTakeProfitPrice({
         direction,
@@ -378,19 +1437,14 @@ var createStrategyAPI = ({
         runtime
       });
     },
-    exit: async ({
-      code,
-      direction,
-      price,
-      timestamp
-    }) => {
-      const marketData = await getMarketData();
+    exit: async ({ code, direction }) => {
+      const priceContext = resolveDecisionPriceContext();
       return {
         kind: "exit",
         code: code ?? toDefaultExitCode(String(strategy), direction),
         closePlan: {
-          price: price ?? marketData.currentPrice,
-          timestamp: timestamp ?? marketData.timestamp,
+          price: priceContext.currentPrice,
+          timestamp: priceContext.timestamp,
           direction
         }
       };
@@ -400,18 +1454,86 @@ var createStrategyAPI = ({
       code: code ?? toDefaultProtectCode(String(strategy), protectPlan.direction),
       protectPlan
     }),
-    getMarketData,
-    nextIndicators: (candle, btcCandle) => indicatorsState?.next(candle, btcCandle),
+    getCurrentIndicatorsContext,
+    getBaseContext,
+    getDecisionPriceContext,
     getCurrentPosition,
-    isCurrentPositionExists: isPositionExists,
     getDirectionalTpSlPrices: (params) => getDirectionalTpSlPrices(params),
     createLastTradeController: (params) => createLastTradeController({
       env,
       ...params
-    })
+    }),
+    createStateController
   };
 };
+
+// src/utils/strategyHelpers/sharedReplay.ts
+var sharedStrategyReplayStates = /* @__PURE__ */ new Map();
+var processLike = globalThis.process;
+var SHARED_REPLAY_PROFILE = processLike?.env?.TRADEJS_STRATEGY_REPLAY_PROFILE === "1";
+var sharedReplayProfile = {
+  requests: 0,
+  hits: 0,
+  creates: 0,
+  uncached: 0,
+  releases: 0,
+  releasedEntries: 0
+};
+if (SHARED_REPLAY_PROFILE) {
+  processLike?.once?.("exit", () => {
+    console.log(
+      JSON.stringify(
+        {
+          strategyReplayProfile: {
+            ...sharedReplayProfile,
+            retainedEntries: sharedStrategyReplayStates.size
+          }
+        },
+        null,
+        2
+      )
+    );
+  });
+}
+var getSharedStrategyReplayState = (key, createState) => {
+  if (SHARED_REPLAY_PROFILE) {
+    sharedReplayProfile.requests += 1;
+  }
+  if (!key) {
+    if (SHARED_REPLAY_PROFILE) {
+      sharedReplayProfile.uncached += 1;
+    }
+    return createState();
+  }
+  const existing = sharedStrategyReplayStates.get(key);
+  if (existing) {
+    if (SHARED_REPLAY_PROFILE) {
+      sharedReplayProfile.hits += 1;
+    }
+    return existing;
+  }
+  const state = createState();
+  sharedStrategyReplayStates.set(key, state);
+  if (SHARED_REPLAY_PROFILE) {
+    sharedReplayProfile.creates += 1;
+  }
+  return state;
+};
+var releaseStrategyReplayCache = (keyPrefix) => {
+  if (SHARED_REPLAY_PROFILE) {
+    sharedReplayProfile.releases += 1;
+  }
+  for (const key of sharedStrategyReplayStates.keys()) {
+    if (key === keyPrefix || key.startsWith(`${keyPrefix}:`)) {
+      sharedStrategyReplayStates.delete(key);
+      if (SHARED_REPLAY_PROFILE) {
+        sharedReplayProfile.releasedEntries += 1;
+      }
+    }
+  }
+};
 export {
+  buildBaseContextGateFeatures,
   buildDefaultIndicatorPeriods,
   buildEntrySignalDecision,
   buildStrategySignal,
@@ -420,7 +1542,12 @@ export {
   createStrategyAPI,
   createStrategyIndicatorsState,
   getDirectionalTpSlPrices,
+  getSharedStrategyReplayState,
   getStrategyMarketSnapshot,
   mapAiRuntimeFromConfig,
-  mapMlRuntimeFromConfig
+  mapMlRuntimeFromConfig,
+  refreshSignalBaseContextGateFeatures,
+  releaseStrategyIndicatorsReplayCache,
+  releaseStrategyReplayCache,
+  resolveBacktestExecutionPrice
 };