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

package/dist/lib/identifiers.mjs

@@ -0,0 +1,163 @@
+import { isIP } from "node:net";
+import { domainToASCII } from "node:url";
+class IdentifierValidationError extends TypeError {
+  constructor(code, identifierType, message) {
+    super(message);
+    this.code = code;
+    this.identifierType = identifierType;
+  }
+  code;
+  identifierType;
+  name = "IdentifierValidationError";
+}
+const PUBLISHER_DOMAIN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/;
+function isDomain(value) {
+  if (value.length > 253 || !PUBLISHER_DOMAIN.test(value) || value.split(".").some((label) => label.length > 63) || isIP(value))
+    return false;
+  try {
+    return !isIP(new URL(`https://${value}`).hostname);
+  } catch {
+    return false;
+  }
+}
+function accepted(input, value) {
+  return { ok: true, value, ...input === value ? {} : { rewrite: { from: input, to: value } } };
+}
+function rejected(type, code = "invalid_identifier") {
+  return {
+    ok: false,
+    error: new IdentifierValidationError(
+      code,
+      type,
+      code === "invalid_publisher_domain" ? "publisher_domain must be a canonical lowercase hostname without wildcards, URLs, or IP addresses" : `Invalid ${type} identifier`
+    )
+  };
+}
+function validatePublisherDomain(value) {
+  return typeof value === "string" && isDomain(value) ? accepted(value, value) : rejected("publisher_domain", "invalid_publisher_domain");
+}
+function normalizeHostname(input, type) {
+  if (typeof input !== "string") return rejected(type);
+  let value = input.trim();
+  if (/^https?:\/\//i.test(value)) {
+    try {
+      const url = new URL(value);
+      if (url.username || url.password) return rejected(type);
+      value = url.hostname;
+    } catch {
+      return rejected(type);
+    }
+  }
+  const wildcard = value.startsWith("*.");
+  if (wildcard && type !== "domain") return rejected(type);
+  if (/[\s/\\:@?#%]/.test(wildcard ? value.slice(2) : value)) return rejected(type);
+  const host = domainToASCII((wildcard ? value.slice(2) : value).toLowerCase().replace(/\.$/, ""));
+  if (!isDomain(host)) return rejected(type);
+  return accepted(input, `${wildcard ? "*." : ""}${host}`);
+}
+const normalizeDomainIdentifier = (value) => normalizeHostname(value, "domain");
+const normalizeSubdomainIdentifier = (value) => normalizeHostname(value, "subdomain");
+function normalizePattern(type, input, pattern, uppercase = false) {
+  if (typeof input !== "string") return rejected(type);
+  const value = uppercase ? input.trim().toUpperCase() : input.trim();
+  return pattern.test(value) ? accepted(input, value) : rejected(type);
+}
+const normalizeIosBundleIdentifier = (value) => normalizePattern("ios_bundle", value, /^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+$/);
+const normalizeAndroidPackageIdentifier = (value) => normalizePattern("android_package", value, /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/);
+const normalizeAppleAppStoreIdentifier = (value) => normalizePattern("apple_app_store_id", value, /^[1-9][0-9]*$/);
+const normalizeGooglePlayIdentifier = (value) => normalizePattern("google_play_id", value, /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)+$/);
+const normalizeRokuStoreIdentifier = (value) => normalizePattern("roku_store_id", value, /^[1-9][0-9]*$/);
+const normalizeFireTvAsinIdentifier = (value) => normalizePattern("fire_tv_asin", value, /^[A-Z0-9]{10}$/, true);
+const normalizeSamsungAppIdentifier = (value) => normalizePattern("samsung_app_id", value, /^[A-Za-z0-9._-]+$/);
+const normalizeAppleTvBundleIdentifier = (value) => normalizePattern("apple_tv_bundle", value, /^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+$/);
+const normalizeBundleIdentifier = (value) => normalizePattern("bundle_id", value, /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)+$/);
+function normalizePropertyIdentifier(type, value) {
+  switch (type) {
+    case "domain":
+      return normalizeDomainIdentifier(value);
+    case "subdomain":
+      return normalizeSubdomainIdentifier(value);
+    case "ios_bundle":
+      return normalizeIosBundleIdentifier(value);
+    case "android_package":
+      return normalizeAndroidPackageIdentifier(value);
+    case "apple_app_store_id":
+      return normalizeAppleAppStoreIdentifier(value);
+    case "google_play_id":
+      return normalizeGooglePlayIdentifier(value);
+    case "roku_store_id":
+      return normalizeRokuStoreIdentifier(value);
+    case "fire_tv_asin":
+      return normalizeFireTvAsinIdentifier(value);
+    case "samsung_app_id":
+      return normalizeSamsungAppIdentifier(value);
+    case "apple_tv_bundle":
+      return normalizeAppleTvBundleIdentifier(value);
+    case "bundle_id":
+      return normalizeBundleIdentifier(value);
+    case "apple_podcast_id":
+      return normalizePattern(type, value, /^[1-9][0-9]*$/);
+    case "rss_url": {
+      if (typeof value !== "string") return rejected(type);
+      try {
+        const url = new URL(value.trim());
+        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || !isDomain(url.hostname))
+          return rejected(type);
+        return accepted(value, url.toString());
+      } catch {
+        return rejected(type);
+      }
+    }
+    case "network_id":
+    case "venue_id":
+    case "screen_id":
+    case "openooh_venue_type":
+    case "spotify_collection_id":
+    case "podcast_guid":
+    case "station_id":
+    case "facility_id":
+      return normalizePattern(type, value, /^[^\x00-\x1f\x7f]+$/);
+    default:
+      return rejected(type, "unsupported_identifier_type");
+  }
+}
+const validatePropertyIdentifier = normalizePropertyIdentifier;
+const validateDomainIdentifier = normalizeDomainIdentifier;
+const validateSubdomainIdentifier = normalizeSubdomainIdentifier;
+const validateIosBundleIdentifier = normalizeIosBundleIdentifier;
+const validateAndroidPackageIdentifier = normalizeAndroidPackageIdentifier;
+const validateAppleAppStoreIdentifier = normalizeAppleAppStoreIdentifier;
+const validateGooglePlayIdentifier = normalizeGooglePlayIdentifier;
+const validateRokuStoreIdentifier = normalizeRokuStoreIdentifier;
+const validateFireTvAsinIdentifier = normalizeFireTvAsinIdentifier;
+const validateSamsungAppIdentifier = normalizeSamsungAppIdentifier;
+const validateAppleTvBundleIdentifier = normalizeAppleTvBundleIdentifier;
+const validateBundleIdentifier = normalizeBundleIdentifier;
+export {
+  IdentifierValidationError,
+  normalizeAndroidPackageIdentifier,
+  normalizeAppleAppStoreIdentifier,
+  normalizeAppleTvBundleIdentifier,
+  normalizeBundleIdentifier,
+  normalizeDomainIdentifier,
+  normalizeFireTvAsinIdentifier,
+  normalizeGooglePlayIdentifier,
+  normalizeIosBundleIdentifier,
+  normalizePropertyIdentifier,
+  normalizeRokuStoreIdentifier,
+  normalizeSamsungAppIdentifier,
+  normalizeSubdomainIdentifier,
+  validateAndroidPackageIdentifier,
+  validateAppleAppStoreIdentifier,
+  validateAppleTvBundleIdentifier,
+  validateBundleIdentifier,
+  validateDomainIdentifier,
+  validateFireTvAsinIdentifier,
+  validateGooglePlayIdentifier,
+  validateIosBundleIdentifier,
+  validatePropertyIdentifier,
+  validatePublisherDomain,
+  validateRokuStoreIdentifier,
+  validateSamsungAppIdentifier,
+  validateSubdomainIdentifier
+};

