evolcore 0.0.2 → 0.0.4

package/dist/config/contact-book.js

@@ -1,6 +1,9 @@
 import { agentContactConfig } from '../paths.js';
 import { isValidAid } from '../aun/aid/validation.js';
-import { ConfigTarget, read, validateConfig, write } from './config-manager.js';
+import { isExplicitGroupId } from '../aun/group-identity.js';
+import { ConfigTarget, read, validateConfig } from './config-manager.js';
+import { ContactMutationError, contactRevision, mutateContactBookSync } from './contact-book-store.js';
+import { formatContactAlias, normalizeContactChannelKey, parseContactAlias, } from './contact-alias.js';
 export class ContactBookError extends Error {
     code;
     constructor(code, message) {
@@ -10,13 +13,11 @@ export class ContactBookError extends Error {
     }
 }
 let aliasMapCache = new WeakMap();
-const emptyAliasMap = {
-    scopedAliasToPrimary: new Map(),
-    conflictingScopedAliases: new Set(),
-    legacyAliasToPrimary: new Map(),
-    conflictingLegacyAliases: new Set(),
+let snapshotByBook = new WeakMap();
+const EMPTY_ALIAS_MAP = {
+    aliasToPrimary: new Map(),
+    conflictingAliases: new Set(),
 };
-const SCOPED_ALIAS_PREFIX = 'channel-key:';
 export function agentContactConfigPath(aid) {
     return agentContactConfig(aid);
 }
@@ -26,346 +27,230 @@ export function readContactBook(selfAid, opts = {}) {
     return read(ConfigTarget.Contact, { self: selfAid }, { cache: opts.cache ?? true });
 }
 export function resolvePrincipal(selfAid, channelType, actorId, channelKey) {
-    const normalizedActor = String(actorId || '').trim();
-    const normalizedChannel = String(channelType || '').trim().toLowerCase();
-    if (normalizedChannel === 'aun') {
-        return isValidAid(normalizedActor)
-            ? { principalId: normalizedActor, principalStatus: 'native_aid' }
-            : { principalStatus: normalizedActor ? 'unmapped' : 'error' };
+    const actor = String(actorId || '').trim();
+    const type = String(channelType || '').trim().toLowerCase();
+    if (type === 'aun') {
+        return isValidAid(actor)
+            ? { principalId: actor, principalStatus: 'native_aid' }
+            : { principalStatus: actor ? 'unmapped' : 'error' };
     }
-    const normalizedSelf = String(selfAid || '').trim();
-    const normalizedChannelKey = normalizeChannelKey(normalizedSelf, normalizedChannel, channelKey);
-    const legacyAlias = normalizeLegacyAlias(normalizedChannel, normalizedActor);
-    if (!isValidAid(normalizedSelf) || !normalizedChannelKey || !legacyAlias) {
+    const canonicalChannelKey = normalizeContactChannelKey(selfAid, type, channelKey);
+    if (!isValidAid(String(selfAid || '').trim()) || !actor || !canonicalChannelKey) {
         return { principalStatus: 'error' };
     }
-    const scopedAlias = scopedAliasLookupKey(normalizedChannelKey, normalizedActor);
     try {
-        const aliases = loadAliasMap(normalizedSelf);
-        if (aliases.conflictingScopedAliases.has(scopedAlias)) {
-            return { principalStatus: 'conflict' };
-        }
-        const scopedPrincipalId = aliases.scopedAliasToPrimary.get(scopedAlias);
-        if (scopedPrincipalId) {
-            return { principalId: scopedPrincipalId, principalStatus: 'mapped' };
-        }
-        // Legacy aliases did not identify a channel instance. They remain trusted only
-        // while the configured channel type has exactly one matching instance.
-        if (!isUnambiguousLegacyChannel(normalizedSelf, normalizedChannel, normalizedChannelKey)) {
-            return { principalStatus: 'unmapped' };
-        }
-        if (aliases.conflictingLegacyAliases.has(legacyAlias)) {
+        const aliases = loadAliasMap(selfAid);
+        const exact = formatContactAlias(canonicalChannelKey, actor);
+        if (aliases.conflictingAliases.has(exact))
             return { principalStatus: 'conflict' };
-        }
-        const legacyPrincipalId = aliases.legacyAliasToPrimary.get(legacyAlias);
-        return legacyPrincipalId
-            ? { principalId: legacyPrincipalId, principalStatus: 'mapped' }
-            : { principalStatus: 'unmapped' };
+        const mapped = aliases.aliasToPrimary.get(exact);
+        if (mapped)
+            return { principalId: mapped, principalStatus: 'mapped' };
+        return { principalStatus: 'unmapped' };
     }
     catch {
         return { principalStatus: 'error' };
     }
 }
 export function resolvePrimaryId(selfAid, channelType, actorId, channelKey) {
-    const normalizedActor = String(actorId || '').trim();
-    return resolvePrincipal(selfAid, channelType, normalizedActor, channelKey).principalId ?? normalizedActor;
+    const actor = String(actorId || '').trim();
+    return resolvePrincipal(selfAid, channelType, actor, channelKey).principalId ?? actor;
 }
 export function bindContactAlias(selfAid, primaryId, channelType, actorId, channelKey) {
     const primary = normalizePrimaryId(primaryId);
-    const alias = requireScopedAlias(selfAid, channelType, actorId, channelKey);
-    const legacyAlias = requireLegacyAlias(channelType, actorId);
-    ensureNativeAidIsNotRemapped(primary, channelType, actorId);
-    const next = cloneContactBook(readContactBook(selfAid, { cache: true }));
-    ensureScopedAliasAvailable(next, selfAid, primary, alias.lookupKey);
-    const contacts = next.contacts ?? {};
-    let removedLegacyAlias = false;
-    // An explicit scoped bind supersedes every unscoped copy of the same alias.
-    // Otherwise unbinding the scoped entry could silently reactivate a legacy
-    // mapping owned by another principal.
-    for (const [contactId, value] of Object.entries(contacts)) {
-        const entry = normalizeContactEntry(value);
-        const filtered = entry.aliases.filter(item => normalizeLegacyAliasString(item) !== legacyAlias);
-        if (filtered.length !== entry.aliases.length) {
-            contacts[contactId] = { ...entry, aliases: filtered };
-            removedLegacyAlias = true;
+    const type = String(channelType || '').trim().toLowerCase();
+    const actor = String(actorId || '').trim();
+    if (type === 'aun') {
+        if (!isValidAid(actor) || actor !== primary) {
+            throw new ContactBookError('NATIVE_AID_REMAP_FORBIDDEN', `Native AID "${actor}" cannot be remapped to "${primary}"`);
         }
-    }
-    const current = normalizeContactEntry(contacts[primary]);
-    const alreadyScoped = current.aliases.some(value => (normalizeScopedAliasString(value, selfAid)?.lookupKey === alias.lookupKey));
-    if (alreadyScoped && !removedLegacyAlias) {
         return false;
     }
-    contacts[primary] = {
-        ...current,
-        aliases: alreadyScoped
-            ? current.aliases
-            : [...current.aliases, alias.serialized],
-    };
-    next.contacts = contacts;
-    write(ConfigTarget.Contact, next, { self: selfAid });
-    return true;
+    const canonicalChannelKey = normalizeContactChannelKey(selfAid, type, channelKey);
+    if (!canonicalChannelKey || !actor) {
+        throw new ContactBookError('INVALID_ALIAS', `Invalid contact alias: ${String(channelKey)}:${String(actorId)}`);
+    }
+    if (!getContactSnapshot(selfAid).contacts.has(primary)) {
+        throw new ContactBookError('NOT_FOUND', `Contact was not found: ${primary}`);
+    }
+    const alias = formatContactAlias(canonicalChannelKey, actor);
+    try {
+        return mutateContactBookSync({
+            selfAid,
+            mutation: { type: 'bind-alias', primaryId: primary, alias },
+        }).changed;
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError)
+            throw new ContactBookError(error.code, error.message);
+        throw error;
+    }
 }
 export function unbindContactAlias(selfAid, primaryId, channelType, actorId, channelKey) {
     const primary = normalizePrimaryId(primaryId);
-    const alias = requireScopedAlias(selfAid, channelType, actorId, channelKey);
-    const legacyAlias = requireLegacyAlias(channelType, actorId);
-    const next = cloneContactBook(readContactBook(selfAid, { cache: true }));
-    const contacts = next.contacts ?? {};
-    let changed = false;
-    // Remove the requested scoped binding from the target principal and purge
-    // every unscoped copy of the same raw alias.  Legacy aliases do not carry a
-    // channel-instance identity, so retaining one on another contact would
-    // silently reactivate that principal after this scoped binding is revoked.
-    for (const [contactId, value] of Object.entries(contacts)) {
-        const entry = normalizeContactEntry(value);
-        const filtered = entry.aliases.filter(item => {
-            const isTargetScoped = contactId.trim() === primary
-                && normalizeScopedAliasString(item, selfAid)?.lookupKey === alias.lookupKey;
-            const isLegacyCopy = normalizeLegacyAliasString(item) === legacyAlias;
-            return !isTargetScoped && !isLegacyCopy;
-        });
-        if (filtered.length !== entry.aliases.length) {
-            contacts[contactId] = { ...entry, aliases: filtered };
-            changed = true;
-        }
+    const type = String(channelType || '').trim().toLowerCase();
+    const actor = String(actorId || '').trim();
+    const canonicalChannelKey = normalizeContactChannelKey(selfAid, type, channelKey);
+    if (!canonicalChannelKey || type === 'aun' || !actor) {
+        throw new ContactBookError('INVALID_ALIAS', `Invalid contact alias: ${String(channelKey)}:${String(actorId)}`);
     }
-    if (!changed) {
-        return false;
+    const alias = formatContactAlias(canonicalChannelKey, actor);
+    try {
+        return mutateContactBookSync({
+            selfAid,
+            mutation: { type: 'unbind-alias', primaryId: primary, alias },
+        }).changed;
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError)
+            throw new ContactBookError(error.code, error.message);
+        throw error;
     }
-    next.contacts = contacts;
-    write(ConfigTarget.Contact, next, { self: selfAid });
-    return true;
 }
 export function clearContactBookCache() {
     aliasMapCache = new WeakMap();
+    snapshotByBook = new WeakMap();
 }
-function loadAliasMap(selfAid) {
-    const book = readContactBook(selfAid, { cache: true });
-    if (!book)
-        return emptyAliasMap;
-    const cached = aliasMapCache.get(book);
+export function getContactSnapshot(selfAid) {
+    const book = readContactBook(selfAid, { cache: true }) ?? { $schema_version: 2, contacts: {} };
+    const cached = snapshotByBook.get(book);
     if (cached)
         return cached;
-    const validationErrors = validateConfig(ConfigTarget.Contact, book);
-    if (validationErrors.length > 0) {
-        throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact book for ${selfAid}: ${validationErrors.join('; ')}`);
-    }
-    const built = buildAliasMap(book, selfAid);
-    aliasMapCache.set(book, built);
-    return built;
-}
-function buildAliasMap(config, selfAid) {
-    const scopedAliasToPrimary = new Map();
-    const conflictingScopedAliases = new Set();
-    const legacyAliasToPrimary = new Map();
-    const conflictingLegacyAliases = new Set();
-    const contacts = config?.contacts;
-    if (!contacts || typeof contacts !== 'object' || Array.isArray(contacts)) {
-        return {
-            scopedAliasToPrimary,
-            conflictingScopedAliases,
-            legacyAliasToPrimary,
-            conflictingLegacyAliases,
-        };
-    }
-    for (const [rawPrimaryId, entry] of Object.entries(contacts)) {
-        const primaryId = rawPrimaryId.trim();
-        if (!isValidAid(primaryId) || !entry || typeof entry !== 'object' || Array.isArray(entry))
-            continue;
-        const aliases = Array.isArray(entry.aliases) ? entry.aliases : [];
-        for (const rawAlias of aliases) {
-            const scoped = normalizeScopedAliasString(rawAlias, selfAid);
-            if (scoped) {
-                addAliasMapping(scopedAliasToPrimary, conflictingScopedAliases, scoped.lookupKey, primaryId);
-            }
-            else {
-                const legacy = normalizeLegacyAliasString(rawAlias);
-                if (legacy) {
-                    addAliasMapping(legacyAliasToPrimary, conflictingLegacyAliases, legacy, primaryId);
-                }
-            }
-        }
+    const errors = validateConfig(ConfigTarget.Contact, book);
+    if (errors.length) {
+        throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact book for ${selfAid}: ${errors.join('; ')}`);
     }
-    return {
-        scopedAliasToPrimary,
-        conflictingScopedAliases,
-        legacyAliasToPrimary,
-        conflictingLegacyAliases,
-    };
-}
-function addAliasMapping(aliases, conflicts, alias, primaryId) {
-    if (conflicts.has(alias))
-        return;
-    const existing = aliases.get(alias);
-    if (existing && existing !== primaryId) {
-        aliases.delete(alias);
-        conflicts.add(alias);
-        return;
-    }
-    aliases.set(alias, primaryId);
-}
-function cloneContactBook(config) {
-    const next = config ? { ...config } : {};
-    const contacts = {};
-    const rawContacts = config?.contacts;
-    if (rawContacts && typeof rawContacts === 'object' && !Array.isArray(rawContacts)) {
-        for (const [primaryId, entry] of Object.entries(rawContacts)) {
-            contacts[primaryId] = normalizeContactEntry(entry);
-        }
+    const aliases = buildAliasMap(book, selfAid);
+    if (aliases.conflictingAliases.size) {
+        throw new ContactBookError('ALIAS_CONFLICT', `Conflicting contact aliases: ${[...aliases.conflictingAliases].join(', ')}`);
     }
-    next.contacts = contacts;
-    return next;
+    const snapshot = buildSnapshot(book, selfAid, aliases);
+    snapshotByBook.set(book, snapshot);
+    return snapshot;
 }
-function normalizeContactEntry(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return { aliases: [] };
-    }
-    const entry = value;
+export function resolveContactView(selfAid, primaryId) {
+    const id = String(primaryId || '').trim();
+    const owner = listAgentOwners(selfAid).includes(id);
+    const entry = getContactSnapshot(selfAid).contacts.get(id);
+    const status = owner ? 'active' : entry?.status ?? 'active';
     return {
-        ...entry,
-        aliases: Array.isArray(entry.aliases)
-            ? entry.aliases.filter((item) => typeof item === 'string')
-            : [],
+        primaryId: id,
+        ...(entry?.displayName ? { displayName: entry.displayName } : {}),
+        aliases: entry?.aliases ?? [],
+        status,
+        blocked: status === 'blocked',
+        isOwner: owner,
+        source: owner ? 'owner' : entry ? 'contact' : 'none',
     };
 }
-function ensureScopedAliasAvailable(config, selfAid, primaryId, alias) {
-    const owners = findScopedAliasOwners(config, selfAid, alias);
-    if (owners.size === 0)
-        return;
-    if (owners.size === 1 && owners.has(primaryId))
-        return;
-    throw new ContactBookError('ALIAS_CONFLICT', `Alias "${alias}" is already bound to ${[...owners].join(', ')}`);
+export function isBlockedContact(selfAid, primaryId) {
+    return resolveContactView(selfAid, primaryId).blocked;
 }
-function findScopedAliasOwners(config, selfAid, alias) {
-    const owners = new Set();
-    const contacts = config.contacts;
-    if (!contacts || typeof contacts !== 'object' || Array.isArray(contacts))
-        return owners;
-    for (const [rawPrimaryId, entry] of Object.entries(contacts)) {
-        const primaryId = rawPrimaryId.trim();
-        if (!primaryId || !entry || typeof entry !== 'object' || Array.isArray(entry))
-            continue;
-        const aliases = Array.isArray(entry.aliases) ? entry.aliases : [];
-        if (aliases.some(value => normalizeScopedAliasString(value, selfAid)?.lookupKey === alias)) {
-            owners.add(primaryId);
-        }
-    }
-    return owners;
+export function isAcceptedContact(selfAid, primaryId) {
+    const id = String(primaryId || '').trim();
+    const snapshot = getContactSnapshot(selfAid);
+    const entry = snapshot.contacts.get(id);
+    return !!entry && (entry.status === undefined || entry.status === 'active');
 }
-function normalizePrimaryId(value) {
-    const primaryId = String(value || '').trim();
-    if (!isValidAid(primaryId)) {
-        throw new ContactBookError('INVALID_PRIMARY_ID', `Invalid contact primary AID: ${String(value)}`);
-    }
-    return primaryId;
-}
-function requireLegacyAlias(channelType, actorId) {
-    const alias = normalizeLegacyAlias(channelType, actorId);
-    if (!alias) {
-        throw new ContactBookError('INVALID_ALIAS', `Invalid contact alias: ${String(channelType)}:${String(actorId)}`);
-    }
-    return alias;
-}
-function normalizeLegacyAlias(channelType, actorId) {
-    const channel = String(channelType || '').trim().toLowerCase();
-    const id = String(actorId || '').trim();
-    if (!/^[a-z0-9_-]+$/.test(channel) || !id)
-        return null;
-    return `${channel}:${id}`;
-}
-function normalizeLegacyAliasString(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    if (trimmed.startsWith(SCOPED_ALIAS_PREFIX))
-        return null;
-    const idx = trimmed.indexOf(':');
-    if (idx <= 0 || idx === trimmed.length - 1)
-        return null;
-    return normalizeLegacyAlias(trimmed.slice(0, idx), trimmed.slice(idx + 1));
-}
-function requireScopedAlias(selfAid, channelType, actorId, channelKey) {
-    const normalizedActor = String(actorId || '').trim();
-    const normalizedChannel = String(channelType || '').trim().toLowerCase();
-    const normalizedChannelKey = normalizeChannelKey(selfAid, normalizedChannel, channelKey);
-    if (!normalizedActor || !normalizedChannelKey) {
-        throw new ContactBookError('INVALID_CHANNEL_ALIAS', `Invalid scoped contact alias: ${String(channelKey)}:${String(actorId)}`);
-    }
-    return {
-        lookupKey: scopedAliasLookupKey(normalizedChannelKey, normalizedActor),
-        serialized: serializeScopedAlias(normalizedChannelKey, normalizedActor),
-    };
-}
-function normalizeScopedAliasString(value, selfAid) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed.startsWith(SCOPED_ALIAS_PREFIX))
-        return null;
-    const encoded = trimmed.slice(SCOPED_ALIAS_PREFIX.length);
-    const separator = encoded.indexOf(':');
-    if (separator <= 0 || separator === encoded.length - 1)
-        return null;
+/**
+ * 对端展示名：联系人簿 displayName → principalId。仅用于展示（预览行/日志），
+ * 关系键始终用原生 peerId，不受此影响。
+ *
+ * 非 AUN 渠道的 actorId 是渠道原生 ID（飞书 open_id 等），直接展示不可读；
+ * 联系人簿已把它 alias 到主体 AID 上，取其 displayName 即可。
+ * 未绑定/联系人簿损坏时返回 undefined，由调用方按自己的兜底链继续。
+ */
+export function resolvePeerDisplayLabel(selfAid, channelType, actorId, channelKey) {
+    const actor = String(actorId || '').trim();
+    if (!String(selfAid || '').trim() || !actor)
+        return undefined;
     try {
-        const channelKey = decodeURIComponent(encoded.slice(0, separator));
-        const actorId = decodeURIComponent(encoded.slice(separator + 1)).trim();
-        const channelType = channelKey.split('#', 1)[0]?.toLowerCase() ?? '';
-        const normalizedChannelKey = normalizeChannelKey(selfAid, channelType, channelKey);
-        if (!normalizedChannelKey || !actorId)
-            return null;
-        return {
-            lookupKey: scopedAliasLookupKey(normalizedChannelKey, actorId),
-            serialized: serializeScopedAlias(normalizedChannelKey, actorId),
-        };
+        const { principalId } = resolvePrincipal(selfAid, channelType, actor, channelKey);
+        if (!principalId)
+            return undefined;
+        return resolveContactView(selfAid, principalId).displayName || principalId;
     }
     catch {
-        return null;
+        // 联系人簿损坏（校验失败/alias 冲突）不应影响消息处理
+        return undefined;
     }
 }
-function serializeScopedAlias(channelKey, actorId) {
-    return `${SCOPED_ALIAS_PREFIX}${encodeURIComponent(channelKey)}:${encodeURIComponent(actorId)}`;
-}
-function scopedAliasLookupKey(channelKey, actorId) {
-    return JSON.stringify([channelKey, actorId]);
+function buildSnapshot(book, selfAid, aliases) {
+    const contacts = new Map();
+    const blockedIndex = new Set();
+    const owners = new Set(listAgentOwners(selfAid));
+    for (const [primaryId, rawEntry] of Object.entries(book.contacts)) {
+        if (!isValidAid(primaryId) || isExplicitGroupId(primaryId)) {
+            throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact AID: ${primaryId}`);
+        }
+        if (rawEntry.status === 'blocked' && owners.has(primaryId)) {
+            throw new ContactBookError('INVALID_CONTACT_BOOK', `Owner contact ${primaryId} cannot be blocked`);
+        }
+        const entry = Object.freeze({
+            ...rawEntry,
+            ...(rawEntry.aliases ? { aliases: Object.freeze([...rawEntry.aliases]) } : {}),
+        });
+        contacts.set(primaryId, entry);
+        if (entry.status === 'blocked')
+            blockedIndex.add(primaryId);
+    }
+    return Object.freeze({
+        contacts,
+        aliasIndex: aliases.aliasToPrimary,
+        conflictingAliases: aliases.conflictingAliases,
+        blockedIndex,
+        contactRevision: contactRevision(book),
+    });
 }
-function normalizeChannelKey(selfAid, channelType, value) {
-    const key = typeof value === 'string' ? value.trim() : '';
-    const parts = key.split('#');
-    if (parts.length !== 3)
-        return null;
-    const [rawType, keySelfAid, name] = parts;
-    const normalizedType = rawType.toLowerCase();
-    if (!/^[a-z0-9_-]+$/.test(normalizedType)
-        || normalizedType !== channelType
-        || keySelfAid !== selfAid
-        || !name) {
-        return null;
+function loadAliasMap(selfAid) {
+    const book = readContactBook(selfAid, { cache: true });
+    if (!book)
+        return EMPTY_ALIAS_MAP;
+    const cached = aliasMapCache.get(book);
+    if (cached)
+        return cached;
+    const errors = validateConfig(ConfigTarget.Contact, book);
+    if (errors.length) {
+        throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact book for ${selfAid}: ${errors.join('; ')}`);
     }
-    return `${normalizedType}#${keySelfAid}#${name}`;
+    const built = buildAliasMap(book, selfAid);
+    aliasMapCache.set(book, built);
+    return built;
 }
-function isUnambiguousLegacyChannel(selfAid, channelType, channelKey) {
-    try {
-        const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
-        const matches = new Set();
-        for (const candidate of agent?.channels ?? []) {
-            if (!candidate || typeof candidate !== 'object')
-                continue;
-            const candidateType = String(candidate.type || '').trim().toLowerCase();
-            const candidateName = String(candidate.name || '').trim();
-            if (candidateType !== channelType || !candidateName || candidateName.includes('#'))
+function buildAliasMap(book, selfAid) {
+    const aliasToPrimary = new Map();
+    const conflictingAliases = new Set();
+    for (const [primaryId, entry] of Object.entries(book?.contacts ?? {})) {
+        if (!isValidAid(primaryId) || isExplicitGroupId(primaryId) || !entry || typeof entry !== 'object')
+            continue;
+        for (const rawAlias of entry.aliases ?? []) {
+            const parsed = parseContactAlias(rawAlias, selfAid);
+            if (!parsed) {
+                throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact alias for ${selfAid}: ${String(rawAlias)}`);
+            }
+            const alias = parsed.alias;
+            if (conflictingAliases.has(alias))
                 continue;
-            matches.add(`${candidateType}#${selfAid}#${candidateName}`);
+            const existing = aliasToPrimary.get(alias);
+            if (existing && existing !== primaryId) {
+                aliasToPrimary.delete(alias);
+                conflictingAliases.add(alias);
+            }
+            else {
+                aliasToPrimary.set(alias, primaryId);
+            }
         }
-        return matches.size === 1 && matches.has(channelKey);
-    }
-    catch {
-        return false;
     }
+    return { aliasToPrimary, conflictingAliases };
 }
-function ensureNativeAidIsNotRemapped(primaryId, channelType, actorId) {
-    const channel = String(channelType || '').trim().toLowerCase();
-    const actor = String(actorId || '').trim();
-    if (channel === 'aun' && isValidAid(actor) && actor !== primaryId) {
-        throw new ContactBookError('NATIVE_AID_REMAP_FORBIDDEN', `Native AID "${actor}" cannot be remapped to "${primaryId}"`);
+function normalizePrimaryId(value) {
+    const id = String(value || '').trim();
+    if (!isValidAid(id) || isExplicitGroupId(id)) {
+        throw new ContactBookError('INVALID_PRIMARY_ID', `Invalid individual contact AID: ${String(value)}`);
     }
+    return id;
+}
+function listAgentOwners(selfAid) {
+    const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
+    return [...new Set((agent?.owners ?? []).map(value => String(value || '').trim()).filter(Boolean))];
 }