@tradejs/cli 3.1.29-beta.261 → 3.1.29-beta.263

package/dist/scripts/runtimeEvidence.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-
@@ -34,8 +35,8 @@ __export(runtimeEvidence_exports, {
   runtimeEvidence: () => runtimeEvidence
 });
 module.exports = __toCommonJS(runtimeEvidence_exports);
-var import_promises4 = __toESM(require("fs/promises"));
-var import_node_path4 = __toESM(require("path"));
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -384,582 +385,31 @@ var buildRuntimeEvidenceReportPayload = ({
 });
 
 // src/lib/runtimeEvidenceArtifacts.ts
+var runtimeEvidenceArtifacts_exports = {};
+__reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
+
+// src/lib/runtimeEvidenceCompositionSnapshots.ts
 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"
-    );
-  }
-  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 resolveRuntimeEvidenceDeploymentSnapshot = async ({
-  userName,
-  projectRoot: projectRoot2,
-  deploymentId
-}) => {
-  const [deployment, strategies] = await Promise.all([
-    (0, import_runtimeStrategies.getRuntimeDeployment)({ userName, projectRoot: projectRoot2, deploymentId }),
-    (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName, projectRoot: projectRoot2, deploymentId })
-  ]);
-  if (!deployment) {
-    throw new Error(`Runtime deployment not found: ${deploymentId}`);
-  }
-  return {
-    schemaVersion: 2,
-    id: deployment.id,
-    deploymentCompositionId: deployment.deploymentCompositionId,
-    label: deployment.label,
-    connectorName: deployment.connectorName,
-    provider: deployment.provider,
-    accountId: deployment.accountId,
-    enabled: deployment.enabled,
-    strategies: strategies.map(
-      ({
-        strategyName,
-        strategyRevision,
-        enabled,
-        controlState,
-        interval,
-        universe,
-        accountId,
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        selection
-      }) => ({
-        strategyName,
-        strategyRevision,
-        enabled,
-        controlState,
-        interval,
-        universe,
-        ...accountId ? { accountId } : {},
-        strategyPackage,
-        strategyPackageVersion,
-        strategyDependencyVersions,
-        runtimePackageVersion,
-        strategyConfig,
-        ...selection ? { selection } : {}
-      })
-    ),
-    ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-    ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-  };
-};
-
-// 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";
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
-var runtimeEvidenceIdentitySha256 = (artifact) => {
-  const identityArtifact = { ...artifact };
-  delete identityArtifact.generatedAt;
-  const runtime = asRecord(identityArtifact.runtime);
-  if (runtime) {
-    const identityRuntime = { ...runtime };
-    delete identityRuntime.generatedAt;
-    identityArtifact.runtime = identityRuntime;
-  }
-  return sha256(JSON.stringify(identityArtifact));
-};
-var isExistingDestinationError = (error) => {
-  const code = error.code;
-  return code === "EEXIST" || code === "ENOTEMPTY";
-};
-var safeSegment = (value, fallback) => {
-  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
-  return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
-};
-var compactTimestamp = (timestamp) => new Date(timestamp).toISOString().replace(/[-:]/g, "").replace(/\.000Z$/, "Z");
-var dateParts = (timestamp) => {
-  const date = new Date(timestamp);
-  return [
-    String(date.getUTCFullYear()),
-    String(date.getUTCMonth() + 1).padStart(2, "0"),
-    String(date.getUTCDate()).padStart(2, "0")
-  ];
-};
-var assertFiniteTimestamp = (value, label) => {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new Error(`Invalid runtime evidence ${label}`);
-  }
-  return value;
-};
-var parseManifest = (value) => {
-  const manifest = asRecord(value);
-  const window = asRecord(manifest?.window);
-  const payload = asRecord(manifest?.payload);
-  const counts = asRecord(manifest?.counts);
-  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence" || typeof manifest.artifactId !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.userName !== "string" || typeof manifest.createdAt !== "number" || payload?.file !== RUNTIME_EVIDENCE_PAYLOAD_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Array.isArray(manifest.lineageKeys)) {
-    throw new Error("Invalid runtime evidence manifest");
-  }
-  return {
-    schemaVersion: 1,
-    artifactId: manifest.artifactId,
-    reportType: "runtime-evidence",
-    deploymentId: manifest.deploymentId,
-    userName: manifest.userName,
-    createdAt: manifest.createdAt,
-    window: {
-      startTime: assertFiniteTimestamp(window?.startTime, "window.startTime"),
-      endTime: assertFiniteTimestamp(window?.endTime, "window.endTime")
-    },
-    payload: {
-      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
-      sha256: payload.sha256,
-      bytes: payload.bytes
-    },
-    counts: Object.fromEntries(
-      Object.entries(counts ?? {}).filter(
-        (entry) => typeof entry[1] === "number" && Number.isFinite(entry[1])
-      )
-    ),
-    lineageKeys: manifest.lineageKeys.filter(
-      (value2) => typeof value2 === "string" && value2.length > 0
-    )
-  };
-};
-var publishRuntimeEvidenceBundle = async ({
-  publishRoot,
-  deploymentId,
-  userName,
-  startTime,
-  endTime,
-  artifact,
-  counts,
-  lineageKeys
-}) => {
-  assertCurrentRuntimeEvidenceArtifact(artifact);
-  const payload = `${JSON.stringify(artifact, null, 2)}
-`;
-  const payloadSha256 = sha256(payload);
-  const identitySha256 = runtimeEvidenceIdentitySha256(artifact);
-  const safeDeploymentId = safeSegment(deploymentId, "default");
-  const artifactId = [
-    compactTimestamp(startTime),
-    compactTimestamp(endTime),
-    identitySha256.slice(0, 16)
-  ].join("_");
-  const createdAt = Date.now();
-  const manifest = {
-    schemaVersion: 1,
-    artifactId,
-    reportType: "runtime-evidence",
-    deploymentId: safeDeploymentId,
-    userName,
-    createdAt,
-    window: { startTime, endTime },
-    payload: {
-      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
-      sha256: payloadSha256,
-      bytes: Buffer.byteLength(payload)
-    },
-    counts,
-    lineageKeys: [...new Set(lineageKeys)].sort()
-  };
-  const incomingRoot = import_node_path.default.join(publishRoot, "incoming");
-  const readyRoot = import_node_path.default.join(
-    publishRoot,
-    "ready",
-    safeDeploymentId,
-    ...dateParts(endTime)
-  );
-  const bundleDir = import_node_path.default.join(readyRoot, artifactId);
-  const temporaryDir = import_node_path.default.join(
-    incomingRoot,
-    `${artifactId}.tmp-${(0, import_node_crypto.randomUUID)()}`
-  );
-  await import_promises.default.mkdir(temporaryDir, { recursive: true });
-  try {
-    await Promise.all([
-      import_promises.default.writeFile(
-        import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_PAYLOAD_FILE),
-        payload,
-        "utf8"
-      ),
-      import_promises.default.writeFile(
-        import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_MANIFEST_FILE),
-        `${JSON.stringify(manifest, null, 2)}
-`,
-        "utf8"
-      )
-    ]);
-    await import_promises.default.writeFile(
-      import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_COMPLETE_FILE),
-      `${artifactId}
-`,
-      "utf8"
-    );
-    await import_promises.default.mkdir(readyRoot, { recursive: true });
-    try {
-      await import_promises.default.rename(temporaryDir, bundleDir);
-    } catch (error) {
-      if (!isExistingDestinationError(error)) {
-        throw error;
-      }
-      await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
-    }
-  } catch (error) {
-    await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
-    throw error;
-  }
-  return verifyRuntimeEvidenceBundle(bundleDir);
-};
-var verifyRuntimeEvidenceBundle = async (bundleDir) => {
-  const manifestPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_MANIFEST_FILE);
-  const payloadPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_PAYLOAD_FILE);
-  const completePath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_COMPLETE_FILE);
-  const [manifestText, payload, completeText] = await Promise.all([
-    import_promises.default.readFile(manifestPath, "utf8"),
-    import_promises.default.readFile(payloadPath),
-    import_promises.default.readFile(completePath, "utf8")
-  ]);
-  const manifest = parseManifest(JSON.parse(manifestText));
-  if (completeText.trim() !== manifest.artifactId) {
-    throw new Error(`Invalid completion marker in ${bundleDir}`);
-  }
-  if (payload.byteLength !== manifest.payload.bytes) {
-    throw new Error(`Runtime evidence size mismatch in ${bundleDir}`);
-  }
-  if (sha256(payload) !== manifest.payload.sha256) {
-    throw new Error(`Runtime evidence checksum mismatch in ${bundleDir}`);
-  }
-  const artifact = asRecord(JSON.parse(payload.toString("utf8")));
-  const artifactWindow = asRecord(artifact?.window);
-  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,
-    payloadPath,
-    manifest,
-    artifact
-  };
-};
-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))
-    );
-  };
-  await visit(rootDir, 0);
-  return bundles.sort();
-};
-
-// src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto3 = require("crypto");
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
+var runtimeEvidenceDeployment_exports = {};
+__reExport(runtimeEvidenceDeployment_exports, require("@tradejs/node/diagnostics"));
 
 // 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 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
