@adcp/sdk 14.0.0-rc.42 → 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.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');
@@ -2917,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);
   }
@@ -4638,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;
@@ -4669,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');
@@ -4692,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);
@@ -4748,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
@@ -4777,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,
@@ -4799,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;
   }
 
@@ -4825,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;
@@ -4842,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),
@@ -4853,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;