@tradejs/cli 1.0.8 → 1.0.10

package/dist/scripts/runtimeEvidence.js

@@ -0,0 +1,605 @@
+"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/scripts/runtimeEvidence.ts
+var runtimeEvidence_exports = {};
+__export(runtimeEvidence_exports, {
+  main: () => main,
+  runtimeEvidence: () => runtimeEvidence
+});
+module.exports = __toCommonJS(runtimeEvidence_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/lib/runtimeDebugEvidence.ts
+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 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 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 ?? []
+  };
+};
+
+// src/scripts/runtimeEvidence.ts
+import_args.default.option(["u", "user"], "Use user config", "root");
+import_args.default.option(
+  ["S", "startTime"],
+  "Window start timestamp, seconds/ms, or ISO date"
+);
+import_args.default.option(["E", "endTime"], "Window end timestamp, seconds/ms, or ISO date");
+import_args.default.option(
+  ["H", "hours"],
+  "Fallback window in hours when start/end are omitted",
+  24
+);
+import_args.default.option(["s", "strategy"], "Strategy filter, comma-separated");
+import_args.default.option(["o", "out"], "Output JSON path", "output/runtime-evidence.json");
+var flags = import_args.default.parse(process.argv);
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var toEpochMs = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const raw = String(value).trim();
+  if (/^\d+$/.test(raw)) {
+    const parsed2 = Number(raw);
+    return parsed2 < 1e12 ? Math.trunc(parsed2 * 1e3) : Math.trunc(parsed2);
+  }
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var resolveWindow = () => {
+  const endTime = toEpochMs(flags.endTime) ?? Date.now();
+  const hours = Math.max(
+    1,
+    Number.parseInt(String(flags.hours ?? 24), 10) || 24
+  );
+  const startTime = toEpochMs(flags.startTime) ?? endTime - hours * 60 * 60 * 1e3;
+  if (startTime >= endTime) {
+    throw new Error(
+      `Invalid window: startTime (${startTime}) must be less than endTime (${endTime})`
+    );
+  }
+  return {
+    startTime,
+    endTime,
+    source: flags.startTime != null || flags.endTime != null ? "explicit" : "hours"
+  };
+};
+var parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
+var runtimeEvidence = async () => {
+  const { startTime, endTime, source } = resolveWindow();
+  const strategies = parseStrategyFilter(flags.strategy);
+  const evidence = await collectRuntimeDebugEvidence({
+    userName: flags.user,
+    startTime,
+    endTime,
+    strategies: strategies.length ? strategies : void 0
+  });
+  const runtime = await buildRuntimeDebugReportPayload({
+    userName: flags.user,
+    startTime,
+    endTime,
+    signals: evidence.signals,
+    evaluations: evidence.evaluations,
+    trades: evidence.trades,
+    strategyConfigs: evidence.strategyConfigs,
+    evaluationStatsBuckets: evidence.evaluationStatsBuckets
+  });
+  const artifact = {
+    reportType: "runtime-evidence",
+    generatedAt: Date.now(),
+    userName: flags.user,
+    window: {
+      startTime,
+      endTime,
+      startIso: new Date(startTime).toISOString(),
+      endIso: new Date(endTime).toISOString(),
+      source
+    },
+    strategies,
+    runtime
+  };
+  const outPath = import_node_path.default.resolve(projectRoot, String(flags.out));
+  await import_promises.default.mkdir(import_node_path.default.dirname(outPath), { recursive: true });
+  await import_promises.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+  console.log(import_chalk.default.green(`Wrote ${outPath}`));
+  console.log(
+    JSON.stringify(
+      {
+        strategies: artifact.strategies,
+        runtimeCounts: artifact.runtime.counts
+      },
+      null,
+      2
+    )
+  );
+};
+var main = runtimeEvidence;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main,
+  runtimeEvidence
+});