package/dist/lib/index.d.mts

@@ -1,3 +1,5 @@
+export * from './identifiers.mjs';
+export type { ResolveIdentifiersAllOptions, ResolveIdentifierOutcome } from './registry/index.mjs';
 export { RegistryClient, RegistryRequestError, isRegistryRequestError, RegistrySync, PropertyRegistry, InMemoryCursorStore, FileCursorStore, buildCommunityMirrorAdagents, } from './registry/index.mjs';
 export type { RegistrySyncConfig, RegistrySyncState, RegistrySyncTransport, RegistrySyncEvents, AgentFilter, RegistrySyncProperty, CursorStore, PropertyRegistryConfig, FeedStreamQuery, FeedStreamMessage, FeedHeartbeat, FeedStreamErrorData, OpenFeedStreamOptions, FeedFreshness, } from './registry/index.mjs';
 export { openFeedStream, parseSseStream, sanitizeStreamText, DEFAULT_MAX_SSE_FRAME_BYTES, FeedStreamError, FeedStreamUnsupportedError, FeedStreamCursorExpiredError, FeedStreamHttpError, FeedStreamParseError, } from './registry/index.mjs';
@@ -57,7 +59,7 @@ export { MemoryStorage, createMemoryStorage, createMemoryStorageConfig } from '.
 export { ADCPError, TaskTimeoutError, MaxClarificationError, DeferredTaskError, TaskAbortedError, AgentNotFoundError, UnsupportedTaskError, ProtocolError, ValidationError as ADCPValidationError, // Rename to avoid conflict
 MissingInputHandlerError, InvalidContextError, ConfigurationError, AuthenticationCredentialsRejectedError, AuthenticationRequiredError, FeatureUnsupportedError, ProtocolFeatureUnsupportedError, UnsupportedBuyingModeError, AccountRequiredError, AccountPendingApprovalError, AccountAmbiguousError, BuyerSetupError, AccountNotFoundError, AccountSetupRequiredError, AccountPaymentRequiredError, AccountNotProvisionedError, SDK_ERROR_TO_PROTOCOL_ERROR_CODE, VersionUnsupportedError, IdempotencyConflictError, IdempotencyExpiredError, ResponseTooLargeError, ActionNotAllowedError, adcpErrorToTypedError, getClientPreflightAdcpError, isADCPError, isErrorOfType, extractErrorInfo, is401Error, mapSdkErrorCodeToProtocolErrorCode, } from './errors/index.mjs';
 export type { OAuthMetadataInfo, ClientPreflightAdcpErrorInfo, ClientPreflightAdcpErrorRecovery, FeatureUnsupportedErrorOptions, ProtocolFeatureUnsupportedErrorOptions, ActionNotAllowedErrorDetails, ActionNotAllowedReasonValue, ActionNotAllowedAttemptedAction, ActionNotAllowedAvailableAction, ActionNotAllowedRecovery, } from './errors/index.mjs';
