@tradejs/cli 3.1.27-beta.248 → 3.1.27-beta.250

package/dist/scripts/runtimeEvidence.js

@@ -34,8 +34,8 @@ __export(runtimeEvidence_exports, {
   runtimeEvidence: () => runtimeEvidence
 });
 module.exports = __toCommonJS(runtimeEvidence_exports);
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path4 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -851,35 +851,51 @@ var verifyRuntimeEvidenceBundle = async (bundleDir) => {
     artifact
   };
 };
-
-// src/lib/runtimeLineage.ts
-var import_node_crypto2 = require("crypto");
-var normalizeForStableJson = (value) => {
-  if (Array.isArray(value)) {
-    return value.map(normalizeForStableJson);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+var discoverRuntimeEvidenceBundles = async (rootDir) => {
+  const bundles = [];
+  const visit = async (directory, depth) => {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = await import_promises.default.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    const names = new Set(entries.map((entry) => entry.name));
+    if (names.has(RUNTIME_EVIDENCE_MANIFEST_FILE) && names.has(RUNTIME_EVIDENCE_PAYLOAD_FILE) && names.has(RUNTIME_EVIDENCE_COMPLETE_FILE)) {
+      bundles.push(directory);
+      return;
+    }
+    await Promise.all(
+      entries.filter(
+        (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+      ).map((entry) => visit(import_node_path.default.join(directory, entry.name), depth + 1))
     );
-  }
-  return value;
+  };
+  await visit(rootDir, 0);
+  return bundles.sort();
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
-var runtimeLineageKey = (lineage) => [
-  "v3",
-  lineage.deploymentCompositionId,
-  lineage.strategyRevision,
-  lineage.strategyPackageVersion,
-  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
-  lineage.runtimePackageVersion
-].join(":");
 
-// src/lib/runtimeEvidenceProducer.ts
+// src/lib/runtimeEvidenceCompositionSnapshots.ts
 var import_node_crypto3 = require("crypto");
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
+
+// src/lib/runtimeEvidenceProducer.ts
+var import_node_crypto2 = require("crypto");
 var import_promises2 = __toESM(require("fs/promises"));
 var import_node_path2 = __toESM(require("path"));
-var sha2562 = (value) => (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
+var isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var sha2562 = (value) => (0, import_node_crypto2.createHash)("sha256").update(value).digest("hex");
+var parseRuntimeEvidenceProducer = (value) => {
+  const producer = isRecord2(value) ? value : null;
+  const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
+  if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
+    throw new Error("Runtime evidence producer image identity is invalid");
+  }
+  return producer;
+};
 var resolveRuntimeEvidenceProducer = async ({
   projectRoot: projectRoot2,
   required
@@ -925,6 +941,241 @@ var resolveRuntimeEvidenceProducer = async ({
   };
 };
 
+// src/lib/runtimeEvidenceCompositionSnapshots.ts
+var SNAPSHOT_FILE = "snapshot.json";
+var MANIFEST_FILE = "manifest.json";
+var COMPLETE_FILE = ".complete";
+var isRecord3 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var sha2563 = (value) => (0, import_node_crypto3.createHash)("sha256").update(value).digest("hex");
+var parseManifest2 = (value) => {
+  const manifest = isRecord3(value) ? value : null;
+  const payload = isRecord3(manifest?.payload) ? manifest.payload : null;
+  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence-composition-snapshot" || typeof manifest.createdAt !== "number" || typeof manifest.userName !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.deploymentCompositionId !== "string" || payload?.file !== SNAPSHOT_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number") {
+    throw new Error("Invalid runtime evidence composition snapshot manifest");
+  }
+  return manifest;
+};
+var verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
+  const [manifestText, payload, completeText] = await Promise.all([
+    import_promises3.default.readFile(import_node_path3.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+    import_promises3.default.readFile(import_node_path3.default.join(bundleDir, SNAPSHOT_FILE)),
+    import_promises3.default.readFile(import_node_path3.default.join(bundleDir, COMPLETE_FILE), "utf8")
+  ]);
+  const manifest = parseManifest2(JSON.parse(manifestText));
+  if (completeText.trim() !== manifest.deploymentCompositionId) {
+    throw new Error(`Invalid completion marker in ${bundleDir}`);
+  }
+  if (payload.byteLength !== manifest.payload.bytes || sha2563(payload) !== manifest.payload.sha256) {
+    throw new Error(
+      `Runtime evidence snapshot checksum mismatch in ${bundleDir}`
+    );
+  }
+  const value = JSON.parse(payload.toString("utf8"));
+  const record = isRecord3(value) ? value : null;
+  if (record?.schemaVersion !== 1 || record.reportType !== "runtime-evidence-composition-snapshot" || record.userName !== manifest.userName) {
+    throw new Error(
+      `Invalid runtime evidence snapshot payload in ${bundleDir}`
+    );
+  }
+  const deployment = parseRuntimeEvidenceDeploymentSnapshot(record.deployment);
+  const producer = parseRuntimeEvidenceProducer(record.producer);
+  if (deployment.id !== manifest.deploymentId || deployment.deploymentCompositionId !== manifest.deploymentCompositionId) {
+    throw new Error(
+      `Runtime evidence snapshot identity mismatch in ${bundleDir}`
+    );
+  }
+  return { bundleDir, deployment, producer };
+};
+var discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
+  const rootDir = import_node_path3.default.join(evidenceRoot, "snapshots");
+  const bundleDirs = [];
+  let deployments;
+  try {
+    deployments = await import_promises3.default.readdir(rootDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  for (const deployment of deployments.filter((entry) => entry.isDirectory())) {
+    const deploymentDir = import_node_path3.default.join(rootDir, deployment.name);
+    const compositions = await import_promises3.default.readdir(deploymentDir, {
+      withFileTypes: true
+    });
+    bundleDirs.push(
+      ...compositions.filter(
+        (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+      ).map((entry) => import_node_path3.default.join(deploymentDir, entry.name))
+    );
+  }
+  return Promise.all(
+    bundleDirs.sort().map(verifyRuntimeEvidenceCompositionSnapshot)
+  );
+};
+
+// src/lib/runtimeEvidenceCompositions.ts
+var stableSnapshotIdentity = (deployment) => JSON.stringify({ ...deployment, tickers: void 0 });
+var producerIdentity = (producer) => JSON.stringify(producer);
+var loadRuntimeEvidenceCompositionSnapshots = async ({
+  publishRoot,
+  currentDeployment,
+  currentProducer
+}) => {
+  const snapshots = /* @__PURE__ */ new Map();
+  const register = (snapshot) => {
+    const compositionId = snapshot.deployment.deploymentCompositionId;
+    const known = snapshots.get(compositionId);
+    if (known && (stableSnapshotIdentity(known.deployment) !== stableSnapshotIdentity(snapshot.deployment) || producerIdentity(known.producer) !== producerIdentity(snapshot.producer))) {
+      throw new Error(
+        `Conflicting runtime evidence snapshot for composition ${compositionId}`
+      );
+    }
+    snapshots.set(compositionId, snapshot);
+  };
+  const compositionSnapshots = await discoverRuntimeEvidenceCompositionSnapshots(publishRoot);
+  for (const snapshot of compositionSnapshots) {
+    if (snapshot.deployment.id !== currentDeployment.id) continue;
+    register({
+      deployment: { ...snapshot.deployment, tickers: void 0 },
+      producer: snapshot.producer
+    });
+  }
+  const bundleDirs = await discoverRuntimeEvidenceBundles(publishRoot);
+  for (const bundleDir of bundleDirs) {
+    const bundle = await verifyRuntimeEvidenceBundle(bundleDir);
+    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+      bundle.artifact.deployment
+    );
+    if (deployment.id !== currentDeployment.id) continue;
+    if (bundle.artifact.producer == null) continue;
+    register({
+      deployment: { ...deployment, tickers: void 0 },
+      producer: parseRuntimeEvidenceProducer(bundle.artifact.producer)
+    });
+  }
+  const historicalCurrent = snapshots.get(
+    currentDeployment.deploymentCompositionId
+  );
+  if (historicalCurrent && stableSnapshotIdentity(historicalCurrent.deployment) !== stableSnapshotIdentity(currentDeployment)) {
+    throw new Error(
+      `Current runtime deployment conflicts with stored composition ${currentDeployment.deploymentCompositionId}`
+    );
+  }
+  snapshots.set(currentDeployment.deploymentCompositionId, {
+    deployment: { ...currentDeployment, tickers: void 0 },
+    producer: currentProducer
+  });
+  return snapshots;
+};
+var rowCompositionId = (row) => row.runtimeLineage?.deploymentCompositionId ?? row.lineage?.deploymentCompositionId ?? null;
+var rowTimestamp = (row) => {
+  for (const field of [
+    "firstTimestamp",
+    "entryTimestamp",
+    "timestamp",
+    "lastTimestamp"
+  ]) {
+    const value = row[field];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return Number.POSITIVE_INFINITY;
+};
+var belongsToSnapshot = (row, deployment) => {
+  const strategy = activeRuntimeEvidenceStrategies(deployment).find(
+    (candidate) => candidate.strategyName === row.strategy
+  );
+  return Boolean(
+    strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && runtimeLineageMatchesStrategySnapshot({
+      lineage: row.runtimeLineage ?? row.lineage,
+      deployment,
+      strategy
+    })
+  );
+};
+var splitRuntimeEvidenceByComposition = ({
+  evidence,
+  snapshots,
+  includeEmptyCompositionIds = [],
+  ignoreUnknownCompositions = false
+}) => {
+  const observed = /* @__PURE__ */ new Set();
+  for (const row of [
+    ...evidence.trades,
+    ...evidence.signals,
+    ...evidence.evaluations,
+    ...evidence.lineageScopes
+  ]) {
+    const compositionId = rowCompositionId(row);
+    if (compositionId) observed.add(compositionId);
+  }
+  for (const compositionId of includeEmptyCompositionIds) {
+    observed.add(compositionId);
+  }
+  const missing = [...observed].filter(
+    (compositionId) => !snapshots.has(compositionId)
+  );
+  if (missing.length && !ignoreUnknownCompositions) {
+    throw new Error(
+      `Runtime evidence has no verified deployment snapshot for composition(s): ${missing.sort().join(", ")}`
+    );
+  }
+  return [...observed].filter((compositionId) => snapshots.has(compositionId)).map((compositionId) => snapshots.get(compositionId)).map(({ deployment, producer }) => {
+    const trades = evidence.trades.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const signals = evidence.signals.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const evaluations = evidence.evaluations.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const lineageScopes = evidence.lineageScopes.filter(
+      (row) => belongsToSnapshot(row, deployment)
+    );
+    const timestamps = [
+      ...trades,
+      ...signals,
+      ...evaluations,
+      ...lineageScopes
+    ].map((row) => rowTimestamp(row));
+    return {
+      deployment,
+      producer,
+      trades,
+      signals,
+      evaluations,
+      lineageScopes,
+      firstTimestamp: Math.min(...timestamps)
+    };
+  }).sort(
+    (left, right) => left.firstTimestamp - right.firstTimestamp || left.deployment.deploymentCompositionId.localeCompare(
+      right.deployment.deploymentCompositionId
+    )
+  );
+};
+
+// src/lib/runtimeLineage.ts
+var import_node_crypto4 = require("crypto");
+var normalizeForStableJson = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeForStableJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+    );
+  }
+  return value;
+};
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var runtimeLineageKey = (lineage) => [
+  "v3",
+  lineage.deploymentCompositionId,
+  lineage.strategyRevision,
+  lineage.strategyPackageVersion,
+  `deps:${fingerprintRuntimeValue(lineage.strategyDependencyVersions).slice(0, 16)}`,
+  lineage.runtimePackageVersion
+].join(":");
+
 // src/scripts/runtimeEvidence.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -1015,15 +1266,30 @@ var runtimeEvidence = async () => {
     projectRoot,
     deploymentId
   });
-  const activeStrategies = activeRuntimeEvidenceStrategies(
-    deploymentSnapshot
-  ).map(({ strategyName }) => strategyName);
   const requestedStrategies = parseStrategyFilter(flags.strategy);
-  const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
+  const evidence = await collectRuntimeDebugEvidence({
+    userName: flags.user,
+    startTime,
+    endTime,
+    strategies: requestedStrategies.length ? requestedStrategies : void 0,
+    deploymentId
+  });
+  const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
+    publishRoot: import_node_path4.default.resolve(projectRoot, publishDir),
+    currentDeployment: deploymentSnapshot,
+    currentProducer: producer
+  }) : /* @__PURE__ */ new Map([
+    [
+      deploymentSnapshot.deploymentCompositionId,
+      { deployment: deploymentSnapshot, producer }
+    ]
+  ]);
   const declaredStrategies = new Set(
-    deploymentSnapshot.strategies.map(({ strategyName }) => strategyName)
+    [...snapshots.values()].flatMap(
+      ({ deployment }) => deployment.strategies.map(({ strategyName }) => strategyName)
+    )
   );
