@tradejs/cli 1.0.8 → 1.0.10

package/dist/lib/runtimeRedis.js

@@ -0,0 +1,157 @@
+"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/runtimeRedis.ts
+var runtimeRedis_exports = {};
+__export(runtimeRedis_exports, {
+  getRuntimeStrategyConfigKeys: () => getRuntimeStrategyConfigKeys,
+  isRuntimeStrategyEnabled: () => isRuntimeStrategyEnabled,
+  isRuntimeTradeRecord: () => isRuntimeTradeRecord,
+  loadRuntimeStrategyConfigs: () => loadRuntimeStrategyConfigs,
+  loadRuntimeStrategyNames: () => loadRuntimeStrategyNames,
+  loadRuntimeTrades: () => loadRuntimeTrades,
+  loadStrategyResultSymbols: () => loadStrategyResultSymbols,
+  resolveStrategyConfigIdentityByKey: () => resolveStrategyConfigIdentityByKey,
+  resolveStrategyNameByConfigKey: () => resolveStrategyNameByConfigKey
+});
+module.exports = __toCommonJS(runtimeRedis_exports);
+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 isRuntimeStrategyEnabled = (strategyConfig) => {
+  const enabled = strategyConfig.ENABLE;
+  return enabled !== false;
+};
+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 loadRuntimeStrategyNames = async (userName) => [
+  ...new Set(
+    (await getRuntimeStrategyConfigKeys(userName)).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value))
+  )
+].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);
+};
+var loadStrategyResultSymbols = async ({
+  userName,
+  strategy
+}) => {
+  const results = await (0, import_redis.getData)(
+    import_redis.redisKeys.strategyResults(userName, strategy),
+    {}
+  );
+  return Object.keys(results ?? {}).sort(
+    (left, right) => left.localeCompare(right)
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRuntimeStrategyConfigKeys,
+  isRuntimeStrategyEnabled,
+  isRuntimeTradeRecord,
+  loadRuntimeStrategyConfigs,
+  loadRuntimeStrategyNames,
+  loadRuntimeTrades,
+  loadStrategyResultSymbols,
+  resolveStrategyConfigIdentityByKey,
+  resolveStrategyNameByConfigKey
+});

package/dist/lib/runtimeSignalsLoader.js

@@ -0,0 +1,187 @@
+"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/runtimeSignalsLoader.ts
+var runtimeSignalsLoader_exports = {};
+__export(runtimeSignalsLoader_exports, {
+  isRuntimeSignalEvaluationRecord: () => isRuntimeSignalEvaluationRecord,
+  isSignalRecord: () => isSignalRecord,
+  loadRuntimeSignalEvaluationStatsBuckets: () => loadRuntimeSignalEvaluationStatsBuckets,
+  loadRuntimeSignalEvaluations: () => loadRuntimeSignalEvaluations,
+  loadRuntimeSignals: () => loadRuntimeSignals
+});
+module.exports = __toCommonJS(runtimeSignalsLoader_exports);
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var import_constants = require("@tradejs/core/constants");
+var import_time = 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_time.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_redis.redisKeys.runtimeSignalBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis.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_redis.getData)(
+        import_redis.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_redis.redisKeys.runtimeSignalEvaluationBuckets(userName);
+  const bucketKeys = filterBucketKeysByWindow(
+    await (0, import_redis.getKeys)(bucketPrefix),
+    bucketPrefix,
+    startTime,
+    endTime
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis.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_redis.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis.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_redis.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRuntimeSignalEvaluationRecord,
+  isSignalRecord,
+  loadRuntimeSignalEvaluationStatsBuckets,
+  loadRuntimeSignalEvaluations,
+  loadRuntimeSignals
+});

package/dist/lib/runtimeSignalsStorage.js

