@adcp/sdk 14.0.0-rc.39 → 14.0.0-rc.40

package/dist/lib/supply-path/verify.mjs

@@ -0,0 +1,203 @@
+import { withAbortSignal } from "../protocols/abort.mjs";
+import {
+  parsePublisherPropertySelector,
+  expandPublisherPropertySelector
+} from "../discovery/publisher-property-selector.mjs";
+import { domain, records, strings } from "./validation.mjs";
+import { RegistryClient } from "../registry/index.mjs";
+import { SupplyPathEvidenceSession } from "./fetch-evidence.mjs";
+import {
+  isUnqualifiedPropertySelector,
+  hasValidPropertySelectorPredicate,
+  evaluateSupplyPath,
+  evaluationLimitVerdict,
+  supplyPathAdsTxtPolicy,
+  parseInventoryPartnerDomains
+} from "./evaluate.mjs";
+import { assertRegistrySupplyPathResult, validateSupplyPathRequest } from "./validation.mjs";
+const MAX_PROPERTY_SCOPE_VALUES = 32768;
+const MAX_PROPERTY_SELECTOR_EXPANSIONS = 4096;
+async function verifySupplyPath(request, options = { source: "authoritative" }) {
+  const normalized = validateSupplyPathRequest(request);
+  if (options.source === "registry") {
+    const result = await (options.registry ?? new RegistryClient()).verifySupplyPath(normalized);
+    assertRegistrySupplyPathResult(result, normalized);
+    return result;
+  }
+  if (options.source !== "authoritative") throw new TypeError("source must be registry or authoritative");
+  const session = new SupplyPathEvidenceSession(options);
+  try {
+    return await withAbortSignal(
+      [session.signal],
+      void 0,
+      () => verifyAuthoritativeSupplyPath(normalized, options, session)
+    );
+  } finally {
+    session.close();
+  }
+}
+async function verifyAuthoritativeSupplyPath(normalized, options, session) {
+  if (options.propertySelectors !== void 0) {
+    if (!Array.isArray(options.propertySelectors) || !options.propertySelectors.length)
+      throw new TypeError("propertySelectors must be non-empty");
+    if (options.propertySelectors.length > 1024)
+      throw new TypeError("propertySelectors exceed the evaluation work limit");
+    for (const raw of options.propertySelectors) {
+      if (!isUnqualifiedPropertySelector(raw)) throw new TypeError("Unsupported product property selector fields");
+      if (!hasValidPropertySelectorPredicate(raw))
+        throw new TypeError("Product property selector predicate conflicts with selection_type");
+    }
+  }
+  const [ownerManifest, hostManifest] = await Promise.all([
+    session.adagents(normalized.owner_domain),
+    session.adagents(normalized.host_domain)
+  ]);
+  const input = {
+    ownerDomain: normalized.owner_domain,
+    hostDomain: normalized.host_domain,
+    agentUrl: normalized.agent_url,
+    collectionId: normalized.collection_id,
+    ownerManifest,
+    hostManifest,
+    requireExplicitOwnerPublisherDomain: session.crossOriginAuthorities.has(normalized.owner_domain),
+    requireExplicitHostPublisherDomain: session.crossOriginAuthorities.has(normalized.host_domain),
+    hostInventoryPartnerDomains: null,
+    hostInventoryPartnerDomainsByFile: void 0,
+    heldRevocations: {
+      owner: session.revocations.get(normalized.owner_domain)?.map((r) => r.publisher_domain),
+      host: session.revocations.get(normalized.host_domain)?.map((r) => r.publisher_domain)
+    }
+  };
+  const scopedInput = input;
+  let selectorLimitExceeded = false;
+  if (options.propertySelectors !== void 0) {
+    const ids = /* @__PURE__ */ new Set();
+    const rawProperties = hostManifest?.properties;
+    if (Array.isArray(rawProperties) && rawProperties.length > 1024) selectorLimitExceeded = true;
+    const properties = selectorLimitExceeded ? [] : records(rawProperties).filter(
+      (p) => p.publisher_domain === void 0 && !input.requireExplicitHostPublisherDomain || domain(p.publisher_domain) === normalized.host_domain
+    );
+    let unresolved = false;
+    let scopeValues = properties.length;
+    const availableTags = /* @__PURE__ */ new Set();
+    for (const property of properties) {
+      session.assertActive();
+      if (property.tags === void 0) continue;
+      if (!Array.isArray(property.tags) || property.tags.length > 1024 || property.tags.some((tag) => typeof tag !== "string" || !tag.trim())) {
+        selectorLimitExceeded = true;
+        continue;
+      }
+      scopeValues += property.tags.length;
+      if (scopeValues > MAX_PROPERTY_SCOPE_VALUES) {
+        selectorLimitExceeded = true;
+        break;
+      }
+      for (const tag of property.tags) {
+        if (tag.length > 8192) selectorLimitExceeded = true;
+        availableTags.add(tag);
+      }
+    }
+    const selectors = [];
+    for (const raw of options.propertySelectors) {
+      session.assertActive();
+      if (selectorLimitExceeded) continue;
+      const selector = parsePublisherPropertySelector(raw);
+      const expansionCount = "publisher_domains" in selector ? selector.publisher_domains.length : 1;
+      if (selectors.length + expansionCount > MAX_PROPERTY_SELECTOR_EXPANSIONS) {
+        selectorLimitExceeded = true;
+        continue;
+      }
+      const expanded = expandPublisherPropertySelector(selector);
+      selectors.push(...expanded);
+    }
+    const selectedTags = /* @__PURE__ */ new Set();
+    let selectAll = false;
+    for (const single of selectors) {
+      session.assertActive();
+      scopeValues += 1;
+      if (scopeValues > MAX_PROPERTY_SCOPE_VALUES) selectorLimitExceeded = true;
+      if (!selectorLimitExceeded) {
+        if (domain(single.publisher_domain) !== normalized.host_domain)
+          throw new TypeError("propertySelectors must name host_domain");
+        if (single.selection_type === "by_id") {
+          if (!strings(single.property_ids)) throw new TypeError("Invalid product property IDs");
+          scopeValues += single.property_ids.length;
+          if (single.property_ids.length > 1024 || single.property_ids.some((id) => id.length > 8192))
+            selectorLimitExceeded = true;
+          for (const id of single.property_ids) ids.add(id);
+        } else {
+          if (single.selection_type === "by_tag" && !strings(single.property_tags))
+            throw new TypeError("Invalid product property tags");
+          if (single.selection_type === "all") {
+            selectAll = true;
+            if (!properties.length) unresolved = true;
+          } else {
+            scopeValues += single.property_tags.length;
+            if (single.property_tags.length > 1024 || single.property_tags.some((tag) => tag.length > 8192))
+              selectorLimitExceeded = true;
+            let matched = false;
+            for (const tag of single.property_tags) {
+              if (!availableTags.has(tag)) continue;
+              matched = true;
+              selectedTags.add(tag);
+            }
+            if (!matched) unresolved = true;
+          }
+        }
+      }
+    }
+    if (scopeValues > MAX_PROPERTY_SCOPE_VALUES) selectorLimitExceeded = true;
+    if (!selectorLimitExceeded && (selectAll || selectedTags.size)) {
+      for (const property of properties) {
+        session.assertActive();
+        const selected = selectAll || Array.isArray(property.tags) && property.tags.some((tag) => selectedTags.has(tag));
+        if (!selected) continue;
+        if (typeof property.property_id !== "string" || !property.property_id.length) unresolved = true;
+        else ids.add(property.property_id);
+      }
+    }
+    scopedInput.requiredHostPropertyIds = selectorLimitExceeded || unresolved ? [] : [...ids];
+  }
+  session.assertActive();
+  let verdict = selectorLimitExceeded ? evaluationLimitVerdict() : evaluateSupplyPath(scopedInput);
+  session.assertActive();
+  if (!verdict.legs.host_authorization.ok && verdict.legs.host_authorization.failure !== "evaluation_limit_exceeded") {
+    const policy = supplyPathAdsTxtPolicy(scopedInput);
+    const responses = await Promise.all(
+      policy.files.map((kind) => session.read(normalized.host_domain, kind, `https://${normalized.host_domain}/${kind}`))
+    );
+    input.hostInventoryPartnerDomainsByFile = Object.fromEntries(
+      policy.files.map((file, index) => [
+        file,
+        responses[index] ? parseInventoryPartnerDomains(new TextDecoder().decode(responses[index].body)) : null
+      ])
+    );
+    session.assertActive();
+    verdict = evaluateSupplyPath(scopedInput);
+    session.assertActive();
+  } else if (verdict.legs.host_authorization.ok) {
+    verdict = evaluateSupplyPath({ ...scopedInput, inventoryPartnerDomainEvaluated: false });
+    session.assertActive();
+  }
+  session.assertActive();
+  return {
+    ...verdict,
+    ...normalized,
+    source: "authoritative",
+    ...options.propertySelectors ? { property_selectors: options.propertySelectors } : {},
+    sources: {
+      owner_adagents_url: `https://${normalized.owner_domain}/.well-known/adagents.json`,
+      host_adagents_url: `https://${normalized.host_domain}/.well-known/adagents.json`,
+      cached: false,
+      held_revocations: [...session.revocations].filter(([authority]) => authority === normalized.owner_domain || authority === normalized.host_domain).map(([authority, entries]) => ({ authority, entries })),
+      evidence: session.evidence.filter(
+        (e) => e.publisher_domain === normalized.owner_domain || e.publisher_domain === normalized.host_domain
+      )
+    },
+    checked_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+export {
+  verifyAuthoritativeSupplyPath,
+  verifySupplyPath
+};

package/dist/lib/testing/storyboard/request-signing/grader.js

@@ -148,7 +148,7 @@ function preflightSkip(vector, kind, contract, options) {
     return { ...base, skipped: true, skip_reason: "operator_skip" };
   }
   if (options.agentCapability) {
-    const mismatch = capabilityMismatch(vector, options.agentCapability);
+    const mismatch = capabilityMismatch(vector, kind, options.agentCapability);
     if (mismatch) {
       return { ...base, skipped: true, skip_reason: "capability_profile_mismatch", diagnostic: mismatch };
     }
@@ -474,23 +474,33 @@ function contentDigestStructuralMismatch(vector, agentCoversContentDigest) {
   }
   return void 0;
 }
+const CONTENT_DIGEST_POLICY_REFUSALS = /* @__PURE__ */ new Set([
+  "request_signature_components_incomplete",
+  "request_signature_components_unexpected"
+]);
+function contentDigestDeclarationMismatch(vector, kind, agentPolicy) {
+  const vectorCd = vector.verifier_capability.covers_content_digest;
+  if (vectorCd === "either" || vectorCd === agentPolicy) return void 0;
+  if (agentPolicy === "either") {
+    const expected = kind === "negative" ? vector.expected_error_code : void 0;
+    if (expected === void 0 || !CONTENT_DIGEST_POLICY_REFUSALS.has(expected)) return void 0;
+  }
+  return `Vector asserts covers_content_digest='${vectorCd}' but agent declares '${agentPolicy}'. The vector can't grade against this profile \u2014 its expected verifier behavior doesn't match what the agent implements.`;
+}
 function contentDigestPolicyMismatch(vector, kind, agentPolicy) {
   if (kind === "negative") {
-    const vectorCd = vector.verifier_capability.covers_content_digest;
-    if (vectorCd !== "either" && vectorCd !== agentPolicy) {
-      return `Vector asserts covers_content_digest='${vectorCd}' but agent declares '${agentPolicy}'. The agent's policy is incompatible with the vector's expected verifier behavior.`;
-    }
+    const declared = contentDigestDeclarationMismatch(vector, kind, agentPolicy);
+    if (declared) return declared;
   }
   return contentDigestStructuralMismatch(vector, agentPolicy);
 }
-function capabilityMismatch(vector, agentCap) {
+function capabilityMismatch(vector, kind, agentCap) {
   const vectorCap = vector.verifier_capability;
   if (vectorCap.supported !== agentCap.supported) {
     return `Vector asserts supported=${vectorCap.supported} but agent declares supported=${agentCap.supported}. Verify the agent's request_signing capability block.`;
   }
-  if (vectorCap.covers_content_digest !== "either" && vectorCap.covers_content_digest !== agentCap.covers_content_digest) {
-    return `Vector asserts covers_content_digest='${vectorCap.covers_content_digest}' but agent declares '${agentCap.covers_content_digest}'. The vector can't grade against this profile \u2014 its expected verifier behavior doesn't match what the agent implements.`;
-  }
+  const declared = contentDigestDeclarationMismatch(vector, kind, agentCap.covers_content_digest);
+  if (declared) return declared;
   const structural = contentDigestStructuralMismatch(vector, agentCap.covers_content_digest);
   if (structural) return structural;
   const vectorRequiredFor = vectorCap.required_for ?? [];

package/dist/lib/testing/storyboard/request-signing/grader.mjs

@@ -128,7 +128,7 @@ function preflightSkip(vector, kind, contract, options) {
     return { ...base, skipped: true, skip_reason: "operator_skip" };
   }
   if (options.agentCapability) {
-    const mismatch = capabilityMismatch(vector, options.agentCapability);
+    const mismatch = capabilityMismatch(vector, kind, options.agentCapability);
     if (mismatch) {
       return { ...base, skipped: true, skip_reason: "capability_profile_mismatch", diagnostic: mismatch };
     }
@@ -454,23 +454,33 @@ function contentDigestStructuralMismatch(vector, agentCoversContentDigest) {
   }
   return void 0;
 }
+const CONTENT_DIGEST_POLICY_REFUSALS = /* @__PURE__ */ new Set([
+  "request_signature_components_incomplete",
+  "request_signature_components_unexpected"
+]);
+function contentDigestDeclarationMismatch(vector, kind, agentPolicy) {
+  const vectorCd = vector.verifier_capability.covers_content_digest;
+  if (vectorCd === "either" || vectorCd === agentPolicy) return void 0;
+  if (agentPolicy === "either") {
+    const expected = kind === "negative" ? vector.expected_error_code : void 0;
+    if (expected === void 0 || !CONTENT_DIGEST_POLICY_REFUSALS.has(expected)) return void 0;
+  }
+  return `Vector asserts covers_content_digest='${vectorCd}' but agent declares '${agentPolicy}'. The vector can't grade against this profile \u2014 its expected verifier behavior doesn't match what the agent implements.`;
+}
 function contentDigestPolicyMismatch(vector, kind, agentPolicy) {
   if (kind === "negative") {
-    const vectorCd = vector.verifier_capability.covers_content_digest;
-    if (vectorCd !== "either" && vectorCd !== agentPolicy) {
-      return `Vector asserts covers_content_digest='${vectorCd}' but agent declares '${agentPolicy}'. The agent's policy is incompatible with the vector's expected verifier behavior.`;
-    }
+    const declared = contentDigestDeclarationMismatch(vector, kind, agentPolicy);
+    if (declared) return declared;
   }
   return contentDigestStructuralMismatch(vector, agentPolicy);
 }
-function capabilityMismatch(vector, agentCap) {
+function capabilityMismatch(vector, kind, agentCap) {
   const vectorCap = vector.verifier_capability;
   if (vectorCap.supported !== agentCap.supported) {
     return `Vector asserts supported=${vectorCap.supported} but agent declares supported=${agentCap.supported}. Verify the agent's request_signing capability block.`;
   }
-  if (vectorCap.covers_content_digest !== "either" && vectorCap.covers_content_digest !== agentCap.covers_content_digest) {
-    return `Vector asserts covers_content_digest='${vectorCap.covers_content_digest}' but agent declares '${agentCap.covers_content_digest}'. The vector can't grade against this profile \u2014 its expected verifier behavior doesn't match what the agent implements.`;
-  }
+  const declared = contentDigestDeclarationMismatch(vector, kind, agentCap.covers_content_digest);
+  if (declared) return declared;
   const structural = contentDigestStructuralMismatch(vector, agentCap.covers_content_digest);
   if (structural) return structural;
   const vectorRequiredFor = vectorCap.required_for ?? [];

package/dist/lib/testing/storyboard/validations.d.mts

@@ -197,7 +197,7 @@ export interface UpstreamTrafficQueryResult {
  */
 export declare function runValidations(validations: StoryboardValidation[], context: ValidationContext): ValidationResult[];
 /** Capability semver emitted in run summaries and used for advisory expiry. */
-export declare const RUNNER_CAPABILITY_VERSION = "14.0.0-rc.39";
+export declare const RUNNER_CAPABILITY_VERSION = "14.0.0-rc.40";
 /** True when a failed validation contributes to the owning step's grade. */
 export declare function validationFailsStep(result: ValidationResult): boolean;
 /**

package/dist/lib/testing/storyboard/validations.d.ts

@@ -197,7 +197,7 @@ export interface UpstreamTrafficQueryResult {
  */
 export declare function runValidations(validations: StoryboardValidation[], context: ValidationContext): ValidationResult[];
 /** Capability semver emitted in run summaries and used for advisory expiry. */
-export declare const RUNNER_CAPABILITY_VERSION = "14.0.0-rc.39";
+export declare const RUNNER_CAPABILITY_VERSION = "14.0.0-rc.40";
 /** True when a failed validation contributes to the owning step's grade. */
 export declare function validationFailsStep(result: ValidationResult): boolean;
 /**

package/dist/lib/v2/projection/creative-delivery.d.mts

@@ -52,7 +52,7 @@ export type CanonicalPlacement = Omit<CanonicalCreativeResponse<Placement>, 'for
     format_ids?: never;
     format_options?: NonEmptyCanonicalFormatDeclarations;
 };
-export type CanonicalProduct = Omit<CanonicalCreativeResponse<Product>, 'format_ids' | 'format_options' | 'placements'> & {
+export type CanonicalProduct = Omit<CanonicalCreativeResponse<Product>, 'format_ids' | 'format_options' | 'placements'> & import('../../supply-path/products.mjs').ProductSupplyPathAnnotation & {
     product_id: string;
     format_ids?: never;
     format_options: NonEmptyCanonicalFormatDeclarations;

package/dist/lib/v2/projection/creative-delivery.d.ts

@@ -52,7 +52,7 @@ export type CanonicalPlacement = Omit<CanonicalCreativeResponse<Placement>, 'for
     format_ids?: never;
     format_options?: NonEmptyCanonicalFormatDeclarations;
 };
-export type CanonicalProduct = Omit<CanonicalCreativeResponse<Product>, 'format_ids' | 'format_options' | 'placements'> & {
+export type CanonicalProduct = Omit<CanonicalCreativeResponse<Product>, 'format_ids' | 'format_options' | 'placements'> & import('../../supply-path/products').ProductSupplyPathAnnotation & {
     product_id: string;
     format_ids?: never;
     format_options: NonEmptyCanonicalFormatDeclarations;

package/dist/lib/validation/schema-loader.js

@@ -449,11 +449,13 @@ function ensureInit(version) {
 }
 function ensureCoreLoaded(s) {
   if (s.coreLoaded) return;
-  const responseToolFiles = /* @__PURE__ */ new Map();
+  const responseToolFiles = /* @__PURE__ */ new Set();
+  const responseToolIds = /* @__PURE__ */ new Set();
   for (const [key, file] of s.fileIndex) {
     if (key.endsWith("::request")) continue;
-    const direction = key.slice(key.indexOf("::") + 2);
-    responseToolFiles.set(file, direction);
+    responseToolFiles.add(file);
+    const schema = loadJson(file);
+    if (typeof schema.$id === "string") responseToolIds.add(schema.$id);
   }
   const registeredIds = getAjvRegisteredIds(s.ajv);
   for (const entry of (0, import_fs.readdirSync)(s.root, { withFileTypes: true })) {
@@ -461,9 +463,9 @@ function ensureCoreLoaded(s) {
     if (!isRuntimeSchemaDirectory(entry.name)) continue;
     const abs = import_path.default.join(s.root, entry.name);
     for (const file of walkJsonFiles(abs)) {
-      const responseDirection = responseToolFiles.get(file);
       const schema = loadJson(file);
-      const schemaToRegister = responseDirection === void 0 ? schema : relaxResponseRoot(schema);
+      const isResponseTool = responseToolFiles.has(file) || typeof schema.$id === "string" && responseToolIds.has(schema.$id);
+      const schemaToRegister = isResponseTool ? relaxResponseRoot(schema) : schema;
       if (typeof schemaToRegister.$id === "string" && !registeredIds.has(schemaToRegister.$id)) {
         s.ajv.addSchema(schemaToRegister);
         registeredIds.add(schemaToRegister.$id);

package/dist/lib/validation/schema-loader.mjs

@@ -399,11 +399,13 @@ function ensureInit(version) {
 }
 function ensureCoreLoaded(s) {
   if (s.coreLoaded) return;
-  const responseToolFiles = /* @__PURE__ */ new Map();
+  const responseToolFiles = /* @__PURE__ */ new Set();
+  const responseToolIds = /* @__PURE__ */ new Set();
   for (const [key, file] of s.fileIndex) {
     if (key.endsWith("::request")) continue;
-    const direction = key.slice(key.indexOf("::") + 2);
-    responseToolFiles.set(file, direction);
+    responseToolFiles.add(file);
+    const schema = loadJson(file);
+    if (typeof schema.$id === "string") responseToolIds.add(schema.$id);
   }
   const registeredIds = getAjvRegisteredIds(s.ajv);
   for (const entry of readdirSync(s.root, { withFileTypes: true })) {
@@ -411,9 +413,9 @@ function ensureCoreLoaded(s) {
     if (!isRuntimeSchemaDirectory(entry.name)) continue;
     const abs = path.join(s.root, entry.name);
     for (const file of walkJsonFiles(abs)) {
-      const responseDirection = responseToolFiles.get(file);
       const schema = loadJson(file);
-      const schemaToRegister = responseDirection === void 0 ? schema : relaxResponseRoot(schema);
+      const isResponseTool = responseToolFiles.has(file) || typeof schema.$id === "string" && responseToolIds.has(schema.$id);
+      const schemaToRegister = isResponseTool ? relaxResponseRoot(schema) : schema;
       if (typeof schemaToRegister.$id === "string" && !registeredIds.has(schemaToRegister.$id)) {
         s.ajv.addSchema(schemaToRegister);
         registeredIds.add(schemaToRegister.$id);

package/dist/lib/version.d.mts

@@ -1,7 +1,7 @@
 /**
  * AdCP SDK library version
  */
-export declare const LIBRARY_VERSION = "14.0.0-rc.39";
+export declare const LIBRARY_VERSION = "14.0.0-rc.40";
 /**
  * AdCP specification version this library is built for
  */
@@ -33,10 +33,10 @@ export type AdcpVersion = (typeof COMPATIBLE_ADCP_VERSIONS)[number];
  * Full version information
  */
 export declare const VERSION_INFO: {
-    readonly library: "14.0.0-rc.39";
+    readonly library: "14.0.0-rc.40";
     readonly adcp: "3.2.0-rc.3";
     readonly compatibleVersions: readonly ["v2.5", "v2.6", "v3", "3.0.0", "3.0", "3.0.1", "3.0.2", "3.0.3", "3.0.4", "3.0.5", "3.0.6", "3.0.7", "3.0.8", "3.0.9", "3.0.10", "3.0.11", "3.0.12", "3.0.13", "3.0.14", "3.0.15", "3.0.16", "3.0.17", "3.0.18", "3.0.19", "3.0.20", "3.0.21", "3.0.22", "3.0.23", "3.0.24", "3.0.25", "3.1.0", "3.1", "3.1.1", "3.1.2", "3.1.3", "3.1.4", "3.1.5", "3.1.6", "3.1.7", "3.1.8", "3.1.9", "3.1.10", "3.1.11", "3.1.12", "3.1.13", "3.1.14", "3.1.15", "3.1.16", "3.1.17", "3.1.18", "3.2.0-rc.3", "3.2-rc.3"];
-    readonly generatedAt: "2026-09-18T19:37:01.879Z";
+    readonly generatedAt: "2026-09-19T13:27:46.372Z";
 };
 /**
  * Get the AdCP specification version this library is built for

package/dist/lib/version.d.ts

@@ -1,7 +1,7 @@
 /**
  * AdCP SDK library version
  */
-export declare const LIBRARY_VERSION = "14.0.0-rc.39";
+export declare const LIBRARY_VERSION = "14.0.0-rc.40";
 /**
  * AdCP specification version this library is built for
  */
@@ -33,10 +33,10 @@ export type AdcpVersion = (typeof COMPATIBLE_ADCP_VERSIONS)[number];
  * Full version information
  */
 export declare const VERSION_INFO: {
-    readonly library: "14.0.0-rc.39";
+    readonly library: "14.0.0-rc.40";
     readonly adcp: "3.2.0-rc.3";
     readonly compatibleVersions: readonly ["v2.5", "v2.6", "v3", "3.0.0", "3.0", "3.0.1", "3.0.2", "3.0.3", "3.0.4", "3.0.5", "3.0.6", "3.0.7", "3.0.8", "3.0.9", "3.0.10", "3.0.11", "3.0.12", "3.0.13", "3.0.14", "3.0.15", "3.0.16", "3.0.17", "3.0.18", "3.0.19", "3.0.20", "3.0.21", "3.0.22", "3.0.23", "3.0.24", "3.0.25", "3.1.0", "3.1", "3.1.1", "3.1.2", "3.1.3", "3.1.4", "3.1.5", "3.1.6", "3.1.7", "3.1.8", "3.1.9", "3.1.10", "3.1.11", "3.1.12", "3.1.13", "3.1.14", "3.1.15", "3.1.16", "3.1.17", "3.1.18", "3.2.0-rc.3", "3.2-rc.3"];
-    readonly generatedAt: "2026-09-18T19:37:01.879Z";
+    readonly generatedAt: "2026-09-19T13:27:46.372Z";
 };
 /**
  * Get the AdCP specification version this library is built for

package/dist/lib/version.js

@@ -31,7 +31,7 @@ __export(version_exports, {
   toReleasePrecisionVersion: () => toReleasePrecisionVersion
 });
 module.exports = __toCommonJS(version_exports);
-const LIBRARY_VERSION = "14.0.0-rc.39";
+const LIBRARY_VERSION = "14.0.0-rc.40";
 const ADCP_VERSION = "3.2.0-rc.3";
 const ADCP_MAJOR_VERSION = 3;
 const COMPATIBLE_ADCP_VERSIONS = [
@@ -89,10 +89,10 @@ const COMPATIBLE_ADCP_VERSIONS = [
   "3.2-rc.3"
 ];
 const VERSION_INFO = {
-  library: "14.0.0-rc.39",
+  library: "14.0.0-rc.40",
   adcp: "3.2.0-rc.3",
   compatibleVersions: COMPATIBLE_ADCP_VERSIONS,
-  generatedAt: "2026-09-18T19:37:01.879Z"
+  generatedAt: "2026-09-19T13:27:46.372Z"
 };
 function getAdcpVersion() {
   return ADCP_VERSION;

package/dist/lib/version.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = "14.0.0-rc.39";
+const LIBRARY_VERSION = "14.0.0-rc.40";
 const ADCP_VERSION = "3.2.0-rc.3";
 const ADCP_MAJOR_VERSION = 3;
 const COMPATIBLE_ADCP_VERSIONS = [
@@ -56,10 +56,10 @@ const COMPATIBLE_ADCP_VERSIONS = [
   "3.2-rc.3"
 ];
 const VERSION_INFO = {
-  library: "14.0.0-rc.39",
+  library: "14.0.0-rc.40",
   adcp: "3.2.0-rc.3",
   compatibleVersions: COMPATIBLE_ADCP_VERSIONS,
-  generatedAt: "2026-09-18T19:37:01.879Z"
+  generatedAt: "2026-09-19T13:27:46.372Z"
 };
 function getAdcpVersion() {
   return ADCP_VERSION;

package/docs/TYPE-SUMMARY.md

@@ -1,7 +1,7 @@
 # AdCP Type Summary
 
-> Generated at: 2026-09-18
-> @adcp/sdk v14.0.0-rc.39
+> Generated at: 2026-09-19
+> @adcp/sdk v14.0.0-rc.40
 
 Curated reference of the types that matter for using the AdCP client. For full generated types see `src/lib/types/tools.generated.ts` and `src/lib/types/core.generated.ts`.
 

package/docs/guides/SUPPLY-PATH-VERIFICATION.md

@@ -0,0 +1,101 @@
+# Supply-path verification
+
+Use `verifySupplyPath` to check an owner-sold collection on a host publisher. It returns a state and five independently diagnosed legs: owner collection declaration, owner distribution/carriage, owner agent declaration, host authorization, and `INVENTORYPARTNERDOMAIN` evidence.
+
+```typescript
+import { verifySupplyPath } from '@adcp/sdk';
+
+const result = await verifySupplyPath({
+  owner_domain: 'channel-owner.example',
+  host_domain: 'hoststream.example',
+  agent_url: 'https://sales.channel-owner.example',
+  collection_id: 'retro_news',
+}, { source: 'authoritative', timeoutMs: 15_000, retainEvidenceBodies: true });
+
+if (result.state !== 'verified_owner_sold') {
+  // Apply your buying policy. Never treat owner_attested as authorization.
+  console.log(result.legs);
+}
+// Store this evidence with the decision, including exact bytes when enabled.
+console.log(result.sources.evidence);
+```
+
+| State | Meaning |
+| --- | --- |
+| `verified_owner_sold` | The owner's collection and carriage references resolve, and a host grant covers the complete carried property scope for this agent and collection without unevaluated constraints. |
+| `host_delegated` | The host's ads.txt/app-ads.txt names the owner, and the owner declares the agent and collection. This weaker evidence does not bind the host to this agent or collection. Accept only under an explicit buyer policy. |
+| `owner_attested` | The owner asserts carriage. This is discovery information, never host sales authorization. |
+| `unverified` | The evidence cannot establish a path. |
+
+The state is a supply-path decision, not a purchase guarantee, exclusivity claim, proof of delivery, or blanket product authorization. Country, effective-time and placement restrictions require an applicable context; this API fails closed on owner or host entries carrying those restrictions, including unknown authorization fields. Independent unrestricted entries can still establish a path. Collection distribution identifiers identify channels in a catalog; they are not host property IDs and are never silently converted into property IDs.
+
+`collection_id` is optional for a domain-level inquiry. The evaluator considers complete individual collection paths and returns the strongest one as `resolved_collection_id`; it never combines carriage from one collection with authorization for another. For a particular product, always check its explicit collection IDs.
+
+## Registry mode
+
+```typescript
+import { RegistryClient, verifySupplyPath } from '@adcp/sdk';
+
+const request = {
+  owner_domain: 'channel-owner.example',
+  host_domain: 'hoststream.example',
+  agent_url: 'https://sales.channel-owner.example',
+  collection_id: 'retro_news',
+};
+const registry = new RegistryClient();
+const cached = await registry.verifySupplyPath(request);
+// Equivalent:
+await verifySupplyPath(request, { source: 'registry', registry });
+```
+
+This is a typed wrapper over `POST /api/registry/verify/supply-path`. It preserves the registry's verdict, diagnostics, URLs, `cached` flag, timestamp and additional response fields. HTTP failures and malformed/inconsistent response shapes reject the promise. The wrapper requires `semantics_version: "1"`; an older registry must upgrade before it can serve this API. Registry responses describe cached evidence; `checked_at` is the decision time, not proof that the origin files were fetched then. The registry includes `owner_fetched_at`, `host_fetched_at` and resolved URLs so cache provenance can be assessed separately. The wrapper does not promote registry provenance into authoritative evidence.
+
+## Discovery annotations
+
+```typescript
+import { annotateProductsSupplyPaths } from '@adcp/sdk';
+
+// products must be the actual products returned by your seller.
+const annotated = await annotateProductsSupplyPaths(products, sellerAgentUrl, {
+  source: 'authoritative',
+  maxPaths: 64,
+});
+for (const product of annotated) {
+  console.log(product.supply_path_state, product.supply_path_verification);
+}
+```
+
+Alternatively, configure a client with `validation.supplyPathVerification: { source: 'authoritative' }`. Completed `get_products` and `list_products` responses are annotated before completion handlers receive them, including resumed completion paths. Annotation is opt-in because it performs additional network requests.
+
+Products combining `publisher_properties` with a collection selector in a different publisher namespace receive `supply_path_state`, the weakest state across their distinct external paths. Details live in `supply_path_verification.paths`. Authoritative mode uses `scope: 'product_properties'` and resolves every product selector against the host manifest; a verified path must cover all selected properties. Registry mode uses `scope: 'owner_host_collection'` because the endpoint accepts no product property context. Its annotation cannot certify the product's selected properties. Neither mode certifies placements, countries, effective dates, or other product restrictions. The weaker `host_delegated` state never establishes concrete product property coverage.
+Products, ordering and unrelated seller fields are preserved. Computed annotation replaces any seller-authored verification fields. Local-only products have no external-path annotation. Invalid or omitted product `collection_ids` and path-limit overflow produce `unverified` with errors. Network policy refusal, unconfirmed authoritative-location changes, cancellation and registry failures reject the operation instead of returning a seller-authored or stale success. Batches deduplicate both paths and evidence fetches within the operation, run at most four paths concurrently, and default to 64 distinct paths (maximum 256).
+
+## Selector types
+
+`AuthorizationCollectionSelector.collection_ids` is optional: omission grants all collections declared by that exact publisher. Present `[]`, `null`, non-array values and mixed-type ID arrays are invalid, not bulk grants. `ProductCollectionSelector` requires a non-empty explicit ID tuple. `CollectionDistribution` accepts `property_ids`, `identifiers`, or both. Public discovery and registry authorization types preserve these distinctions.
+
+## Network and evidence policy
+
+Authoritative mode starts at each publisher's HTTPS `/.well-known/adagents.json`. It uses the SDK's existing SSRF-safe fetcher: every DNS address is checked, the connection is pinned to a validated address, TLS verification remains enabled, and private/link-local/metadata addresses are refused. It does not contact the agent endpoint. No authorization credentials are sent to publisher evidence URLs.
+
+HTTP redirects are limited to three within the exact HTTPS origin. A publisher-origin `authoritative_location` pointer or `superseded_by` migration may explicitly delegate to another HTTPS origin once; that target cannot redirect again. Properties from a cross-origin document must explicitly name their `publisher_domain`; unscoped shared-network properties cannot authorize another publisher. Credentials, nonstandard ports, mixed pointer/catalog files and chained pointers fail closed. This stricter authoritative API does not use community catalogs, cached fallback documents or MANAGERDOMAIN discovery. Those discovery routes need additional publisher scope proofs before they can serve as enforcement evidence.
+
+Collections in a cross-origin authoritative document must explicitly name their owning `publisher_domain`, just as shared host properties must identify their publisher. A domain pointing at an unrelated public catalog cannot borrow that catalog's collections, including through weaker inventory-partner evidence. Publisher-origin collection declarations may omit the field. Owner agent grants in shared cross-origin documents must also explicitly select that owner through `collections[].publisher_domain`; an absent `collections` constraint cannot authorize every member. Within that owner namespace, omitted `collection_ids` still grants all collections.
+
+Authoritative locations are pinned only after the first successfully fetched, parsed, non-chained manifest with the required authorization envelope. Unavailable or malformed targets do not establish a pin. `SupplyPathAuthorityStore.check` is a non-mutating precheck that rejects a different existing pin before fetching its target. After validation, `observe` must atomically insert an absent pin or compare against the existing pin, rejecting a mismatch even when another request or operator changed it after the precheck. A successful `check` is neither a reservation nor authorization; verification requires a successful `observe`. Configure a durable shared store across restarts or workers, and perform the final comparison and insert in one transaction scoped to the trusted tenant and publisher. After independently confirming a publisher migration, update the durable pin or call `approveChange` on your in-memory instance. For the process default, import `defaultSupplyPathAuthorities` from `@adcp/sdk` and call `defaultSupplyPathAuthorities.approveChange(publisherDomain, confirmedHttpsLocation)`. Never approve changes from an automatic retry. First-successful-use pinning cannot detect an origin already compromised before that observation.
+
+The default deadline is 15 seconds for the whole path (or whole annotation batch), configurable up to 60 seconds. Each decompressed response is capped at 256 KiB, configurable up to 20 MiB, with a 64 MiB aggregate evidence budget per operation. The evaluator rejects arrays above 1,024 entries, strings above 8,192 characters, total input above 32,768 values, or a conservative selector-work estimate above four million operations with `evaluation_limit_exceeded`. Cancellation is supported through `signal`. `trustedFetchFn` is an explicit advanced egress hook: it assumes responsibility for DNS resolution, address policy and DNS rebinding protection; its evidence reports `connection_pinned: false`. It must honor request cancellation and manual redirect handling.
+
+Evidence contains requested/resolved URLs, HTTP status, fetch time, SHA-256 of exact decompressed bytes, byte count, connection-pinning status and structured failure codes. `retainEvidenceBodies` also retains those bytes as JSON-safe `body_base64`, including pointer and HTTP redirect documents. Retain the entire chain alongside an enforcement decision. Bodies are untrusted publisher content; store them as opaque evidence, not instructions or trusted log fields. A live fetch is an observation at `fetched_at`, not a permanent authorization grant; reverify before subsequent decisions when freshness matters.
+
+`inventory_partner_domain.failure: 'not_evaluated'` means the IAB fetch was skipped because host authorization already established the strongest state. A 404 is fetched-and-absent (`not_declared`); transport failures remain `ads_txt_unavailable`, with the cause in evidence. Websites use ads.txt, apps use app-ads.txt, and mixed surfaces require the owner in every applicable file. `unsupported_constraints` identifies unevaluated grant fields in `detail`.
+
+Validated publisher revocations are persisted immediately after parsing, before later fetches or authority-store operations can fail. They are held for seven days per publisher authority, including after the next manifest omits them. The default `InMemorySupplyPathRevocationStore` holds them for the process lifetime. For enforcement across restarts or multiple workers, configure a durable shared `SupplyPathRevocationStore`; its `observe` operation must be atomic and retain first-observation expiry by publisher domain within each authority, retaining the first-observation clock when `revoked_at` changes. Store failures and malformed revocation evidence reject verification. `sources.held_revocations` records the hold used in the decision. Keep observations from different publisher authorities isolated. The process-local store admits at most 1,024 live revocations per authority and 10,000 overall. Both process-local stores limit admission to 128 new authorities per 60-second window; the revocation store counts authorities with a new nonempty hold, and the pointer store counts first pins. Existing holds and pins remain readable during admission refusals. Pointer storage is capped at 10,000 authorities for the process lifetime. Overflow rejects verification without evicting live evidence or silently adopting a replacement pin.
+
+These defaults are shared by callers in the process. A sustained many-domain attack can still exhaust their finite capacity, including domains controlled under a wildcard. Rate-limit verification requests by authenticated caller or tenant before invoking the API; publisher domain alone is not an abuse-control identity. For multi-tenant enforcement, pass tenant-scoped durable `revocationStore` and `authorityStore` instances. Capture the tenant from trusted application context in each instance, then key revocations by `(tenant, authority, publisher_domain)` and pins by `(tenant, publisher_domain)`. Make capacity/admission limits and transactions tenant-scoped, and reject exhausted writes instead of deleting live evidence. Neither store interface derives a tenant from counterparty evidence. Do not recover from capacity errors by silently replacing a store with an empty one.
+
+Authority-store keys use the exact serialized HTTPS URL supplied by the verifier. URLs containing a fragment delimiter, including an empty trailing `#`, are refused. Preserve query and path spelling rather than merging potentially distinct server resources. The request deadline bounds the caller's wait; a durable `observe` transaction may complete after the caller times out. It still represents a successfully validated manifest, so retries must be idempotent and must not undo that pin or any retained denial.
+
+## Contract and conformance
+
+The state/leg contract originates in [adcp#6897](https://github.com/adcontextprotocol/adcp/pull/6897) and its fail-closed companion. Both implementations execute the same [canonical supply-path vectors](https://github.com/adcontextprotocol/adcp/tree/main/static/compliance/source/test-vectors/supply-path), including each verdict, resolved collection, leg failure, parser result, and applicable IAB-file policy. The SDK vendors the JSON byte-for-byte from a reviewed upstream commit; provenance and checksums are recorded in `test/fixtures/supply-path/source.json`. Updating it requires selecting a reviewed upstream commit and rerunning both implementations. The runtime `semantics_version` prevents silent acceptance of registries running the older fail-open evaluator.

package/docs/llms.txt

@@ -1,7 +1,7 @@
 # Ad Context Protocol (AdCP)
 
-> Generated at: 2026-09-18
-> Library: @adcp/sdk v14.0.0-rc.39
+> Generated at: 2026-09-19
+> Library: @adcp/sdk v14.0.0-rc.40
 > AdCP major version: 3
 > Canonical URL: https://adcontextprotocol.github.io/adcp-client/llms.txt
 > Note: the `Library` stamp reflects the package.json version at doc-generation time. The narrative below describes the surface that lands on the next-published minor — including any 6.7 helpers documented here ahead of the release tag.