@adcp/sdk 14.0.0-rc.41 → 14.0.0-rc.43

package/CONTRIBUTING.md

@@ -109,7 +109,13 @@ The Node test runner otherwise derives concurrency from the machine CPU count. T
 too aggressive on developer workstations because several test files launch their own
 TypeScript compiler or CLI subprocesses. The repository runner therefore caps local
 fast suites at two workers and runs the slow group serially. CI keeps its existing
-machine-derived concurrency and splits the fast suite into three shards.
+machine-derived concurrency and splits the fast suite into three shards. Those CI
+shards use per-file durations recorded by the latest successful `main` run and a
+deterministic longest-first assignment. A new or renamed test uses the median known
+duration; when no history is available, all files use an equal one-second weight.
+Pull requests may restore this history but cannot publish it, so untrusted or failed
+runs cannot poison future shard assignments. Each shard uploads its assignment
+manifest with the timing artifact for debugging.
 
 `npm test` and `npm run test:lib` build the library once before starting their test
 groups, then every test reads that completed `dist/` tree. Set `TEST_CONCURRENCY=1`

package/README.md

@@ -59,6 +59,19 @@ Large workspaces should keep the generated schema surface out of the default typ
 | Runtime Zod schemas and tool schema maps      | `@adcp/sdk/schemas`                                                                     |
 | Broad generated protocol type barrel          | `@adcp/sdk/types`                                                                       |
 
+### Focused client runtime (`@adcp/sdk/client/core`)
+
+Applications that only call AdCP agents can avoid evaluating the SDK's server,
+compliance, testing, and unrelated protocol surfaces:
+
+```ts
+import { ADCPMultiAgentClient, InMemoryWebhookRegistrationStore } from '@adcp/sdk/client/core';
+```
+
+The existing `@adcp/sdk/client` path remains an alias of the package root for
+compatibility. Use `/client/core` when cold import and test-worker startup time
+matter.
+
 For application monorepos, keep `skipLibCheck: true` unless you are intentionally auditing SDK declarations. If a package only needs request/response types for a few tools, prefer the per-tool slices over importing generated types through the root package or the broad `@adcp/sdk/types` barrel.
 
 ## Quick Start: AdCP 3.2

package/bin/adcp-grade.js

@@ -43,7 +43,8 @@ Options:
   --transport <mode>         \`mcp\` (default) wraps each vector body in a
                              JSON-RPC tools/call envelope and posts to the
                              agent's MCP mount (see #612); \`raw\` posts to
-                             per-operation AdCP endpoints (REST-binding agents).
+                             per-operation AdCP endpoints (REST-binding agents);
+                             \`a2a\` signs the official A2A client's request.
   --timeout <ms>             Per-probe timeout (default 10000)
   --json                     Emit the full GradeReport as JSON
   -h, --help                 Show this help
@@ -199,8 +200,8 @@ async function runRequestSigningGrader(args) {
         break;
       case '--transport': {
         const mode = args[++i];
-        if (mode !== 'raw' && mode !== 'mcp') {
-          console.error(`ERROR: --transport must be \"raw\" or \"mcp\", got \"${mode}\"\n`);
+        if (mode !== 'raw' && mode !== 'mcp' && mode !== 'a2a') {
+          console.error(`ERROR: --transport must be \"raw\", \"mcp\", or \"a2a\", got \"${mode}\"\n`);
           process.exit(2);
         }
         options.transport = mode;

package/bin/adcp-storyboard-summary.js

@@ -350,7 +350,7 @@ function formatStepVerdictLines(step, options = {}) {
   return [`${step?.passed ? '✅ Passed' : '❌ Failed'}${suffix}`];
 }
 
-const SIGNING_TRANSPORTS = ['raw', 'mcp'];
+const SIGNING_TRANSPORTS = ['raw', 'mcp', 'a2a'];
 
 // Tokens only ever passed as a (rejected) value for a boolean flag — no
 // storyboard id or agent URL looks like these, so treating them as a misuse

package/bin/adcp.js

