@agentunion/fastaun 0.4.6 → 0.4.8

package/dist/client/v2-e2ee.js

@@ -0,0 +1,1640 @@
+import * as crypto from 'node:crypto';
+import { normalizeGroupId } from '../group-id.js';
+import { E2EEError, StateError, ValidationError } from '../errors.js';
+import { decryptMessage, encryptGroupMessage, encryptP2PMessage, } from '../v2/e2ee/index.js';
+import { V2Session } from '../v2/session/index.js';
+import { isJsonObject } from '../types.js';
+const V2_BOOTSTRAP_TTL_MS = 60 * 60 * 1000;
+const V2_RETRYABLE_CODES = new Set([-33011, -33012, -33050, -33052, -33054]);
+const MEMBERSHIP_ACTIONS = new Set([
+    'member_added',
+    'member_left',
+    'member_removed',
+    'role_changed',
+    'owner_transferred',
+    'joined',
+    'join_approved',
+    'invite_code_used',
+]);
+const JOIN_ACTIONS = new Set(['member_added', 'joined', 'join_approved', 'invite_code_used']);
+function pubDerMatchesFingerprint(pubDer, certFingerprint) {
+    const expected = String(certFingerprint ?? '').trim().toLowerCase();
+    if (!expected)
+        return true;
+    if (!expected.startsWith('sha256:'))
+        return false;
+    const expectedHex = expected.slice('sha256:'.length);
+    if (![16, 64].includes(expectedHex.length) || !/^[0-9a-f]+$/.test(expectedHex))
+        return false;
+    const spkiHex = crypto.createHash('sha256').update(Buffer.from(pubDer)).digest('hex');
+    return expectedHex.length === 16 ? spkiHex.slice(0, 16) === expectedHex : spkiHex === expectedHex;
+}
+function v2LeftPad32(bytes) {
+    if (bytes.length === 32)
+        return bytes;
+    if (bytes.length > 32)
+        return bytes.subarray(bytes.length - 32);
+    const out = new Uint8Array(32);
+    out.set(bytes, 32 - bytes.length);
+    return out;
+}
+function v2B64ToBytes(value) {
+    const buf = Buffer.from(String(value ?? '').trim(), 'base64');
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function v2B64uToBytes(value) {
+    const std = String(value ?? '').replace(/-/g, '+').replace(/_/g, '/');
+    const pad = std.length % 4 === 0 ? '' : '='.repeat(4 - (std.length % 4));
+    return v2B64ToBytes(std + pad);
+}
+function formatE2EEError(error) {
+    return error instanceof Error ? error : String(error);
+}
+function truthyBool(value) {
+    if (value === true || value === 1)
+        return true;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+    }
+    return false;
+}
+function attachGatewayProximity(message, source) {
+    if (isJsonObject(source.proximity)) {
+        message.proximity = { ...source.proximity };
+    }
+    for (const key of ['same_device', 'same_network', 'same_egress_ip']) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            message[key] = source[key];
+        }
+    }
+}
+function getV2DeviceId(dev) {
+    if (Object.prototype.hasOwnProperty.call(dev, 'device_id')) {
+        return { present: true, value: String(dev.device_id ?? '').trim() };
+    }
+    if (Object.prototype.hasOwnProperty.call(dev, 'owner_device_id')) {
+        return { present: true, value: String(dev.owner_device_id ?? '').trim() };
+    }
+    return { present: false, value: '' };
+}
+function normalizeV2WrapPolicy(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return { explicit: false, version: '', protocol: '', scope: 'device' };
+    }
+    const obj = raw;
+    let protocol = String(obj.protocol ?? '').trim().toUpperCase();
+    if (protocol !== '1DH' && protocol !== '3DH')
+        protocol = '';
+    let scope = String(obj.scope ?? '').trim().toLowerCase();
+    if (scope !== 'aid' && scope !== 'device') {
+        scope = obj.per_aid_wrap === true ? 'aid' : 'device';
+    }
+    if (scope === 'aid')
+        protocol = '1DH';
+    return {
+        explicit: true,
+        version: String(obj.version ?? ''),
+        protocol,
+        scope: scope,
+    };
+}
+function v2WrapCapabilities() {
+    return {
+        version: 'v2.1',
+        protocols: ['1DH', '3DH'],
+        scopes: ['aid', 'device'],
+        per_aid_wrap: true,
+        per_device_wrap: true,
+    };
+}
+function applyV2WrapPolicyToTargets(targets, policy) {
+    if (!policy.explicit)
+        return targets;
+    const out = [];
+    const seen = new Set();
+    for (const target of targets) {
+        const row = { ...target };
+        if (policy.protocol === '1DH') {
+            row.keySource = 'aid_master';
+            row.spkPkDer = undefined;
+            row.spkId = '';
+        }
+        if (policy.scope === 'aid') {
+            const key = `${row.aid}\x1f${row.role}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            row.deviceId = '';
+        }
+        out.push(row);
+    }
+    return out;
+}
+export class V2E2EECoordinator {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    get client() {
+        return this.runtime.client;
+    }
+    get bootstrapCache() {
+        const client = this.client;
+        if (!(client._v2BootstrapCache instanceof Map)) {
+            client._v2BootstrapCache = new Map();
+        }
+        return client._v2BootstrapCache;
+    }
+    getBootstrapCacheEntry(key) {
+        return this.bootstrapCache.get(key);
+    }
+    setBootstrapCacheEntry(key, entry) {
+        this.bootstrapCache.set(key, entry);
+    }
+    deleteBootstrapCacheEntry(key) {
+        this.bootstrapCache.delete(key);
+    }
+    clearBootstrapCache() {
+        this.bootstrapCache.clear();
+    }
+    pruneExpiredBootstrapCache(ttlMs, now = Date.now()) {
+        for (const [key, entry] of this.bootstrapCache) {
+            if (now - Number(entry.cachedAt ?? 0) >= ttlMs) {
+                this.bootstrapCache.delete(key);
+            }
+        }
+    }
+    async onConnected(opts) {
+        const client = this.client;
+        try {
+            await client._initV2Session();
+        }
+        catch (exc) {
+            client._clientLog.warn(`V2 session init failed (non-fatal): ${formatE2EEError(exc)}`);
+        }
+        if (opts.backgroundSync && client._v2Session && typeof client._v2AutoConfirmPendingProposals === 'function') {
+            client._safeAsync(client._v2AutoConfirmPendingProposals());
+        }
+    }
+    async initV2Session() {
+        const client = this.client;
+        if (!client._aid)
+            return;
+        const aidAtStart = client._aid;
+        const deviceIdAtStart = client._deviceId;
+        const currentAid = client._currentAid;
+        const generationAtStart = Number(client._v2RuntimeGeneration ?? 0);
+        const existing = client._v2Session;
+        if (existing && existing.aid === aidAtStart && existing.deviceId === deviceIdAtStart) {
+            return;
+        }
+        if (existing) {
+            this.clearBootstrapCache();
+        }
+        const identityChanged = () => client._aid !== aidAtStart
+            || client._deviceId !== deviceIdAtStart
+            || client._currentAid !== currentAid
+            || Number(client._v2RuntimeGeneration ?? 0) !== generationAtStart;
+        if (!currentAid?.privateKeyPem) {
+            client._clientLog.warn('V2 session init skipped: no AID private key');
+            return;
+        }
+        const privateKey = crypto.createPrivateKey(currentAid.privateKeyPem);
+        const jwk = privateKey.export({ format: 'jwk' });
+        if (jwk.kty !== 'EC' || jwk.crv !== 'P-256' || !jwk.d) {
+            throw new StateError('AID private key must be EC P-256');
+        }
+        const aidPriv = v2LeftPad32(v2B64uToBytes(jwk.d));
+        const pubDer = crypto.createPublicKey(privateKey).export({ format: 'der', type: 'spki' });
+        const aidPubDer = new Uint8Array(pubDer);
+        const storeProvider = client._tokenStore;
+        const v2Store = storeProvider.getV2KeyStore?.call(client._tokenStore, client._aid);
+        if (!v2Store) {
+            throw new StateError('V2 key store is unavailable for current keystore');
+        }
+        if (identityChanged())
+            return;
+        const session = new V2Session(v2Store, deviceIdAtStart, aidAtStart, aidPriv, aidPubDer);
+        await session.ensureRegistered(client._v2CallFn());
+        if (identityChanged())
+            return;
+        client._v2KeyStore = v2Store;
+        client._v2Session = session;
+        client._clientLog.debug(`V2 session initialized aid=${aidAtStart} device=${deviceIdAtStart}`);
+    }
+    scheduleGroupSpkRegistration(groupId, opts) {
+        const client = this.client;
+        const gid = String(groupId ?? '').trim();
+        if (!gid || !client._v2Session)
+            return;
+        if (!(client._groupSpkRegistrationInflight instanceof Set)) {
+            client._groupSpkRegistrationInflight = new Set();
+        }
+        const inflight = client._groupSpkRegistrationInflight;
+        if (inflight.has(gid))
+            return;
+        inflight.add(gid);
+        client._safeAsync((async () => {
+            try {
+                await client._v2Session.ensureGroupRegistered?.(gid, client._v2CallFn());
+                client._clientLog.debug(`group SPK registered: group=${gid} reason=${opts.reason}`);
+            }
+            catch (exc) {
+                client._clientLog.debug(`group SPK registration failed (non-fatal): group=${gid} reason=${opts.reason} err=${formatE2EEError(exc)}`);
+            }
+            finally {
+                inflight.delete(gid);
+            }
+        })());
+    }
+    scheduleGroupSpkRotation(groupId, opts) {
+        const client = this.client;
+        const gid = String(groupId ?? '').trim();
+        if (!gid || !client._v2Session)
+            return;
+        if (!(client._groupSpkRotationInflight instanceof Set)) {
+            client._groupSpkRotationInflight = new Set();
+        }
+        const inflight = client._groupSpkRotationInflight;
+        if (inflight.has(gid))
+            return;
+        inflight.add(gid);
+        client._safeAsync((async () => {
+            try {
+                await client._v2Session.rotateGroupSPK?.(gid, client._v2CallFn());
+                client._clientLog.debug(`group SPK rotated: group=${gid} reason=${opts.reason}`);
+            }
+            catch (exc) {
+                client._clientLog.debug(`group SPK rotation failed (non-fatal): group=${gid} reason=${opts.reason} err=${formatE2EEError(exc)}`);
+            }
+            finally {
+                inflight.delete(gid);
+            }
+        })());
+    }
+    scheduleGroupSpkRegistrationAfterPeerFallback(groupId) {
+        const client = this.client;
+        const gid = String(groupId ?? '').trim();
+        if (!gid)
+            return;
+        if (!(client._groupSpkPeerFallbackRegistered instanceof Set)) {
+            client._groupSpkPeerFallbackRegistered = new Set();
+        }
+        const registered = client._groupSpkPeerFallbackRegistered;
+        if (registered.has(gid))
+            return;
+        registered.add(gid);
+        this.scheduleGroupSpkRegistration(gid, { reason: 'peer_device_prekey_fallback' });
+    }
+    async getV2SenderPubDer(fromAid, senderDeviceId, certFingerprint) {
+        const client = this.client;
+        const session = client._v2Session;
+        if (!session || !fromAid)
+            return null;
+        const senderPubDer = session.getPeerIK(fromAid, senderDeviceId);
+        if (senderPubDer && pubDerMatchesFingerprint(senderPubDer, certFingerprint))
+            return senderPubDer;
+        try {
+            const normalizedFp = String(certFingerprint ?? '').trim() || undefined;
+            const certPem = await client._fetchPeerCert(fromAid, normalizedFp, 3000);
+            const cert = new crypto.X509Certificate(certPem);
+            const certPubDer = cert.publicKey.export({ type: 'spki', format: 'der' });
+            const certPub = new Uint8Array(certPubDer);
+            if (!pubDerMatchesFingerprint(certPub, certFingerprint))
+                return null;
+            session.cachePeerIK(fromAid, senderDeviceId, certPub);
+            client._clientLog.debug(`V2 decrypt: sender IK fallback from PKI cert for ${fromAid}`);
+            return certPub;
+        }
+        catch (exc) {
+            client._clientLog.warn(`V2 decrypt: PKI cert sender IK fallback failed for ${fromAid}: ${formatE2EEError(exc)}`);
+            return null;
+        }
+    }
+    pendingSenderIKMessageKey(msg, groupId) {
+        const client = this.client;
+        const messageId = String(msg.message_id ?? '').trim();
+        const seq = String(msg.seq ?? '').trim();
+        const prefix = groupId ? `group:${groupId}` : `p2p:${client._aid ?? ''}`;
+        return `${prefix}:${messageId || seq || Math.random().toString(36).slice(2)}`;
+    }
+    pendingSenderIKFetchKey(fromAid, senderDeviceId, groupId) {
+        return `${fromAid}#${senderDeviceId}#${groupId || ''}`;
+    }
+    scheduleSenderIKPending(args) {
+        const client = this.client;
+        const fromAid = String(args.fromAid ?? '').trim();
+        if (!fromAid)
+            return;
+        const senderDeviceId = String(args.senderDeviceId ?? '');
+        const groupId = String(args.groupId ?? '').trim();
+        const messageKey = this.pendingSenderIKMessageKey(args.msg, groupId);
+        client._v2SenderIKPending.set(messageKey, {
+            msg: { ...args.msg },
+            fromAid,
+            senderDeviceId,
+            groupId,
+            createdAt: Date.now(),
+        });
+        client._clientLog.debug(`V2 decrypt pending sender IK: key=${messageKey} from=${fromAid} device=${senderDeviceId || '-'} group=${groupId || '<p2p>'} pending=${client._v2SenderIKPending.size}`);
+        this.scheduleSenderIKFetch(fromAid, senderDeviceId, groupId);
+    }
+    scheduleSenderIKFetch(fromAid, senderDeviceId, groupId) {
+        const client = this.client;
+        const fetchKey = this.pendingSenderIKFetchKey(fromAid, senderDeviceId, groupId);
+        if (!fromAid || client._v2SenderIKFetching.has(fetchKey))
+            return;
+        client._v2SenderIKFetching.add(fetchKey);
+        client._safeAsync(this.resolveSenderIKPending(fromAid, senderDeviceId, groupId, fetchKey));
+    }
+    async resolveSenderIKPending(fromAid, senderDeviceId, groupId, fetchKey) {
+        const client = this.client;
+        try {
+            const session = client._v2Session;
+            if (session && fromAid) {
+                try {
+                    const bs = await client.call('message.v2.bootstrap', {
+                        peer_aid: fromAid,
+                        e2ee_wrap_capabilities: v2WrapCapabilities(),
+                    });
+                    if (typeof client._primeBootstrapPeerCerts === 'function') {
+                        await client._primeBootstrapPeerCerts(bs, fromAid);
+                    }
+                    const peers = (Array.isArray(bs?.peer_devices) ? bs.peer_devices : []);
+                    for (const dev of peers)
+                        client._cacheV2PeerIKFromDevice(dev, fromAid);
+                }
+                catch (exc) {
+                    client._clientLog.warn(`V2 sender IK pending bootstrap failed peer=${fromAid}: ${formatE2EEError(exc)}`);
+                }
+                if (groupId) {
+                    try {
+                        const gbs = await client.call('group.v2.bootstrap', {
+                            group_id: groupId,
+                            e2ee_wrap_capabilities: v2WrapCapabilities(),
+                        });
+                        const devices = (Array.isArray(gbs?.devices) ? gbs.devices : []);
+                        const audit = (Array.isArray(gbs?.audit_recipients) ? gbs.audit_recipients : []);
+                        for (const dev of devices)
+                            client._cacheV2PeerIKFromDevice(dev);
+                        for (const dev of audit)
+                            client._cacheV2PeerIKFromDevice(dev);
+                    }
+                    catch (exc) {
+                        client._clientLog.warn(`V2 sender IK pending group bootstrap failed group=${groupId}: ${formatE2EEError(exc)}`);
+                    }
+                }
+                if (!session.getPeerIK(fromAid, senderDeviceId)) {
+                    await this.getV2SenderPubDer(fromAid, senderDeviceId);
+                }
+            }
+            const pendingItems = [...client._v2SenderIKPending.entries()].filter(([, entry]) => entry.fromAid === fromAid && entry.senderDeviceId === senderDeviceId && entry.groupId === groupId);
+            for (const [key, entry] of pendingItems) {
+                let plaintext = null;
+                try {
+                    plaintext = await client._decryptV2Message(entry.msg, false);
+                }
+                catch (exc) {
+                    client._clientLog.warn(`V2 sender IK pending retry raised: key=${key} err=${formatE2EEError(exc)}`);
+                }
+                client._v2SenderIKPending.delete(key);
+                if (plaintext === null) {
+                    client._clientLog.debug(`V2 sender IK pending retry failed: key=${key}`);
+                    continue;
+                }
+                const seq = Number(entry.msg.seq ?? 0);
+                if (entry.groupId) {
+                    plaintext.group_id = entry.groupId;
+                    await client._publishPulledMessage('group.message_created', `group:${entry.groupId}`, seq, plaintext);
+                }
+                else {
+                    await client._publishPulledMessage('message.received', `p2p:${client._aid ?? ''}`, seq, plaintext);
+                }
+                client._clientLog.debug(`V2 sender IK pending retry delivered: key=${key}`);
+            }
+        }
+        finally {
+            client._v2SenderIKFetching.delete(fetchKey);
+        }
+    }
+    async buildV2P2PEnvelope(opts) {
+        const client = this.client;
+        if (!client._v2Session) {
+            throw new StateError('V2 session not initialized');
+        }
+        const session = client._v2Session;
+        const to = String(opts.to ?? '').trim();
+        if (!to)
+            throw new ValidationError("message.send requires 'to'");
+        const useCache = opts.useCache !== false;
+        let peerDevices = [];
+        let auditRaw = [];
+        let wrapPolicy = normalizeV2WrapPolicy(undefined);
+        const cached = useCache ? this.getBootstrapCacheEntry(to) : undefined;
+        if (cached && Date.now() - Number(cached.cachedAt ?? 0) < V2_BOOTSTRAP_TTL_MS) {
+            peerDevices = (cached.devices ?? []);
+            auditRaw = (cached.auditRecipients ?? []);
+            wrapPolicy = cached.wrapPolicy ?? wrapPolicy;
+            client._clientLog.debug(`message.v2.bootstrap cache hit: to=${to}, devices=${peerDevices.length}, audit=${auditRaw.length}`);
+        }
+        else {
+            const bs = await client.call('message.v2.bootstrap', {
+                peer_aid: to,
+                e2ee_wrap_capabilities: v2WrapCapabilities(),
+            });
+            if (typeof client._primeBootstrapPeerCerts === 'function') {
+                await client._primeBootstrapPeerCerts(bs, to);
+            }
+            wrapPolicy = normalizeV2WrapPolicy(bs.e2ee_wrap_policy);
+            peerDevices = (Array.isArray(bs?.peer_devices) ? bs.peer_devices : []);
+            auditRaw = (Array.isArray(bs?.audit_recipients) ? bs.audit_recipients : []);
+            client._clientLog.debug(`message.v2.bootstrap fetched: to=${to}, devices=${peerDevices.length}, audit=${auditRaw.length}`);
+            if (peerDevices.length > 0) {
+                this.setBootstrapCacheEntry(to, {
+                    devices: peerDevices,
+                    auditRecipients: auditRaw,
+                    cachedAt: Date.now(),
+                    wrapPolicy,
+                });
+            }
+        }
+        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);
+        }
+        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 {
+                    const selfBs = await client.call('message.v2.bootstrap', {
+                        peer_aid: client._aid,
+                        e2ee_wrap_capabilities: v2WrapCapabilities(),
+                    });
+                    if (typeof client._primeBootstrapPeerCerts === 'function') {
+                        await client._primeBootstrapPeerCerts(selfBs, client._aid);
+                    }
+                    selfDevices = (Array.isArray(selfBs?.peer_devices) ? selfBs.peer_devices : []);
+                    const selfWrapPolicy = normalizeV2WrapPolicy(selfBs.e2ee_wrap_policy);
+                    if (selfDevices.length > 0) {
+                        this.setBootstrapCacheEntry(client._aid, {
+                            devices: selfDevices,
+                            auditRecipients: [],
+                            cachedAt: Date.now(),
+                            wrapPolicy: selfWrapPolicy,
+                        });
+                    }
+                }
+                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 self-sync bootstrap failed (non-fatal): ${formatE2EEError(exc)}`);
+            }
+        }
+        if (targets.length === 0) {
+            throw new E2EEError(`V2 bootstrap: no usable devices found for ${to}`);
+        }
+        const envelope = encryptP2PMessage(session.getSenderIdentity(), {
+            targets: applyV2WrapPolicyToTargets(targets, wrapPolicy),
+            auditRecipients: applyV2WrapPolicyToTargets(auditTargets, wrapPolicy),
+        }, opts.payload, {
+            messageId: opts.messageId,
+            timestamp: opts.timestamp,
+            protectedHeaders: opts.protectedHeaders,
+            context: opts.context,
+        });
+        client._logMessageDebug('send-envelope', 'message.send.v2', 'message.send', {
+            message_id: envelope.message_id,
+            to,
+            type: envelope.type,
+            version: envelope.version,
+            protected_headers: envelope.protected_headers,
+            context: envelope.context,
+        }, {
+            payloadOverride: envelope,
+            extra: {
+                plaintext_payload: opts.payload,
+                target_count: targets.length,
+                audit_count: auditTargets.length,
+                use_cache: useCache,
+            },
+        });
+        return envelope;
+    }
+    async sendV2(to, payload, opts) {
+        const client = this.client;
+        await client._ensureV2SessionReady('message.send', 'V2 session not initialized; encrypted message.send requires V2 (V1 E2EE removed)');
+        const toAid = String(to ?? '').trim();
+        if (!toAid)
+            throw new ValidationError("message.send requires 'to'");
+        if (!isJsonObject(payload))
+            throw new ValidationError('message.send payload must be a dict for V2 encryption');
+        client._logMessageDebug('send-plaintext', 'message.send.v2', 'message.send', {
+            to: toAid,
+            message_id: opts?.messageId ?? '',
+            payload,
+        }, { payloadOverride: payload });
+        const attempt = async (useCache) => {
+            client._clientLog.debug(`message.v2.send attempt: to=${toAid}, use_cache=${useCache}`);
+            const envelope = await client._buildV2P2PEnvelope({
+                to: toAid,
+                payload,
+                messageId: opts?.messageId,
+                timestamp: opts?.timestamp,
+                protectedHeaders: opts?.protectedHeaders,
+                context: opts?.context,
+                useCache,
+            });
+            const result = await client.call('message.send', {
+                to: toAid,
+                payload: envelope,
+                encrypt: false,
+            });
+            client._clientLog.debug(`message.v2.send ok: to=${toAid}, use_cache=${useCache}, seq=${String((isJsonObject(result) ? result.seq : '') ?? '')}`);
+            return result;
+        };
+        try {
+            return await attempt(true);
+        }
+        catch (exc) {
+            const excCode = exc?.code;
+            if (V2_RETRYABLE_CODES.has(Number(excCode))) {
+                client._clientLog.debug(`V2 P2P speculative send rejected (code=${String(excCode)}), refreshing bootstrap`);
+                this.deleteBootstrapCacheEntry(toAid);
+                return await attempt(false);
+            }
+            throw exc;
+        }
+    }
+    async pullV2(afterSeq = 0, limit = 50, opts) {
+        const client = this.client;
+        await client._ensureV2SessionReady('message.pull');
+        const ns = client._aid ? `p2p:${client._aid}` : '';
+        if (ns && !opts?.gateLocked) {
+            return await client._runPullSerialized(ns, async () => this.pullV2(afterSeq, limit, {
+                ...(opts ?? {}),
+                gateLocked: true,
+                scheduleFollowup: true,
+            }));
+        }
+        const decrypted = [];
+        let nextAfterSeq = opts?.force ? afterSeq : (afterSeq || (ns ? client._seqTracker.getContiguousSeq(ns) : 0));
+        let pageCount = 0;
+        const maxPages = 100;
+        while (pageCount < maxPages) {
+            pageCount += 1;
+            client._clientLog.debug(`message.v2.pull page request: page=${pageCount}, after_seq=${nextAfterSeq}, limit=${limit}, ns=${ns || '<none>'}`);
+            const result = await client._callRawV2Rpc('message.v2.pull', {
+                after_seq: nextAfterSeq,
+                limit,
+                ...(opts?.force ? { force: true } : {}),
+            });
+            const messages = (Array.isArray(result?.messages) ? result.messages : []);
+            client._clientLog.debug(`message.v2.pull page response: page=${pageCount}, raw_count=${messages.length}, has_more=${String(result.has_more ?? '')}, server_ack_seq=${String(result.server_ack_seq ?? '')}`);
+            for (const msg of messages) {
+                client._logMessageDebug('pull-raw', 'message.v2.pull', 'message.received', msg);
+            }
+            const seqs = messages
+                .map((msg) => Number(msg.seq ?? 0))
+                .filter((seq) => Number.isFinite(seq) && seq > 0);
+            const pageContigBefore = ns ? client._seqTracker.getContiguousSeq(ns) : 0;
+            let pageMaxSeq = nextAfterSeq;
+            if (seqs.length > 0) {
+                pageMaxSeq = Math.max(...seqs);
+                if (ns) {
+                    client._seqTracker.forceContiguousSeq(ns, pageMaxSeq);
+                    client._clientLog.debug(`message.v2.pull force contiguous: ns=${ns}, page_max_seq=${pageMaxSeq}, previous=${pageContigBefore}`);
+                }
+            }
+            for (const msg of messages) {
+                const seq = Number(msg.seq ?? 0);
+                if (!Number.isFinite(seq) || seq <= 0)
+                    continue;
+                const version = String(msg.version ?? 'v2');
+                if (version === 'v1') {
+                    const legacy = isJsonObject(msg.legacy_v1) ? msg.legacy_v1 : {};
+                    const legacyPayload = legacy.payload;
+                    const payloadType = isJsonObject(legacyPayload)
+                        ? String(legacyPayload.type ?? '').trim()
+                        : '';
+                    if (legacyPayload !== undefined && legacyPayload !== null && payloadType !== 'e2ee.encrypted' && payloadType !== 'e2ee.group_encrypted') {
+                        const v1Msg = {
+                            message_id: String(msg.message_id ?? ''),
+                            from: String(msg.from_aid ?? ''),
+                            to: String(legacy.to ?? client._aid ?? ''),
+                            seq: msg.seq,
+                            type: String(msg.type ?? ''),
+                            timestamp: msg.t_server,
+                            payload: legacyPayload,
+                            encrypted: false,
+                        };
+                        const appEvent = client._delivery.p2pAppEventForMessage(v1Msg);
+                        if (ns) {
+                            await client._publishPulledMessage(appEvent.event, ns, seq, appEvent.payload);
+                        }
+                        else {
+                            await client._publishAppEvent(appEvent.event, appEvent.payload, 'pull');
+                        }
+                        decrypted.push(v1Msg);
+                        client._clientLog.debug(`message.v2.pull plaintext V1 delivered: seq=${seq}, ns=${ns || '<none>'}`);
+                    }
+                    else {
+                        client._clientLog.debug(`message.v2.pull skipping V1 envelope seq=${seq} payload_type=${payloadType || '<none>'} (V1 E2EE removed)`);
+                    }
+                    continue;
+                }
+                if (version !== 'v2') {
+                    client._clientLog.debug(`message.v2.pull skipping non-V2 row seq=${seq} version=${String(msg.version ?? '')}`);
+                    continue;
+                }
+                const spkId = String(msg.spk_id ?? '');
+                if (spkId && client._v2Session && !client._v2Session.isCurrentSPK(spkId)) {
+                    client._v2Session.trackOldSPKMaxSeq(spkId, seq);
+                }
+                const plaintext = await client._decryptV2Message(msg);
+                if (plaintext === null) {
+                    client._clientLog.debug(`message.v2.pull decrypt returned null: seq=${seq}, ns=${ns || '<none>'}`);
+                    continue;
+                }
+                if (ns) {
+                    await client._publishPulledMessage('message.received', ns, seq, plaintext);
+                }
+                else {
+                    await client._publishAppEvent('message.received', plaintext, 'pull');
+                }
+                decrypted.push(plaintext);
+                client._logMessageDebug('decrypt-ok', 'message.v2.pull', 'message.received', plaintext);
+            }
+            const hasServerAckSeq = Object.prototype.hasOwnProperty.call(result, 'server_ack_seq');
+            const serverAckSeq = Number(result.server_ack_seq ?? 0);
+            if (ns && Number.isFinite(serverAckSeq) && serverAckSeq > 0) {
+                const contig = client._seqTracker.getContiguousSeq(ns);
+                if (contig < serverAckSeq) {
+                    client._clientLog.info(`message.v2.pull retention-floor advance: ns=${ns} contiguous=${contig} -> server_ack_seq=${serverAckSeq}`);
+                    client._seqTracker.forceContiguousSeq(ns, serverAckSeq);
+                }
+            }
+            if (ns) {
+                const ackSeq = client._seqTracker.getContiguousSeq(ns);
+                const contigAdvanced = ackSeq !== pageContigBefore;
+                if (contigAdvanced) {
+                    await client._drainOrderedMessages(ns, undefined, true);
+                    client._saveSeqTrackerState();
+                }
+                const ackNeeded = messages.length > 0
+                    && ackSeq > 0
+                    && !opts?.skipAutoAck
+                    && (contigAdvanced || (hasServerAckSeq && ackSeq > serverAckSeq));
+                if (ackNeeded) {
+                    client._clientLog.debug(`message.v2.pull sending auto-ack: ns=${ns}, ack_seq=${ackSeq}, raw_count=${messages.length}`);
+                    await this.ackV2(ackSeq);
+                }
+            }
+            const nextAfter = Math.max(pageMaxSeq, nextAfterSeq);
+            if (messages.length === 0 || nextAfter <= nextAfterSeq || result.has_more === false)
+                break;
+            nextAfterSeq = nextAfter;
+        }
+        if (pageCount >= maxPages) {
+            client._clientLog.warn(`message.v2.pull reached max_pages=${maxPages} after_seq=${nextAfterSeq}`);
+        }
+        client._clientLog.debug(`message.v2.pull done: requested_after_seq=${afterSeq}, pages=${pageCount}, decrypted=${decrypted.length}, ns=${ns || '<none>'}`);
+        return decrypted;
+    }
+    async ackV2(upToSeq) {
+        const client = this.client;
+        const ns = client._aid ? `p2p:${client._aid}` : '';
+        let seq = Number(upToSeq ?? (ns ? client._seqTracker.getContiguousSeq(ns) : 0));
+        if (!Number.isFinite(seq) || seq <= 0) {
+            client._clientLog.debug(`message.v2.ack skipped: ns=${ns || '<none>'}, up_to_seq=${String(upToSeq ?? '')}`);
+            return { acked: 0 };
+        }
+        seq = client._clampAckSeq('message.v2.ack', 'up_to_seq', ns, seq);
+        client._clientLog.debug(`message.v2.ack send: ns=${ns || '<none>'}, up_to_seq=${seq}`);
+        const raw = await client._callRawV2Rpc('message.v2.ack', { up_to_seq: seq });
+        const result = isJsonObject(raw)
+            ? { ...raw }
+            : { result: raw };
+        let actualAckSeq = seq;
+        if ('effective_ack_seq' in result)
+            actualAckSeq = Number(result.effective_ack_seq ?? 0);
+        else if ('ack_seq' in result)
+            actualAckSeq = Number(result.ack_seq ?? 0);
+        else if ('cursor' in result)
+            actualAckSeq = Number(result.cursor ?? 0);
+        if (!Number.isFinite(actualAckSeq))
+            actualAckSeq = seq;
+        result.ack_seq = actualAckSeq;
+        result.success = true;
+        if (Number(result.acked ?? 0) === 0)
+            result.acked = actualAckSeq;
+        if (client._v2Session) {
+            try {
+                const destroyed = await Promise.resolve(client._v2Session.maybeDestroyOldSPKs(actualAckSeq));
+                if (destroyed.length > 0) {
+                    client._clientLog.info(`V2 destroyed old SPKs after ack: ${destroyed.slice(0, 3).join(',')} (PFS)`);
+                }
+            }
+            catch (exc) {
+                client._clientLog.debug(`V2 SPK destroy failed (non-fatal): ${formatE2EEError(exc)}`);
+            }
+        }
+        client._clientLog.debug(`message.v2.ack ok: ns=${ns || '<none>'}, requested=${seq}, effective=${actualAckSeq}, acked=${String(result.acked ?? '')}`);
+        return result;
+    }
+    async sendGroupV2(groupId, payload, opts) {
+        const client = this.client;
+        await client._ensureV2SessionReady('group.send', 'V2 session not initialized; encrypted group.send requires V2 (V1 E2EE removed)');
+        const gid = normalizeGroupId(groupId) || String(groupId ?? '').trim();
+        if (!gid)
+            throw new ValidationError("group.send requires 'group_id'");
+        if (!isJsonObject(payload))
+            throw new ValidationError('group.send payload must be a dict for V2 encryption');
+        client._logMessageDebug('send-plaintext', 'group.send.v2', 'group.send', {
+            group_id: gid,
+            message_id: opts?.messageId ?? '',
+            payload,
+        }, { payloadOverride: payload });
+        const attempt = async (useCache) => {
+            client._clientLog.debug(`group.v2.send attempt: group=${gid}, use_cache=${useCache}`);
+            const envelope = await client._buildV2GroupEnvelope({
+                groupId: gid,
+                payload,
+                messageId: opts?.messageId,
+                timestamp: opts?.timestamp,
+                protectedHeaders: opts?.protectedHeaders,
+                context: opts?.context,
+                useCache,
+            });
+            const result = await client.call('group.v2.send', {
+                group_id: gid,
+                envelope,
+            });
+            client._clientLog.debug(`group.v2.send ok: group=${gid}, use_cache=${useCache}, seq=${String((isJsonObject(result) ? result.seq : '') ?? '')}`);
+            return result;
+        };
+        const markSentSeq = (result) => {
+            if (!isJsonObject(result))
+                return;
+            const obj = result;
+            const seq = Number(obj.seq ?? 0);
+            if (!Number.isFinite(seq) || seq <= 0)
+                return;
+            const ns = `group:${gid}`;
+            client._seqTracker.onMessageSeq(ns, seq);
+            client._markPublishedSeq(ns, seq);
+            client._saveSeqTrackerState();
+            client._clientLog.debug(`group.v2.send marked own seq: group=${gid}, ns=${ns}, seq=${seq}`);
+        };
+        try {
+            const result = await attempt(true);
+            markSentSeq(result);
+            return result;
+        }
+        catch (exc) {
+            const excCode = Number(exc?.code);
+            if (V2_RETRYABLE_CODES.has(excCode)) {
+                client._clientLog.debug(`V2 group speculative send rejected (code=${String(excCode)}), refreshing bootstrap`);
+                this.deleteBootstrapCacheEntry(`group:${gid}`);
+                const result = await attempt(false);
+                markSentSeq(result);
+                return result;
+            }
+            throw exc;
+        }
+    }
+    async buildV2GroupEnvelope(opts) {
+        const client = this.client;
+        if (!client._v2Session)
+            throw new StateError('V2 session not initialized');
+        const session = client._v2Session;
+        const groupId = normalizeGroupId(opts.groupId) || String(opts.groupId ?? '').trim();
+        if (!groupId)
+            throw new ValidationError("group.send requires 'group_id'");
+        const cacheKey = `group:${groupId}`;
+        const useCache = opts.useCache !== false;
+        let allDevices = [];
+        let auditRecipientsRaw = [];
+        let epoch = 0;
+        let stateCommitment = { state_version: 0, state_hash: '', state_chain: '' };
+        let wrapPolicy = normalizeV2WrapPolicy(undefined);
+        const cached = useCache ? this.getBootstrapCacheEntry(cacheKey) : undefined;
+        if (cached && Date.now() - Number(cached.cachedAt ?? 0) < V2_BOOTSTRAP_TTL_MS) {
+            allDevices = (cached.devices ?? []);
+            auditRecipientsRaw = (cached.auditRecipients ?? []);
+            epoch = Number(cached.epoch ?? 0) || 0;
+            stateCommitment = cached.stateCommitment ?? stateCommitment;
+            wrapPolicy = cached.wrapPolicy ?? wrapPolicy;
+            client._clientLog.debug(`group.v2.bootstrap cache hit: group=${groupId}, devices=${allDevices.length}, audit=${auditRecipientsRaw.length}, epoch=${epoch}, state_version=${stateCommitment.state_version}`);
+        }
+        else {
+            const bs = await client.call('group.v2.bootstrap', {
+                group_id: groupId,
+                e2ee_wrap_capabilities: v2WrapCapabilities(),
+            });
+            allDevices = (Array.isArray(bs.devices) ? bs.devices : []);
+            auditRecipientsRaw = (Array.isArray(bs.audit_recipients) ? bs.audit_recipients : []);
+            epoch = Number(bs.epoch ?? 0) || 0;
+            wrapPolicy = normalizeV2WrapPolicy(bs.e2ee_wrap_policy);
+            client._clientLog.debug(`group.v2.bootstrap fetched: group=${groupId}, devices=${allDevices.length}, audit=${auditRecipientsRaw.length}, epoch=${epoch}, members=${Array.isArray(bs.member_aids) ? bs.member_aids.length : 0}`);
+            const stateChain = String(bs.state_chain ?? '');
+            await client._v2CheckFork(groupId, stateChain);
+            await client._v2VerifyStateSignature(groupId, bs);
+            await client._publishV2GroupSecurityLevel(groupId, bs);
+            stateCommitment = {
+                state_version: Number(bs.state_version ?? 0) || 0,
+                state_hash: String(bs.state_hash_signed ?? bs.state_hash ?? ''),
+                state_chain: stateChain,
+            };
+            if (allDevices.length > 0) {
+                this.setBootstrapCacheEntry(cacheKey, {
+                    devices: allDevices,
+                    auditRecipients: auditRecipientsRaw,
+                    cachedAt: Date.now(),
+                    epoch,
+                    stateCommitment,
+                    wrapPolicy,
+                });
+            }
+            const pendingAdds = Array.isArray(bs.pending_adds) ? bs.pending_adds : [];
+            if (pendingAdds.length > 0 && client._v2Session) {
+                client._v2MaybeTriggerAutoPropose(groupId);
+            }
+        }
+        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',
+            });
+            if (target)
+                targets.push(target);
+        }
+        if (targets.length === 0) {
+            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 envelope = encryptGroupMessage(session.getSenderIdentity(), groupId, epoch, applyV2WrapPolicyToTargets(targets, wrapPolicy), opts.payload, {
+            messageId: opts.messageId,
+            timestamp: opts.timestamp,
+            protectedHeaders: opts.protectedHeaders,
+            context: opts.context,
+        }, stateCommitment);
+        client._logMessageDebug('send-envelope', 'group.send.v2', 'group.send', {
+            group_id: groupId,
+            message_id: envelope.message_id,
+            type: envelope.type,
+            version: envelope.version,
+            protected_headers: envelope.protected_headers,
+            context: envelope.context,
+        }, {
+            payloadOverride: envelope,
+            extra: {
+                plaintext_payload: opts.payload,
+                epoch,
+                target_count: targets.length,
+                audit_count: auditRecipientsRaw.length,
+                state_version: stateCommitment.state_version,
+                use_cache: useCache,
+            },
+        });
+        return envelope;
+    }
+    async pullGroupV2Internal(params) {
+        await this.pullGroupV2(params.group_id, params.after_seq, params.limit, { gateLocked: true });
+    }
+    async pullGroupV2(groupId, afterSeq = 0, limit = 50, opts) {
+        const client = this.client;
+        await client._ensureV2SessionReady('group.pull');
+        const gid = normalizeGroupId(groupId) || String(groupId ?? '').trim();
+        if (!gid)
+            throw new ValidationError('group.pull requires group_id');
+        const ns = `group:${gid}`;
+        if (!opts?.gateLocked) {
+            return await client._runPullSerialized(ns, async () => this.pullGroupV2(gid, afterSeq, limit, {
+                ...(opts ?? {}),
+                gateLocked: true,
+                scheduleFollowup: true,
+            }));
+        }
+        const decrypted = [];
+        const cursorParams = opts?.cursorParams ?? {};
+        const ownsCursor = opts?.ownsCursor !== false;
+        let nextAfterSeq = opts?.explicitAfterSeq ? afterSeq : (afterSeq || client._seqTracker.getContiguousSeq(ns));
+        let pageCount = 0;
+        const maxPages = 100;
+        while (pageCount < maxPages) {
+            pageCount += 1;
+            client._clientLog.debug(`group.v2.pull page request: group=${gid}, page=${pageCount}, after_seq=${nextAfterSeq}, limit=${limit}, ns=${ns}`);
+            const result = await client._callRawV2Rpc('group.v2.pull', {
+                group_id: gid,
+                after_seq: nextAfterSeq,
+                limit,
+                ...cursorParams,
+            });
+            const messages = (Array.isArray(result.messages) ? result.messages : []);
+            const cursor = isJsonObject(result.cursor) ? result.cursor : null;
+            client._clientLog.debug(`group.v2.pull page response: group=${gid}, page=${pageCount}, raw_count=${messages.length}, has_more=${String(result.has_more ?? '')}, cursor_current=${String(cursor?.current_seq ?? '')}`);
+            for (const msg of messages) {
+                client._logMessageDebug('pull-raw', 'group.v2.pull', 'group.message_created', msg);
+            }
+            const seqs = messages
+                .map((msg) => Number(msg.seq ?? 0))
+                .filter((seq) => Number.isFinite(seq) && seq > 0);
+            const pageContigBefore = client._seqTracker.getContiguousSeq(ns);
+            let pageMaxSeq = nextAfterSeq;
+            if (seqs.length > 0) {
+                pageMaxSeq = Math.max(...seqs);
+                client._seqTracker.forceContiguousSeq(ns, pageMaxSeq);
+                client._clientLog.debug(`group.v2.pull force contiguous: group=${gid}, ns=${ns}, page_max_seq=${pageMaxSeq}, previous=${pageContigBefore}`);
+            }
+            for (const msg of messages) {
+                const seq = Number(msg.seq ?? 0);
+                if (!Number.isFinite(seq) || seq <= 0)
+                    continue;
+                const version = String(msg.version ?? 'v2');
+                if (version === 'v1') {
+                    const payload = msg.payload;
+                    const payloadObj = isJsonObject(payload) ? payload : null;
+                    if (payloadObj) {
+                        const payloadType = String(payloadObj.type ?? '').trim();
+                        if (payloadType !== 'e2ee.encrypted' && payloadType !== 'e2ee.group_encrypted') {
+                            const v1Msg = {
+                                message_id: String(msg.message_id ?? ''),
+                                from: String(msg.from_aid ?? ''),
+                                group_id: gid,
+                                seq: msg.seq,
+                                type: String(msg.type ?? ''),
+                                timestamp: msg.t_server,
+                                payload,
+                                encrypted: false,
+                            };
+                            await client._publishPulledMessage('group.message_created', ns, seq, v1Msg);
+                            decrypted.push(v1Msg);
+                            client._clientLog.debug(`group.v2.pull plaintext V1 delivered: group=${gid}, seq=${seq}`);
+                            continue;
+                        }
+                    }
+                    else if (payload !== undefined && payload !== null) {
+                        const v1Msg = {
+                            message_id: String(msg.message_id ?? ''),
+                            from: String(msg.from_aid ?? ''),
+                            group_id: gid,
+                            seq: msg.seq,
+                            type: String(msg.type ?? ''),
+                            timestamp: msg.t_server,
+                            payload,
+                            encrypted: false,
+                        };
+                        await client._publishPulledMessage('group.message_created', ns, seq, v1Msg);
+                        decrypted.push(v1Msg);
+                        client._clientLog.debug(`group.v2.pull plaintext V1 delivered: group=${gid}, seq=${seq}`);
+                        continue;
+                    }
+                    client._clientLog.debug(`group.v2.pull skipping V1 envelope group=${gid} seq=${seq} payload_type=${payloadObj ? String(payloadObj.type ?? '') : '<none>'} (V1 E2EE removed)`);
+                    continue;
+                }
+                if (version !== 'v2') {
+                    client._clientLog.debug(`group.v2.pull skipping non-V2 row group=${gid} seq=${seq} version=${String(msg.version ?? '')}`);
+                    continue;
+                }
+                const plaintext = await client._decryptV2Message(msg);
+                if (plaintext === null) {
+                    client._clientLog.debug(`group.v2.pull decrypt returned null: group=${gid}, seq=${seq}`);
+                    continue;
+                }
+                plaintext.group_id = gid;
+                await client._publishPulledMessage('group.message_created', ns, seq, plaintext);
+                decrypted.push(plaintext);
+                client._logMessageDebug('decrypt-ok', 'group.v2.pull', 'group.message_created', plaintext);
+            }
+            const cursorCurrentSeq = Number(cursor?.current_seq ?? 0);
+            const hasServerCursor = cursor !== null && Object.prototype.hasOwnProperty.call(cursor, 'current_seq');
+            const retentionFloor = Math.max(client._pullRetentionFloor(result, 'retention_floor_message_seq', 'retention_floor_message_seq'), Number.isFinite(cursorCurrentSeq) ? cursorCurrentSeq : 0);
+            if (retentionFloor > 0) {
+                const contig = client._seqTracker.getContiguousSeq(ns);
+                if (contig < retentionFloor) {
+                    client._clientLog.info(`group.v2.pull retention-floor advance: ns=${ns} contiguous=${contig} -> retention_floor=${retentionFloor}`);
+                    client._seqTracker.forceContiguousSeq(ns, retentionFloor);
+                }
+            }
+            const ackSeq = client._seqTracker.getContiguousSeq(ns);
+            const contigAdvanced = ackSeq !== pageContigBefore;
+            if (contigAdvanced) {
+                await client._drainOrderedMessages(ns, undefined, true);
+                client._saveSeqTrackerState();
+            }
+            const ackNeeded = messages.length > 0
+                && ackSeq > 0
+                && ownsCursor
+                && (contigAdvanced || (hasServerCursor && ackSeq > cursorCurrentSeq));
+            if (ackNeeded) {
+                client._clientLog.debug(`group.v2.pull sending auto-ack: group=${gid}, ns=${ns}, ack_seq=${ackSeq}, raw_count=${messages.length}`);
+                await this.ackGroupV2(gid, ackSeq);
+            }
+            const nextAfter = Math.max(pageMaxSeq, nextAfterSeq);
+            if (!ownsCursor)
+                break;
+            if (messages.length === 0 || nextAfter <= nextAfterSeq || result.has_more === false)
+                break;
+            nextAfterSeq = nextAfter;
+        }
+        if (pageCount >= maxPages) {
+            client._clientLog.warn(`group.v2.pull reached max_pages=${maxPages} group=${gid} after_seq=${nextAfterSeq}`);
+        }
+        client._clientLog.debug(`group.v2.pull done: group=${gid}, requested_after_seq=${afterSeq}, pages=${pageCount}, decrypted=${decrypted.length}, ns=${ns}`);
+        return decrypted;
+    }
+    async ackGroupV2(groupId, upToSeq) {
+        const client = this.client;
+        const gid = normalizeGroupId(groupId) || String(groupId ?? '').trim();
+        if (!gid)
+            throw new ValidationError('group.ack_messages requires group_id');
+        const ns = `group:${gid}`;
+        let seq = Number(upToSeq ?? client._seqTracker.getContiguousSeq(ns));
+        if (!Number.isFinite(seq) || seq <= 0) {
+            client._clientLog.debug(`group.v2.ack skipped: group=${gid}, ns=${ns}, up_to_seq=${String(upToSeq ?? '')}`);
+            return { acked: 0 };
+        }
+        seq = client._clampAckSeq('group.v2.ack', 'up_to_seq', ns, seq);
+        client._clientLog.debug(`group.v2.ack send: group=${gid}, ns=${ns}, up_to_seq=${seq}`);
+        const result = await client._callRawV2Rpc('group.v2.ack', { group_id: gid, up_to_seq: seq });
+        client._clientLog.debug(`group.v2.ack ok: group=${gid}, ns=${ns}, requested=${seq}, result=${client._debugJson(result)}`);
+        return result;
+    }
+    async putMessageThoughtEncryptedV2(params) {
+        const client = this.client;
+        const toAid = String(params.to ?? '').trim();
+        client._validateMessageRecipient(toAid);
+        const payload = isJsonObject(params.payload) ? params.payload : null;
+        if (!toAid)
+            throw new ValidationError('message.thought.put requires to');
+        if (payload === null)
+            throw new ValidationError('message.thought.put payload must be an object when encrypt=true');
+        const thoughtId = String(params.thought_id ?? '').trim() || `mt-${crypto.randomUUID()}`;
+        const timestamp = Number(params.timestamp ?? Date.now());
+        const protectedHeaders = client._protectedHeadersFromParams(params);
+        client._logMessageDebug('thought-send-plaintext', 'message.thought.put.v2', 'message.thought.put', {
+            to: toAid,
+            thought_id: thoughtId,
+            timestamp,
+            payload,
+        }, { payloadOverride: payload });
+        const attempt = async (useCache) => {
+            client._clientLog.debug(`message.thought.put attempt: to=${toAid}, thought_id=${thoughtId}, use_cache=${useCache}`);
+            const context = isJsonObject(params.context) ? params.context : undefined;
+            const envelope = await client._buildV2P2PEnvelope({
+                to: toAid,
+                payload,
+                messageId: thoughtId,
+                timestamp,
+                useCache,
+                protectedHeaders,
+                context,
+            });
+            const sendParams = {
+                to: toAid,
+                payload: envelope,
+                encrypted: true,
+                thought_id: thoughtId,
+                timestamp,
+            };
+            if ('context' in params)
+                sendParams.context = params.context;
+            client._signClientOperation('message.thought.put', sendParams);
+            client._logMessageDebug('thought-send-envelope', 'message.thought.put.v2', 'message.thought.put', sendParams, {
+                payloadOverride: envelope,
+                extra: { to: toAid, thought_id: thoughtId, use_cache: useCache },
+            });
+            const result = await client._transport.call('message.thought.put', sendParams);
+            client._clientLog.debug(`message.thought.put ok: to=${toAid}, thought_id=${thoughtId}, use_cache=${useCache}`);
+            return result;
+        };
+        try {
+            return await attempt(true);
+        }
+        catch (exc) {
+            const excCode = Number(exc?.code);
+            if (V2_RETRYABLE_CODES.has(excCode)) {
+                client._clientLog.debug(`V2 P2P thought put speculative rejected (code=${String(excCode)}), refreshing bootstrap`);
+                this.deleteBootstrapCacheEntry(toAid);
+                return await attempt(false);
+            }
+            throw exc;
+        }
+    }
+    async putGroupThoughtEncryptedV2(params) {
+        const client = this.client;
+        const groupId = String(params.group_id ?? '').trim();
+        const payload = isJsonObject(params.payload) ? params.payload : null;
+        if (!groupId)
+            throw new ValidationError("group.thought.put requires 'group_id'");
+        if (payload === null)
+            throw new ValidationError('group.thought.put payload must be an object when encrypt=true');
+        const thoughtId = String(params.thought_id ?? '').trim() || `gt-${crypto.randomUUID()}`;
+        const timestamp = Number(params.timestamp ?? Date.now());
+        const protectedHeaders = client._protectedHeadersFromParams(params);
+        client._logMessageDebug('thought-send-plaintext', 'group.thought.put.v2', 'group.thought.put', {
+            group_id: groupId,
+            thought_id: thoughtId,
+            timestamp,
+            payload,
+        }, { payloadOverride: payload });
+        const attempt = async (useCache) => {
+            client._clientLog.debug(`group.thought.put attempt: group=${groupId}, thought_id=${thoughtId}, use_cache=${useCache}`);
+            const context = isJsonObject(params.context) ? params.context : undefined;
+            const envelope = await client._buildV2GroupEnvelope({
+                groupId,
+                payload,
+                messageId: thoughtId,
+                timestamp,
+                useCache,
+                protectedHeaders,
+                context,
+            });
+            const sendParams = {
+                group_id: groupId,
+                payload: envelope,
+                encrypted: true,
+                thought_id: thoughtId,
+                timestamp,
+            };
+            if ('context' in params)
+                sendParams.context = params.context;
+            client._signClientOperation('group.thought.put', sendParams);
+            client._logMessageDebug('thought-send-envelope', 'group.thought.put.v2', 'group.thought.put', sendParams, {
+                payloadOverride: envelope,
+                extra: { group_id: groupId, thought_id: thoughtId, use_cache: useCache },
+            });
+            const result = await client._transport.call('group.thought.put', sendParams);
+            client._clientLog.debug(`group.thought.put ok: group=${groupId}, thought_id=${thoughtId}, use_cache=${useCache}`);
+            return result;
+        };
+        try {
+            return await attempt(true);
+        }
+        catch (exc) {
+            const excCode = Number(exc?.code);
+            if (V2_RETRYABLE_CODES.has(excCode)) {
+                client._clientLog.debug(`V2 group thought put speculative rejected (code=${String(excCode)}), refreshing bootstrap`);
+                this.deleteBootstrapCacheEntry(`group:${groupId}`);
+                return await attempt(false);
+            }
+            throw exc;
+        }
+    }
+    async decryptGroupThoughts(result) {
+        const client = this.client;
+        client._clientLog.debug(`group.thought.get decrypt enter: found=${String(result.found ?? '')}, group=${String(result.group_id ?? '')}, sender=${String(result.sender_aid ?? '')}`);
+        if (!result.found) {
+            client._clientLog.debug('group.thought.get decrypt exit: not found');
+            return { ...result, thoughts: [] };
+        }
+        const items = Array.isArray(result.thoughts) ? result.thoughts.filter(isJsonObject) : [];
+        if (items.length === 0) {
+            client._clientLog.debug('group.thought.get decrypt exit: empty thoughts');
+            return { ...result, thoughts: [] };
+        }
+        const groupId = String(result.group_id ?? '');
+        const senderAid = String(result.sender_aid ?? '');
+        const thoughts = [];
+        for (const item of items) {
+            const payload = isJsonObject(item.payload) ? item.payload : null;
+            const thoughtId = String(item.thought_id ?? item.message_id ?? '');
+            const fromAid = String(item.from ?? item.sender_aid ?? senderAid);
+            client._logMessageDebug('thought-get-raw', 'group.thought.get', 'group.thought.get', item, {
+                extra: { group_id: groupId, thought_id: thoughtId, from: fromAid },
+            });
+            let decryptFailed = false;
+            let decryptedPayload = payload ?? {};
+            let e2ee;
+            if (payload?.type === 'e2ee.group_encrypted' && String(payload.version ?? '') === 'v2') {
+                e2ee = client._v2E2eeMeta(payload);
+                const plain = await client._decryptV2EnvelopeForThought({ envelope: payload, fromAid });
+                if (plain === null) {
+                    decryptFailed = true;
+                    client._clientLog.debug(`group.thought.get decrypt returned null: group=${groupId}, thought_id=${thoughtId}, from=${fromAid}`);
+                }
+                else {
+                    decryptedPayload = plain;
+                    client._logMessageDebug('thought-decrypt-ok', 'group.thought.get', 'group.thought.get', {
+                        group_id: groupId,
+                        thought_id: thoughtId,
+                        from: fromAid,
+                        payload: plain,
+                    });
+                }
+            }
+            else if (payload?.type === 'e2ee.group_encrypted') {
+                decryptFailed = true;
+                client._clientLog.debug(`group.thought.get unsupported encrypted payload: group=${groupId}, thought_id=${thoughtId}, type=${String(payload.type ?? '')}, version=${String(payload.version ?? '')}`);
+            }
+            const thought = {
+                thought_id: thoughtId,
+                message_id: thoughtId,
+                payload: decryptFailed ? (payload ?? {}) : decryptedPayload,
+                created_at: item.created_at,
+            };
+            if (e2ee !== undefined) {
+                thought.e2ee = e2ee;
+                if (isJsonObject(e2ee))
+                    client._attachV2EnvelopeMetadata(thought, e2ee);
+            }
+            if (decryptFailed)
+                thought.decrypt_failed = true;
+            if ('context' in item)
+                thought.context = item.context;
+            client._logMessageDebug(decryptFailed ? 'thought-decrypt-fail' : 'thought-result', 'group.thought.get', 'group.thought.get', thought, {
+                extra: { group_id: groupId, thought_id: thoughtId },
+            });
+            thoughts.push(thought);
+        }
+        client._clientLog.debug(`group.thought.get decrypt exit: group=${groupId}, total=${items.length}, returned=${thoughts.length}`);
+        return { ...result, thoughts };
+    }
+    async decryptMessageThoughts(result) {
+        const client = this.client;
+        client._clientLog.debug(`message.thought.get decrypt enter: found=${String(result.found ?? '')}, peer=${String(result.peer_aid ?? '')}, sender=${String(result.sender_aid ?? '')}`);
+        if (!result.found) {
+            client._clientLog.debug('message.thought.get decrypt exit: not found');
+            return { ...result, thoughts: [] };
+        }
+        const items = Array.isArray(result.thoughts) ? result.thoughts.filter(isJsonObject) : [];
+        if (items.length === 0) {
+            client._clientLog.debug('message.thought.get decrypt exit: empty thoughts');
+            return { ...result, thoughts: [] };
+        }
+        const senderAid = String(result.sender_aid ?? '');
+        const peerAid = String(result.peer_aid ?? '');
+        const thoughts = [];
+        for (const item of items) {
+            const payload = isJsonObject(item.payload) ? item.payload : null;
+            const thoughtId = String(item.thought_id ?? item.message_id ?? '');
+            const fromAid = String(item.from ?? senderAid);
+            const toAid = String(item.to ?? peerAid);
+            client._logMessageDebug('thought-get-raw', 'message.thought.get', 'message.thought.get', item, {
+                extra: { thought_id: thoughtId, from: fromAid, to: toAid },
+            });
+            let decryptFailed = false;
+            let decryptedPayload = payload ?? {};
+            let e2ee;
+            if (payload?.type === 'e2ee.p2p_encrypted' && String(payload.version ?? '') === 'v2') {
+                e2ee = client._v2E2eeMeta(payload);
+                const plain = await client._decryptV2EnvelopeForThought({ envelope: payload, fromAid });
+                if (plain === null) {
+                    decryptFailed = true;
+                    client._clientLog.debug(`message.thought.get decrypt returned null: thought_id=${thoughtId}, from=${fromAid}, to=${toAid}`);
+                }
+                else {
+                    decryptedPayload = plain;
+                    client._logMessageDebug('thought-decrypt-ok', 'message.thought.get', 'message.thought.get', {
+                        thought_id: thoughtId,
+                        from: fromAid,
+                        to: toAid,
+                        payload: plain,
+                    });
+                }
+            }
+            else if (payload?.type === 'e2ee.encrypted' || payload?.type === 'e2ee.p2p_encrypted') {
+                decryptFailed = true;
+                client._clientLog.debug(`message.thought.get unsupported encrypted payload: thought_id=${thoughtId}, type=${String(payload.type ?? '')}, version=${String(payload.version ?? '')}`);
+            }
+            const thought = {
+                thought_id: thoughtId,
+                message_id: thoughtId,
+                from: fromAid,
+                to: toAid,
+                payload: decryptFailed ? (payload ?? {}) : decryptedPayload,
+                created_at: item.created_at,
+            };
+            if (e2ee !== undefined) {
+                thought.e2ee = e2ee;
+                if (isJsonObject(e2ee))
+                    client._attachV2EnvelopeMetadata(thought, e2ee);
+            }
+            if (decryptFailed)
+                thought.decrypt_failed = true;
+            if ('context' in item)
+                thought.context = item.context;
+            client._logMessageDebug(decryptFailed ? 'thought-decrypt-fail' : 'thought-result', 'message.thought.get', 'message.thought.get', thought, {
+                extra: { thought_id: thoughtId },
+            });
+            thoughts.push(thought);
+        }
+        client._clientLog.debug(`message.thought.get decrypt exit: total=${items.length}, returned=${thoughts.length}`);
+        return { ...result, thoughts };
+    }
+    async decryptV2EnvelopeForThought(opts) {
+        const client = this.client;
+        const session = client._v2Session;
+        if (!session || !opts.envelope)
+            return null;
+        const envelope = opts.envelope;
+        let spkId = '';
+        let recipientKeySource = '';
+        if (Array.isArray(envelope.recipients)) {
+            for (const row of envelope.recipients) {
+                if (!Array.isArray(row) || row.length < 6)
+                    continue;
+                if (String(row[0] ?? '') === client._aid
+                    && (String(row[1] ?? '') === client._deviceId || String(row[1] ?? '') === '')) {
+                    spkId = String(row[5] ?? '');
+                    recipientKeySource = String(row[3] ?? '');
+                    break;
+                }
+            }
+        }
+        else if (isJsonObject(envelope.recipient)) {
+            const recipient = envelope.recipient;
+            spkId = String(recipient.spk_id ?? '');
+            recipientKeySource = String(recipient.key_source ?? '');
+        }
+        const aad = isJsonObject(envelope.aad) ? envelope.aad : {};
+        const groupIdForKeys = String(aad.group_id ?? envelope.group_id ?? '').trim();
+        const fromAid = String(opts.fromAid || aad.from || '').trim();
+        const senderDeviceId = String(aad.from_device ?? '');
+        client._clientLog.debug(`V2 thought decrypt start: from=${fromAid}, sender_device=${senderDeviceId}, group=${groupIdForKeys || '<p2p>'}, spk_id=${spkId || '<empty>'}, key_source=${recipientKeySource || '<empty>'}, type=${String(envelope.type ?? '')}`);
+        let ikPriv;
+        let spkPriv;
+        try {
+            if (groupIdForKeys) {
+                const keys = session.getGroupDecryptKeys(groupIdForKeys, spkId);
+                ikPriv = keys.ikPriv;
+                spkPriv = keys.spkPriv ?? undefined;
+            }
+            else {
+                const keys = session.getDecryptKeys(spkId);
+                ikPriv = keys.ikPriv;
+                spkPriv = keys.spkPriv;
+            }
+        }
+        catch (exc) {
+            client._clientLog.warn(`V2 thought decrypt: SPK lookup failed from=${fromAid}, group=${groupIdForKeys || '<p2p>'}, spk_id=${spkId || '<empty>'}: ${formatE2EEError(exc)}`);
+            return null;
+        }
+        const senderCertFingerprint = String(envelope.sender_cert_fingerprint ?? '').trim().toLowerCase();
+        const senderPubDer = await this.getV2SenderPubDer(fromAid, senderDeviceId, senderCertFingerprint);
+        if (!senderPubDer) {
+            client._clientLog.warn(`V2 thought decrypt: no sender IK for ${fromAid} device=${senderDeviceId}`);
+            this.scheduleSenderIKFetch(fromAid, senderDeviceId, groupIdForKeys);
+            return null;
+        }
+        try {
+            const plain = decryptMessage(envelope, client._aid ?? '', client._deviceId, ikPriv, spkPriv, senderPubDer);
+            client._clientLog.debug(`V2 thought decrypt ok: from=${fromAid}, sender_device=${senderDeviceId}, group=${groupIdForKeys || '<p2p>'}`);
+            if (plain !== null) {
+                if (groupIdForKeys && recipientKeySource === 'group_device_prekey' && session.isLastUploadedGroupSPK(groupIdForKeys, spkId)) {
+                    this.scheduleGroupSpkRotation(groupIdForKeys, { reason: 'thought_group_spk_consumed' });
+                }
+                else if (groupIdForKeys && recipientKeySource === 'peer_device_prekey') {
+                    this.scheduleGroupSpkRegistrationAfterPeerFallback(groupIdForKeys);
+                }
+            }
+            return plain;
+        }
+        catch (exc) {
+            client._clientLog.warn(`V2 thought decrypt failed from=${fromAid}: ${formatE2EEError(exc)}`);
+            return null;
+        }
+    }
+    encryptedPushEnvelope(msg) {
+        const payload = msg.payload;
+        if (this.isEncryptedEnvelopePayload(payload))
+            return payload;
+        if (typeof msg.envelope_json === 'string' && msg.envelope_json.trim()) {
+            try {
+                const parsed = JSON.parse(msg.envelope_json);
+                if (this.isEncryptedEnvelopePayload(parsed))
+                    return parsed;
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    isEncryptedPushMessage(msg) {
+        if (truthyBool(msg.encrypted))
+            return true;
+        return this.encryptedPushEnvelope(msg) !== null;
+    }
+    isEncryptedEnvelopePayload(payload) {
+        if (!isJsonObject(payload))
+            return false;
+        const envelope = payload;
+        const payloadType = String(envelope.type ?? '').trim();
+        if (payloadType.startsWith('e2ee.'))
+            return true;
+        if (!String(envelope.ciphertext ?? '').trim())
+            return false;
+        return envelope.nonce !== undefined
+            || envelope.tag !== undefined
+            || envelope.recipient !== undefined
+            || envelope.recipients !== undefined
+            || envelope.wrapped_key !== undefined
+            || envelope.recipients_digest !== undefined;
+    }
+    isV2EncryptedEnvelopePayload(envelope) {
+        if (!envelope)
+            return false;
+        const payloadType = String(envelope.type ?? '').trim();
+        if (payloadType === 'e2ee.p2p_encrypted' || payloadType === 'e2ee.group_encrypted')
+            return true;
+        return String(envelope.version ?? '').trim().toLowerCase() === 'v2' && payloadType.startsWith('e2ee.');
+    }
+    safeUndecryptablePushEvent(msg, group) {
+        const client = this.client;
+        const event = {
+            message_id: msg.message_id,
+            from: msg.from,
+            seq: msg.seq,
+            timestamp: (msg.timestamp ?? msg.t_server),
+            device_id: msg.device_id,
+            slot_id: msg.slot_id,
+            _decrypt_error: 'encrypted push payload is not decryptable on raw push path',
+            _decrypt_stage: 'push_envelope',
+        };
+        if (group) {
+            event.group_id = msg.group_id;
+        }
+        else {
+            event.to = msg.to;
+        }
+        const envelope = this.encryptedPushEnvelope(msg);
+        if (envelope) {
+            event._envelope_type = String(envelope.type ?? '');
+            event._suite = String(envelope.suite ?? '');
+            if (this.isV2EncryptedEnvelopePayload(envelope)) {
+                client._attachV2EnvelopeMetadata(event, client._v2E2eeMeta(envelope));
+            }
+        }
+        return event;
+    }
+    async decryptEncryptedPushPayload(msg, group) {
+        const client = this.client;
+        const envelope = this.encryptedPushEnvelope(msg);
+        if (!this.isV2EncryptedEnvelopePayload(envelope))
+            return null;
+        const aad = isJsonObject(envelope.aad) ? envelope.aad : {};
+        const fromAid = String(msg.from_aid ?? msg.from ?? msg.sender_aid ?? aad.from ?? '').trim();
+        const plaintext = await client._decryptV2EnvelopeForThought({ envelope, fromAid });
+        if (!plaintext)
+            return null;
+        const e2ee = client._v2E2eeMeta(envelope);
+        const result = {
+            message_id: String(msg.message_id ?? ''),
+            from: fromAid,
+            seq: msg.seq,
+            timestamp: (msg.t_server ?? msg.timestamp),
+            payload: plaintext,
+            encrypted: true,
+            e2ee,
+        };
+        result.direction = fromAid && fromAid === client._aid ? 'outbound_sync' : 'inbound';
+        if (msg.t_server !== undefined)
+            result.t_server = msg.t_server;
+        if (msg.device_id !== undefined)
+            result.device_id = msg.device_id;
+        if (msg.slot_id !== undefined)
+            result.slot_id = msg.slot_id;
+        attachGatewayProximity(result, msg);
+        if (group) {
+            result.group_id = (msg.group_id ?? aad.group_id ?? envelope.group_id);
+        }
+        else {
+            result.to = (msg.to ?? client._aid ?? '');
+        }
+        client._attachV2EnvelopeMetadata(result, e2ee);
+        client._logMessageDebug('decrypt-ok', 'push.encrypted', group ? 'group.message_created' : 'message.received', result);
+        return result;
+    }
+    async publishEncryptedPushAsUndecryptable(event, ns, seq, msg, group) {
+        const client = this.client;
+        const safeEvent = this.safeUndecryptablePushEvent(msg, group);
+        client._logMessageDebug('decrypt-fail', 'push.encrypted', event, safeEvent);
+        if (ns) {
+            return await client._publishOrderedMessage(event, ns, seq, safeEvent);
+        }
+        const published = client._publishAppEvent(event, safeEvent, 'push');
+        if (published && typeof published.then === 'function')
+            await published;
+        return true;
+    }
+    async publishEncryptedPushMessage(normalEvent, undecryptableEvent, ns, seq, msg, group) {
+        const client = this.client;
+        const decrypted = await this.decryptEncryptedPushPayload(msg, group);
+        if (decrypted) {
+            if (ns)
+                return await client._publishOrderedMessage(normalEvent, ns, seq, decrypted);
+            const published = client._publishAppEvent(normalEvent, decrypted, 'push');
+            if (published && typeof published.then === 'function')
+                await published;
+            return true;
+        }
+        return await this.publishEncryptedPushAsUndecryptable(undecryptableEvent, ns, seq, msg, group);
+    }
+    async decryptV2PushMessage(data) {
+        if (!isJsonObject(data))
+            return null;
+        return await this.client._decryptV2Message(data);
+    }
+    handleGroupChangedSpk(data, groupId, action) {
+        if (!this.client._v2Session || !groupId || !MEMBERSHIP_ACTIONS.has(action))
+            return;
+        const joinedAid = String(data.joined_aid ?? data.member_aid ?? data.aid ?? '').trim();
+        const actorAid = String(data.actor_aid ?? '').trim();
+        const selfAid = String(this.client._aid ?? '').trim();
+        const isSelfJoin = JOIN_ACTIONS.has(action) && !!selfAid && (joinedAid === selfAid ||
+            (!joinedAid && (action === 'joined' || action === 'invite_code_used') && actorAid === selfAid));
+        if (isSelfJoin) {
+            this.scheduleGroupSpkRegistration(groupId, { reason: `group_changed:${action}` });
+        }
+        else {
+            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 V2 epoch change: group=${groupId} epoch=${String(epoch)}`);
+        }
+        catch (exc) {
+            client._clientLog.debug(`SPK rotation after V2 epoch change failed (non-fatal): ${formatE2EEError(exc)}`);
+        }
+    }
+}
+//# sourceMappingURL=v2-e2ee.js.map