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

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

@@ -0,0 +1,1107 @@
+"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 acceptance_policy_exports = {};
+__export(acceptance_policy_exports, {
+  createAcceptancePolicyCatalogResolver: () => createAcceptancePolicyCatalogResolver,
+  resolveAcceptancePolicyCatalog: () => resolveAcceptancePolicyCatalog,
+  resolveAcceptancePolicyProfiles: () => resolveAcceptancePolicyProfiles,
+  resolveVerifiedAcceptancePolicyProfiles: () => resolveVerifiedAcceptancePolicyProfiles
+});
+module.exports = __toCommonJS(acceptance_policy_exports);
+var import_jcs = require('../utils/jcs.js');
+var import_canonical_references = require('../canonical-references/index.js');
+var import_schema_loader = require('../validation/schema-loader.js');
+var import_version = require('../version.js');
+var import_well_formed_unicode = require('../utils/well-formed-unicode.js');
+const CATALOG_SCHEMA_REF = "media-buy/acceptance-policy-catalog.json";
+const PROFILE_SCHEMA_REF = "media-buy/acceptance-policy-profile.json";
+const DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+const DEFAULT_TIMEOUT_MS = 5e3;
+const DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+const MAX_TIMEOUT_MS = 3e4;
+const MAX_BODY_BYTES = 1024 * 1024;
+const MAX_CANONICAL_JSON_DEPTH = 128;
+const MAX_CATALOG_JSON_DEPTH = 256;
+const MAX_CATALOG_JSON_NODES = 1e5;
+const MAX_CATALOG_JSON_STRING_CODE_UNITS = 1024 * 1024;
+const DEFAULT_MAX_REGISTRY_PROFILES = 32;
+const MAX_REGISTRY_PROFILES = 32;
+const MAX_REGISTRY_CONCURRENCY = 4;
+const MAX_SELECTED_PROFILE_IDS = 1024;
+const MAX_REGISTRY_JSON_NODES = 5e4;
+const MAX_REGISTRY_JSON_STRING_CODE_UNITS = 256 * 1024;
+function issue(code, message, pointer, options = {}) {
+  return {
+    code,
+    message,
+    pointer,
+    ...options.keyword !== void 0 && { keyword: options.keyword },
+    ...options.retryable !== void 0 && { retryable: options.retryable },
+    ...options.httpStatus !== void 0 && { httpStatus: options.httpStatus }
+  };
+}
+function fail(error, issues) {
+  return { ok: false, fromCache: false, error, ...issues !== void 0 && { issues } };
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function cloneCatalog(catalog) {
+  return cloneJson(catalog);
+}
+function cloneSuccess(result, fromCache) {
+  const catalog = cloneCatalog(result.catalog);
+  const sellerProfiles = new Map((catalog.profiles ?? []).map((profile) => [profile.profile_id, profile]));
+  const registryRefs = new Map((catalog.registry_profiles ?? []).map((ref) => [ref.profile_id, ref]));
+  const registryProfiles = /* @__PURE__ */ new Map();
+  return {
+    ok: true,
+    fromCache,
+    catalog,
+    ...result.issues !== void 0 && {
+      // cloneSuccess is used only by the capability-lifetime resolver. Its
+      // cached success cannot retry registry work until invalidate().
+      issues: cloneJson(
+        result.issues.map((value) => value.retryable === true ? { ...value, retryable: false } : value)
+      )
+    },
+    defaultProfiles: result.defaultProfiles.map((value) => {
+      if (value.source === "seller") {
+        return { ...value, profile: sellerProfiles.get(value.profileId) ?? cloneJson(value.profile) };
+      }
+      const ref = registryRefs.get(value.profileId) ?? cloneJson(value.ref);
+      if (value.resolution === "resolved") {
+        let profile = registryProfiles.get(value.profileId);
+        if (!profile) {
+          profile = cloneJson(value.profile);
+          registryProfiles.set(value.profileId, profile);
+        }
+        return { ...value, ref, profile };
+      }
+      return { ...value, ref };
+    })
+  };
+}
+function snapshotCapability(capability) {
+  const snapshot = { ...capability };
+  if (Array.isArray(snapshot.default_profile_ids)) {
+    snapshot.default_profile_ids = [...snapshot.default_profile_ids];
+  }
+  return snapshot;
+}
+function validateCapability(capability, options) {
+  if (!capability || typeof capability.catalog_url !== "string" || typeof capability.catalog_digest !== "string") {
+    return issue(
+      "invalid_capability",
+      "Acceptance-policy discovery must provide catalog_url and catalog_digest strings",
+      "/media_buy/acceptance_policy_discovery"
+    );
+  }
+  if (!DIGEST_RE.test(capability.catalog_digest)) {
+    return issue(
+      "invalid_capability",
+      "catalog_digest must be sha256 followed by 64 lowercase hexadecimal characters",
+      "/media_buy/acceptance_policy_discovery/catalog_digest"
+    );
+  }
+  let parsed;
+  try {
+    parsed = new URL(capability.catalog_url);
+  } catch {
+    return issue("unsafe_url", "catalog_url is not a valid URL", "/media_buy/acceptance_policy_discovery/catalog_url");
+  }
+  if (parsed.username !== "" || parsed.password !== "") {
+    return issue(
+      "unsafe_url",
+      "catalog_url must not contain URL credentials",
+      "/media_buy/acceptance_policy_discovery/catalog_url"
+    );
+  }
+  const unsafeHttpAllowed = options.allowUnsafeHttp === true && parsed.protocol === "http:";
+  if (parsed.protocol !== "https:" && !unsafeHttpAllowed) {
+    return issue("unsafe_url", "catalog_url must use HTTPS", "/media_buy/acceptance_policy_discovery/catalog_url");
+  }
+  const defaults = capability.default_profile_ids;
+  if (defaults !== void 0) {
+    if (!Array.isArray(defaults) || defaults.length === 0 || defaults.length > MAX_SELECTED_PROFILE_IDS || defaults.some((value) => typeof value !== "string" || value.length === 0)) {
+      return issue(
+        "invalid_capability",
+        `default_profile_ids must contain 1-${MAX_SELECTED_PROFILE_IDS} non-empty strings`,
+        "/media_buy/acceptance_policy_discovery/default_profile_ids"
+      );
+    }
+    if (new Set(defaults).size !== defaults.length) {
+      return issue(
+        "invalid_capability",
+        "default_profile_ids must be unique",
+        "/media_buy/acceptance_policy_discovery/default_profile_ids"
+      );
+    }
+  }
+  return void 0;
+}
+function validateOptions(options) {
+  if (options.registryResolver !== void 0 && (options.registryResolver === null || typeof options.registryResolver.resolvePolicy !== "function")) {
+    return issue(
+      "invalid_options",
+      "registryResolver must provide a resolvePolicy function",
+      "/options/registryResolver"
+    );
+  }
+  if (options.allowUnsafeHttp === true && options.allowPrivateNetwork !== true) {
+    return issue(
+      "invalid_options",
+      "allowUnsafeHttp requires allowPrivateNetwork and is only intended for local test fixtures",
+      "/options/allowUnsafeHttp"
+    );
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > MAX_TIMEOUT_MS)) {
+    return issue(
+      "invalid_options",
+      `timeoutMs must be a positive safe integer no greater than ${MAX_TIMEOUT_MS}`,
+      "/options/timeoutMs"
+    );
+  }
+  if (options.registryTimeoutMs !== void 0 && (!Number.isSafeInteger(options.registryTimeoutMs) || options.registryTimeoutMs <= 0 || options.registryTimeoutMs > MAX_TIMEOUT_MS)) {
+    return issue(
+      "invalid_options",
+      `registryTimeoutMs must be a positive safe integer no greater than ${MAX_TIMEOUT_MS}`,
+      "/options/registryTimeoutMs"
+    );
+  }
+  if (options.maxRegistryProfiles !== void 0 && (!Number.isSafeInteger(options.maxRegistryProfiles) || options.maxRegistryProfiles <= 0 || options.maxRegistryProfiles > MAX_REGISTRY_PROFILES)) {
+    return issue(
+      "invalid_options",
+      `maxRegistryProfiles must be a positive safe integer no greater than ${MAX_REGISTRY_PROFILES}`,
+      "/options/maxRegistryProfiles"
+    );
+  }
+  if (options.maxBodyBytes !== void 0 && (!Number.isSafeInteger(options.maxBodyBytes) || options.maxBodyBytes <= 0 || options.maxBodyBytes > MAX_BODY_BYTES)) {
+    return issue(
+      "invalid_options",
+      `maxBodyBytes must be a positive safe integer no greater than ${MAX_BODY_BYTES}`,
+      "/options/maxBodyBytes"
+    );
+  }
+  return void 0;
+}
+function translateFetchFailure(result) {
+  const pointer = "/media_buy/acceptance_policy_discovery/catalog_url";
+  const transport = { retryable: result.error.retryable, httpStatus: result.httpStatus };
+  switch (result.error.code) {
+    case "redirect_blocked":
+      return fail(issue("redirect_blocked", "Acceptance-policy catalog redirects are disabled", pointer, transport));
+    case "body_too_large":
+      return fail(
+        issue("body_too_large", "Acceptance-policy catalog exceeded the configured byte limit", pointer, transport)
+      );
+    case "digest_mismatch":
+      return fail(
+        issue(
+          "digest_mismatch",
+          "Acceptance-policy catalog digest did not match the exact response bytes",
+          "/media_buy/acceptance_policy_discovery/catalog_digest",
+          transport
+        )
+      );
+    case "invalid_json":
+      return fail(issue("invalid_json", "Acceptance-policy catalog is not valid JSON", "/", transport));
+    case "document_too_deep":
+      return fail(
+        issue("catalog_document_invalid", "Acceptance-policy catalog exceeds the safe JSON depth limit", "/", transport)
+      );
+    case "http_error":
+      return fail(
+        issue("http_error", "Acceptance-policy catalog returned a non-success HTTP status", pointer, transport)
+      );
+    case "non_https_url":
+    case "unsafe_url":
+    case "invalid_ref":
+      return fail(
+        issue("unsafe_url", "Acceptance-policy catalog URL was blocked by remote-resolution policy", pointer, transport)
+      );
+    default:
+      return fail(issue("fetch_failed", "Acceptance-policy catalog could not be fetched", pointer, transport));
+  }
+}
+const SAFE_POINTER_SEGMENTS = /* @__PURE__ */ new Set([
+  "profiles",
+  "registry_profiles",
+  "catalog_version",
+  "generated_at",
+  "ext",
+  "profile_id",
+  "profile_version",
+  "profile_digest",
+  "version",
+  "content_digest",
+  "policy_id",
+  "policy_version",
+  "policy_digest",
+  "policy_refs",
+  "coverage",
+  "scope",
+  "region_aliases",
+  "description",
+  "rules",
+  "rule_id",
+  "subject_category",
+  "subject_categories",
+  "subject_facets",
+  "advertiser_roles",
+  "jurisdictions",
+  "jurisdiction_groups",
+  "all_jurisdictions",
+  "applies_to",
+  "disposition",
+  "requirements",
+  "policy_ids",
+  "effective_at",
+  "expires_at"
+]);
+const ARRAY_POINTER_SEGMENTS = /* @__PURE__ */ new Set([
+  "profiles",
+  "registry_profiles",
+  "policy_refs",
+  "rules",
+  "subject_categories",
+  "subject_facets",
+  "advertiser_roles",
+  "jurisdictions",
+  "jurisdiction_groups",
+  "applies_to",
+  "policy_ids"
+]);
+function sanitizePointer(pointer) {
+  if (!pointer || pointer === "/") return "/";
+  let numericIndexAllowed = false;
+  let regionAliasKeyExpected = false;
+  const sanitized = pointer.split("/").map((segment, index) => {
+    if (index === 0) return segment;
+    if (regionAliasKeyExpected) {
+      regionAliasKeyExpected = false;
+      numericIndexAllowed = true;
+      return "<property>";
+    }
+    if (/^\d+$/.test(segment)) {
+      const safe = numericIndexAllowed;
+      numericIndexAllowed = false;
+      return safe ? segment : "<property>";
+    }
+    if (SAFE_POINTER_SEGMENTS.has(segment)) {
+      regionAliasKeyExpected = segment === "region_aliases";
+      numericIndexAllowed = ARRAY_POINTER_SEGMENTS.has(segment);
+      return segment;
+    }
+    numericIndexAllowed = false;
+    return "<property>";
+  }).join("/");
+  return sanitized.length <= 256 ? sanitized : `${sanitized.slice(0, 244)}/<truncated>`;
+}
+function schemaIssues(errors) {
+  return (errors ?? []).map(
+    (error) => issue(
+      "schema_invalid",
+      `Acceptance-policy catalog failed schema validation: ${error.message ?? "validation failed"}`,
+      sanitizePointer(error.instancePath || "/"),
+      { keyword: error.keyword }
+    )
+  );
+}
+function semanticIssues(catalog, defaultProfileIds) {
+  const issues = [];
+  const record = (value) => {
+    if (issues.length < 32) issues.push(value);
+  };
+  const seenProfiles = /* @__PURE__ */ new Set();
+  const allProfiles = [
+    ...(catalog.profiles ?? []).map((profile, index) => ({ profile, pointer: `/profiles/${index}` })),
+    ...(catalog.registry_profiles ?? []).map((profile, index) => ({
+      profile,
+      pointer: `/registry_profiles/${index}`
+    }))
+  ];
+  for (const entry of allProfiles) {
+    if (seenProfiles.has(entry.profile.profile_id)) {
+      record(
+        issue(
+          "duplicate_profile_id",
+          "A profile_id must occur at most once across seller and registry profile lists",
+          `${entry.pointer}/profile_id`
+        )
+      );
+    }
+    seenProfiles.add(entry.profile.profile_id);
+  }
+  for (const [index, profileId] of defaultProfileIds.entries()) {
+    if (!seenProfiles.has(profileId)) {
+      record(
+        issue(
+          "unresolved_profile_id",
+          "An advertised default profile does not resolve in the catalog",
+          `/media_buy/acceptance_policy_discovery/default_profile_ids/${index}`
+        )
+      );
+    }
+  }
+  for (const [profileIndex, profile] of (catalog.profiles ?? []).entries()) {
+    const profilePointer = `/profiles/${profileIndex}`;
+    const { content_digest: _digest, ...digestInput } = profile;
+    const canonicalInputIssue = validateCanonicalJson(digestInput, profilePointer);
+    if (canonicalInputIssue) {
+      record(canonicalInputIssue);
+      continue;
+    }
+    let actualDigest;
+    try {
+      actualDigest = `sha256:${(0, import_jcs.canonicalJsonSha256)(digestInput)}`;
+    } catch {
+      record(
+        issue(
+          "profile_canonicalization_invalid",
+          "A seller profile cannot be canonicalized as RFC 8785 I-JSON",
+          profilePointer
+        )
+      );
+      continue;
+    }
+    if (actualDigest !== profile.content_digest) {
+      record(
+        issue(
+          "profile_digest_mismatch",
+          "A seller profile content_digest did not match its RFC 8785 canonical content",
+          `${profilePointer}/content_digest`
+        )
+      );
+    }
+    const policyIds = /* @__PURE__ */ new Set();
+    for (const [refIndex, reference] of profile.policy_refs.entries()) {
+      const policyId = reference.policy_id;
+      if (policyIds.has(policyId)) {
+        record(
+          issue(
+            "reference_invalid",
+            "A seller profile must reference each policy_id at most once",
+            `${profilePointer}/policy_refs/${refIndex}/policy_id`
+          )
+        );
+      }
+      policyIds.add(policyId);
+    }
+    const ruleIds = /* @__PURE__ */ new Set();
+    const regionAliases = new Set(Object.keys(profile.region_aliases ?? {}));
+    for (const [groupIndex, groupId] of (profile.scope?.jurisdiction_groups ?? []).entries()) {
+      if (!regionAliases.has(groupId)) {
+        record(
+          issue(
+            "reference_invalid",
+            "A scope jurisdiction group must resolve in the profile region_aliases",
+            `${profilePointer}/scope/jurisdiction_groups/${groupIndex}`
+          )
+        );
+      }
+    }
+    for (const [ruleIndex, rule] of profile.rules.entries()) {
+      const rulePointer = `${profilePointer}/rules/${ruleIndex}`;
+      if (ruleIds.has(rule.rule_id)) {
+        record(issue("reference_invalid", "A seller profile must use unique rule_id values", `${rulePointer}/rule_id`));
+      }
+      ruleIds.add(rule.rule_id);
+      for (const [policyIndex, policyId] of (rule.policy_ids ?? []).entries()) {
+        if (!policyIds.has(policyId)) {
+          record(
+            issue(
+              "reference_invalid",
+              "A rule policy_id must resolve to exactly one profile policy_refs entry",
+              `${rulePointer}/policy_ids/${policyIndex}`
+            )
+          );
+        }
+      }
+      for (const [groupIndex, groupId] of (rule.jurisdiction_groups ?? []).entries()) {
+        if (!regionAliases.has(groupId)) {
+          record(
+            issue(
+              "reference_invalid",
+              "A rule jurisdiction group must resolve in the profile region_aliases",
+              `${rulePointer}/jurisdiction_groups/${groupIndex}`
+            )
+          );
+        }
+      }
+    }
+  }
+  return issues;
+}
+function validateCanonicalJson(value, pointer, limits = {}) {
+  const pending = [{ value, depth: 0 }];
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  let stringCodeUnits = 0;
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current.exit) {
+      ancestors.delete(current.value);
+      continue;
+    }
+    nodes += 1;
+    if (limits.maxNodes !== void 0 && nodes > limits.maxNodes) {
+      return issue("profile_canonicalization_invalid", "A seller profile exceeds the safe JSON node limit", pointer);
+    }
+    if (current.depth > MAX_CANONICAL_JSON_DEPTH) {
+      return issue(
+        "profile_canonicalization_invalid",
+        `A seller profile exceeds the maximum canonical JSON depth of ${MAX_CANONICAL_JSON_DEPTH}`,
+        pointer
+      );
+    }
+    if (typeof current.value === "number" && !Number.isFinite(current.value)) {
+      return issue("profile_canonicalization_invalid", "A seller profile contains a non-finite JSON number", pointer);
+    }
+    if (typeof current.value === "string") {
+      stringCodeUnits += current.value.length;
+      if (limits.maxStringCodeUnits !== void 0 && stringCodeUnits > limits.maxStringCodeUnits) {
+        return issue(
+          "profile_canonicalization_invalid",
+          "A seller profile exceeds the safe string-size limit",
+          pointer
+        );
+      }
+      if (!(0, import_well_formed_unicode.isWellFormedUnicodeString)(current.value)) {
+        return issue(
+          "profile_canonicalization_invalid",
+          "A seller profile must contain well-formed Unicode before RFC 8785 canonicalization",
+          pointer
+        );
+      }
+      continue;
+    }
+    if (current.value === null || typeof current.value !== "object") continue;
+    if (ancestors.has(current.value)) {
+      return issue("profile_canonicalization_invalid", "A seller profile must not contain JSON cycles", pointer);
+    }
+    ancestors.add(current.value);
+    pending.push({ ...current, exit: true });
+    if (Array.isArray(current.value)) {
+      for (const child of current.value) pending.push({ value: child, depth: current.depth + 1 });
+      continue;
+    }
+    for (const [key, child] of Object.entries(current.value)) {
+      stringCodeUnits += key.length;
+      if (limits.maxStringCodeUnits !== void 0 && stringCodeUnits > limits.maxStringCodeUnits) {
+        return issue(
+          "profile_canonicalization_invalid",
+          "A seller profile exceeds the safe string-size limit",
+          pointer
+        );
+      }
+      if (!(0, import_well_formed_unicode.isWellFormedUnicodeString)(key)) {
+        return issue(
+          "profile_canonicalization_invalid",
+          "A seller profile must contain well-formed Unicode before RFC 8785 canonicalization",
+          pointer
+        );
+      }
+      pending.push({ value: child, depth: current.depth + 1 });
+    }
+  }
+  return void 0;
+}
+function validateCatalogDocument(value) {
+  const pending = [{ value, depth: 0 }];
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  let nodes = 0;
+  let stringCodeUnits = 0;
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current.exit) {
+      ancestors.delete(current.value);
+      continue;
+    }
+    nodes += 1;
+    if (nodes > MAX_CATALOG_JSON_NODES) {
+      return issue("catalog_document_invalid", "Acceptance-policy catalog exceeds the safe JSON node limit", "/");
+    }
+    if (current.depth > MAX_CATALOG_JSON_DEPTH) {
+      return issue(
+        "catalog_document_invalid",
+        `Acceptance-policy catalog exceeds the maximum JSON depth of ${MAX_CATALOG_JSON_DEPTH}`,
+        "/"
+      );
+    }
+    if (typeof current.value === "number" && !Number.isFinite(current.value)) {
+      return issue("catalog_document_invalid", "Acceptance-policy catalog contains a non-finite JSON number", "/");
+    }
+    if (typeof current.value === "string") {
+      stringCodeUnits += current.value.length;
+      if (stringCodeUnits > MAX_CATALOG_JSON_STRING_CODE_UNITS) {
+        return issue("catalog_document_invalid", "Acceptance-policy catalog exceeds the safe string-size limit", "/");
+      }
+      if (!(0, import_well_formed_unicode.isWellFormedUnicodeString)(current.value)) {
+        return issue("catalog_document_invalid", "Acceptance-policy catalog must contain well-formed Unicode", "/");
+      }
+      continue;
+    }
+    if (current.value === null || typeof current.value !== "object") continue;
+    if (ancestors.has(current.value)) {
+      return issue("catalog_document_invalid", "Acceptance-policy catalog must not contain JSON cycles", "/");
+    }
+    ancestors.add(current.value);
+    pending.push({ ...current, exit: true });
+    if (Array.isArray(current.value)) {
+      for (const child of current.value) pending.push({ value: child, depth: current.depth + 1 });
+      continue;
+    }
+    for (const [key, child] of Object.entries(current.value)) {
+      stringCodeUnits += key.length;
+      if (stringCodeUnits > MAX_CATALOG_JSON_STRING_CODE_UNITS) {
+        return issue("catalog_document_invalid", "Acceptance-policy catalog exceeds the safe string-size limit", "/");
+      }
+      if (!(0, import_well_formed_unicode.isWellFormedUnicodeString)(key)) {
+        return issue("catalog_document_invalid", "Acceptance-policy catalog must contain well-formed Unicode", "/");
+      }
+      pending.push({ value: child, depth: current.depth + 1 });
+    }
+  }
+  return void 0;
+}
+function resolveDefaults(catalog, profileIds) {
+  return resolveAcceptancePolicyProfiles(catalog, profileIds).filter(
+    (value) => value.resolution !== "missing"
+  );
+}
+function resolveAcceptancePolicyProfiles(catalog, profileIds) {
+  const sellerProfiles = new Map((catalog.profiles ?? []).map((profile) => [profile.profile_id, profile]));
+  const registryProfiles = new Map((catalog.registry_profiles ?? []).map((profile) => [profile.profile_id, profile]));
+  return profileIds.map((profileId) => {
+    const seller = sellerProfiles.get(profileId);
+    if (seller) {
+      return { source: "seller", resolution: "resolved", profileId, profile: seller };
+    }
+    const ref = registryProfiles.get(profileId);
+    if (ref) return { source: "registry", resolution: "unresolved", profileId, ref };
+    return { source: "catalog", resolution: "missing", profileId };
+  });
+}
+function safeVersionLabel(version) {
+  return /^[0-9A-Za-z.-]{1,64}$/.test(version) ? version : "<requested version>";
+}
+const REGISTRY_TIMEOUT = /* @__PURE__ */ Symbol("registry-timeout");
+async function waitForRegistryPolicy(pending, timeoutMs, controller) {
+  let timer;
+  try {
+    return await Promise.race([
+      pending,
+      new Promise((resolve) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          resolve(REGISTRY_TIMEOUT);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function resolveRegistryProfile(ref, pointer, options, deadlineAt, controller) {
+  let policy;
+  try {
+    const remainingMs = deadlineAt - performance.now();
+    if (controller.signal.aborted || remainingMs <= 0) {
+      return fail(
+        issue("registry_timeout", "Registry profile resolution exceeded the overall deadline", pointer, {
+          retryable: true
+        })
+      );
+    }
+    const resolved = await waitForRegistryPolicy(
+      options.registryResolver.resolvePolicy({
+        policy_id: ref.policy_id,
+        version: ref.policy_version,
+        signal: controller.signal
+      }),
+      remainingMs,
+      controller
+    );
+    if (controller.signal.aborted || performance.now() >= deadlineAt) {
+      return fail(
+        issue("registry_timeout", "Registry profile resolution exceeded the overall deadline", pointer, {
+          retryable: true
+        })
+      );
+    }
+    if (resolved === REGISTRY_TIMEOUT) {
+      return fail(
+        issue("registry_timeout", "Registry profile resolution exceeded the overall deadline", pointer, {
+          retryable: true
+        })
+      );
+    }
+    policy = resolved;
+  } catch {
+    if (controller.signal.aborted || performance.now() >= deadlineAt) {
+      return fail(
+        issue("registry_timeout", "Registry profile resolution exceeded the overall deadline", pointer, {
+          retryable: true
+        })
+      );
+    }
+    return fail(
+      issue("registry_fetch_failed", "The pinned registry policy could not be fetched", pointer, { retryable: true })
+    );
+  }
+  if (!policy || typeof policy !== "object") {
+    return fail(
+      issue("registry_reference_unresolved", "The pinned registry policy version did not resolve", pointer, {
+        retryable: false
+      })
+    );
+  }
+  if (policy.policy_id !== ref.policy_id || policy.version !== ref.policy_version) {
+    return fail(
+      issue("registry_policy_mismatch", "The registry returned a different policy identity or version", pointer)
+    );
+  }
+  if (policy.canonical_content === null || typeof policy.canonical_content !== "object" || Array.isArray(policy.canonical_content) || typeof policy.content_digest !== "string") {
+    return fail(
+      issue("registry_policy_unverifiable", "The registry policy lacks verifiable canonical content", pointer)
+    );
+  }
+  const registryJsonLimits = {
+    maxNodes: MAX_REGISTRY_JSON_NODES,
+    maxStringCodeUnits: MAX_REGISTRY_JSON_STRING_CODE_UNITS
+  };
+  if (validateCanonicalJson(policy.canonical_content, pointer, registryJsonLimits)) {
+    return fail(
+      issue("registry_policy_unverifiable", "The registry policy canonical content is not safe I-JSON", pointer)
+    );
+  }
+  let policyDigest;
+  try {
+    policyDigest = `sha256:${(0, import_jcs.canonicalJsonSha256)(policy.canonical_content)}`;
+  } catch {
+    return fail(
+      issue("registry_policy_unverifiable", "The registry policy canonical content cannot be verified", pointer)
+    );
+  }
+  if (policyDigest !== policy.content_digest || policyDigest !== ref.policy_digest) {
+    return fail(
+      issue("registry_policy_digest_mismatch", "The registry policy digest does not match the catalog pin", pointer)
+    );
+  }
+  const profileValue = policy.acceptance_profile;
+  if (profileValue === null || typeof profileValue !== "object" || Array.isArray(profileValue)) {
+    return fail(
+      issue("registry_profile_invalid", "The pinned registry policy does not contain an acceptance profile", pointer)
+    );
+  }
+  if (validateCanonicalJson(profileValue, pointer, registryJsonLimits)) {
+    return fail(issue("registry_profile_invalid", "The registry acceptance profile is not safe I-JSON", pointer));
+  }
+  const requestedVersion = options.adcpVersion ?? import_version.ADCP_VERSION;
+  let validator;
+  try {
+    validator = (0, import_schema_loader.getSchemaValidatorByRef)(PROFILE_SCHEMA_REF, requestedVersion, void 0, { allErrors: false });
+  } catch {
+    return fail(
+      issue(
+        "schema_unavailable",
+        `Acceptance-policy profile schema is unavailable for ${safeVersionLabel(requestedVersion)}`,
+        pointer
+      )
+    );
+  }
+  if (!validator) {
+    return fail(
+      issue(
+        "schema_unavailable",
+        `Acceptance-policy profile schema is unavailable for ${safeVersionLabel(requestedVersion)}`,
+        pointer
+      )
+    );
+  }
+  if (!validator(profileValue)) {
+    const error = issue(
+      "registry_profile_schema_invalid",
+      "The registry acceptance profile is incompatible with the selected AdCP schema",
+      pointer,
+      {
+        keyword: validator.errors?.[0]?.keyword
+      }
+    );
+    const details = schemaIssues(validator.errors).map((value) => ({
+      ...value,
+      message: "Acceptance-policy profile failed schema validation",
+      pointer: `${pointer}/acceptance_profile${value.pointer === "/" ? "" : value.pointer}`
+    }));
+    return fail(error, [error, ...details]);
+  }
+  const profile = profileValue;
+  if (profile.profile_id !== ref.profile_id || profile.version !== ref.profile_version) {
+    return fail(
+      issue("registry_profile_mismatch", "The registry returned a different profile identity or version", pointer)
+    );
+  }
+  if (profile.content_digest !== ref.profile_digest) {
+    return fail(
+      issue("registry_profile_digest_mismatch", "The registry profile digest does not match the catalog pin", pointer)
+    );
+  }
+  const { content_digest: _digest, ...profileDigestInput } = profile;
+  let profileDigest;
+  try {
+    profileDigest = `sha256:${(0, import_jcs.canonicalJsonSha256)(profileDigestInput)}`;
+  } catch {
+    return fail(
+      issue("registry_profile_digest_mismatch", "The registry profile canonical digest cannot be verified", pointer)
+    );
+  }
+  if (profileDigest !== profile.content_digest) {
+    return fail(
+      issue("registry_profile_digest_mismatch", "The registry profile content does not match its digest", pointer)
+    );
+  }
+  const semantic = semanticIssues({ catalog_version: "registry", profiles: [profile] }, []);
+  if (semantic.length > 0) {
+    const error = issue("registry_profile_invalid", "The registry profile failed integrity validation", pointer);
+    const details = semantic.map((value) => ({
+      ...value,
+      pointer: `${pointer}/acceptance_profile${value.pointer.replace(/^\/profiles\/0/, "")}`
+    }));
+    return fail(error, [error, ...details]);
+  }
+  return {
+    source: "registry",
+    resolution: "resolved",
+    profileId: ref.profile_id,
+    profile: cloneJson(profile),
+    ref
+  };
+}
+async function resolveVerifiedAcceptancePolicyProfiles(catalog, profileIds, options) {
+  const optionsSnapshot = { ...options };
+  return resolveVerifiedAcceptancePolicyProfilesInternal(catalog, profileIds, optionsSnapshot, false);
+}
+async function resolveVerifiedAcceptancePolicyProfilesInternal(catalog, profileIds, options, catalogAlreadyValidated) {
+  if (!options?.registryResolver || typeof options.registryResolver.resolvePolicy !== "function") {
+    return fail(
+      issue("invalid_options", "registryResolver must provide a resolvePolicy function", "/options/registryResolver")
+    );
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0 || options.timeoutMs > MAX_TIMEOUT_MS)) {
+    return fail(
+      issue(
+        "invalid_options",
+        `timeoutMs must be a positive safe integer no greater than ${MAX_TIMEOUT_MS}`,
+        "/options/timeoutMs"
+      )
+    );
+  }
+  if (options.maxRegistryProfiles !== void 0 && (!Number.isSafeInteger(options.maxRegistryProfiles) || options.maxRegistryProfiles <= 0 || options.maxRegistryProfiles > MAX_REGISTRY_PROFILES)) {
+    return fail(
+      issue(
+        "invalid_options",
+        `maxRegistryProfiles must be a positive safe integer no greater than ${MAX_REGISTRY_PROFILES}`,
+        "/options/maxRegistryProfiles"
+      )
+    );
+  }
+  if (!Array.isArray(profileIds) || profileIds.some((profileId) => typeof profileId !== "string" || profileId.length === 0)) {
+    return fail(issue("invalid_options", "profileIds must contain only non-empty strings", "/profileIds"));
+  }
+  if (profileIds.length > MAX_SELECTED_PROFILE_IDS) {
+    return fail(
+      issue(
+        "invalid_options",
+        `profileIds must contain no more than ${MAX_SELECTED_PROFILE_IDS} entries`,
+        "/profileIds"
+      )
+    );
+  }
+  const requestedVersion = options.adcpVersion ?? import_version.ADCP_VERSION;
+  let catalogSnapshot;
+  if (catalogAlreadyValidated) {
+    catalogSnapshot = catalog;
+  } else {
+    const documentIssue = validateCatalogDocument(catalog);
+    if (documentIssue) return fail(documentIssue);
+    let validator;
+    try {
+      validator = (0, import_schema_loader.getSchemaValidatorByRef)(CATALOG_SCHEMA_REF, requestedVersion, void 0, { allErrors: false });
+    } catch {
+      return fail(
+        issue(
+          "schema_unavailable",
+          `Acceptance-policy catalog schema is unavailable for ${safeVersionLabel(requestedVersion)}`,
+          "/"
+        )
+      );
+    }
+    if (!validator) {
+      return fail(
+        issue(
+          "schema_unavailable",
+          `Acceptance-policy catalog schema is unavailable for ${safeVersionLabel(requestedVersion)}`,
+          "/"
+        )
+      );
+    }
+    if (!validator(catalog)) {
+      const issues2 = schemaIssues(validator.errors);
+      return fail(
+        issues2[0] ?? issue("schema_invalid", "Acceptance-policy catalog failed schema validation", "/"),
+        issues2
+      );
+    }
+    const integrityIssues = semanticIssues(catalog, []);
+    if (integrityIssues.length > 0) return fail(integrityIssues[0], integrityIssues);
+    catalogSnapshot = cloneCatalog(catalog);
+  }
+  const classified = resolveAcceptancePolicyProfiles(catalogSnapshot, [...profileIds]);
+  const distinctRegistryProfiles = new Set(
+    classified.filter((value) => value.source === "registry" && value.resolution === "unresolved").map((value) => value.profileId)
+  );
+  const maxRegistryProfiles = options.maxRegistryProfiles ?? DEFAULT_MAX_REGISTRY_PROFILES;
+  if (distinctRegistryProfiles.size > maxRegistryProfiles) {
+    return {
+      ok: true,
+      profiles: classified,
+      issues: [
+        issue(
+          "registry_resolution_limit_exceeded",
+          "The selected registry profile count exceeds the configured resolution limit",
+          "/registry_profiles"
+        )
+      ]
+    };
+  }
+  const registryIndexes = new Map(
+    (catalogSnapshot.registry_profiles ?? []).map((ref, index) => [ref.profile_id, index])
+  );
+  const registryValues = new Map(
+    classified.filter(
+      (value) => value.source === "registry" && value.resolution === "unresolved"
+    ).map((value) => [value.profileId, value])
+  );
+  const resolutionByProfileId = /* @__PURE__ */ new Map();
+  const registryEntries = [...registryValues.entries()];
+  const controller = new AbortController();
+  const deadlineAt = performance.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  let nextRegistryIndex = 0;
+  async function resolveWorker() {
+    while (nextRegistryIndex < registryEntries.length) {
+      const entryIndex = nextRegistryIndex++;
+      const [profileId, value] = registryEntries[entryIndex];
+      const catalogIndex = registryIndexes.get(profileId);
+      const resolved = await resolveRegistryProfile(
+        value.ref,
+        catalogIndex === void 0 ? "/registry_profiles" : `/registry_profiles/${catalogIndex}`,
+        options,
+        deadlineAt,
+        controller
+      );
+      resolutionByProfileId.set(profileId, resolved);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(MAX_REGISTRY_CONCURRENCY, registryEntries.length) }, async () => resolveWorker())
+  );
+  const profiles = [];
+  const issues = [];
+  const reportedFailures = /* @__PURE__ */ new Set();
+  for (const value of classified) {
+    if (value.source !== "registry" || value.resolution !== "unresolved") {
+      profiles.push(value);
+      continue;
+    }
+    const resolved = resolutionByProfileId.get(value.profileId);
+    if (!resolved || "ok" in resolved) {
+      profiles.push(value);
+      if (resolved && !reportedFailures.has(value.profileId)) {
+        issues.push(...resolved.issues ?? [resolved.error]);
+        reportedFailures.add(value.profileId);
+      }
+      continue;
+    }
+    profiles.push(resolved);
+  }
+  return { ok: true, profiles, ...issues.length > 0 && { issues } };
+}
+async function resolveOnce(capability, options) {
+  const invalidOptions = validateOptions(options);
+  if (invalidOptions) return fail(invalidOptions);
+  const invalid = validateCapability(capability, options);
+  if (invalid) return fail(invalid);
+  let fetched;
+  try {
+    fetched = await (0, import_canonical_references.resolveCanonicalReference)(
+      { uri: capability.catalog_url, digest: capability.catalog_digest },
+      {
+        timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        maxBodyBytes: options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES,
+        allowUnsafeHttp: options.allowUnsafeHttp,
+        allowPrivateNetwork: options.allowPrivateNetwork
+      }
+    );
+  } catch {
+    return fail(
+      issue(
+        "fetch_failed",
+        "Acceptance-policy catalog resolution failed safely",
+        "/media_buy/acceptance_policy_discovery/catalog_url",
+        { retryable: false }
+      )
+    );
+  }
+  if (!fetched.ok) return translateFetchFailure(fetched);
+  const requestedVersion = options.adcpVersion ?? import_version.ADCP_VERSION;
+  const displayVersion = safeVersionLabel(requestedVersion);
+  let validator;
+  try {
+    validator = (0, import_schema_loader.getSchemaValidatorByRef)(CATALOG_SCHEMA_REF, requestedVersion, void 0, { allErrors: false });
+  } catch {
+    return fail(
+      issue("schema_unavailable", `Acceptance-policy catalog schema is unavailable for ${displayVersion}`, "/")
+    );
+  }
+  if (!validator) {
+    return fail(
+      issue("schema_unavailable", `Acceptance-policy catalog schema is unavailable for ${displayVersion}`, "/")
+    );
+  }
+  if (!validator(fetched.document)) {
+    const issues2 = schemaIssues(validator.errors);
+    return fail(
+      issues2[0] ?? issue("schema_invalid", "Acceptance-policy catalog failed schema validation", "/"),
+      issues2
+    );
+  }
+  const catalog = fetched.document;
+  const issues = semanticIssues(catalog, capability.default_profile_ids ?? []);
+  if (issues.length > 0) return fail(issues[0], issues);
+  const documentIssue = validateCatalogDocument(catalog);
+  if (documentIssue) return fail(documentIssue);
+  const clonedCatalog = cloneCatalog(catalog);
+  let defaultProfiles = resolveDefaults(clonedCatalog, capability.default_profile_ids ?? []);
+  let registryIssues;
+  if (options.registryResolver && defaultProfiles.some((value) => value.resolution === "unresolved")) {
+    const verified = await resolveVerifiedAcceptancePolicyProfilesInternal(
+      clonedCatalog,
+      capability.default_profile_ids ?? [],
+      {
+        registryResolver: options.registryResolver,
+        adcpVersion: requestedVersion,
+        timeoutMs: options.registryTimeoutMs,
+        maxRegistryProfiles: options.maxRegistryProfiles
+      },
+      true
+    );
+    if (!verified.ok) return verified;
+    registryIssues = verified.issues;
+    defaultProfiles = verified.profiles.filter(
+      (value) => value.resolution !== "missing"
+    );
+  }
+  return {
+    ok: true,
+    fromCache: false,
+    catalog: clonedCatalog,
+    defaultProfiles,
+    ...registryIssues !== void 0 && { issues: registryIssues }
+  };
+}
+async function resolveAcceptancePolicyCatalog(capability, options = {}) {
+  return resolveOnce(snapshotCapability(capability), { ...options });
+}
+function createAcceptancePolicyCatalogResolver(options = {}) {
+  const resolverOptions = { ...options };
+  let capabilityKey;
+  let cached;
+  let generation = 0;
+  let inFlight;
+  return {
+    async resolve(capability) {
+      const snapshot = snapshotCapability(capability);
+      const nextKey = JSON.stringify({
+        catalog_url: snapshot?.catalog_url,
+        catalog_digest: snapshot?.catalog_digest,
+        default_profile_ids: snapshot?.default_profile_ids
+      });
+      if (nextKey !== capabilityKey) {
+        capabilityKey = nextKey;
+        cached = void 0;
+        inFlight = void 0;
+        generation += 1;
+      }
+      if (cached) return cloneSuccess(cached, true);
+      if (inFlight?.key === nextKey && inFlight.generation === generation) {
+        let shared;
+        try {
+          shared = await inFlight.promise;
+        } catch {
+          return fail(
+            issue(
+              "fetch_failed",
+              "Acceptance-policy catalog resolution failed safely",
+              "/media_buy/acceptance_policy_discovery/catalog_url",
+              { retryable: false }
+            )
+          );
+        }
+        return shared.ok ? cloneSuccess(shared, false) : shared;
+      }
+      const startedGeneration = generation;
+      const promise = resolveOnce(snapshot, resolverOptions);
+      inFlight = { key: nextKey, generation: startedGeneration, promise };
+      let result;
+      try {
+        result = await promise;
+      } catch {
+        result = fail(
+          issue(
+            "fetch_failed",
+            "Acceptance-policy catalog resolution failed safely",
+            "/media_buy/acceptance_policy_discovery/catalog_url",
+            { retryable: false }
+          )
+        );
+      } finally {
+        if (inFlight?.promise === promise) inFlight = void 0;
+      }
+      if (!result.ok) return result;
+      if (generation === startedGeneration && capabilityKey === nextKey) {
+        cached = cloneSuccess(result, false);
+      }
+      return cloneSuccess(result, false);
+    },
+    invalidate() {
+      capabilityKey = void 0;
+      cached = void 0;
+      inFlight = void 0;
+      generation += 1;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAcceptancePolicyCatalogResolver,
+  resolveAcceptancePolicyCatalog,
+  resolveAcceptancePolicyProfiles,
+  resolveVerifiedAcceptancePolicyProfiles
+});