-}) => {
-  const projectSha = String(process.env.TRADEJS_PROJECT_SHA ?? "").trim();
-  const imageDigest = String(
-    process.env.TRADEJS_PROJECT_IMAGE_DIGEST ?? ""
-  ).trim();
-  if (!projectSha && !imageDigest && !required) {
-    return null;
-  }
-  if (!/^[a-f0-9]{40}$/.test(projectSha)) {
-    throw new Error(
-      "TRADEJS_PROJECT_SHA must be a full lowercase Git SHA before publishing runtime evidence"
-    );
-  }
-  if (!/^sha256:[a-f0-9]{64}$/.test(imageDigest)) {
-    throw new Error(
-      "TRADEJS_PROJECT_IMAGE_DIGEST must be an immutable sha256 digest before publishing runtime evidence"
-    );
-  }
-  const manifestPath = import_node_path2.default.join(projectRoot2, "runtime-package-manifest.json");
-  let manifest;
-  try {
-    manifest = await import_promises2.default.readFile(manifestPath);
-  } catch (error) {
-    if (!required && error.code === "ENOENT") {
-      return null;
-    }
-    throw new Error(
-      `Runtime package manifest is required for runtime evidence: ${manifestPath}`,
-      { cause: error }
-    );
-  }
-  return {
-    schemaVersion: 1,
-    projectSha,
-    imageDigest,
-    runtimePackageManifest: {
-      file: "runtime-package-manifest.json",
-      sha256: sha2562(manifest)
-    }
-  };
-};
+var runtimeEvidenceProducer_exports = {};
+__reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
 
 // 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;
