@probemesh/sdk 0.1.0

package/dist/chunk-HJK52QJF.js

@@ -0,0 +1,994 @@
+import {
+  ProbeMeshError
+} from "./chunk-2ASMVLG4.js";
+
+// src/integrationTemplates.ts
+var DEFAULT_SDK_VERSION = "^0.1.0";
+var TEMPLATE_ORDER = [
+  "provider-x402-sandbox",
+  "buyer-hosted-router",
+  "catalog-policy-ci",
+  "audit-trail-export"
+];
+var TEMPLATE_PACKAGE_NAMES = {
+  "provider-x402-sandbox": "probemesh-provider-x402-sandbox",
+  "buyer-hosted-router": "probemesh-buyer-hosted-router",
+  "catalog-policy-ci": "probemesh-catalog-policy-ci",
+  "audit-trail-export": "probemesh-audit-trail-export"
+};
+var TEMPLATE_REGISTRY = [
+  {
+    id: "provider-x402-sandbox",
+    name: "Provider x402 Sandbox",
+    description: "Manifest-backed provider starter with the x402 sandbox protocol and an acceptance config.",
+    files: createProviderX402SandboxFiles()
+  },
+  {
+    id: "buyer-hosted-router",
+    name: "Buyer Hosted Router",
+    description: "Hosted buyer starter with paid provider routing, payment strategy, catalog policy, and audit collection.",
+    files: createBuyerHostedRouterFiles()
+  },
+  {
+    id: "catalog-policy-ci",
+    name: "Catalog Policy CI",
+    description: "CI-friendly catalog policy check starter with machine-readable reports.",
+    files: createCatalogPolicyCiFiles()
+  },
+  {
+    id: "audit-trail-export",
+    name: "Audit Trail Export",
+    description: "Local audit artifact collection and audit trail export starter.",
+    files: createAuditTrailExportFiles()
+  }
+];
+function listProbeMeshIntegrationTemplates() {
+  return TEMPLATE_ORDER.map((id) => cloneTemplate(requireTemplate(id)));
+}
+function getProbeMeshIntegrationTemplate(id) {
+  return cloneTemplate(requireTemplate(id));
+}
+function renderProbeMeshIntegrationTemplate(options) {
+  const template = requireTemplate(options.templateId);
+  const packageName = options.packageName?.trim() ?? TEMPLATE_PACKAGE_NAMES[template.id];
+  const sdkVersion = options.sdkVersion?.trim() ?? DEFAULT_SDK_VERSION;
+  assertValidPackageName(packageName);
+  assertNonEmptyString(sdkVersion, "sdkVersion");
+  return {
+    template: cloneTemplate(template),
+    packageName,
+    files: template.files.map((file) => ({
+      ...file,
+      path: validateRelativeTemplatePath(file.path),
+      content: renderTemplateContent(file.content, {
+        packageName,
+        sdkVersion
+      })
+    }))
+  };
+}
+function requireTemplate(id) {
+  const template = TEMPLATE_REGISTRY.find((candidate) => candidate.id === id);
+  if (!template) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Unknown ProbeMesh integration template "${id}".`
+    });
+  }
+  return template;
+}
+function cloneTemplate(template) {
+  return {
+    ...template,
+    files: template.files.map((file) => ({ ...file }))
+  };
+}
+function renderTemplateContent(content, values) {
+  return content.replaceAll("{{packageName}}", values.packageName).replaceAll("{{sdkVersion}}", values.sdkVersion);
+}
+function assertNonEmptyString(value, label) {
+  if (value.trim().length === 0) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `${label} must be a non-empty string.`
+    });
+  }
+}
+function assertValidPackageName(packageName) {
+  assertNonEmptyString(packageName, "packageName");
+  if (packageName.length > 214 || packageName.startsWith(".") || packageName.startsWith("_") || packageName.includes(" ") || !/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(packageName)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Invalid packageName "${packageName}".`
+    });
+  }
+}
+function validateRelativeTemplatePath(path) {
+  assertNonEmptyString(path, "template file path");
+  if (path.startsWith("/") || path.startsWith("\\") || path.includes("..") || path.split(/[\\/]/).some((segment) => segment.length === 0)) {
+    throw new ProbeMeshError({
+      code: "invalid_request",
+      message: `Invalid template file path "${path}".`
+    });
+  }
+  return path;
+}
+function createProviderX402SandboxFiles() {
+  return [
+    templateFile(
+      "package.json",
+      [
+        "{",
+        '  "name": "{{packageName}}",',
+        '  "private": true,',
+        '  "type": "module",',
+        '  "engines": {',
+        '    "node": ">=20.12.0"',
+        "  },",
+        '  "packageManager": "pnpm@10.33.0",',
+        '  "scripts": {',
+        '    "dev": "tsx src/index.ts",',
+        '    "accept:x402": "probemesh-x402-accept --config x402-acceptance.config.mjs",',
+        '    "conformance:provider": "probemesh-conformance --config provider-conformance.config.mjs",',
+        '    "dossier:provider": "probemesh-dossier --config provider-dossier.config.mjs"',
+        "  },",
+        '  "dependencies": {',
+        '    "@probemesh/sdk": "{{sdkVersion}}"',
+        "  },",
+        '  "devDependencies": {',
+        '    "tsx": "^4.15.7",',
+        '    "typescript": "^5.4.5"',
+        "  }",
+        "}"
+      ]
+    ),
+    templateFile(
+      "README.md",
+      [
+        "# {{packageName}}",
+        "",
+        "Manifest-backed ProbeMesh provider starter using the local x402 sandbox protocol.",
+        "",
+        "## Run",
+        "",
+        "```sh",
+        "pnpm install",
+        "pnpm dev",
+        "pnpm accept:x402",
+        "pnpm conformance:provider",
+        "pnpm dossier:provider",
+        "```",
+        "",
+        "`pnpm accept:x402` writes a JSON report, Markdown report, and provider catalog artifact under `artifacts/`.",
+        "",
+        "`pnpm conformance:provider` writes a JSON report, Markdown report, and provider conformance artifact under `artifacts/`.",
+        "",
+        "`pnpm dossier:provider` bundles the catalog and conformance artifacts into one provider onboarding dossier under `artifacts/`.",
+        "",
+        "The x402 sandbox emits deterministic payment headers and receipts. It does not use a real wallet, facilitator, settlement network, or live funds."
+      ]
+    ),
+    templateFile(
+      "src/index.ts",
+      [
+        "import {",
+        "  createAdapterFromManifest,",
+        "  createProbeMesh,",
+        "  createX402SandboxProtocol,",
+        "  hasReceipt,",
+        '} from "@probemesh/sdk";',
+        "",
+        'const providerId = "starter-x402-provider";',
+        "const manifest = {",
+        "  id: providerId,",
+        '  displayName: "Starter x402 Provider",',
+        '  capabilities: ["price-lookup"],',
+        '  protocolMode: "x402",',
+        "  paymentOptions: [",
+        "    {",
+        '      id: "x402-sandbox-usdc",',
+        '      protocolMode: "x402",',
+        '      pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        '      receiptTypes: ["payment_proof", "settlement_confirmation", "provider_delivery"],',
+        "    },",
+        "  ],",
+        '  pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        '  inputSchema: { type: "object" },',
+        '  outputSchema: { type: "object" },',
+        "  receipts: { payment: true, delivery: true, responseEvidence: false },",
+        "} as const;",
+        "",
+        "const adapter = createAdapterFromManifest(",
+        "  manifest,",
+        "  {",
+        '    "price-lookup": (_request, context) => ({',
+        '      data: { symbol: "BTC", currency: "USD", price: 64000, paidWith: context.paymentSelection?.protocolMode },',
+        "      receiptRefs: [",
+        "        {",
+        '          type: "provider_delivery",',
+        "          provider: providerId,",
+        '          status: "recorded",',
+        '          ref: context.callId + ":provider_delivery",',
+        "          timestamp: context.startedAt.toISOString(),",
+        "        },",
+        "      ],",
+        "    }),",
+        "  },",
+        "  {",
+        "    protocolAdapters: [createX402SandboxProtocol({ providerId })],",
+        "  },",
+        ");",
+        "",
+        "const probemesh = createProbeMesh({ adapters: [adapter] });",
+        "const response = await probemesh.call({",
+        '  capability: "price-lookup",',
+        '  input: { symbol: "BTC", currency: "USD" },',
+        "  constraints: { maxCostUsd: 0.02, requireReceipt: true },",
+        '  paymentPreferences: { allowedProtocols: ["x402"] },',
+        '  paymentStrategy: { mode: "receipt_coverage" },',
+        '  idempotencyKey: "starter-x402-call",',
+        "});",
+        "",
+        "console.log(JSON.stringify({",
+        "  status: response.status,",
+        "  provider: response.provider.id,",
+        "  protocol: response.route?.paymentSelection?.protocolMode,",
+        '  hasPaymentProof: hasReceipt(response, "payment_proof"),',
+        '  hasSettlement: hasReceipt(response, "settlement_confirmation"),',
+        '  hasDelivery: hasReceipt(response, "provider_delivery"),',
+        "  safety: response.safety,",
+        "}, null, 2));"
+      ]
+    ),
+    templateFile(
+      "x402-acceptance.config.mjs",
+      [
+        'import { createAdapterFromManifest, createX402SandboxProtocol } from "@probemesh/sdk";',
+        "",
+        'const providerId = "starter-x402-provider";',
+        "const manifest = {",
+        "  id: providerId,",
+        '  displayName: "Starter x402 Provider",',
+        '  capabilities: ["price-lookup"],',
+        '  protocolMode: "x402",',
+        "  paymentOptions: [",
+        "    {",
+        '      id: "x402-sandbox-usdc",',
+        '      protocolMode: "x402",',
+        '      pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        '      receiptTypes: ["payment_proof", "settlement_confirmation", "provider_delivery"],',
+        "    },",
+        "  ],",
+        '  pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        '  inputSchema: { type: "object" },',
+        '  outputSchema: { type: "object" },',
+        "  receipts: { payment: true, delivery: true, responseEvidence: false },",
+        "};",
+        "",
+        "const adapter = createAdapterFromManifest(",
+        "  manifest,",
+        "  {",
+        '    "price-lookup": (_request, context) => ({',
+        '      data: { symbol: "BTC", currency: "USD", price: 64000 },',
+        "      receiptRefs: [",
+        "        {",
+        '          type: "provider_delivery",',
+        "          provider: providerId,",
+        '          status: "recorded",',
+        '          ref: context.callId + ":provider_delivery",',
+        "          timestamp: context.startedAt.toISOString(),",
+        "        },",
+        "      ],",
+        "    }),",
+        "  },",
+        "  { protocolAdapters: [createX402SandboxProtocol({ providerId })] },",
+        ");",
+        "",
+        "export default {",
+        "  acceptance: {",
+        "    adapters: [adapter],",
+        "    request: {",
+        '      capability: "price-lookup",',
+        '      input: { symbol: "BTC", currency: "USD" },',
+        "      constraints: { maxCostUsd: 0.02, requireReceipt: true },",
+        '      paymentPreferences: { allowedProtocols: ["x402"] },',
+        '      idempotencyKey: "starter-x402-acceptance",',
+        "    },",
+        "    expectedProviderId: providerId,",
+        '    requiredReceiptTypes: ["payment_proof", "settlement_confirmation", "provider_delivery"],',
+        "  },",
+        '  catalog: { manifest, artifactId: providerId + ":x402-sandbox" },',
+        '  report: { title: "Starter x402 sandbox acceptance" },',
+        "  outputs: {",
+        '    json: "artifacts/x402-acceptance-report.json",',
+        '    markdown: "artifacts/x402-acceptance-report.md",',
+        '    catalog: "artifacts/provider-catalog-artifact.json",',
+        "  },",
+        "};"
+      ]
+    ),
+    templateFile(
+      "provider-conformance.config.mjs",
+      [
+        'import { createAdapterFromManifest, createX402SandboxProtocol } from "@probemesh/sdk";',
+        "",
+        'const providerId = "starter-x402-provider";',
+        'const requiredReceiptTypes = ["payment_proof", "settlement_confirmation", "provider_delivery"];',
+        "const manifest = {",
+        "  id: providerId,",
+        '  displayName: "Starter x402 Provider",',
+        '  capabilities: ["price-lookup"],',
+        '  protocolMode: "x402",',
+        "  paymentOptions: [",
+        "    {",
+        '      id: "x402-sandbox-usdc",',
+        '      protocolMode: "x402",',
+        '      pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        "      receiptTypes: requiredReceiptTypes,",
+        "    },",
+        "  ],",
+        '  pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        "  inputSchema: {",
+        '    type: "object",',
+        '    required: ["symbol", "currency"],',
+        "    properties: {",
+        '      symbol: { type: "string" },',
+        '      currency: { type: "string" },',
+        "    },",
+        "    additionalProperties: true,",
+        "  },",
+        "  outputSchema: {",
+        '    type: "object",',
+        '    required: ["symbol", "currency", "price"],',
+        "    properties: {",
+        '      symbol: { type: "string" },',
+        '      currency: { type: "string" },',
+        '      price: { type: "number" },',
+        '      paidWith: { type: "string" },',
+        "    },",
+        "    additionalProperties: true,",
+        "  },",
+        "  receipts: { payment: true, delivery: true, responseEvidence: false },",
+        "};",
+        "",
+        "const adapter = createAdapterFromManifest(",
+        "  manifest,",
+        "  {",
+        '    "price-lookup": (_request, context) => ({',
+        '      data: { symbol: "BTC", currency: "USD", price: 64000, paidWith: context.paymentSelection?.protocolMode },',
+        "      receiptRefs: [",
+        "        {",
+        '          type: "provider_delivery",',
+        "          provider: providerId,",
+        '          status: "recorded",',
+        '          ref: context.callId + ":provider_delivery",',
+        "          timestamp: context.startedAt.toISOString(),",
+        "        },",
+        "      ],",
+        "    }),",
+        "  },",
+        "  { protocolAdapters: [createX402SandboxProtocol({ providerId })] },",
+        ");",
+        "",
+        "export default {",
+        "  conformance: {",
+        "    manifest,",
+        "    adapters: [adapter],",
+        "    request: {",
+        '      capability: "price-lookup",',
+        '      input: { symbol: "BTC", currency: "USD" },',
+        "      constraints: { maxCostUsd: 0.02, requireReceipt: true },",
+        '      paymentPreferences: { allowedProtocols: ["x402"], requiredReceiptTypes },',
+        '      paymentStrategy: { mode: "receipt_coverage", preferredReceiptTypes: requiredReceiptTypes },',
+        '      idempotencyKey: "starter-x402-conformance",',
+        "    },",
+        "    expectedProviderId: providerId,",
+        "    requiredReceiptTypes,",
+        "    schemaValidation: { input: true, output: true },",
+        "  },",
+        '  report: { title: "Starter x402 sandbox conformance", format: "markdown" },',
+        '  artifact: { artifactId: providerId + ":x402-sandbox-conformance" },',
+        "  outputs: {",
+        '    json: "artifacts/provider-conformance-report.json",',
+        '    markdown: "artifacts/provider-conformance-report.md",',
+        '    artifact: "artifacts/provider-conformance-artifact.json",',
+        "  },",
+        "};"
+      ]
+    ),
+    templateFile(
+      "provider-dossier.config.mjs",
+      [
+        "export default {",
+        '  catalogArtifactFile: "artifacts/provider-catalog-artifact.json",',
+        '  conformanceArtifactFile: "artifacts/provider-conformance-artifact.json",',
+        "  dossier: {",
+        '    dossierId: "starter-x402-provider:onboarding-dossier",',
+        '    title: "Starter x402 provider onboarding dossier",',
+        '    format: "markdown",',
+        "  },",
+        "  outputs: {",
+        '    json: "artifacts/provider-onboarding-dossier.json",',
+        '    markdown: "artifacts/provider-onboarding-dossier.md",',
+        "  },",
+        "};"
+      ]
+    )
+  ];
+}
+function createBuyerHostedRouterFiles() {
+  return [
+    templateFile(
+      "package.json",
+      [
+        "{",
+        '  "name": "{{packageName}}",',
+        '  "private": true,',
+        '  "type": "module",',
+        '  "engines": {',
+        '    "node": ">=20.12.0"',
+        "  },",
+        '  "packageManager": "pnpm@10.33.0",',
+        '  "scripts": {',
+        '    "dev": "tsx src/index.ts"',
+        "  },",
+        '  "dependencies": {',
+        '    "@probemesh/sdk": "{{sdkVersion}}"',
+        "  },",
+        '  "devDependencies": {',
+        '    "tsx": "^4.15.7",',
+        '    "typescript": "^5.4.5"',
+        "  }",
+        "}"
+      ]
+    ),
+    templateFile(
+      "README.md",
+      [
+        "# {{packageName}}",
+        "",
+        "Hosted buyer starter with a paid provider, payment strategy, catalog policy, and audit collector.",
+        "",
+        "## Run",
+        "",
+        "```sh",
+        "pnpm install",
+        "pnpm dev",
+        "```",
+        "",
+        "Everything runs locally. The payment protocol is mock-only and intended for integration testing."
+      ]
+    ),
+    templateFile(
+      "src/index.ts",
+      [
+        "import {",
+        "  createPaidPriceLookupProvider,",
+        "  createProbeMesh,",
+        "  createProbeMeshAuditTrailCollector,",
+        "  createProviderCatalog,",
+        "  createProviderCatalogArtifact,",
+        "  startHostedRouter,",
+        "  summarizeProbeMeshAuditTrailBundle,",
+        '} from "@probemesh/sdk";',
+        "",
+        'const apiKey = "local-dev-api-key";',
+        'const providerId = "paid-price-provider";',
+        'const receiptTypes = ["payment_proof", "provider_delivery"] as const;',
+        "const manifest = {",
+        "  id: providerId,",
+        '  displayName: "Paid Price Lookup Provider",',
+        '  capabilities: ["price-lookup"],',
+        '  protocolMode: "mock-payment",',
+        "  paymentOptions: [",
+        "    {",
+        '      id: "mock-payment-standard",',
+        '      protocolMode: "mock-payment",',
+        '      pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        "      receiptTypes: [...receiptTypes],",
+        "    },",
+        "  ],",
+        '  pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        '  inputSchema: { type: "object" },',
+        '  outputSchema: { type: "object" },',
+        "  receipts: { payment: true, delivery: true, responseEvidence: false },",
+        "} as const;",
+        "",
+        "const acceptanceReport = {",
+        '  title: "Starter paid provider acceptance",',
+        '  status: "passed",',
+        '  gate: { accepted: true, status: "accepted", requiredCheckNames: [], failedRequiredCheckNames: [], reasons: ["local starter"] },',
+        "  summary: {",
+        '    status: "passed", totalChecks: 1, passedChecks: 1, failedChecks: 0, failedCheckNames: [],',
+        "    providerId, receiptTypes: [...receiptTypes], requiredReceiptTypes: [...receiptTypes],",
+        '    timelineEventTypes: ["call.completed"], telemetryEventTypes: ["call.completed"],',
+        '    safety: { paymentStatus: "authorized", settlementStatus: "settled", deliveryStatus: "delivered", moneyMayHaveMoved: true },',
+        '    retrySafety: { retryable: false, safeToAutoRetry: false, reason: "completed" },',
+        "  },",
+        "  checks: [],",
+        "  receipts: {",
+        "    total: 2, types: [...receiptTypes], providers: [providerId],",
+        "    byType: { payment_proof: 1, provider_delivery: 1 },",
+        "    hasPaymentProof: true, hasSettlementConfirmation: false, hasProviderDelivery: true,",
+        "  },",
+        '  timelineEventTypes: ["call.completed"],',
+        '  telemetryEventTypes: ["call.completed"],',
+        '  safety: { paymentStatus: "authorized", settlementStatus: "settled", deliveryStatus: "delivered", moneyMayHaveMoved: true },',
+        '  retrySafety: { retryable: false, safeToAutoRetry: false, reason: "completed" },',
+        "} as const;",
+        "",
+        "const catalog = createProviderCatalog({",
+        "  artifacts: [",
+        "    createProviderCatalogArtifact({",
+        "      manifest,",
+        "      acceptanceReport,",
+        '      artifactId: providerId + ":mock-payment",',
+        '      generatedAt: "2026-05-15T00:00:00.000Z",',
+        "    }),",
+        "  ],",
+        "});",
+        "",
+        "const collector = createProbeMeshAuditTrailCollector();",
+        "const router = await startHostedRouter({",
+        "  port: 0,",
+        "  apiKeys: [apiKey],",
+        "  adapters: [createPaidPriceLookupProvider()],",
+        "  catalogPolicy: {",
+        "    catalog,",
+        "    requiredReceiptTypes: [...receiptTypes],",
+        "    maxCostUsd: 0.02,",
+        "  },",
+        "  auditArtifacts: { enabled: true, onArtifact: collector.onArtifact },",
+        "});",
+        "",
+        "try {",
+        "  const probemesh = createProbeMesh({ hosted: { baseUrl: router.url, apiKey } });",
+        "  const response = await probemesh.call({",
+        '    capability: "price-lookup",',
+        '    input: { symbol: "ETH", currency: "USD" },',
+        "    constraints: { maxCostUsd: 0.02, requireReceipt: true },",
+        '    paymentPreferences: { allowedProtocols: ["mock-payment"] },',
+        '    paymentStrategy: { mode: "lowest_cost" },',
+        '    idempotencyKey: "buyer-hosted-router-demo",',
+        "  });",
+        '  const bundle = collector.createBundle({ bundleId: "buyer-hosted-router-audit" });',
+        "  console.log(JSON.stringify({",
+        "    status: response.status,",
+        "    provider: response.provider.id,",
+        "    route: response.route,",
+        "    safety: response.safety,",
+        "    auditSummary: summarizeProbeMeshAuditTrailBundle(bundle),",
+        "  }, null, 2));",
+        "} finally {",
+        "  await router.close();",
+        "}"
+      ]
+    )
+  ];
+}
+function createCatalogPolicyCiFiles() {
+  return [
+    templateFile(
+      "package.json",
+      [
+        "{",
+        '  "name": "{{packageName}}",',
+        '  "private": true,',
+        '  "type": "module",',
+        '  "engines": {',
+        '    "node": ">=20.12.0"',
+        "  },",
+        '  "packageManager": "pnpm@10.33.0",',
+        '  "scripts": {',
+        '    "check:catalog": "probemesh-catalog-check --config catalog-policy.config.mjs --format markdown --out-json artifacts/catalog-policy.json --out-md artifacts/catalog-policy.md --out-bundle artifacts/catalog-policy-bundle.json"',
+        "  },",
+        '  "dependencies": {',
+        '    "@probemesh/sdk": "{{sdkVersion}}"',
+        "  }",
+        "}"
+      ]
+    ),
+    templateFile(
+      "README.md",
+      [
+        "# {{packageName}}",
+        "",
+        "CI starter for validating a buyer-side ProbeMesh provider catalog and router policy.",
+        "",
+        "## Run",
+        "",
+        "```sh",
+        "pnpm install",
+        "pnpm check:catalog",
+        "```",
+        "",
+        "The generated artifacts are safe to store in CI because they contain metadata and hashes, not secrets or executable adapters."
+      ]
+    ),
+    templateFile(
+      "catalog-policy.config.mjs",
+      [
+        'import { createProviderCatalogArtifact } from "@probemesh/sdk";',
+        "",
+        'const providerId = "catalog-ready-price-provider";',
+        'const receiptTypes = ["payment_proof", "provider_delivery"];',
+        "const manifest = {",
+        "  id: providerId,",
+        '  displayName: "Catalog Ready Price Provider",',
+        '  capabilities: ["price-lookup"],',
+        '  protocolMode: "mock-payment",',
+        "  paymentOptions: [",
+        "    {",
+        '      id: "mock-payment-standard",',
+        '      protocolMode: "mock-payment",',
+        '      pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        "      receiptTypes,",
+        "    },",
+        "  ],",
+        '  pricing: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        '  inputSchema: { type: "object" },',
+        '  outputSchema: { type: "object" },',
+        "  receipts: { payment: true, delivery: true, responseEvidence: false },",
+        "};",
+        "const acceptanceReport = {",
+        '  title: "Catalog ready provider",',
+        '  status: "passed",',
+        '  gate: { accepted: true, status: "accepted", requiredCheckNames: [], failedRequiredCheckNames: [], reasons: ["starter fixture"] },',
+        '  summary: { status: "passed", totalChecks: 1, passedChecks: 1, failedChecks: 0, failedCheckNames: [], providerId, receiptTypes, requiredReceiptTypes: receiptTypes, timelineEventTypes: ["call.completed"], telemetryEventTypes: ["call.completed"] },',
+        "  checks: [],",
+        "  receipts: { total: 2, types: receiptTypes, providers: [providerId], byType: { payment_proof: 1, provider_delivery: 1 }, hasPaymentProof: true, hasSettlementConfirmation: false, hasProviderDelivery: true },",
+        '  timelineEventTypes: ["call.completed"],',
+        '  telemetryEventTypes: ["call.completed"],',
+        "};",
+        "",
+        "export default {",
+        '  artifacts: [createProviderCatalogArtifact({ manifest, acceptanceReport, artifactId: providerId + ":mock-payment" })],',
+        '  catalogPolicy: { status: "ready", maxCostUsd: 0.02, requiredReceiptTypes: receiptTypes },',
+        '  adapterInventory: [{ id: providerId, capabilities: ["price-lookup"], pricing: manifest.pricing }],',
+        "  queries: [",
+        "    {",
+        '      capability: "price-lookup",',
+        "      minMatches: 1,",
+        '      paymentPreferences: { allowedProtocols: ["mock-payment"], requiredReceiptTypes: receiptTypes },',
+        '      paymentStrategy: { mode: "lowest_cost" },',
+        "    },",
+        "  ],",
+        '  report: { title: "Starter catalog policy check" },',
+        '  bundle: { bundleId: "starter-catalog-policy-bundle" },',
+        "};"
+      ]
+    )
+  ];
+}
+function createAuditTrailExportFiles() {
+  return [
+    templateFile(
+      "package.json",
+      [
+        "{",
+        '  "name": "{{packageName}}",',
+        '  "private": true,',
+        '  "type": "module",',
+        '  "engines": {',
+        '    "node": ">=20.12.0"',
+        "  },",
+        '  "packageManager": "pnpm@10.33.0",',
+        '  "scripts": {',
+        '    "dev": "tsx src/index.ts",',
+        '    "export:audit-trail": "probemesh-audit-trail-export --config audit-trail.config.mjs --format markdown --out-json artifacts/audit-trail.json --out-md artifacts/audit-trail.md"',
+        "  },",
+        '  "dependencies": {',
+        '    "@probemesh/sdk": "{{sdkVersion}}"',
+        "  },",
+        '  "devDependencies": {',
+        '    "tsx": "^4.15.7",',
+        '    "typescript": "^5.4.5"',
+        "  }",
+        "}"
+      ]
+    ),
+    templateFile(
+      "README.md",
+      [
+        "# {{packageName}}",
+        "",
+        "Starter for collecting safe ProbeMesh call audit artifacts and exporting a local audit trail bundle.",
+        "",
+        "## Run",
+        "",
+        "```sh",
+        "pnpm install",
+        "pnpm dev",
+        "pnpm export:audit-trail",
+        "```",
+        "",
+        "Audit artifacts include route, receipts, safety, retry decisions, and hashes. Raw request input and secrets are not stored."
+      ]
+    ),
+    templateFile(
+      "src/index.ts",
+      [
+        "import {",
+        "  createPaidPriceLookupProvider,",
+        "  createProbeMesh,",
+        "  createProbeMeshAuditTrailCollector,",
+        "  formatProbeMeshAuditTrailBundle,",
+        "  startHostedRouter,",
+        '} from "@probemesh/sdk";',
+        "",
+        'const apiKey = "local-audit-api-key";',
+        "const collector = createProbeMeshAuditTrailCollector();",
+        "const router = await startHostedRouter({",
+        "  port: 0,",
+        "  apiKeys: [apiKey],",
+        "  adapters: [createPaidPriceLookupProvider()],",
+        "  auditArtifacts: { enabled: true, onArtifact: collector.onArtifact },",
+        "});",
+        "",
+        "try {",
+        "  const probemesh = createProbeMesh({ hosted: { baseUrl: router.url, apiKey } });",
+        "  await probemesh.call({",
+        '    capability: "price-lookup",',
+        '    input: { symbol: "SOL", currency: "USD" },',
+        "    constraints: { maxCostUsd: 0.02, requireReceipt: true },",
+        '    paymentPreferences: { allowedProtocols: ["mock-payment"] },',
+        '    idempotencyKey: "audit-trail-starter-call",',
+        "  });",
+        '  const bundle = collector.createBundle({ bundleId: "audit-trail-starter-bundle" });',
+        '  console.log(formatProbeMeshAuditTrailBundle(bundle, { format: "markdown" }));',
+        "} finally {",
+        "  await router.close();",
+        "}"
+      ]
+    ),
+    templateFile(
+      "audit-trail.config.mjs",
+      [
+        'import { createProbeMeshCallAuditArtifact } from "@probemesh/sdk";',
+        "",
+        'const generatedAt = "2026-05-15T00:00:00.000Z";',
+        "const response = {",
+        '  callId: "starter-audit-call",',
+        '  capability: "price-lookup",',
+        '  data: { symbol: "ETH", currency: "USD", price: 3200 },',
+        '  provider: { id: "starter-audit-provider", displayName: "Starter Audit Provider", mode: "hosted" },',
+        '  cost: { unit: "call", amountUsd: 0.01, currency: "USD" },',
+        "  latencyMs: 4,",
+        '  receiptRefs: [{ type: "provider_delivery", provider: "starter-audit-provider", status: "recorded", ref: "starter-audit-call:delivery", timestamp: generatedAt }],',
+        '  retrySafety: { retryable: false, safeToAutoRetry: false, reason: "completed" },',
+        '  status: "completed",',
+        "};",
+        "",
+        "export default {",
+        "  artifacts: [",
+        "    createProbeMeshCallAuditArtifact({",
+        '      request: { capability: "price-lookup", input: { symbol: "ETH" }, idempotencyKey: "starter-audit-call" },',
+        "      response,",
+        "      generatedAt,",
+        "    }),",
+        "  ],",
+        '  bundle: { bundleId: "starter-audit-trail", generatedAt },',
+        "};"
+      ]
+    )
+  ];
+}
+function templateFile(path, lines) {
+  return {
+    path,
+    content: `${lines.join("\n")}
+`
+  };
+}
+
+// src/cli/probemeshInitCli.ts
+import { mkdir, stat, writeFile } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "path";
+var USAGE = "Usage: probemesh-init [--list] [--template <id> --out-dir <path>] [--package-name <name>] [--force] [--dry-run]";
+async function runProbeMeshInitCli(options = {}) {
+  const argv = options.argv ?? [];
+  const cwd = options.cwd ?? process.cwd();
+  try {
+    const parsedArgs = parseCliArgs(argv);
+    if (parsedArgs.help) {
+      return cliSuccess({
+        listed: true,
+        dryRun: false,
+        stdout: `${USAGE}
+`
+      });
+    }
+    if (parsedArgs.list) {
+      return cliSuccess({
+        listed: true,
+        dryRun: false,
+        stdout: formatTemplateList()
+      });
+    }
+    if (!parsedArgs.templateId) {
+      return cliFailure("--template <id> is required unless --list is used.");
+    }
+    if (!parsedArgs.outDir) {
+      return cliFailure("--out-dir <path> is required when generating a template.");
+    }
+    const rendered = renderProbeMeshIntegrationTemplate({
+      templateId: parsedArgs.templateId,
+      packageName: parsedArgs.packageName
+    });
+    const outDir = resolve(cwd, parsedArgs.outDir);
+    const plannedFiles = rendered.files.map((file) => ({
+      ...file,
+      path: file.path
+    }));
+    await assertSafeTargets({
+      outDir,
+      files: plannedFiles,
+      force: parsedArgs.force === true
+    });
+    if (!parsedArgs.dryRun) {
+      await writeRenderedTemplate({
+        outDir,
+        rendered
+      });
+    }
+    return cliSuccess({
+      listed: false,
+      dryRun: parsedArgs.dryRun === true,
+      templateId: rendered.template.id,
+      outDir,
+      files: plannedFiles,
+      stdout: formatGenerationResult({
+        rendered,
+        outDir,
+        dryRun: parsedArgs.dryRun === true
+      })
+    });
+  } catch (error) {
+    return cliFailure(
+      error instanceof Error ? error.message : "Unknown probemesh-init 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 === "--list") {
+      parsedArgs.list = true;
+      continue;
+    }
+    if (arg === "--template") {
+      parsedArgs.templateId = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-dir") {
+      parsedArgs.outDir = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--package-name") {
+      parsedArgs.packageName = requireValue(argv, index, arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "--force") {
+      parsedArgs.force = true;
+      continue;
+    }
+    if (arg === "--dry-run") {
+      parsedArgs.dryRun = true;
+      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;
+}
+function formatTemplateList() {
+  const templates = listProbeMeshIntegrationTemplates();
+  const lines = [
+    "Available ProbeMesh integration templates:",
+    ...templates.map(
+      (template) => `- ${template.id}: ${template.name} - ${template.description}`
+    )
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function formatGenerationResult(options) {
+  const prefix = options.dryRun ? "Dry run: would generate" : "Generated";
+  const lines = [
+    `${prefix} ${options.rendered.template.id} in ${options.outDir}`,
+    `Package: ${options.rendered.packageName}`,
+    ...options.rendered.files.map((file) => `- ${file.path}`)
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function assertSafeTargets(options) {
+  const collisions = [];
+  for (const file of options.files) {
+    const target = resolveTemplateTarget(options.outDir, file.path);
+    if (options.force) {
+      continue;
+    }
+    if (await pathExists(target)) {
+      collisions.push(file.path);
+    }
+  }
+  if (collisions.length > 0) {
+    throw new Error(
+      [
+        "Refusing to overwrite existing template files without --force.",
+        `Existing files: ${collisions.join(", ")}`
+      ].join(" ")
+    );
+  }
+}
+async function writeRenderedTemplate(options) {
+  for (const file of options.rendered.files) {
+    const target = resolveTemplateTarget(options.outDir, file.path);
+    await mkdir(dirname(target), {
+      recursive: true
+    });
+    await writeFile(target, file.content, "utf8");
+  }
+}
+function resolveTemplateTarget(outDir, filePath) {
+  const target = resolve(outDir, filePath);
+  const relativeTarget = relative(outDir, target);
+  if (relativeTarget.startsWith("..") || isAbsolute(relativeTarget)) {
+    throw new Error(`Template file path escapes output directory: ${filePath}`);
+  }
+  return target;
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function cliSuccess(result) {
+  return {
+    exitCode: 0,
+    ...result
+  };
+}
+function cliFailure(message) {
+  return {
+    exitCode: 2,
+    listed: false,
+    dryRun: false,
+    stdout: "",
+    stderr: `${message}
+${USAGE}
+`
+  };
+}
+
+export {
+  listProbeMeshIntegrationTemplates,
+  getProbeMeshIntegrationTemplate,
+  renderProbeMeshIntegrationTemplate,
+  runProbeMeshInitCli
+};
+//# sourceMappingURL=chunk-HJK52QJF.js.map