@agentunion/fastaun-browser 0.5.0 → 0.5.1

package/dist/client/v2-e2ee.js

@@ -3,9 +3,13 @@ import { E2EEError, StateError, ValidationError } from '../errors.js';
 import { normalizeGroupId } from '../group-id.js';
 import { decryptMessage, encryptGroupMessage, encryptP2PMessage, } from '../v2/e2ee/index.js';
 import { V2Session, V2KeyStore } from '../v2/session/index.js';
-import { isJsonObject } from '../types.js';
+import { ConnectionState, isJsonObject } from '../types.js';
 const V2_BOOTSTRAP_TTL_MS = 60 * 60 * 1000;
 const V2_RETRYABLE_CODES = new Set([-33011, -33012, -33050, -33052, -33054]);
+const V2_GROUP_STALE_BOOTSTRAP_CODE = -33054;
+const V2_SESSION_INIT_RETRY_LIMIT = 12;
+const V2_SESSION_INIT_RETRY_BASE_MS = 1000;
+const V2_SESSION_INIT_RETRY_MAX_MS = 5000;
 const MEMBERSHIP_ACTIONS = new Set([
     'member_added',
     'member_left',
@@ -57,6 +61,17 @@ function v2B64uToBytes(value) {
 function formatE2EEError(error) {
     return error instanceof Error ? error : String(error);
 }
+function isTransientV2SessionInitError(error) {
+    const text = (error instanceof Error ? error.message : String(error)).toLowerCase();
+    return text.includes('no_service')
+        || text.includes('service plane unavailable')
+        || text.includes('transport not connected')
+        || text.includes('transport closed')
+        || text.includes('websocket closed')
+        || text.includes('websocket is not open')
+        || text.includes('connection closed')
+        || text.includes('socket closed');
+}
 function uuidV4() {
     if (typeof crypto.randomUUID === 'function')
         return crypto.randomUUID();
@@ -203,6 +218,10 @@ function applyV2WrapPolicyToTargets(targets, policy) {
 }
 export class V2E2EECoordinator {
     runtime;
+    targetSetCache = new Map();
+    v2SessionInitRetryTimer = null;
+    v2SessionInitRetryBackgroundSync = false;
+    v2SessionInitRetryIdentityKey = null;
     constructor(runtime) {
         this.runtime = runtime;
     }
@@ -224,29 +243,151 @@ export class V2E2EECoordinator {
     }
     deleteBootstrapCacheEntry(key) {
         this.bootstrapCache.delete(key);
+        this.targetSetCache.delete(key);
     }
     clearBootstrapCache() {
         this.bootstrapCache.clear();
+        this.targetSetCache.clear();
     }
     pruneExpiredBootstrapCache(ttlMs, now = Date.now()) {
         for (const [key, entry] of this.bootstrapCache) {
             if (now - Number(entry.cachedAt ?? 0) >= ttlMs) {
                 this.bootstrapCache.delete(key);
+                this.targetSetCache.delete(key);
+            }
+        }
+        for (const [key, entry] of this.targetSetCache) {
+            if (now - Number(entry.cachedAt ?? 0) >= ttlMs) {
+                this.targetSetCache.delete(key);
             }
         }
     }
+    getTargetSetCache(key) {
+        const cached = this.targetSetCache.get(key);
+        if (!cached || Date.now() - cached.cachedAt >= V2_BOOTSTRAP_TTL_MS) {
+            if (cached)
+                this.targetSetCache.delete(key);
+            return undefined;
+        }
+        return cached.value;
+    }
+    setTargetSetCache(key, value) {
+        this.targetSetCache.set(key, { cachedAt: Date.now(), value });
+        return value;
+    }
+    cloneP2PTargetSet(value) {
+        return {
+            targets: value.targets.map((target) => ({ ...target })),
+            auditRecipients: value.auditRecipients.map((target) => ({ ...target })),
+        };
+    }
+    cloneGroupTargetSet(value) {
+        return {
+            targets: value.targets.map((target) => ({ ...target })),
+        };
+    }
     async onConnected(opts) {
         const client = this.client;
         try {
             await client._initV2Session();
+            this.clearV2SessionInitRetry();
         }
         catch (exc) {
             client._clientLog.warn(`V2 session init failed (non-fatal): ${formatE2EEError(exc)}`);
+            if (isTransientV2SessionInitError(exc)) {
+                this.scheduleV2SessionInitRetry(1, opts.backgroundSync, exc);
+            }
         }
         if (opts.backgroundSync && client._v2Session && typeof client._v2AutoConfirmPendingProposals === 'function') {
             client._safeAsync(client._v2AutoConfirmPendingProposals());
         }
     }
+    currentV2SessionInitRetryIdentityKey() {
+        const client = this.client;
+        if (!client._aid)
+            return null;
+        return JSON.stringify([
+            client._aid,
+            client._deviceId ?? '',
+            client._currentAid ?? null,
+            Number(client._v2RuntimeGeneration ?? 0),
+        ]);
+    }
+    canRetryV2SessionInit(identityKey) {
+        const client = this.client;
+        return client.state === ConnectionState.READY
+            && !client._closing
+            && this.currentV2SessionInitRetryIdentityKey() === identityKey;
+    }
+    clearV2SessionInitRetry() {
+        if (this.v2SessionInitRetryTimer) {
+            globalThis.clearTimeout(this.v2SessionInitRetryTimer);
+            this.v2SessionInitRetryTimer = null;
+        }
+        this.v2SessionInitRetryBackgroundSync = false;
+        this.v2SessionInitRetryIdentityKey = null;
+    }
+    scheduleV2SessionInitRetry(attempt, backgroundSync, reason) {
+        const client = this.client;
+        if (attempt > V2_SESSION_INIT_RETRY_LIMIT) {
+            this.v2SessionInitRetryBackgroundSync = false;
+            this.v2SessionInitRetryIdentityKey = null;
+            client._clientLog.warn(`V2 session init retry exhausted: attempts=${V2_SESSION_INIT_RETRY_LIMIT} last_error=${formatE2EEError(reason)}`);
+            return;
+        }
+        const identityKey = this.currentV2SessionInitRetryIdentityKey();
+        if (!identityKey || !this.canRetryV2SessionInit(identityKey))
+            return;
+        if (this.v2SessionInitRetryIdentityKey && this.v2SessionInitRetryIdentityKey !== identityKey) {
+            this.clearV2SessionInitRetry();
+        }
+        if (this.v2SessionInitRetryTimer) {
+            this.v2SessionInitRetryBackgroundSync = this.v2SessionInitRetryBackgroundSync || backgroundSync;
+            return;
+        }
+        this.v2SessionInitRetryIdentityKey = identityKey;
+        this.v2SessionInitRetryBackgroundSync = this.v2SessionInitRetryBackgroundSync || backgroundSync;
+        const delayMs = Math.min(V2_SESSION_INIT_RETRY_BASE_MS * attempt, V2_SESSION_INIT_RETRY_MAX_MS);
+        client._clientLog.debug(`V2 session init retry scheduled: attempt=${attempt} delay_ms=${delayMs} reason=${formatE2EEError(reason)}`);
+        this.v2SessionInitRetryTimer = globalThis.setTimeout(() => {
+            this.v2SessionInitRetryTimer = null;
+            if (!this.canRetryV2SessionInit(identityKey)) {
+                this.clearV2SessionInitRetry();
+                return;
+            }
+            client._safeAsync(this.retryV2SessionInit(attempt, identityKey));
+        }, delayMs);
+    }
+    async retryV2SessionInit(attempt, identityKey) {
+        const client = this.client;
+        if (!this.canRetryV2SessionInit(identityKey)) {
+            this.clearV2SessionInitRetry();
+            return;
+        }
+        try {
+            await client._initV2Session();
+            const backgroundSync = this.v2SessionInitRetryBackgroundSync;
+            this.clearV2SessionInitRetry();
+            client._clientLog.debug(`V2 session init retry succeeded: attempt=${attempt}`);
+            if (backgroundSync && client._v2Session) {
+                if (typeof client._v2AutoConfirmPendingProposals === 'function') {
+                    client._safeAsync(client._v2AutoConfirmPendingProposals());
+                }
+                if (typeof client._fillP2pGap === 'function') {
+                    client._safeAsync(client._fillP2pGap());
+                }
+            }
+        }
+        catch (exc) {
+            client._clientLog.warn(`V2 session init retry failed: attempt=${attempt} err=${formatE2EEError(exc)}`);
+            if (isTransientV2SessionInitError(exc)) {
+                this.scheduleV2SessionInitRetry(attempt + 1, this.v2SessionInitRetryBackgroundSync, exc);
+            }
+            else {
+                this.clearV2SessionInitRetry();
+            }
+        }
+    }
     async initV2Session() {
         const client = this.client;
         if (!client._aid)
@@ -563,6 +704,7 @@ export class V2E2EECoordinator {
         const decrypted = [];
         let nextAfterSeq = opts?.force ? afterSeq : (afterSeq || (ns ? client._seqTracker.getContiguousSeq(ns) : 0));
         let pageCount = 0;
+        let lastAutoAckSeq = 0;
         const maxPages = 100;
         while (pageCount < maxPages) {
             pageCount += 1;
@@ -571,7 +713,12 @@ export class V2E2EECoordinator {
                 limit,
                 ...(opts?.force ? { force: true } : {}),
             });
-            const messages = (Array.isArray(result?.messages) ? result.messages : []);
+            const pageMessages = (Array.isArray(result?.messages) ? result.messages : []);
+            const messages = pageMessages.filter((msg) => {
+                const seq = Number(msg.seq ?? 0);
+                return Number.isFinite(seq) && seq > nextAfterSeq;
+            });
+            client._clientLog.debug(`message.v2.pull page response: page=${pageCount}, raw_count=${messages.length}, stale_count=${Math.max(0, pageMessages.length - messages.length)}, has_more=${String(result.has_more ?? '')}, server_ack_seq=${String(result.server_ack_seq ?? '')}`);
             const seqs = messages
                 .map((msg) => Number(msg.seq ?? 0))
                 .filter((seq) => Number.isFinite(seq) && seq > 0);
@@ -650,17 +797,19 @@ export class V2E2EECoordinator {
                 const contigAdvanced = ackSeq !== pageContigBefore;
                 if (contigAdvanced) {
                     await client._drainOrderedMessages(ns);
-                    client._saveSeqTrackerState();
+                    client._persistSeq(ns);
                 }
-                const ackNeeded = messages.length > 0
+                const ackNeeded = pageMessages.length > 0
                     && ackSeq > 0
+                    && ackSeq > lastAutoAckSeq
                     && (contigAdvanced || (hasServerAckSeq && ackSeq > serverAckSeq));
                 if (ackNeeded) {
                     await this.ackV2(ackSeq);
+                    lastAutoAckSeq = ackSeq;
                 }
             }
             const nextAfter = Math.max(pageMaxSeq, nextAfterSeq);
-            if (messages.length === 0 || nextAfter <= nextAfterSeq || result.has_more === false)
+            if (messages.length === 0 || nextAfter <= nextAfterSeq)
                 break;
             nextAfterSeq = nextAfter;
         }
@@ -737,7 +886,7 @@ export class V2E2EECoordinator {
                     const ns = `group:${gid}`;
                     client._seqTracker.onMessageSeq(ns, seq);
                     client._markPublishedSeq(ns, seq);
-                    client._saveSeqTrackerState();
+                    await client._saveSeqTrackerState();
                 }
             }
             return client._delivery.attachSendResultEnvelope('group.send', {
@@ -761,7 +910,7 @@ export class V2E2EECoordinator {
                         const ns = `group:${gid}`;
                         client._seqTracker.onMessageSeq(ns, seq);
                         client._markPublishedSeq(ns, seq);
-                        client._saveSeqTrackerState();
+                        await client._saveSeqTrackerState();
                     }
                 }
                 return client._delivery.attachSendResultEnvelope('group.send', {
@@ -787,6 +936,7 @@ export class V2E2EECoordinator {
             throw new ValidationError('group.pull requires group_id');
         const ns = `group:${gid}`;
         const decrypted = [];
+        const wireGroupId = String(opts?.wireGroupId ?? groupId ?? '').trim() || gid;
         const cursorParams = opts?.cursorParams ?? {};
         const ownsCursor = opts?.ownsCursor !== false;
         let nextAfterSeq = opts?.explicitAfterSeq ? afterSeq : (afterSeq || client._seqTracker.getContiguousSeq(ns));
@@ -795,7 +945,8 @@ export class V2E2EECoordinator {
         while (pageCount < maxPages) {
             pageCount += 1;
             const result = await client._callRawV2Rpc('group.v2.pull', {
-                group_id: gid,
+                group_id: wireGroupId,
+                group_aid: gid,
                 after_seq: nextAfterSeq,
                 limit,
                 ...cursorParams,
@@ -886,7 +1037,7 @@ export class V2E2EECoordinator {
             const contigAdvanced = ackSeq !== pageContigBefore;
             if (contigAdvanced) {
                 await client._drainOrderedMessages(ns);
-                client._saveSeqTrackerState();
+                client._persistSeq(ns);
             }
             const hasServerCursor = cursor !== null && Object.prototype.hasOwnProperty.call(cursor, 'current_seq');
             const ackNeeded = messages.length > 0
@@ -918,7 +1069,7 @@ export class V2E2EECoordinator {
         if (!Number.isFinite(seq) || seq <= 0)
             return { acked: 0 };
         seq = client._clampAckSeq('group.v2.ack', 'up_to_seq', ns, seq);
-        return client._callRawV2Rpc('group.v2.ack', { group_id: gid, up_to_seq: seq });
+        return client._callRawV2Rpc('group.v2.ack', { group_id: gid, group_aid: gid, up_to_seq: seq });
     }
     async putMessageThoughtEncryptedV2(params) {
         const client = this.client;
@@ -1429,6 +1580,7 @@ export class V2E2EECoordinator {
             wrapPolicy = cached.wrapPolicy;
         }
         else {
+            this.targetSetCache.delete(to);
             const bs = await client.call('message.v2.bootstrap', {
                 peer_aid: to,
                 e2ee_wrap_capabilities: v2WrapCapabilities(),
@@ -1448,73 +1600,85 @@ export class V2E2EECoordinator {
         if (peerDevices.length === 0) {
             throw new E2EEError(`V2 bootstrap: no devices found for ${to}`);
         }
-        const targets = [];
-        for (const dev of peerDevices) {
-            const devId = getV2DeviceId(dev);
-            const target = await client._v2BuildTargetFromDevice({
-                dev,
-                aid: to,
-                deviceId: devId.value,
-                role: 'peer',
-                defaultKeySource: 'peer_device_prekey',
-            });
-            if (target)
-                targets.push(target);
-        }
-        for (const dev of auditRaw) {
-            const target = await client._v2BuildTargetFromDevice({
-                dev,
-                aid: String(dev.aid ?? ''),
-                deviceId: String(dev.device_id ?? ''),
-                role: 'audit',
-                defaultKeySource: 'peer_device_prekey',
-            });
-            if (target)
-                targets.push(target);
+        let targetSet = useCache ? this.getTargetSetCache(to) : undefined;
+        if (targetSet) {
+            targetSet = this.cloneP2PTargetSet(targetSet);
         }
-        if (client._aid && client._aid !== to) {
-            try {
-                const selfCached = this.getBootstrapCacheEntry(client._aid);
-                let selfDevices = [];
-                if (selfCached && (Date.now() - Number(selfCached.cachedAt ?? 0)) < V2_BOOTSTRAP_TTL_MS) {
-                    selfDevices = (selfCached.devices ?? []);
-                }
-                else {
-                    const selfBs = await client.call('message.v2.bootstrap', {
-                        peer_aid: client._aid,
-                        e2ee_wrap_capabilities: v2WrapCapabilities(),
-                    });
-                    selfDevices = (Array.isArray(selfBs?.peer_devices) ? selfBs.peer_devices : []);
-                    if (selfDevices.length > 0) {
-                        this.setBootstrapCacheEntry(client._aid, {
-                            devices: selfDevices,
-                            auditRecipients: [],
-                            cachedAt: Date.now(),
+        else {
+            const targets = [];
+            for (const dev of peerDevices) {
+                const devId = getV2DeviceId(dev);
+                const target = await client._v2BuildTargetFromDevice({
+                    dev,
+                    aid: to,
+                    deviceId: devId.value,
+                    role: 'peer',
+                    defaultKeySource: 'peer_device_prekey',
+                });
+                if (target)
+                    targets.push(target);
+            }
+            const auditTargets = [];
+            for (const dev of auditRaw) {
+                const target = await client._v2BuildTargetFromDevice({
+                    dev,
+                    aid: String(dev.aid ?? ''),
+                    deviceId: String(dev.device_id ?? ''),
+                    role: 'audit',
+                    defaultKeySource: 'peer_device_prekey',
+                });
+                if (target)
+                    auditTargets.push(target);
+            }
+            if (client._aid && client._aid !== to) {
+                try {
+                    const selfCached = this.getBootstrapCacheEntry(client._aid);
+                    let selfDevices = [];
+                    if (selfCached && (Date.now() - Number(selfCached.cachedAt ?? 0)) < V2_BOOTSTRAP_TTL_MS) {
+                        selfDevices = (selfCached.devices ?? []);
+                    }
+                    else {
+                        this.targetSetCache.delete(client._aid);
+                        const selfBs = await client.call('message.v2.bootstrap', {
+                            peer_aid: client._aid,
+                            e2ee_wrap_capabilities: v2WrapCapabilities(),
+                        });
+                        selfDevices = (Array.isArray(selfBs?.peer_devices) ? selfBs.peer_devices : []);
+                        if (selfDevices.length > 0) {
+                            this.setBootstrapCacheEntry(client._aid, {
+                                devices: selfDevices,
+                                auditRecipients: [],
+                                cachedAt: Date.now(),
+                            });
+                        }
+                    }
+                    for (const dev of selfDevices) {
+                        const devId = getV2DeviceId(dev);
+                        if (!devId.present || devId.value === client._deviceId)
+                            continue;
+                        const target = await client._v2BuildTargetFromDevice({
+                            dev,
+                            aid: client._aid,
+                            deviceId: devId.value,
+                            role: 'self_sync',
+                            defaultKeySource: 'peer_device_prekey',
                         });
+                        if (target)
+                            targets.push(target);
                     }
                 }
-                for (const dev of selfDevices) {
-                    const devId = getV2DeviceId(dev);
-                    if (!devId.present || devId.value === client._deviceId)
-                        continue;
-                    const target = await client._v2BuildTargetFromDevice({
-                        dev,
-                        aid: client._aid,
-                        deviceId: devId.value,
-                        role: 'self_sync',
-                        defaultKeySource: 'peer_device_prekey',
-                    });
-                    if (target)
-                        targets.push(target);
+                catch (exc) {
+                    client._clientLog.debug(`V2 thought self-sync bootstrap failed (non-fatal): ${String(exc)}`);
                 }
             }
-            catch (exc) {
-                client._clientLog.debug(`V2 thought self-sync bootstrap failed (non-fatal): ${String(exc)}`);
-            }
+            targetSet = this.setTargetSetCache(to, {
+                targets: applyV2WrapPolicyToTargets(targets, wrapPolicy),
+                auditRecipients: applyV2WrapPolicyToTargets(auditTargets, wrapPolicy),
+            });
+            targetSet = this.cloneP2PTargetSet(targetSet);
         }
         const sender = await session.getSenderIdentity();
-        const sendTargets = applyV2WrapPolicyToTargets(targets, wrapPolicy);
-        const envelope = await encryptP2PMessage(sender, { targets: sendTargets, auditRecipients: [] }, opts.payload, { messageId: opts.messageId, timestamp: opts.timestamp, protectedHeaders: opts.protectedHeaders, context: opts.context });
+        const envelope = await encryptP2PMessage(sender, targetSet, opts.payload, { messageId: opts.messageId, timestamp: opts.timestamp, protectedHeaders: opts.protectedHeaders, context: opts.context });
         return envelope;
     }
     async buildV2GroupEnvelope(opts) {
@@ -1523,7 +1687,8 @@ export class V2E2EECoordinator {
             throw new StateError('V2 session not initialized');
         }
         const session = client._v2Session;
-        const groupId = normalizeGroupId(opts.groupId) || String(opts.groupId ?? '').trim();
+        const rawGroupId = String(opts.groupId ?? '').trim();
+        const groupId = normalizeGroupId(rawGroupId) || rawGroupId;
         if (!groupId)
             throw new ValidationError("group.send requires 'group_id'");
         const useCache = opts.useCache !== false;
@@ -1533,15 +1698,26 @@ export class V2E2EECoordinator {
         let stateCommitment = { state_version: 0, state_hash: '', state_chain: '' };
         let auditRecipientsRaw = [];
         let wrapPolicy;
-        const cached = useCache ? this.getBootstrapCacheEntry(cacheKey) : undefined;
+        let usedCachedBootstrap = false;
+        let cached = useCache ? this.getBootstrapCacheEntry(cacheKey) : undefined;
+        if (!cached && useCache && rawGroupId && rawGroupId !== groupId) {
+            const legacyCacheKey = `group:${rawGroupId}`;
+            cached = this.getBootstrapCacheEntry(legacyCacheKey);
+            if (cached) {
+                this.setBootstrapCacheEntry(cacheKey, cached);
+                this.deleteBootstrapCacheEntry(legacyCacheKey);
+            }
+        }
         if (cached && (Date.now() - Number(cached.cachedAt ?? 0)) < V2_BOOTSTRAP_TTL_MS) {
             allDevices = (cached.devices ?? []);
             epoch = Number(cached.epoch ?? 0) || 0;
             stateCommitment = cached.stateCommitment ?? { state_version: 0, state_hash: '', state_chain: '' };
             auditRecipientsRaw = (cached.auditRecipients ?? []);
             wrapPolicy = cached.wrapPolicy;
+            usedCachedBootstrap = true;
         }
         else {
+            this.targetSetCache.delete(cacheKey);
             const bs = await client.call('group.v2.bootstrap', {
                 group_id: groupId,
                 e2ee_wrap_capabilities: v2WrapCapabilities(),
@@ -1576,40 +1752,64 @@ export class V2E2EECoordinator {
         if (allDevices.length === 0) {
             throw new E2EEError(`V2 group bootstrap: no devices found for group ${groupId}`);
         }
-        const targets = [];
-        for (const dev of allDevices) {
-            const devAid = String(dev.aid ?? '').trim();
-            const devId = getV2DeviceId(dev);
-            if (devAid === client._aid && devId.present && devId.value === client._deviceId)
-                continue;
-            const role = devAid === client._aid ? 'self_sync' : 'member';
-            const target = await client._v2BuildTargetFromDevice({
-                dev,
-                aid: devAid,
-                deviceId: devId.value,
-                role,
-                defaultKeySource: 'peer_device_prekey',
+        let targetSet = useCache ? this.getTargetSetCache(cacheKey) : undefined;
+        if (targetSet) {
+            targetSet = this.cloneGroupTargetSet(targetSet);
+        }
+        else {
+            const targets = [];
+            for (const dev of allDevices) {
+                const devAid = String(dev.aid ?? '').trim();
+                const devId = getV2DeviceId(dev);
+                if (devAid === client._aid && devId.present && devId.value === client._deviceId)
+                    continue;
+                const role = devAid === client._aid ? 'self_sync' : 'member';
+                const target = await client._v2BuildTargetFromDevice({
+                    dev,
+                    aid: devAid,
+                    deviceId: devId.value,
+                    role,
+                    defaultKeySource: 'peer_device_prekey',
+                });
+                if (target)
+                    targets.push(target);
+            }
+            if (targets.length === 0) {
+                if (usedCachedBootstrap) {
+                    throw new E2EEError(`V2 group: no target devices for group ${groupId}; bootstrap may be stale`, {
+                        code: V2_GROUP_STALE_BOOTSTRAP_CODE,
+                        data: { expected_peer_aids: [] },
+                    });
+                }
+                throw new E2EEError(`V2 group: no target devices for group ${groupId}`);
+            }
+            for (const dev of auditRecipientsRaw) {
+                const target = await client._v2BuildTargetFromDevice({
+                    dev,
+                    aid: String(dev.aid ?? ''),
+                    deviceId: String(dev.device_id ?? ''),
+                    role: 'audit',
+                    defaultKeySource: 'peer_device_prekey',
+                });
+                if (target)
+                    targets.push(target);
+            }
+            targetSet = this.setTargetSetCache(cacheKey, {
+                targets: applyV2WrapPolicyToTargets(targets, wrapPolicy),
             });
-            if (target)
-                targets.push(target);
+            targetSet = this.cloneGroupTargetSet(targetSet);
         }
-        if (targets.length === 0) {
+        if (targetSet.targets.length === 0) {
+            if (usedCachedBootstrap) {
+                throw new E2EEError(`V2 group: no target devices for group ${groupId}; bootstrap may be stale`, {
+                    code: V2_GROUP_STALE_BOOTSTRAP_CODE,
+                    data: { expected_peer_aids: [] },
+                });
+            }
             throw new E2EEError(`V2 group: no target devices for group ${groupId}`);
         }
-        for (const dev of auditRecipientsRaw) {
-            const target = await client._v2BuildTargetFromDevice({
-                dev,
-                aid: String(dev.aid ?? ''),
-                deviceId: String(dev.device_id ?? ''),
-                role: 'audit',
-                defaultKeySource: 'peer_device_prekey',
-            });
-            if (target)
-                targets.push(target);
-        }
         const sender = await session.getSenderIdentity();
-        const sendTargets = applyV2WrapPolicyToTargets(targets, wrapPolicy);
-        const envelope = await encryptGroupMessage(sender, groupId, epoch, sendTargets, opts.payload, { messageId: opts.messageId, timestamp: opts.timestamp, protectedHeaders: opts.protectedHeaders, context: opts.context }, stateCommitment);
+        const envelope = await encryptGroupMessage(sender, groupId, epoch, targetSet.targets, opts.payload, { messageId: opts.messageId, timestamp: opts.timestamp, protectedHeaders: opts.protectedHeaders, context: opts.context }, stateCommitment);
         return envelope;
     }
     handleGroupChangedSpk(data, groupId, action) {
@@ -1627,26 +1827,5 @@ export class V2E2EECoordinator {
             this.scheduleGroupSpkRotation(groupId, { reason: `group_changed:${action}` });
         }
     }
-    async handleV2EpochRotated(data) {
-        const client = this.client;
-        if (!data || typeof data !== 'object' || Array.isArray(data))
-            return;
-        const d = data;
-        const groupId = String(d.group_id ?? '').trim();
-        if (!groupId)
-            return;
-        const epoch = d.epoch ?? 0;
-        client._clientLog.debug(`_onV2EpochRotated: group=${groupId} epoch=${String(epoch)}`);
-        this.deleteBootstrapCacheEntry(`group:${groupId}`);
-        if (!client._v2Session)
-            return;
-        try {
-            await client._v2Session.rotateSPK(client._v2CallFn());
-            client._clientLog.info(`SPK rotated after epoch change: group=${groupId} epoch=${String(epoch)}`);
-        }
-        catch (exc) {
-            client._clientLog.debug(`SPK rotation after epoch change failed (non-fatal): ${formatE2EEError(exc)}`);
-        }
-    }
 }
 //# sourceMappingURL=v2-e2ee.js.map