@adcp/sdk 16.0.0-beta.6 → 16.0.0-beta.8

package/dist/lib/core/SingleAgentClient.mjs

@@ -163,7 +163,9 @@ import { resolveWebhookUrl, selectWebhookTemplate } from "./webhook-url.mjs";
 import { getV25Adapter } from "../adapters/legacy/v2-5/index.mjs";
 import {
   ProductPropertyPolicyError,
-  validateProductsAgainstPropertyPolicy
+  validateProductsAgainstPropertyPolicy,
+  isSupportedPropertyIdentifierType,
+  normalizeDomainForPropertyPolicy
 } from "../media-buy/property-policy.mjs";
 import { resolvePropertyList } from "../server/targeting-helpers.mjs";
 import {
@@ -787,7 +789,9 @@ function productIdForPricingDiagnostics(product) {
   return typeof id === "string" ? id : void 0;
 }
 function propertyListReferenceFromRequest(params) {
-  const value = params.property_list;
+  const filters = params.filters;
+  const nested = filters && typeof filters === "object" && !Array.isArray(filters) && Object.hasOwn(filters, "property_list") && filters.property_list !== void 0;
+  const value = nested ? filters.property_list : params.property_list;
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   const ref = value;
   if (typeof ref.agent_url !== "string" || typeof ref.list_id !== "string") return void 0;
@@ -800,21 +804,37 @@ function propertyListReferenceFromRequest(params) {
 function productPolicyRequestSnapshot(requestParams) {
   const account = canonicalAccountRoutingSnapshot(requestParams.account);
   const propertyList = propertyListReferenceFromRequest(requestParams);
+  const referenceError = propertyListReferenceError(requestParams);
   return Object.freeze({
     ...account ? { account } : {},
-    ...propertyList ? { property_list: Object.freeze(propertyList) } : {}
+    ...propertyList ? { property_list: Object.freeze(propertyList) } : {},
+    ...referenceError ? { property_list_error: referenceError } : {}
   });
 }
+function propertyListReferenceError(params) {
+  if (typeof params.property_list_error === "string") return params.property_list_error;
+  const filters = params.filters;
+  if (params.property_list !== void 0 && !propertyListReferenceFromRequest({ property_list: params.property_list }))
+    return "property_list_invalid_reference";
+  if (!filters || typeof filters !== "object" || Array.isArray(filters) || !Object.hasOwn(filters, "property_list") || filters.property_list === void 0)
+    return void 0;
+  const nested = propertyListReferenceFromRequest(params);
+  if (!nested) return "property_list_invalid_reference";
+  if (params.property_list !== void 0) {
+    const legacy = propertyListReferenceFromRequest({ property_list: params.property_list });
+    if (!legacy || nested.agent_url !== legacy.agent_url || nested.list_id !== legacy.list_id || nested.auth_token !== legacy.auth_token) {
+      return "property_list_conflicting_references";
+    }
+  }
+  return void 0;
+}
 function hasProductPropertyPolicyRules(policy) {
   return Boolean(
     policy.allowedDomains?.length || policy.allowedPropertyIdentifiers?.length || policy.requireAllowedPropertyMatch || policy.excludedDomains?.length || policy.excludedPropertyIds?.length || policy.strict || policy.unknownSelectorBehavior || policy.missingPublisherPropertiesBehavior
   );
 }
-function comparablePropertyIdentifiers(identifiers) {
-  return identifiers.filter((identifier) => identifier.type === "domain" || identifier.type === "subdomain").map((identifier) => ({ type: identifier.type, value: identifier.value }));
-}
 function unsupportedPropertyIdentifiers(identifiers) {
-  return identifiers.filter((identifier) => identifier.type !== "domain" && identifier.type !== "subdomain").map((identifier) => ({ type: identifier.type }));
+  return identifiers.filter((identifier) => !isSupportedPropertyIdentifierType(identifier.type)).map((identifier) => ({ type: identifier.type }));
 }
 function sanitizeDiagnosticUrl(value) {
   try {
@@ -1411,8 +1431,17 @@ class SingleAgentClient {
   }
   assertDurablePropertyListCredentialSupported(taskType, requestParams) {
     if (!this.config.deferredStorage || taskType !== "get_products") return;
-    const propertyList = propertyListReferenceFromRequest(requestParams);
-    if (!propertyList?.auth_token) return;
+    const filters = requestParams.filters;
+    const references = [
+      requestParams.property_list,
+      filters && typeof filters === "object" ? filters.property_list : void 0
+    ];
+    const hasCredential = references.some((reference) => {
+      if (!reference || typeof reference !== "object") return false;
+      const token = reference.auth_token;
+      return token !== void 0 && token !== null && token !== "";
+    });
+    if (!hasCredential) return;
     const policyConfig = this.config.validation?.productPropertyPolicy;
     if (policyConfig === false || policyConfig?.enforceRequestPropertyList === false) return;
     throw new ConfigurationError(
@@ -4223,39 +4252,40 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       message = "Property list not adhered to",
       enforceRequestPropertyList = true,
       propertyListResolveOptions,
+      resolvePublisherProperties,
+      maxPublisherLookups = 100,
+      publisherLookupTimeoutMs = 1e4,
+      publisherLookupBudgetMs = 1e4,
       ...explicitPolicy
     } = policyConfig || {};
     const policy = {
       ...explicitPolicy
     };
     let resolvedRequestPropertyList;
-    if (requestPropertyList && enforceRequestPropertyList) {
+    const referenceError = propertyListReferenceError(requestParams);
+    if ((requestPropertyList || referenceError) && enforceRequestPropertyList) {
       try {
+        if (referenceError) throw new Error(referenceError);
         const resolved = await resolvePropertyList(requestPropertyList, propertyListResolveOptions);
-        const comparableIdentifiers = comparablePropertyIdentifiers(resolved.identifiers);
         const unsupportedIdentifiers = unsupportedPropertyIdentifiers(resolved.identifiers);
-        if (unsupportedIdentifiers.length > 0) {
-          throw new Error("property_list_unsupported_identifier_types");
-        }
-        if (comparableIdentifiers.length > 0 || resolved.identifiers.length === 0) {
-          policy.allowedPropertyIdentifiers = [...policy.allowedPropertyIdentifiers ?? [], ...comparableIdentifiers];
-          policy.requireAllowedPropertyMatch = true;
-        }
+        policy.allowedPropertyIdentifiers = [...policy.allowedPropertyIdentifiers ?? [], ...resolved.identifiers];
+        policy.requireAllowedPropertyMatch = true;
         policy.strict = policy.strict ?? true;
         resolvedRequestPropertyList = {
           listId: resolved.listId,
           agentUrl: resolved.agentUrl,
           identifierCount: resolved.identifiers.length,
+          unsupportedIdentifierTypes: [...new Set(unsupportedIdentifiers.map((identifier) => identifier.type))],
           ...resolved.cacheValidUntil ? { cacheValidUntil: resolved.cacheValidUntil } : {}
         };
       } catch (err) {
         const errorCode = propertyListResolutionErrorCode(err);
-        const diagnosticAgentUrl = sanitizeDiagnosticUrl(requestPropertyList.agent_url);
+        const diagnosticAgentUrl = requestPropertyList ? sanitizeDiagnosticUrl(requestPropertyList.agent_url) : "invalid_url";
         return attachMatch({
           success: false,
           status: "failed",
           data: response,
-          error: `${message}: could not resolve property_list ${requestPropertyList.list_id}`,
+          error: `${message}: could not resolve property_list`,
           metadata: {
             ...result.metadata,
             status: "failed",
@@ -4268,7 +4298,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
               message,
               diagnostics: [],
               request_property_list: {
-                list_id: requestPropertyList.list_id,
+                list_id: requestPropertyList?.list_id ?? "invalid_reference",
                 agent_url: diagnosticAgentUrl,
                 resolution_error: errorCode
               }
@@ -4283,7 +4313,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
               mode,
               ok: false,
               request_property_list: {
-                list_id: requestPropertyList.list_id,
+                list_id: requestPropertyList?.list_id,
                 agent_url: diagnosticAgentUrl,
                 resolution_error: errorCode
               }
@@ -4293,6 +4323,65 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
       }
     }
     if (!hasProductPropertyPolicyRules(policy)) return result;
+    if (resolvePublisherProperties && policy.allowedPropertyIdentifiers?.some(
+      (identifier) => identifier.type !== "domain" && identifier.type !== "subdomain"
+    )) {
+      if (!Number.isSafeInteger(maxPublisherLookups) || maxPublisherLookups < 1 || !Number.isSafeInteger(publisherLookupTimeoutMs) || publisherLookupTimeoutMs < 1 || publisherLookupTimeoutMs > 2147483647 || !Number.isSafeInteger(publisherLookupBudgetMs) || publisherLookupBudgetMs < 1 || publisherLookupBudgetMs > 2147483647) {
+        throw new ConfigurationError("Publisher lookup limits must be positive bounded integers");
+      }
+      const { validatePublisherDomain } = await import("../identifiers.mjs");
+      const catalogs = Object.assign(
+        /* @__PURE__ */ Object.create(null),
+        policy.publisherProperties
+      );
+      const domains = new Set(
+        response.products.flatMap(
+          (product) => Array.isArray(product.publisher_properties) ? product.publisher_properties.flatMap(
+            (selector) => selector && typeof selector === "object" && "publisher_domain" in selector ? [selector.publisher_domain] : []
+          ) : []
+        )
+      );
+      const hosts = [
+        ...new Set(
+          [...domains].flatMap(
+            (domain) => typeof domain === "string" ? [normalizeDomainForPropertyPolicy(domain)?.host] : []
+          )
+        )
+      ].filter((host) => typeof host === "string" && !Object.hasOwn(catalogs, host));
+      for (const host of hosts) catalogs[host] = void 0;
+      const lookupStartedAt = performance.now();
+      for (const host of hosts.slice(0, maxPublisherLookups)) {
+        throwIfAborted(taskSignal);
+        const remainingBudgetMs = publisherLookupBudgetMs - (performance.now() - lookupStartedAt);
+        if (remainingBudgetMs <= 0) break;
+        if (!validatePublisherDomain(host).ok || isLikelyPrivateUrl(`https://${host}`)) continue;
+        const controller = new AbortController();
+        const signal = taskSignal ? AbortSignal.any([taskSignal, controller.signal]) : controller.signal;
+        let timeout;
+        let budgetExpired = false;
+        try {
+          catalogs[host] = await Promise.race([
+            resolvePublisherProperties(host, { signal }),
+            new Promise((_, reject) => {
+              timeout = setTimeout(
+                () => {
+                  if (remainingBudgetMs <= publisherLookupTimeoutMs) budgetExpired = true;
+                  controller.abort();
+                  reject(new Error("publisher_catalog_timeout"));
+                },
+                Math.min(publisherLookupTimeoutMs, remainingBudgetMs)
+              );
+            })
+          ]);
+        } catch {
+          catalogs[host] = void 0;
+        } finally {
+          if (timeout) clearTimeout(timeout);
+        }
+        if (budgetExpired) break;
+      }
+      policy.publisherProperties = catalogs;
+    }
     let validation;
     try {
       validation = validateProductsAgainstPropertyPolicy({
@@ -4316,6 +4405,7 @@ Hint: this usually means agent_uri does not include the MCP endpoint path. The S
           list_id: resolvedRequestPropertyList.listId,
           agent_url: sanitizeDiagnosticUrl(resolvedRequestPropertyList.agentUrl),
           identifier_count: resolvedRequestPropertyList.identifierCount,
+          unsupported_identifier_types: resolvedRequestPropertyList.unsupportedIdentifierTypes,
           ...resolvedRequestPropertyList.cacheValidUntil ? { cache_valid_until: resolvedRequestPropertyList.cacheValidUntil } : {}
         }
       } : {},

package/dist/lib/core/TaskExecutor.d.mts

@@ -441,6 +441,7 @@ export declare class TaskExecutor {
      * AJV runs.
      */
     private validateResponseSchema;
+    private validateResponseSchemaAgainst;
     private responseAdcpVersionForValidation;
     private effectiveResponseAdcpVersion;
     /**

package/dist/lib/core/TaskExecutor.d.ts

@@ -441,6 +441,7 @@ export declare class TaskExecutor {
      * AJV runs.
      */
     private validateResponseSchema;
+    private validateResponseSchemaAgainst;
     private responseAdcpVersionForValidation;
     private effectiveResponseAdcpVersion;
     /**

package/dist/lib/core/TaskExecutor.js

@@ -4459,41 +4459,22 @@ class TaskExecutor {
     const mode = this.responseValidationMode;
     const logViolations = this.config.logSchemaViolations !== false;
     try {
-      let validationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? import_version.ADCP_VERSION;
-      if (taskName === "get_adcp_capabilities" && validationVersion !== "v2.5") {
-        validationVersion = (0, import_schema_loader.resolveServedValidationVersion)(response, validationVersion);
-      }
-      const normalizedResponse = this.normalizeResponseForValidation(response, taskName, validationVersion === "v2.5");
-      const outcome = (this.config.experimentalIdentity33?.() || this.config.identity33SchemaExperiment && normalizedResponse && typeof normalizedResponse === "object" && (0, import_adcp_version_config.isAdcpVersionAtLeast)(normalizedResponse.adcp_version, "3.3")) && mode !== "off" ? validateIdentity33Payload(taskName, "response", normalizedResponse, validationVersion) : (0, import_client_hooks.validateIncomingResponse)(taskName, normalizedResponse, mode, void 0, validationVersion);
-      if (outcome.valid) return { valid: true, errors: [] };
-      const errorStrings = outcome.issues.map((i) => `${i.pointer}: ${i.message}`);
-      if (logViolations) {
-        debugLogs.push({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: mode === "strict" ? "error" : "warning",
-          message: `Schema validation ${mode === "strict" ? "failed" : "warning"} for ${taskName}: ${(0, import_schema_validator.formatIssues)(
-            outcome.issues
-          )}`,
-          errors: errorStrings,
-          issues: outcome.issues,
-          schemaVariant: outcome.variant,
-          schemaVersion: validationVersion,
-          mode
-        });
-      }
-      if (mode === "warn") {
-        if (logViolations) {
-          console.warn(
-            `Schema validation failed for ${taskName} against AdCP ${validationVersion} (non-blocking):`,
-            errorStrings
-          );
-        }
-        return { valid: true, errors: [] };
-      }
-      if (logViolations) {
-        console.error(`Schema validation failed for ${taskName} against AdCP ${validationVersion}:`, errorStrings);
+      const pinnedValidationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? import_version.ADCP_VERSION;
+      if (taskName === "get_adcp_capabilities" && pinnedValidationVersion !== "v2.5") {
+        return (0, import_schema_loader.withServedValidationVersion)(
+          response,
+          pinnedValidationVersion,
+          (validationVersion) => this.validateResponseSchemaAgainst(response, taskName, debugLogs, mode, logViolations, validationVersion)
+        );
       }
-      return { valid: false, errors: errorStrings };
+      return this.validateResponseSchemaAgainst(
+        response,
+        taskName,
+        debugLogs,
+        mode,
+        logViolations,
+        pinnedValidationVersion
+      );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "unknown error";
       console.error("Error during schema validation:", errorMessage);
@@ -4503,6 +4484,39 @@ class TaskExecutor {
       };
     }
   }
+  validateResponseSchemaAgainst(response, taskName, debugLogs, mode, logViolations, validationVersion) {
+    const normalizedResponse = this.normalizeResponseForValidation(response, taskName, validationVersion === "v2.5");
+    const outcome = (this.config.experimentalIdentity33?.() || this.config.identity33SchemaExperiment && normalizedResponse && typeof normalizedResponse === "object" && (0, import_adcp_version_config.isAdcpVersionAtLeast)(normalizedResponse.adcp_version, "3.3")) && mode !== "off" ? validateIdentity33Payload(taskName, "response", normalizedResponse, validationVersion) : (0, import_client_hooks.validateIncomingResponse)(taskName, normalizedResponse, mode, void 0, validationVersion);
+    if (outcome.valid) return { valid: true, errors: [] };
+    const errorStrings = outcome.issues.map((i) => `${i.pointer}: ${i.message}`);
+    if (logViolations) {
+      debugLogs.push({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: mode === "strict" ? "error" : "warning",
+        message: `Schema validation ${mode === "strict" ? "failed" : "warning"} for ${taskName}: ${(0, import_schema_validator.formatIssues)(
+          outcome.issues
+        )}`,
+        errors: errorStrings,
+        issues: outcome.issues,
+        schemaVariant: outcome.variant,
+        schemaVersion: validationVersion,
+        mode
+      });
+    }
+    if (mode === "warn") {
+      if (logViolations) {
+        console.warn(
+          `Schema validation failed for ${taskName} against AdCP ${validationVersion} (non-blocking):`,
+          errorStrings
+        );
+      }
+      return { valid: true, errors: [] };
+    }
+    if (logViolations) {
+      console.error(`Schema validation failed for ${taskName} against AdCP ${validationVersion}:`, errorStrings);
+    }
+    return { valid: false, errors: errorStrings };
+  }
   responseAdcpVersionForValidation() {
     if (this.config.versionEnvelope === "major-only") return "3.0";
     return void 0;

package/dist/lib/core/TaskExecutor.mjs

@@ -26,7 +26,7 @@ import {
   resolveValidationModes
 } from "../validation/client-hooks.mjs";
 import { formatIssues } from "../validation/schema-validator.mjs";
-import { resolveServedValidationVersion } from "../validation/schema-loader.mjs";
+import { withServedValidationVersion } from "../validation/schema-loader.mjs";
 import { ADCP_VERSION } from "../version.mjs";
 import { unwrapProtocolResponse, isAdcpOperationSuccess } from "../utils/response-unwrapper.mjs";
 import { extractAdcpErrorInfo, extractCorrelationId } from "../utils/error-extraction.mjs";
@@ -4437,41 +4437,22 @@ class TaskExecutor {
     const mode = this.responseValidationMode;
     const logViolations = this.config.logSchemaViolations !== false;
     try {
-      let validationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? ADCP_VERSION;
-      if (taskName === "get_adcp_capabilities" && validationVersion !== "v2.5") {
-        validationVersion = resolveServedValidationVersion(response, validationVersion);
-      }
-      const normalizedResponse = this.normalizeResponseForValidation(response, taskName, validationVersion === "v2.5");
-      const outcome = (this.config.experimentalIdentity33?.() || this.config.identity33SchemaExperiment && normalizedResponse && typeof normalizedResponse === "object" && isAdcpVersionAtLeast(normalizedResponse.adcp_version, "3.3")) && mode !== "off" ? validateIdentity33Payload(taskName, "response", normalizedResponse, validationVersion) : validateIncomingResponse(taskName, normalizedResponse, mode, void 0, validationVersion);
-      if (outcome.valid) return { valid: true, errors: [] };
-      const errorStrings = outcome.issues.map((i) => `${i.pointer}: ${i.message}`);
-      if (logViolations) {
-        debugLogs.push({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          type: mode === "strict" ? "error" : "warning",
-          message: `Schema validation ${mode === "strict" ? "failed" : "warning"} for ${taskName}: ${formatIssues(
-            outcome.issues
-          )}`,
-          errors: errorStrings,
-          issues: outcome.issues,
-          schemaVariant: outcome.variant,
-          schemaVersion: validationVersion,
-          mode
-        });
-      }
-      if (mode === "warn") {
-        if (logViolations) {
-          console.warn(
-            `Schema validation failed for ${taskName} against AdCP ${validationVersion} (non-blocking):`,
-            errorStrings
-          );
-        }
-        return { valid: true, errors: [] };
-      }
-      if (logViolations) {
-        console.error(`Schema validation failed for ${taskName} against AdCP ${validationVersion}:`, errorStrings);
+      const pinnedValidationVersion = (serverVersion ?? this.lastKnownServerVersion) === "v2" ? "v2.5" : this.responseAdcpVersionForValidation() ?? this.config.adcpVersion ?? ADCP_VERSION;
+      if (taskName === "get_adcp_capabilities" && pinnedValidationVersion !== "v2.5") {
+        return withServedValidationVersion(
+          response,
+          pinnedValidationVersion,
+          (validationVersion) => this.validateResponseSchemaAgainst(response, taskName, debugLogs, mode, logViolations, validationVersion)
+        );
       }
-      return { valid: false, errors: errorStrings };
+      return this.validateResponseSchemaAgainst(
+        response,
+        taskName,
+        debugLogs,
+        mode,
+        logViolations,
+        pinnedValidationVersion
+      );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "unknown error";
       console.error("Error during schema validation:", errorMessage);
@@ -4481,6 +4462,39 @@ class TaskExecutor {
       };
     }
   }
+  validateResponseSchemaAgainst(response, taskName, debugLogs, mode, logViolations, validationVersion) {
+    const normalizedResponse = this.normalizeResponseForValidation(response, taskName, validationVersion === "v2.5");
+    const outcome = (this.config.experimentalIdentity33?.() || this.config.identity33SchemaExperiment && normalizedResponse && typeof normalizedResponse === "object" && isAdcpVersionAtLeast(normalizedResponse.adcp_version, "3.3")) && mode !== "off" ? validateIdentity33Payload(taskName, "response", normalizedResponse, validationVersion) : validateIncomingResponse(taskName, normalizedResponse, mode, void 0, validationVersion);
+    if (outcome.valid) return { valid: true, errors: [] };
+    const errorStrings = outcome.issues.map((i) => `${i.pointer}: ${i.message}`);
+    if (logViolations) {
+      debugLogs.push({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: mode === "strict" ? "error" : "warning",
+        message: `Schema validation ${mode === "strict" ? "failed" : "warning"} for ${taskName}: ${formatIssues(
+          outcome.issues
+        )}`,
+        errors: errorStrings,
+        issues: outcome.issues,
+        schemaVariant: outcome.variant,
+        schemaVersion: validationVersion,
+        mode
+      });
+    }
+    if (mode === "warn") {
+      if (logViolations) {
+        console.warn(
+          `Schema validation failed for ${taskName} against AdCP ${validationVersion} (non-blocking):`,
+          errorStrings
+        );
+      }
+      return { valid: true, errors: [] };
+    }
+    if (logViolations) {
+      console.error(`Schema validation failed for ${taskName} against AdCP ${validationVersion}:`, errorStrings);
+    }
+    return { valid: false, errors: errorStrings };
+  }
   responseAdcpVersionForValidation() {
     if (this.config.versionEnvelope === "major-only") return "3.0";
     return void 0;

package/dist/lib/identifiers.d.mts

@@ -0,0 +1,53 @@
+import type { PropertyIdentifierTypes } from './types/core.generated.mjs';
+export type IdentifierValidationErrorCode = 'invalid_identifier' | 'unsupported_identifier_type' | 'invalid_publisher_domain';
+export declare class IdentifierValidationError extends TypeError {
+    readonly code: IdentifierValidationErrorCode;
+    readonly identifierType: string;
+    readonly name = "IdentifierValidationError";
+    constructor(code: IdentifierValidationErrorCode, identifierType: string, message: string);
+}
+export interface IdentifierRewrite {
+    from: string;
+    to: string;
+}
+export type IdentifierValidationResult = {
+    ok: true;
+    value: string;
+    rewrite?: IdentifierRewrite;
+} | {
+    ok: false;
+    error: IdentifierValidationError;
+};
+/** Validate a registration hostname as supplied. This deliberately does not repair URLs or wildcards. */
+export declare function validatePublisherDomain(value: string): IdentifierValidationResult;
+export declare const normalizeDomainIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeSubdomainIdentifier: (value: string) => IdentifierValidationResult;
+/** Bundle identifiers are case-sensitive; normalization preserves their case. */
+export declare const normalizeIosBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeAndroidPackageIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeAppleAppStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeGooglePlayIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeRokuStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeFireTvAsinIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeSamsungAppIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeAppleTvBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeBundleIdentifier: (value: string) => IdentifierValidationResult;
+/**
+ * Validate and canonicalize an AdCP identifier. Opaque identifier families keep
+ * their spelling and case; only surrounding whitespace is removed. No network
+ * lookup or existence/ownership assertion is performed.
+ */
+export declare function normalizePropertyIdentifier(type: PropertyIdentifierTypes | string, value: string): IdentifierValidationResult;
+/** Validation includes the same explicit rewrite report as normalization. */
+export declare const validatePropertyIdentifier: typeof normalizePropertyIdentifier;
+export declare const validateDomainIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateSubdomainIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateIosBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateAndroidPackageIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateAppleAppStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateGooglePlayIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateRokuStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateFireTvAsinIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateSamsungAppIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateAppleTvBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateBundleIdentifier: (value: string) => IdentifierValidationResult;

package/dist/lib/identifiers.d.ts

@@ -0,0 +1,53 @@
+import type { PropertyIdentifierTypes } from './types/core.generated';
+export type IdentifierValidationErrorCode = 'invalid_identifier' | 'unsupported_identifier_type' | 'invalid_publisher_domain';
+export declare class IdentifierValidationError extends TypeError {
+    readonly code: IdentifierValidationErrorCode;
+    readonly identifierType: string;
+    readonly name = "IdentifierValidationError";
+    constructor(code: IdentifierValidationErrorCode, identifierType: string, message: string);
+}
+export interface IdentifierRewrite {
+    from: string;
+    to: string;
+}
+export type IdentifierValidationResult = {
+    ok: true;
+    value: string;
+    rewrite?: IdentifierRewrite;
+} | {
+    ok: false;
+    error: IdentifierValidationError;
+};
+/** Validate a registration hostname as supplied. This deliberately does not repair URLs or wildcards. */
+export declare function validatePublisherDomain(value: string): IdentifierValidationResult;
+export declare const normalizeDomainIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeSubdomainIdentifier: (value: string) => IdentifierValidationResult;
+/** Bundle identifiers are case-sensitive; normalization preserves their case. */
+export declare const normalizeIosBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeAndroidPackageIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeAppleAppStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeGooglePlayIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeRokuStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeFireTvAsinIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeSamsungAppIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeAppleTvBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const normalizeBundleIdentifier: (value: string) => IdentifierValidationResult;
+/**
+ * Validate and canonicalize an AdCP identifier. Opaque identifier families keep
+ * their spelling and case; only surrounding whitespace is removed. No network
+ * lookup or existence/ownership assertion is performed.
+ */
+export declare function normalizePropertyIdentifier(type: PropertyIdentifierTypes | string, value: string): IdentifierValidationResult;
+/** Validation includes the same explicit rewrite report as normalization. */
+export declare const validatePropertyIdentifier: typeof normalizePropertyIdentifier;
+export declare const validateDomainIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateSubdomainIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateIosBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateAndroidPackageIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateAppleAppStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateGooglePlayIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateRokuStoreIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateFireTvAsinIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateSamsungAppIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateAppleTvBundleIdentifier: (value: string) => IdentifierValidationResult;
+export declare const validateBundleIdentifier: (value: string) => IdentifierValidationResult;