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

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

@@ -0,0 +1,46 @@
+/** Conservative, advisory evaluation of already-verified acceptance profiles. */
+import type { AcceptanceContext } from '../types/core.generated.mjs';
+import type { AcceptancePolicyProfileResolution, AcceptancePolicyRequirement, AcceptancePolicyRule, AcceptancePolicySurface } from './index.mjs';
+export type AcceptancePolicyOutcome = 'allowed' | 'prohibited' | 'requires_disclosure' | 'requires_setup' | 'requires_review' | 'unknown';
+export type AcceptancePolicyAssessmentDiagnosticCode = 'profile_unresolved' | 'profile_conflict' | 'invalid_profile' | 'assessment_limit_exceeded' | 'partial_coverage' | 'incomplete_context' | 'invalid_context' | 'invalid_evaluation_time' | 'schema_unavailable';
+export interface AcceptancePolicyAssessmentDiagnostic {
+    code: AcceptancePolicyAssessmentDiagnosticCode;
+    profileId?: string;
+    ruleId?: string;
+}
+export interface AssessAcceptancePolicyInput {
+    /** Seller-default and product profiles to compose. Unresolved entries fail closed. */
+    profiles: readonly AcceptancePolicyProfileResolution[];
+    acceptanceContext: AcceptanceContext;
+    appliesTo: AcceptancePolicySurface;
+    /** Evaluation instant for rule windows. Defaults to the current time. */
+    evaluatedAt?: Date | string;
+    /** Schema bundle used to validate acceptanceContext and each resolved profile. Defaults to the SDK pin. */
+    adcpVersion?: string;
+}
+export interface AcceptancePolicyAssessment {
+    /** Advisory only. The seller's response to an exact request remains authoritative. */
+    advisory: true;
+    outcome: AcceptancePolicyOutcome;
+    profileIds: string[];
+    matchingRuleIds: string[];
+    matchedRules: AcceptancePolicyMatchedRule[];
+    requirements: AcceptancePolicyRequirement[];
+    diagnostics: AcceptancePolicyAssessmentDiagnostic[];
+}
+export interface AcceptancePolicyMatchedRule {
+    profileId: string;
+    ruleId: string;
+    disposition: AcceptancePolicyRule['disposition'];
+    policyIds: string[];
+    requirements: AcceptancePolicyRequirement[];
+}
+/**
+ * Compose verified seller-default and product acceptance profiles
+ * restrictively for one decision surface.
+ *
+ * The result is preflight guidance, not authorization. Missing profiles,
+ * partial coverage, out-of-scope complete profiles, and omitted buyer facts
+ * remain `unknown`; an explicit matching prohibition still wins.
+ */
+export declare function assessAcceptancePolicy(input: AssessAcceptancePolicyInput): AcceptancePolicyAssessment;

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

@@ -0,0 +1,46 @@
+/** Conservative, advisory evaluation of already-verified acceptance profiles. */
+import type { AcceptanceContext } from '../types/core.generated';
+import type { AcceptancePolicyProfileResolution, AcceptancePolicyRequirement, AcceptancePolicyRule, AcceptancePolicySurface } from './index';
+export type AcceptancePolicyOutcome = 'allowed' | 'prohibited' | 'requires_disclosure' | 'requires_setup' | 'requires_review' | 'unknown';
+export type AcceptancePolicyAssessmentDiagnosticCode = 'profile_unresolved' | 'profile_conflict' | 'invalid_profile' | 'assessment_limit_exceeded' | 'partial_coverage' | 'incomplete_context' | 'invalid_context' | 'invalid_evaluation_time' | 'schema_unavailable';
+export interface AcceptancePolicyAssessmentDiagnostic {
+    code: AcceptancePolicyAssessmentDiagnosticCode;
+    profileId?: string;
+    ruleId?: string;
+}
+export interface AssessAcceptancePolicyInput {
+    /** Seller-default and product profiles to compose. Unresolved entries fail closed. */
+    profiles: readonly AcceptancePolicyProfileResolution[];
+    acceptanceContext: AcceptanceContext;
+    appliesTo: AcceptancePolicySurface;
+    /** Evaluation instant for rule windows. Defaults to the current time. */
+    evaluatedAt?: Date | string;
+    /** Schema bundle used to validate acceptanceContext and each resolved profile. Defaults to the SDK pin. */
+    adcpVersion?: string;
+}
+export interface AcceptancePolicyAssessment {
+    /** Advisory only. The seller's response to an exact request remains authoritative. */
+    advisory: true;
+    outcome: AcceptancePolicyOutcome;
+    profileIds: string[];
+    matchingRuleIds: string[];
+    matchedRules: AcceptancePolicyMatchedRule[];
+    requirements: AcceptancePolicyRequirement[];
+    diagnostics: AcceptancePolicyAssessmentDiagnostic[];
+}
+export interface AcceptancePolicyMatchedRule {
+    profileId: string;
+    ruleId: string;
+    disposition: AcceptancePolicyRule['disposition'];
+    policyIds: string[];
+    requirements: AcceptancePolicyRequirement[];
+}
+/**
+ * Compose verified seller-default and product acceptance profiles
+ * restrictively for one decision surface.
+ *
+ * The result is preflight guidance, not authorization. Missing profiles,
+ * partial coverage, out-of-scope complete profiles, and omitted buyer facts
+ * remain `unknown`; an explicit matching prohibition still wins.
+ */
+export declare function assessAcceptancePolicy(input: AssessAcceptancePolicyInput): AcceptancePolicyAssessment;

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

@@ -0,0 +1,447 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var evaluator_exports = {};
+__export(evaluator_exports, {
+  assessAcceptancePolicy: () => assessAcceptancePolicy
+});
+module.exports = __toCommonJS(evaluator_exports);
+var import_schema_loader = require('../validation/schema-loader.js');
+var import_version = require('../version.js');
+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 ?? import_version.ADCP_VERSION;
+    contextValidator = (0, import_schema_loader.getSchemaValidatorByRef)(CONTEXT_SCHEMA_REF, adcpVersion);
+    profileValidator = (0, import_schema_loader.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)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assessAcceptancePolicy
+});