-  const unknownStrategies = strategies.filter(
+  const unknownStrategies = requestedStrategies.filter(
     (strategyName) => !declaredStrategies.has(strategyName)
   );
   if (unknownStrategies.length) {
@@ -1031,97 +1297,94 @@ var runtimeEvidence = async () => {
       `Strategies are not declared in ${deploymentId}: ${unknownStrategies.join(", ")}`
     );
   }
-  const evidence = await collectRuntimeDebugEvidence({
-    userName: flags.user,
-    startTime,
-    endTime,
-    strategies,
-    deploymentId
+  const compositionRows = splitRuntimeEvidenceByComposition({
+    evidence,
+    snapshots,
+    includeEmptyCompositionIds: publishDir ? [] : [deploymentSnapshot.deploymentCompositionId],
+    ignoreUnknownCompositions: !publishDir
   });
-  const activeSnapshots = new Map(
-    activeRuntimeEvidenceStrategies(deploymentSnapshot).map((strategy) => [
-      strategy.strategyName,
-      strategy
-    ])
-  );
-  const belongsToCurrentDeployment = (row) => {
-    const snapshot = activeSnapshots.get(row.strategy);
-    return Boolean(
-      snapshot && row.deploymentId === deploymentSnapshot.id && row.accountId === deploymentSnapshot.accountId && runtimeLineageMatchesStrategySnapshot({
-        lineage: row.runtimeLineage,
-        deployment: deploymentSnapshot,
-        strategy: snapshot
-      })
+  const artifacts = compositionRows.map((composition) => {
+    const strategies = activeRuntimeEvidenceStrategies(composition.deployment).map(({ strategyName }) => strategyName).filter(
+      (strategyName) => !requestedStrategies.length || requestedStrategies.includes(strategyName)
     );
-  };
-  const currentSignals = evidence.signals.filter(belongsToCurrentDeployment);
-  const currentEvaluations = evidence.evaluations.filter(
-    belongsToCurrentDeployment
-  );
-  const currentTrades = evidence.trades.filter(belongsToCurrentDeployment);
-  const currentLineageScopes = evidence.lineageScopes.filter(
-    (scope) => belongsToCurrentDeployment({
-      ...scope,
-      runtimeLineage: scope.lineage
-    })
-  );
-  const runtime = buildRuntimeEvidenceReportPayload({
-    userName: flags.user,
-    startTime,
-    endTime,
-    signals: currentSignals,
-    evaluations: currentEvaluations,
-    trades: currentTrades,
-    lineageScopes: currentLineageScopes
-  });
-  const deployment = resolveRuntimeEvidenceTickerUniverse({
-    deployment: deploymentSnapshot,
-    lineageScopes: currentLineageScopes
-  });
-  const artifact = {
-    reportType: "runtime-evidence",
-    generatedAt: Date.now(),
-    ...producer ? { producer } : {},
-    userName: flags.user,
-    window: {
+    const runtime = buildRuntimeEvidenceReportPayload({
+      userName: flags.user,
       startTime,
       endTime,
-      startIso: new Date(startTime).toISOString(),
-      endIso: new Date(endTime).toISOString(),
-      source
-    },
-    strategies,
-    deployment,
-    runtime
-  };
-  const outPath = import_node_path3.default.resolve(projectRoot, String(flags.out));
-  await import_promises3.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
-  await import_promises3.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      signals: composition.signals,
+      evaluations: composition.evaluations,
+      trades: composition.trades,
+      lineageScopes: composition.lineageScopes
+    });
+    const deployment = resolveRuntimeEvidenceTickerUniverse({
+      deployment: composition.deployment,
+      lineageScopes: composition.lineageScopes
+    });
+    return {
+      artifact: {
+        reportType: "runtime-evidence",
+        generatedAt: Date.now(),
+        ...composition.producer ? { producer: composition.producer } : {},
+        ...producer && composition.producer && composition.producer !== producer ? { collector: producer } : {},
+        userName: flags.user,
+        window: {
+          startTime,
+          endTime,
+          startIso: new Date(startTime).toISOString(),
+          endIso: new Date(endTime).toISOString(),
+          source
+        },
+        strategies,
+        deployment,
+        runtime
+      },
+      composition
+    };
+  });
+  const current = artifacts.find(
+    ({ artifact: artifact2 }) => artifact2.deployment.deploymentCompositionId === deploymentSnapshot.deploymentCompositionId
+  ) ?? artifacts.at(-1);
+  if (!current) {
+    throw new Error("Runtime evidence window has no versioned runtime rows");
+  }
+  const artifact = current.artifact;
+  const outPath = import_node_path4.default.resolve(projectRoot, String(flags.out));
+  await import_promises4.default.mkdir(import_node_path4.default.dirname(outPath), { recursive: true });
+  await import_promises4.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
-  const published = publishDir ? await publishRuntimeEvidenceBundle({
-    publishRoot: import_node_path3.default.resolve(projectRoot, publishDir),
-    deploymentId,
-    userName: String(flags.user),
-    startTime,
-    endTime,
-    artifact,
-    counts: artifact.runtime.counts,
-    lineageKeys: [
-      ...currentSignals.map((signal) => signal.runtimeLineage),
-      ...currentEvaluations.map((evaluation) => evaluation.runtimeLineage),
-      ...currentTrades.map((trade) => trade.runtimeLineage),
-      ...currentLineageScopes.map((scope) => scope.lineage)
-    ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
-  }) : null;
+  const published = publishDir ? await Promise.all(
+    artifacts.map(
+      ({ artifact: artifact2, composition }) => publishRuntimeEvidenceBundle({
+        publishRoot: import_node_path4.default.resolve(projectRoot, publishDir),
+        deploymentId,
+        userName: String(flags.user),
+        startTime,
+        endTime,
+        artifact: artifact2,
+        counts: artifact2.runtime.counts,
+        lineageKeys: [
+          ...composition.signals.map((signal) => signal.runtimeLineage),
+          ...composition.evaluations.map(
+            (evaluation) => evaluation.runtimeLineage
+          ),
+          ...composition.trades.map((trade) => trade.runtimeLineage),
+          ...composition.lineageScopes.map((scope) => scope.lineage)
+        ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
+      })
+    )
+  ) : [];
   console.log(import_chalk.default.green(`Wrote ${outPath}`));
-  if (published) {
-    console.log(import_chalk.default.green(`Published ${published.bundleDir}`));
+  for (const bundle of published) {
+    console.log(import_chalk.default.green(`Published ${bundle.bundleDir}`));
   }
   console.log(
     JSON.stringify(
       {
-        strategies: artifact.strategies,
-        runtimeCounts: artifact.runtime.counts
+        compositions: artifacts.map(({ artifact: artifact2 }) => ({
+          deploymentCompositionId: artifact2.deployment.deploymentCompositionId,
+          strategies: artifact2.strategies,
+          runtimeCounts: artifact2.runtime.counts
+        }))
       },
       null,
       2