+var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+var parseManifest = (value) => {
+  const manifest = isRecord(value) ? value : null;
+  const payload = isRecord(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");
   }
@@ -967,28 +417,28 @@ var parseManifest2 = (value) => {
 };
 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")
+    import_promises.default.readFile(import_node_path.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+    import_promises.default.readFile(import_node_path.default.join(bundleDir, SNAPSHOT_FILE)),
+    import_promises.default.readFile(import_node_path.default.join(bundleDir, COMPLETE_FILE), "utf8")
   ]);
-  const manifest = parseManifest2(JSON.parse(manifestText));
+  const manifest = parseManifest(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) {
+  if (payload.byteLength !== manifest.payload.bytes || sha256(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;
+  const record = isRecord(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);
+  const deployment = (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(record.deployment);
+  const producer = (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(record.producer);
   if (deployment.id !== manifest.deploymentId || deployment.deploymentCompositionId !== manifest.deploymentCompositionId) {
     throw new Error(
       `Runtime evidence snapshot identity mismatch in ${bundleDir}`
@@ -997,24 +447,24 @@ var verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
   return { bundleDir, deployment, producer };
 };
 var discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-  const rootDir = import_node_path3.default.join(evidenceRoot, "snapshots");
+  const rootDir = import_node_path.default.join(evidenceRoot, "snapshots");
   const bundleDirs = [];
   let deployments;
   try {
-    deployments = await import_promises3.default.readdir(rootDir, { withFileTypes: true });
+    deployments = await import_promises.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, {
+    const deploymentDir = import_node_path.default.join(rootDir, deployment.name);
+    const compositions = await import_promises.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))
+      ).map((entry) => import_node_path.default.join(deploymentDir, entry.name))
     );
   }
   return Promise.all(
@@ -1056,17 +506,17 @@ var loadRuntimeEvidenceCompositionSnapshots = async ({
       producer: snapshot.producer
     });
   }
-  const bundleDirs = await discoverRuntimeEvidenceBundles(publishRoot);
+  const bundleDirs = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(publishRoot);
   for (const bundleDir of bundleDirs) {
-    const bundle = await verifyRuntimeEvidenceBundle(bundleDir);
-    const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+    const bundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir);
+    const deployment = (0, runtimeEvidenceDeployment_exports.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),
+      producer: (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(bundle.artifact.producer),
       // A historical composition may reappear through a position that closes
       // in this window even without current-window lineage scopes. Its latest
       // checksum-verified universe is only a fallback; fresh scopes win.
@@ -1101,11 +551,11 @@ var rowTimestamp = (row) => {
   return Number.POSITIVE_INFINITY;
 };
 var belongsToSnapshot = (row, deployment) => {
-  const strategy = activeRuntimeEvidenceStrategies(deployment).find(
+  const strategy = (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(deployment).find(
     (candidate) => candidate.strategyName === row.strategy
   );
   return Boolean(
-    strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && runtimeLineageMatchesStrategySnapshot({
+    strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && (0, runtimeEvidenceDeployment_exports.runtimeLineageMatchesStrategySnapshot)({
       lineage: row.runtimeLineage ?? row.lineage,
       deployment,
       strategy
@@ -1176,7 +626,7 @@ var splitRuntimeEvidenceByComposition = ({
 };
 
 // src/lib/runtimeLineage.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto2 = require("crypto");
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -1188,7 +638,7 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintRuntimeValue = (value) => (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+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,
@@ -1279,11 +729,11 @@ var runtimeEvidence = async () => {
   const { startTime, endTime, source } = resolveWindow();
   const deploymentId = String(flags.deployment);
   const publishDir = String(flags.publishDir ?? "").trim();
-  const producer = await resolveRuntimeEvidenceProducer({
+  const producer = await (0, runtimeEvidenceProducer_exports.resolveRuntimeEvidenceProducer)({
     projectRoot,
     required: Boolean(publishDir)
   });
-  const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
+  const deploymentSnapshot = await (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceDeploymentSnapshot)({
     userName: String(flags.user),
     projectRoot,
     deploymentId
@@ -1297,7 +747,7 @@ var runtimeEvidence = async () => {
     deploymentId
   });
   const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
-    publishRoot: import_node_path4.default.resolve(projectRoot, publishDir),
+    publishRoot: import_node_path2.default.resolve(projectRoot, publishDir),
     currentDeployment: deploymentSnapshot,
     currentProducer: producer
   }) : /* @__PURE__ */ new Map([
@@ -1326,7 +776,7 @@ var runtimeEvidence = async () => {
     ignoreUnknownCompositions: !publishDir
   });
   const artifacts = compositionRows.map((composition) => {
-    const strategies = activeRuntimeEvidenceStrategies(composition.deployment).map(({ strategyName }) => strategyName).filter(
+    const strategies = (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(composition.deployment).map(({ strategyName }) => strategyName).filter(
       (strategyName) => !requestedStrategies.length || requestedStrategies.includes(strategyName)
     );
     const runtime = buildRuntimeEvidenceReportPayload({
@@ -1338,7 +788,7 @@ var runtimeEvidence = async () => {
       trades: composition.trades,
       lineageScopes: composition.lineageScopes
     });
-    const deployment = resolveRuntimeEvidenceTickerUniverse({
+    const deployment = (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceTickerUniverse)({
       deployment: composition.deployment,
       lineageScopes: composition.lineageScopes,
       fallbackTickers: composition.fallbackTickers
@@ -1371,14 +821,14 @@ var runtimeEvidence = async () => {
     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)}
+  const outPath = import_node_path2.default.resolve(projectRoot, String(flags.out));
+  await import_promises2.default.mkdir(import_node_path2.default.dirname(outPath), { recursive: true });
+  await import_promises2.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
   const published = publishDir ? await Promise.all(
     artifacts.map(
-      ({ artifact: artifact2, composition }) => publishRuntimeEvidenceBundle({
-        publishRoot: import_node_path4.default.resolve(projectRoot, publishDir),
+      ({ artifact: artifact2, composition }) => (0, runtimeEvidenceArtifacts_exports.publishRuntimeEvidenceBundle)({
+        publishRoot: import_node_path2.default.resolve(projectRoot, publishDir),
         deploymentId,
         userName: String(flags.user),
         startTime,