@@ -57,7 +57,10 @@ const {
 } = require('./adcp-storyboard-summary.js');
 
 const { scheduleVersionCheck } = require('./adcp-version-check.js');
-const { formatStoryboardResultsAsJUnit } = require('../dist/lib/testing/storyboard/junit.js');
+const {
+  formatStoryboardResultsAsJUnit,
+  routedStoryboardResultGroup,
+} = require('../dist/lib/testing/storyboard/junit.js');
 const { ADCP_VERSION, LIBRARY_VERSION } = require('../dist/lib/version.js');
 const { isAdcpVersionSupported } = require('../dist/lib/utils/adcp-version-config.js');
 const { appendBuiltInVersionUnsupportedHint } = require('./adcp-version-unsupported-hint.js');
@@ -2180,17 +2183,15 @@ WEBHOOK OPTIONS:
                                   HTTP-on-the-wire — spec-compliant.
 
 REQUEST-SIGNING VECTOR OPTIONS (signed_requests storyboard):
-  --signing-transport raw|mcp     How the RFC 9421 conformance vectors are
+  --signing-transport raw|mcp|a2a How the RFC 9421 conformance vectors are
                                   framed on the wire. NOT the same as
                                   --transport/--protocol, which selects how the
                                   storyboard itself talks to the agent. Default:
                                   inferred from the resolved protocol — an MCP
                                   run wraps each vector in a tools/call envelope
