@tradejs/node 2.0.5 → 2.0.7

package/dist/strategies.js

@@ -5537,6 +5537,7 @@ var require_lodash = __commonJS({
 // src/strategies.ts
 var strategies_exports = {};
 __export(strategies_exports, {
+  BINANCE_BREADTH_UNIVERSE_KEYS: () => BINANCE_BREADTH_UNIVERSE_KEYS,
   DEFAULT_AI_MODEL: () => DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS: () => MAX_AI_SERIES_POINTS,
   askAI: () => askAI,
@@ -5544,6 +5545,7 @@ __export(strategies_exports, {
   buildAiPayload: () => buildAiPayload,
   buildAiPrompts: () => buildAiPrompts,
   buildAiSystemPrompt: () => buildAiSystemPrompt,
+  buildBinanceBreadthUniverseSnapshot: () => buildBinanceBreadthUniverseSnapshot,
   buildCompactAiIndicatorsSnapshot: () => buildCompactAiIndicatorsSnapshot,
   closeOppositePositionsBeforeOpen: () => closeOppositePositionsBeforeOpen,
   createCloseAllOnGlobalProfitBeforeSignalsHook: () => createCloseAllOnGlobalProfitBeforeSignalsHook,
@@ -5561,8 +5563,12 @@ __export(strategies_exports, {
   ensureStrategyPluginsLoaded: () => ensureStrategyPluginsLoaded,
   executeEntryOrder: () => executeEntryOrder,
   getAvailableStrategyNames: () => getAvailableStrategyNames,
+  getBinanceBreadthUniverseSnapshot: () => getBinanceBreadthUniverseSnapshot,
+  getBinanceBreadthUniverses: () => getBinanceBreadthUniverses,
   getDeterministicAiGateContext: () => getDeterministicAiGateContext,
   getOpenRouterModelKwargs: () => getOpenRouterModelKwargs,
+  getOrderArrivalSnapshot: () => getOrderArrivalSnapshot,
+  getPrimaryBinanceBreadthUniverse: () => getPrimaryBinanceBreadthUniverse,
   getRegisteredManifests: () => getRegisteredManifests,
   getRegisteredStrategies: () => getRegisteredStrategies,
   getStrategyCreator: () => getStrategyCreator,
@@ -5575,7 +5581,8 @@ __export(strategies_exports, {
   runAiPrompt: () => runAiPrompt,
   runAiPromptLocal: () => runAiPromptLocal,
   strategies: () => strategies,
-  trimSeriesDeep: () => trimSeriesDeep
+  trimSeriesDeep: () => trimSeriesDeep,
+  validateEntryProtectionAtArrival: () => validateEntryProtectionAtArrival
 });
 module.exports = __toCommonJS(strategies_exports);
 __reExport(strategies_exports, require("@tradejs/core/strategies"), module.exports);
@@ -5763,6 +5770,51 @@ var buildMarketBreadthContextFromSignal = (signal) => {
     dispersion: toFiniteNumber(breadth.dispersion)
   };
 };
+var buildMarketBreadthsContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const breadths = toRecord(relative?.marketBreadths);
+  const build = (key) => {
+    const breadth = toRecord(breadths?.[key]);
+    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)
+    };
+  };
+  return {
+    top5: build("top5"),
+    top10: build("top10"),
+    top30: build("top30"),
+    top50: build("top50"),
+    top100: build("top100")
+  };
+};
 var buildTargetVsBtcContextFromSignal = (signal) => {
   const baseContext = toRecord(signal.additionalIndicators?.baseContext);
   const relative = toRecord(baseContext?.relative);
@@ -6100,6 +6152,7 @@ var buildAiMarketContext = (signal) => ({
   },
   relative: {
     marketBreadth: buildMarketBreadthContextFromSignal(signal),
+    marketBreadths: buildMarketBreadthsContextFromSignal(signal),
     targetVsBtc: buildTargetVsBtcContextFromSignal(signal),
     btcAltRegime: buildBtcAltRegimeContextFromSignal(signal),
     cmcGlobal: buildCmcGlobalContextFromSignal(signal),
@@ -6888,7 +6941,7 @@ Input payload structure:
   \u2022 \`marketContext.execution.binanceCoinbaseSpread\`: AI-friendly BTC spread view projected from \`payload.additionalIndicators.baseContext.relative.execution.venueSpread\`; \`value=(Coinbase-Binance)/Binance\`, \`bps=value*10000\`.
   \u2022 \`marketContext.participation.trueDelta\`: Binance taker buy/sell volume delta from kline payload when \`source=kline_taker_volume\`; otherwise absent/unavailable.
   \u2022 \`marketContext.participation.tradeFlow\`: Binance aggTrades buy/sell pressure buckets when available.
-  \u2022 \`marketContext.relative.marketBreadth\`: equal/volume-weighted alt-basket return, advance/decline ratio, and MA breadth for the configured Binance breadth universe.
+  \u2022 \`marketContext.relative.marketBreadths.top5|top10|top30|top50|top100\`: equal/volume-weighted alt-basket return, advance/decline ratio, and MA breadth for the five versioned Binance breadth universes. \`marketBreadth\` remains the top30 primary view used by existing gates.
   \u2022 \`marketContext.relative.targetVsBtc\`: target/BTC ratio returns, alpha, beta, and short-window correlation; use it to decide whether the target is leading or lagging BTC in the signal direction.
   \u2022 \`marketContext.relative.btcAltRegime\`: Binance-derived BTC-vs-alt basket regime, BTC/alt 24h returns, BTC turnover share, and alt dispersion; use it as a broad alt-market risk pocket.
   \u2022 \`marketContext.relative.cmcGlobal\`: historical CoinMarketCap global market metrics: total/alt market cap, total/alt volume, BTC/ETH dominance and 24h changes, active markets, \`interval\`, and \`altLiquidityRegime\`.
@@ -7413,7 +7466,7 @@ var getActiveRuntimeTrade = async (params) => {
     import_redis2.redisKeys.runtimeTrade(userName, orderId),
     null
   );
-  if (!existing) {
+  if (!existing || existing.status !== "active") {
     await (0, import_redis2.delKey)(
       import_redis2.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId)
     );
@@ -7742,6 +7795,313 @@ var enrichSignalWithDerivativesContext = async (params) => {
 var import_timescale2 = require("@tradejs/infra/timescale");
 var import_logger5 = require("@tradejs/infra/logger");
 var import_strategies2 = require("@tradejs/core/strategies");
+
+// src/binanceBreadthUniverses.ts
+var import_node_crypto2 = require("crypto");
+
+// src/config/binanceBreadthUniverses.json
+var binanceBreadthUniverses_default = {
+  schemaVersion: 1,
+  updatedAt: "2026-07-24T15:28:27.234Z",
+  source: "binance_spot_usdt_turnover24h",
+  fingerprint: "43df006e5510bb99",
+  universes: {
+    top5: {
+      size: 5,
+      fingerprint: "ba5b73456b18",
+      symbols: ["ETHUSDT", "USD1USDT", "SOLUSDT", "OPNUSDT", "VANAUSDT"]
+    },
+    top10: {
+      size: 10,
+      fingerprint: "370eb5af9778",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT"
+      ]
+    },
+    top30: {
+      size: 30,
+      fingerprint: "685a7e7f5fce",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT",
+        "BNBUSDT",
+        "DOGEUSDT",
+        "REUSDT",
+        "RIFUSDT",
+        "ZAMAUSDT",
+        "TRXUSDT",
+        "EURUSDT",
+        "AEROUSDT",
+        "UUSDT",
+        "SUIUSDT",
+        "XAUTUSDT",
+        "NEARUSDT",
+        "LTCUSDT",
+        "SPCXBUSDT",
+        "LAUSDT",
+        "AVAXUSDT",
+        "WLDUSDT",
+        "ONDOUSDT",
+        "XLMUSDT",
+        "UNIUSDT"
+      ]
+    },
+    top50: {
+      size: 50,
+      fingerprint: "cb9725e24141",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT",
+        "BNBUSDT",
+        "DOGEUSDT",
+        "REUSDT",
+        "RIFUSDT",
+        "ZAMAUSDT",
+        "TRXUSDT",
+        "EURUSDT",
+        "AEROUSDT",
+        "UUSDT",
+        "SUIUSDT",
+        "XAUTUSDT",
+        "NEARUSDT",
+        "LTCUSDT",
+        "SPCXBUSDT",
+        "LAUSDT",
+        "AVAXUSDT",
+        "WLDUSDT",
+        "ONDOUSDT",
+        "XLMUSDT",
+        "UNIUSDT",
+        "ADAUSDT",
+        "SNDKBUSDT",
+        "KAITOUSDT",
+        "UTKUSDT",
+        "PEPEUSDT",
+        "WLFIUSDT",
+        "PAXGUSDT",
+        "ENAUSDT",
+        "TAOUSDT",
+        "AAVEUSDT",
+        "CRCLBUSDT",
+        "LINKUSDT",
+        "TONUSDT",
+        "ALLOUSDT",
+        "PUMPUSDT",
+        "INJUSDT",
+        "HOMEUSDT",
+        "MUBUSDT",
+        "TSLABUSDT",
+        "GRAMUSDT"
+      ]
+    },
+    top100: {
+      size: 100,
+      fingerprint: "f397883a81cf",
+      symbols: [
+        "ETHUSDT",
+        "USD1USDT",
+        "SOLUSDT",
+        "OPNUSDT",
+        "VANAUSDT",
+        "DEXEUSDT",
+        "BANKUSDT",
+        "ZECUSDT",
+        "XRPUSDT",
+        "RLUSDUSDT",
+        "BNBUSDT",
+        "DOGEUSDT",
+        "REUSDT",
+        "RIFUSDT",
+        "ZAMAUSDT",
+        "TRXUSDT",
+        "EURUSDT",
+        "AEROUSDT",
+        "UUSDT",
+        "SUIUSDT",
+        "XAUTUSDT",
+        "NEARUSDT",
+        "LTCUSDT",
+        "SPCXBUSDT",
+        "LAUSDT",
+        "AVAXUSDT",
+        "WLDUSDT",
+        "ONDOUSDT",
+        "XLMUSDT",
+        "UNIUSDT",
+        "ADAUSDT",
+        "SNDKBUSDT",
+        "KAITOUSDT",
+        "UTKUSDT",
+        "PEPEUSDT",
+        "WLFIUSDT",
+        "PAXGUSDT",
+        "ENAUSDT",
+        "TAOUSDT",
+        "AAVEUSDT",
+        "CRCLBUSDT",
+        "LINKUSDT",
+        "TONUSDT",
+        "ALLOUSDT",
+        "PUMPUSDT",
+        "INJUSDT",
+        "HOMEUSDT",
+        "MUBUSDT",
+        "TSLABUSDT",
+        "GRAMUSDT",
+        "\u5E01\u5B89\u4EBA\u751FUSDT",
+        "SYNUSDT",
+        "TRUMPUSDT",
+        "PROMUSDT",
+        "XPLUSDT",
+        "HBARUSDT",
+        "ERAUSDT",
+        "BCHUSDT",
+        "SOXLBUSDT",
+        "DOTUSDT",
+        "EPICUSDT",
+        "KITEUSDT",
+        "NFPUSDT",
+        "KGSTUSDT",
+        "FILUSDT",
+        "FETUSDT",
+        "KORUBUSDT",
+        "ARBUSDT",
+        "STXUSDT",
+        "HEIUSDT",
+        "BARDUSDT",
+        "DASHUSDT",
+        "ASTERUSDT",
+        "VANRYUSDT",
+        "INTCBUSDT",
+        "ETCUSDT",
+        "EIGENUSDT",
+        "PENGUUSDT",
+        "LRCUSDT",
+        "VIRTUALUSDT",
+        "POLUSDT",
+        "ICPUSDT",
+        "ZBTUSDT",
+        "SKHYBUSDT",
+        "SHIBUSDT",
+        "LDOUSDT",
+        "APTUSDT",
+        "JTOUSDT",
+        "NOMUSDT",
+        "ZROUSDT",
+        "OPUSDT",
+        "BONKUSDT",
+        "SKLUSDT",
+        "HEMIUSDT",
+        "TNSRUSDT",
+        "INTWBUSDT",
+        "BIOUSDT",
+        "TIAUSDT",
+        "ORDIUSDT",
+        "XUSDUSDT"
+      ]
+    }
+  }
+};
+
+// src/binanceBreadthUniverses.ts
+var BINANCE_BREADTH_UNIVERSE_KEYS = [
+  "top5",
+  "top10",
+  "top30",
+  "top50",
+  "top100"
+];
+var fingerprint = (value, length) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
+var normalizeSymbols = (symbols) => symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean);
+var buildBinanceBreadthUniverseSnapshot = ({
+  rankedSymbols,
+  updatedAt = (/* @__PURE__ */ new Date()).toISOString()
+}) => {
+  const uniqueSymbols = [...new Set(normalizeSymbols(rankedSymbols))];
+  if (uniqueSymbols.length < 100) {
+    throw new Error(
+      `Binance breadth snapshot requires at least 100 symbols, got ${uniqueSymbols.length}`
+    );
+  }
+  const universes = Object.fromEntries(
+    BINANCE_BREADTH_UNIVERSE_KEYS.map((key) => {
+      const size = Number(key.slice(3));
+      const symbols = uniqueSymbols.slice(0, size);
+      return [
+        key,
+        {
+          size,
+          fingerprint: fingerprint(symbols, 12),
+          symbols
+        }
+      ];
+    })
+  );
+  return {
+    schemaVersion: 1,
+    updatedAt,
+    source: "binance_spot_usdt_turnover24h",
+    fingerprint: fingerprint(universes, 16),
+    universes
+  };
+};
+var validateSnapshot = (value) => {
+  const rebuilt = buildBinanceBreadthUniverseSnapshot({
+    rankedSymbols: value.universes.top100.symbols,
+    updatedAt: value.updatedAt
+  });
+  if (value.schemaVersion !== 1 || value.source !== rebuilt.source || value.fingerprint !== rebuilt.fingerprint) {
+    throw new Error("Invalid Binance breadth universe snapshot fingerprint");
+  }
+  for (const key of BINANCE_BREADTH_UNIVERSE_KEYS) {
+    const actual = value.universes[key];
+    const expected = rebuilt.universes[key];
+    if (actual.size !== expected.size || actual.fingerprint !== expected.fingerprint || JSON.stringify(actual.symbols) !== JSON.stringify(expected.symbols)) {
+      throw new Error(`Invalid Binance breadth universe snapshot: ${key}`);
+    }
+  }
+  return value;
+};
+var snapshot = validateSnapshot(binanceBreadthUniverses_default);
+var getBinanceBreadthUniverseSnapshot = () => snapshot;
+var getBinanceBreadthUniverses = () => BINANCE_BREADTH_UNIVERSE_KEYS.map((key) => {
+  const definition = snapshot.universes[key];
+  return {
+    key,
+    size: definition.size,
+    fingerprint: definition.fingerprint,
+    universe: `binance_${key}_usdt_${definition.fingerprint}`,
+    symbols: [...definition.symbols]
+  };
+});
+var getPrimaryBinanceBreadthUniverse = () => getBinanceBreadthUniverses().find(({ key }) => key === "top30");
+
+// src/strategyHelpers/binanceMarketContext.ts
 var DEFAULT_MAX_AGE_BY_INTERVAL = {
   "1m": 3 * 6e4,
   "5m": 10 * 6e4,
@@ -7773,7 +8133,6 @@ var signalIntervalToMarketInterval = (value) => {
   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"];
@@ -7846,13 +8205,30 @@ var getCachedBreadth = ({
   breadthCache.set(key, promise);
   return promise;
 };
+var toMarketBreadthContext = (breadth, interval) => ({
+  source: "binance_klines",
+  universe: breadth.universe,
+  interval,
+  asOfTs: breadth.ts.getTime(),
+  ageMs: breadth.ageMs,
+  stale: breadth.stale,
+  symbolsCount: toFiniteNumberOrNull2(breadth.symbolsCount),
+  advancers: toFiniteNumberOrNull2(breadth.advancers),
+  decliners: toFiniteNumberOrNull2(breadth.decliners),
+  unchanged: toFiniteNumberOrNull2(breadth.unchanged),
+  advanceDeclineRatio: toFiniteNumberOrNull2(breadth.advanceDeclineRatio),
+  pctAboveMa20: toFiniteNumberOrNull2(breadth.pctAboveMa20),
+  pctAboveMa50: toFiniteNumberOrNull2(breadth.pctAboveMa50),
+  equalWeightedReturn: toFiniteNumberOrNull2(breadth.equalWeightedReturn),
+  volumeWeightedReturn: toFiniteNumberOrNull2(breadth.volumeWeightedReturn),
+  dispersion: toFiniteNumberOrNull2(breadth.dispersion)
+});
 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)) {
@@ -7861,26 +8237,49 @@ var enrichSignalWithBinanceMarketContext = async (params) => {
   try {
     const referenceSymbols = getReferenceSymbols();
     const primaryReferenceSymbol = resolvePrimaryReferenceSymbol2(signal.symbol);
-    const [referenceRows, breadth] = await Promise.all([
+    const breadthUniverses = params.breadthUniverse ? [
+      {
+        key: "top30",
+        universe: params.breadthUniverse
+      }
+    ] : getBinanceBreadthUniverses();
+    const [referenceRows, breadthRows] = await Promise.all([
       getCachedReferenceRows({
         referenceSymbols,
         interval,
         timestamp: signal.timestamp,
         maxAgeMs
       }),
-      getCachedBreadth({
-        breadthUniverse,
-        interval,
-        timestamp: signal.timestamp,
-        maxAgeMs
-      })
+      Promise.all(
+        breadthUniverses.map(async ({ key, universe }) => ({
+          key,
+          breadth: await getCachedBreadth({
+            breadthUniverse: universe,
+            interval,
+            timestamp: signal.timestamp,
+            maxAgeMs
+          })
+        }))
+      )
     ]);
+    const availableBreadths = breadthRows.filter(
+      (row) => row.breadth != null
+    );
+    const marketBreadths = Object.fromEntries(
+      availableBreadths.map(({ key, breadth }) => [
+        key,
+        toMarketBreadthContext(breadth, interval)
+      ])
+    );
+    const primaryBreadth = availableBreadths.find(
+      ({ key }) => key === "top30"
+    )?.breadth;
     const tradeFlowBySymbol = Object.fromEntries(
       referenceRows.filter((row) => row.tradeFlow).map((row) => [row.symbol, row.tradeFlow])
     );
     const targetReferenceSymbol = signal.symbol.trim().toUpperCase();
     const targetTradeFlow = tradeFlowBySymbol[targetReferenceSymbol];
-    if (!Object.keys(tradeFlowBySymbol).length && !breadth) {
+    if (!Object.keys(tradeFlowBySymbol).length && !availableBreadths.length) {
       return false;
     }
     const baseContext = signal.additionalIndicators.baseContext;
@@ -7907,76 +8306,65 @@ var enrichSignalWithBinanceMarketContext = async (params) => {
               tradeFlowBySymbol
             }
           } : {},
-          ...breadth ? {
-            marketBreadth: {
-              source: "binance_klines",
-              universe: breadth.universe,
-              interval,
-              asOfTs: breadth.ts.getTime(),
-              ageMs: breadth.ageMs,
-              stale: breadth.stale,
-              symbolsCount: toFiniteNumberOrNull2(breadth.symbolsCount),
-              advancers: toFiniteNumberOrNull2(breadth.advancers),
-              decliners: toFiniteNumberOrNull2(breadth.decliners),
-              unchanged: toFiniteNumberOrNull2(breadth.unchanged),
-              advanceDeclineRatio: toFiniteNumberOrNull2(
-                breadth.advanceDeclineRatio
-              ),
-              pctAboveMa20: toFiniteNumberOrNull2(breadth.pctAboveMa20),
-              pctAboveMa50: toFiniteNumberOrNull2(breadth.pctAboveMa50),
-              equalWeightedReturn: toFiniteNumberOrNull2(
-                breadth.equalWeightedReturn
-              ),
-              volumeWeightedReturn: toFiniteNumberOrNull2(
-                breadth.volumeWeightedReturn
-              ),
-              dispersion: toFiniteNumberOrNull2(breadth.dispersion)
-            },
-            btcAltRegime: {
-              source: "binance_klines",
-              universe: breadth.universe,
-              interval,
-              asOfTs: breadth.ts.getTime(),
-              ageMs: breadth.ageMs,
-              stale: breadth.stale,
-              btcReturn1h: toFiniteNumberOrNull2(breadth.btcReturn1h),
-              btcReturn4h: toFiniteNumberOrNull2(breadth.btcReturn4h),
-              btcReturn24h: toFiniteNumberOrNull2(breadth.btcReturn24h),
-              altBasketReturn1h: toFiniteNumberOrNull2(
-                breadth.altBasketReturn1h
+          ...availableBreadths.length ? {
+            marketBreadths,
+            ...primaryBreadth ? {
+              marketBreadth: toMarketBreadthContext(
+                primaryBreadth,
+                interval
               ),
-              altBasketReturn4h: toFiniteNumberOrNull2(
-                breadth.altBasketReturn4h
-              ),
-              altBasketReturn24h: toFiniteNumberOrNull2(
-                breadth.altBasketReturn24h
-              ),
-              btcVsAltReturn1h: toFiniteNumberOrNull2(
-                breadth.btcVsAltReturn1h
-              ),
-              btcVsAltReturn4h: toFiniteNumberOrNull2(
-                breadth.btcVsAltReturn4h
-              ),
-              btcVsAltReturn24h: toFiniteNumberOrNull2(
-                breadth.btcVsAltReturn24h
-              ),
-              btcTurnoverShare1h: toFiniteNumberOrNull2(
-                breadth.btcTurnoverShare1h
-              ),
-              btcTurnoverShare24h: toFiniteNumberOrNull2(
-                breadth.btcTurnoverShare24h
-              ),
-              btcTurnoverShareChange24h: toFiniteNumberOrNull2(
-                breadth.btcTurnoverShareChange24h
-              ),
-              altVolToBtcVol24h: toFiniteNumberOrNull2(
-                breadth.altVolToBtcVol24h
-              ),
-              altDispersion24h: toFiniteNumberOrNull2(
-                breadth.altDispersion24h
-              ),
-              regime: breadth.btcAltRegime ?? "unknown"
-            }
+              btcAltRegime: {
+                source: "binance_klines",
+                universe: primaryBreadth.universe,
+                interval,
+                asOfTs: primaryBreadth.ts.getTime(),
+                ageMs: primaryBreadth.ageMs,
+                stale: primaryBreadth.stale,
+                btcReturn1h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcReturn1h
+                ),
+                btcReturn4h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcReturn4h
+                ),
+                btcReturn24h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcReturn24h
+                ),
+                altBasketReturn1h: toFiniteNumberOrNull2(
+                  primaryBreadth.altBasketReturn1h
+                ),
+                altBasketReturn4h: toFiniteNumberOrNull2(
+                  primaryBreadth.altBasketReturn4h
+                ),
+                altBasketReturn24h: toFiniteNumberOrNull2(
+                  primaryBreadth.altBasketReturn24h
+                ),
+                btcVsAltReturn1h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcVsAltReturn1h
+                ),
+                btcVsAltReturn4h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcVsAltReturn4h
+                ),
+                btcVsAltReturn24h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcVsAltReturn24h
+                ),
+                btcTurnoverShare1h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcTurnoverShare1h
+                ),
+                btcTurnoverShare24h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcTurnoverShare24h
+                ),
+                btcTurnoverShareChange24h: toFiniteNumberOrNull2(
+                  primaryBreadth.btcTurnoverShareChange24h
+                ),
+                altVolToBtcVol24h: toFiniteNumberOrNull2(
+                  primaryBreadth.altVolToBtcVol24h
+                ),
+                altDispersion24h: toFiniteNumberOrNull2(
+                  primaryBreadth.altDispersion24h
+                ),
+                regime: primaryBreadth.btcAltRegime ?? "unknown"
+              }
+            } : {}
           } : {}
         }
       }
@@ -8505,18 +8893,18 @@ var findReplayAiAnalysis = ({
     return void 0;
   }
   let best = null;
-  for (const snapshot of snapshots) {
-    if (snapshot.symbol !== signal.symbol || snapshot.direction !== direction || snapshot.strategy && snapshot.strategy !== signal.strategy) {
+  for (const snapshot2 of snapshots) {
+    if (snapshot2.symbol !== signal.symbol || snapshot2.direction !== direction || snapshot2.strategy && snapshot2.strategy !== signal.strategy) {
       continue;
     }
-    const toleranceMs = Math.max(0, Number(snapshot.toleranceMs ?? 0));
-    const diff = Math.abs(snapshot.timestamp - signal.timestamp);
+    const toleranceMs = Math.max(0, Number(snapshot2.toleranceMs ?? 0));
+    const diff = Math.abs(snapshot2.timestamp - signal.timestamp);
     if (diff > toleranceMs || best && diff >= best.diff) {
       continue;
     }
     best = {
       diff,
-      analysis: snapshot.analysis
+      analysis: snapshot2.analysis
     };
   }
   return best?.analysis;
@@ -8604,7 +8992,7 @@ var enrichSignalWithMlAi = async ({
   return enrichSignalWithAi({ signal, userName, symbol, direction, env, ai });
 };
 var toFiniteNumberOrNull4 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-var getArrivalSnapshot = async ({
+var getOrderArrivalSnapshot = async ({
   connector,
   symbol
 }) => {
@@ -8649,6 +9037,29 @@ var getArrivalSnapshot = async ({
     };
   }
 };
+var validateEntryProtectionAtArrival = ({
+  direction,
+  signalPrice,
+  bid,
+  ask,
+  arrivalMid,
+  takeProfits,
+  stopLossPrice
+}) => {
+  const entryReference = direction === "LONG" ? ask ?? arrivalMid ?? signalPrice : bid ?? arrivalMid ?? signalPrice;
+  const stopReference = direction === "LONG" ? bid ?? arrivalMid ?? signalPrice : ask ?? arrivalMid ?? signalPrice;
+  if (!Number.isFinite(entryReference) || entryReference <= 0 || !Number.isFinite(stopReference) || stopReference <= 0) {
+    throw new Error("INVALID_ENTRY_REFERENCE_AT_ARRIVAL");
+  }
+  for (const takeProfit of takeProfits) {
+    if (!Number.isFinite(takeProfit.price) || takeProfit.price <= 0 || (direction === "LONG" ? takeProfit.price <= entryReference : takeProfit.price >= entryReference)) {
+      throw new Error("TAKE_PROFIT_CROSSED_BEFORE_ENTRY");
+    }
+  }
+  if (stopLossPrice != null && (!Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || (direction === "LONG" ? stopLossPrice >= stopReference : stopLossPrice <= stopReference))) {
+    throw new Error("STOP_LOSS_CROSSED_BEFORE_ENTRY");
+  }
+};
 var resolveRuntimeTelemetryQuality = ({
   signalClosePrice,
   arrivalMid,
@@ -8723,7 +9134,22 @@ var executeEntryOrder = async ({
   signal.orderQty = qty;
   signal.orderValue = qty * currentPrice;
   signal.orderFailureReason = void 0;
-  const arrivalSnapshot = await getArrivalSnapshot({ connector, symbol });
+  const arrivalSnapshot = await getOrderArrivalSnapshot({ connector, symbol });
+  try {
+    validateEntryProtectionAtArrival({
+      direction,
+      signalPrice: currentPrice,
+      bid: arrivalSnapshot.bid,
+      ask: arrivalSnapshot.ask,
+      arrivalMid: arrivalSnapshot.arrivalMid,
+      takeProfits,
+      stopLossPrice
+    });
+  } catch (error) {
+    signal.orderStatus = "failed";
+    signal.orderFailureReason = error.message;
+    throw error;
+  }
   const orderSubmitTime = Date.now();
   const orderPlaced = await connector.placeOrder({
     symbol,
@@ -8938,6 +9364,7 @@ var resolveStrategyConfig = async ({
 };
 
 // src/strategyRuntime.ts
+var import_types = require("@tradejs/types");
 var buildExitOrderSignal = ({
   strategyName,
   symbol,
@@ -9646,6 +10073,19 @@ var executeEntryDecision = async ({
       return signal;
     }
     await beforePlaceOrder();
+    const arrivalSnapshot = await getOrderArrivalSnapshot({
+      connector,
+      symbol
+    });
+    validateEntryProtectionAtArrival({
+      direction: decision.entryContext.direction,
+      signalPrice: decision.entryContext.prices.currentPrice,
+      bid: arrivalSnapshot.bid,
+      ask: arrivalSnapshot.ask,
+      arrivalMid: arrivalSnapshot.arrivalMid,
+      takeProfits: decision.orderPlan.takeProfits,
+      stopLossPrice: decision.orderPlan.stopLossPrice
+    });
     const orderPlaced = await connector.placeOrder({
       symbol,
       qty: decision.orderPlan.qty,
@@ -9707,7 +10147,11 @@ var executeEntryDecision = async ({
       entry,
       market
     });
-    import_logger8.logger.error("order error: %s %s", symbol, err);
+    if (err?.message === import_types.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
+      import_logger8.logger.warn("order warning: %s %s", symbol, err);
+    } else {
+      import_logger8.logger.error("order error: %s %s", symbol, err);
+    }
     return signal ?? "ORDER_ERROR";
   }
   return signal ?? decision.code;
@@ -10972,6 +11416,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BINANCE_BREADTH_UNIVERSE_KEYS,
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
   askAI,
@@ -10979,6 +11424,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   buildAiPayload,
   buildAiPrompts,
   buildAiSystemPrompt,
+  buildBinanceBreadthUniverseSnapshot,
   buildCompactAiIndicatorsSnapshot,
   closeOppositePositionsBeforeOpen,
   createCloseAllOnGlobalProfitBeforeSignalsHook,
@@ -10996,8 +11442,12 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   ensureStrategyPluginsLoaded,
   executeEntryOrder,
   getAvailableStrategyNames,
+  getBinanceBreadthUniverseSnapshot,
+  getBinanceBreadthUniverses,
   getDeterministicAiGateContext,
   getOpenRouterModelKwargs,
+  getOrderArrivalSnapshot,
+  getPrimaryBinanceBreadthUniverse,
   getRegisteredManifests,
   getRegisteredStrategies,
   getStrategyCreator,
@@ -11011,6 +11461,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   runAiPromptLocal,
   strategies,
   trimSeriesDeep,
+  validateEntryProtectionAtArrival,
   ...require("@tradejs/core/strategies")
 });
 /*! Bundled license information: