@probemesh/sdk 0.1.0

package/dist/chunk-ZJOLPBJJ.js

@@ -0,0 +1,1091 @@
+import {
+  assertProviderCatalogArtifact,
+  mergePaymentPreferences,
+  resolveProviderPaymentOption,
+  validatePaymentPreferences,
+  validatePaymentStrategy,
+  validateProviderCatalogArtifact,
+  validateProviderPaymentOptions
+} from "./chunk-3H7UGVI6.js";
+import {
+  ProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/providerCatalog.ts
+var PROVIDER_CATALOG_SCHEMA_VERSION = "probemesh.provider-catalog.index.v1";
+function validateProviderCatalog(catalog) {
+  const errors = [];
+  if (!isRecord(catalog)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Provider catalog must be an object."
+        }
+      ]
+    };
+  }
+  if (catalog.schemaVersion !== PROVIDER_CATALOG_SCHEMA_VERSION) {
+    errors.push({
+      path: "schemaVersion",
+      message: `schemaVersion must be "${PROVIDER_CATALOG_SCHEMA_VERSION}".`
+    });
+  }
+  validateIsoTimestamp(catalog.generatedAt, "generatedAt", errors);
+  if (!Array.isArray(catalog.entries)) {
+    errors.push({
+      path: "entries",
+      message: "entries must be an array."
+    });
+  } else {
+    catalog.entries.forEach(
+      (entry, index) => validateProviderCatalogEntry(entry, `entries.${index}`, errors)
+    );
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function assertProviderCatalog(catalog) {
+  const result = validateProviderCatalog(catalog);
+  if (result.valid) {
+    return;
+  }
+  throw new ProbeMeshError({
+    code: "invalid_request",
+    message: `Invalid provider catalog: ${formatValidationErrors(result.errors)}`
+  });
+}
+function parseProviderCatalogArtifactJson(json) {
+  if (typeof json !== "string") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog artifact JSON must be a string."
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (cause) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog artifact JSON must be valid JSON.",
+      cause
+    });
+  }
+  assertProviderCatalogArtifact(parsed);
+  return parsed;
+}
+function createProviderCatalog(options) {
+  assertProviderCatalogOptions(options);
+  const entries = options.artifacts.map((artifact, index) => {
+    const validation = validateProviderCatalogArtifact(artifact);
+    if (!validation.valid) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `Invalid provider catalog artifact at index ${index}: ${formatValidationErrors(
+          validation.errors
+        )}`
+      });
+    }
+    return createCatalogEntryFromArtifact(artifact);
+  });
+  const catalog = {
+    schemaVersion: PROVIDER_CATALOG_SCHEMA_VERSION,
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    entries
+  };
+  assertProviderCatalog(catalog);
+  return catalog;
+}
+function findProviderCatalogMatches(catalog, query) {
+  assertProviderCatalog(catalog);
+  assertProviderCatalogQuery(query);
+  const requiredStatus = query.status ?? "ready";
+  const requiredReceiptTypes = query.requiredReceiptTypes ?? [];
+  const providerIds = query.providerIds;
+  const blockedProviderIds = new Set(query.blockedProviderIds ?? []);
+  return catalog.entries.flatMap((entry) => {
+    const providerId = entry.provider.id;
+    if (entry.status !== requiredStatus) {
+      return [];
+    }
+    if (!entry.provider.capabilities.includes(query.capability)) {
+      return [];
+    }
+    if (query.protocolMode !== void 0 && entry.provider.protocolMode !== query.protocolMode) {
+      return [];
+    }
+    if (providerIds !== void 0 && !providerIds.includes(providerId)) {
+      return [];
+    }
+    if (blockedProviderIds.has(providerId)) {
+      return [];
+    }
+    const paymentPreferences = mergePaymentPreferences(
+      query.protocolMode ? {
+        allowedProtocols: [query.protocolMode]
+      } : void 0,
+      query.paymentPreferences
+    );
+    const paymentResolution = resolveProviderPaymentOption({
+      providerId,
+      providerMode: entry.provider.protocolMode,
+      capabilities: entry.provider.capabilities,
+      capability: query.capability,
+      pricing: entry.provider.pricing,
+      paymentOptions: entry.provider.paymentOptions,
+      paymentPreferences,
+      paymentStrategy: query.paymentStrategy,
+      defaultReceiptTypes: entry.acceptance.receipts.types
+    });
+    const cost = paymentSelectionCost(paymentResolution.selection) ?? resolveCatalogCost(entry, query.capability);
+    if (query.maxCostUsd !== void 0 && (cost === void 0 || cost.amountUsd > query.maxCostUsd)) {
+      return [];
+    }
+    if (!hasRequiredReceiptTypes(entry, requiredReceiptTypes)) {
+      return [];
+    }
+    if (!paymentResolution.selection) {
+      return [];
+    }
+    return [
+      {
+        entry,
+        providerId,
+        capability: query.capability,
+        status: entry.status,
+        cost,
+        paymentSelection: paymentResolution.selection,
+        reasons: createMatchReasons(
+          entry,
+          query,
+          cost,
+          paymentResolution.selection
+        )
+      }
+    ];
+  });
+}
+function summarizeProviderCatalog(catalog) {
+  assertProviderCatalog(catalog);
+  const providers = /* @__PURE__ */ new Set();
+  const capabilities = /* @__PURE__ */ new Set();
+  const protocolModes = /* @__PURE__ */ new Set();
+  let readyEntries = 0;
+  let rejectedEntries = 0;
+  for (const entry of catalog.entries) {
+    providers.add(entry.provider.id);
+    protocolModes.add(entry.provider.protocolMode);
+    for (const capability of entry.provider.capabilities) {
+      capabilities.add(capability);
+    }
+    if (entry.status === "ready") {
+      readyEntries += 1;
+    } else {
+      rejectedEntries += 1;
+    }
+  }
+  return {
+    schemaVersion: catalog.schemaVersion,
+    generatedAt: catalog.generatedAt,
+    totalEntries: catalog.entries.length,
+    readyEntries,
+    rejectedEntries,
+    providers: [...providers],
+    capabilities: [...capabilities],
+    protocolModes: [...protocolModes]
+  };
+}
+function assertProviderCatalogOptions(options) {
+  if (!isRecord(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog options must be an object."
+    });
+  }
+  if (!Array.isArray(options.artifacts)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog options require an artifacts array."
+    });
+  }
+  if (options.generatedAt !== void 0 && (typeof options.generatedAt !== "string" || Number.isNaN(Date.parse(options.generatedAt)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog generatedAt must be an ISO timestamp."
+    });
+  }
+}
+function assertProviderCatalogQuery(query) {
+  if (!isRecord(query)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog query must be an object."
+    });
+  }
+  if (typeof query.capability !== "string" || query.capability.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog query capability must be a non-empty string."
+    });
+  }
+  if (query.protocolMode !== void 0 && (typeof query.protocolMode !== "string" || query.protocolMode.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog query protocolMode must be a non-empty string."
+    });
+  }
+  validatePaymentPreferences(query.paymentPreferences, query.capability);
+  validatePaymentStrategy(query.paymentStrategy, query.capability);
+  if (query.maxCostUsd !== void 0 && (typeof query.maxCostUsd !== "number" || !Number.isFinite(query.maxCostUsd) || query.maxCostUsd < 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog query maxCostUsd must be a non-negative finite number."
+    });
+  }
+  if (query.status !== void 0 && query.status !== "ready" && query.status !== "rejected") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: 'Provider catalog query status must be "ready" or "rejected".'
+    });
+  }
+  validateQueryStringArray(query.providerIds, "providerIds");
+  validateQueryStringArray(query.blockedProviderIds, "blockedProviderIds");
+  if (query.requiredReceiptTypes !== void 0 && (!Array.isArray(query.requiredReceiptTypes) || query.requiredReceiptTypes.some((receiptType) => !isReceiptType(receiptType)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog query requiredReceiptTypes must contain known receipt types."
+    });
+  }
+}
+function createCatalogEntryFromArtifact(artifact) {
+  return {
+    artifactId: artifact.artifactId,
+    generatedAt: artifact.generatedAt,
+    status: artifact.status,
+    provider: {
+      id: artifact.provider.id,
+      displayName: artifact.provider.displayName,
+      capabilities: [...artifact.provider.capabilities],
+      protocolMode: artifact.provider.protocolMode,
+      paymentOptions: cloneSerializable(artifact.provider.paymentOptions),
+      pricing: cloneSerializable(artifact.provider.pricing),
+      receipts: cloneSerializable(artifact.provider.receipts),
+      limits: cloneSerializable(artifact.provider.limits)
+    },
+    acceptance: {
+      gate: cloneSerializable(artifact.acceptance.gate),
+      failedChecks: [...artifact.acceptance.failedChecks],
+      receipts: cloneSerializable(artifact.acceptance.receipts),
+      safety: cloneSerializable(artifact.acceptance.safety),
+      retrySafety: cloneSerializable(artifact.acceptance.retrySafety),
+      route: cloneSerializable(artifact.acceptance.route),
+      timelineEventTypes: [...artifact.acceptance.timelineEventTypes],
+      telemetryEventTypes: [...artifact.acceptance.telemetryEventTypes],
+      errorCode: artifact.acceptance.errorCode
+    }
+  };
+}
+function resolveCatalogCost(entry, capability) {
+  const pricing = entry.provider.pricing;
+  if (isProbeMeshPricing(pricing)) {
+    return pricingToCost(pricing);
+  }
+  const capabilityPricing = pricing[capability];
+  if (!isProbeMeshPricing(capabilityPricing)) {
+    return void 0;
+  }
+  return pricingToCost(capabilityPricing);
+}
+function pricingToCost(pricing) {
+  return {
+    amountUsd: pricing.amountUsd,
+    currency: pricing.currency,
+    unit: pricing.unit
+  };
+}
+function hasRequiredReceiptTypes(entry, requiredReceiptTypes) {
+  const receiptTypes = new Set(entry.acceptance.receipts.types);
+  return requiredReceiptTypes.every(
+    (receiptType) => receiptTypes.has(receiptType)
+  );
+}
+function createMatchReasons(entry, query, cost, paymentSelection) {
+  const reasons = [
+    `status:${entry.status}`,
+    `capability:${query.capability}`,
+    `protocol:${entry.provider.protocolMode}`
+  ];
+  if (query.paymentPreferences !== void 0) {
+    reasons.push("payment_preferences:matched");
+  }
+  if (query.paymentStrategy !== void 0) {
+    reasons.push(`payment_strategy:${query.paymentStrategy.mode}`);
+  }
+  if (paymentSelection?.score !== void 0) {
+    reasons.push(`payment_score:${paymentSelection.score}`);
+  }
+  for (const scoreReason of paymentSelection?.scoreReasons ?? []) {
+    reasons.push(`payment_score_reason:${scoreReason}`);
+  }
+  if (query.providerIds !== void 0) {
+    reasons.push("provider:allowed");
+  }
+  if (query.maxCostUsd !== void 0 && cost !== void 0) {
+    reasons.push(`cost:${cost.amountUsd}<=${query.maxCostUsd}`);
+  }
+  if ((query.requiredReceiptTypes ?? []).length > 0) {
+    reasons.push(`receipts:${query.requiredReceiptTypes?.join(",")}`);
+  }
+  return reasons;
+}
+function paymentSelectionCost(selection) {
+  return selection?.cost;
+}
+function validateQueryStringArray(value, name) {
+  if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Provider catalog query ${name} must be an array of non-empty strings.`
+    });
+  }
+}
+function isProbeMeshPricing(value) {
+  return isRecord(value) && typeof value.unit === "string" && typeof value.amountUsd === "number" && Number.isFinite(value.amountUsd) && value.amountUsd >= 0 && (value.currency === void 0 || typeof value.currency === "string");
+}
+function isReceiptType(value) {
+  return value === "payment_proof" || value === "settlement_confirmation" || value === "provider_delivery" || value === "provider_response_evidence" || value === "authorization_decision";
+}
+function cloneSerializable(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function validateProviderCatalogEntry(entry, path, errors) {
+  if (!isRecord(entry)) {
+    errors.push({
+      path,
+      message: "catalog entry must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString(entry.artifactId, `${path}.artifactId`, errors);
+  validateIsoTimestamp(entry.generatedAt, `${path}.generatedAt`, errors);
+  if (entry.status !== "ready" && entry.status !== "rejected") {
+    errors.push({
+      path: `${path}.status`,
+      message: 'status must be "ready" or "rejected".'
+    });
+  }
+  validateEntryProvider(entry.provider, `${path}.provider`, errors);
+  validateEntryAcceptance(entry.acceptance, `${path}.acceptance`, errors);
+}
+function validateEntryProvider(provider, path, errors) {
+  if (!isRecord(provider)) {
+    errors.push({
+      path,
+      message: "provider must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString(provider.id, `${path}.id`, errors);
+  validateNonEmptyString(provider.displayName, `${path}.displayName`, errors);
+  validateStringArray(provider.capabilities, `${path}.capabilities`, errors);
+  validateNonEmptyString(provider.protocolMode, `${path}.protocolMode`, errors);
+  validateProviderPaymentOptions(
+    provider.paymentOptions,
+    `${path}.paymentOptions`,
+    Array.isArray(provider.capabilities) ? provider.capabilities : [],
+    errors
+  );
+  validatePricingDeclaration(provider.pricing, `${path}.pricing`, errors);
+  validateReceiptSupport(provider.receipts, `${path}.receipts`, errors);
+  if (provider.limits !== void 0 && !isRecord(provider.limits)) {
+    errors.push({
+      path: `${path}.limits`,
+      message: "limits must be an object when provided."
+    });
+  }
+}
+function validateEntryAcceptance(acceptance, path, errors) {
+  if (!isRecord(acceptance)) {
+    errors.push({
+      path,
+      message: "acceptance must be an object."
+    });
+    return;
+  }
+  if (!isRecord(acceptance.gate)) {
+    errors.push({
+      path: `${path}.gate`,
+      message: "gate must be an object."
+    });
+  } else {
+    if (typeof acceptance.gate.accepted !== "boolean") {
+      errors.push({
+        path: `${path}.gate.accepted`,
+        message: "gate.accepted must be a boolean."
+      });
+    }
+    if (acceptance.gate.status !== "accepted" && acceptance.gate.status !== "rejected") {
+      errors.push({
+        path: `${path}.gate.status`,
+        message: 'gate.status must be "accepted" or "rejected".'
+      });
+    }
+  }
+  validateStringArray(acceptance.failedChecks, `${path}.failedChecks`, errors);
+  validateReceiptSummary(acceptance.receipts, `${path}.receipts`, errors);
+  validateStringArray(
+    acceptance.timelineEventTypes,
+    `${path}.timelineEventTypes`,
+    errors
+  );
+  validateStringArray(
+    acceptance.telemetryEventTypes,
+    `${path}.telemetryEventTypes`,
+    errors
+  );
+}
+function validatePricingDeclaration(pricing, path, errors) {
+  if (!isRecord(pricing)) {
+    errors.push({
+      path,
+      message: "pricing must be an object."
+    });
+    return;
+  }
+  if (isPricingObject(pricing)) {
+    validatePricingObject(pricing, path, errors);
+    return;
+  }
+  for (const [capability, capabilityPricing] of Object.entries(pricing)) {
+    validateNonEmptyString(capability, `${path}.${capability}`, errors);
+    validatePricingObject(capabilityPricing, `${path}.${capability}`, errors);
+  }
+}
+function validatePricingObject(pricing, path, errors) {
+  if (!isRecord(pricing)) {
+    errors.push({
+      path,
+      message: "pricing entry must be an object."
+    });
+    return;
+  }
+  validateNonEmptyString(pricing.unit, `${path}.unit`, errors);
+  if (typeof pricing.amountUsd !== "number" || !Number.isFinite(pricing.amountUsd) || pricing.amountUsd < 0) {
+    errors.push({
+      path: `${path}.amountUsd`,
+      message: "amountUsd must be a non-negative finite number."
+    });
+  }
+  if (pricing.currency !== void 0 && typeof pricing.currency !== "string") {
+    errors.push({
+      path: `${path}.currency`,
+      message: "currency must be a string when provided."
+    });
+  }
+}
+function validateReceiptSupport(receipts, path, errors) {
+  if (!isRecord(receipts)) {
+    errors.push({
+      path,
+      message: "receipts must be an object."
+    });
+    return;
+  }
+  for (const key of ["payment", "delivery", "responseEvidence"]) {
+    if (typeof receipts[key] !== "boolean") {
+      errors.push({
+        path: `${path}.${key}`,
+        message: `${key} must be a boolean.`
+      });
+    }
+  }
+}
+function validateReceiptSummary(receipts, path, errors) {
+  if (!isRecord(receipts)) {
+    errors.push({
+      path,
+      message: "receipts must be an object."
+    });
+    return;
+  }
+  if (typeof receipts.total !== "number" || !Number.isFinite(receipts.total)) {
+    errors.push({
+      path: `${path}.total`,
+      message: "total must be a finite number."
+    });
+  }
+  validateStringArray(receipts.types, `${path}.types`, errors);
+  validateStringArray(receipts.providers, `${path}.providers`, errors);
+  for (const key of [
+    "hasPaymentProof",
+    "hasSettlementConfirmation",
+    "hasProviderDelivery"
+  ]) {
+    if (typeof receipts[key] !== "boolean") {
+      errors.push({
+        path: `${path}.${key}`,
+        message: `${key} must be a boolean.`
+      });
+    }
+  }
+}
+function isPricingObject(value) {
+  return "unit" in value || "amountUsd" in value || "currency" in value;
+}
+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 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 string.`
+    });
+  }
+}
+function formatValidationErrors(errors) {
+  return errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/providerCatalogPolicy.ts
+function evaluateProviderCatalogPolicy(options) {
+  assertEvaluationOptions(options);
+  const catalogPolicy = resolveCatalogPolicy(options.catalogPolicy);
+  const adapterInventory = options.adapterInventory;
+  const adapterIds = new Set(adapterInventory.map((adapter) => adapter.id));
+  const catalogSummary = summarizeProviderCatalog(options.catalog);
+  const checks = [
+    {
+      name: "catalog_valid",
+      status: "passed",
+      message: "Provider catalog is valid."
+    },
+    {
+      name: "adapter_inventory_valid",
+      status: "passed",
+      message: "Adapter inventory is valid."
+    }
+  ];
+  const queryResults = options.queries.map(
+    (query) => evaluateQuery({
+      catalog: options.catalog,
+      catalogPolicy,
+      query,
+      adapterInventory,
+      adapterIds,
+      checks
+    })
+  );
+  const failedChecks = checks.filter((check) => check.status === "failed").length;
+  const routeableMatches = queryResults.reduce(
+    (total, result) => total + result.routeableMatches.length,
+    0
+  );
+  const missingAdapterMatches = queryResults.reduce(
+    (total, result) => total + result.missingAdapterMatches.length,
+    0
+  );
+  return {
+    status: failedChecks === 0 ? "passed" : "failed",
+    checks,
+    summary: {
+      ...catalogSummary,
+      totalQueries: options.queries.length,
+      passedChecks: checks.length - failedChecks,
+      failedChecks,
+      routeableMatches,
+      missingAdapterMatches
+    },
+    queryResults
+  };
+}
+function createProviderCatalogPolicyReport(result, options = {}) {
+  const report = {
+    title: options.title ?? "ProbeMesh Catalog Policy Report",
+    generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    status: result.status,
+    summary: cloneSerializable2(result.summary),
+    checks: cloneSerializable2(result.checks),
+    queryResults: cloneSerializable2(result.queryResults)
+  };
+  return sanitizeReport(report, options.forbiddenOutputValues ?? []);
+}
+function formatProviderCatalogPolicyReport(report, options = {}) {
+  if ((options.format ?? "json") === "markdown") {
+    return formatMarkdownReport(report);
+  }
+  return JSON.stringify(report, null, 2);
+}
+function assertEvaluationOptions(options) {
+  if (!isRecord2(options)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog policy evaluation options must be an object."
+    });
+  }
+  assertProviderCatalog(options.catalog);
+  assertAdapterInventory(options.adapterInventory);
+  if (!Array.isArray(options.queries) || options.queries.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog policy evaluation requires at least one query."
+    });
+  }
+  options.queries.forEach(
+    (query, index) => assertExpectedQuery(query, `queries.${index}`)
+  );
+  assertCatalogPolicyOptions(options.catalogPolicy, "catalogPolicy");
+}
+function assertAdapterInventory(adapterInventory) {
+  if (!Array.isArray(adapterInventory)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: "Provider catalog policy adapterInventory must be an array."
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  adapterInventory.forEach((adapter, index) => {
+    const path = `adapterInventory.${index}`;
+    if (!isRecord2(adapter)) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `${path} must be an object.`
+      });
+    }
+    if (typeof adapter.id !== "string" || adapter.id.length === 0) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `${path}.id must be a non-empty string.`
+      });
+    }
+    if (seen.has(adapter.id)) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `${path}.id duplicates adapter "${adapter.id}".`
+      });
+    }
+    seen.add(adapter.id);
+    if (!Array.isArray(adapter.capabilities) || adapter.capabilities.some(
+      (capability) => typeof capability !== "string" || capability.length === 0
+    )) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `${path}.capabilities must be an array of non-empty strings.`
+      });
+    }
+    if (adapter.paymentOptions !== void 0 && (!Array.isArray(adapter.paymentOptions) || adapter.paymentOptions.some(
+      (option) => !isRecord2(option) || typeof option.id !== "string" || option.id.length === 0 || typeof option.protocolMode !== "string" || option.protocolMode.length === 0
+    ))) {
+      throw new ProbeMeshError({
+        code: "invalid_request",
+        message: `${path}.paymentOptions must be an array of payment option objects when provided.`
+      });
+    }
+  });
+}
+function assertExpectedQuery(query, path) {
+  if (!isRecord2(query)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path} must be an object.`
+    });
+  }
+  if (typeof query.capability !== "string" || query.capability.length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path}.capability must be a non-empty string.`
+    });
+  }
+  const minMatches = query.minMatches;
+  if (minMatches !== void 0 && (typeof minMatches !== "number" || !Number.isInteger(minMatches) || minMatches < 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path}.minMatches must be a non-negative integer.`
+    });
+  }
+  assertCatalogPolicyOptions(query, path);
+}
+function assertCatalogPolicyOptions(policy, path) {
+  if (policy === void 0) {
+    return;
+  }
+  if (!isRecord2(policy)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path} must be an object when provided.`
+    });
+  }
+  if (policy.status !== void 0 && policy.status !== "ready" && policy.status !== "rejected") {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path}.status must be "ready" or "rejected".`
+    });
+  }
+  if (policy.protocolMode !== void 0 && (typeof policy.protocolMode !== "string" || policy.protocolMode.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path}.protocolMode must be a non-empty string.`
+    });
+  }
+  validatePaymentPreferences(policy.paymentPreferences, `${path}.paymentPreferences`);
+  validatePaymentStrategy(policy.paymentStrategy, `${path}.paymentStrategy`);
+  if (policy.maxCostUsd !== void 0 && (typeof policy.maxCostUsd !== "number" || !Number.isFinite(policy.maxCostUsd) || policy.maxCostUsd < 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path}.maxCostUsd must be a non-negative finite number.`
+    });
+  }
+  validateStringArray2(policy.providerIds, `${path}.providerIds`);
+  validateStringArray2(policy.blockedProviderIds, `${path}.blockedProviderIds`);
+  if (policy.requiredReceiptTypes !== void 0 && (!Array.isArray(policy.requiredReceiptTypes) || policy.requiredReceiptTypes.some((receiptType) => !isReceiptType2(receiptType)))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path}.requiredReceiptTypes must contain known receipt types.`
+    });
+  }
+}
+function evaluateQuery(options) {
+  const resolvedQuery = resolveQuery(options.catalogPolicy, options.query);
+  const matches = findProviderCatalogMatches(options.catalog, resolvedQuery);
+  const routeableMatches = matches.filter(
+    (match) => hasRouteableAdapter(match, options.adapterInventory)
+  );
+  const missingAdapterMatches = matches.filter((match) => !options.adapterIds.has(match.providerId)).map((match) => ({
+    providerId: match.providerId,
+    capability: match.capability,
+    catalogArtifactId: match.entry.artifactId,
+    catalogStatus: match.entry.status,
+    reasons: [
+      ...match.reasons,
+      `missing_adapter:${match.providerId}`
+    ]
+  }));
+  const skippedProviders = createSkippedProviders(
+    options.catalog.entries,
+    options.query.capability,
+    matches,
+    resolvedQuery,
+    options.adapterInventory
+  );
+  const minMatches = options.query.minMatches ?? 1;
+  pushCheck(options.checks, {
+    name: "ready_matches",
+    status: matches.length >= minMatches ? "passed" : "failed",
+    capability: options.query.capability,
+    message: matches.length >= minMatches ? `Found ${matches.length} catalog match(es) for "${options.query.capability}".` : `Expected at least ${minMatches} catalog match(es) for "${options.query.capability}", found ${matches.length}.`
+  });
+  pushCheck(options.checks, {
+    name: "routeable_matches",
+    status: routeableMatches.length >= minMatches ? "passed" : "failed",
+    capability: options.query.capability,
+    message: routeableMatches.length >= minMatches ? `Found ${routeableMatches.length} routeable adapter-backed match(es) for "${options.query.capability}".` : `Expected at least ${minMatches} routeable adapter-backed match(es) for "${options.query.capability}", found ${routeableMatches.length}.`
+  });
+  for (const missingMatch of missingAdapterMatches) {
+    pushCheck(options.checks, {
+      name: "missing_adapter",
+      status: routeableMatches.length >= minMatches ? "passed" : "failed",
+      capability: missingMatch.capability,
+      providerId: missingMatch.providerId,
+      message: routeableMatches.length >= minMatches ? `Catalog provider "${missingMatch.providerId}" matches policy but is missing from adapter inventory; minimum routeable matches are still satisfied.` : `Catalog provider "${missingMatch.providerId}" matches policy but is missing from adapter inventory.`
+    });
+  }
+  return {
+    query: options.query,
+    matches,
+    routeableMatches,
+    missingAdapterMatches,
+    skippedProviders
+  };
+}
+function resolveCatalogPolicy(policy) {
+  return {
+    enabled: policy?.enabled ?? true,
+    status: policy?.status ?? "ready",
+    protocolMode: policy?.protocolMode,
+    paymentPreferences: policy?.paymentPreferences,
+    paymentStrategy: policy?.paymentStrategy,
+    maxCostUsd: policy?.maxCostUsd,
+    requiredReceiptTypes: policy?.requiredReceiptTypes,
+    providerIds: policy?.providerIds,
+    blockedProviderIds: policy?.blockedProviderIds
+  };
+}
+function resolveQuery(policy, query) {
+  const queryPolicy = resolveCatalogPolicy(query);
+  const activePolicy = policy.enabled ? policy : resolveCatalogPolicy(void 0);
+  return {
+    capability: query.capability,
+    protocolMode: queryPolicy.protocolMode ?? activePolicy.protocolMode,
+    paymentPreferences: mergePaymentPreferences(
+      activePolicy.paymentPreferences,
+      queryPolicy.paymentPreferences
+    ),
+    paymentStrategy: queryPolicy.paymentStrategy ?? activePolicy.paymentStrategy,
+    maxCostUsd: strictestMaxCostUsd(
+      queryPolicy.maxCostUsd,
+      activePolicy.maxCostUsd
+    ),
+    requiredReceiptTypes: unionProviderIds(
+      queryPolicy.requiredReceiptTypes,
+      activePolicy.requiredReceiptTypes
+    ),
+    providerIds: intersectProviderIds(
+      queryPolicy.providerIds,
+      activePolicy.providerIds
+    ),
+    blockedProviderIds: unionProviderIds(
+      queryPolicy.blockedProviderIds,
+      activePolicy.blockedProviderIds
+    ),
+    status: queryPolicy.status ?? activePolicy.status
+  };
+}
+function hasRouteableAdapter(match, adapterInventory) {
+  return adapterInventory.some(
+    (adapter) => adapter.id === match.providerId && adapter.capabilities.includes(match.capability) && (adapter.paymentOptions === void 0 || match.paymentSelection === void 0 || adapter.paymentOptions.some(
+      (option) => option.id === match.paymentSelection?.optionId
+    ))
+  );
+}
+function createSkippedProviders(entries, capability, matches, query, adapterInventory) {
+  const matchIds = new Set(matches.map((match) => match.providerId));
+  const adapterIds = new Set(adapterInventory.map((adapter) => adapter.id));
+  const catalogProviderIds = new Set(entries.map((entry) => entry.provider.id));
+  const skippedCatalogEntries = entries.filter((entry) => entry.provider.capabilities.includes(capability)).filter((entry) => !matchIds.has(entry.provider.id)).map((entry) => ({
+    providerId: entry.provider.id,
+    capability,
+    catalogArtifactId: entry.artifactId,
+    catalogStatus: entry.status,
+    reasons: explainSkippedEntry(entry, query, adapterIds)
+  }));
+  const inventoryOnlyAdapters = adapterInventory.filter((adapter) => adapter.capabilities.includes(capability)).filter((adapter) => !catalogProviderIds.has(adapter.id)).map((adapter) => ({
+    providerId: adapter.id,
+    capability,
+    inventoryOnly: true,
+    reasons: ["adapter:not_in_catalog"]
+  }));
+  return [...skippedCatalogEntries, ...inventoryOnlyAdapters];
+}
+function explainSkippedEntry(entry, query, adapterIds) {
+  const reasons = [];
+  const providerId = entry.provider.id;
+  if (entry.status !== (query.status ?? "ready")) {
+    reasons.push(`status:${entry.status}`);
+  }
+  if (query.protocolMode && entry.provider.protocolMode !== query.protocolMode) {
+    reasons.push(`protocol:${entry.provider.protocolMode}`);
+  }
+  if (query.paymentPreferences) {
+    const paymentMatch = findProviderCatalogMatches(
+      {
+        schemaVersion: "probemesh.provider-catalog.index.v1",
+        generatedAt: "1970-01-01T00:00:00.000Z",
+        entries: [entry]
+      },
+      {
+        capability: query.capability,
+        paymentPreferences: query.paymentPreferences,
+        status: entry.status
+      }
+    );
+    if (paymentMatch.length === 0) {
+      reasons.push("payment_preferences:not_matched");
+    }
+  }
+  if (query.providerIds && !query.providerIds.includes(providerId)) {
+    reasons.push("provider:not_allowed");
+  }
+  if (query.blockedProviderIds?.includes(providerId)) {
+    reasons.push("provider:blocked");
+  }
+  const cost = resolveCatalogCost2(entry, query.capability);
+  if (query.maxCostUsd !== void 0 && (cost === void 0 || cost.amountUsd > query.maxCostUsd)) {
+    reasons.push(`cost:${cost?.amountUsd ?? "unknown"}>${query.maxCostUsd}`);
+  }
+  const receiptTypes = new Set(entry.acceptance.receipts.types);
+  for (const receiptType of query.requiredReceiptTypes ?? []) {
+    if (!receiptTypes.has(receiptType)) {
+      reasons.push(`missing_receipt:${receiptType}`);
+    }
+  }
+  if (!adapterIds.has(providerId)) {
+    reasons.push(`missing_adapter:${providerId}`);
+  }
+  return reasons.length > 0 ? reasons : ["not_matched"];
+}
+function resolveCatalogCost2(entry, capability) {
+  const pricing = entry.provider.pricing;
+  if (isPricing(pricing)) {
+    return pricing;
+  }
+  const capabilityPricing = pricing[capability];
+  return isPricing(capabilityPricing) ? capabilityPricing : void 0;
+}
+function pushCheck(checks, check) {
+  checks.push(check);
+}
+function strictestMaxCostUsd(first, second) {
+  if (first === void 0) {
+    return second;
+  }
+  if (second === void 0) {
+    return first;
+  }
+  return Math.min(first, second);
+}
+function intersectProviderIds(first, second) {
+  if (!first) {
+    return second;
+  }
+  if (!second) {
+    return first;
+  }
+  return first.filter((providerId) => second.includes(providerId));
+}
+function unionProviderIds(first, second) {
+  return [.../* @__PURE__ */ new Set([...first ?? [], ...second ?? []])];
+}
+function formatMarkdownReport(report) {
+  const lines = [
+    `# ${report.title}`,
+    "",
+    `Status: ${report.status}`,
+    `Generated: ${report.generatedAt}`,
+    "",
+    "## Summary",
+    `- Total entries: ${report.summary.totalEntries}`,
+    `- Ready entries: ${report.summary.readyEntries}`,
+    `- Rejected entries: ${report.summary.rejectedEntries}`,
+    `- Queries: ${report.summary.totalQueries}`,
+    `- Routeable matches: ${report.summary.routeableMatches}`,
+    `- Missing adapter matches: ${report.summary.missingAdapterMatches}`,
+    `- Failed checks: ${report.summary.failedChecks}`,
+    "",
+    "## Checks",
+    ...report.checks.map(
+      (check) => `- ${check.status === "passed" ? "[x]" : "[ ]"} ${check.name}: ${check.message}`
+    ),
+    "",
+    "## Queries",
+    ...report.queryResults.flatMap((result) => [
+      `### ${result.query.capability}`,
+      `- Matches: ${formatProviderIds(result.matches.map((match) => match.providerId))}`,
+      `- Payment options: ${formatMatchPaymentOptions(result.routeableMatches)}`,
+      `- Routeable: ${formatProviderIds(
+        result.routeableMatches.map((match) => match.providerId)
+      )}`,
+      `- Missing adapters: ${formatProviderIds(
+        result.missingAdapterMatches.map((match) => match.providerId)
+      )}`,
+      `- Skipped: ${formatProviderIds(
+        result.skippedProviders.map((provider) => provider.providerId)
+      )}`,
+      ""
+    ])
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function formatProviderIds(providerIds) {
+  return providerIds.length > 0 ? providerIds.join(", ") : "none";
+}
+function formatMatchPaymentOptions(matches) {
+  if (matches.length === 0) {
+    return "none";
+  }
+  return matches.map((match) => {
+    const selection = match.paymentSelection;
+    if (!selection) {
+      return `${match.providerId}: none`;
+    }
+    const score = selection.score !== void 0 ? ` score=${selection.score}` : "";
+    const reasons = selection.scoreReasons && selection.scoreReasons.length > 0 ? ` (${selection.scoreReasons.join("; ")})` : "";
+    return `${match.providerId}: ${selection.optionId}/${selection.protocolMode}${score}${reasons}`;
+  }).join(", ");
+}
+function sanitizeReport(value, forbiddenOutputValues) {
+  return replaceForbiddenValues(
+    cloneSerializable2(value),
+    forbiddenOutputValues.filter((entry) => entry.length > 0)
+  );
+}
+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 cloneSerializable2(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function validateStringArray2(value, path) {
+  if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0))) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${path} must be an array of non-empty strings.`
+    });
+  }
+}
+function isPricing(value) {
+  return isRecord2(value) && typeof value.unit === "string" && typeof value.amountUsd === "number" && Number.isFinite(value.amountUsd) && value.amountUsd >= 0 && (value.currency === void 0 || typeof value.currency === "string");
+}
+function isReceiptType2(value) {
+  return value === "payment_proof" || value === "settlement_confirmation" || value === "provider_delivery" || value === "provider_response_evidence" || value === "authorization_decision";
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  PROVIDER_CATALOG_SCHEMA_VERSION,
+  validateProviderCatalog,
+  assertProviderCatalog,
+  parseProviderCatalogArtifactJson,
+  createProviderCatalog,
+  findProviderCatalogMatches,
+  summarizeProviderCatalog,
+  evaluateProviderCatalogPolicy,
+  createProviderCatalogPolicyReport,
+  formatProviderCatalogPolicyReport
+};
+//# sourceMappingURL=chunk-ZJOLPBJJ.js.map