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

package/dist/lib/acceptance-policy/evaluator.mjs

@@ -0,0 +1,423 @@
+import { getSchemaValidatorByRef } from "../validation/schema-loader.mjs";
+import { ADCP_VERSION } from "../version.mjs";
+const CONTEXT_SCHEMA_REF = "media-buy/acceptance-context.json";
+const PROFILE_SCHEMA_REF = "media-buy/acceptance-policy-profile.json";
+const MAX_ASSESSMENT_PROFILES = 1024;
+const MAX_ASSESSMENT_RULES = 1e4;
+const MAX_ASSESSMENT_CONTEXT_VALUES = 4096;
+const MAX_ASSESSMENT_JSON_NODES = 1e5;
+const MAX_ASSESSMENT_STRING_CODE_UNITS = 1024 * 1024;
+const MAX_ASSESSMENT_JSON_DEPTH = 64;
+const MAX_ASSESSMENT_DIAGNOSTICS = 32;
+const SURFACES = /* @__PURE__ */ new Set([
+  "account",
+  "media_buy",
+  "creative",
+  "landing_page",
+  "targeting",
+  "delivery",
+  "format"
+]);
+const REVIEW_REQUIREMENTS = /* @__PURE__ */ new Set([
+  "prior_authorization",
+  "sales_assisted",
+  "funding_restriction",
+  "targeting_restriction",
+  "creative_restriction",
+  "destination_restriction",
+  "format_restriction",
+  "time_restriction",
+  "custom"
+]);
+const SETUP_REQUIREMENTS = /* @__PURE__ */ new Set([
+  "advertiser_verification",
+  "advertiser_eligibility",
+  "certification",
+  "license",
+  "account_setup"
+]);
+const DISCLOSURE_REQUIREMENTS = /* @__PURE__ */ new Set(["category_declaration", "disclosure", "transparency_reporting"]);
+function diagnostic(code, profileId, ruleId) {
+  return {
+    code,
+    ...profileId !== void 0 && { profileId },
+    ...ruleId !== void 0 && { ruleId }
+  };
+}
+function dedupeDiagnostics(diagnostics) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of diagnostics) {
+    const key = `${value.code}\0${value.profileId ?? ""}\0${value.ruleId ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(value);
+    if (result.length >= MAX_ASSESSMENT_DIAGNOSTICS) break;
+  }
+  return result;
+}
+function unknownAssessment(profileIds, diagnostics) {
+  return {
+    advisory: true,
+    outcome: "unknown",
+    profileIds,
+    matchingRuleIds: [],
+    matchedRules: [],
+    requirements: [],
+    diagnostics: dedupeDiagnostics(diagnostics)
+  };
+}
+function expandedJurisdictions(profile, groups) {
+  const jurisdictions = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    if (!Object.prototype.hasOwnProperty.call(profile.region_aliases ?? {}, group)) continue;
+    for (const jurisdiction of profile.region_aliases?.[group] ?? []) jurisdictions.add(jurisdiction);
+  }
+  return jurisdictions;
+}
+function profileAliasesResolve(profile) {
+  const aliases = profile.region_aliases ?? {};
+  const groups = [
+    ...profile.scope?.jurisdiction_groups ?? [],
+    ...profile.rules.flatMap((rule) => rule.jurisdiction_groups ?? [])
+  ];
+  return groups.every((group) => Object.prototype.hasOwnProperty.call(aliases, group));
+}
+function completeScopeCovers(profile, context, appliesTo) {
+  const scope = profile.scope;
+  if (!scope?.applies_to?.includes(appliesTo)) return false;
+  if (!context.subjects?.length || !scope.subject_categories?.length) return false;
+  const scopedCategories = new Set(scope.subject_categories);
+  if (context.subjects.some((subject) => !scopedCategories.has(subject.subject_category))) return false;
+  if (scope.all_jurisdictions === true) return true;
+  if (!context.delivery_jurisdictions?.length) return false;
+  const covered = new Set(scope.jurisdictions ?? []);
+  for (const jurisdiction of expandedJurisdictions(profile, scope.jurisdiction_groups ?? [])) {
+    covered.add(jurisdiction);
+  }
+  return context.delivery_jurisdictions.every((jurisdiction) => covered.has(jurisdiction));
+}
+function ruleMatches(profile, rule, contextIndex, appliesTo, evaluatedAtMs) {
+  if (!rule.applies_to.includes(appliesTo)) return false;
+  let uncertain = false;
+  if (rule.effective_at !== void 0) {
+    const effectiveAtMs = Date.parse(rule.effective_at);
+    if (!Number.isFinite(effectiveAtMs)) uncertain = true;
+    else if (evaluatedAtMs < effectiveAtMs) return false;
+  }
+  if (rule.expires_at !== void 0) {
+    const expiresAtMs = Date.parse(rule.expires_at);
+    if (!Number.isFinite(expiresAtMs)) uncertain = true;
+    else if (evaluatedAtMs >= expiresAtMs) return false;
+  }
+  const subjects = contextIndex.subjectsByCategory.get(rule.subject_category);
+  if (!contextIndex.hasSubjects) {
+    uncertain = true;
+  } else if (!subjects) {
+    return false;
+  }
+  if (subjects && rule.subject_facets?.length) {
+    if (!rule.subject_facets.some((facet) => subjects.facets.has(facet))) {
+      if (!subjects.hasMissingFacets) return false;
+      uncertain = true;
+    }
+  }
+  if (rule.advertiser_roles?.length) {
+    if (contextIndex.advertiserRoles.size === 0) {
+      uncertain = true;
+    } else if (!rule.advertiser_roles.some((role) => contextIndex.advertiserRoles.has(role))) {
+      return false;
+    }
+  }
+  if (rule.jurisdictions?.length || rule.jurisdiction_groups?.length) {
+    if (rule.jurisdiction_groups?.some(
+      (group) => !Object.prototype.hasOwnProperty.call(profile.region_aliases ?? {}, group)
+    )) {
+      return "unknown";
+    }
+    if (contextIndex.deliveryJurisdictions.size === 0) {
+      uncertain = true;
+    } else {
+      const expected = new Set(rule.jurisdictions ?? []);
+      for (const jurisdiction of expandedJurisdictions(profile, rule.jurisdiction_groups ?? [])) {
+        expected.add(jurisdiction);
+      }
+      if (![...expected].some((jurisdiction) => contextIndex.deliveryJurisdictions.has(jurisdiction))) return false;
+    }
+  }
+  return uncertain ? "unknown" : true;
+}
+function requirementsOutcome(requirements) {
+  const kinds = new Set(requirements.map((requirement) => String(requirement.kind)));
+  if ([...kinds].some((kind) => REVIEW_REQUIREMENTS.has(kind))) return "requires_review";
+  if ([...kinds].some((kind) => SETUP_REQUIREMENTS.has(kind))) return "requires_setup";
+  if ([...kinds].every((kind) => DISCLOSURE_REQUIREMENTS.has(kind))) return "requires_disclosure";
+  return "requires_review";
+}
+function cloneRequirement(requirement) {
+  return JSON.parse(JSON.stringify(requirement));
+}
+function consumeAssessmentComplexity(value, budget) {
+  const pending = [{ value, depth: 0 }];
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  let queuedNodes = 1;
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current.exit) {
+      ancestors.delete(current.value);
+      continue;
+    }
+    queuedNodes -= 1;
+    budget.nodes += 1;
+    if (budget.nodes > MAX_ASSESSMENT_JSON_NODES) return "limit";
+    if (current.depth > MAX_ASSESSMENT_JSON_DEPTH) return "invalid";
+    if (typeof current.value === "string") {
+      budget.stringCodeUnits += current.value.length;
+      if (budget.stringCodeUnits > MAX_ASSESSMENT_STRING_CODE_UNITS) return "limit";
+      continue;
+    }
+    if (current.value === null || typeof current.value !== "object") continue;
+    if (ancestors.has(current.value)) return "invalid";
+    ancestors.add(current.value);
+    pending.push({ ...current, exit: true });
+    if (Array.isArray(current.value)) {
+      if (budget.nodes + queuedNodes + current.value.length > MAX_ASSESSMENT_JSON_NODES) return "limit";
+      queuedNodes += current.value.length;
+      for (const child of current.value) pending.push({ value: child, depth: current.depth + 1 });
+      continue;
+    }
+    const record = current.value;
+    for (const key in record) {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) continue;
+      budget.stringCodeUnits += key.length;
+      if (budget.stringCodeUnits > MAX_ASSESSMENT_STRING_CODE_UNITS) return "limit";
+      if (budget.nodes + queuedNodes + 1 > MAX_ASSESSMENT_JSON_NODES) return "limit";
+      queuedNodes += 1;
+      pending.push({ value: record[key], depth: current.depth + 1 });
+    }
+  }
+  return "valid";
+}
+function exceedsContextValueLimit(context) {
+  const subjects = Array.isArray(context.subjects) ? context.subjects : [];
+  const advertiserRoles = Array.isArray(context.advertiser_roles) ? context.advertiser_roles : [];
+  const deliveryJurisdictions = Array.isArray(context.delivery_jurisdictions) ? context.delivery_jurisdictions : [];
+  if (subjects.length > MAX_ASSESSMENT_CONTEXT_VALUES || advertiserRoles.length > MAX_ASSESSMENT_CONTEXT_VALUES || deliveryJurisdictions.length > MAX_ASSESSMENT_CONTEXT_VALUES) {
+    return true;
+  }
+  let values = subjects.length + advertiserRoles.length + deliveryJurisdictions.length;
+  for (const subject of subjects) {
+    if (!subject || typeof subject !== "object" || !Array.isArray(subject.subject_facets)) continue;
+    values += subject.subject_facets.length;
+    if (values > MAX_ASSESSMENT_CONTEXT_VALUES) return true;
+  }
+  return values > MAX_ASSESSMENT_CONTEXT_VALUES;
+}
+function assessAcceptancePolicy(input) {
+  if (!input || typeof input !== "object" || !Array.isArray(input.profiles)) {
+    return unknownAssessment([], [diagnostic("invalid_profile")]);
+  }
+  if (input.profiles.length > MAX_ASSESSMENT_PROFILES) {
+    return unknownAssessment([], [diagnostic("assessment_limit_exceeded")]);
+  }
+  const profileIds = [
+    ...new Set(
+      input.profiles.flatMap(
+        (value) => value && typeof value === "object" && value.resolution === "resolved" && typeof value.profileId === "string" ? [value.profileId] : []
+      )
+    )
+  ];
+  if (input.profiles.length === 0) {
+    return unknownAssessment(profileIds, [diagnostic("profile_unresolved")]);
+  }
+  if (!input.acceptanceContext || typeof input.acceptanceContext !== "object") {
+    return unknownAssessment(profileIds, [diagnostic("invalid_context")]);
+  }
+  if (!SURFACES.has(input.appliesTo)) {
+    return unknownAssessment(profileIds, [diagnostic("incomplete_context")]);
+  }
+  if (exceedsContextValueLimit(input.acceptanceContext)) {
+    return unknownAssessment(profileIds, [diagnostic("assessment_limit_exceeded")]);
+  }
+  const contextComplexity = consumeAssessmentComplexity(input.acceptanceContext, {
+    nodes: 0,
+    stringCodeUnits: 0
+  });
+  if (contextComplexity === "limit") {
+    return unknownAssessment(profileIds, [diagnostic("assessment_limit_exceeded")]);
+  }
+  if (contextComplexity === "invalid") {
+    return unknownAssessment(profileIds, [diagnostic("invalid_context")]);
+  }
+  let contextValidator;
+  let profileValidator;
+  try {
+    const adcpVersion = input.adcpVersion ?? ADCP_VERSION;
+    contextValidator = getSchemaValidatorByRef(CONTEXT_SCHEMA_REF, adcpVersion);
+    profileValidator = getSchemaValidatorByRef(PROFILE_SCHEMA_REF, adcpVersion);
+  } catch {
+    return unknownAssessment(profileIds, [diagnostic("schema_unavailable")]);
+  }
+  if (!contextValidator || !profileValidator) {
+    return unknownAssessment(profileIds, [diagnostic("schema_unavailable")]);
+  }
+  if (!contextValidator(input.acceptanceContext)) {
+    return unknownAssessment(profileIds, [diagnostic("invalid_context")]);
+  }
+  const mutableSubjectsByCategory = /* @__PURE__ */ new Map();
+  for (const subject of input.acceptanceContext.subjects ?? []) {
+    const indexed = mutableSubjectsByCategory.get(subject.subject_category) ?? {
+      facets: /* @__PURE__ */ new Set(),
+      hasMissingFacets: false
+    };
+    if (!subject.subject_facets?.length) indexed.hasMissingFacets = true;
+    else for (const facet of subject.subject_facets) indexed.facets.add(facet);
+    mutableSubjectsByCategory.set(subject.subject_category, indexed);
+  }
+  const contextIndex = {
+    hasSubjects: (input.acceptanceContext.subjects?.length ?? 0) > 0,
+    subjectsByCategory: mutableSubjectsByCategory,
+    advertiserRoles: new Set(input.acceptanceContext.advertiser_roles ?? []),
+    deliveryJurisdictions: new Set(input.acceptanceContext.delivery_jurisdictions ?? [])
+  };
+  const evaluatedAt = input.evaluatedAt ?? /* @__PURE__ */ new Date();
+  const evaluatedAtMs = evaluatedAt instanceof Date ? evaluatedAt.getTime() : Date.parse(evaluatedAt);
+  if (!Number.isFinite(evaluatedAtMs)) {
+    return unknownAssessment(profileIds, [diagnostic("invalid_evaluation_time")]);
+  }
+  const diagnostics = [];
+  const matchingRules = [];
+  let uncertain = false;
+  const profiles = [];
+  const profileIdentities = /* @__PURE__ */ new Map();
+  const seenProfileIdentities = /* @__PURE__ */ new Set();
+  const countedProfileIdentities = /* @__PURE__ */ new Set();
+  const measuredProfileObjects = /* @__PURE__ */ new WeakSet();
+  const invalidProfileObjects = /* @__PURE__ */ new WeakSet();
+  const profileValidationResults = /* @__PURE__ */ new WeakMap();
+  const profileAliasResults = /* @__PURE__ */ new WeakMap();
+  const complexityBudget = { nodes: 0, stringCodeUnits: 0 };
+  let candidateRuleCount = 0;
+  for (const value of input.profiles) {
+    if (!value || typeof value !== "object" || typeof value.profileId !== "string") {
+      uncertain = true;
+      diagnostics.push(diagnostic("invalid_profile"));
+      continue;
+    }
+    if (value.resolution !== "resolved") {
+      uncertain = true;
+      diagnostics.push(
+        value.resolution === "missing" || value.resolution === "unresolved" ? diagnostic("profile_unresolved", value.profileId) : diagnostic("invalid_profile", value.profileId)
+      );
+      continue;
+    }
+    const profileValue = value.profile;
+    if (profileValue && typeof profileValue === "object" && invalidProfileObjects.has(profileValue)) {
+      uncertain = true;
+      diagnostics.push(diagnostic("invalid_profile", value.profileId));
+      continue;
+    }
+    if (profileValue && typeof profileValue === "object" && !measuredProfileObjects.has(profileValue)) {
+      measuredProfileObjects.add(profileValue);
+      const complexity = consumeAssessmentComplexity(profileValue, complexityBudget);
+      if (complexity === "limit") {
+        return unknownAssessment(profileIds, [...diagnostics, diagnostic("assessment_limit_exceeded")]);
+      }
+      if (complexity === "invalid") {
+        invalidProfileObjects.add(profileValue);
+        uncertain = true;
+        diagnostics.push(diagnostic("invalid_profile", value.profileId));
+        continue;
+      }
+    }
+    const candidateIdentityKey = typeof value.profile?.version === "string" && typeof value.profile?.content_digest === "string" ? `${value.profileId}\0${value.profile.version}\0${value.profile.content_digest}` : void 0;
+    if ((candidateIdentityKey === void 0 || !countedProfileIdentities.has(candidateIdentityKey)) && Array.isArray(value.profile?.rules)) {
+      if (candidateIdentityKey !== void 0) countedProfileIdentities.add(candidateIdentityKey);
+      candidateRuleCount += value.profile.rules.length;
+      if (candidateRuleCount > MAX_ASSESSMENT_RULES) {
+        return unknownAssessment(profileIds, [...diagnostics, diagnostic("assessment_limit_exceeded")]);
+      }
+    }
+    let validProfile = false;
+    if (profileValue && typeof profileValue === "object" && profileValidationResults.has(profileValue)) {
+      validProfile = profileValidationResults.get(profileValue) ?? false;
+    } else {
+      try {
+        validProfile = profileValidator(value.profile);
+      } catch {
+        validProfile = false;
+      }
+      if (profileValue && typeof profileValue === "object") {
+        profileValidationResults.set(profileValue, validProfile);
+      }
+    }
+    if (!validProfile || value.profile.profile_id !== value.profileId) {
+      uncertain = true;
+      diagnostics.push(diagnostic("invalid_profile", value.profileId));
+      continue;
+    }
+    let aliasesValid = profileAliasResults.get(profileValue);
+    if (aliasesValid === void 0) {
+      aliasesValid = profileAliasesResolve(value.profile);
+      profileAliasResults.set(profileValue, aliasesValid);
+    }
+    if (!aliasesValid) {
+      uncertain = true;
+      diagnostics.push(diagnostic("invalid_profile", value.profileId));
+      continue;
+    }
+    const identityKey = `${value.profileId}\0${value.profile.version}\0${value.profile.content_digest}`;
+    if (seenProfileIdentities.has(identityKey)) continue;
+    seenProfileIdentities.add(identityKey);
+    const knownIdentity = profileIdentities.get(value.profileId);
+    if (knownIdentity && (knownIdentity.version !== value.profile.version || knownIdentity.contentDigest !== value.profile.content_digest)) {
+      uncertain = true;
+      diagnostics.push(diagnostic("profile_conflict", value.profileId));
+      profiles.push(value.profile);
+      continue;
+    }
+    if (knownIdentity) continue;
+    profileIdentities.set(value.profileId, {
+      version: value.profile.version,
+      contentDigest: value.profile.content_digest
+    });
+    profiles.push(value.profile);
+  }
+  for (const profile of profiles) {
+    if (profile.coverage === "partial") {
+      uncertain = true;
+      diagnostics.push(diagnostic("partial_coverage", profile.profile_id));
+    } else if (!completeScopeCovers(profile, input.acceptanceContext, input.appliesTo)) {
+      uncertain = true;
+      diagnostics.push(diagnostic("incomplete_context", profile.profile_id));
+    }
+    for (const rule of profile.rules) {
+      const match = ruleMatches(profile, rule, contextIndex, input.appliesTo, evaluatedAtMs);
+      if (match === true) matchingRules.push({ profileId: profile.profile_id, rule });
+      if (match === "unknown") {
+        uncertain = true;
+        diagnostics.push(diagnostic("incomplete_context", profile.profile_id, rule.rule_id));
+      }
+    }
+  }
+  const requirements = matchingRules.flatMap((value) => value.rule.requirements ?? []);
+  const outcome = matchingRules.some((value) => value.rule.disposition === "prohibited") ? "prohibited" : uncertain ? "unknown" : requirements.length > 0 ? requirementsOutcome(requirements) : "allowed";
+  return {
+    advisory: true,
+    outcome,
+    profileIds: [...profileIdentities.keys()],
+    matchingRuleIds: matchingRules.map((value) => value.rule.rule_id),
+    matchedRules: matchingRules.map(({ profileId, rule }) => ({
+      profileId,
+      ruleId: rule.rule_id,
+      disposition: rule.disposition,
+      policyIds: [...rule.policy_ids ?? []],
+      requirements: (rule.requirements ?? []).map(cloneRequirement)
+    })),
+    requirements: requirements.map(cloneRequirement),
+    diagnostics: dedupeDiagnostics(diagnostics)
+  };
+}
+export {
+  assessAcceptancePolicy
+};

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

@@ -5,6 +5,7 @@
  * likely seller treatment; it never authorizes an exact media-buy request.
  */
 import type { ResolvePolicyResponse } from '../registry/types.mjs';
+export { assessAcceptancePolicy } from './evaluator.mjs';
 export interface AcceptancePolicyDiscoveryCapability {
     catalog_url: string;
     catalog_digest: string;
@@ -15,13 +16,24 @@ export interface AcceptancePolicyReference {
     version: string;
     content_digest: string;
 }
+export interface AcceptancePolicyRequirement {
+    kind: 'category_declaration' | 'advertiser_verification' | 'advertiser_eligibility' | 'funding_restriction' | 'certification' | 'license' | 'prior_authorization' | 'account_setup' | 'sales_assisted' | 'disclosure' | 'targeting_restriction' | 'creative_restriction' | 'destination_restriction' | 'format_restriction' | 'time_restriction' | 'transparency_reporting' | 'custom';
+    [key: string]: unknown;
+}
+export type AcceptancePolicySurface = 'account' | 'media_buy' | 'creative' | 'landing_page' | 'targeting' | 'delivery' | 'format';
 export interface AcceptancePolicyRule {
     rule_id: string;
     subject_category: string;
+    subject_facets?: string[];
+    advertiser_roles?: string[];
+    jurisdictions?: string[];
     jurisdiction_groups?: string[];
     applies_to: string[];
     disposition: 'allowed' | 'conditional' | 'prohibited';
+    requirements?: AcceptancePolicyRequirement[];
     policy_ids?: string[];
+    effective_at?: string;
+    expires_at?: string;
     [key: string]: unknown;
 }
 export interface AcceptancePolicyProfile {
@@ -31,7 +43,11 @@ export interface AcceptancePolicyProfile {
     policy_refs: AcceptancePolicyReference[];
     coverage: 'partial' | 'complete';
     scope?: {
+        subject_categories?: string[];
+        applies_to?: string[];
+        jurisdictions?: string[];
         jurisdiction_groups?: string[];
+        all_jurisdictions?: true;
         [key: string]: unknown;
     };
     region_aliases?: Record<string, string[]>;
@@ -118,6 +134,8 @@ export interface ResolveVerifiedAcceptancePolicyProfilesOptions {
     timeoutMs?: number;
     /** Maximum distinct registry profiles resolved in one call. Default and maximum 32. */
     maxRegistryProfiles?: number;
+    /** Caller-owned cancellation signal, composed with the registry deadline. */
+    signal?: AbortSignal;
 }
 export interface VerifiedAcceptancePolicyProfilesSuccess {
     ok: true;
@@ -131,6 +149,8 @@ export interface ResolveAcceptancePolicyCatalogOptions {
     adcpVersion?: string;
     /** Overall DNS/connect/body timeout for the catalog fetch. Default 5 seconds. */
     timeoutMs?: number;
+    /** Caller-owned cancellation signal, composed with fetch and registry deadlines. */
+    signal?: AbortSignal;
     /** 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. */

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

@@ -5,6 +5,7 @@
  * likely seller treatment; it never authorizes an exact media-buy request.
  */
 import type { ResolvePolicyResponse } from '../registry/types';
+export { assessAcceptancePolicy } from './evaluator';
 export interface AcceptancePolicyDiscoveryCapability {
     catalog_url: string;
     catalog_digest: string;
@@ -15,13 +16,24 @@ export interface AcceptancePolicyReference {
     version: string;
     content_digest: string;
 }
+export interface AcceptancePolicyRequirement {
+    kind: 'category_declaration' | 'advertiser_verification' | 'advertiser_eligibility' | 'funding_restriction' | 'certification' | 'license' | 'prior_authorization' | 'account_setup' | 'sales_assisted' | 'disclosure' | 'targeting_restriction' | 'creative_restriction' | 'destination_restriction' | 'format_restriction' | 'time_restriction' | 'transparency_reporting' | 'custom';
+    [key: string]: unknown;
+}
+export type AcceptancePolicySurface = 'account' | 'media_buy' | 'creative' | 'landing_page' | 'targeting' | 'delivery' | 'format';
 export interface AcceptancePolicyRule {
     rule_id: string;
     subject_category: string;
+    subject_facets?: string[];
+    advertiser_roles?: string[];
+    jurisdictions?: string[];
     jurisdiction_groups?: string[];
     applies_to: string[];
     disposition: 'allowed' | 'conditional' | 'prohibited';
+    requirements?: AcceptancePolicyRequirement[];
     policy_ids?: string[];
+    effective_at?: string;
+    expires_at?: string;
     [key: string]: unknown;
 }
 export interface AcceptancePolicyProfile {
@@ -31,7 +43,11 @@ export interface AcceptancePolicyProfile {
     policy_refs: AcceptancePolicyReference[];
     coverage: 'partial' | 'complete';
     scope?: {
+        subject_categories?: string[];
+        applies_to?: string[];
+        jurisdictions?: string[];
         jurisdiction_groups?: string[];
+        all_jurisdictions?: true;
         [key: string]: unknown;
     };
     region_aliases?: Record<string, string[]>;
@@ -118,6 +134,8 @@ export interface ResolveVerifiedAcceptancePolicyProfilesOptions {
     timeoutMs?: number;
     /** Maximum distinct registry profiles resolved in one call. Default and maximum 32. */
     maxRegistryProfiles?: number;
+    /** Caller-owned cancellation signal, composed with the registry deadline. */
+    signal?: AbortSignal;
 }
 export interface VerifiedAcceptancePolicyProfilesSuccess {
     ok: true;
@@ -131,6 +149,8 @@ export interface ResolveAcceptancePolicyCatalogOptions {
     adcpVersion?: string;
     /** Overall DNS/connect/body timeout for the catalog fetch. Default 5 seconds. */
     timeoutMs?: number;
+    /** Caller-owned cancellation signal, composed with fetch and registry deadlines. */
+    signal?: AbortSignal;
     /** 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. */