-export type { ActionNotAllowedDetails, ActionNotAllowedReason, AvailableActionsResult, AvailableActionsSource, DecomposedUpdateMediaBuy, DecomposedUpdateMediaBuyMutation, LegacyCoarseAction, MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, MediaBuyAvailableAction, MediaBuyMutationDirection, MediaBuyMutationScope, MediaBuyUpdateFieldAction, MediaBuyValidAction, ModeMismatchRecovery, PreflightAllowed, PreflightDenial, PreflightDenied, BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, PreflightResult, ResolvedAction, SLAWindow, SlaWindow, StructuredOnlyMediaBuyAction, ResolvedTargetingInput, TargetingInputFor, ValidateProductsAgainstPropertyPolicyOptions, UpdateFieldEntry, UpdateMediaBuyRequestLike, } from './media-buy/index.mjs';
+export type { ActionNotAllowedDetails, ActionNotAllowedReason, AvailableActionsResult, AvailableActionsSource, DecomposedUpdateMediaBuy, DecomposedUpdateMediaBuyMutation, LegacyCoarseAction, MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, MediaBuyAvailableAction, MediaBuyMutationDirection, MediaBuyMutationScope, MediaBuyUpdateFieldAction, MediaBuyValidAction, ModeMismatchRecovery, PreflightAllowed, PreflightDenial, PreflightDenied, BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPolicyResolvedProperty, ProductPropertyPolicyIdentifier, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, PreflightResult, ResolvedAction, SLAWindow, SlaWindow, StructuredOnlyMediaBuyAction, ResolvedTargetingInput, TargetingInputFor, ValidateProductsAgainstPropertyPolicyOptions, UpdateFieldEntry, UpdateMediaBuyRequestLike, } from './media-buy/index.mjs';
 export { ACTIONS_BY_FIELD, LEGACY_COARSE_ACTIONS, STRUCTURED_ONLY_MEDIA_BUY_ACTIONS, UPDATE_FIELDS_BY_ACTION, applyTargetingInput, hasTargetingClears, resolveTargetingInput, canAddPackages, canCancel, canDecreaseBudget, canExtendFlight, canIncreaseBudget, canPause, canReallocateBudget, canRemoveCreative, canRemovePackages, canReplaceCreative, canResume, canShortenFlight, canUpdateCreativeAssignments, canUpdateFlightDates, canUpdateFrequencyCaps, canUpdatePacing, canUpdateTargeting, decomposeUpdateMediaBuy, findAvailableAction, getActionForMutation, getAvailableActions, getRollupParent, ProductPropertyPolicyError, normalizeDomainForPropertyPolicy, preflightUpdateMediaBuy, recoveryForModeMismatch, validateProductsAgainstPropertyPolicy, } from './media-buy/index.mjs';
 export { InputRequiredError } from './core/TaskExecutor.mjs';
 export { generateIdempotencyKey, isMutatingTask, requestUsesIdempotency, isValidIdempotencyKey, useIdempotencyKey, redactIdempotencyKey, IDEMPOTENCY_KEY_PATTERN, MUTATING_TASKS, } from './utils/idempotency.mjs';

package/dist/lib/index.d.ts

@@ -1,3 +1,5 @@
+export * from './identifiers';
+export type { ResolveIdentifiersAllOptions, ResolveIdentifierOutcome } from './registry';
 export { RegistryClient, RegistryRequestError, isRegistryRequestError, RegistrySync, PropertyRegistry, InMemoryCursorStore, FileCursorStore, buildCommunityMirrorAdagents, } from './registry';
 export type { RegistrySyncConfig, RegistrySyncState, RegistrySyncTransport, RegistrySyncEvents, AgentFilter, RegistrySyncProperty, CursorStore, PropertyRegistryConfig, FeedStreamQuery, FeedStreamMessage, FeedHeartbeat, FeedStreamErrorData, OpenFeedStreamOptions, FeedFreshness, } from './registry';
 export { openFeedStream, parseSseStream, sanitizeStreamText, DEFAULT_MAX_SSE_FRAME_BYTES, FeedStreamError, FeedStreamUnsupportedError, FeedStreamCursorExpiredError, FeedStreamHttpError, FeedStreamParseError, } from './registry';
@@ -57,7 +59,7 @@ export { MemoryStorage, createMemoryStorage, createMemoryStorageConfig } from '.
 export { ADCPError, TaskTimeoutError, MaxClarificationError, DeferredTaskError, TaskAbortedError, AgentNotFoundError, UnsupportedTaskError, ProtocolError, ValidationError as ADCPValidationError, // Rename to avoid conflict
 MissingInputHandlerError, InvalidContextError, ConfigurationError, AuthenticationCredentialsRejectedError, AuthenticationRequiredError, FeatureUnsupportedError, ProtocolFeatureUnsupportedError, UnsupportedBuyingModeError, AccountRequiredError, AccountPendingApprovalError, AccountAmbiguousError, BuyerSetupError, AccountNotFoundError, AccountSetupRequiredError, AccountPaymentRequiredError, AccountNotProvisionedError, SDK_ERROR_TO_PROTOCOL_ERROR_CODE, VersionUnsupportedError, IdempotencyConflictError, IdempotencyExpiredError, ResponseTooLargeError, ActionNotAllowedError, adcpErrorToTypedError, getClientPreflightAdcpError, isADCPError, isErrorOfType, extractErrorInfo, is401Error, mapSdkErrorCodeToProtocolErrorCode, } from './errors';
 export type { OAuthMetadataInfo, ClientPreflightAdcpErrorInfo, ClientPreflightAdcpErrorRecovery, FeatureUnsupportedErrorOptions, ProtocolFeatureUnsupportedErrorOptions, ActionNotAllowedErrorDetails, ActionNotAllowedReasonValue, ActionNotAllowedAttemptedAction, ActionNotAllowedAvailableAction, ActionNotAllowedRecovery, } from './errors';
