@tradejs/cli 1.0.9 → 1.0.10

package/dist/lib/runtimeDebugEvidence.js

@@ -0,0 +1,526 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeDebugEvidence.ts
+var runtimeDebugEvidence_exports = {};
+__export(runtimeDebugEvidence_exports, {
+  RUNTIME_DEBUG_TIMEZONE: () => RUNTIME_DEBUG_TIMEZONE,
+  RUNTIME_DEBUG_TIMEZONE_LABEL: () => RUNTIME_DEBUG_TIMEZONE_LABEL,
+  buildRuntimeDebugEvaluationId: () => buildRuntimeDebugEvaluationId,
+  buildRuntimeDebugReportAttachment: () => buildRuntimeDebugReportAttachment,
+  buildRuntimeDebugReportPayload: () => buildRuntimeDebugReportPayload,
+  collectRuntimeDebugEvidence: () => collectRuntimeDebugEvidence
+});
+module.exports = __toCommonJS(runtimeDebugEvidence_exports);
+var import_redis3 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeRedis.ts
+var import_redis = require("@tradejs/infra/redis");
+var import_time = require("@tradejs/core/time");
+var RESERVED_STRATEGY_NAMES = /* @__PURE__ */ new Set(["charts"]);
+var RESERVED_CONFIG_IDS = /* @__PURE__ */ new Set(["results"]);
+var resolveStrategyConfigIdentityByKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) return null;
+  const [users, keyUserName, strategiesKey, strategyName, configId] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || !strategyName || !configId || RESERVED_STRATEGY_NAMES.has(strategyName) || RESERVED_CONFIG_IDS.has(configId) || !/^[a-zA-Z0-9_-]+$/.test(configId)) {
+    return null;
+  }
+  return { strategyName, configId };
+};
+var isRuntimeTradeRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
+};
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  return resolveStrategyConfigIdentityByKey(userName, key)?.strategyName ?? null;
+};
+var getRuntimeStrategyConfigKeys = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => resolveStrategyConfigIdentityByKey(userName, key)).sort((left, right) => left.localeCompare(right));
+};
+var loadRuntimeStrategyConfigs = async (userName, {
+  onInvalidConfig
+} = {}) => {
+  const configKeys = await getRuntimeStrategyConfigKeys(userName);
+  const strategyConfigs = await Promise.all(
+    configKeys.map(async (key) => {
+      const strategyName = resolveStrategyNameByConfigKey(userName, key);
+      const identity = resolveStrategyConfigIdentityByKey(userName, key);
+      if (!strategyName || !identity) {
+        return null;
+      }
+      const strategyConfig = await (0, import_redis.getData)(
+        key,
+        null
+      );
+      if (!strategyConfig || typeof strategyConfig !== "object" || Array.isArray(strategyConfig)) {
+        onInvalidConfig?.(key);
+        return null;
+      }
+      return {
+        key,
+        strategyName,
+        configId: identity.configId,
+        strategyConfig
+      };
+    })
+  );
+  return strategyConfigs.filter(Boolean);
+};
+var loadRuntimeTrades = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
+  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
+  if (hasWindow) {
+    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+    const bucketTrades = (await Promise.all(
+      dayKeys.map(
+        (dayKey) => (0, import_redis.getHashJsonValues)(
+          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
+        )
+      )
+    )).flat();
+    const dedupedBucketTrades = /* @__PURE__ */ new Map();
+    for (const trade of bucketTrades) {
+      if (!isRuntimeTradeRecord(trade)) {
+        continue;
+      }
+      dedupedBucketTrades.set(trade.orderId, trade);
+    }
+    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+    if (windowedTrades.length > 0 || dayKeys.length === 0) {
+      return windowedTrades;
+    }
+  }
+  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
+  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
+    (key) => !key.startsWith(bucketPrefix)
+  );
+  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var import_redis2 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var import_constants = require("@tradejs/core/constants");
+var import_time2 = require("@tradejs/core/time");
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var isSignalRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
+};
+var isRuntimeSignalEvaluationRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
+};
+var sortByTimestamp = (records) => [...records].sort((left, right) => left.timestamp - right.timestamp);
+var filterBucketKeysByWindow = (bucketKeys, prefix, startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime) || startTime == null || endTime == null) {
+    return bucketKeys;
+  }
+  const allowedDayKeys = new Set((0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime));
+  if (!allowedDayKeys.size) {
+    return [];
+  }
+  return bucketKeys.filter((key) => {
+    const suffix = key.slice(prefix.length);
+    const firstColon = suffix.indexOf(":");
+    if (firstColon <= 0) {
+      return false;
+    }
+    return allowedDayKeys.has(suffix.slice(0, firstColon));
+  });
+};
+var loadRuntimeSignals = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis2.redisKeys.runtimeSignalBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis2.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis2.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const seen = /* @__PURE__ */ new Set();
+  const payloads = await Promise.all(
+    refs.map(async (ref) => {
+      const dedupeKey = `${ref.symbol}:${ref.signalId}`;
+      if (seen.has(dedupeKey)) {
+        return null;
+      }
+      seen.add(dedupeKey);
+      const signal = await (0, import_redis2.getData)(
+        import_redis2.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var loadRuntimeSignalEvaluations = async (userName, {
+  startTime,
+  endTime
+} = {}) => {
+  const bucketPrefix = import_redis2.redisKeys.runtimeSignalEvaluationBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis2.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis2.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    deduped.set(evaluation.evaluationId, evaluation);
+  }
+  return sortByTimestamp([...deduped.values()]);
+};
+var parseBucketKey = (prefix, key) => {
+  if (!key.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = key.slice(prefix.length);
+  const firstColon = suffix.indexOf(":");
+  if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+    return null;
+  }
+  return {
+    dayKey: suffix.slice(0, firstColon),
+    strategy: suffix.slice(firstColon + 1)
+  };
+};
+var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
+  const prefix = import_redis2.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis2.getKeys)(prefix);
+  const entries = await Promise.all(
+    keys.map(async (key) => {
+      const parsedKey = parseBucketKey(prefix, key);
+      if (!parsedKey) {
+        return null;
+      }
+      return {
+        key,
+        ...parsedKey,
+        stats: parseRuntimeSignalStatsBucket(await (0, import_redis2.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+
+// src/lib/runtimeDebugEvidence.ts
+var RUNTIME_DEBUG_TIMEZONE = "Europe/Moscow";
+var RUNTIME_DEBUG_TIMEZONE_LABEL = "MSK";
+var formatRuntimeDebugDateTime = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+  timeZone: RUNTIME_DEBUG_TIMEZONE,
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour: "2-digit",
+  minute: "2-digit",
+  hour12: false
+}).format(new Date(timestamp));
+var getRuntimeDebugDateParts = (timestamp) => Object.fromEntries(
+  new Intl.DateTimeFormat("en-US", {
+    timeZone: RUNTIME_DEBUG_TIMEZONE,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(new Date(timestamp)).map((part) => [part.type, part.value])
+);
+var formatRuntimeDebugIsoDayKey = (timestamp) => {
+  const parts = getRuntimeDebugDateParts(timestamp);
+  return `${parts.year}-${parts.month}-${parts.day}`;
+};
+var buildRuntimeDebugEvaluationId = ({
+  strategy,
+  symbol,
+  timestamp
+}) => `${strategy}:${symbol}:${timestamp}`;
+var filterByStrategies = (values, strategies) => {
+  if (!strategies?.length) {
+    return values;
+  }
+  const strategySet = new Set(strategies);
+  return values.filter((value) => strategySet.has(value.strategy));
+};
+var collectRuntimeDebugEvidence = async ({
+  userName,
+  startTime,
+  endTime,
+  strategies
+}) => {
+  const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
+  const dayKeySet = new Set(dayKeys);
+  const [trades, signals, evaluations, evaluationStatsBuckets, configs] = await Promise.all([
+    loadRuntimeTrades(userName, { startTime, endTime }),
+    loadRuntimeSignals(userName, { startTime, endTime }),
+    loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
+    loadRuntimeSignalEvaluationStatsBuckets(userName),
+    loadRuntimeStrategyConfigs(userName)
+  ]);
+  const filteredStats = evaluationStatsBuckets.filter(
+    (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
+  );
+  return {
+    dayKeys,
+    trades: filterByStrategies(trades, strategies),
+    signals: filterByStrategies(signals, strategies),
+    evaluations: filterByStrategies(evaluations, strategies),
+    evaluationStatsBuckets: filteredStats,
+    strategyConfigs: configs.filter(
+      (config) => !strategies?.length || strategies.includes(config.strategyName)
+    )
+  };
+};
+var buildRuntimeDebugReportPayload = async ({
+  userName,
+  startTime,
+  endTime,
+  signals,
+  evaluations,
+  trades,
+  strategyConfigs,
+  evaluationStatsBuckets
+}) => {
+  const signalById = new Map(
+    signals.map((signal) => [signal.signalId, signal])
+  );
+  const evaluationById = new Map(
+    evaluations.map((evaluation) => [evaluation.evaluationId, evaluation])
+  );
+  const evaluationBySignalShape = new Map(
+    evaluations.map((evaluation) => [
+      buildRuntimeDebugEvaluationId(evaluation),
+      evaluation
+    ])
+  );
+  const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
+  const debugTrades = await Promise.all(
+    trades.map(async (trade) => {
+      const signal = trade.signalId != null ? signalById.get(trade.signalId) : void 0;
+      const evaluationId = buildRuntimeDebugEvaluationId({
+        strategy: trade.strategy,
+        symbol: trade.symbol,
+        timestamp: signal?.timestamp ?? trade.entryTimestamp
+      });
+      const knownEvaluation = evaluationById.get(evaluationId) ?? evaluationBySignalShape.get(evaluationId);
+      const tradeDayKey = (0, import_time2.getRuntimeStorageDayKey)(trade.entryTimestamp);
+      const signalDayKey = signal != null ? (0, import_time2.getRuntimeStorageDayKey)(signal.timestamp) : tradeDayKey;
+      const evaluationDayKey = knownEvaluation != null ? (0, import_time2.getRuntimeStorageDayKey)(knownEvaluation.timestamp) : signalDayKey;
+      const tradeKey = import_redis3.redisKeys.runtimeTrade(userName, trade.orderId);
+      const tradeBucketKey = import_redis3.redisKeys.runtimeTradeBucket(
+        userName,
+        tradeDayKey
+      );
+      const activeTradeKey = import_redis3.redisKeys.runtimeActiveTrade(
+        userName,
+        trade.symbol
+      );
+      const signalKey = trade.signalId != null ? import_redis3.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
+      const evaluationBucketKey = import_redis3.redisKeys.runtimeSignalEvaluationBucket(
+        userName,
+        evaluationDayKey,
+        knownEvaluation?.strategy ?? trade.strategy
+      );
+      const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
+      const evaluationKey = import_redis3.redisKeys.runtimeSignalEvaluation(
+        userName,
+        evaluationField
+      );
+      const [
+        tradeValue,
+        activeTradeValue,
+        signalValue,
+        directEvaluationValue,
+        bucketEvaluationValue
+      ] = await Promise.all([
+        (0, import_redis3.getData)(tradeKey, null),
+        (0, import_redis3.getData)(activeTradeKey, null),
+        signalKey ? (0, import_redis3.getData)(signalKey, null) : Promise.resolve(null),
+        (0, import_redis3.getData)(evaluationKey, null),
+        knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis3.getHashJsonField)(
+          evaluationBucketKey,
+          evaluationField,
+          null
+        )
+      ]);
+      const evaluationValue = directEvaluationValue ?? bucketEvaluationValue ?? knownEvaluation ?? null;
+      return {
+        redisDebug: {
+          trade: tradeKey,
+          tradeBucket: {
+            key: tradeBucketKey,
+            field: trade.orderId
+          },
+          activeTrade: activeTradeKey,
+          signal: signalKey,
+          evaluation: {
+            key: evaluationBucketKey,
+            field: evaluationField,
+            directKey: evaluationKey
+          }
+        },
+        trade,
+        redisValues: {
+          trade: tradeValue,
+          tradeBucket: trade,
+          activeTrade: activeTradeValue,
+          signal: signalValue ?? signal ?? null,
+          evaluation: evaluationValue ?? knownEvaluation ?? null
+        }
+      };
+    })
+  );
+  const linkedEvaluations = /* @__PURE__ */ new Map();
+  for (const trade of debugTrades) {
+    const evaluation = trade.redisValues.evaluation;
+    if (evaluation && typeof evaluation === "object" && "evaluationId" in evaluation && typeof evaluation.evaluationId === "string") {
+      linkedEvaluations.set(
+        evaluation.evaluationId,
+        evaluation
+      );
+    }
+  }
+  const reportEvaluations = evaluations.length > 0 ? evaluations : [...linkedEvaluations.values()];
+  return {
+    reportType: "runtime-daily-debug",
+    generatedAt: Date.now(),
+    generatedAtMsk: formatRuntimeDebugDateTime(Date.now()),
+    userName,
+    window: {
+      startTime,
+      endTime,
+      startMsk: formatRuntimeDebugDateTime(startTime),
+      endMsk: formatRuntimeDebugDateTime(endTime),
+      dayKeys
+    },
+    redisPrefixes: {
+      runtimeTrades: import_redis3.redisKeys.runtimeTrades(userName),
+      runtimeTradeBuckets: import_redis3.redisKeys.runtimeTradeBuckets(userName),
+      runtimeActiveTrades: import_redis3.redisKeys.runtimeActiveTrades(userName),
+      runtimeSignals: import_redis3.redisKeys.runtimeSignalBuckets(userName),
+      runtimeSignalEvaluations: import_redis3.redisKeys.runtimeSignalEvaluationBuckets(userName),
+      runtimeSignalEvaluationStats: import_redis3.redisKeys.runtimeSignalEvaluationStatsBuckets(userName)
+    },
+    counts: {
+      trades: trades.length,
+      signals: signals.length,
+      evaluations: reportEvaluations.length,
+      evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+      strategyConfigs: strategyConfigs?.length ?? 0
+    },
+    trades: debugTrades,
+    signals: signals.map((signal) => ({
+      redisKey: import_redis3.redisKeys.storeSignal(signal.symbol, signal.signalId),
+      signal
+    })),
+    evaluations: reportEvaluations.map((evaluation) => ({
+      redisDebug: {
+        key: import_redis3.redisKeys.runtimeSignalEvaluationBucket(
+          userName,
+          (0, import_time2.getRuntimeStorageDayKey)(evaluation.timestamp),
+          evaluation.strategy
+        ),
+        field: evaluation.evaluationId,
+        directKey: import_redis3.redisKeys.runtimeSignalEvaluation(
+          userName,
+          evaluation.evaluationId
+        )
+      },
+      evaluation
+    })),
+    evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+    strategyConfigs: strategyConfigs ?? []
+  };
+};
+var buildRuntimeDebugReportAttachment = async (params) => {
+  const payload = await buildRuntimeDebugReportPayload(params);
+  const dayKey = formatRuntimeDebugIsoDayKey(params.endTime);
+  return {
+    filename: `tradejs-runtime-debug-${params.userName}-${dayKey}.json`,
+    content: JSON.stringify(payload, null, 2),
+    caption: `Runtime debug ${dayKey} ${RUNTIME_DEBUG_TIMEZONE_LABEL}`,
+    summary: {
+      trades: payload.counts.trades,
+      signals: payload.counts.signals,
+      evaluations: payload.counts.evaluations
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNTIME_DEBUG_TIMEZONE,
+  RUNTIME_DEBUG_TIMEZONE_LABEL,
+  buildRuntimeDebugEvaluationId,
+  buildRuntimeDebugReportAttachment,
+  buildRuntimeDebugReportPayload,
+  collectRuntimeDebugEvidence
+});

package/dist/lib/runtimeModeConfig.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeModeConfig.ts
+var runtimeModeConfig_exports = {};
+__export(runtimeModeConfig_exports, {
+  buildRuntimeModeStrategyConfig: () => buildRuntimeModeStrategyConfig,
+  hasRuntimeEntryGateEnabled: () => hasRuntimeEntryGateEnabled,
+  resolveReplayStrategyEnv: () => resolveReplayStrategyEnv
+});
+module.exports = __toCommonJS(runtimeModeConfig_exports);
+var hasRuntimeEntryGateEnabled = (strategyConfig) => strategyConfig.AI_ENABLED === true || strategyConfig.ML_ENABLED === true;
+var resolveReplayStrategyEnv = ({
+  strategyConfig,
+  forceRuntimeGates = false
+}) => forceRuntimeGates || hasRuntimeEntryGateEnabled(strategyConfig) ? "PARITY" : "BACKTEST";
+var buildRuntimeModeStrategyConfig = ({
+  strategyConfig,
+  env,
+  interval,
+  makeOrders,
+  recordRuntimeTrades,
+  aiReplayAnalyses
+}) => ({
+  ...strategyConfig,
+  ENV: env,
+  MAKE_ORDERS: makeOrders,
+  INTERVAL: interval,
+  ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
+  ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRuntimeModeStrategyConfig,
+  hasRuntimeEntryGateEnabled,
+  resolveReplayStrategyEnv
+});