@adcp/sdk 10.0.1 → 11.1.0

package/dist/lib/registry/sync.js

@@ -56,7 +56,9 @@ class RegistrySync extends node_events_1.EventEmitter {
     maxStreamFailures;
     indexAgents;
     indexAuthorizations;
+    indexProperties;
     indexBrandHierarchies;
+    ignoredEventHandler;
     errorHandler;
     cursorStore;
     _state = 'idle';
@@ -78,6 +80,10 @@ class RegistrySync extends node_events_1.EventEmitter {
     agents = new Map();
     authByDomain = new Map();
     authByAgent = new Map();
+    authLocationsById = new Map();
+    propertiesByRid = new Map();
+    propertyRidsByDomain = new Map();
+    propertyAliasesByRid = new Map();
     brandAncestorsByDomain = new Map();
     brandHierarchyByDomain = new Map();
     brandHierarchyKeysByEntity = new Map();
@@ -106,8 +112,10 @@ class RegistrySync extends node_events_1.EventEmitter {
         this.maxStreamFailures = config.maxStreamFailures ?? 3;
         this.indexAgents = config.indexes?.agents !== false;
         this.indexAuthorizations = config.indexes?.authorizations !== false;
+        this.indexProperties = config.indexes?.properties !== false;
         this.indexBrandHierarchies = config.indexes?.brandHierarchies !== false;
         this.cursorStore = config.cursorStore ?? new cursor_store_1.InMemoryCursorStore();
+        this.ignoredEventHandler = config.onIgnoredEvent;
         this.errorHandler = config.onError;
     }
     // ====== Lifecycle ======
@@ -196,7 +204,7 @@ class RegistrySync extends node_events_1.EventEmitter {
             if (filter.min_properties != null && p.property_count < filter.min_properties)
                 return false;
             if (filter.compliance_status?.length) {
-                const status = agent.compliance_summary?.status ?? 'unknown';
+                const status = (agent.compliance_summary?.status ?? 'unknown');
                 if (!filter.compliance_status.includes(status))
                     return false;
             }
@@ -206,11 +214,18 @@ class RegistrySync extends node_events_1.EventEmitter {
     // ====== Authorization Lookups ======
     /** Get all authorizations for a publisher domain. */
     getAuthorizationsForDomain(domain) {
-        return this.authByDomain.get(domain) ?? [];
+        return this.authByDomain.get(this.authDomainKey(domain)) ?? [];
     }
     /** Get all authorizations for an agent. */
     getAuthorizationsForAgent(agentUrl) {
-        return this.authByAgent.get(agentUrl) ?? [];
+        const entries = [];
+        for (const key of this.authAgentKeysForUrl(agentUrl)) {
+            for (const entry of this.authByAgent.get(key) ?? []) {
+                if (!entries.includes(entry))
+                    entries.push(entry);
+            }
+        }
+        return entries;
     }
     /**
      * Check if an agent has any authorization for a publisher domain.
@@ -223,8 +238,27 @@ class RegistrySync extends node_events_1.EventEmitter {
      * authorization after a missed revocation.
      */
     isAuthorized(agentUrl, domain) {
-        const entries = this.authByDomain.get(domain);
-        return entries != null && entries.some(e => e.agent_url === agentUrl);
+        const entries = this.authByDomain.get(this.authDomainKey(domain));
+        return entries != null && entries.some(entry => this.authorizationAgentMatches(entry, agentUrl));
+    }
+    // ====== Property Lookups ======
+    /** Get a property feed record by property_rid. Merged aliases resolve to their canonical RID. */
+    getProperty(rid) {
+        const property = this.propertiesByRid.get(this.resolvePropertyRid(rid));
+        return property ? this.cloneProperty(property) : undefined;
+    }
+    /** Get all property feed records for a publisher domain. */
+    getPropertiesForDomain(domain) {
+        const rids = this.propertyRidsByDomain.get(this.normalizeDomainKey(domain));
+        if (!rids)
+            return [];
+        const properties = [];
+        for (const rid of rids) {
+            const property = this.propertiesByRid.get(this.resolvePropertyRid(rid));
+            if (property)
+                properties.push(this.cloneProperty(property));
+        }
+        return properties;
     }
     // ====== Brand Hierarchy Lookups ======
     /**
@@ -254,6 +288,7 @@ class RegistrySync extends node_events_1.EventEmitter {
         return {
             agents: this.agents.size,
             authorizations: authCount,
+            properties: this.propertiesByRid.size,
             brandHierarchies: this.brandHierarchyKeysByEntity.size,
         };
     }
@@ -694,37 +729,29 @@ class RegistrySync extends node_events_1.EventEmitter {
     }
     // ====== Private: Event Application ======
     applyEvent(event) {
-        const payload = event.payload;
+        const payload = this.asRecord(event.payload);
         switch (event.event_type) {
             case 'agent.discovered':
             case 'agent.profile_updated': {
                 if (!this.indexAgents)
                     break;
                 const existing = this.agents.get(event.entity_id);
-                if (existing && payload.inventory_profile) {
+                const inventoryProfile = this.isAgentInventoryProfile(payload.inventory_profile)
+                    ? payload.inventory_profile
+                    : undefined;
+                if (existing && inventoryProfile) {
                     this.agents.set(event.entity_id, {
                         ...existing,
-                        inventory_profile: payload.inventory_profile,
+                        inventory_profile: inventoryProfile,
                     });
                 }
                 else if (!existing) {
                     // New agent: use payload data or create stub
                     this.agents.set(event.entity_id, {
                         url: event.entity_id,
-                        name: payload.name ?? event.entity_id,
-                        type: payload.type ?? 'unknown',
-                        inventory_profile: payload.inventory_profile ?? {
-                            channels: [],
-                            property_types: [],
-                            markets: [],
-                            categories: [],
-                            category_taxonomy: 'iab_content_3.0',
-                            tags: [],
-                            delivery_types: [],
-                            property_count: 0,
-                            publisher_count: 0,
-                            has_tmp: false,
-                        },
+                        name: typeof payload.name === 'string' ? payload.name : event.entity_id,
+                        type: typeof payload.type === 'string' ? payload.type : 'unknown',
+                        inventory_profile: inventoryProfile ?? this.emptyInventoryProfile(),
                         match: { score: 0, matched_filters: [] },
                     });
                 }
@@ -734,62 +761,47 @@ class RegistrySync extends node_events_1.EventEmitter {
                 if (this.indexAgents)
                     this.agents.delete(event.entity_id);
                 if (this.indexAuthorizations)
-                    this.authByAgent.delete(event.entity_id);
+                    this.removeAuthorizationsForAgent(event.entity_id);
                 break;
             }
             case 'authorization.granted': {
                 if (!this.indexAuthorizations)
                     break;
-                const entry = payload;
-                if (!entry.agent_url || !entry.publisher_domain || !entry.authorization_type)
+                if (!this.isAuthorizationPayload(payload))
                     break;
-                const domainEntries = this.authByDomain.get(entry.publisher_domain) ?? [];
-                if (!domainEntries.some(e => e.agent_url === entry.agent_url && e.authorization_type === entry.authorization_type)) {
-                    domainEntries.push(entry);
-                    this.authByDomain.set(entry.publisher_domain, domainEntries);
-                }
-                const agentEntries = this.authByAgent.get(entry.agent_url) ?? [];
-                if (!agentEntries.some(e => e.publisher_domain === entry.publisher_domain && e.authorization_type === entry.authorization_type)) {
-                    agentEntries.push(entry);
-                    this.authByAgent.set(entry.agent_url, agentEntries);
-                }
+                if (typeof payload.authorization_type !== 'string')
+                    break;
+                this.upsertAuthorizationEntry(this.authorizationEntryFromEvent(payload));
+                break;
+            }
+            case 'authorization.modified': {
+                if (!this.indexAuthorizations)
+                    break;
+                if (!this.isAuthorizationPayload(payload))
+                    break;
+                const entry = this.authorizationEntryFromEvent(payload);
+                if (!entry.id && !entry.authorization_type)
+                    break;
+                this.upsertAuthorizationEntry(entry, { fallbackToTupleOnMissingRowId: true });
                 break;
             }
             case 'authorization.revoked': {
                 if (!this.indexAuthorizations)
                     break;
-                const agentUrl = payload.agent_url;
-                const domain = payload.publisher_domain;
-                const authType = payload.authorization_type;
-                if (!agentUrl || !domain)
+                if (!this.isAuthorizationPayload(payload))
                     break;
-                const domainEntries = this.authByDomain.get(domain);
-                if (domainEntries) {
-                    const filtered = domainEntries.filter(e => !(e.agent_url === agentUrl && (!authType || e.authorization_type === authType)));
-                    if (filtered.length > 0)
-                        this.authByDomain.set(domain, filtered);
-                    else
-                        this.authByDomain.delete(domain);
-                }
-                const agentEntries = this.authByAgent.get(agentUrl);
-                if (agentEntries) {
-                    const filtered = agentEntries.filter(e => !(e.publisher_domain === domain && (!authType || e.authorization_type === authType)));
-                    if (filtered.length > 0)
-                        this.authByAgent.set(agentUrl, filtered);
-                    else
-                        this.authByAgent.delete(agentUrl);
-                }
+                const entry = this.authorizationEntryFromEvent(payload);
+                this.removeAuthorizationEntries(entry, {
+                    matchByRowId: Boolean(entry.id || !entry.authorization_type),
+                    fallbackToTupleOnMissingRowId: true,
+                });
                 break;
             }
             case 'agent.compliance_changed': {
                 if (this.indexAgents) {
                     const existing = this.agents.get(event.entity_id);
                     const summary = payload.compliance_summary;
-                    if (existing &&
-                        summary &&
-                        typeof summary === 'object' &&
-                        'status' in summary &&
-                        typeof summary.status === 'string') {
+                    if (existing && this.isAgentCompliance(summary)) {
                         this.agents.set(event.entity_id, {
                             ...existing,
                             compliance_summary: summary,
@@ -807,6 +819,19 @@ class RegistrySync extends node_events_1.EventEmitter {
                 });
                 break;
             }
+            case 'property.created':
+            case 'property.updated':
+            case 'property.reactivated':
+            case 'property.stale': {
+                if (this.indexProperties)
+                    this.upsertPropertyEvent(payload);
+                break;
+            }
+            case 'property.merged': {
+                if (this.indexProperties)
+                    this.handlePropertyMerge(payload);
+                break;
+            }
             case 'brand.hierarchy_updated':
             case 'brand.updated':
             case 'brand.resolved': {
@@ -820,8 +845,20 @@ class RegistrySync extends node_events_1.EventEmitter {
                     this.deleteBrandHierarchy(event.entity_id, payload);
                 break;
             }
-            // Property and publisher events: no-op for v1 (no property index yet)
+            case 'collection.created':
+            case 'collection.updated':
+            case 'collection.merged':
+            case 'collection.removed': {
+                this.ignoreEvent(event, 'collection.* indexing requires typed collection schemas and a reference consumer');
+                break;
+            }
+            case 'publisher.adagents_changed':
+            case 'publisher.adagents_discovered': {
+                this.ignoreEvent(event, 'publisher.* indexing requires a reference consumer');
+                break;
+            }
             default:
+                this.ignoreEvent(event, 'unknown or unsupported registry feed event type');
                 break;
         }
     }
@@ -830,11 +867,301 @@ class RegistrySync extends node_events_1.EventEmitter {
         this.agents.clear();
         this.authByDomain.clear();
         this.authByAgent.clear();
+        this.authLocationsById.clear();
+        this.propertiesByRid.clear();
+        this.propertyRidsByDomain.clear();
+        this.propertyAliasesByRid.clear();
         this.brandAncestorsByDomain.clear();
         this.brandHierarchyByDomain.clear();
         this.brandHierarchyKeysByEntity.clear();
         this.brandHierarchyEntityByKey.clear();
     }
+    ignoreEvent(event, reason) {
+        this.ignoredEventHandler?.(event, reason);
+        this.emit('ignoredEvent', { event, reason });
+    }
+    upsertAuthorizationEntry(entry, options) {
+        const normalizedEntry = this.normalizeAuthorizationEntry(entry);
+        this.removeAuthorizationEntries(normalizedEntry, {
+            matchByRowId: Boolean(normalizedEntry.id),
+            fallbackToTupleOnMissingRowId: options?.fallbackToTupleOnMissingRowId,
+        });
+        const domainKey = this.authDomainKey(normalizedEntry.publisher_domain);
+        const domainEntries = this.authByDomain.get(domainKey) ?? [];
+        domainEntries.push(normalizedEntry);
+        this.authByDomain.set(domainKey, domainEntries);
+        const agentKey = this.authAgentKey(normalizedEntry);
+        for (const key of this.authAgentKeys(normalizedEntry)) {
+            const agentEntries = this.authByAgent.get(key) ?? [];
+            agentEntries.push(normalizedEntry);
+            this.authByAgent.set(key, agentEntries);
+        }
+        if (normalizedEntry.id) {
+            this.authLocationsById.set(normalizedEntry.id, {
+                agentKey,
+                domainKey,
+            });
+        }
+    }
+    normalizeAuthorizationEntry(entry) {
+        if (entry.effective_until || !entry.effective_to)
+            return entry;
+        return { ...entry, effective_until: entry.effective_to };
+    }
+    authorizationEntryFromEvent(entry) {
+        return this.normalizeAuthorizationEntry(entry);
+    }
+    removeAuthorizationsForAgent(agentUrl) {
+        const agentKeys = this.authAgentKeysForUrl(agentUrl);
+        for (const [key, entries] of this.authByAgent) {
+            if (entries.some(entry => this.authorizationAgentMatches(entry, agentUrl)))
+                agentKeys.add(key);
+        }
+        for (const agentKey of agentKeys) {
+            const entries = [...(this.authByAgent.get(agentKey) ?? [])];
+            for (const entry of entries) {
+                this.removeAuthorizationEntries(entry, {
+                    matchByRowId: Boolean(entry.id),
+                    fallbackToTupleOnMissingRowId: true,
+                });
+            }
+            this.authByAgent.delete(agentKey);
+        }
+    }
+    removeAuthorizationEntries(target, options) {
+        const normalizedTarget = this.normalizeAuthorizationEntry(target);
+        const domainKeys = new Set([this.authDomainKey(normalizedTarget.publisher_domain)]);
+        const agentKeys = this.authAgentKeys(normalizedTarget);
+        let effectiveOptions = options;
+        if (normalizedTarget.id && options?.matchByRowId) {
+            const existingLocation = this.authLocationsById.get(normalizedTarget.id);
+            if (!existingLocation && options.fallbackToTupleOnMissingRowId) {
+                effectiveOptions = { ...options, matchByRowId: false };
+            }
+            if (existingLocation) {
+                domainKeys.add(existingLocation.domainKey);
+                agentKeys.add(existingLocation.agentKey);
+            }
+        }
+        for (const domain of domainKeys) {
+            const entries = this.authByDomain.get(domain);
+            if (!entries)
+                continue;
+            for (const entry of entries) {
+                if (this.authorizationMatches(entry, normalizedTarget, effectiveOptions)) {
+                    for (const key of this.authAgentKeys(entry))
+                        agentKeys.add(key);
+                }
+            }
+        }
+        for (const domain of domainKeys) {
+            this.removeAuthorizationEntriesFromBucket(this.authByDomain, domain, normalizedTarget, effectiveOptions);
+        }
+        for (const agentUrl of agentKeys) {
+            this.removeAuthorizationEntriesFromBucket(this.authByAgent, agentUrl, normalizedTarget, effectiveOptions);
+        }
+    }
+    removeAuthorizationEntriesFromBucket(bucket, key, target, options) {
+        const entries = bucket.get(key);
+        if (!entries)
+            return;
+        const filtered = [];
+        for (const entry of entries) {
+            if (this.authorizationMatches(entry, target, options)) {
+                if (entry.id)
+                    this.authLocationsById.delete(entry.id);
+            }
+            else {
+                filtered.push(entry);
+            }
+        }
+        if (filtered.length > 0)
+            bucket.set(key, filtered);
+        else
+            bucket.delete(key);
+    }
+    authorizationMatches(entry, target, options) {
+        if (target.id && options?.matchByRowId)
+            return entry.id === target.id;
+        if (!this.authorizationEntriesShareAgent(entry, target))
+            return false;
+        if (this.authDomainKey(entry.publisher_domain) !== this.authDomainKey(target.publisher_domain))
+            return false;
+        if (target.authorization_type)
+            return entry.authorization_type === target.authorization_type;
+        return true;
+    }
+    authorizationAgentMatches(entry, agentUrl) {
+        return this.authAgentKeysOverlap(this.authAgentKeys(entry), this.authAgentKeysForUrl(agentUrl));
+    }
+    authorizationEntriesShareAgent(left, right) {
+        return this.authAgentKeysOverlap(this.authAgentKeys(left), this.authAgentKeys(right));
+    }
+    authDomainKey(domain) {
+        return this.normalizeDomainKey(domain);
+    }
+    authAgentKey(entry) {
+        return this.authAgentKeyFromUrl(entry.agent_url);
+    }
+    authAgentKeys(entry) {
+        const keys = this.authAgentKeysForUrl(entry.agent_url);
+        if (entry.agent_url_canonical?.trim()) {
+            for (const key of this.authAgentKeysForUrl(entry.agent_url_canonical))
+                keys.add(key);
+        }
+        return keys;
+    }
+    authAgentKeysForUrl(agentUrl) {
+        const trimmed = agentUrl.trim();
+        const keys = new Set();
+        if (trimmed)
+            keys.add(trimmed);
+        keys.add(this.authAgentKeyFromUrl(agentUrl));
+        return keys;
+    }
+    authAgentKeysOverlap(left, right) {
+        for (const key of left) {
+            if (right.has(key))
+                return true;
+        }
+        return false;
+    }
+    authAgentKeyFromUrl(agentUrl) {
+        const trimmed = agentUrl.trim();
+        if (!trimmed)
+            return trimmed;
+        try {
+            const parsed = new URL(trimmed);
+            if (parsed.host)
+                return `${parsed.protocol.toLowerCase()}//${parsed.host.toLowerCase()}`;
+        }
+        catch {
+            // Fall through to best-effort normalization for malformed or scheme-less values.
+        }
+        const schemeEnd = trimmed.indexOf('://');
+        const authorityStart = schemeEnd > 0 ? schemeEnd + 3 : 0;
+        let authorityEnd = trimmed.length;
+        for (const delimiter of ['/', '?', '#']) {
+            const index = trimmed.indexOf(delimiter, authorityStart);
+            if (index >= 0 && index < authorityEnd)
+                authorityEnd = index;
+        }
+        if (authorityEnd === authorityStart)
+            return trimmed.toLowerCase();
+        const scheme = schemeEnd > 0 ? `${trimmed.slice(0, authorityStart).toLowerCase()}` : '';
+        return `${scheme}${trimmed.slice(authorityStart, authorityEnd).toLowerCase()}`;
+    }
+    upsertPropertyEvent(payload) {
+        const rid = this.propertyRidFromPayload(payload);
+        if (!rid)
+            return;
+        const canonicalRid = this.resolvePropertyRid(rid);
+        const existing = this.propertiesByRid.get(canonicalRid);
+        const next = this.propertyFromPayload(canonicalRid, payload, existing);
+        if (!next)
+            return;
+        this.setPropertyEntry(next, existing);
+    }
+    handlePropertyMerge(payload) {
+        if (typeof payload.alias_rid !== 'string' || typeof payload.canonical_rid !== 'string')
+            return;
+        const aliasRid = this.resolvePropertyRid(payload.alias_rid);
+        const canonicalRid = this.resolvePropertyRid(payload.canonical_rid);
+        if (!aliasRid || !canonicalRid || aliasRid === canonicalRid)
+            return;
+        const aliasEntry = this.propertiesByRid.get(aliasRid);
+        const canonicalEntry = this.propertiesByRid.get(canonicalRid);
+        const payloadEntry = this.propertyFromPayload(canonicalRid, payload);
+        this.propertyAliasesByRid.set(payload.alias_rid, canonicalRid);
+        this.propertyAliasesByRid.set(aliasRid, canonicalRid);
+        if (!aliasEntry && !canonicalEntry && !payloadEntry)
+            return;
+        const merged = {
+            ...(aliasEntry ? this.cloneProperty(aliasEntry) : {}),
+            ...(canonicalEntry ? this.cloneProperty(canonicalEntry) : {}),
+            ...(payloadEntry ? this.cloneProperty(payloadEntry) : {}),
+            property_rid: canonicalRid,
+        };
+        if (!merged.publisher_domain) {
+            merged.publisher_domain = canonicalEntry?.publisher_domain ?? aliasEntry?.publisher_domain;
+        }
+        this.deletePropertyEntry(aliasRid);
+        this.setPropertyEntry(merged, canonicalEntry);
+    }
+    propertyFromPayload(rid, payload, existing) {
+        const publisherDomain = this.propertyDomainFromPayload(payload) ?? existing?.publisher_domain;
+        const next = existing ? this.cloneProperty(existing) : { property_rid: rid };
+        let hasPayloadFields = false;
+        for (const [key, value] of Object.entries(payload)) {
+            if (value === undefined || key === 'alias_rid' || key === 'canonical_rid')
+                continue;
+            hasPayloadFields = true;
+            next[key] = this.cloneJsonValue(value);
+        }
+        next.property_rid = rid;
+        if (publisherDomain)
+            next.publisher_domain = publisherDomain;
+        return hasPayloadFields || publisherDomain || existing ? next : null;
+    }
+    setPropertyEntry(entry, previous) {
+        if (previous?.publisher_domain && previous.publisher_domain !== entry.publisher_domain) {
+            this.removePropertyRidFromDomain(entry.property_rid, previous.publisher_domain);
+        }
+        this.propertiesByRid.set(entry.property_rid, this.cloneProperty(entry));
+        if (entry.publisher_domain) {
+            const key = this.normalizeDomainKey(entry.publisher_domain);
+            const rids = this.propertyRidsByDomain.get(key) ?? new Set();
+            rids.add(entry.property_rid);
+            this.propertyRidsByDomain.set(key, rids);
+        }
+    }
+    deletePropertyEntry(rid) {
+        const entry = this.propertiesByRid.get(rid);
+        if (entry?.publisher_domain)
+            this.removePropertyRidFromDomain(rid, entry.publisher_domain);
+        this.propertiesByRid.delete(rid);
+    }
+    removePropertyRidFromDomain(rid, domain) {
+        const key = this.normalizeDomainKey(domain);
+        const rids = this.propertyRidsByDomain.get(key);
+        if (!rids)
+            return;
+        rids.delete(rid);
+        if (rids.size === 0)
+            this.propertyRidsByDomain.delete(key);
+    }
+    propertyRidFromPayload(payload) {
+        if (typeof payload.property_rid === 'string' && payload.property_rid.trim())
+            return payload.property_rid;
+        if (typeof payload.rid === 'string' && payload.rid.trim())
+            return payload.rid;
+        if (typeof payload.id === 'string' && payload.id.trim())
+            return payload.id;
+        return null;
+    }
+    propertyDomainFromPayload(payload) {
+        if (typeof payload.publisher_domain === 'string' && payload.publisher_domain.trim())
+            return payload.publisher_domain;
+        const property = this.asRecord(payload.property);
+        return typeof property.publisher_domain === 'string' && property.publisher_domain.trim()
+            ? property.publisher_domain
+            : undefined;
+    }
+    stringValue(value) {
+        return typeof value === 'string' && value.trim() ? value : undefined;
+    }
+    resolvePropertyRid(rid) {
+        let current = rid;
+        const seen = new Set();
+        while (this.propertyAliasesByRid.has(current) && !seen.has(current)) {
+            seen.add(current);
+            current = this.propertyAliasesByRid.get(current);
+        }
+        return current;
+    }
+    cloneProperty(property) {
+        return this.cloneJsonValue(property);
+    }
     applyBrandHierarchyEvent(entityId, payload) {
         const resolvedChain = this.extractResolvedBrandChain(payload.chain);
         const domainChain = resolvedChain.length > 0
@@ -906,12 +1233,101 @@ class RegistrySync extends node_events_1.EventEmitter {
         }
         this.brandHierarchyKeysByEntity.delete(entityKey);
     }
+    asRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    }
+    emptyInventoryProfile() {
+        return {
+            channels: [],
+            property_types: [],
+            markets: [],
+            categories: [],
+            category_taxonomy: 'iab_content_3.0',
+            tags: [],
+            delivery_types: [],
+            property_count: 0,
+            publisher_count: 0,
+            has_tmp: false,
+        };
+    }
+    isStringArray(value) {
+        return Array.isArray(value) && value.every(item => typeof item === 'string');
+    }
+    isAgentInventoryProfile(value) {
+        const profile = this.asRecord(value);
+        return (this.isStringArray(profile.channels) &&
+            this.isStringArray(profile.property_types) &&
+            this.isStringArray(profile.markets) &&
+            this.isStringArray(profile.categories) &&
+            (typeof profile.category_taxonomy === 'string' || profile.category_taxonomy === null) &&
+            this.isStringArray(profile.tags) &&
+            this.isStringArray(profile.delivery_types) &&
+            (profile.format_ids === undefined || this.isStringArray(profile.format_ids)) &&
+            typeof profile.property_count === 'number' &&
+            typeof profile.publisher_count === 'number' &&
+            typeof profile.has_tmp === 'boolean');
+    }
+    isAuthorizationPayload(value) {
+        const payload = this.asRecord(value);
+        return ((payload.id === undefined || this.stringValue(payload.id) !== undefined) &&
+            this.stringValue(payload.agent_url) !== undefined &&
+            this.stringValue(payload.publisher_domain) !== undefined &&
+            (payload.authorization_type === undefined || this.stringValue(payload.authorization_type) !== undefined) &&
+            (payload.property_ids === undefined || this.isStringArray(payload.property_ids)) &&
+            (payload.property_tags === undefined || this.isStringArray(payload.property_tags)) &&
+            (payload.placement_ids === undefined || this.isStringArray(payload.placement_ids)) &&
+            (payload.placement_tags === undefined || this.isStringArray(payload.placement_tags)) &&
+            (payload.countries === undefined || this.isStringArray(payload.countries)) &&
+            (payload.effective_from === undefined || typeof payload.effective_from === 'string') &&
+            (payload.effective_until === undefined || typeof payload.effective_until === 'string') &&
+            (payload.effective_to === undefined || typeof payload.effective_to === 'string'));
+    }
+    isAgentCompliance(value) {
+        const summary = this.asRecord(value);
+        const statuses = new Set(['passing', 'degraded', 'failing', 'unknown', 'opted_out']);
+        const lifecycleStages = new Set(['development', 'testing', 'production', 'deprecated']);
+        if (summary.status === 'opted_out') {
+            return ((summary.lifecycle_stage === undefined ||
+                (typeof summary.lifecycle_stage === 'string' && lifecycleStages.has(summary.lifecycle_stage))) &&
+                (summary.tracks === undefined ||
+                    (summary.tracks != null && typeof summary.tracks === 'object' && !Array.isArray(summary.tracks))) &&
+                (summary.streak_days === undefined || typeof summary.streak_days === 'number') &&
+                (summary.last_checked_at === undefined ||
+                    typeof summary.last_checked_at === 'string' ||
+                    summary.last_checked_at === null) &&
+                (summary.headline === undefined || typeof summary.headline === 'string' || summary.headline === null));
+        }
+        return (typeof summary.status === 'string' &&
+            statuses.has(summary.status) &&
+            typeof summary.lifecycle_stage === 'string' &&
+            lifecycleStages.has(summary.lifecycle_stage) &&
+            summary.tracks != null &&
+            typeof summary.tracks === 'object' &&
+            !Array.isArray(summary.tracks) &&
+            typeof summary.streak_days === 'number' &&
+            (typeof summary.last_checked_at === 'string' || summary.last_checked_at === null) &&
+            (typeof summary.headline === 'string' || summary.headline === null));
+    }
+    isResolvedBrand(value) {
+        const brand = this.asRecord(value);
+        return typeof brand.canonical_id === 'string' && typeof brand.canonical_domain === 'string';
+    }
+    cloneJsonValue(value) {
+        if (Array.isArray(value))
+            return value.map(item => this.cloneJsonValue(item));
+        if (value && typeof value === 'object') {
+            const copy = {};
+            for (const [key, nested] of Object.entries(value)) {
+                copy[key] = this.cloneJsonValue(nested);
+            }
+            return copy;
+        }
+        return value;
+    }
     extractResolvedBrandChain(value) {
         if (!Array.isArray(value))
             return [];
-        if (!value.every(item => item && typeof item === 'object' && !Array.isArray(item)))
-            return [];
-        return value.filter(item => typeof item.canonical_domain === 'string');
+        return value.filter(item => this.isResolvedBrand(item));
     }
     extractDomainChain(value) {
         if (!Array.isArray(value))