@probemesh/sdk 0.1.0

package/dist/chunk-HNBDX7IU.js

@@ -0,0 +1,705 @@
+import {
+  assertProbeMeshCallAuditArtifact,
+  validateProbeMeshCallAuditArtifact
+} from "./chunk-5Q3PDYIA.js";
+import {
+  loadCliConfigDefault,
+  redactX402Secrets
+} from "./chunk-NYTV263W.js";
+import {
+  ProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/auditTrailBundle.ts
+import { createHash } from "crypto";
+var PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION = "probemesh.audit-trail.v1";
+function createProbeMeshAuditTrailCollector() {
+  const artifacts = [];
+  return {
+    onArtifact(artifact) {
+      assertProbeMeshCallAuditArtifact(artifact);
+      artifacts.push(cloneSerializable(artifact));
+    },
+    getArtifacts() {
+      return cloneSerializable(artifacts);
+    },
+    clear() {
+      artifacts.length = 0;
+    },
+    createBundle(options = {}) {
+      return createProbeMeshAuditTrailBundle({
+        ...options,
+        artifacts
+      });
+    }
+  };
+}
+function createProbeMeshAuditTrailBundle(options) {
+  assertBundleOptions(options);
+  for (const [index, artifact] of options.artifacts.entries()) {
+    const validation = validateProbeMeshCallAuditArtifact(artifact);
+    if (!validation.valid) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `Invalid ProbeMesh call audit artifact at index ${index}: ${formatValidationErrors(
+          validation.errors
+        )}`
+      });
+    }
+  }
+  const artifacts = sanitizeBundleOutput(
+    options.artifacts,
+    options.forbiddenOutputValues ?? []
+  );
+  const summary = summarizeArtifacts(artifacts);
+  const hashesWithoutBundle = {
+    artifacts: hashStableJson(artifacts),
+    summary: hashStableJson(summary),
+    bundle: ""
+  };
+  const bundleBase = {
+    schemaVersion: PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION,
+    bundleId: options.bundleId ?? `audit_trail_${hashStableJson({
+      artifacts: hashesWithoutBundle.artifacts,
+      summary: hashesWithoutBundle.summary
+    }).slice(0, 16)}`,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    status: artifacts.length > 0 ? "complete" : "incomplete",
+    hashAlgorithm: "sha256",
+    hashes: hashesWithoutBundle,
+    summary,
+    artifacts
+  };
+  const bundle = {
+    ...bundleBase,
+    hashes: {
+      ...hashesWithoutBundle,
+      bundle: hashBundleContent(bundleBase)
+    }
+  };
+  assertProbeMeshAuditTrailBundle(bundle);
+  return bundle;
+}
+function summarizeProbeMeshAuditTrailBundle(bundleOrArtifacts) {
+  return Array.isArray(bundleOrArtifacts) ? summarizeArtifacts(bundleOrArtifacts) : cloneSerializable(bundleOrArtifacts.summary);
+}
+function validateProbeMeshAuditTrailBundle(bundle) {
+  const errors = [];
+  if (!isRecord(bundle)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "ProbeMesh audit trail bundle must be an object."
+        }
+      ]
+    };
+  }
+  if (bundle.schemaVersion !== PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION) {
+    errors.push({
+      path: "schemaVersion",
+      message: `schemaVersion must be "${PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION}".`
+    });
+  }
+  validateNonEmptyString(bundle.bundleId, "bundleId", errors);
+  validateIsoTimestamp(bundle.generatedAt, "generatedAt", errors);
+  if (bundle.status !== "complete" && bundle.status !== "incomplete") {
+    errors.push({
+      path: "status",
+      message: 'status must be "complete" or "incomplete".'
+    });
+  }
+  if (bundle.hashAlgorithm !== "sha256") {
+    errors.push({
+      path: "hashAlgorithm",
+      message: 'hashAlgorithm must be "sha256".'
+    });
+  }
+  validateHashes(bundle.hashes, errors);
+  validateSummary(bundle.summary, errors);
+  if (!Array.isArray(bundle.artifacts)) {
+    errors.push({
+      path: "artifacts",
+      message: "artifacts must be an array."
+    });
+  } else {
+    bundle.artifacts.forEach((artifact, index) => {
+      const validation = validateProbeMeshCallAuditArtifact(artifact);
+      for (const artifactError of validation.errors) {
+        errors.push({
+          path: `artifacts.${index}.${artifactError.path}`,
+          message: artifactError.message
+        });
+      }
+    });
+  }
+  if (errors.length === 0) {
+    const typedBundle = bundle;
+    pushHashMismatch(
+      errors,
+      "hashes.artifacts",
+      typedBundle.hashes.artifacts,
+      hashStableJson(typedBundle.artifacts)
+    );
+    pushHashMismatch(
+      errors,
+      "hashes.summary",
+      typedBundle.hashes.summary,
+      hashStableJson(typedBundle.summary)
+    );
+    pushHashMismatch(
+      errors,
+      "hashes.bundle",
+      typedBundle.hashes.bundle,
+      hashBundleContent(typedBundle)
+    );
+    const expectedSummary = summarizeArtifacts(typedBundle.artifacts);
+    if (stableStringify(typedBundle.summary) !== stableStringify(expectedSummary)) {
+      errors.push({
+        path: "summary",
+        message: "summary does not match bundle artifacts."
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertProbeMeshAuditTrailBundle(bundle) {
+  const result = validateProbeMeshAuditTrailBundle(bundle);
+  if (result.valid) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `Invalid ProbeMesh audit trail bundle: ${formatValidationErrors(
+      result.errors
+    )}`
+  });
+}
+function formatProbeMeshAuditTrailBundle(bundle, options = {}) {
+  assertProbeMeshAuditTrailBundle(bundle);
+  if ((options.format ?? "json") === "markdown") {
+    return formatBundleMarkdown(bundle);
+  }
+  return JSON.stringify(bundle, null, 2);
+}
+function assertBundleOptions(options) {
+  if (!isRecord(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh audit trail bundle options must be an object."
+    });
+  }
+  if (!Array.isArray(options.artifacts)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh audit trail bundle artifacts must be an array."
+    });
+  }
+  if (options.generatedAt !== void 0 && (typeof options.generatedAt !== "string" || Number.isNaN(Date.parse(options.generatedAt)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh audit trail bundle generatedAt must be an ISO timestamp."
+    });
+  }
+  if (options.bundleId !== void 0 && (typeof options.bundleId !== "string" || options.bundleId.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh audit trail bundleId must be a non-empty string."
+    });
+  }
+  if (options.forbiddenOutputValues !== void 0 && (!Array.isArray(options.forbiddenOutputValues) || options.forbiddenOutputValues.some((value) => typeof value !== "string"))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "ProbeMesh audit trail bundle forbiddenOutputValues must be an array of strings."
+    });
+  }
+}
+function summarizeArtifacts(artifacts) {
+  const providers = [];
+  const capabilities = [];
+  const receiptTypes = [];
+  const policyBundleIds = [];
+  let unsafePaymentEvidenceCalls = 0;
+  let retrySafeFailures = 0;
+  let uncoveredPolicyFailures = 0;
+  for (const artifact of artifacts) {
+    pushUnique(providers, artifact.call.providerId);
+    pushUnique(capabilities, artifact.call.capability);
+    for (const receiptType of artifact.evidence.receiptSummary.types) {
+      pushUnique(receiptTypes, receiptType);
+    }
+    const attestationBundleId = artifact.evidence.route?.attestation?.bundleId;
+    pushUnique(policyBundleIds, attestationBundleId);
+    if (artifact.evidence.safety?.moneyMayHaveMoved === true || artifact.evidence.receiptSummary.hasPaymentProof) {
+      unsafePaymentEvidenceCalls += 1;
+    }
+    if (artifact.status === "failed" && artifact.evidence.retrySafety?.safeToAutoRetry === true) {
+      retrySafeFailures += 1;
+    }
+    if (artifact.status === "failed" && artifact.evidence.route?.explanation?.attempts.some(
+      (attempt) => attempt.reason === "skipped_policy_bundle_uncovered"
+    ) === true) {
+      uncoveredPolicyFailures += 1;
+    }
+  }
+  return {
+    totalCalls: artifacts.length,
+    completedCalls: artifacts.filter((artifact) => artifact.status === "completed").length,
+    failedCalls: artifacts.filter((artifact) => artifact.status === "failed").length,
+    providers,
+    capabilities,
+    receiptTypes,
+    policyBundleIds,
+    unsafePaymentEvidenceCalls,
+    retrySafeFailures,
+    uncoveredPolicyFailures
+  };
+}
+function validateHashes(hashes, errors) {
+  if (!isRecord(hashes)) {
+    errors.push({
+      path: "hashes",
+      message: "hashes must be an object."
+    });
+    return;
+  }
+  for (const key of ["artifacts", "summary", "bundle"]) {
+    validateSha256String(hashes[key], `hashes.${key}`, errors);
+  }
+}
+function validateSummary(summary, errors) {
+  if (!isRecord(summary)) {
+    errors.push({
+      path: "summary",
+      message: "summary must be an object."
+    });
+    return;
+  }
+  for (const key of [
+    "totalCalls",
+    "completedCalls",
+    "failedCalls",
+    "unsafePaymentEvidenceCalls",
+    "retrySafeFailures",
+    "uncoveredPolicyFailures"
+  ]) {
+    if (typeof summary[key] !== "number" || !Number.isFinite(summary[key]) || summary[key] < 0) {
+      errors.push({
+        path: `summary.${key}`,
+        message: `summary.${key} must be a non-negative finite number.`
+      });
+    }
+  }
+  validateStringArray(summary.providers, "summary.providers", errors);
+  validateStringArray(summary.capabilities, "summary.capabilities", errors);
+  validateStringArray(summary.receiptTypes, "summary.receiptTypes", errors);
+  validateStringArray(summary.policyBundleIds, "summary.policyBundleIds", errors);
+}
+function hashBundleContent(bundle) {
+  return hashStableJson({
+    ...bundle,
+    hashes: {
+      ...bundle.hashes,
+      bundle: ""
+    }
+  });
+}
+function pushHashMismatch(errors, path, expected, actual) {
+  if (expected === actual) {
+    return;
+  }
+  errors.push({
+    path,
+    message: `${path} does not match bundle content.`
+  });
+}
+function hashStableJson(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function stableStringify(value) {
+  return JSON.stringify(sortSerializable(value));
+}
+function sortSerializable(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortSerializable);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.keys(value).sort().filter((key) => value[key] !== void 0).map((key) => [key, sortSerializable(value[key])])
+  );
+}
+function sanitizeBundleOutput(value, forbiddenOutputValues) {
+  const forbiddenValues = forbiddenOutputValues.filter((entry) => entry.length > 0);
+  return redactX402Secrets(
+    replaceForbiddenValues(cloneSerializable(value), forbiddenValues)
+  );
+}
+function replaceForbiddenValues(value, forbiddenValues) {
+  if (typeof value === "string") {
+    return forbiddenValues.reduce(
+      (current, forbidden) => current.split(forbidden).join("[REDACTED]"),
+      value
+    );
+  }
+  if (value === null || typeof value !== "object" || value instanceof Date) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => replaceForbiddenValues(entry, forbiddenValues));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      replaceForbiddenValues(entry, forbiddenValues)
+    ])
+  );
+}
+function cloneSerializable(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function formatBundleMarkdown(bundle) {
+  return [
+    `# ProbeMesh Audit Trail Bundle`,
+    ``,
+    `Status: ${bundle.status}`,
+    `Schema: ${bundle.schemaVersion}`,
+    `Bundle ID: ${bundle.bundleId}`,
+    `Generated: ${bundle.generatedAt}`,
+    ``,
+    `## Summary`,
+    `- Total calls: ${bundle.summary.totalCalls}`,
+    `- Completed: ${bundle.summary.completedCalls}`,
+    `- Failed: ${bundle.summary.failedCalls}`,
+    `- Providers: ${formatInlineList(bundle.summary.providers)}`,
+    `- Capabilities: ${formatInlineList(bundle.summary.capabilities)}`,
+    `- Receipt types: ${formatInlineList(bundle.summary.receiptTypes)}`,
+    `- Policy bundles: ${formatInlineList(bundle.summary.policyBundleIds)}`,
+    `- Unsafe payment evidence calls: ${bundle.summary.unsafePaymentEvidenceCalls}`,
+    `- Retry-safe failures: ${bundle.summary.retrySafeFailures}`,
+    `- Uncovered policy failures: ${bundle.summary.uncoveredPolicyFailures}`,
+    ``,
+    `## Artifacts`,
+    ...bundle.artifacts.map(
+      (artifact) => `- ${artifact.call.callId ?? artifact.artifactId}: ${artifact.status} / ${artifact.call.capability} / ${artifact.call.providerId ?? "none"}`
+    ),
+    ``,
+    `## Hashes`,
+    `- Bundle: ${bundle.hashes.bundle}`,
+    `- Artifacts: ${bundle.hashes.artifacts}`,
+    `- Summary: ${bundle.hashes.summary}`
+  ].join("\n");
+}
+function formatInlineList(values) {
+  return values.length === 0 ? "none" : values.join(", ");
+}
+function pushUnique(values, value) {
+  if (value && !values.includes(value)) {
+    values.push(value);
+  }
+}
+function validateSha256String(value, path, errors) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) {
+    errors.push({
+      path,
+      message: `${path} must be a sha256 hex string.`
+    });
+  }
+}
+function validateNonEmptyString(value, path, errors) {
+  if (typeof value !== "string" || value.length === 0) {
+    errors.push({
+      path,
+      message: `${path} must be a non-empty string.`
+    });
+  }
+}
+function validateIsoTimestamp(value, path, errors) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    errors.push({
+      path,
+      message: `${path} must be an ISO timestamp.`
+    });
+  }
+}
+function validateStringArray(value, path, errors) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    errors.push({
+      path,
+      message: `${path} must be an array of non-empty strings.`
+    });
+  }
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function formatValidationErrors(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+
+// src/cli/auditTrailExportCli.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+var USAGE = "Usage: probemesh-audit-trail-export --config <path> [--format markdown|json] [--out-json <path>] [--out-md <path>] [--bundle-id <text>] [--generated-at <iso>]";
+async function runProbeMeshAuditTrailExportCli(options = {}) {
+  const argv = options.argv ?? [];
+  const cwd = options.cwd ?? process.cwd();
+  try {
+    const parsedArgs = parseCliArgs(argv);
+    if (parsedArgs.help) {
+      return {
+        exitCode: 0,
+        skipped: true,
+        stdout: `${USAGE}
+`
+      };
+    }
+    if (!parsedArgs.configPath) {
+      return cliFailure("--config <path> is required.");
+    }
+    const configExport = await loadCliConfig(parsedArgs.configPath, {
+      argv,
+      cwd
+    });
+    if (isCliSkip(configExport)) {
+      return {
+        exitCode: 0,
+        skipped: true,
+        skip: configExport,
+        stdout: `ProbeMesh audit trail export skipped: ${configExport.reason}
+`
+      };
+    }
+    assertCliConfig(configExport);
+    const artifacts = await loadArtifacts({
+      cwd,
+      inlineArtifacts: configExport.artifacts,
+      artifactFiles: configExport.artifactFiles
+    });
+    const bundle = createProbeMeshAuditTrailBundle({
+      artifacts,
+      bundleId: parsedArgs.bundleId ?? configExport.bundle?.bundleId,
+      generatedAt: parsedArgs.generatedAt ?? configExport.bundle?.generatedAt,
+      forbiddenOutputValues: configExport.bundle?.forbiddenOutputValues
+    });
+    const selectedFormat = parsedArgs.format ?? configExport.bundle?.format ?? "markdown";
+    const stdout = formatProbeMeshAuditTrailBundle(bundle, {
+      format: selectedFormat
+    });
+    const artifactPaths = await writeArtifacts({
+      cwd,
+      bundle,
+      outputs: {
+        json: parsedArgs.outJson ?? configExport.outputs?.json,
+        markdown: parsedArgs.outMarkdown ?? configExport.outputs?.markdown
+      }
+    });
+    return {
+      exitCode: bundle.status === "complete" ? 0 : 1,
+      skipped: false,
+      bundle,
+      stdout,
+      artifactPaths
+    };
+  } catch (error) {
+    return cliFailure(
+      error instanceof Error ? error.message : "Unknown audit trail export CLI failure."
+    );
+  }
+}
+function parseCliArgs(argv) {
+  const parsedArgs = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      parsedArgs.help = true;
+      continue;
+    }
+    if (arg === "--config") {
+      parsedArgs.configPath = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--format") {
+      const format = requireValue(argv, index, arg);
+      if (format !== "markdown" && format !== "json") {
+        throw new Error("--format must be markdown or json.");
+      }
+      parsedArgs.format = format;
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-json") {
+      parsedArgs.outJson = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-md") {
+      parsedArgs.outMarkdown = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--bundle-id") {
+      parsedArgs.bundleId = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--generated-at") {
+      parsedArgs.generatedAt = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument "${arg}".`);
+  }
+  return parsedArgs;
+}
+function requireValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${flag} requires a value.`);
+  }
+  return value;
+}
+async function loadCliConfig(configPath, context) {
+  const configExport = await loadCliConfigDefault(configPath, context.cwd);
+  if (typeof configExport === "function") {
+    return configExport(context);
+  }
+  return configExport;
+}
+function isCliSkip(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && value.skip === true && typeof value.reason === "string";
+}
+function assertCliConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Audit trail export CLI config must export an object.");
+  }
+  const config = value;
+  if (config.artifacts !== void 0 && !Array.isArray(config.artifacts)) {
+    throw new Error("Audit trail export CLI artifacts must be an array.");
+  }
+  if (config.artifactFiles !== void 0 && (!Array.isArray(config.artifactFiles) || config.artifactFiles.some((artifactFile) => typeof artifactFile !== "string"))) {
+    throw new Error("Audit trail export CLI artifactFiles must be an array of strings.");
+  }
+  if (config.bundle !== void 0) {
+    assertBundleConfig(config.bundle);
+  }
+  const outputs = config.outputs;
+  if (outputs !== void 0 && (!outputs || typeof outputs !== "object" || Array.isArray(outputs) || outputs.json !== void 0 && typeof outputs.json !== "string" || outputs.markdown !== void 0 && typeof outputs.markdown !== "string")) {
+    throw new Error("Audit trail export CLI outputs must contain string paths.");
+  }
+}
+function assertBundleConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Audit trail export CLI bundle config must be an object.");
+  }
+  const bundle = value;
+  if (bundle.bundleId !== void 0 && typeof bundle.bundleId !== "string") {
+    throw new Error("Audit trail export CLI bundleId must be a string.");
+  }
+  if (bundle.generatedAt !== void 0 && typeof bundle.generatedAt !== "string") {
+    throw new Error("Audit trail export CLI generatedAt must be a string.");
+  }
+  if (bundle.forbiddenOutputValues !== void 0 && (!Array.isArray(bundle.forbiddenOutputValues) || bundle.forbiddenOutputValues.some((value2) => typeof value2 !== "string"))) {
+    throw new Error(
+      "Audit trail export CLI forbiddenOutputValues must be an array of strings."
+    );
+  }
+  if (bundle.format !== void 0 && bundle.format !== "markdown" && bundle.format !== "json") {
+    throw new Error("Audit trail export CLI bundle format must be markdown or json.");
+  }
+}
+async function loadArtifacts(options) {
+  const artifacts = [
+    ...options.inlineArtifacts ?? []
+  ];
+  for (const artifactFile of options.artifactFiles ?? []) {
+    const loadedArtifacts = await loadArtifactFile(options.cwd, artifactFile);
+    artifacts.push(...loadedArtifacts);
+  }
+  return artifacts;
+}
+async function loadArtifactFile(cwd, artifactFile) {
+  const artifactPath = resolve(cwd, artifactFile);
+  const body = await readFile(artifactPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (error) {
+    throw new Error(
+      `Invalid audit artifact JSON in "${artifactFile}": ${error instanceof Error ? error.message : "parse failed"}`
+    );
+  }
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (parsed && typeof parsed === "object") {
+    return [parsed];
+  }
+  throw new Error(
+    `Audit artifact file "${artifactFile}" must contain an artifact object or artifact array.`
+  );
+}
+async function writeArtifacts(options) {
+  const artifactPaths = {};
+  if (options.outputs.json) {
+    const outputPath = resolve(options.cwd, options.outputs.json);
+    await writeArtifact(
+      outputPath,
+      formatProbeMeshAuditTrailBundle(options.bundle, {
+        format: "json"
+      })
+    );
+    artifactPaths.json = outputPath;
+  }
+  if (options.outputs.markdown) {
+    const outputPath = resolve(options.cwd, options.outputs.markdown);
+    await writeArtifact(
+      outputPath,
+      formatProbeMeshAuditTrailBundle(options.bundle, {
+        format: "markdown"
+      })
+    );
+    artifactPaths.markdown = outputPath;
+  }
+  return artifactPaths;
+}
+async function writeArtifact(outputPath, body) {
+  await mkdir(dirname(outputPath), {
+    recursive: true
+  });
+  await writeFile(outputPath, body, "utf8");
+}
+function cliFailure(message) {
+  return {
+    exitCode: 2,
+    skipped: false,
+    stdout: "",
+    stderr: `${message}
+${USAGE}
+`
+  };
+}
+
+export {
+  PROBEMESH_AUDIT_TRAIL_BUNDLE_SCHEMA_VERSION,
+  createProbeMeshAuditTrailCollector,
+  createProbeMeshAuditTrailBundle,
+  summarizeProbeMeshAuditTrailBundle,
+  validateProbeMeshAuditTrailBundle,
+  assertProbeMeshAuditTrailBundle,
+  formatProbeMeshAuditTrailBundle,
+  runProbeMeshAuditTrailExportCli
+};
+//# sourceMappingURL=chunk-HNBDX7IU.js.map