-export type { ActionNotAllowedDetails, ActionNotAllowedReason, AvailableActionsResult, AvailableActionsSource, DecomposedUpdateMediaBuy, DecomposedUpdateMediaBuyMutation, LegacyCoarseAction, MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, MediaBuyAvailableAction, MediaBuyMutationDirection, MediaBuyMutationScope, MediaBuyUpdateFieldAction, MediaBuyValidAction, ModeMismatchRecovery, PreflightAllowed, PreflightDenial, PreflightDenied, BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, PreflightResult, ResolvedAction, SLAWindow, SlaWindow, StructuredOnlyMediaBuyAction, ResolvedTargetingInput, TargetingInputFor, ValidateProductsAgainstPropertyPolicyOptions, UpdateFieldEntry, UpdateMediaBuyRequestLike, } from './media-buy';
+export type { ActionNotAllowedDetails, ActionNotAllowedReason, AvailableActionsResult, AvailableActionsSource, DecomposedUpdateMediaBuy, DecomposedUpdateMediaBuyMutation, LegacyCoarseAction, MediaBuyActionContext, MediaBuyActionId, MediaBuyActionMode, MediaBuyAvailableAction, MediaBuyMutationDirection, MediaBuyMutationScope, MediaBuyUpdateFieldAction, MediaBuyValidAction, ModeMismatchRecovery, PreflightAllowed, PreflightDenial, PreflightDenied, BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPolicyResolvedProperty, ProductPropertyPolicyIdentifier, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, PreflightResult, ResolvedAction, SLAWindow, SlaWindow, StructuredOnlyMediaBuyAction, ResolvedTargetingInput, TargetingInputFor, ValidateProductsAgainstPropertyPolicyOptions, UpdateFieldEntry, UpdateMediaBuyRequestLike, } from './media-buy';
 export { ACTIONS_BY_FIELD, LEGACY_COARSE_ACTIONS, STRUCTURED_ONLY_MEDIA_BUY_ACTIONS, UPDATE_FIELDS_BY_ACTION, applyTargetingInput, hasTargetingClears, resolveTargetingInput, canAddPackages, canCancel, canDecreaseBudget, canExtendFlight, canIncreaseBudget, canPause, canReallocateBudget, canRemoveCreative, canRemovePackages, canReplaceCreative, canResume, canShortenFlight, canUpdateCreativeAssignments, canUpdateFlightDates, canUpdateFrequencyCaps, canUpdatePacing, canUpdateTargeting, decomposeUpdateMediaBuy, findAvailableAction, getActionForMutation, getAvailableActions, getRollupParent, ProductPropertyPolicyError, normalizeDomainForPropertyPolicy, preflightUpdateMediaBuy, recoveryForModeMismatch, validateProductsAgainstPropertyPolicy, } from './media-buy';
 export { InputRequiredError } from './core/TaskExecutor';
 export { generateIdempotencyKey, isMutatingTask, requestUsesIdempotency, isValidIdempotencyKey, useIdempotencyKey, redactIdempotencyKey, IDEMPOTENCY_KEY_PATTERN, MUTATING_TASKS, } from './utils/idempotency';

package/dist/lib/index.js

@@ -735,6 +735,7 @@ __export(index_exports, {
   withSpan: () => import_observability.withSpan
 });
 module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require('./identifiers.js'), module.exports);
 var import_registry = require('./registry/index.js');
 var import_registry2 = require('./registry/index.js');
 var import_brand = require('./brand/index.js');
