@agentunion/fastaun 0.5.15 → 0.5.17

package/dist/client/v2-e2ee.js

@@ -773,6 +773,12 @@ export class V2E2EECoordinator {
                     }
                     continue;
                 }
+                if (!entry.groupId && String(entry.msg.storage ?? '') === 'volatile') {
+                    await this.publishPendingV2VolatileMessage(entry.msg, plaintext, 'pending_retry');
+                    pending.delete(key);
+                    client._clientLog.debug(`V2 sender IK pending retry delivered: key=${key}`);
+                    continue;
+                }
                 pending.delete(key);
                 const seq = Number(entry.msg.seq ?? 0);
                 if (entry.groupId) {
@@ -795,6 +801,30 @@ export class V2E2EECoordinator {
             }
         }
     }
+    async publishPendingV2VolatileMessage(rawMessage, plaintext, source) {
+        const delivery = this.client._delivery;
+        const claim = delivery.beginVolatileDelivery(rawMessage);
+        if (claim === 'inflight')
+            return;
+        if (claim === 'seen') {
+            await delivery.ackVolatileMessages([rawMessage], true, false);
+            return;
+        }
+        try {
+            const publicMessage = delivery.publicVolatileMessage(plaintext);
+            for (const key of ['storage', 'volatile_cursor', 'created_at', 'expires_at', 'persist']) {
+                if (Object.prototype.hasOwnProperty.call(rawMessage, key))
+                    publicMessage[key] = rawMessage[key];
+            }
+            const appEvent = delivery.p2pAppEventForMessage(publicMessage);
+            await this.client._publishAppEvent(appEvent.event, appEvent.payload, source);
+            delivery.markVolatileSeen(rawMessage);
+        }
+        finally {
+            delivery.finishVolatileDelivery(rawMessage);
+        }
+        await delivery.ackVolatileMessages([rawMessage], true, false);
+    }
     async buildV2P2PEnvelope(opts) {
         const client = this.client;
         if (!client._v2Session) {
@@ -841,6 +871,10 @@ export class V2E2EECoordinator {
         if (peerDevices.length === 0) {
             throw new E2EEError(`V2 bootstrap: no devices found for ${to}`);
         }
+        const targetDeviceId = String(opts.deviceId ?? '').trim();
+        if (targetDeviceId && !peerDevices.some((dev) => String(dev.device_id ?? '').trim() === targetDeviceId)) {
+            throw new E2EEError(`V2 bootstrap: target device ${targetDeviceId} not found for ${to}`);
+        }
         let targetSet = useCache ? this.getTargetSetCache(to) : undefined;
         if (targetSet) {
             targetSet = this.cloneP2PTargetSet(targetSet);
@@ -926,6 +960,20 @@ export class V2E2EECoordinator {
         if (targetSet.targets.length === 0) {
             throw new E2EEError(`V2 bootstrap: no usable devices found for ${to}`);
         }
+        if (targetDeviceId) {
+            let peerTargetFound = false;
+            targetSet.targets = targetSet.targets.filter((target) => {
+                const isPeerTarget = target.aid === to
+                    && (target.deviceId === targetDeviceId || (wrapPolicy.scope === 'aid' && !target.deviceId))
+                    && target.role !== 'self_sync';
+                if (isPeerTarget)
+                    peerTargetFound = true;
+                return isPeerTarget || target.role === 'self_sync';
+            });
+            if (!peerTargetFound) {
+                throw new E2EEError(`V2 bootstrap: target device ${targetDeviceId} not found for ${to}`);
+            }
+        }
         const envelope = encryptP2PMessage(session.getSenderIdentity(), targetSet, opts.payload, {
             messageId: opts.messageId,
             timestamp: opts.timestamp,
@@ -954,6 +1002,7 @@ export class V2E2EECoordinator {
         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();
+        const targetDeviceId = String(opts?.deviceId ?? '').trim();
         if (!toAid)
             throw new ValidationError("message.send requires 'to'");
         if (!isJsonObject(payload))
@@ -971,6 +1020,7 @@ export class V2E2EECoordinator {
                 payload,
                 messageId,
                 timestamp: opts?.timestamp,
+                deviceId: targetDeviceId || undefined,
                 protectedHeaders: opts?.protectedHeaders,
                 context: opts?.context,
                 useCache,
@@ -979,6 +1029,8 @@ export class V2E2EECoordinator {
                 to: toAid,
                 payload: envelope,
                 message_id: messageId,
+                ...(targetDeviceId ? { device_id: targetDeviceId } : {}),
+                ...(opts?.ttl !== undefined ? { ttl: opts.ttl } : {}),
                 encrypt: false,
                 _skip_send_result_envelope: true,
             });
@@ -992,6 +1044,7 @@ export class V2E2EECoordinator {
                 payload,
                 message_id: messageId,
                 timestamp: opts?.timestamp,
+                ttl: opts?.ttl,
                 protected_headers: opts?.protectedHeaders,
                 context: opts?.context,
             }, result, true);
@@ -1007,6 +1060,7 @@ export class V2E2EECoordinator {
                     payload,
                     message_id: messageId,
                     timestamp: opts?.timestamp,
+                    ttl: opts?.ttl,
                     protected_headers: opts?.protectedHeaders,
                     context: opts?.context,
                 }, result, true);
@@ -1223,6 +1277,7 @@ export class V2E2EECoordinator {
             }), true);
         }
         const decrypted = [];
+        let volatileCursor = String(opts?.afterVolatileCursor ?? client._delivery.volatilePullCursor?.() ?? '').trim();
         let nextAfterSeq = opts?.force ? afterSeq : (afterSeq || (ns ? client._seqTracker.getContiguousSeq(ns) : 0));
         let pullGateKey = ns
             ? pullGateKeyForClient(client, 'message.v2.pull', {
@@ -1237,17 +1292,31 @@ export class V2E2EECoordinator {
         const maxPages = Math.max(1, Math.min(100, Math.trunc(Number(opts?.maxPages ?? 100) || 100)));
         while (pageCount < maxPages) {
             pageCount += 1;
+            const requestedVolatileCursor = volatileCursor;
             const ackUpToSeq = pendingAckSeq;
             const inlineAckGeneration = ackUpToSeq > 0
                 ? client._delivery.captureP2PInlineAckGeneration()
                 : null;
             client._clientLog.debug(`message.v2.pull page request: page=${pageCount}, after_seq=${nextAfterSeq}, limit=${limit}, ack_up_to_seq=${ackUpToSeq}, ns=${ns || '<none>'}`);
-            const result = await client._callRawV2Rpc('message.v2.pull', {
-                after_seq: nextAfterSeq,
-                limit,
-                ...(opts?.force ? { force: true } : {}),
-                ...(ackUpToSeq > 0 ? { ack_up_to_seq: ackUpToSeq } : {}),
-            }, pullGateKey);
+            let result;
+            try {
+                result = await client._callRawV2Rpc('message.v2.pull', {
+                    after_seq: nextAfterSeq,
+                    limit,
+                    ...(volatileCursor ? { after_volatile_cursor: volatileCursor } : {}),
+                    ...(opts?.force ? { force: true } : {}),
+                    ...(ackUpToSeq > 0 ? { ack_up_to_seq: ackUpToSeq } : {}),
+                }, pullGateKey);
+            }
+            catch (exc) {
+                if (!volatileCursor || !String(exc instanceof Error ? exc.message : exc).toLowerCase().includes('volatile cursor epoch mismatch')) {
+                    throw exc;
+                }
+                client._delivery.resetVolatilePullCursor?.();
+                volatileCursor = '';
+                pageCount -= 1;
+                continue;
+            }
             if (ackUpToSeq > 0) {
                 const actualAckSeq = client._delivery.resolveP2PPullAckSeq(result, ackUpToSeq);
                 if (actualAckSeq >= ackUpToSeq) {
@@ -1266,10 +1335,16 @@ export class V2E2EECoordinator {
                 }
             }
             const pageMessages = (Array.isArray(result?.messages) ? result.messages : []);
+            const volatileMessages = client._delivery.volatileMessages?.(pageMessages) ?? [];
+            if (volatileMessages.length > 0) {
+                decrypted.push(...await this.publishV2VolatileMessages(volatileMessages, 'pull', true));
+                volatileCursor = String(client._delivery.volatilePullCursor?.() ?? '').trim();
+            }
             const messages = deduplicateForwardPageMessages(pageMessages, nextAfterSeq);
             const cursor = isJsonObject(result.cursor) ? result.cursor : null;
             const hasMoreField = Object.prototype.hasOwnProperty.call(result, 'has_more');
             const hasMore = result.has_more === true;
+            const volatileHasMore = result.volatile_has_more === true;
             const serverHead = safeNonNegativeSeq(cursor?.latest_seq) ?? 0;
             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_head=${serverHead}, server_ack_seq=${String(result.server_ack_seq ?? '')}`);
             for (const msg of messages) {
@@ -1469,7 +1544,7 @@ export class V2E2EECoordinator {
             const rawCount = messages.length;
             if (blockedSeq > 0)
                 break;
-            const shouldContinue = shouldContinueForwardPage({
+            const shouldContinuePersistent = shouldContinueForwardPage({
                 rawCount,
                 nextAfterSeq,
                 nextAfter,
@@ -1480,7 +1555,11 @@ export class V2E2EECoordinator {
                 observedUpper: Math.max(client._seqTracker.getMaxSeenSeq(ns), Number(client._pendingP2pPullUpper?.get?.(ns) ?? 0)),
                 pendingAckSeq,
             });
-            if (!shouldContinue)
+            const shouldContinueVolatile = (hasMore || volatileHasMore)
+                && volatileMessages.length > 0
+                && Boolean(volatileCursor)
+                && volatileCursor !== requestedVolatileCursor;
+            if (!shouldContinuePersistent && !shouldContinueVolatile)
                 break;
             if (pullGateKey && opts?.gateLocked && client._rpcPipeline?.yieldPullGate) {
                 const nextKey = pullGateKeyForClient(client, 'message.v2.pull', {
@@ -1518,6 +1597,73 @@ export class V2E2EECoordinator {
             throw error;
         }
     }
+    async publishV2VolatileMessages(messages, source, advanceCursor) {
+        const client = this.client;
+        if (!client._v2Session)
+            return [];
+        const processed = [];
+        const plaintextMessages = [];
+        let complete = true;
+        for (const rawMessage of messages) {
+            const claim = client._delivery.beginVolatileDelivery(rawMessage);
+            if (claim === 'seen') {
+                processed.push(rawMessage);
+                continue;
+            }
+            if (claim === 'inflight') {
+                complete = false;
+                continue;
+            }
+            let plaintext;
+            try {
+                if (this.isEncryptedPushMessage(rawMessage)) {
+                    plaintext = await client._decryptV2Message(rawMessage, true, true, true, true, undefined, false, source);
+                }
+                else {
+                    const legacy = isJsonObject(rawMessage.legacy_v1)
+                        ? rawMessage.legacy_v1
+                        : {};
+                    plaintext = {
+                        message_id: String(rawMessage.message_id ?? ''),
+                        from: String(rawMessage.from_aid ?? rawMessage.from ?? ''),
+                        to: String(legacy.to ?? rawMessage.to ?? client._aid ?? ''),
+                        type: String(rawMessage.type ?? ''),
+                        timestamp: rawMessage.t_server ?? rawMessage.timestamp,
+                        payload: legacy.payload !== undefined ? legacy.payload : rawMessage.payload,
+                        encrypted: false,
+                    };
+                    for (const key of ['context', 'protected_headers', 'headers', 'client_signature']) {
+                        if (Object.prototype.hasOwnProperty.call(rawMessage, key))
+                            plaintext[key] = rawMessage[key];
+                    }
+                    if (rawMessage.sender_device_id !== undefined)
+                        plaintext.sender_device_id = rawMessage.sender_device_id;
+                    attachGatewayProximity(plaintext, rawMessage);
+                }
+                if (!plaintext) {
+                    complete = false;
+                    continue;
+                }
+                const publicMessage = client._delivery.publicVolatileMessage(plaintext);
+                for (const key of ['storage', 'volatile_cursor', 'created_at', 'expires_at', 'persist']) {
+                    if (Object.prototype.hasOwnProperty.call(rawMessage, key))
+                        publicMessage[key] = rawMessage[key];
+                }
+                const appEvent = client._delivery.p2pAppEventForMessage(publicMessage);
+                await client._publishAppEvent(appEvent.event, appEvent.payload, source);
+                client._delivery.markVolatileSeen(rawMessage);
+                processed.push(rawMessage);
+                plaintextMessages.push(publicMessage);
+            }
+            finally {
+                client._delivery.finishVolatileDelivery(rawMessage);
+            }
+        }
+        if (processed.length > 0) {
+            await client._delivery.ackVolatileMessages(processed, true, advanceCursor && complete && processed.length === messages.length);
+        }
+        return plaintextMessages;
+    }
     async confirmForwardP2PAck(upToSeq) {
         const ns = this.client._aid ? `p2p:${this.client._aid}` : '';
         try {
@@ -1533,28 +1679,41 @@ export class V2E2EECoordinator {
             throw exc;
         }
     }
-    async ackV2(upToSeq) {
-        return this.ackV2WithConfirmation(upToSeq, false);
+    async ackV2(upToSeq, opts) {
+        return this.ackV2WithConfirmation(upToSeq, false, opts);
     }
     async ackV2ForForward(upToSeq) {
         return this.ackV2WithConfirmation(upToSeq, true);
     }
-    async ackV2WithConfirmation(upToSeq, requireServerWatermark) {
+    async ackV2WithConfirmation(upToSeq, requireServerWatermark, opts) {
         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) {
+        const volatileCursors = Array.isArray(opts?.volatileCursors) ? opts?.volatileCursors : [];
+        const volatileIds = Array.isArray(opts?.volatileIds) ? opts?.volatileIds : [];
+        let seq = Number(upToSeq ?? ((volatileCursors.length > 0 || volatileIds.length > 0)
+            ? 0
+            : (ns ? client._seqTracker.getContiguousSeq(ns) : 0)));
+        if ((!Number.isFinite(seq) || seq <= 0) && volatileCursors.length === 0 && volatileIds.length === 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);
-        if (seq <= 0)
+        if (Number.isFinite(seq) && seq > 0) {
+            seq = client._clampAckSeq('message.v2.ack', 'up_to_seq', ns, seq);
+        }
+        else {
+            seq = 0;
+        }
+        if (seq <= 0 && volatileCursors.length === 0 && volatileIds.length === 0)
             return { acked: 0 };
         const inlineAckGeneration = client._delivery.captureP2PInlineAckGeneration();
         const v2SessionAtStart = client._v2Session;
         const v2RuntimeGenerationAtStart = Number(client._v2RuntimeGeneration ?? 0);
         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 raw = await client._callRawV2Rpc('message.v2.ack', {
+            ...(seq > 0 ? { up_to_seq: seq } : {}),
+            ...(volatileCursors.length > 0 ? { volatile_cursors: volatileCursors } : {}),
+            ...(volatileIds.length > 0 ? { volatile_ids: volatileIds } : {}),
+        });
         const result = isJsonObject(raw)
             ? { ...raw }
             : { result: raw };
@@ -1566,7 +1725,7 @@ export class V2E2EECoordinator {
         }
         result.ack_seq = actualAckSeq;
         result.success = true;
-        if (inlineAckGeneration !== null) {
+        if (seq > 0 && inlineAckGeneration !== null) {
             client._delivery.onP2PV2AckSucceeded(actualAckSeq, inlineAckGeneration);
         }
         if (v2SessionAtStart
@@ -1664,7 +1823,6 @@ export class V2E2EECoordinator {
         let epoch = 0;
         let stateCommitment = { state_version: 0, state_hash: '', state_chain: '' };
         let wrapPolicy = normalizeV2WrapPolicy(undefined);
-        let usedCachedBootstrap = false;
         const cached = useCache ? this.getBootstrapCacheEntry(cacheKey) : undefined;
         if (cached && Date.now() - Number(cached.cachedAt ?? 0) < V2_BOOTSTRAP_TTL_MS) {
             allDevices = (cached.devices ?? []);
@@ -1672,7 +1830,6 @@ export class V2E2EECoordinator {
             epoch = Number(cached.epoch ?? 0) || 0;
             stateCommitment = cached.stateCommitment ?? stateCommitment;
             wrapPolicy = cached.wrapPolicy ?? wrapPolicy;
-            usedCachedBootstrap = true;
             client._clientLog.debug(`group.v2.bootstrap cache hit: group=${groupId}, devices=${allDevices.length}, audit=${auditRecipientsRaw.length}, epoch=${epoch}, state_version=${stateCommitment.state_version}`);
         }
         else {
@@ -1736,13 +1893,10 @@ export class V2E2EECoordinator {
                     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}`);
+                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: [] },
+                });
             }
             for (const dev of auditRecipientsRaw) {
                 const target = await client._v2BuildTargetFromDevice({
@@ -1761,13 +1915,10 @@ export class V2E2EECoordinator {
             targetSet = this.cloneGroupTargetSet(targetSet);
         }
         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}`);
+            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: [] },
+            });
         }
         const envelope = encryptGroupMessage(session.getSenderIdentity(), groupId, epoch, targetSet.targets, opts.payload, {
             messageId: opts.messageId,
@@ -2751,7 +2902,6 @@ export class V2E2EECoordinator {
             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',
         };
@@ -2795,13 +2945,14 @@ export class V2E2EECoordinator {
             encrypted: true,
             e2ee,
         };
+        const senderDeviceId = String(aad.from_device ?? '').trim();
+        if (senderDeviceId)
+            result.sender_device_id = senderDeviceId;
         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);