@@ -0,0 +1,185 @@
+"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/runtimeSignalsStorage.ts
+var runtimeSignalsStorage_exports = {};
+__export(runtimeSignalsStorage_exports, {
+  DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS: () => DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS,
+  RUNTIME_SIGNAL_RETENTION_DAYS_ENV: () => RUNTIME_SIGNAL_RETENTION_DAYS_ENV,
+  buildRuntimeSignalStatsIncrements: () => buildRuntimeSignalStatsIncrements,
+  getRuntimeSignalRetentionTtlSeconds: () => getRuntimeSignalRetentionTtlSeconds,
+  getRuntimeStorageDayKey: () => import_time.getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys: () => import_time.getRuntimeStorageDayKeys,
+  isRuntimeSignalBucketRef: () => isRuntimeSignalBucketRef,
+  normalizeRuntimeSignalSkipReason: () => normalizeRuntimeSignalSkipReason,
+  parseRuntimeSignalStatsBucket: () => parseRuntimeSignalStatsBucket,
+  shouldStoreDetailedRuntimeSignalEvaluation: () => shouldStoreDetailedRuntimeSignalEvaluation,
+  shouldStoreRuntimeSignalDiagnostics: () => shouldStoreRuntimeSignalDiagnostics,
+  toRuntimeSignalBucketRef: () => toRuntimeSignalBucketRef,
+  toStoredRuntimeSignal: () => toStoredRuntimeSignal
+});
+module.exports = __toCommonJS(runtimeSignalsStorage_exports);
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var SECONDS_PER_DAY = 86400;
+var RUNTIME_SIGNAL_RETENTION_DAYS_ENV = "RUNTIME_SIGNAL_RETENTION_DAYS";
+var DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS = import_constants.TTL_3D;
+var parsePositiveNumber = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+var getRuntimeSignalRetentionTtlSeconds = () => {
+  const explicitDays = parsePositiveNumber(
+    process.env[RUNTIME_SIGNAL_RETENTION_DAYS_ENV]
+  );
+  if (explicitDays != null) {
+    return Math.ceil(explicitDays * SECONDS_PER_DAY);
+  }
+  return DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS;
+};
+var toRuntimeSignalBucketRef = (signal) => ({
+  signalId: signal.signalId,
+  symbol: signal.symbol,
+  strategy: signal.strategy,
+  timestamp: signal.timestamp,
+  ...signal.runtimeConfigId && signal.runtimeConfigId !== "config" ? { runtimeConfigId: signal.runtimeConfigId } : {}
+});
+var shouldStoreRuntimeSignalDiagnostics = (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed";
+var toStoredRuntimeSignal = (signal) => {
+  if (shouldStoreRuntimeSignalDiagnostics(signal)) {
+    return signal;
+  }
+  const stored = { ...signal };
+  delete stored.figures;
+  delete stored.indicators;
+  delete stored.additionalIndicators;
+  return stored;
+};
+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 normalizeRuntimeSignalSkipReason = (reason, fallbackSource) => {
+  let source = fallbackSource;
+  let normalizedReason = reason;
+  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
+    source = "AI";
+    normalizedReason = "MIN_AI_QUALITY";
+  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
+    source = "AI";
+    normalizedReason = "QUALITY_UNAVAILABLE";
+  } else if (reason === "ML_RESULT_UNAVAILABLE") {
+    source = "ML";
+    normalizedReason = "RESULT_UNAVAILABLE";
+  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
+    source = "ML";
+    normalizedReason = "ML_THRESHOLD";
+  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
+    source = "hook";
+    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
+      "HOOK_BEFORE_ENTRY_GATE:".length
+    )}`;
+  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
+    source = "hook";
+    normalizedReason = "BEFORE_ENTRY_GATE";
+  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
+    source = "policy";
+  }
+  return {
+    source: `skip from ${source}`,
+    reason: normalizedReason
+  };
+};
+var buildStatsReasonField = (source, reason) => `reason:${source}:${reason}`;
+var buildRuntimeSignalStatsIncrements = (evaluation) => {
+  const increments = {
+    evaluated: 1
+  };
+  if (evaluation.status === "signal") {
+    increments.signals = 1;
+  }
+  let skipReason = null;
+  let fallbackSource = "core";
+  if (evaluation.status === "skip") {
+    skipReason = evaluation.reason || "NO_SIGNAL";
+    fallbackSource = "core";
+  } else if (evaluation.status === "signal" && (evaluation.orderStatus === "skipped" || evaluation.orderStatus === "canceled")) {
+    skipReason = evaluation.orderSkipReason || evaluation.reason || `orderStatus=${evaluation.orderStatus}`;
+    fallbackSource = "runtime";
+  } else if (evaluation.status === "error") {
+    skipReason = evaluation.reason || "EVALUATION_ERROR";
+    fallbackSource = "runtime";
+  }
+  if (skipReason) {
+    const normalized = normalizeRuntimeSignalSkipReason(
+      skipReason,
+      fallbackSource
+    );
+    increments[buildStatsReasonField(normalized.source, normalized.reason)] = 1;
+  }
+  return increments;
+};
+var shouldStoreDetailedRuntimeSignalEvaluation = (evaluation) => evaluation.status !== "skip";
+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
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS,
+  RUNTIME_SIGNAL_RETENTION_DAYS_ENV,
+  buildRuntimeSignalStatsIncrements,
+  getRuntimeSignalRetentionTtlSeconds,
+  getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys,
+  isRuntimeSignalBucketRef,
+  normalizeRuntimeSignalSkipReason,
+  parseRuntimeSignalStatsBucket,
+  shouldStoreDetailedRuntimeSignalEvaluation,
+  shouldStoreRuntimeSignalDiagnostics,
+  toRuntimeSignalBucketRef,
+  toStoredRuntimeSignal
+});

package/dist/lib/runtimeStrategyBacktest.js

@@ -0,0 +1,134 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeStrategyBacktest.ts
+var runtimeStrategyBacktest_exports = {};
+__export(runtimeStrategyBacktest_exports, {
+  BACKTEST_CLI_RUNTIME_CONFIG_KEYS: () => BACKTEST_CLI_RUNTIME_CONFIG_KEYS,
+  loadRuntimeStrategyBacktestConfigs: () => loadRuntimeStrategyBacktestConfigs,
+  toStrategyConfigGrid: () => toStrategyConfigGrid
+});
+module.exports = __toCommonJS(runtimeStrategyBacktest_exports);
+var import_chalk = __toESM(require("chalk"));
+
+// 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 isRuntimeStrategyEnabled = (strategyConfig) => {
+  const enabled = strategyConfig.ENABLE;
+  return enabled !== false;
+};
+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);
+};
+
+// src/lib/runtimeStrategyBacktest.ts
+var BACKTEST_CLI_RUNTIME_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "ENV",
+  "INTERVAL",
+  "MAKE_ORDERS",
+  "CLOSE_OPPOSITE_POSITIONS",
+  "BACKTEST_PRICE_MODE",
+  "BACKTEST_ENTRY_DELAY_BARS"
+]);
+var toStrategyConfigGrid = (strategyConfig) => Object.fromEntries(
+  Object.entries(strategyConfig).filter(([key]) => !BACKTEST_CLI_RUNTIME_CONFIG_KEYS.has(key)).map(([key, value]) => [key, [value]])
+);
+var loadRuntimeStrategyBacktestConfigs = async (userName) => {
+  const configs = await loadRuntimeStrategyConfigs(userName, {
+    onInvalidConfig: (key) => {
+      console.log(import_chalk.default.yellow(`Skip invalid runtime strategy config: ${key}`));
+    }
+  });
+  return configs.filter(({ configId }) => configId === "config").filter(({ strategyName, strategyConfig }) => {
+    const enabled = isRuntimeStrategyEnabled(strategyConfig);
+    if (!enabled) {
+      console.log(
+        import_chalk.default.yellow(
+          `Skip inactive runtime strategy config by ENABLE=false: ${strategyName}`
+        )
+      );
+    }
+    return enabled;
+  }).map(({ strategyName, strategyConfig }) => ({
+    strategyName,
+    strategyConfig,
+    backtestConfig: toStrategyConfigGrid(strategyConfig)
+  }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACKTEST_CLI_RUNTIME_CONFIG_KEYS,
+  loadRuntimeStrategyBacktestConfigs,
+  toStrategyConfigGrid
+});