@tradejs/cli 2.0.13 → 2.0.14

package/dist/scripts/replayRunner.js

@@ -5183,6 +5183,412 @@ var backfillCoinMarketCapContextForBacktest = backfillCoinMarketCapContext;
 var backfillCoinMarketCapContextForReplay = backfillCoinMarketCapContext;
 var backfillCoinMarketCapContextForSignals = (params) => backfillCoinMarketCapContext({ ...params, refreshStaleFearGreed: true });
 
+// src/lib/hyperliquidWhaleBackfill.ts
+var import_timescale4 = require("@tradejs/infra/timescale");
+var import_strategies2 = require("@tradejs/node/strategies");
+
+// src/lib/hyperliquidWhaleData.ts
+var HYPERLIQUID_WHALE_BUCKET_MS = 6e4;
+var finiteNumber = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var POSITION_EPSILON = 1e-12;
+var normalizePosition = (value) => Math.abs(value) <= POSITION_EPSILON ? 0 : value;
+var classifyHyperliquidPositionChange = (params) => {
+  const startValue = finiteNumber(params.startPosition);
+  const size = finiteNumber(params.size);
+  const side = String(params.side ?? "").toUpperCase();
+  if (startValue == null || size == null || size <= 0) return null;
+  if (side !== "B" && side !== "A") return null;
+  const startPosition = normalizePosition(startValue);
+  const endPosition = normalizePosition(
+    startPosition + (side === "B" ? size : -size)
+  );
+  const startLong = Math.max(startPosition, 0);
+  const endLong = Math.max(endPosition, 0);
+  const startShort = Math.max(-startPosition, 0);
+  const endShort = Math.max(-endPosition, 0);
+  const longEntrySize = Math.max(0, endLong - startLong);
+  const shortEntrySize = Math.max(0, endShort - startShort);
+  const longExitSize = Math.max(0, startLong - endLong);
+  const shortExitSize = Math.max(0, startShort - endShort);
+  const flipped = startPosition * endPosition < 0;
+  const opened = startPosition === 0;
+  const closed = endPosition === 0;
+  const increased = Math.sign(startPosition) === Math.sign(endPosition) && Math.abs(endPosition) > Math.abs(startPosition);
+  return {
+    startPosition,
+    endPosition,
+    action: flipped ? "flip" : opened ? "open" : closed ? "close" : increased ? "increase" : "reduce",
+    longEntrySize,
+    shortEntrySize,
+    longExitSize,
+    shortExitSize
+  };
+};
+var normalizeAddress = (value) => typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value) ? value.toLowerCase() : null;
+var normalizeTradeFields = (value) => {
+  const symbol = typeof value.coin === "string" ? value.coin.trim() : "";
+  const price = finiteNumber(value.px);
+  const size = finiteNumber(value.sz);
+  const timestamp = finiteNumber(value.time);
+  const tid = typeof value.tid === "string" || typeof value.tid === "number" ? String(value.tid) : "";
+  if (!symbol || price == null || size == null || timestamp == null || !tid || price <= 0 || size <= 0) {
+    return null;
+  }
+  return {
+    symbol,
+    price,
+    size,
+    timestamp,
+    tid,
+    notionalUsd: price * size
+  };
+};
+var normalizeHyperliquidUserFill = (params) => {
+  const normalized = normalizeTradeFields(params.fill);
+  if (!normalized || !params.trackedSymbols.has(normalized.symbol)) return null;
+  const address = normalizeAddress(params.address);
+  if (!address) return null;
+  const side = String(params.fill.side ?? "").toUpperCase();
+  if (side !== "B" && side !== "A") return null;
+  const positionChange = classifyHyperliquidPositionChange({
+    startPosition: params.fill.startPosition,
+    side,
+    size: normalized.size
+  });
+  const closedPnl = finiteNumber(params.fill.closedPnl);
+  const liquidation = params.fill.liquidation != null && typeof params.fill.liquidation === "object";
+  const positionFields = positionChange ? side === "B" ? {
+    buyerStartPosition: positionChange.startPosition,
+    buyerEndPosition: positionChange.endPosition,
+    buyerPositionAction: positionChange.action,
+    buyerClosedPnl: closedPnl,
+    buyerLiquidation: liquidation
+  } : {
+    sellerStartPosition: positionChange.startPosition,
+    sellerEndPosition: positionChange.endPosition,
+    sellerPositionAction: positionChange.action,
+    sellerClosedPnl: closedPnl,
+    sellerLiquidation: liquidation
+  } : {};
+  return {
+    symbol: normalized.symbol,
+    ts: new Date(normalized.timestamp),
+    tid: normalized.tid,
+    price: normalized.price,
+    size: normalized.size,
+    notionalUsd: normalized.notionalUsd,
+    buyerAddress: side === "B" ? address : null,
+    sellerAddress: side === "A" ? address : null,
+    buyerTracked: side === "B",
+    sellerTracked: side === "A",
+    ...positionFields,
+    ...params.identity,
+    source: "hyperliquid_user_fills"
+  };
+};
+
+// src/lib/hyperliquidRateLimiter.ts
+var DEFAULT_WEIGHT_PER_MINUTE = 1e3;
+var WINDOW_MS = 6e4;
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+var HyperliquidInfoRateLimiter = class {
+  constructor(capacity = DEFAULT_WEIGHT_PER_MINUTE, now = Date.now, wait = sleep2) {
+    this.capacity = capacity;
+    this.now = now;
+    this.wait = wait;
+    this.reservations = [];
+    this.queue = Promise.resolve();
+  }
+  reserve(weight) {
+    const normalizedWeight = Math.max(1, Math.ceil(weight));
+    const pending = this.queue.then(
+      () => this.reserveInternal(normalizedWeight)
+    );
+    this.queue = pending.catch(() => void 0);
+    return pending;
+  }
+  async reserveInternal(weight) {
+    if (weight > this.capacity) {
+      throw new Error(
+        `Hyperliquid request weight ${weight} exceeds limiter capacity ${this.capacity}`
+      );
+    }
+    for (; ; ) {
+      const nowMs = this.now();
+      this.reservations = this.reservations.filter(
+        (reservation) => reservation.atMs > nowMs - WINDOW_MS
+      );
+      const used = this.reservations.reduce(
+        (sum, reservation) => sum + reservation.weight,
+        0
+      );
+      if (used + weight <= this.capacity) {
+        this.reservations.push({ atMs: nowMs, weight });
+        return;
+      }
+      const oldest = this.reservations[0];
+      await this.wait(Math.max(1, oldest.atMs + WINDOW_MS - nowMs));
+    }
+  }
+};
+var hyperliquidInfoResponseWeight = (rows) => Math.max(0, Math.ceil(Math.max(0, rows) / 20));
+
+// src/lib/hyperliquidWhaleBackfill.ts
+var DEFAULT_BASE_URL = "https://api.hyperliquid.xyz";
+var DEFAULT_CONCURRENCY = 2;
+var DEFAULT_RATE_LIMIT_WEIGHT = 1e3;
+var MAX_PAGE_SIZE = 2e3;
+var MAX_PAGES_PER_WHALE = 5;
+var REQUEST_WEIGHT = 20;
+var sleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+var positiveInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var minuteCeil = (value) => Math.ceil(value / HYPERLIQUID_WHALE_BUCKET_MS) * HYPERLIQUID_WHALE_BUCKET_MS;
+var nextMinute = (value) => (Math.floor(value / HYPERLIQUID_WHALE_BUCKET_MS) + 1) * HYPERLIQUID_WHALE_BUCKET_MS;
+var fetchHyperliquidUserFillsByTime = async (params) => {
+  const fetchImpl = params.fetchImpl ?? fetch;
+  const limiter = params.rateLimiter ?? new HyperliquidInfoRateLimiter(
+    positiveInt(
+      process.env.HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT,
+      DEFAULT_RATE_LIMIT_WEIGHT
+    ),
+    Date.now,
+    params.wait ?? sleep3
+  );
+  const fills = [];
+  let cursor = params.startTime;
+  for (let page = 0; page < (params.maxPages ?? MAX_PAGES_PER_WHALE) && cursor <= params.endTime; page += 1) {
+    await limiter.reserve(REQUEST_WEIGHT);
+    const response = await fetchImpl(
+      `${process.env.HYPERLIQUID_API_BASE_URL?.trim() || DEFAULT_BASE_URL}/info`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          type: "userFillsByTime",
+          user: params.address,
+          startTime: cursor,
+          endTime: params.endTime,
+          aggregateByTime: true
+        })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(
+        `Hyperliquid userFillsByTime ${response.status}: ${await response.text()}`
+      );
+    }
+    const raw = await response.json();
+    const pageRows = Array.isArray(raw) ? raw : [];
+    const responseWeight = hyperliquidInfoResponseWeight(pageRows.length);
+    if (responseWeight > 0) await limiter.reserve(responseWeight);
+    fills.push(...pageRows);
+    if (pageRows.length < MAX_PAGE_SIZE) {
+      return { fills, truncated: false, coveredFromMs: params.startTime };
+    }
+    const lastTime = Math.max(
+      ...pageRows.map((row) => Number(row.time)).filter(Number.isFinite)
+    );
+    if (!Number.isFinite(lastTime) || lastTime < cursor) {
+      throw new Error(
+        `Hyperliquid fills pagination stalled for ${params.address}`
+      );
+    }
+    cursor = lastTime + 1;
+  }
+  if (cursor > params.endTime) {
+    return { fills, truncated: false, coveredFromMs: params.startTime };
+  }
+  const firstAvailableTime = Math.min(
+    ...fills.map((fill) => Number(fill.time)).filter(Number.isFinite)
+  );
+  return {
+    fills,
+    truncated: true,
+    coveredFromMs: Math.min(params.endTime + 1, nextMinute(firstAvailableTime))
+  };
+};
+var runConcurrent = async (params) => {
+  let nextIndex = 0;
+  await Promise.all(
+    Array.from(
+      { length: Math.min(params.concurrency, params.items.length) },
+      async () => {
+        for (; ; ) {
+          const index = nextIndex;
+          nextIndex += 1;
+          if (index >= params.items.length) return;
+          await params.worker(params.items[index], index);
+        }
+      }
+    )
+  );
+};
+var backfillHyperliquidWhaleContext = async (params) => {
+  const universe = (0, import_strategies2.getHyperliquidPerpUniverseSnapshot)();
+  const whales = (0, import_strategies2.getHyperliquidWhaleRegistrySnapshot)();
+  const trackedSymbols = new Set(universe.symbols);
+  const identity = {
+    universeFingerprint: universe.fingerprint,
+    whaleRegistryFingerprint: whales.fingerprint
+  };
+  const fromMs = Math.floor(params.startMs / HYPERLIQUID_WHALE_BUCKET_MS) * HYPERLIQUID_WHALE_BUCKET_MS;
+  const toMs = minuteCeil(params.endMs);
+  const cached = await (0, import_timescale4.hasHyperliquidWhaleBackfillCoverage)({
+    fromMs,
+    toMs,
+    ...identity
+  });
+  const emptyResult = () => ({
+    cached,
+    cacheOnly: params.cacheOnly,
+    fills: 0,
+    events: 0,
+    buckets: 0,
+    coverageBuckets: 0,
+    complete: cached,
+    walletsProcessed: 0,
+    walletsCached: 0,
+    completeWallets: 0,
+    truncatedWallets: 0,
+    failedWallets: 0,
+    fromMs,
+    toMs
+  });
+  if (cached || params.cacheOnly) return emptyResult();
+  const limiter = new HyperliquidInfoRateLimiter(
+    positiveInt(
+      process.env.HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT,
+      DEFAULT_RATE_LIMIT_WEIGHT
+    ),
+    Date.now,
+    params.wait ?? sleep3
+  );
+  const concurrency = Math.min(
+    4,
+    positiveInt(
+      params.concurrency ?? process.env.HYPERLIQUID_WHALE_CONCURRENCY,
+      DEFAULT_CONCURRENCY
+    )
+  );
+  let fills = 0;
+  let events = 0;
+  let walletsProcessed = 0;
+  let walletsCached = 0;
+  let completeWallets = 0;
+  let truncatedWallets = 0;
+  let failedWallets = 0;
+  const failures = [];
+  await runConcurrent({
+    items: whales.addresses,
+    concurrency,
+    worker: async (address) => {
+      const previous = await (0, import_timescale4.getHyperliquidWhaleWalletCoverage)({
+        address,
+        fromMs,
+        toMs,
+        ...identity
+      });
+      if (previous && previous.status !== "failed") {
+        walletsCached += 1;
+        if (previous.status === "complete") completeWallets += 1;
+        else truncatedWallets += 1;
+      } else {
+        try {
+          const result2 = await fetchHyperliquidUserFillsByTime({
+            address,
+            startTime: fromMs,
+            endTime: toMs - 1,
+            fetchImpl: params.fetchImpl,
+            rateLimiter: limiter
+          });
+          const addressEvents = result2.fills.map(
+            (fill) => normalizeHyperliquidUserFill({
+              fill,
+              address,
+              trackedSymbols,
+              identity
+            })
+          ).filter((row) => row != null);
+          await (0, import_timescale4.upsertHyperliquidWhaleTradeEvents)(addressEvents);
+          await (0, import_timescale4.upsertHyperliquidWhaleWalletCoverage)({
+            address,
+            fromMs,
+            toMs,
+            coveredFromMs: result2.coveredFromMs,
+            coveredToMs: toMs,
+            status: result2.truncated ? "truncated" : "complete",
+            fillsCount: result2.fills.length,
+            ...identity
+          });
+          fills += result2.fills.length;
+          events += addressEvents.length;
+          if (result2.truncated) truncatedWallets += 1;
+          else completeWallets += 1;
+        } catch (error) {
+          const normalizedError = error instanceof Error ? error : new Error(String(error));
+          failures.push(normalizedError);
+          failedWallets += 1;
+          await (0, import_timescale4.upsertHyperliquidWhaleWalletCoverage)({
+            address,
+            fromMs,
+            toMs,
+            coveredFromMs: null,
+            coveredToMs: null,
+            status: "failed",
+            fillsCount: 0,
+            error: normalizedError.message,
+            ...identity
+          });
+        }
+      }
+      walletsProcessed += 1;
+      params.log?.(
+        `Hyperliquid whales ${walletsProcessed}/${whales.addresses.length}: complete=${completeWallets}, truncated=${truncatedWallets}, failed=${failedWallets}, fills=${fills}, events=${events}`
+      );
+    }
+  });
+  const buckets = await (0, import_timescale4.rebuildHyperliquidWhaleFlowRows)({
+    fromMs,
+    toMs,
+    ...identity
+  });
+  const coverageBuckets = await (0, import_timescale4.rebuildHyperliquidWhaleCoverageRows)({
+    fromMs,
+    toMs,
+    expectedWhales: whales.addresses.length,
+    ...identity
+  });
+  const result = {
+    cached: false,
+    cacheOnly: false,
+    fills,
+    events,
+    buckets,
+    coverageBuckets,
+    complete: truncatedWallets === 0 && failedWallets === 0,
+    walletsProcessed,
+    walletsCached,
+    completeWallets,
+    truncatedWallets,
+    failedWallets,
+    fromMs,
+    toMs
+  };
+  if (params.strict !== false && failures.length) {
+    throw new AggregateError(
+      failures,
+      `Hyperliquid whale backfill failed for ${failures.length}/${whales.addresses.length} wallets`
+    );
+  }
+  return result;
+};
+
 // src/lib/marketContextPrepare.ts
 var shouldPrepareDerivativesContextForRun = (params) => {
   if (params.universe === "tradfi") return false;
@@ -5233,6 +5639,20 @@ var shouldPrepareCoinMarketCapContextForRun = (params) => {
     cacheOnly: params.cacheOnly
   });
 };