-                                  (mcp); an A2A run reports the vectors
-                                  signing_transport_unavailable (COVERAGE
-                                  UNAVAILABLE; the track cannot pass) because
-                                  the fixtures have no A2A framing. Pass raw for
-                                  agents that
+                                  (mcp); an A2A run signs the exact request the
+                                  official A2A client emits after Agent Card
+                                  discovery. Pass raw for agents that
                                   expose AdCP tools as per-operation HTTP
                                   endpoints. Mirrors
                                   \`adcp grade request-signing --transport\`.
@@ -2919,7 +2920,7 @@ async function handleStoryboardRun(args) {
       'Usage: adcp storyboard run <agent> [storyboard_id|--file path] [options]\n' +
         '  Local agent: adcp storyboard run --local-agent <module> [storyboard_id|bundle_id]\n' +
         '  Multi-instance: adcp storyboard run --url <url1> --url <url2> <storyboard_id|bundle_id>\n' +
-        '  Multi-agent:   adcp storyboard run --agents-map ./agents.yaml <storyboard_id|bundle_id>'
+        '  Multi-agent:   adcp storyboard run --agents-map ./agents.yaml [storyboard_id|bundle_id]'
     );
     process.exit(2);
   }
@@ -4640,9 +4641,8 @@ async function handleMultiInstanceStoryboardRun(args, opts, urls) {
  * `get_adcp_capabilities`; tools without a unique claimant fall through to
  * `--default-agent`, or fail-fast with `unroutable_task`.
  *
- * Capability-driven full assessment is intentionally not supported here —
- * the assessment dispatches via `comply()` which expects a single agent.
- * Storyboard ID, bundle ID, or `--file` is required.
+ * With no storyboard or file, every tenant is discovered first and the
+ * topology runs the union of capability-applicable storyboards.
  */
 async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   const { authToken, authScheme, protocolFlag, jsonOutput, dryRun, positionalArgs, file: filePath, format } = opts;
@@ -4671,17 +4671,11 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   }
 
   const storyboardId = firstPositional;
+  const capabilityDriven = !filePath && !storyboardId;
   if (filePath && storyboardId) {
     console.error('ERROR: Cannot combine a storyboard ID with --file. Use one or the other.');
     process.exit(2);
   }
-  if (!filePath && !storyboardId) {
-    console.error(
-      'ERROR: Multi-agent routing requires a storyboard ID, bundle ID, or --file. ' +
-        'Capability-driven full assessment is not yet routing-aware.'
-    );
-    process.exit(2);
-  }
 
   const { loadStoryboardFile, runStoryboard, getComplianceStoryboardById, loadBundleStoryboards, findBundleById } =
     await import('../dist/lib/testing/storyboard/index.js');
@@ -4694,7 +4688,7 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
       console.error(`Failed to load storyboard from ${filePath}: ${err.message}`);
       process.exit(2);
     }
-  } else {
+  } else if (storyboardId) {
     const bundle = findBundleById(storyboardId, resolveOptions);
     if (bundle) {
       const bundleStoryboards = loadBundleStoryboards(bundle);
@@ -4750,6 +4744,49 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
 
   await loadInvariantModules(args);
 
+  let routedSelection;
+  let routedSelectionSummary;
+  let routingProfiles;
+  if (capabilityDriven) {
+    const { discoverAgentRouting } = await import('../dist/lib/testing/storyboard/agent-routing.js');
+    const { resolveRoutedAssessment } = await import('../dist/lib/testing/compliance/comply.js');
+    const discoveryOptions = {
+      protocol,
+      ...buildResolvedAuthOption({ resolvedAuth: authToken, resolvedAuthScheme: authScheme || 'bearer' }),
+      ...(opts.allowHttp && { allow_http: true }),
+      agents: routing.agents,
+      ...(routing.default_agent ? { default_agent: routing.default_agent } : {}),
+      ...(runComplianceDir && { complianceDir: runComplianceDir }),
+      ...(runAdcpVersion && { adcpVersion: runAdcpVersion }),
+      ...(runSchemaRoot && { schemaRoot: runSchemaRoot }),
+      ...sandboxRunOptions(opts),
+      ...(requestSigningOpts ?? {}),
+    };
+    const restoreDiscoveryLogs = jsonOutput ? captureStdoutLogs() : null;
+    try {
+      if (!jsonOutput) console.error('Discovering routed agent capabilities...');
+      const routingContext = await discoverAgentRouting(discoveryOptions);
+      routingProfiles = routingContext.profiles;
+      routedSelection = resolveRoutedAssessment(routingProfiles, resolveOptions);
+      routedSelectionSummary = {
+        agents: routedSelection.agents,
+        not_applicable: routedSelection.not_applicable,
+        missing_tools: routedSelection.missing_tools,
+        storyboard_ids: routedSelection.storyboards.map(storyboard => storyboard.id),
+      };
+      storyboards.push(...routedSelection.storyboards);
+    } catch (err) {
+      console.error(`ERROR: Failed to resolve routed assessment: ${err.message}`);
+      process.exit(1);
+    } finally {
+      if (restoreDiscoveryLogs) restoreDiscoveryLogs();
+    }
+    if (storyboards.length === 0) {
+      console.error('ERROR: Routed capability discovery selected no runnable storyboards.');
+      process.exit(1);
+    }
+  }
+
   const totalSteps = storyboards.reduce(
     (sum, sb) => sum + sb.phases.reduce((phaseSum, p) => phaseSum + p.steps.length, 0),
     0
@@ -4779,6 +4816,10 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
         default_agent: routing.default_agent,
         protocol,
         preview: true,
+        ...(capabilityDriven && {
+          assessment_mode: 'capability-driven',
+          selection: routedSelectionSummary,
+        }),
         storyboards: storyboards.map(sb => ({
           storyboard_id: sb.id,
           storyboard_title: sb.title,
@@ -4801,6 +4842,10 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
       }
       console.log(`\n${totalSteps} step(s) would be routed at run time. Use without --dry-run to execute.`);
     }
+    if (capabilityDriven) {
+      const { closeConnections } = await import('../dist/lib/protocols/index.js');
+      await closeConnections(protocol);
+    }
     return;
   }
 
@@ -4827,6 +4872,7 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
     }),
     ...(opts.loadedTestKit !== undefined && { test_kit: opts.loadedTestKit }),
     ...(requestSigningOpts ?? {}),
+    ...(routingProfiles && { _routingProfiles: routingProfiles }),
   };
 
   const restoreLogs = jsonOutput ? captureStdoutLogs() : null;
@@ -4844,7 +4890,12 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   }
 
   if (format === 'junit') {
-    process.stdout.write(formatStoryboardResultsAsJUnit(results));
+    const suiteGroups = capabilityDriven
+      ? Object.fromEntries(results.map(result => [result.storyboard_id, routedStoryboardResultGroup(result)]))
+      : undefined;
+    process.stdout.write(
+      formatStoryboardResultsAsJUnit(results, suiteGroups ? { suite_groups: suiteGroups } : undefined)
+    );
     if (opts.softFail && hadFailure) {
       printSoftFailBlock(
         results.filter(r => !r.overall_passed).map(r => r.storyboard_id),
@@ -4855,13 +4906,25 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   }
 
   if (jsonOutput) {
+    const reports = {};
+    if (capabilityDriven) {
+      for (const result of results) {
+        const group = routedStoryboardResultGroup(result);
+        (reports[group] ??= []).push(result);
+      }
+    }
     await writeJsonOutput(
-      results.length === 1
+      !capabilityDriven && results.length === 1
         ? results[0]
         : {
             agents: routing.agents,
             default_agent: routing.default_agent,
-            storyboards: results,
+            ...(capabilityDriven && {
+              assessment_mode: 'capability-driven',
+              selection: routedSelectionSummary,
+              reports,
+            }),
+            ...(!capabilityDriven && { storyboards: results }),
             overall_passed: !hadFailure,
           }
     );

package/dist/lib/acceptance-policy/index.d.mts

@@ -0,0 +1,176 @@
+/**
+ * Buyer-side resolution of seller acceptance-policy catalogs.
+ *
+ * Catalog discovery is advisory. A successfully resolved catalog describes
+ * likely seller treatment; it never authorizes an exact media-buy request.
+ */
+import type { ResolvePolicyResponse } from '../registry/types.mjs';
+export interface AcceptancePolicyDiscoveryCapability {
+    catalog_url: string;
+    catalog_digest: string;
+    default_profile_ids?: readonly string[];
+}
+export interface AcceptancePolicyReference {
+    policy_id: string;
+    version: string;
+    content_digest: string;
+}
+export interface AcceptancePolicyRule {
+    rule_id: string;
+    subject_category: string;
+    jurisdiction_groups?: string[];
+    applies_to: string[];
+    disposition: 'allowed' | 'conditional' | 'prohibited';
+    policy_ids?: string[];
+    [key: string]: unknown;
+}
+export interface AcceptancePolicyProfile {
+    profile_id: string;
+    version: string;
+    content_digest: string;
+    policy_refs: AcceptancePolicyReference[];
+    coverage: 'partial' | 'complete';
+    scope?: {
+        jurisdiction_groups?: string[];
+        [key: string]: unknown;
+    };
+    region_aliases?: Record<string, string[]>;
+    rules: AcceptancePolicyRule[];
+    [key: string]: unknown;
+}
+export interface RegistryAcceptancePolicyProfileReference {
+    policy_id: string;
+    policy_version: string;
+    policy_digest: string;
+    profile_id: string;
+    profile_version: string;
+    profile_digest: string;
+}
+export interface AcceptancePolicyCatalog {
+    catalog_version: string;
+    generated_at?: string;
+    profiles?: AcceptancePolicyProfile[];
+    registry_profiles?: RegistryAcceptancePolicyProfileReference[];
+    ext?: Record<string, unknown>;
+}
+export type ResolvedAcceptancePolicyDefault = {
+    source: 'seller';
+    resolution: 'resolved';
+    profileId: string;
+    profile: AcceptancePolicyProfile;
+} | {
+    source: 'registry';
+    resolution: 'resolved';
+    profileId: string;
+    profile: AcceptancePolicyProfile;
+    ref: RegistryAcceptancePolicyProfileReference;
+} | {
+    source: 'registry';
+    resolution: 'unresolved';
+    profileId: string;
+    ref: RegistryAcceptancePolicyProfileReference;
+};
+export type AcceptancePolicyProfileResolution = ResolvedAcceptancePolicyDefault | {
+    source: 'catalog';
+    resolution: 'missing';
+    profileId: string;
+};
+export type AcceptancePolicyCatalogErrorCode = 'invalid_capability' | 'invalid_options' | 'unsafe_url' | 'redirect_blocked' | 'fetch_failed' | 'http_error' | 'body_too_large' | 'digest_mismatch' | 'invalid_json' | 'catalog_document_invalid' | 'schema_unavailable' | 'schema_invalid' | 'duplicate_profile_id' | 'unresolved_profile_id' | 'profile_canonicalization_invalid' | 'profile_digest_mismatch' | 'reference_invalid' | 'registry_fetch_failed' | 'registry_reference_unresolved' | 'registry_policy_mismatch' | 'registry_policy_unverifiable' | 'registry_policy_digest_mismatch' | 'registry_profile_schema_invalid' | 'registry_profile_invalid' | 'registry_profile_mismatch' | 'registry_profile_digest_mismatch' | 'registry_resolution_limit_exceeded' | 'registry_timeout';
+export interface AcceptancePolicyCatalogIssue {
+    code: AcceptancePolicyCatalogErrorCode;
+    message: string;
+    /** JSON Pointer into the capability or catalog. Values are never echoed. */
+    pointer: string;
+    keyword?: string;
+    retryable?: boolean;
+    httpStatus?: number;
+}
+export interface AcceptancePolicyCatalogFailure {
+    ok: false;
+    fromCache: false;
+    error: AcceptancePolicyCatalogIssue;
+    issues?: AcceptancePolicyCatalogIssue[];
+}
+export interface AcceptancePolicyCatalogSuccess {
+    ok: true;
+    fromCache: boolean;
+    catalog: AcceptancePolicyCatalog;
+    defaultProfiles: ResolvedAcceptancePolicyDefault[];
+    /** Non-fatal registry diagnostics. Affected profiles remain unresolved. */
+    issues?: AcceptancePolicyCatalogIssue[];
+}
+export type AcceptancePolicyCatalogResult = AcceptancePolicyCatalogSuccess | AcceptancePolicyCatalogFailure;
+/** Registry fields covered by acceptance-policy pin verification. */
+export type AcceptancePolicyRegistryPolicy = Pick<ResolvePolicyResponse, 'policy_id' | 'version' | 'content_digest' | 'canonical_content' | 'acceptance_profile'>;
+/** Minimal trusted-registry surface needed to resolve an immutable policy version. */
+export interface AcceptancePolicyRegistryResolver {
+    resolvePolicy(params: {
+        policy_id: string;
+        version?: string;
+        signal?: AbortSignal;
+    }): Promise<AcceptancePolicyRegistryPolicy | null>;
+}
+export interface ResolveVerifiedAcceptancePolicyProfilesOptions {
+    registryResolver: AcceptancePolicyRegistryResolver;
+    /** Schema bundle used to validate embedded profiles. Defaults to the SDK pin. */
+    adcpVersion?: string;
+    /** Overall deadline for all selected registry lookups. Default 5 seconds. */
+    timeoutMs?: number;
+    /** Maximum distinct registry profiles resolved in one call. Default and maximum 32. */
+    maxRegistryProfiles?: number;
+}
+export interface VerifiedAcceptancePolicyProfilesSuccess {
+    ok: true;
+    profiles: AcceptancePolicyProfileResolution[];
+    /** Per-profile failures. Each affected registry profile remains unresolved. */
+    issues?: AcceptancePolicyCatalogIssue[];
+}
+export type VerifiedAcceptancePolicyProfilesResult = VerifiedAcceptancePolicyProfilesSuccess | AcceptancePolicyCatalogFailure;
+export interface ResolveAcceptancePolicyCatalogOptions {
+    /** Schema bundle used to validate the fetched catalog. Defaults to the SDK pin. */
+    adcpVersion?: string;
+    /** Overall DNS/connect/body timeout for the catalog fetch. Default 5 seconds. */
+    timeoutMs?: number;
+    /** Hard response-body cap. Default and maximum 1 MiB; callers may lower it. */
+    maxBodyBytes?: number;
+    /** Test/dev-only HTTP opt-in; requires allowPrivateNetwork. Production callers must leave false. */
+    allowUnsafeHttp?: boolean;
+    /** Test/dev-only opt-in for private-network fixtures. Production callers must leave false. */
+    allowPrivateNetwork?: boolean;
+    /** Trusted AdCP registry client used to resolve and verify registry-backed defaults. */
+    registryResolver?: AcceptancePolicyRegistryResolver;
+    /** Overall deadline for registry resolution. Default 5 seconds. */
+    registryTimeoutMs?: number;
+    /** Maximum registry-backed defaults resolved in one call. Default and maximum 32. */
+    maxRegistryProfiles?: number;
+}
+export interface AcceptancePolicyCatalogResolver {
+    /**
+     * Resolve the currently advertised catalog. A capability change atomically
+     * invalidates the resolver's single-entry cache before the next fetch.
+     */
+    resolve(capability: AcceptancePolicyDiscoveryCapability): Promise<AcceptancePolicyCatalogResult>;
+    /** Explicit invalidation hook for a capabilities-changed notification. */
+    invalidate(): void;
+}
+/**
+ * Resolve seller-local profiles and identify registry pins that still require
+ * trusted registry resolution. Missing IDs and unresolved registry references
+ * are never represented as usable policy rules.
+ */
+export declare function resolveAcceptancePolicyProfiles(catalog: AcceptancePolicyCatalog, profileIds: readonly string[]): AcceptancePolicyProfileResolution[];
+/**
+ * Resolve selected seller-local and registry-backed profiles from a catalog
+ * already obtained through the digest-pinned catalog resolver. Registry
+ * content becomes usable only after both immutable policy and embedded profile
+ * pins verify; each failed pin remains unresolved with an issue diagnostic.
+ */
+export declare function resolveVerifiedAcceptancePolicyProfiles(catalog: AcceptancePolicyCatalog, profileIds: readonly string[], options: ResolveVerifiedAcceptancePolicyProfilesOptions): Promise<VerifiedAcceptancePolicyProfilesResult>;
+/** Resolve once without retaining remote content. */
+export declare function resolveAcceptancePolicyCatalog(capability: AcceptancePolicyDiscoveryCapability, options?: ResolveAcceptancePolicyCatalogOptions): Promise<AcceptancePolicyCatalogResult>;
+/**
+ * Create a capability-lifetime resolver. It retains only the current
+ * capability's successful catalog and clears that entry whenever any
+ * advertised catalog URL, digest, or default profile changes.
+ */
+export declare function createAcceptancePolicyCatalogResolver(options?: ResolveAcceptancePolicyCatalogOptions): AcceptancePolicyCatalogResolver;

package/dist/lib/acceptance-policy/index.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Buyer-side resolution of seller acceptance-policy catalogs.
+ *
+ * Catalog discovery is advisory. A successfully resolved catalog describes
+ * likely seller treatment; it never authorizes an exact media-buy request.
+ */
+import type { ResolvePolicyResponse } from '../registry/types';
+export interface AcceptancePolicyDiscoveryCapability {
+    catalog_url: string;
+    catalog_digest: string;
+    default_profile_ids?: readonly string[];
+}
+export interface AcceptancePolicyReference {
+    policy_id: string;
+    version: string;
+    content_digest: string;
+}
+export interface AcceptancePolicyRule {
+    rule_id: string;
+    subject_category: string;
+    jurisdiction_groups?: string[];
+    applies_to: string[];
+    disposition: 'allowed' | 'conditional' | 'prohibited';
+    policy_ids?: string[];
+    [key: string]: unknown;
+}
+export interface AcceptancePolicyProfile {
+    profile_id: string;
+    version: string;
+    content_digest: string;
+    policy_refs: AcceptancePolicyReference[];
+    coverage: 'partial' | 'complete';
+    scope?: {
+        jurisdiction_groups?: string[];
+        [key: string]: unknown;
+    };
+    region_aliases?: Record<string, string[]>;
+    rules: AcceptancePolicyRule[];
+    [key: string]: unknown;
+}
+export interface RegistryAcceptancePolicyProfileReference {
+    policy_id: string;
+    policy_version: string;
+    policy_digest: string;
+    profile_id: string;
+    profile_version: string;
+    profile_digest: string;
+}
+export interface AcceptancePolicyCatalog {
+    catalog_version: string;
+    generated_at?: string;
+    profiles?: AcceptancePolicyProfile[];
+    registry_profiles?: RegistryAcceptancePolicyProfileReference[];
+    ext?: Record<string, unknown>;
+}
+export type ResolvedAcceptancePolicyDefault = {
+    source: 'seller';
+    resolution: 'resolved';
+    profileId: string;
+    profile: AcceptancePolicyProfile;
+} | {
+    source: 'registry';
+    resolution: 'resolved';
+    profileId: string;
+    profile: AcceptancePolicyProfile;
+    ref: RegistryAcceptancePolicyProfileReference;
+} | {
+    source: 'registry';
+    resolution: 'unresolved';
+    profileId: string;
+    ref: RegistryAcceptancePolicyProfileReference;
+};
+export type AcceptancePolicyProfileResolution = ResolvedAcceptancePolicyDefault | {
+    source: 'catalog';
+    resolution: 'missing';
+    profileId: string;
+};
+export type AcceptancePolicyCatalogErrorCode = 'invalid_capability' | 'invalid_options' | 'unsafe_url' | 'redirect_blocked' | 'fetch_failed' | 'http_error' | 'body_too_large' | 'digest_mismatch' | 'invalid_json' | 'catalog_document_invalid' | 'schema_unavailable' | 'schema_invalid' | 'duplicate_profile_id' | 'unresolved_profile_id' | 'profile_canonicalization_invalid' | 'profile_digest_mismatch' | 'reference_invalid' | 'registry_fetch_failed' | 'registry_reference_unresolved' | 'registry_policy_mismatch' | 'registry_policy_unverifiable' | 'registry_policy_digest_mismatch' | 'registry_profile_schema_invalid' | 'registry_profile_invalid' | 'registry_profile_mismatch' | 'registry_profile_digest_mismatch' | 'registry_resolution_limit_exceeded' | 'registry_timeout';
+export interface AcceptancePolicyCatalogIssue {
+    code: AcceptancePolicyCatalogErrorCode;
+    message: string;
+    /** JSON Pointer into the capability or catalog. Values are never echoed. */
+    pointer: string;
+    keyword?: string;
+    retryable?: boolean;
+    httpStatus?: number;
+}
+export interface AcceptancePolicyCatalogFailure {
+    ok: false;
+    fromCache: false;
+    error: AcceptancePolicyCatalogIssue;
+    issues?: AcceptancePolicyCatalogIssue[];
+}
+export interface AcceptancePolicyCatalogSuccess {
+    ok: true;
+    fromCache: boolean;
+    catalog: AcceptancePolicyCatalog;
+    defaultProfiles: ResolvedAcceptancePolicyDefault[];
+    /** Non-fatal registry diagnostics. Affected profiles remain unresolved. */
+    issues?: AcceptancePolicyCatalogIssue[];
+}
+export type AcceptancePolicyCatalogResult = AcceptancePolicyCatalogSuccess | AcceptancePolicyCatalogFailure;
+/** Registry fields covered by acceptance-policy pin verification. */
+export type AcceptancePolicyRegistryPolicy = Pick<ResolvePolicyResponse, 'policy_id' | 'version' | 'content_digest' | 'canonical_content' | 'acceptance_profile'>;
+/** Minimal trusted-registry surface needed to resolve an immutable policy version. */
+export interface AcceptancePolicyRegistryResolver {
+    resolvePolicy(params: {
+        policy_id: string;
+        version?: string;
+        signal?: AbortSignal;
+    }): Promise<AcceptancePolicyRegistryPolicy | null>;
+}
+export interface ResolveVerifiedAcceptancePolicyProfilesOptions {
+    registryResolver: AcceptancePolicyRegistryResolver;
+    /** Schema bundle used to validate embedded profiles. Defaults to the SDK pin. */
+    adcpVersion?: string;
+    /** Overall deadline for all selected registry lookups. Default 5 seconds. */
+    timeoutMs?: number;
+    /** Maximum distinct registry profiles resolved in one call. Default and maximum 32. */
+    maxRegistryProfiles?: number;
+}
+export interface VerifiedAcceptancePolicyProfilesSuccess {
+    ok: true;
+    profiles: AcceptancePolicyProfileResolution[];
+    /** Per-profile failures. Each affected registry profile remains unresolved. */
+    issues?: AcceptancePolicyCatalogIssue[];
+}
+export type VerifiedAcceptancePolicyProfilesResult = VerifiedAcceptancePolicyProfilesSuccess | AcceptancePolicyCatalogFailure;
+export interface ResolveAcceptancePolicyCatalogOptions {
+    /** Schema bundle used to validate the fetched catalog. Defaults to the SDK pin. */
+    adcpVersion?: string;
+    /** Overall DNS/connect/body timeout for the catalog fetch. Default 5 seconds. */
+    timeoutMs?: number;
+    /** Hard response-body cap. Default and maximum 1 MiB; callers may lower it. */
+    maxBodyBytes?: number;
+    /** Test/dev-only HTTP opt-in; requires allowPrivateNetwork. Production callers must leave false. */
+    allowUnsafeHttp?: boolean;
+    /** Test/dev-only opt-in for private-network fixtures. Production callers must leave false. */
+    allowPrivateNetwork?: boolean;
+    /** Trusted AdCP registry client used to resolve and verify registry-backed defaults. */
+    registryResolver?: AcceptancePolicyRegistryResolver;
+    /** Overall deadline for registry resolution. Default 5 seconds. */
+    registryTimeoutMs?: number;
+    /** Maximum registry-backed defaults resolved in one call. Default and maximum 32. */
+    maxRegistryProfiles?: number;
+}
+export interface AcceptancePolicyCatalogResolver {
+    /**
+     * Resolve the currently advertised catalog. A capability change atomically
+     * invalidates the resolver's single-entry cache before the next fetch.
+     */
+    resolve(capability: AcceptancePolicyDiscoveryCapability): Promise<AcceptancePolicyCatalogResult>;
+    /** Explicit invalidation hook for a capabilities-changed notification. */
+    invalidate(): void;
+}
+/**
+ * Resolve seller-local profiles and identify registry pins that still require
+ * trusted registry resolution. Missing IDs and unresolved registry references
+ * are never represented as usable policy rules.
+ */
+export declare function resolveAcceptancePolicyProfiles(catalog: AcceptancePolicyCatalog, profileIds: readonly string[]): AcceptancePolicyProfileResolution[];
+/**
+ * Resolve selected seller-local and registry-backed profiles from a catalog
+ * already obtained through the digest-pinned catalog resolver. Registry
+ * content becomes usable only after both immutable policy and embedded profile
+ * pins verify; each failed pin remains unresolved with an issue diagnostic.
+ */
+export declare function resolveVerifiedAcceptancePolicyProfiles(catalog: AcceptancePolicyCatalog, profileIds: readonly string[], options: ResolveVerifiedAcceptancePolicyProfilesOptions): Promise<VerifiedAcceptancePolicyProfilesResult>;
+/** Resolve once without retaining remote content. */
+export declare function resolveAcceptancePolicyCatalog(capability: AcceptancePolicyDiscoveryCapability, options?: ResolveAcceptancePolicyCatalogOptions): Promise<AcceptancePolicyCatalogResult>;
+/**
+ * Create a capability-lifetime resolver. It retains only the current
+ * capability's successful catalog and clears that entry whenever any
+ * advertised catalog URL, digest, or default profile changes.
+ */
+export declare function createAcceptancePolicyCatalogResolver(options?: ResolveAcceptancePolicyCatalogOptions): AcceptancePolicyCatalogResolver;