@tradejs/cli 3.1.16-beta.230 → 3.1.17-beta.231

package/dist/lib/runtimeDebugEvidence.js

@@ -65,9 +65,7 @@ var loadRuntimeTrades = async (userName, {
       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;
-    }
+    return windowedTrades;
   }
   const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
   const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
@@ -325,16 +323,14 @@ var collectRuntimeDebugEvidence = async ({
     signals,
     evaluations,
     evaluationStatsBuckets,
-    lineageScopes,
-    configs
+    lineageScopes
   ] = await Promise.all([
     loadRuntimeTrades(userName, { startTime, endTime }),
     loadRuntimeClosedTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
-    loadRuntimeLineageScopes(userName, { startTime, endTime }),
-    (0, import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs)(userName)
+    loadRuntimeLineageScopes(userName, { startTime, endTime })
   ]);
   const tradesByOrderId = new Map(
     entryTrades.map((trade) => [trade.orderId, trade])
@@ -359,9 +355,6 @@ var collectRuntimeDebugEvidence = async ({
     evaluationStatsBuckets: filteredStats,
     lineageScopes: lineageScopes.filter(matchesDeployment).filter(
       (scope) => !strategies?.length || strategies.includes(scope.strategy)
-    ),
-    strategyConfigs: deploymentId ? [] : configs.filter(
-      (config) => !strategies?.length || strategies.includes(config.strategyName)
     )
   };
 };
@@ -372,7 +365,6 @@ var buildRuntimeDebugReportPayload = async ({
   signals,
   evaluations,
   trades,
-  strategyConfigs,
   evaluationStatsBuckets,
   lineageScopes
 }) => {
@@ -502,8 +494,7 @@ var buildRuntimeDebugReportPayload = async ({
       signals: signals.length,
       evaluations: reportEvaluations.length,
       evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
-      lineageScopes: lineageScopes?.length ?? 0,
-      strategyConfigs: strategyConfigs?.length ?? 0
+      lineageScopes: lineageScopes?.length ?? 0
     },
     trades: debugTrades,
     signals: signals.map((signal) => ({
@@ -526,8 +517,7 @@ var buildRuntimeDebugReportPayload = async ({
       evaluation
     })),
     evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-    lineageScopes: lineageScopes ?? [],
-    strategyConfigs: strategyConfigs ?? []
+    lineageScopes: lineageScopes ?? []
   };
 };
 var buildRuntimeEvidenceReportPayload = ({
@@ -537,7 +527,6 @@ var buildRuntimeEvidenceReportPayload = ({
   signals,
   evaluations,
   trades,
-  strategyConfigs,
   evaluationStatsBuckets,
   lineageScopes
 }) => ({
@@ -556,15 +545,13 @@ var buildRuntimeEvidenceReportPayload = ({
     signals: signals.length,
     evaluations: evaluations.length,
     evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
-    lineageScopes: lineageScopes?.length ?? 0,
-    strategyConfigs: strategyConfigs?.length ?? 0
+    lineageScopes: lineageScopes?.length ?? 0
   },
   trades: trades.map((trade) => ({ trade })),
   signals: signals.map((signal) => ({ signal })),
   evaluations: evaluations.map((evaluation) => ({ evaluation })),
   evaluationStatsBuckets: evaluationStatsBuckets ?? [],
-  lineageScopes: lineageScopes ?? [],
-  strategyConfigs: strategyConfigs ?? []
+  lineageScopes: lineageScopes ?? []
 });
 var buildRuntimeDebugReportAttachment = async (params) => {
   const payload = await buildRuntimeDebugReportPayload(params);

package/dist/lib/runtimeEvidenceArtifacts.js

@@ -41,6 +41,166 @@ module.exports = __toCommonJS(runtimeEvidenceArtifacts_exports);
 var import_node_crypto = require("crypto");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
+
+// src/lib/runtimeEvidenceDeployment.ts
+var import_runtimeStrategies = 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"
+    );
+  }
+  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;
+};
+
+// src/lib/runtimeEvidenceArtifacts.ts
 var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
 var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
 var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
@@ -124,6 +284,7 @@ var publishRuntimeEvidenceBundle = async ({
   counts,
   lineageKeys
 }) => {
+  assertCurrentRuntimeEvidenceArtifact(artifact);
   const payload = `${JSON.stringify(artifact, null, 2)}
 `;
   const payloadSha256 = sha256(payload);
@@ -223,6 +384,10 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
   if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
     throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
   }
+  const deployment = assertCurrentRuntimeEvidenceArtifact(artifact);
+  if (deployment.id !== manifest.deploymentId) {
+    throw new Error(`Runtime evidence deployment mismatch in ${bundleDir}`);
+  }
   return {
     bundleDir,
     manifestPath,

package/dist/lib/runtimeEvidenceDeployment.js

@@ -21,10 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var runtimeEvidenceDeployment_exports = {};
 __export(runtimeEvidenceDeployment_exports, {
   activeRuntimeEvidenceStrategies: () => activeRuntimeEvidenceStrategies,
+  assertCurrentRuntimeEvidenceArtifact: () => assertCurrentRuntimeEvidenceArtifact,
   parseRuntimeEvidenceDeploymentSnapshot: () => parseRuntimeEvidenceDeploymentSnapshot,
   resolveRuntimeEvidenceDeploymentSnapshot: () => resolveRuntimeEvidenceDeploymentSnapshot,
   resolveRuntimeEvidenceTickerUniverse: () => resolveRuntimeEvidenceTickerUniverse,
-  runtimeDeploymentFromEvidence: () => runtimeDeploymentFromEvidence
+  runtimeDeploymentFromEvidence: () => runtimeDeploymentFromEvidence,
+  runtimeLineageMatchesStrategySnapshot: () => runtimeLineageMatchesStrategySnapshot
 });
 module.exports = __toCommonJS(runtimeEvidenceDeployment_exports);
 var import_runtimeStrategies = require("@tradejs/node/runtimeStrategies");
@@ -60,7 +62,7 @@ var samePackageVersions = (left, right) => {
   );
   return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
 };
-var lineageMatchesStrategySnapshot = ({
+var runtimeLineageMatchesStrategySnapshot = ({
   lineage,
   deployment,
   strategy
@@ -107,6 +109,82 @@ var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
   };
 };
 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"
+    );
+  }
+  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
@@ -139,7 +217,7 @@ var resolveRuntimeEvidenceTickerUniverse = ({
   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) || !lineageMatchesStrategySnapshot({
+    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !runtimeLineageMatchesStrategySnapshot({
       lineage: scope.lineage,
       deployment,
       strategy
@@ -234,8 +312,10 @@ var resolveRuntimeEvidenceDeploymentSnapshot = async ({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   activeRuntimeEvidenceStrategies,
+  assertCurrentRuntimeEvidenceArtifact,
   parseRuntimeEvidenceDeploymentSnapshot,
   resolveRuntimeEvidenceDeploymentSnapshot,
   resolveRuntimeEvidenceTickerUniverse,
-  runtimeDeploymentFromEvidence
+  runtimeDeploymentFromEvidence,
+  runtimeLineageMatchesStrategySnapshot
 });