@tradejs/node 1.0.8 → 1.0.10

package/dist/chunk-37VNDZVX.mjs

@@ -0,0 +1,1040 @@
+import {
+  getStrategyProfileMlAdapter
+} from "./chunk-IUZML4RK.mjs";
+import {
+  getStrategyManifest
+} from "./chunk-QVSMINLG.mjs";
+
+// src/strategyHelpers/binanceMarketContext.ts
+import {
+  getLatestMarketBreadth,
+  getLatestMarketTradeFlow
+} from "@tradejs/infra/timescale";
+import { logger } from "@tradejs/infra/logger";
+import { refreshSignalBaseContextGateFeatures } from "@tradejs/core/strategies";
+var DEFAULT_MAX_AGE_BY_INTERVAL = {
+  "1m": 3 * 6e4,
+  "5m": 10 * 6e4,
+  "15m": 30 * 6e4,
+  "1h": 2 * 60 * 6e4
+};
+var binanceMarketContextUnavailable = false;
+var referenceRowsCache = /* @__PURE__ */ new Map();
+var breadthCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized)
+    return env === "BACKTEST" || env === "CRON" || env === "PARITY";
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var toFiniteNumberOrNull = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var signalIntervalToMarketInterval = (value) => {
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "5" || normalized === "5m") return "5m";
+  if (normalized === "60" || normalized === "1h") return "1h";
+  return "15m";
+};
+var resolveMarketInterval = (signal, override) => override ?? signalIntervalToMarketInterval(signal.interval);
+var resolveBreadthUniverse = () => (process.env.BINANCE_MARKET_CONTEXT_BREADTH_UNIVERSE || "binance_top30_usdt").trim().toLowerCase();
+var getReferenceSymbols = () => {
+  const symbols = (process.env.BINANCE_MARKET_CONTEXT_REFERENCE_SYMBOLS || "BTCUSDT,ETHUSDT").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+  return symbols.length ? [...new Set(symbols)] : ["BTCUSDT", "ETHUSDT"];
+};
+var resolvePrimaryReferenceSymbol = (signalSymbol) => {
+  const symbol = signalSymbol.trim().toUpperCase();
+  const referenceSymbols = getReferenceSymbols();
+  return referenceSymbols.includes(symbol) ? symbol : referenceSymbols[0];
+};
+var hasBaseContext = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var isBinanceMarketContextEnabled = (env) => parseEnabledFlag(process.env.BINANCE_MARKET_CONTEXT_ENABLED, env);
+var toTradeFlowContext = (row, interval) => row ? {
+  source: "binance_agg_trades",
+  interval,
+  asOfTs: row.ts.getTime(),
+  ageMs: row.ageMs,
+  stale: row.stale,
+  trades: toFiniteNumberOrNull(row.trades),
+  buyPressurePct: toFiniteNumberOrNull(row.buyPressurePct),
+  buyBaseVolume: toFiniteNumberOrNull(row.buyBaseVolume),
+  sellBaseVolume: toFiniteNumberOrNull(row.sellBaseVolume),
+  buyQuoteVolume: toFiniteNumberOrNull(row.buyQuoteVolume),
+  sellQuoteVolume: toFiniteNumberOrNull(row.sellQuoteVolume),
+  netBaseDelta: toFiniteNumberOrNull(row.netBaseDelta),
+  netQuoteDelta: toFiniteNumberOrNull(row.netQuoteDelta)
+} : null;
+var getCachedReferenceRows = ({
+  referenceSymbols,
+  interval,
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${referenceSymbols.join(",")}:${interval}:${timestamp}:${maxAgeMs}`;
+  const cached = referenceRowsCache.get(key);
+  if (cached) return cached;
+  const promise = Promise.all(
+    referenceSymbols.map(async (symbol) => {
+      const tradeFlow = await getLatestMarketTradeFlow({
+        symbol,
+        interval,
+        atMs: timestamp,
+        maxAgeMs
+      });
+      return {
+        symbol,
+        tradeFlow: toTradeFlowContext(tradeFlow, interval)
+      };
+    })
+  );
+  referenceRowsCache.set(key, promise);
+  return promise;
+};
+var getCachedBreadth = ({
+  breadthUniverse,
+  interval,
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${breadthUniverse}:${interval}:${timestamp}:${maxAgeMs}`;
+  const cached = breadthCache.get(key);
+  if (cached) return cached;
+  const promise = getLatestMarketBreadth({
+    universe: breadthUniverse,
+    interval,
+    atMs: timestamp,
+    maxAgeMs
+  });
+  breadthCache.set(key, promise);
+  return promise;
+};
+var enrichSignalWithBinanceMarketContext = async (params) => {
+  const {
+    signal,
+    env,
+    enabled = isBinanceMarketContextEnabled(env),
+    interval = resolveMarketInterval(signal, params.interval),
+    breadthUniverse = resolveBreadthUniverse(),
+    maxAgeMs = DEFAULT_MAX_AGE_BY_INTERVAL[interval]
+  } = params;
+  if (signal.universe === "tradfi" || !enabled || binanceMarketContextUnavailable || !hasBaseContext(signal)) {
+    return false;
+  }
+  try {
+    const referenceSymbols = getReferenceSymbols();
+    const primaryReferenceSymbol = resolvePrimaryReferenceSymbol(signal.symbol);
+    const [referenceRows, breadth] = await Promise.all([
+      getCachedReferenceRows({
+        referenceSymbols,
+        interval,
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedBreadth({
+        breadthUniverse,
+        interval,
+        timestamp: signal.timestamp,
+        maxAgeMs
+      })
+    ]);
+    const tradeFlowBySymbol = Object.fromEntries(
+      referenceRows.filter((row) => row.tradeFlow).map((row) => [row.symbol, row.tradeFlow])
+    );
+    const targetReferenceSymbol = signal.symbol.trim().toUpperCase();
+    const targetTradeFlow = tradeFlowBySymbol[targetReferenceSymbol];
+    if (!Object.keys(tradeFlowBySymbol).length && !breadth) {
+      return false;
+    }
+    const baseContext = signal.additionalIndicators.baseContext;
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators,
+      baseContext: {
+        ...baseContext,
+        participation: {
+          ...baseContext.participation,
+          ...targetTradeFlow ? {
+            tradeFlow: targetTradeFlow
+          } : {}
+        },
+        relative: {
+          ...baseContext.relative,
+          execution: {
+            ...baseContext.relative.execution
+          },
+          ...Object.keys(tradeFlowBySymbol).length ? {
+            referenceTradeFlow: {
+              source: "binance_reference_market",
+              primaryReferenceSymbol,
+              referenceSymbols,
+              tradeFlowBySymbol
+            }
+          } : {},
+          ...breadth ? {
+            marketBreadth: {
+              source: "binance_klines",
+              universe: breadth.universe,
+              interval,
+              asOfTs: breadth.ts.getTime(),
+              ageMs: breadth.ageMs,
+              stale: breadth.stale,
+              symbolsCount: toFiniteNumberOrNull(breadth.symbolsCount),
+              advancers: toFiniteNumberOrNull(breadth.advancers),
+              decliners: toFiniteNumberOrNull(breadth.decliners),
+              unchanged: toFiniteNumberOrNull(breadth.unchanged),
+              advanceDeclineRatio: toFiniteNumberOrNull(
+                breadth.advanceDeclineRatio
+              ),
+              pctAboveMa20: toFiniteNumberOrNull(breadth.pctAboveMa20),
+              pctAboveMa50: toFiniteNumberOrNull(breadth.pctAboveMa50),
+              equalWeightedReturn: toFiniteNumberOrNull(
+                breadth.equalWeightedReturn
+              ),
+              volumeWeightedReturn: toFiniteNumberOrNull(
+                breadth.volumeWeightedReturn
+              ),
+              dispersion: toFiniteNumberOrNull(breadth.dispersion)
+            },
+            btcAltRegime: {
+              source: "binance_klines",
+              universe: breadth.universe,
+              interval,
+              asOfTs: breadth.ts.getTime(),
+              ageMs: breadth.ageMs,
+              stale: breadth.stale,
+              btcReturn1h: toFiniteNumberOrNull(breadth.btcReturn1h),
+              btcReturn4h: toFiniteNumberOrNull(breadth.btcReturn4h),
+              btcReturn24h: toFiniteNumberOrNull(breadth.btcReturn24h),
+              altBasketReturn1h: toFiniteNumberOrNull(
+                breadth.altBasketReturn1h
+              ),
+              altBasketReturn4h: toFiniteNumberOrNull(
+                breadth.altBasketReturn4h
+              ),
+              altBasketReturn24h: toFiniteNumberOrNull(
+                breadth.altBasketReturn24h
+              ),
+              btcVsAltReturn1h: toFiniteNumberOrNull(
+                breadth.btcVsAltReturn1h
+              ),
+              btcVsAltReturn4h: toFiniteNumberOrNull(
+                breadth.btcVsAltReturn4h
+              ),
+              btcVsAltReturn24h: toFiniteNumberOrNull(
+                breadth.btcVsAltReturn24h
+              ),
+              btcTurnoverShare1h: toFiniteNumberOrNull(
+                breadth.btcTurnoverShare1h
+              ),
+              btcTurnoverShare24h: toFiniteNumberOrNull(
+                breadth.btcTurnoverShare24h
+              ),
+              btcTurnoverShareChange24h: toFiniteNumberOrNull(
+                breadth.btcTurnoverShareChange24h
+              ),
+              altVolToBtcVol24h: toFiniteNumberOrNull(
+                breadth.altVolToBtcVol24h
+              ),
+              altDispersion24h: toFiniteNumberOrNull(
+                breadth.altDispersion24h
+              ),
+              regime: breadth.btcAltRegime ?? "unknown"
+            }
+          } : {}
+        }
+      }
+    };
+    refreshSignalBaseContextGateFeatures(signal);
+    return true;
+  } catch (error) {
+    binanceMarketContextUnavailable = true;
+    logger.warn(
+      "Binance market context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyHelpers/coinMarketCapContext.ts
+import { refreshSignalBaseContextGateFeatures as refreshSignalBaseContextGateFeatures2 } from "@tradejs/core/strategies";
+import { logger as logger2 } from "@tradejs/infra/logger";
+import {
+  getLatestMarketCmcExchangeLiquidityContext,
+  getLatestMarketCmcFearGreedContext,
+  getLatestMarketCmcIndexContexts,
+  getLatestMarketGlobalContext,
+  getLatestMarketReferenceAssetContexts
+} from "@tradejs/infra/timescale";
+var DEFAULT_MAX_AGE_MS = 48 * 60 * 6e4;
+var SOURCE_GLOBAL_DAILY = "coinmarketcap_global";
+var SOURCE_REFERENCE = "coinmarketcap_reference_asset";
+var SOURCE_EXCHANGE_LIQUIDITY = "coinmarketcap_exchange_liquidity";
+var SOURCE_FEAR_GREED = "coinmarketcap_fear_greed";
+var SOURCE_INDEX = "coinmarketcap_index";
+var DAY_MS = 864e5;
+var coinMarketCapContextUnavailable = false;
+var globalContextCache = /* @__PURE__ */ new Map();
+var referenceContextCache = /* @__PURE__ */ new Map();
+var exchangeLiquidityContextCache = /* @__PURE__ */ new Map();
+var fearGreedContextCache = /* @__PURE__ */ new Map();
+var indexContextCache = /* @__PURE__ */ new Map();
+var parseEnabledFlag2 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return env === "BACKTEST" || env === "PARITY" || env === "CRON";
+  }
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var toFiniteNumberOrNull2 = (value) => {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var safeDivide = (numerator, denominator) => numerator != null && denominator != null && denominator > 0 ? numerator / denominator : null;
+var hasBaseContext2 = (signal) => Boolean(
+  signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
+);
+var resolveMaxAgeMs = () => asInt(process.env.COINMARKETCAP_CONTEXT_MAX_AGE_MS, DEFAULT_MAX_AGE_MS);
+var toAltLiquidityRegime = ({
+  stale,
+  btcDominanceChange24hPct,
+  altMarketCapChange24hPct,
+  altVolumeChange24hPct
+}) => {
+  if (stale) return "unknown";
+  if (altMarketCapChange24hPct != null && altMarketCapChange24hPct <= -0.03 || altVolumeChange24hPct != null && altVolumeChange24hPct <= -0.15) {
+    return "risk_off";
+  }
+  if (btcDominanceChange24hPct != null && btcDominanceChange24hPct >= 0.25) {
+    return "btc_favored";
+  }
+  if (btcDominanceChange24hPct != null && btcDominanceChange24hPct <= -0.25 && (altMarketCapChange24hPct == null || altMarketCapChange24hPct >= 0)) {
+    return "alt_friendly";
+  }
+  return "neutral";
+};
+var toReferenceLiquidityRegime = ({
+  stale,
+  ethBtcMarketCapRatioChange24hPct,
+  ethVsBtcVolumeRatio
+}) => {
+  if (stale) return "unknown";
+  if (ethVsBtcVolumeRatio != null && ethVsBtcVolumeRatio < 0.15) return "thin";
+  if (ethBtcMarketCapRatioChange24hPct != null && ethBtcMarketCapRatioChange24hPct >= 0.01) {
+    return "eth_led";
+  }
+  if (ethBtcMarketCapRatioChange24hPct != null && ethBtcMarketCapRatioChange24hPct <= -0.01) {
+    return "btc_led";
+  }
+  return "balanced";
+};
+var toExchangeLiquidityRegime = ({
+  stale,
+  totalVolumeChange24hPct,
+  fallback
+}) => {
+  if (stale) return "unknown";
+  if (totalVolumeChange24hPct != null && totalVolumeChange24hPct >= 0.15) {
+    return "expanding";
+  }
+  if (totalVolumeChange24hPct != null && totalVolumeChange24hPct <= -0.15) {
+    return "contracting";
+  }
+  return fallback;
+};
+var toIndexRegime = ({
+  stale,
+  cmc100Change24hPct,
+  cmc20Change24hPct,
+  cmc20ToCmc100RatioChange24hPct
+}) => {
+  if (stale) return "unknown";
+  if (cmc100Change24hPct == null && cmc20Change24hPct == null) {
+    return "unknown";
+  }
+  if ((cmc100Change24hPct ?? 0) <= -0.02 && (cmc20Change24hPct ?? 0) <= -0.02) {
+    return "risk_off";
+  }
+  if ((cmc20ToCmc100RatioChange24hPct ?? 0) >= 5e-3) {
+    return "top20_led";
+  }
+  if ((cmc20ToCmc100RatioChange24hPct ?? 0) <= -5e-3) {
+    return "large_cap_led";
+  }
+  return "balanced";
+};
+var getCachedGlobalContext = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_GLOBAL_DAILY}:${timestamp}:${maxAgeMs}`;
+  const cached = globalContextCache.get(key);
+  if (cached) return cached;
+  const promise = getLatestMarketGlobalContext({
+    source: SOURCE_GLOBAL_DAILY,
+    atMs: timestamp,
+    maxAgeMs
+  });
+  globalContextCache.set(key, promise);
+  return promise;
+};
+var getCachedReferenceContexts = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_REFERENCE}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = referenceContextCache.get(key);
+  if (cached) return cached;
+  const promise = getLatestMarketReferenceAssetContexts({
+    source: SOURCE_REFERENCE,
+    symbols: ["BTCUSDT", "ETHUSDT"],
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  referenceContextCache.set(key, promise);
+  return promise;
+};
+var getCachedExchangeLiquidityContext = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_EXCHANGE_LIQUIDITY}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = exchangeLiquidityContextCache.get(key);
+  if (cached) return cached;
+  const promise = getLatestMarketCmcExchangeLiquidityContext({
+    source: SOURCE_EXCHANGE_LIQUIDITY,
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  exchangeLiquidityContextCache.set(key, promise);
+  return promise;
+};
+var getCachedFearGreedContext = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_FEAR_GREED}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = fearGreedContextCache.get(key);
+  if (cached) return cached;
+  const promise = getLatestMarketCmcFearGreedContext({
+    source: SOURCE_FEAR_GREED,
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  fearGreedContextCache.set(key, promise);
+  return promise;
+};
+var getCachedIndexContexts = ({
+  timestamp,
+  maxAgeMs
+}) => {
+  const key = `${SOURCE_INDEX}:1d:${timestamp}:${maxAgeMs}`;
+  const cached = indexContextCache.get(key);
+  if (cached) return cached;
+  const promise = getLatestMarketCmcIndexContexts({
+    source: SOURCE_INDEX,
+    indexSlugs: ["cmc100", "cmc20"],
+    interval: "1d",
+    atMs: timestamp,
+    maxAgeMs
+  });
+  indexContextCache.set(key, promise);
+  return promise;
+};
+var isCoinMarketCapContextEnabled = (env) => parseEnabledFlag2(process.env.COINMARKETCAP_CONTEXT_ENABLED, env);
+var enrichSignalWithCoinMarketCapContext = async (params) => {
+  const {
+    signal,
+    env,
+    enabled = isCoinMarketCapContextEnabled(env),
+    maxAgeMs = resolveMaxAgeMs()
+  } = params;
+  if (signal.universe === "tradfi" || !enabled || coinMarketCapContextUnavailable || !hasBaseContext2(signal)) {
+    return false;
+  }
+  try {
+    const [
+      globalDailyRow,
+      dailyReferences,
+      previousDailyReferences,
+      exchangeLiquidityRow,
+      fearGreedRow,
+      indexRows
+    ] = await Promise.all([
+      getCachedGlobalContext({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedReferenceContexts({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedReferenceContexts({
+        timestamp: signal.timestamp - DAY_MS,
+        maxAgeMs: maxAgeMs + DAY_MS
+      }),
+      getCachedExchangeLiquidityContext({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedFearGreedContext({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      }),
+      getCachedIndexContexts({
+        timestamp: signal.timestamp,
+        maxAgeMs
+      })
+    ]);
+    const globalRow = globalDailyRow;
+    const references = dailyReferences;
+    const previousReferences = previousDailyReferences;
+    if (!globalRow && !references.size && !exchangeLiquidityRow && !fearGreedRow && !indexRows.size) {
+      return false;
+    }
+    const btcRow = references.get("BTCUSDT") ?? null;
+    const ethRow = references.get("ETHUSDT") ?? null;
+    const previousBtcRow = previousReferences.get("BTCUSDT") ?? null;
+    const previousEthRow = previousReferences.get("ETHUSDT") ?? null;
+    const btcMarketCapUsd = toFiniteNumberOrNull2(btcRow?.marketCapUsd);
+    const ethMarketCapUsd = toFiniteNumberOrNull2(ethRow?.marketCapUsd);
+    const previousBtcMarketCapUsd = toFiniteNumberOrNull2(
+      previousBtcRow?.marketCapUsd
+    );
+    const previousEthMarketCapUsd = toFiniteNumberOrNull2(
+      previousEthRow?.marketCapUsd
+    );
+    const ethBtcMarketCapRatio = safeDivide(ethMarketCapUsd, btcMarketCapUsd);
+    const previousEthBtcMarketCapRatio = safeDivide(
+      previousEthMarketCapUsd,
+      previousBtcMarketCapUsd
+    );
+    const ethBtcMarketCapRatioChange24hPct = ethBtcMarketCapRatio != null && previousEthBtcMarketCapRatio != null && previousEthBtcMarketCapRatio > 0 ? (ethBtcMarketCapRatio - previousEthBtcMarketCapRatio) / previousEthBtcMarketCapRatio : null;
+    const btcVolumeUsd = toFiniteNumberOrNull2(btcRow?.volumeUsd);
+    const ethVolumeUsd = toFiniteNumberOrNull2(ethRow?.volumeUsd);
+    const referenceStale = btcRow?.stale === true || ethRow?.stale === true || !btcRow || !ethRow;
+    const btcDominanceChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.btcDominanceChange24hPct
+    );
+    const altMarketCapChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.altMarketCapChange24hPct
+    );
+    const altVolumeChange24hPct = toFiniteNumberOrNull2(
+      globalRow?.altVolumeChange24hPct
+    );
+    const altLiquidityRegime = globalRow ? toAltLiquidityRegime({
+      stale: globalRow.stale,
+      btcDominanceChange24hPct,
+      altMarketCapChange24hPct,
+      altVolumeChange24hPct
+    }) : "unknown";
+    const exchangeLiquidityRegime = exchangeLiquidityRow ? toExchangeLiquidityRegime({
+      stale: exchangeLiquidityRow.stale,
+      totalVolumeChange24hPct: toFiniteNumberOrNull2(
+        exchangeLiquidityRow.totalVolumeChange24hPct
+      ),
+      fallback: exchangeLiquidityRow.liquidityRegime ?? "unknown"
+    }) : "unknown";
+    const cmc100Row = indexRows.get("cmc100") ?? null;
+    const cmc20Row = indexRows.get("cmc20") ?? null;
+    const cmc100Value = toFiniteNumberOrNull2(cmc100Row?.value);
+    const cmc20Value = toFiniteNumberOrNull2(cmc20Row?.value);
+    const cmc100Change24hPct = toFiniteNumberOrNull2(
+      cmc100Row?.valueChange24hPct
+    );
+    const cmc20Change24hPct = toFiniteNumberOrNull2(cmc20Row?.valueChange24hPct);
+    const cmc20ToCmc100Ratio = safeDivide(cmc20Value, cmc100Value);
+    const cmc20ToCmc100RatioChange24hPct = cmc20Change24hPct != null && cmc100Change24hPct != null ? (1 + cmc20Change24hPct) / (1 + cmc100Change24hPct) - 1 : null;
+    const indexStale = cmc100Row?.stale === true || cmc20Row?.stale === true || !cmc100Row || !cmc20Row;
+    const indexRegime = toIndexRegime({
+      stale: indexStale,
+      cmc100Change24hPct,
+      cmc20Change24hPct,
+      cmc20ToCmc100RatioChange24hPct
+    });
+    const baseContext = signal.additionalIndicators.baseContext;
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators,
+      baseContext: {
+        ...baseContext,
+        relative: {
+          ...baseContext.relative,
+          ...globalRow ? {
+            cmcGlobal: {
+              source: globalRow.source,
+              interval: "1d",
+              asOfTs: globalRow.ts.getTime(),
+              ageMs: globalRow.ageMs,
+              stale: globalRow.stale,
+              totalMarketCapUsd: toFiniteNumberOrNull2(
+                globalRow.totalMarketCapUsd
+              ),
+              totalVolumeUsd: toFiniteNumberOrNull2(
+                globalRow.totalVolumeUsd
+              ),
+              totalVolumeReportedUsd: toFiniteNumberOrNull2(
+                globalRow.totalVolumeReportedUsd
+              ),
+              altMarketCapUsd: toFiniteNumberOrNull2(
+                globalRow.altMarketCapUsd
+              ),
+              altVolumeUsd: toFiniteNumberOrNull2(globalRow.altVolumeUsd),
+              altVolumeReportedUsd: toFiniteNumberOrNull2(
+                globalRow.altVolumeReportedUsd
+              ),
+              btcDominancePct: toFiniteNumberOrNull2(
+                globalRow.btcDominancePct
+              ),
+              ethDominancePct: toFiniteNumberOrNull2(
+                globalRow.ethDominancePct
+              ),
+              btcDominanceChange24hPct,
+              ethDominanceChange24hPct: toFiniteNumberOrNull2(
+                globalRow.ethDominanceChange24hPct
+              ),
+              altMarketCapChange24hPct,
+              altVolumeChange24hPct,
+              activeCryptocurrencies: toFiniteNumberOrNull2(
+                globalRow.activeCryptocurrencies
+              ),
+              activeExchanges: toFiniteNumberOrNull2(
+                globalRow.activeExchanges
+              ),
+              activeMarketPairs: toFiniteNumberOrNull2(
+                globalRow.activeMarketPairs
+              ),
+              altLiquidityRegime
+            }
+          } : {},
+          ...btcRow || ethRow ? {
+            cmcReferenceAssets: {
+              source: SOURCE_REFERENCE,
+              interval: "1d",
+              asOfTs: Math.max(
+                btcRow?.ts.getTime() ?? 0,
+                ethRow?.ts.getTime() ?? 0
+              ),
+              ageMs: btcRow?.ageMs != null && ethRow?.ageMs != null ? Math.max(btcRow.ageMs, ethRow.ageMs) : btcRow?.ageMs ?? ethRow?.ageMs ?? null,
+              stale: referenceStale,
+              btcMarketCapUsd,
+              ethMarketCapUsd,
+              btcVolumeUsd,
+              ethVolumeUsd,
+              btcVolumeToMarketCap: safeDivide(
+                btcVolumeUsd,
+                btcMarketCapUsd
+              ),
+              ethVolumeToMarketCap: safeDivide(
+                ethVolumeUsd,
+                ethMarketCapUsd
+              ),
+              ethBtcMarketCapRatio,
+              ethBtcMarketCapRatioChange24hPct,
+              ethVsBtcVolumeRatio: safeDivide(ethVolumeUsd, btcVolumeUsd),
+              referenceLiquidityRegime: toReferenceLiquidityRegime({
+                stale: referenceStale,
+                ethBtcMarketCapRatioChange24hPct,
+                ethVsBtcVolumeRatio: safeDivide(ethVolumeUsd, btcVolumeUsd)
+              })
+            }
+          } : {},
+          ...exchangeLiquidityRow ? {
+            cmcExchangeLiquidity: {
+              source: SOURCE_EXCHANGE_LIQUIDITY,
+              interval: exchangeLiquidityRow.interval,
+              asOfTs: exchangeLiquidityRow.ts.getTime(),
+              ageMs: exchangeLiquidityRow.ageMs,
+              stale: exchangeLiquidityRow.stale,
+              exchangesCount: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.exchangesCount
+              ),
+              totalVolumeUsd: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.totalVolumeUsd
+              ),
+              totalVolumeChange24hPct: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.totalVolumeChange24hPct
+              ),
+              binanceVolumeUsd: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.binanceVolumeUsd
+              ),
+              binanceVolumeShare: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.binanceVolumeShare
+              ),
+              topExchangeVolumeShare: toFiniteNumberOrNull2(
+                exchangeLiquidityRow.topExchangeVolumeShare
+              ),
+              liquidityRegime: exchangeLiquidityRegime
+            }
+          } : {},
+          ...fearGreedRow ? {
+            cmcFearGreed: {
+              source: SOURCE_FEAR_GREED,
+              interval: "1d",
+              asOfTs: fearGreedRow.ts.getTime(),
+              ageMs: fearGreedRow.ageMs,
+              stale: fearGreedRow.stale,
+              value: toFiniteNumberOrNull2(fearGreedRow.value),
+              valueChange24h: toFiniteNumberOrNull2(
+                fearGreedRow.valueChange24h
+              ),
+              valueChange7d: toFiniteNumberOrNull2(
+                fearGreedRow.valueChange7d
+              ),
+              classification: fearGreedRow.classification ?? "Unknown",
+              sentimentRegime: fearGreedRow.sentimentRegime ?? "unknown"
+            }
+          } : {},
+          ...cmc100Row || cmc20Row ? {
+            cmcIndexes: {
+              source: SOURCE_INDEX,
+              interval: "1d",
+              asOfTs: Math.max(
+                cmc100Row?.ts.getTime() ?? 0,
+                cmc20Row?.ts.getTime() ?? 0
+              ),
+              ageMs: cmc100Row?.ageMs != null && cmc20Row?.ageMs != null ? Math.max(cmc100Row.ageMs, cmc20Row.ageMs) : cmc100Row?.ageMs ?? cmc20Row?.ageMs ?? null,
+              stale: indexStale,
+              cmc100Value,
+              cmc100Change24hPct,
+              cmc100TopConstituentSymbol: cmc100Row?.topConstituentSymbol ?? null,
+              cmc100TopConstituentWeightPct: toFiniteNumberOrNull2(
+                cmc100Row?.topConstituentWeightPct
+              ),
+              cmc20Value,
+              cmc20Change24hPct,
+              cmc20TopConstituentSymbol: cmc20Row?.topConstituentSymbol ?? null,
+              cmc20TopConstituentWeightPct: toFiniteNumberOrNull2(
+                cmc20Row?.topConstituentWeightPct
+              ),
+              cmc20ToCmc100Ratio,
+              cmc20ToCmc100RatioChange24hPct,
+              indexRegime
+            }
+          } : {}
+        }
+      }
+    };
+    refreshSignalBaseContextGateFeatures2(signal);
+    return true;
+  } catch (error) {
+    coinMarketCapContextUnavailable = true;
+    logger2.warn(
+      "CoinMarketCap context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyHelpers/derivativesContext.ts
+import {
+  buildDerivativesContext,
+  normalizeDerivativesIntervals
+} from "@tradejs/core/indicators";
+import { refreshSignalBaseContextGateFeatures as refreshSignalBaseContextGateFeatures3 } from "@tradejs/core/strategies";
+import {
+  DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
+  resolveDerivativesContextReferenceSymbols
+} from "@tradejs/core/constants";
+import { getDerivativesWindow } from "@tradejs/infra/timescale";
+import { logger as logger3 } from "@tradejs/infra/logger";
+var DEFAULT_INTERVALS = ["15m", "1h"];
+var DEFAULT_LOOKBACK_HOURS = 48;
+var PRIMARY_DERIVATIVES_REFERENCE_SYMBOL = DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[0];
+var SECONDARY_DERIVATIVES_REFERENCE_SYMBOL = DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS[1];
+var derivativesContextUnavailable = false;
+var parseEnabledFlag3 = (value, env) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return true;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (normalized === "backtest") return env === "BACKTEST";
+  if (normalized === "live") return env !== "BACKTEST";
+  return false;
+};
+var parseBooleanFlag = (value, fallback = false) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+};
+var parseLookbackMs = () => {
+  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
+  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
+  return normalizedHours * 60 * 60 * 1e3;
+};
+var parseIntervals = () => {
+  const fromEnv = normalizeDerivativesIntervals(
+    process.env.DERIVATIVES_CONTEXT_INTERVALS
+  );
+  return fromEnv.length ? fromEnv : DEFAULT_INTERVALS;
+};
+var getDerivativesContextReferenceSymbols = () => [
+  ...resolveDerivativesContextReferenceSymbols(
+    process.env.DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS
+  )
+];
+var normalizeSymbol = (symbol) => String(symbol || "").trim().toUpperCase();
+var getSignalPriceChangePct1h = (signal) => {
+  const baseContext = signal.additionalIndicators?.baseContext;
+  if (!baseContext || typeof baseContext !== "object" || Array.isArray(baseContext)) {
+    return null;
+  }
+  const raw = typeof baseContext.raw === "object" && baseContext.raw && !Array.isArray(baseContext.raw) ? baseContext.raw : null;
+  const price = raw && typeof raw.price === "object" && raw.price && !Array.isArray(raw.price) ? raw.price : null;
+  const value = price?.price1hPct;
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var resolvePrimaryReferenceSymbol2 = () => PRIMARY_DERIVATIVES_REFERENCE_SYMBOL;
+var resolveSecondaryReferenceSymbol = () => SECONDARY_DERIVATIVES_REFERENCE_SYMBOL;
+var getPrimaryIntervalContext = (context) => context?.intervals["15m"] ?? context?.intervals["1h"] ?? null;
+var hasDerivativesSymbolData = (context) => Object.keys(context.intervals).length > 0 && !context.summary.riskFlags.includes("missing_derivatives");
+var toFiniteNumberOrNull3 = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var roundNullable = (value, digits = 4) => {
+  if (value == null || !Number.isFinite(value)) return null;
+  const multiplier = 10 ** digits;
+  return Math.round(value * multiplier) / multiplier;
+};
+var deltaNullable = (targetValue, referenceValue) => {
+  const target = toFiniteNumberOrNull3(targetValue);
+  const reference = toFiniteNumberOrNull3(referenceValue);
+  return target == null || reference == null ? null : roundNullable(target - reference);
+};
+var buildTargetDerivedContext = (params) => {
+  const { targetContext, primaryReferenceContext } = params;
+  const targetPrimary = getPrimaryIntervalContext(targetContext);
+  const referencePrimary = getPrimaryIntervalContext(primaryReferenceContext);
+  const targetDirectionAligned = targetContext.summary.directionAligned;
+  const referenceDirectionAligned = primaryReferenceContext?.summary.directionAligned ?? null;
+  return {
+    available: hasDerivativesSymbolData(targetContext),
+    stale: targetContext.summary.riskFlags.includes("stale_derivatives") || targetPrimary?.stale === true ? true : targetPrimary == null ? null : false,
+    sourceSymbol: targetContext.symbol,
+    referenceSymbol: primaryReferenceContext?.symbol ?? null,
+    directionAligned: targetDirectionAligned,
+    referenceDirectionAligned,
+    pressure: targetContext.summary.pressure ?? null,
+    referencePressure: primaryReferenceContext?.summary.pressure ?? null,
+    riskFlags: targetContext.summary.riskFlags,
+    oiChangePct1h: targetPrimary?.oiChangePct1h ?? null,
+    oiAcceleration: targetContext.summary.oiAcceleration ?? null,
+    fundingRate: targetPrimary?.fundingRate ?? null,
+    fundingZScore: targetPrimary?.fundingZScore ?? null,
+    fundingChange1h: targetContext.summary.fundingChange1h ?? null,
+    liqSpikeRatio: targetPrimary?.liqSpikeRatio ?? null,
+    liqImbalance: targetPrimary?.liqImbalance ?? null,
+    targetVsPrimaryOiChangePct1hDelta: deltaNullable(
+      targetPrimary?.oiChangePct1h,
+      referencePrimary?.oiChangePct1h
+    ),
+    targetVsPrimaryFundingZScoreDelta: deltaNullable(
+      targetPrimary?.fundingZScore,
+      referencePrimary?.fundingZScore
+    ),
+    targetReferenceConflict: targetDirectionAligned == null || referenceDirectionAligned == null ? null : targetDirectionAligned !== referenceDirectionAligned
+  };
+};
+var buildReferenceDerivativesContext = (params) => {
+  const {
+    targetSymbol,
+    primaryReferenceSymbol,
+    secondaryReferenceSymbol,
+    referenceSymbols,
+    referenceContexts,
+    targetContext
+  } = params;
+  const primaryContext = referenceContexts[primaryReferenceSymbol] ?? referenceContexts[referenceSymbols[0]];
+  if (!primaryContext) {
+    throw new Error("No derivatives reference contexts built");
+  }
+  const referenceSymbolsMetadata = [
+    .../* @__PURE__ */ new Set([
+      primaryReferenceSymbol,
+      secondaryReferenceSymbol,
+      ...referenceSymbols,
+      ...Object.keys(referenceContexts)
+    ])
+  ];
+  const targetDerived = targetContext && hasDerivativesSymbolData(targetContext) ? buildTargetDerivedContext({
+    targetContext,
+    primaryReferenceContext: primaryContext
+  }) : void 0;
+  return {
+    ...primaryContext,
+    targetSymbol,
+    primaryReferenceSymbol: primaryContext.symbol,
+    secondaryReferenceSymbol: referenceContexts[secondaryReferenceSymbol]?.symbol ?? secondaryReferenceSymbol,
+    referenceSymbols: referenceSymbolsMetadata,
+    referenceContexts,
+    ...targetContext && targetDerived ? {
+      targetContext,
+      targetDerived
+    } : {}
+  };
+};
+var isDerivativesContextEnabled = (env) => parseEnabledFlag3(process.env.DERIVATIVES_CONTEXT_ENABLED, env);
+var isDerivativesTargetContextEnabled = () => parseBooleanFlag(process.env.DERIVATIVES_CONTEXT_TARGET_ENABLED, false);
+var enrichSignalWithDerivativesContext = async (params) => {
+  const { signal, env, enabled = isDerivativesContextEnabled(env) } = params;
+  if (signal.universe === "tradfi" || !enabled || derivativesContextUnavailable) {
+    return false;
+  }
+  try {
+    const intervals = parseIntervals();
+    const referenceSymbols = getDerivativesContextReferenceSymbols();
+    const targetSymbol = normalizeSymbol(signal.symbol);
+    const lookbackMs = parseLookbackMs();
+    const contexts = await Promise.all(
+      referenceSymbols.map(async (symbol) => {
+        const rowsByInterval = await getDerivativesWindow({
+          symbol,
+          intervals,
+          endMs: signal.timestamp,
+          lookbackMs
+        });
+        return [
+          symbol,
+          buildDerivativesContext({
+            symbol,
+            direction: signal.direction,
+            timestamp: signal.timestamp,
+            rowsByInterval,
+            priceChangePct1h: getSignalPriceChangePct1h(signal),
+            intervals
+          })
+        ];
+      })
+    );
+    const referenceContexts = Object.fromEntries(contexts);
+    const primaryReferenceSymbol = resolvePrimaryReferenceSymbol2();
+    const secondaryReferenceSymbol = resolveSecondaryReferenceSymbol();
+    const targetContextEnabled = isDerivativesTargetContextEnabled();
+    const referenceTargetContext = targetContextEnabled && targetSymbol !== primaryReferenceSymbol ? referenceContexts[targetSymbol] : void 0;
+    const shouldFetchTargetContext = targetContextEnabled && targetSymbol.length > 0 && !referenceSymbols.some(
+      (referenceSymbol) => referenceSymbol === targetSymbol
+    );
+    const fetchedTargetContext = shouldFetchTargetContext ? await (async () => {
+      const rowsByInterval = await getDerivativesWindow({
+        symbol: targetSymbol,
+        intervals,
+        endMs: signal.timestamp,
+        lookbackMs
+      });
+      const context = buildDerivativesContext({
+        symbol: targetSymbol,
+        direction: signal.direction,
+        timestamp: signal.timestamp,
+        rowsByInterval,
+        priceChangePct1h: getSignalPriceChangePct1h(signal),
+        intervals
+      });
+      return hasDerivativesSymbolData(context) ? context : void 0;
+    })() : void 0;
+    const targetContext = referenceTargetContext && hasDerivativesSymbolData(referenceTargetContext) ? referenceTargetContext : fetchedTargetContext;
+    const derivativesContext = buildReferenceDerivativesContext({
+      targetSymbol: targetSymbol || signal.symbol,
+      primaryReferenceSymbol,
+      secondaryReferenceSymbol,
+      referenceSymbols,
+      referenceContexts,
+      targetContext
+    });
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators ?? {},
+      baseContext: signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext) ? {
+        ...signal.additionalIndicators.baseContext,
+        derivatives: derivativesContext
+      } : signal.additionalIndicators?.baseContext
+    };
+    refreshSignalBaseContextGateFeatures3(signal);
+    return true;
+  } catch (error) {
+    derivativesContextUnavailable = true;
+    logger3.warn(
+      "Derivatives context disabled after Timescale read failure: %s",
+      String(error)
+    );
+    return false;
+  }
+};
+
+// src/strategyAdapters/ml.ts
+var defaultMlAdapter = {
+  normalizeStrategyConfig: (strategyConfig) => strategyConfig
+};
+var getStrategyMlAdapter = (strategy, profileId) => {
+  const strategyAdapter = getStrategyProfileMlAdapter(
+    getStrategyManifest(strategy),
+    profileId
+  );
+  if (!strategyAdapter) return defaultMlAdapter;
+  return {
+    ...defaultMlAdapter,
+    ...strategyAdapter
+  };
+};
+
+// src/mlPayload.ts
+var normalizeStrategyConfig = (strategyConfig, strategyName, profileId) => {
+  return getStrategyMlAdapter(
+    strategyName,
+    profileId
+  ).normalizeStrategyConfig?.(strategyConfig);
+};
+var buildMlPayload = (payload) => {
+  const strategyName = payload.signal?.strategy ?? payload.context?.strategyName;
+  const profileId = payload.signal?.policyProfileId;
+  const mlAdapter = getStrategyMlAdapter(strategyName, profileId);
+  const normalizedSignal = mlAdapter.normalizeSignal?.(payload.signal) ?? payload.signal;
+  const nextSignal = {
+    ...normalizedSignal,
+    indicators: {
+      ...normalizedSignal?.indicators ?? {}
+    }
+  };
+  const nextContext = payload.context ? {
+    ...payload.context,
+    strategyConfig: normalizeStrategyConfig(
+      payload.context.strategyConfig,
+      strategyName,
+      profileId
+    )
+  } : void 0;
+  return {
+    signal: nextSignal,
+    context: nextContext
+  };
+};
+
+export {
+  enrichSignalWithBinanceMarketContext,
+  enrichSignalWithCoinMarketCapContext,
+  enrichSignalWithDerivativesContext,
+  buildMlPayload
+};