@tradejs/node 2.0.6 → 2.0.8

package/dist/backtest.mjs

@@ -7,10 +7,10 @@ import {
   enrichSignalWithBinanceMarketContext,
   enrichSignalWithCoinMarketCapContext,
   enrichSignalWithDerivativesContext
-} from "./chunk-2DZCHRP6.mjs";
+} from "./chunk-76TEMQKX.mjs";
 import {
   buildAiPayload
-} from "./chunk-IUZML4RK.mjs";
+} from "./chunk-PD25CABK.mjs";
 import {
   getStrategyCreator
 } from "./chunk-QVSMINLG.mjs";
@@ -23,6 +23,9 @@ import "./chunk-UV2HVMKZ.mjs";
 export * from "@tradejs/core/backtest";
 
 // src/testing.ts
+import {
+  BACKTEST_WARNING_CODES
+} from "@tradejs/types";
 import { alignSortedCandlesByTimestamp } from "@tradejs/core/indicators";
 import {
   BACKTEST_EXECUTION_INTERVAL,
@@ -985,6 +988,16 @@ var resolveExecutionCosts = async (params) => {
 var isBacktestEntryDelayControlCode = (value) => typeof value === "string" && value.startsWith("BACKTEST_ENTRY_DELAY_");
 var CLOSED_RESULT_FLUSH_INTERVAL = 500;
 var DEFAULT_STRATEGY_CANDLE_TIMEOUT_MS = 6e4;
+var createBacktestWarningCounts = () => ({
+  [BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY]: 0
+});
+var recordBacktestSignalWarning = (warningCounts, signal) => {
+  if (!signal || typeof signal === "string" || signal.orderStatus !== "failed" || signal.orderFailureReason !== BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY) {
+    return;
+  }
+  const code = BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY;
+  warningCounts[code] = (warningCounts[code] ?? 0) + 1;
+};
 var resolvePositiveInt = (value, fallback) => {
   const parsed = parseInt(String(value ?? ""), 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -1818,6 +1831,7 @@ var testing = async ({
   );
   const pendingMlPayloadBySignalId = /* @__PURE__ */ new Map();
   const pendingAiRowBySignalId = /* @__PURE__ */ new Map();
+  const warningCounts = createBacktestWarningCounts();
   const replaySignalEvaluations = collectReplaySignalEvaluations ? [] : null;
   const flushClosedResultsBatch = async () => {
     if (!ml && !ai) return;
@@ -1862,6 +1876,7 @@ var testing = async ({
     }
   };
   const processSignal = async (signal, candle) => {
+    recordBacktestSignalWarning(warningCounts, signal);
     if (isBacktestEntryDelayControlCode(signal)) {
       return;
     }
@@ -1970,10 +1985,14 @@ var testing = async ({
   }
   await withTimeout("flush closed results", flushClosedResultsBatch());
   const result = await withTimeout("collect result", testConnector.getResult());
-  return replaySignalEvaluations ? {
+  const resultWithWarnings = {
     ...result,
+    warningCounts
+  };
+  return replaySignalEvaluations ? {
+    ...resultWithWarnings,
     inlineReplaySignalEvaluations: replaySignalEvaluations
-  } : result;
+  } : resultWithWarnings;
 };
 var testingGroupInSharedCandleLoop = async (tests) => {
   if (!canRunTestsInSharedCandleLoop(tests)) {
@@ -2227,6 +2246,7 @@ var testingGroupInSharedCandleLoop = async (tests) => {
         testConnector,
         pendingMlPayloadBySignalId: /* @__PURE__ */ new Map(),
         pendingAiRowBySignalId: /* @__PURE__ */ new Map(),
+        warningCounts: createBacktestWarningCounts(),
         replaySignalEvaluations: collectReplaySignalEvaluations ? [] : null
       });
     }
@@ -2279,6 +2299,7 @@ var testingGroupInSharedCandleLoop = async (tests) => {
       }
     };
     const processRunnerSignal = async (runner, signal, candle) => {
+      recordBacktestSignalWarning(runner.warningCounts, signal);
       if (isBacktestEntryDelayControlCode(signal)) {
         return;
       }
@@ -2420,8 +2441,12 @@ var testingGroupInSharedCandleLoop = async (tests) => {
         test: runner.test,
         result: runner.replaySignalEvaluations ? {
           ...result,
+          warningCounts: runner.warningCounts,
           inlineReplaySignalEvaluations: runner.replaySignalEvaluations
-        } : result
+        } : {
+          ...result,
+          warningCounts: runner.warningCounts
+        }
       });
     }
     return results;

package/dist/{chunk-2DZCHRP6.mjs → chunk-76TEMQKX.mjs}

@@ -1,10 +1,315 @@
 import {
   getStrategyProfileMlAdapter
-} from "./chunk-IUZML4RK.mjs";
+} from "./chunk-PD25CABK.mjs";
 import {
   getStrategyManifest
 } from "./chunk-QVSMINLG.mjs";
 
+// src/binanceBreadthUniverses.ts
+import { createHash } from "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) => 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
 import {
   getLatestMarketBreadth,
@@ -43,7 +348,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"];
@@ -116,13 +420,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: toFiniteNumberOrNull(breadth.symbolsCount),
+  advancers: toFiniteNumberOrNull(breadth.advancers),
+  decliners: toFiniteNumberOrNull(breadth.decliners),
+  unchanged: toFiniteNumberOrNull(breadth.unchanged),
+  advanceDeclineRatio: toFiniteNumberOrNull(breadth.advanceDeclineRatio),
+  pctAboveMa20: toFiniteNumberOrNull(breadth.pctAboveMa20),
+  pctAboveMa50: toFiniteNumberOrNull(breadth.pctAboveMa50),
+  equalWeightedReturn: toFiniteNumberOrNull(breadth.equalWeightedReturn),
+  volumeWeightedReturn: toFiniteNumberOrNull(breadth.volumeWeightedReturn),
+  dispersion: toFiniteNumberOrNull(breadth.dispersion)
+});
 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)) {
@@ -131,26 +452,49 @@ var enrichSignalWithBinanceMarketContext = async (params) => {
   try {
     const referenceSymbols = getReferenceSymbols();
     const primaryReferenceSymbol = resolvePrimaryReferenceSymbol(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;
@@ -177,76 +521,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: toFiniteNumberOrNull(breadth.symbolsCount),
-              advancers: toFiniteNumberOrNull(breadth.advancers),
-              decliners: toFiniteNumberOrNull(breadth.decliners),
-              unchanged: toFiniteNumberOrNull(breadth.unchanged),
-              advanceDeclineRatio: toFiniteNumberOrNull(
-                breadth.advanceDeclineRatio
-              ),
-              pctAboveMa20: toFiniteNumberOrNull(breadth.pctAboveMa20),
-              pctAboveMa50: toFiniteNumberOrNull(breadth.pctAboveMa50),
-              equalWeightedReturn: toFiniteNumberOrNull(
-                breadth.equalWeightedReturn
-              ),
-              volumeWeightedReturn: toFiniteNumberOrNull(
-                breadth.volumeWeightedReturn
+          ...availableBreadths.length ? {
+            marketBreadths,
+            ...primaryBreadth ? {
+              marketBreadth: toMarketBreadthContext(
+                primaryBreadth,
+                interval
               ),
-              dispersion: toFiniteNumberOrNull(breadth.dispersion)
-            },
-            btcAltRegime: {
-              source: "binance_klines",
-              universe: breadth.universe,
-              interval,
-              asOfTs: breadth.ts.getTime(),
-              ageMs: breadth.ageMs,
-              stale: breadth.stale,
-              btcReturn1h: toFiniteNumberOrNull(breadth.btcReturn1h),
-              btcReturn4h: toFiniteNumberOrNull(breadth.btcReturn4h),
-              btcReturn24h: toFiniteNumberOrNull(breadth.btcReturn24h),
-              altBasketReturn1h: toFiniteNumberOrNull(
-                breadth.altBasketReturn1h
-              ),
-              altBasketReturn4h: toFiniteNumberOrNull(
-                breadth.altBasketReturn4h
-              ),
-              altBasketReturn24h: toFiniteNumberOrNull(
-                breadth.altBasketReturn24h
-              ),
-              btcVsAltReturn1h: toFiniteNumberOrNull(
-                breadth.btcVsAltReturn1h
-              ),
-              btcVsAltReturn4h: toFiniteNumberOrNull(
-                breadth.btcVsAltReturn4h
-              ),
-              btcVsAltReturn24h: toFiniteNumberOrNull(
-                breadth.btcVsAltReturn24h
-              ),
-              btcTurnoverShare1h: toFiniteNumberOrNull(
-                breadth.btcTurnoverShare1h
-              ),
-              btcTurnoverShare24h: toFiniteNumberOrNull(
-                breadth.btcTurnoverShare24h
-              ),
-              btcTurnoverShareChange24h: toFiniteNumberOrNull(
-                breadth.btcTurnoverShareChange24h
-              ),
-              altVolToBtcVol24h: toFiniteNumberOrNull(
-                breadth.altVolToBtcVol24h
-              ),
-              altDispersion24h: toFiniteNumberOrNull(
-                breadth.altDispersion24h
-              ),
-              regime: breadth.btcAltRegime ?? "unknown"
-            }
+              btcAltRegime: {
+                source: "binance_klines",
+                universe: primaryBreadth.universe,
+                interval,
+                asOfTs: primaryBreadth.ts.getTime(),
+                ageMs: primaryBreadth.ageMs,
+                stale: primaryBreadth.stale,
+                btcReturn1h: toFiniteNumberOrNull(
+                  primaryBreadth.btcReturn1h
+                ),
+                btcReturn4h: toFiniteNumberOrNull(
+                  primaryBreadth.btcReturn4h
+                ),
+                btcReturn24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcReturn24h
+                ),
+                altBasketReturn1h: toFiniteNumberOrNull(
+                  primaryBreadth.altBasketReturn1h
+                ),
+                altBasketReturn4h: toFiniteNumberOrNull(
+                  primaryBreadth.altBasketReturn4h
+                ),
+                altBasketReturn24h: toFiniteNumberOrNull(
+                  primaryBreadth.altBasketReturn24h
+                ),
+                btcVsAltReturn1h: toFiniteNumberOrNull(
+                  primaryBreadth.btcVsAltReturn1h
+                ),
+                btcVsAltReturn4h: toFiniteNumberOrNull(
+                  primaryBreadth.btcVsAltReturn4h
+                ),
+                btcVsAltReturn24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcVsAltReturn24h
+                ),
+                btcTurnoverShare1h: toFiniteNumberOrNull(
+                  primaryBreadth.btcTurnoverShare1h
+                ),
+                btcTurnoverShare24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcTurnoverShare24h
+                ),
+                btcTurnoverShareChange24h: toFiniteNumberOrNull(
+                  primaryBreadth.btcTurnoverShareChange24h
+                ),
+                altVolToBtcVol24h: toFiniteNumberOrNull(
+                  primaryBreadth.altVolToBtcVol24h
+                ),
+                altDispersion24h: toFiniteNumberOrNull(
+                  primaryBreadth.altDispersion24h
+                ),
+                regime: primaryBreadth.btcAltRegime ?? "unknown"
+              }
+            } : {}
           } : {}
         }
       }
@@ -1041,6 +1374,11 @@ var buildMlPayload = (payload) => {
 };
 
 export {
+  BINANCE_BREADTH_UNIVERSE_KEYS,
+  buildBinanceBreadthUniverseSnapshot,
+  getBinanceBreadthUniverseSnapshot,
+  getBinanceBreadthUniverses,
+  getPrimaryBinanceBreadthUniverse,
   enrichSignalWithBinanceMarketContext,
   enrichSignalWithCoinMarketCapContext,
   enrichSignalWithDerivativesContext,