@probemesh/sdk 0.1.0

package/dist/chunk-WKN7QOCA.js

@@ -0,0 +1,977 @@
+import {
+  createProviderConformanceArtifact,
+  formatProviderConformanceArtifact
+} from "./chunk-UU2ZG7P7.js";
+import {
+  createProbeMesh,
+  startHostedRouter
+} from "./chunk-TV42EZSI.js";
+import {
+  isSharedJsonSchemaLike,
+  validateProviderManifest
+} from "./chunk-3H7UGVI6.js";
+import {
+  loadCliConfigDefault,
+  redactX402Secrets
+} from "./chunk-NYTV263W.js";
+import {
+  ProbeMeshError,
+  isProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/schemaValidation.ts
+function validateJsonSchemaLikeValue(value, schema, options = {}) {
+  const errors = [];
+  validateValue(value, schema, options.path ?? "$", errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertJsonSchemaLikeValue(value, schema, options = {}) {
+  const result = validateJsonSchemaLikeValue(value, schema, options);
+  if (result.valid) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `JSON schema-lite validation failed: ${formatValidationErrors(
+      result.errors
+    )}`
+  });
+}
+function validateValue(value, schema, path, errors) {
+  if (!isRecord(schema)) {
+    errors.push({
+      path,
+      message: "schema must be an object."
+    });
+    return;
+  }
+  if (schema.enum !== void 0) {
+    if (!Array.isArray(schema.enum)) {
+      errors.push({
+        path,
+        message: "schema enum must be an array."
+      });
+    } else if (!schema.enum.some((candidate) => deepEqual(candidate, value))) {
+      errors.push({
+        path,
+        message: "value must match one of the schema enum values."
+      });
+    }
+  }
+  if (schema.type !== void 0) {
+    validateType(value, schema.type, path, errors);
+  }
+  if (isRecord(value)) {
+    validateObjectValue(value, schema, path, errors);
+  }
+  if (Array.isArray(value)) {
+    validateArrayValue(value, schema, path, errors);
+  }
+}
+function validateType(value, type, path, errors) {
+  if (typeof type !== "string") {
+    errors.push({
+      path,
+      message: "schema type must be a string."
+    });
+    return;
+  }
+  const valid = type === "object" ? isRecord(value) : type === "array" ? Array.isArray(value) : type === "string" ? typeof value === "string" : type === "number" ? typeof value === "number" && Number.isFinite(value) : type === "integer" ? Number.isInteger(value) : type === "boolean" ? typeof value === "boolean" : type === "null" ? value === null : true;
+  if (!valid) {
+    errors.push({
+      path,
+      message: `value must be ${type}.`
+    });
+  }
+}
+function validateObjectValue(value, schema, path, errors) {
+  if (schema.required !== void 0) {
+    if (!Array.isArray(schema.required)) {
+      errors.push({
+        path,
+        message: "schema required must be an array."
+      });
+    } else {
+      for (const requiredKey of schema.required) {
+        if (typeof requiredKey !== "string") {
+          errors.push({
+            path,
+            message: "schema required entries must be strings."
+          });
+          continue;
+        }
+        if (!(requiredKey in value)) {
+          errors.push({
+            path: `${path}.${requiredKey}`,
+            message: "required property is missing."
+          });
+        }
+      }
+    }
+  }
+  const properties = isRecord(schema.properties) ? schema.properties : void 0;
+  if (properties) {
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (key in value) {
+        validateValue(
+          value[key],
+          propertySchema,
+          `${path}.${key}`,
+          errors
+        );
+      }
+    }
+  }
+  if (schema.additionalProperties === false && properties) {
+    for (const key of Object.keys(value)) {
+      if (!(key in properties)) {
+        errors.push({
+          path: `${path}.${key}`,
+          message: "additional property is not allowed."
+        });
+      }
+    }
+  } else if (isRecord(schema.additionalProperties)) {
+    const additionalSchema = schema.additionalProperties;
+    for (const key of Object.keys(value)) {
+      if (!properties || !(key in properties)) {
+        validateValue(value[key], additionalSchema, `${path}.${key}`, errors);
+      }
+    }
+  }
+}
+function validateArrayValue(value, schema, path, errors) {
+  if (schema.items === void 0) {
+    return;
+  }
+  if (!isRecord(schema.items)) {
+    errors.push({
+      path,
+      message: "schema items must be an object."
+    });
+    return;
+  }
+  value.forEach((item, index) => {
+    validateValue(item, schema.items, `${path}.${index}`, errors);
+  });
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function deepEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function formatValidationErrors(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+
+// src/providerConformance.ts
+var DEFAULT_REQUIRED_RECEIPT_TYPES = ["provider_delivery"];
+async function runProviderConformance(options) {
+  assertConformanceOptions(options);
+  const requiredReceiptTypes = options.requiredReceiptTypes ?? DEFAULT_REQUIRED_RECEIPT_TYPES;
+  const schemaValidation = options.schemaValidation ?? {};
+  const forbiddenOutputValues = options.forbiddenOutputValues ?? [];
+  const manifestValidation = validateProviderManifest(options.manifest);
+  const setupChecks = [
+    manifestValidation.valid ? pass("manifest_valid", "Provider manifest is valid.") : fail("manifest_valid", "Provider manifest is invalid.", {
+      errors: manifestValidation.errors
+    })
+  ];
+  const inputSchema = schemaValidation.input ? schemaForCapability(options.manifest.inputSchema, options.request.capability) : void 0;
+  if (inputSchema) {
+    const inputValidation = validateJsonSchemaLikeValue(
+      options.request.input,
+      inputSchema,
+      {
+        path: "$.input"
+      }
+    );
+    setupChecks.push(
+      inputValidation.valid ? pass("input_schema_valid", "Request input matches the declared schema.") : fail("input_schema_valid", "Request input does not match the declared schema.", {
+        errors: inputValidation.errors
+      })
+    );
+  } else if (schemaValidation.input) {
+    setupChecks.push(
+      fail("input_schema_valid", "No input schema is declared for this capability.")
+    );
+  }
+  if (setupChecks.some((check) => check.status === "failed")) {
+    const checks2 = [
+      ...setupChecks,
+      createSecretSafeOutputCheck({
+        checks: setupChecks,
+        requiredReceiptTypes,
+        telemetryEvents: [],
+        forbiddenOutputValues
+      })
+    ];
+    const status2 = statusFromChecks(checks2);
+    const sanitizedChecks2 = sanitizeConformanceOutput(checks2, forbiddenOutputValues);
+    return {
+      status: status2,
+      checks: sanitizedChecks2,
+      telemetryEvents: [],
+      summary: createSummary({
+        status: status2,
+        checks: sanitizedChecks2,
+        telemetryEvents: [],
+        requiredReceiptTypes
+      })
+    };
+  }
+  const telemetryEvents = [];
+  const hostedRouter = await startHostedRouter({
+    port: 0,
+    adapters: options.adapters,
+    apiKeys: options.apiKey ? [options.apiKey] : void 0,
+    onTelemetryEvent(event) {
+      telemetryEvents.push(event);
+    }
+  });
+  let response;
+  let error;
+  try {
+    const probemesh = createProbeMesh({
+      hosted: {
+        baseUrl: hostedRouter.url,
+        apiKey: options.apiKey
+      }
+    });
+    try {
+      response = await probemesh.call(options.request);
+    } catch (caught) {
+      error = toConformanceError(caught);
+    }
+  } finally {
+    await hostedRouter.close();
+  }
+  const baseChecks = [
+    ...setupChecks,
+    ...createExecutionChecks({
+      response,
+      error,
+      telemetryEvents,
+      expectedProviderId: options.expectedProviderId ?? options.manifest.id,
+      requiredReceiptTypes
+    })
+  ];
+  const outputSchema = schemaValidation.output ? schemaForCapability(options.manifest.outputSchema, options.request.capability) : void 0;
+  if (outputSchema) {
+    baseChecks.push(outputSchemaCheck(response, outputSchema));
+  } else if (schemaValidation.output) {
+    baseChecks.push(
+      fail("output_schema_valid", "No output schema is declared for this capability.")
+    );
+  }
+  const checks = [
+    ...baseChecks,
+    createSecretSafeOutputCheck({
+      response,
+      error,
+      telemetryEvents,
+      checks: baseChecks,
+      requiredReceiptTypes,
+      forbiddenOutputValues
+    })
+  ];
+  const status = statusFromChecks(checks);
+  const sanitizedChecks = sanitizeConformanceOutput(checks, forbiddenOutputValues);
+  const sanitizedResponse = sanitizeConformanceOutput(response, forbiddenOutputValues);
+  const sanitizedError = sanitizeConformanceOutput(error, forbiddenOutputValues);
+  const sanitizedTelemetryEvents = sanitizeConformanceOutput(
+    telemetryEvents,
+    forbiddenOutputValues
+  );
+  return {
+    status,
+    checks: sanitizedChecks,
+    response: sanitizedResponse,
+    error: sanitizedError,
+    telemetryEvents: sanitizedTelemetryEvents,
+    summary: createSummary({
+      status,
+      checks: sanitizedChecks,
+      response: sanitizedResponse,
+      error: sanitizedError,
+      telemetryEvents: sanitizedTelemetryEvents,
+      requiredReceiptTypes
+    })
+  };
+}
+function createProviderConformanceReport(result, options = {}) {
+  const receiptRefs = result.response?.receiptRefs ?? result.error?.receiptRefs;
+  const report = {
+    title: options.title ?? "ProbeMesh Provider Conformance Report",
+    status: result.status,
+    summary: result.summary,
+    checks: result.checks,
+    receipts: summarizeReceipts(receiptRefs),
+    route: result.summary.route,
+    timelineEventTypes: result.summary.timelineEventTypes,
+    telemetryEventTypes: result.summary.telemetryEventTypes,
+    safety: result.summary.safety,
+    retrySafety: result.summary.retrySafety,
+    error: result.error
+  };
+  return sanitizeConformanceOutput(report, options.forbiddenOutputValues ?? []);
+}
+function formatProviderConformanceReport(report, options = {}) {
+  const sanitizedReport = sanitizeConformanceOutput(report, []);
+  if ((options.format ?? "markdown") === "json") {
+    return JSON.stringify(sanitizedReport, null, 2);
+  }
+  return formatConformanceReportMarkdown(sanitizedReport);
+}
+function createExecutionChecks(options) {
+  return [
+    completedResponseCheck(options.response, options.error),
+    selectedProviderCheck(
+      options.response,
+      options.error,
+      options.expectedProviderId
+    ),
+    routeMetadataCheck(options.response, options.error),
+    timelineEventsCheck(options.response, options.error),
+    requiredReceiptsCheck(options.response, options.error, options.requiredReceiptTypes),
+    safetyMetadataCheck(options.response, options.error, options.requiredReceiptTypes),
+    retrySafetyCheck(options.response, options.error),
+    telemetryMatchesTimelineCheck(options.response, options.telemetryEvents)
+  ];
+}
+function completedResponseCheck(response, error) {
+  if (response?.status === "completed") {
+    return pass("completed_response", "Hosted provider call completed.");
+  }
+  return fail(
+    "completed_response",
+    error ? `Hosted provider call failed with ${error.code}.` : "Hosted provider call did not return a completed response.",
+    {
+      errorCode: error?.code,
+      errorMessage: error?.message
+    }
+  );
+}
+function selectedProviderCheck(response, error, expectedProviderId) {
+  const providerId = response?.provider.id;
+  if (providerId && (!expectedProviderId || providerId === expectedProviderId)) {
+    return pass("selected_provider", "Hosted route selected the expected provider.", {
+      providerId
+    });
+  }
+  return fail("selected_provider", "Hosted route did not select the expected provider.", {
+    expectedProviderId,
+    providerId,
+    errorProvider: error?.provider
+  });
+}
+function routeMetadataCheck(response, error) {
+  if (response?.route?.mode === "hosted" && typeof response.route.routeId === "string" && response.route.routeId.length > 0) {
+    return pass("route_metadata", "Hosted route metadata is present.", {
+      routeId: response.route.routeId,
+      selectedProviderId: response.route.selectedProviderId
+    });
+  }
+  return fail("route_metadata", "Hosted route metadata is missing.", {
+    errorRouteId: error?.route?.routeId
+  });
+}
+function timelineEventsCheck(response, error) {
+  const timelineEventTypes = response?.timeline?.events.map((event) => event.type) ?? [];
+  const requiredEvents = [
+    "call.requested",
+    "provider.attempted",
+    "provider.selected",
+    "call.completed"
+  ];
+  const missingEvents = requiredEvents.filter(
+    (eventType) => !timelineEventTypes.includes(eventType)
+  );
+  if (missingEvents.length === 0) {
+    return pass("timeline_events", "Hosted timeline contains the provider conformance events.", {
+      timelineEventTypes
+    });
+  }
+  return fail("timeline_events", "Hosted timeline is missing required events.", {
+    missingEvents,
+    timelineEventTypes,
+    errorTimelineEventTypes: error?.timeline?.events.map((event) => event.type)
+  });
+}
+function requiredReceiptsCheck(response, error, requiredReceiptTypes) {
+  const receiptTypes = getReceiptTypes(response?.receiptRefs);
+  const missingReceiptTypes = requiredReceiptTypes.filter(
+    (receiptType) => !receiptTypes.includes(receiptType)
+  );
+  if (missingReceiptTypes.length === 0) {
+    return pass("required_receipts", "Required receipts are present.", {
+      receiptTypes
+    });
+  }
+  return fail("required_receipts", "Required receipts are missing.", {
+    missingReceiptTypes,
+    receiptTypes,
+    errorReceiptTypes: getReceiptTypes(error?.receiptRefs)
+  });
+}
+function safetyMetadataCheck(response, error, requiredReceiptTypes) {
+  const requiresPaymentSafety = requiredReceiptTypes.some(
+    (receiptType) => ["payment_proof", "settlement_confirmation"].includes(receiptType)
+  );
+  if (!requiresPaymentSafety) {
+    return pass("safety_metadata", "Payment safety metadata is not required for this conformance run.");
+  }
+  if (response?.safety) {
+    return pass("safety_metadata", "Safety metadata is present for paid conformance.", {
+      safety: response.safety
+    });
+  }
+  return fail("safety_metadata", "Safety metadata is missing for paid conformance.", {
+    errorSafety: error?.safety
+  });
+}
+function retrySafetyCheck(response, error) {
+  if (response?.retrySafety) {
+    return pass("retry_safety", "Hosted response includes retry safety metadata.", {
+      retrySafety: response.retrySafety
+    });
+  }
+  return fail("retry_safety", "Hosted response retry safety metadata is missing.", {
+    errorRetrySafety: error?.retrySafety
+  });
+}
+function telemetryMatchesTimelineCheck(response, telemetryEvents) {
+  const timelineEventTypes = response?.timeline?.events.map((event) => event.type) ?? [];
+  const telemetryEventTypes = telemetryEvents.map((event) => event.type);
+  const matches = timelineEventTypes.length > 0 && timelineEventTypes.length === telemetryEventTypes.length && timelineEventTypes.every(
+    (eventType, index) => eventType === telemetryEventTypes[index]
+  );
+  if (matches) {
+    return pass("telemetry_matches_timeline", "Telemetry mirrors the hosted timeline.", {
+      telemetryEventTypes
+    });
+  }
+  return fail("telemetry_matches_timeline", "Telemetry does not mirror the hosted timeline.", {
+    timelineEventTypes,
+    telemetryEventTypes
+  });
+}
+function outputSchemaCheck(response, schema) {
+  if (!response) {
+    return fail("output_schema_valid", "Cannot validate output schema without a response.");
+  }
+  const result = validateJsonSchemaLikeValue(response.data, schema, {
+    path: "$.data"
+  });
+  if (result.valid) {
+    return pass("output_schema_valid", "Provider response data matches the declared schema.");
+  }
+  return fail("output_schema_valid", "Provider response data does not match the declared schema.", {
+    errors: result.errors
+  });
+}
+function createSecretSafeOutputCheck(options) {
+  const forbiddenOutputValues = options.forbiddenOutputValues.filter(
+    (value) => value.length > 0
+  );
+  const candidate = {
+    response: options.response,
+    error: options.error,
+    telemetryEvents: options.telemetryEvents,
+    checks: options.checks,
+    summary: createSummary({
+      status: statusFromChecks(options.checks),
+      checks: options.checks,
+      response: options.response,
+      error: options.error,
+      telemetryEvents: options.telemetryEvents,
+      requiredReceiptTypes: options.requiredReceiptTypes
+    })
+  };
+  const serialized = JSON.stringify(candidate);
+  const leakedValues = forbiddenOutputValues.filter(
+    (value) => serialized.includes(value)
+  );
+  if (leakedValues.length === 0) {
+    return pass("secret_safe_output", "Serialized conformance output contains no forbidden values.", {
+      checkedForbiddenValueCount: forbiddenOutputValues.length
+    });
+  }
+  return fail("secret_safe_output", "Serialized conformance output contains forbidden values.", {
+    leakedValueCount: leakedValues.length
+  });
+}
+function createSummary(options) {
+  const receiptRefs = options.response?.receiptRefs ?? options.error?.receiptRefs;
+  const timeline = options.response?.timeline ?? options.error?.timeline;
+  const route = options.response?.route ?? options.error?.route;
+  const failedCheckNames = options.checks.filter((check) => check.status === "failed").map((check) => check.name);
+  return {
+    status: options.status,
+    totalChecks: options.checks.length,
+    passedChecks: options.checks.length - failedCheckNames.length,
+    failedChecks: failedCheckNames.length,
+    failedCheckNames,
+    callId: options.response?.callId ?? options.error?.callId,
+    providerId: options.response?.provider.id ?? options.error?.provider,
+    errorCode: options.error?.code,
+    receiptTypes: getReceiptTypes(receiptRefs),
+    requiredReceiptTypes: [...options.requiredReceiptTypes],
+    timelineEventTypes: timeline?.events.map((event) => event.type) ?? [],
+    telemetryEventTypes: options.telemetryEvents.map((event) => event.type),
+    safety: options.response?.safety ?? options.error?.safety,
+    retrySafety: options.response?.retrySafety ?? options.error?.retrySafety,
+    route: route ? {
+      routeId: route.routeId,
+      selectedProviderId: route.selectedProviderId,
+      fallbackUsed: route.explanation?.fallbackUsed,
+      fallbackCount: route.explanation?.fallbackCount,
+      stopReason: route.explanation?.stopReason
+    } : void 0
+  };
+}
+function summarizeReceipts(receiptRefs) {
+  const receipts = receiptRefs ?? [];
+  const byType = {};
+  for (const receiptRef of receipts) {
+    byType[receiptRef.type] = (byType[receiptRef.type] ?? 0) + 1;
+  }
+  return {
+    total: receipts.length,
+    types: getReceiptTypes(receipts),
+    providers: [
+      ...new Set(receipts.map((receiptRef) => receiptRef.provider))
+    ],
+    byType,
+    hasPaymentProof: receipts.some(
+      (receiptRef) => receiptRef.type === "payment_proof"
+    ),
+    hasSettlementConfirmation: receipts.some(
+      (receiptRef) => receiptRef.type === "settlement_confirmation"
+    ),
+    hasProviderDelivery: receipts.some(
+      (receiptRef) => receiptRef.type === "provider_delivery"
+    )
+  };
+}
+function formatConformanceReportMarkdown(report) {
+  const lines = [
+    `# ${report.title}`,
+    "",
+    `Conformance: ${report.status}`,
+    `Provider: ${report.summary.providerId ?? "unknown"}`,
+    `Call: ${report.summary.callId ?? "unknown"}`,
+    `Error: ${report.summary.errorCode ?? "none"}`,
+    "",
+    "## Checks",
+    ...report.checks.map(
+      (check) => `- [${check.status === "passed" ? "x" : " "}] ${check.name}: ${check.message}`
+    ),
+    "",
+    "## Receipts",
+    `- Total: ${report.receipts.total}`,
+    `- Types: ${formatInlineList(report.receipts.types)}`,
+    `- Providers: ${formatInlineList(report.receipts.providers)}`,
+    "",
+    "## Route",
+    `- Route ID: ${report.route?.routeId ?? "none"}`,
+    `- Selected provider: ${report.route?.selectedProviderId ?? "none"}`,
+    `- Stop reason: ${report.route?.stopReason ?? "none"}`,
+    "",
+    "## Safety",
+    `- Payment: ${report.safety?.paymentStatus ?? "unknown"}`,
+    `- Settlement: ${report.safety?.settlementStatus ?? "unknown"}`,
+    `- Delivery: ${report.safety?.deliveryStatus ?? "unknown"}`,
+    `- Money may have moved: ${String(
+      report.safety?.moneyMayHaveMoved ?? false
+    )}`,
+    "",
+    "## Retry Safety",
+    `- Retryable: ${String(report.retrySafety?.retryable ?? false)}`,
+    `- Safe to auto retry: ${String(
+      report.retrySafety?.safeToAutoRetry ?? false
+    )}`,
+    `- Reason: ${report.retrySafety?.reason ?? "unknown"}`,
+    "",
+    "## Timeline",
+    `- Events: ${formatInlineList(report.timelineEventTypes)}`,
+    `- Telemetry: ${formatInlineList(report.telemetryEventTypes)}`
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function schemaForCapability(declaration, capability) {
+  if (isSharedJsonSchemaLike(declaration)) {
+    return declaration;
+  }
+  return declaration[capability];
+}
+function toConformanceError(error) {
+  if (isProbeMeshError(error)) {
+    return {
+      name: "ProbeMeshError",
+      code: error.code,
+      message: error.message,
+      status: "failed",
+      capability: error.capability,
+      provider: error.provider,
+      callId: error.callId,
+      receiptRefs: error.receiptRefs,
+      safety: error.safety,
+      timeline: error.timeline,
+      retrySafety: error.retrySafety,
+      route: error.route
+    };
+  }
+  return {
+    name: "ProbeMeshError",
+    code: "provider_unavailable",
+    message: error instanceof Error ? error.message : "provider conformance call failed.",
+    status: "failed"
+  };
+}
+function sanitizeConformanceOutput(value, forbiddenOutputValues) {
+  const forbiddenValues = forbiddenOutputValues.filter((entry) => entry.length > 0);
+  return redactX402Secrets(
+    replaceForbiddenValues(value, forbiddenValues, /* @__PURE__ */ new WeakSet())
+  );
+}
+function replaceForbiddenValues(value, forbiddenValues, seen) {
+  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 (seen.has(value)) {
+    return "[Circular]";
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const entries2 = value.map(
+      (entry) => replaceForbiddenValues(entry, forbiddenValues, seen)
+    );
+    seen.delete(value);
+    return entries2;
+  }
+  const entries = Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      replaceForbiddenValues(entry, forbiddenValues, seen)
+    ])
+  );
+  seen.delete(value);
+  return entries;
+}
+function assertConformanceOptions(options) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider conformance options must be an object."
+    });
+  }
+  if (!Array.isArray(options.adapters)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider conformance adapters must be an array."
+    });
+  }
+  if (!options.request || typeof options.request !== "object" || Array.isArray(options.request)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider conformance request must be an object."
+    });
+  }
+}
+function getReceiptTypes(receiptRefs) {
+  return [...new Set((receiptRefs ?? []).map((receiptRef) => receiptRef.type))];
+}
+function statusFromChecks(checks) {
+  return checks.every((check) => check.status === "passed") ? "passed" : "failed";
+}
+function formatInlineList(values) {
+  return values.length > 0 ? values.join(", ") : "none";
+}
+function pass(name, message, details) {
+  return {
+    name,
+    status: "passed",
+    message,
+    details
+  };
+}
+function fail(name, message, details) {
+  return {
+    name,
+    status: "failed",
+    message,
+    details
+  };
+}
+
+// src/cli/providerConformanceCli.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+var USAGE = "Usage: probemesh-conformance --config <path> [--format markdown|json] [--out-json <path>] [--out-md <path>] [--out-artifact <path>] [--title <text>] [--artifact-id <text>] [--generated-at <iso>]";
+async function runProviderConformanceCli(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: `provider conformance skipped: ${configExport.reason}
+`
+      };
+    }
+    assertCliConfig(configExport);
+    const result = await runProviderConformance(configExport.conformance);
+    const report = createProviderConformanceReport(result, {
+      ...configExport.report ?? {},
+      title: parsedArgs.title ?? configExport.report?.title
+    });
+    const outputs = {
+      json: parsedArgs.outJson ?? configExport.outputs?.json,
+      markdown: parsedArgs.outMarkdown ?? configExport.outputs?.markdown,
+      artifact: parsedArgs.outArtifact ?? configExport.outputs?.artifact
+    };
+    const artifact = createOptionalArtifact({
+      config: configExport,
+      report,
+      artifactId: parsedArgs.artifactId,
+      generatedAt: parsedArgs.generatedAt,
+      requestedArtifactOutput: outputs.artifact
+    });
+    const selectedFormat = parsedArgs.format ?? configExport.report?.format ?? "markdown";
+    const stdout = formatProviderConformanceReport(report, {
+      format: selectedFormat
+    });
+    const artifactPaths = await writeArtifacts({
+      cwd,
+      report,
+      artifact,
+      outputs
+    });
+    return {
+      exitCode: result.status === "passed" ? 0 : 1,
+      skipped: false,
+      result,
+      report,
+      artifact,
+      stdout,
+      artifactPaths
+    };
+  } catch (error) {
+    return cliFailure(
+      error instanceof Error ? error.message : "Unknown provider conformance 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 === "--out-artifact") {
+      parsedArgs.outArtifact = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--title") {
+      parsedArgs.title = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--artifact-id") {
+      parsedArgs.artifactId = 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(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("Provider conformance CLI config must be an object.");
+  }
+  const candidate = config;
+  if (!candidate.conformance || typeof candidate.conformance !== "object" || Array.isArray(candidate.conformance)) {
+    throw new Error("Provider conformance CLI config requires conformance options.");
+  }
+  if (candidate.report !== void 0 && !isRecord2(candidate.report)) {
+    throw new Error("Provider conformance CLI report config must be an object.");
+  }
+  if (candidate.artifact !== void 0 && !isRecord2(candidate.artifact)) {
+    throw new Error("Provider conformance CLI artifact config must be an object.");
+  }
+  if (candidate.outputs !== void 0) {
+    assertOutputs(candidate.outputs);
+  }
+}
+function assertOutputs(outputs) {
+  if (!isRecord2(outputs)) {
+    throw new Error("Provider conformance CLI outputs must be an object.");
+  }
+  for (const [key, value] of Object.entries(outputs)) {
+    if (!["json", "markdown", "artifact"].includes(key) || value !== void 0 && typeof value !== "string") {
+      throw new Error(
+        "Provider conformance CLI outputs may only include json, markdown, and artifact string paths."
+      );
+    }
+  }
+}
+function createOptionalArtifact(options) {
+  if (!options.config.artifact && !options.requestedArtifactOutput) {
+    return void 0;
+  }
+  return createProviderConformanceArtifact({
+    manifest: options.config.conformance.manifest,
+    report: options.report,
+    artifactId: options.artifactId ?? options.config.artifact?.artifactId,
+    generatedAt: options.generatedAt ?? options.config.artifact?.generatedAt,
+    forbiddenOutputValues: options.config.artifact?.forbiddenOutputValues ?? options.config.report?.forbiddenOutputValues ?? options.config.conformance.forbiddenOutputValues
+  });
+}
+async function writeArtifacts(options) {
+  const artifactPaths = {};
+  if (options.outputs.json) {
+    const path = resolve(options.cwd, options.outputs.json);
+    await writeTextFile(
+      path,
+      formatProviderConformanceReport(options.report, {
+        format: "json"
+      })
+    );
+    artifactPaths.json = path;
+  }
+  if (options.outputs.markdown) {
+    const path = resolve(options.cwd, options.outputs.markdown);
+    await writeTextFile(
+      path,
+      formatProviderConformanceReport(options.report, {
+        format: "markdown"
+      })
+    );
+    artifactPaths.markdown = path;
+  }
+  if (options.outputs.artifact) {
+    if (!options.artifact) {
+      throw new Error("Provider conformance artifact output requested but no artifact was created.");
+    }
+    const path = resolve(options.cwd, options.outputs.artifact);
+    await writeTextFile(
+      path,
+      formatProviderConformanceArtifact(options.artifact, {
+        format: "json"
+      })
+    );
+    artifactPaths.artifact = path;
+  }
+  return artifactPaths;
+}
+async function writeTextFile(path, body) {
+  await mkdir(dirname(path), {
+    recursive: true
+  });
+  await writeFile(path, body);
+}
+function cliFailure(message) {
+  return {
+    exitCode: 2,
+    skipped: false,
+    stdout: "",
+    stderr: `Provider conformance CLI failed: ${message}
+`
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  validateJsonSchemaLikeValue,
+  assertJsonSchemaLikeValue,
+  runProviderConformance,
+  createProviderConformanceReport,
+  formatProviderConformanceReport,
+  runProviderConformanceCli
+};
+//# sourceMappingURL=chunk-WKN7QOCA.js.map