+var shouldPrepareHyperliquidWhaleContextForRun = (params) => {
+  const strategyRequiresContext = params.strategyNames?.includes(
+    "HyperliquidConsensus"
+  );
+  if (params.universe === "tradfi" || params.mode === "signals" || params.cacheOnly || !params.aiEnabled && !params.mlEnabled && !strategyRequiresContext) {
+    return false;
+  }
+  const configured = String(
+    process.env.HYPERLIQUID_WHALE_BACKFILL_ENABLED ?? ""
+  ).trim().toLowerCase();
+  if (["0", "false", "no", "off"].includes(configured)) return false;
+  if (strategyRequiresContext) return true;
+  return ["1", "true", "yes", "on"].includes(configured);
+};
 var resolveCoinMarketCapBackfillForMode = (mode) => mode === "backtest" ? backfillCoinMarketCapContextForBacktest : mode === "signals" ? backfillCoinMarketCapContextForSignals : backfillCoinMarketCapContextForReplay;
 var buildCoinMarketCapBackfillParams = (params) => ({
   userName: params.userName,
@@ -5269,6 +5689,18 @@ var prepareMarketContextForRun = async (params) => {
       )
     );
   }
+  if (shouldPrepareHyperliquidWhaleContextForRun(params)) {
+    await timeOperation3(
+      "hyperliquid whale context backfill",
+      () => backfillHyperliquidWhaleContext({
+        startMs: params.preloadStartMs ?? params.startMs,
+        endMs: params.endMs,
+        cacheOnly: params.cacheOnly,
+        strict: false,
+        log
+      })
+    );
+  }
   if (shouldPrepareBinanceMarketContextForRun(params)) {
     await timeOperation3("binance market context backfill", () => {
       const backfill = params.mode === "backtest" ? backfillBinanceMarketContextForBacktest : params.mode === "signals" ? backfillBinanceMarketContextForSignals : backfillBinanceMarketContextForReplay;
@@ -5557,13 +5989,13 @@ var compactReplaySignal = (signal) => {
 var import_chalk9 = __toESM(require("chalk"));
 var import_progress3 = __toESM(require("progress"));
 var import_backtest = require("@tradejs/core/backtest");
-var import_strategies2 = require("@tradejs/core/strategies");
+var import_strategies4 = require("@tradejs/core/strategies");
 var import_time3 = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
 var import_redis3 = require("@tradejs/infra/redis");
 var import_connectors6 = require("@tradejs/node/connectors");
 var import_cli4 = require("@tradejs/node/cli");
-var import_strategies3 = require("@tradejs/node/strategies");
+var import_strategies5 = require("@tradejs/node/strategies");
 
 // src/lib/replay/portfolioReplayConnector.ts
 var import_constants3 = require("@tradejs/core/constants");
@@ -6018,6 +6450,8 @@ var import_node_child_process = require("child_process");
 var import_node_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
+var import_types2 = require("@tradejs/types");
+var import_strategies3 = require("@tradejs/node/strategies");
 var RUNTIME_CONTEXT_ENV_KEYS = [
   "AI_MODE",
   "MIN_AI_QUALITY",
@@ -6035,7 +6469,12 @@ var RUNTIME_CONTEXT_ENV_KEYS = [
   "COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS",
   "COINMARKETCAP_CONTEXT_BACKFILL_ENABLED",
   "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
-  "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS"
+  "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS",
+  "HYPERLIQUID_WHALE_CONTEXT_ENABLED",
+  "HYPERLIQUID_WHALE_BACKFILL_ENABLED",
+  "HYPERLIQUID_WHALE_MIN_COVERAGE_PCT",
+  "HYPERLIQUID_WHALE_CONCURRENCY",
+  "HYPERLIQUID_WHALE_RATE_LIMIT_WEIGHT"
 ];
 var RUNTIME_CONTEXT_DATA_MODEL = {
   derivativesSourceIntervals: "15m",
@@ -6045,7 +6484,11 @@ var RUNTIME_CONTEXT_DATA_MODEL = {
   coinMarketCapAvailabilityModel: "closed-interval-all-daily",
   coinMarketCapDataModelVersion: 3,
   binanceBreadthUniverseModel: "fixed-versioned-top5-top10-top30-top50-top100",
-  binanceBreadthDataModelVersion: 2
+  binanceBreadthDataModelVersion: 2,
+  hyperliquidWhaleCanonicalInterval: "1m",
+  hyperliquidWhaleGateMinNotionalUsd: 5e4,
+  hyperliquidWhaleMinCoveragePct: 0.8,
+  hyperliquidWhaleDataModelVersion: import_types2.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
 };
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
@@ -6058,10 +6501,24 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
+var resolveRuntimeMaxLossValue = (config) => {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return null;
+  }
+  const strategyConfig = config.strategyConfig;
+  if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+    return null;
+  }
+  const maxLossValue = Number(
+    strategyConfig.MAX_LOSS_VALUE
+  );
+  return Number.isFinite(maxLossValue) ? maxLossValue : null;
+};
 var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
 var gitLineageCache = /* @__PURE__ */ new Map();
 var gateFingerprintCache = /* @__PURE__ */ new Map();
 var binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
+var snapshotFingerprintCache = /* @__PURE__ */ new Map();
 var resolveGitLineage = (projectRoot) => {
   const cached = gitLineageCache.get(projectRoot);
   if (cached) {
@@ -6135,6 +6592,24 @@ var resolveBinanceBreadthFingerprint = async (projectRoot) => {
   binanceBreadthFingerprintCache.set(projectRoot, result);
   return result;
 };
+var resolveSnapshotFingerprint = async (projectRoot, relativePath) => {
+  const cacheKey = `${projectRoot}:${relativePath}`;
+  if (snapshotFingerprintCache.has(cacheKey)) {
+    return snapshotFingerprintCache.get(cacheKey) ?? null;
+  }
+  const content = await readOptionalFile(import_node_path.default.join(projectRoot, relativePath));
+  let result = null;
+  if (content) {
+    try {
+      const parsed = JSON.parse(content.toString("utf8"));
+      result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
+    } catch {
+      result = null;
+    }
+  }
+  snapshotFingerprintCache.set(cacheKey, result);
+  return result;
+};
 var resolveGateFingerprint = async ({
   projectRoot,
   strategyName,
@@ -6150,7 +6625,8 @@ var resolveGateFingerprint = async ({
     `packages/strategies/src/${strategyName}/guardrails.ts`,
     `packages/strategies/src/${strategyName}/pockets.ts`,
     `packages/strategies/src/${strategyName}/config.ts`,
-    "packages/node/src/ai.ts"
+    "packages/node/src/ai.ts",
+    "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
   ];
   const optionalEntries = await Promise.all(
     relativeCandidates.map(async (relativePath) => {
@@ -6188,12 +6664,22 @@ var buildRuntimeLineage = async ({
   env = process.env
 }) => {
   const git = resolveGitLineage(projectRoot);
+  const hyperliquidPerpUniverseFingerprint = typeof import_strategies3.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies3.getHyperliquidPerpUniverseSnapshot)().fingerprint : await resolveSnapshotFingerprint(
+    projectRoot,
+    "packages/node/src/config/hyperliquidPerpUniverse.json"
+  );
+  const hyperliquidWhaleRegistryFingerprint = typeof import_strategies3.getHyperliquidWhaleRegistrySnapshot === "function" ? (0, import_strategies3.getHyperliquidWhaleRegistrySnapshot)().fingerprint : await resolveSnapshotFingerprint(
+    projectRoot,
+    "packages/node/src/config/hyperliquidWhales.json"
+  );
   const context = {
     ...Object.fromEntries(
       RUNTIME_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
     ),
     ...RUNTIME_CONTEXT_DATA_MODEL,
     binanceBreadthUniverseFingerprint: await resolveBinanceBreadthFingerprint(projectRoot),
+    hyperliquidPerpUniverseFingerprint,
+    hyperliquidWhaleRegistryFingerprint,
     ...runContext
   };
   return {
@@ -6205,7 +6691,8 @@ var buildRuntimeLineage = async ({
       gitSha: git.gitSha
     }),
     configFingerprint: fingerprintRuntimeValue(config),
-    contextFingerprint: fingerprintRuntimeValue(context)
+    contextFingerprint: fingerprintRuntimeValue(context),
+    maxLossValue: resolveRuntimeMaxLossValue(config)
   };
 };
 var runtimeLineageKey = (lineage) => [
@@ -6222,7 +6709,7 @@ var runtimeLineagesMatch = (left, right) => left != null && right != null && run
 var loadRuntimeStrategies = async (runtimeStrategies) => {
   const strategies = await Promise.all(
     runtimeStrategies.map(async ({ strategyName, strategyConfig }) => {
-      const strategyCreator = await (0, import_strategies3.getStrategyCreator)(
+      const strategyCreator = await (0, import_strategies5.getStrategyCreator)(
         strategyName,
         replayProjectRoot
       );
@@ -6568,7 +7055,7 @@ var runHistoricalSignalsReplay = async ({
           );
           if (result && typeof result !== "string") {
             result.runtimeLineage = strategyRuntime.runtimeLineage;
-            await (0, import_strategies3.enrichSignalWithBinanceMarketContext)({
+            await (0, import_strategies5.enrichSignalWithBinanceMarketContext)({
               signal: result,
               env: "PARITY"
             });
@@ -6592,8 +7079,8 @@ var runHistoricalSignalsReplay = async ({
     }
   } finally {
     for (const keyPrefix of sharedReplayKeyPrefixes) {
-      (0, import_strategies2.releaseStrategyIndicatorsReplayCache)(keyPrefix);
-      (0, import_strategies2.releaseStrategyReplayCache)(keyPrefix);
+      (0, import_strategies4.releaseStrategyIndicatorsReplayCache)(keyPrefix);
+      (0, import_strategies4.releaseStrategyReplayCache)(keyPrefix);
     }
   }
   const artifacts = replayConnector.getReplayArtifacts();
@@ -9629,6 +10116,7 @@ var prepareReplayBinanceMarketContext = async (preparedRun) => {
     cacheOnly: Boolean(replayFlags.cacheOnly),
     aiEnabled: preparedRun.aiEnabled,
     mlEnabled: preparedRun.mlEnabled,
+    strategyNames: preparedRun.strategyNames,
     log: (message) => console.log(import_chalk12.default.gray(message))
   });
 };
@@ -9766,7 +10254,8 @@ var replayBacktest = async () => {
     ),
     mlEnabled: replayStrategies.some(
       ({ strategyConfig }) => Boolean(strategyConfig.ML_ENABLED)
-    )
+    ),
+    strategyNames: replayStrategies.map(({ strategyName }) => strategyName)
   });
   console.log(import_chalk12.default.yellow(`tickers: ${preparedRun.tickers.length}`));
   console.log(