@@ -1583,6 +1584,7 @@ function createAdCPClientFromEnv() {
   withAdditiveCanonicalFormatOptions,
   withMCPConnectionScope,
   withSpan,
+  ...require('./identifiers.js'),
   ...require('./principal/index.js'),
   ...require('./handlers/types.js'),
   ...require('./negotiation/index.js'),

package/dist/lib/index.mjs

@@ -1,3 +1,4 @@
+export * from "./identifiers.mjs";
 import {
   RegistryClient,
   RegistryRequestError,

package/dist/lib/media-buy/index.d.mts

@@ -4,7 +4,7 @@ export { LEGACY_COARSE_ACTIONS } from './types.mjs';
 export type { LiveMediaBuyAction } from './action-types.mjs';
 export type { AvailableActionsResult, AvailableActionsSource } from './available-actions.mjs';
 export { findAvailableAction, getAvailableActions, getRollupParent, __resetValidActionsWarningForTests, } from './available-actions.mjs';
-export type { BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, ValidateProductsAgainstPropertyPolicyOptions, } from './property-policy.mjs';
+export type { BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPolicyResolvedProperty, ProductPropertyPolicyIdentifier, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, ValidateProductsAgainstPropertyPolicyOptions, } from './property-policy.mjs';
 export { ProductPropertyPolicyError, normalizeDomainForPropertyPolicy, validateProductsAgainstPropertyPolicy, } from './property-policy.mjs';
 export type { DecomposedUpdateMediaBuy, DecomposedUpdateMediaBuyMutation, MediaBuyMutationDirection, MediaBuyMutationScope, ModeMismatchRecovery, PreflightAllowed, PreflightDenial, PreflightDenied, PreflightResult, ResolvedAction, } from './preflight.mjs';
 export { canAddPackages, canCancel, canDecreaseBudget, canExtendFlight, canIncreaseBudget, canPause, canReallocateBudget, canRemoveCreative, canRemovePackages, canReplaceCreative, canResume, canShortenFlight, canUpdateCreativeAssignments, canUpdateFlightDates, canUpdateFrequencyCaps, canUpdatePacing, canUpdateTargeting, decomposeUpdateMediaBuy, getActionForMutation, preflightUpdateMediaBuy, recoveryForModeMismatch, } from './preflight.mjs';

package/dist/lib/media-buy/index.d.ts

@@ -4,7 +4,7 @@ export { LEGACY_COARSE_ACTIONS } from './types';
 export type { LiveMediaBuyAction } from './action-types';
 export type { AvailableActionsResult, AvailableActionsSource } from './available-actions';
 export { findAvailableAction, getAvailableActions, getRollupParent, __resetValidActionsWarningForTests, } from './available-actions';
-export type { BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, ValidateProductsAgainstPropertyPolicyOptions, } from './property-policy';
+export type { BuyerPropertyPolicy, NormalizedPolicyDomain, ProductPolicyProductLike, ProductPolicyResolvedProperty, ProductPropertyPolicyIdentifier, ProductPropertyPolicyDiagnostic, ProductPropertyPolicyDiagnosticCode, ProductPropertyPolicyDiagnosticSeverity, ProductPropertyPolicyMode, ProductPropertyPolicySelectorBehavior, ProductPropertyPolicyValidationResult, ValidateProductsAgainstPropertyPolicyOptions, } from './property-policy';
 export { ProductPropertyPolicyError, normalizeDomainForPropertyPolicy, validateProductsAgainstPropertyPolicy, } from './property-policy';
 export type { DecomposedUpdateMediaBuy, DecomposedUpdateMediaBuyMutation, MediaBuyMutationDirection, MediaBuyMutationScope, ModeMismatchRecovery, PreflightAllowed, PreflightDenial, PreflightDenied, PreflightResult, ResolvedAction, } from './preflight';
 export { canAddPackages, canCancel, canDecreaseBudget, canExtendFlight, canIncreaseBudget, canPause, canReallocateBudget, canRemoveCreative, canRemovePackages, canReplaceCreative, canResume, canShortenFlight, canUpdateCreativeAssignments, canUpdateFlightDates, canUpdateFrequencyCaps, canUpdatePacing, canUpdateTargeting, decomposeUpdateMediaBuy, getActionForMutation, preflightUpdateMediaBuy, recoveryForModeMismatch, } from './preflight';

package/dist/lib/media-buy/property-policy.d.mts

@@ -1,3 +1,4 @@
+export declare function isSupportedPropertyIdentifierType(type: string): boolean;
 export type ProductPropertyPolicyMode = 'audit' | 'filter' | 'reject_response';
 export type ProductPropertyPolicySelectorBehavior = 'allow' | 'flag' | 'reject';
 export interface BuyerPropertyPolicy {
@@ -10,6 +11,13 @@ export interface BuyerPropertyPolicy {
      * `*.example.com` matches subdomains only).
      */
     allowedPropertyIdentifiers?: readonly ProductPropertyPolicyIdentifier[];
+    /**
+     * Complete publisher catalogs, keyed by canonical publisher domain. Enables
+     * app/CTV identifier matching for all/by_id/by_tag selectors. Omitted keys
+     * mean unresolved metadata; an empty array means a known empty catalog.
+     * Property IDs remain publisher-scoped and are never treated as app IDs.
+     */
+    publisherProperties?: Readonly<Record<string, readonly ProductPolicyResolvedProperty[] | undefined>>;
     /**
      * Require products to match the allowed domain/identifier set even when that
      * set is empty. Used when a request property_list resolves successfully to
@@ -56,7 +64,12 @@ export interface ProductPropertyPolicyIdentifier {
     type: string;
     value: string;
 }
-export type ProductPropertyPolicyDiagnosticCode = 'outside_property_list' | 'excluded_domain' | 'excluded_property_id' | 'missing_publisher_properties' | 'unresolved_tag_selector' | 'unknown_selector' | 'malformed_publisher_domain';
+export interface ProductPolicyResolvedProperty {
+    property_id?: string;
+    identifiers: readonly ProductPropertyPolicyIdentifier[];
+    tags?: readonly string[];
+}
+export type ProductPropertyPolicyDiagnosticCode = 'outside_property_list' | 'excluded_domain' | 'excluded_property_id' | 'missing_publisher_properties' | 'unresolved_tag_selector' | 'unknown_selector' | 'malformed_publisher_domain' | 'unresolved_property_identifiers' | 'excluded_resolved_property';
 export type ProductPropertyPolicyDiagnosticSeverity = 'rejected' | 'flagged';
 export interface ProductPropertyPolicyDiagnostic {
     code: ProductPropertyPolicyDiagnosticCode;
@@ -75,6 +88,7 @@ export interface ProductPropertyPolicyDiagnostic {
     matched_excluded_domain?: string;
     property_ids?: string[];
     matched_property_ids?: string[];
+    identifier_types?: string[];
 }
 export interface ProductPropertyPolicyValidationResult<TProduct extends ProductPolicyProductLike> {
     mode: ProductPropertyPolicyMode;

package/dist/lib/media-buy/property-policy.d.ts

@@ -1,3 +1,4 @@
+export declare function isSupportedPropertyIdentifierType(type: string): boolean;
 export type ProductPropertyPolicyMode = 'audit' | 'filter' | 'reject_response';
 export type ProductPropertyPolicySelectorBehavior = 'allow' | 'flag' | 'reject';
 export interface BuyerPropertyPolicy {
@@ -10,6 +11,13 @@ export interface BuyerPropertyPolicy {
      * `*.example.com` matches subdomains only).
      */
     allowedPropertyIdentifiers?: readonly ProductPropertyPolicyIdentifier[];
+    /**
+     * Complete publisher catalogs, keyed by canonical publisher domain. Enables
+     * app/CTV identifier matching for all/by_id/by_tag selectors. Omitted keys
+     * mean unresolved metadata; an empty array means a known empty catalog.
+     * Property IDs remain publisher-scoped and are never treated as app IDs.
+     */
+    publisherProperties?: Readonly<Record<string, readonly ProductPolicyResolvedProperty[] | undefined>>;
     /**
      * Require products to match the allowed domain/identifier set even when that
      * set is empty. Used when a request property_list resolves successfully to
@@ -56,7 +64,12 @@ export interface ProductPropertyPolicyIdentifier {
     type: string;
     value: string;
 }
-export type ProductPropertyPolicyDiagnosticCode = 'outside_property_list' | 'excluded_domain' | 'excluded_property_id' | 'missing_publisher_properties' | 'unresolved_tag_selector' | 'unknown_selector' | 'malformed_publisher_domain';
+export interface ProductPolicyResolvedProperty {
+    property_id?: string;
+    identifiers: readonly ProductPropertyPolicyIdentifier[];
+    tags?: readonly string[];
+}
+export type ProductPropertyPolicyDiagnosticCode = 'outside_property_list' | 'excluded_domain' | 'excluded_property_id' | 'missing_publisher_properties' | 'unresolved_tag_selector' | 'unknown_selector' | 'malformed_publisher_domain' | 'unresolved_property_identifiers' | 'excluded_resolved_property';
 export type ProductPropertyPolicyDiagnosticSeverity = 'rejected' | 'flagged';
 export interface ProductPropertyPolicyDiagnostic {
     code: ProductPropertyPolicyDiagnosticCode;
@@ -75,6 +88,7 @@ export interface ProductPropertyPolicyDiagnostic {
     matched_excluded_domain?: string;
     property_ids?: string[];
     matched_property_ids?: string[];
+    identifier_types?: string[];
 }
 export interface ProductPropertyPolicyValidationResult<TProduct extends ProductPolicyProductLike> {
     mode: ProductPropertyPolicyMode;

package/dist/lib/media-buy/property-policy.js

@@ -19,10 +19,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var property_policy_exports = {};
 __export(property_policy_exports, {
   ProductPropertyPolicyError: () => ProductPropertyPolicyError,
+  isSupportedPropertyIdentifierType: () => isSupportedPropertyIdentifierType,
   normalizeDomainForPropertyPolicy: () => normalizeDomainForPropertyPolicy,
   validateProductsAgainstPropertyPolicy: () => validateProductsAgainstPropertyPolicy
 });
 module.exports = __toCommonJS(property_policy_exports);
+var import_enums = require('../types/enums.generated.js');
+function isSupportedPropertyIdentifierType(type) {
+  return import_enums.PropertyIdentifierTypesValues.includes(type);
+}
 class ProductPropertyPolicyError extends Error {
   constructor(result) {
     super(
@@ -82,6 +87,8 @@ function compilePolicy(policy) {
   }
   return {
     allowedDomains,
+    publisherCatalogsConfigured: policy.publisherProperties !== void 0,
+    publisherProperties: policy.publisherProperties ?? {},
     allowedPropertyIdentifiers: [...policy.allowedPropertyIdentifiers ?? []],
     requireAllowedPropertyMatch: policy.requireAllowedPropertyMatch ?? Boolean(policy.allowedDomains?.length || policy.allowedPropertyIdentifiers?.length),
     excludedDomainsByComparable,
@@ -116,6 +123,18 @@ function diagnosticsForProduct(product, productIndex, policy) {
       hasEligibleSubsetSelector = true;
     }
   });
+  if (requiresSubsetMatch) {
+    const scopes = publisherProperties.flatMap(
+      (selector) => selector && typeof selector === "object" && !Array.isArray(selector) ? [identifierScopeForSelector(selector, policy)] : []
+    );
+    if (scopes.some((scope) => scope?.hasNonMatch) && !scopes.some((scope) => scope?.hasMatch))
+      hasEligibleSubsetSelector = false;
+  }
+  if (requiresSubsetMatch && hasEligibleSubsetSelector) {
+    for (const diagnostic of diagnostics) {
+      if (diagnostic.code === "unresolved_property_identifiers") diagnostic.severity = "flagged";
+    }
+  }
   if (requiresSubsetMatch && !hasEligibleSubsetSelector) {
     diagnostics.push({
       code: "outside_property_list",
@@ -141,6 +160,7 @@ function diagnosticsForSelector(rawSelector, productIndex, selectorIndex, produc
     });
   }
   const selector = rawSelector;
+  const identifierScope = identifierScopeForSelector(selector, policy);
   const selectionType = typeof selector.selection_type === "string" ? selector.selection_type : void 0;
   const domainCandidates = publisherDomainCandidates(selector, path);
   const normalizedDomains = domainCandidates.map((candidate) => ({ candidate, normalized: normalizeDomainForPropertyPolicy(candidate.raw) })).filter(
@@ -192,7 +212,27 @@ function diagnosticsForSelector(rawSelector, productIndex, selectorIndex, produc
   }
   for (const { candidate, normalized: normalizedDomain } of normalizedDomains) {
     const matchedAllowedDomain = matchedAllowedDomainForCandidate(normalizedDomain, policy);
-    if (options.enforceEveryDomainInAllowedScope && hasAllowedPropertyScope(policy) && !matchedAllowedDomain) {
+    const needsCatalogForExclusions = policy.publisherCatalogsConfigured && (policy.excludedDomainsByComparable.size > 0 || selectionType !== "by_id" && policy.excludedPropertyIds.size > 0);
+    if ((hasAllowedPropertyScope(policy) || selectionType === "by_tag" || needsCatalogForExclusions) && identifierScope?.unknown) {
+      diagnostics.push(
+        ...diagnosticForBehavior(policy.unknownSelectorBehavior, {
+          code: "unresolved_property_identifiers",
+          identifier_types: [
+            ...new Set(
+              policy.allowedPropertyIdentifiers.filter((identifier) => identifier.type !== "domain" && identifier.type !== "subdomain").map((identifier) => identifier.type)
+            )
+          ],
+          message: "Publisher property identifiers could not be resolved; property-list membership is unknown.",
+          product_index: productIndex,
+          product_id: productId,
+          path,
+          publisher_property_index: selectorIndex,
+          selection_type: selectionType,
+          publisher_domain: candidate.raw
+        })
+      );
+    }
+    if (options.enforceEveryDomainInAllowedScope && hasAllowedPropertyScope(policy) && (identifierScope ? identifierScope.hasNonMatch : !matchedAllowedDomain)) {
       diagnostics.push({
         code: "outside_property_list",
         severity: "rejected",
@@ -227,6 +267,19 @@ function diagnosticsForSelector(rawSelector, productIndex, selectorIndex, produc
       });
     }
   }
+  if (options.enforceExclusions && identifierScope?.hasExcludedProperty) {
+    diagnostics.push({
+      code: "excluded_resolved_property",
+      severity: "rejected",
+      message: "Resolved publisher properties include a buyer-excluded property.",
+      product_index: productIndex,
+      product_id: productId,
+      path,
+      publisher_property_index: selectorIndex,
+      selection_type: selectionType,
+      publisher_domain: domainCandidates[0]?.raw
+    });
+  }
   if (selectionType === "by_id") {
     const propertyIds = stringArray(selector.property_ids);
     const matchedPropertyIds = propertyIds.filter((id) => policy.excludedPropertyIds.has(id));
@@ -248,7 +301,7 @@ function diagnosticsForSelector(rawSelector, productIndex, selectorIndex, produc
         matched_property_ids: matchedPropertyIds
       });
     }
-  } else if (selectionType === "by_tag") {
+  } else if (selectionType === "by_tag" && !identifierScope) {
     diagnostics.push(
       ...diagnosticForBehavior(policy.unknownSelectorBehavior, {
         code: "unresolved_tag_selector",
@@ -264,7 +317,7 @@ function diagnosticsForSelector(rawSelector, productIndex, selectorIndex, produc
         normalized_domains: normalizedDomains.map((entry) => entry.normalized.host)
       })
     );
-  } else if (selectionType !== "all") {
+  } else if (selectionType !== "all" && selectionType !== "by_tag") {
     diagnostics.push(
       ...diagnosticForBehavior(policy.unknownSelectorBehavior, {
         code: "unknown_selector",
@@ -291,6 +344,14 @@ function selectorIsEligibleForSubsetTargeting(rawSelector, productIndex, selecto
   if (!rawSelector || typeof rawSelector !== "object" || Array.isArray(rawSelector)) return false;
   const selector = rawSelector;
   if (selector.publisher_domains !== void 0) return false;
+  const identifierScope = identifierScopeForSelector(selector, policy);
+  if (identifierScope) {
+    const domain = typeof selector.publisher_domain === "string" ? normalizeDomainForPropertyPolicy(selector.publisher_domain) : void 0;
+    if (!domain || policy.excludedDomainsByComparable.has(domain.comparable)) return false;
+    if (selector.selection_type !== "all" && selector.selection_type !== "by_id" && selector.selection_type !== "by_tag")
+      return false;
+    return identifierScope.hasMatch || identifierScope.unknown && !identifierScope.hasNonMatch && policy.unknownSelectorBehavior !== "reject";
+  }
   if (selector.selection_type === "by_tag") return false;
   if (selector.selection_type !== "all" && selector.selection_type !== "by_id") return false;
   const hasEligibleDomain = publisherDomainCandidates(selector, path).some((candidate) => {
@@ -317,6 +378,76 @@ function matchedAllowedDomainForCandidate(candidate, policy) {
   }
   return void 0;
 }
+function identifierScopeForSelector(selector, policy) {
+  if (!policy.allowedPropertyIdentifiers.some((id) => id.type !== "domain" && id.type !== "subdomain") && !policy.publisherCatalogsConfigured)
+    return void 0;
+  const propertyIds = selector.selection_type === "by_id" ? stringArray(selector.property_ids) : [];
+  const hasExcludedId = propertyIds.some((id) => policy.excludedPropertyIds.has(id));
+  const allIdsExcluded = propertyIds.length > 0 && propertyIds.every((id) => policy.excludedPropertyIds.has(id));
+  if (allIdsExcluded) return { allMatch: false, hasMatch: false, hasNonMatch: true, unknown: false };
+  const domain = typeof selector.publisher_domain === "string" ? normalizeDomainForPropertyPolicy(selector.publisher_domain) : void 0;
+  if (!domain) return { allMatch: false, hasMatch: false, hasNonMatch: hasExcludedId, unknown: true };
+  if (policy.excludedDomainsByComparable.has(domain.comparable))
+    return { allMatch: false, hasMatch: false, hasNonMatch: true, unknown: false };
+  const properties = Object.hasOwn(policy.publisherProperties, domain.host) ? policy.publisherProperties[domain.host] : void 0;
+  if (!properties && policy.publisherCatalogsConfigured)
+    return { allMatch: false, hasMatch: false, hasNonMatch: hasExcludedId, unknown: true };
+  if (!properties) {
+    const matchedDomain = !allIdsExcluded && Boolean(matchedAllowedDomainForCandidate(domain, policy));
+    const unknown2 = !matchedDomain && !allIdsExcluded || selector.selection_type === "by_tag";
+    return {
+      allMatch: matchedDomain && !unknown2 && !hasExcludedId,
+      hasMatch: matchedDomain && !unknown2,
+      hasNonMatch: hasExcludedId,
+      unknown: unknown2
+    };
+  }
+  if (!Array.isArray(properties) || properties.some(
+    (property) => !property || typeof property !== "object" || !Array.isArray(property.identifiers) || property.identifiers.some(
+      (identifier) => !identifier || typeof identifier.type !== "string" || typeof identifier.value !== "string"
+    ) || property.tags !== void 0 && (!Array.isArray(property.tags) || property.tags.some((tag) => typeof tag !== "string"))
+  )) {
+    return { allMatch: false, hasMatch: false, hasNonMatch: hasExcludedId, unknown: true };
+  }
+  let selected = [...properties];
+  let missingIds = false;
+  if (selector.selection_type === "by_id") {
+    const ids = stringArray(selector.property_ids);
+    missingIds = !ids.length || ids.some((id) => !properties.some((property) => property.property_id === id));
+    selected = selected.filter((property) => property.property_id && ids.includes(property.property_id));
+  } else if (selector.selection_type === "by_tag") {
+    const tags = stringArray(selector.property_tags);
+    if (!tags.length) return { allMatch: false, hasMatch: false, hasNonMatch: false, unknown: true };
+    selected = selected.filter((property) => property.tags?.some((tag) => tags.includes(tag)));
+  } else if (selector.selection_type !== "all") {
+    return { allMatch: false, hasMatch: false, hasNonMatch: false, unknown: true };
+  }
+  const excluded = selected.map(
+    (property) => policy.excludedPropertyIds.has(property.property_id ?? "") || property.identifiers.some(
+      (identifier) => (identifier.type === "domain" || identifier.type === "subdomain") && policy.excludedDomainsByComparable.has(normalizeDomainForPropertyPolicy(identifier.value)?.comparable ?? "")
+    )
+  );
+  const matches = selected.map(
+    (property, index) => !excluded[index] && (!hasAllowedPropertyScope(policy) || property.identifiers.some(
+      (candidate) => policy.allowedPropertyIdentifiers.some(
+        (allowed) => allowed.type === "domain" || allowed.type === "subdomain" ? (candidate.type === "domain" || candidate.type === "subdomain") && propertyListDomainMatches(candidate.value, allowed.value, allowed.type) : isSupportedPropertyIdentifierType(allowed.type) && candidate.type === allowed.type && candidate.value === allowed.value
+      ) || (candidate.type === "domain" || candidate.type === "subdomain") && policy.allowedDomains.some((allowed) => propertyListDomainMatches(candidate.value, allowed.input))
+    ))
+  );
+  const undecidable = selected.map(
+    (property, index) => !excluded[index] && (property.identifiers.length === 0 || property.identifiers.some(
+      (candidate) => !isSupportedPropertyIdentifierType(candidate.type) && policy.allowedPropertyIdentifiers.some((allowed) => allowed.type === candidate.type)
+    ))
+  );
+  const unknown = matches.some((match, index) => !match && undecidable[index]);
+  return {
+    allMatch: matches.length > 0 && matches.every(Boolean) && !unknown,
+    hasMatch: matches.some(Boolean),
+    hasNonMatch: missingIds || !selected.length || matches.some((match, index) => !match && !undecidable[index]),
+    hasExcludedProperty: excluded.some(Boolean),
+    unknown
+  };
+}
 function publisherDomainCandidates(selector, path) {
   const candidates = [];
   if (typeof selector.publisher_domain === "string") {
@@ -382,6 +513,7 @@ function isUsableHostname(host) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ProductPropertyPolicyError,
+  isSupportedPropertyIdentifierType,
   normalizeDomainForPropertyPolicy,
   validateProductsAgainstPropertyPolicy
 });