@tradejs/cli 3.1.29-beta.262 → 3.1.29-beta.264

package/dist/scripts/replayRunner.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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-
@@ -44,7 +45,7 @@ var import_data4 = require("@tradejs/core/data");
 var import_time7 = require("@tradejs/core/time");
 var import_redis6 = require("@tradejs/infra/redis");
 var import_candles = require("@tradejs/infra/timescale/candles");
-var import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
+var import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
 var import_strategies5 = require("@tradejs/node/strategies");
 
 // src/lib/runFormatting.ts
@@ -4450,245 +4451,8 @@ var runtimeLineagesMatch = (left, right) => left != null && right != null && run
 var runtimeLineagesComparable = (left, right) => runtimeLineagesMatch(left, right) && typeof left?.maxLossValue === "number" && Number.isFinite(left.maxLossValue) && typeof right?.maxLossValue === "number" && Number.isFinite(right.maxLossValue) && left.maxLossValue === right.maxLossValue;
 
 // src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
-var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
-  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
-);
-var INTERVALS = /* @__PURE__ */ new Set([
-  "1",
-  "3",
-  "5",
-  "15",
-  "30",
-  "60",
-  "120",
-  "240",
-  "360",
-  "720",
-  "D",
-  "W",
-  "M"
-]);
-var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
-var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
-var samePackageVersions = (left, right) => {
-  if (!left || !right) return false;
-  const leftEntries = Object.entries(left).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  const rightEntries = Object.entries(right).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
-};
-var runtimeLineageMatchesStrategySnapshot = ({
-  lineage,
-  deployment,
-  strategy
-}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
-  lineage.strategyDependencyVersions,
-  strategy.strategyDependencyVersions
-);
-var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
-  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
-    throw new Error(
-      "Runtime evidence deployment snapshot is missing or invalid"
-    );
-  }
-  const strategies = value.strategies.map((candidate) => {
-    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
-      throw new Error(
-        "Runtime evidence deployment strategy snapshot is invalid"
-      );
-    }
-    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
-      throw new Error(
-        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
-      );
-    }
-    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
-      throw new Error(
-        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
-      );
-    }
-    return candidate;
-  });
-  const identities = /* @__PURE__ */ new Set();
-  for (const strategy of strategies) {
-    if (identities.has(strategy.strategyName)) {
-      throw new Error(
-        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
-      );
-    }
-    identities.add(strategy.strategyName);
-  }
-  return {
-    ...value,
-    strategies
-  };
-};
-var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
-var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
-  const record = isRecord(candidate) ? candidate : null;
-  const nested = record && isRecord(record[field]) ? record[field] : null;
-  return nested ?? record;
-}).filter((record) => record != null);
-var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
-  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
-    throw new Error("Invalid runtime evidence artifact");
-  }
-  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
-    artifact.deployment
-  );
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-  if (activeStrategies.length === 0) {
-    throw new Error("Runtime evidence deployment has no enabled strategies");
-  }
-  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
-  if (!runtime) {
-    throw new Error("Runtime evidence payload is missing");
-  }
-  if ("strategyConfigs" in runtime) {
-    throw new Error(
-      "Runtime evidence payload contains removed strategyConfigs data"
-    );
-  }
-  if ("evaluationStatsBuckets" in runtime) {
-    throw new Error(
-      "Runtime evidence payload contains removed lineage-less evaluationStatsBuckets data"
-    );
-  }
-  const rowFields = [
-    "trades",
-    "signals",
-    "evaluations",
-    "lineageScopes"
-  ];
-  for (const field of rowFields) {
-    if (!Array.isArray(runtime[field])) {
-      throw new Error(`Runtime evidence payload ${field} must be an array`);
-    }
-  }
-  const snapshots = new Map(
-    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-  );
-  const assertRows = (label, rows, lineageField) => {
-    for (const row of rows) {
-      const strategyName = String(row.strategy ?? "").trim();
-      const strategy = snapshots.get(strategyName);
-      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
-        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
-        deployment,
-        strategy
-      })) {
-        throw new Error(
-          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
-        );
-      }
-    }
-  };
-  assertRows(
-    "trade",
-    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "signal",
-    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "evaluation",
-    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "lineage scope",
-    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
-    "lineage"
-  );
-  return deployment;
-};
-var resolveRuntimeEvidenceTickerUniverse = ({
-  deployment,
-  lineageScopes,
-  fallbackTickers
-}) => {
-  const declaredTickers = deployment.tickers?.filter(isNonEmptyString) ?? [];
-  if (declaredTickers.length > 0) {
-    return {
-      ...deployment,
-      tickers: [
-        ...new Set(declaredTickers.map((ticker) => ticker.trim()))
-      ].sort()
-    };
-  }
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-  if (activeStrategies.length > 0 && activeStrategies.every((strategy) => strategy.selection?.tickers?.length)) {
-    return {
-      ...deployment,
-      tickers: [
-        ...new Set(
-          activeStrategies.flatMap(
-            (strategy) => strategy.selection?.tickers ?? []
-          )
-        )
-      ].sort()
-    };
-  }
-  const strategiesByName = new Map(
-    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-  );
-  const tickers = /* @__PURE__ */ new Set();
-  for (const scope of lineageScopes) {
-    const strategy = strategiesByName.get(scope.strategy);
-    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !runtimeLineageMatchesStrategySnapshot({
-      lineage: scope.lineage,
-      deployment,
-      strategy
-    })) {
-      continue;
-    }
-    tickers.add(scope.symbol.trim());
-  }
-  if (tickers.size === 0) {
-    const verifiedFallbackTickers = fallbackTickers?.filter(isNonEmptyString) ?? [];
-    if (verifiedFallbackTickers.length > 0) {
-      return {
-        ...deployment,
-        tickers: [
-          ...new Set(verifiedFallbackTickers.map((ticker) => ticker.trim()))
-        ].sort()
-      };
-    }
-    throw new Error(
-      "Runtime evidence has no immutable ticker universe for the embedded deployment composition"
-    );
-  }
-  return { ...deployment, tickers: [...tickers].sort() };
-};
-var runtimeDeploymentFromEvidence = (deployment) => ({
-  id: deployment.id,
-  deploymentCompositionId: deployment.deploymentCompositionId,
-  label: deployment.label,
-  connectorName: deployment.connectorName,
-  provider: deployment.provider,
-  accountId: deployment.accountId,
-  enabled: deployment.enabled,
-  strategies: deployment.strategies.map(
-    ({ strategyName, strategyRevision, enabled, controlState, selection }) => ({
-      strategyName,
-      strategyRevision,
-      enabled,
-      controlState,
-      ...selection ? { selection } : {}
-    })
-  ),
-  ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-  ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-});
+var runtimeEvidenceDeployment_exports = {};
+__reExport(runtimeEvidenceDeployment_exports, require("@tradejs/node/diagnostics"));
 
 // src/lib/replay/runtimeEvidenceSource.ts
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -4703,7 +4467,7 @@ var assertRuntimeRowsMatchDeployment = ({
   deployment
 }) => {
   const activeStrategies = new Set(
-    activeRuntimeEvidenceStrategies(deployment).map(
+    (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(deployment).map(
       ({ strategyName }) => strategyName
     )
   );
@@ -4727,7 +4491,7 @@ var readRuntimeEvidenceArtifact = async ({
   if (!root || !runtime) {
     throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
   }
-  assertCurrentRuntimeEvidenceArtifact(root);
+  (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(root);
   const rootWindow = asRecord(root.window);
   const runtimeWindow = asRecord(runtime.window);
   return {
@@ -4737,8 +4501,8 @@ var readRuntimeEvidenceArtifact = async ({
     userName: String(root.userName ?? runtime.userName ?? "").trim(),
     startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime),
     endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime),
-    deployment: resolveRuntimeEvidenceTickerUniverse({
-      deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment),
+    deployment: (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceTickerUniverse)({
+      deployment: (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(root.deployment),
       lineageScopes: unwrapRows(
         runtime.lineageScopes,
         "lineageScope"
@@ -4999,7 +4763,7 @@ var import_redis3 = require("@tradejs/infra/redis");
 var import_connectors6 = require("@tradejs/node/connectors");
 var import_cli4 = require("@tradejs/node/cli");
 var import_strategies4 = require("@tradejs/node/strategies");
-var import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
+var import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
 
 // src/lib/replay/portfolioReplayConnector.ts
 var import_constants3 = require("@tradejs/core/constants");
@@ -5990,7 +5754,7 @@ var loadRuntimeStrategies = async (runtimeStrategies) => {
       if (!strategyCreator) {
         throw new Error(`Unknown strategy: ${strategyName}`);
       }
-      const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
+      const installed = await (0, import_runtimeStrategies2.getRuntimeStrategyPackageMetadata)({
         strategyName,
         projectRoot: replayProjectRoot,
         strategyModule
@@ -9909,8 +9673,8 @@ var replayBacktest = async () => {
     );
   }
   const replayComposition = evidenceMetadata ? {
-    deployment: runtimeDeploymentFromEvidence(evidenceMetadata.deployment),
-    strategies: activeRuntimeEvidenceStrategies(
+    deployment: (0, runtimeEvidenceDeployment_exports.runtimeDeploymentFromEvidence)(evidenceMetadata.deployment),
+    strategies: (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(
       evidenceMetadata.deployment
     ).map(
       ({
@@ -9962,7 +9726,7 @@ var replayBacktest = async () => {
     return {
       ...strategy,
       strategyConfig,
-      strategyRevision: (0, import_runtimeStrategies4.computeStrategyRevision)({
+      strategyRevision: (0, import_runtimeStrategies3.computeStrategyRevision)({
         strategyName: strategy.strategyName,
         strategyPackage: strategy.strategyPackage,
         strategyPackageVersion: strategy.strategyPackageVersion,
@@ -9972,7 +9736,7 @@ var replayBacktest = async () => {
       })
     };
   });
-  const researchDeploymentCompositionId = (0, import_runtimeStrategies4.computeDeploymentCompositionId)({
+  const researchDeploymentCompositionId = (0, import_runtimeStrategies3.computeDeploymentCompositionId)({
     deploymentId: deployment.id,
     connectorName: deployment.connectorName,
     provider: deployment.provider,