@agentunion/fastaun 0.5.21 → 0.5.23

package/dist/client/v2-e2ee.js

@@ -1306,6 +1306,7 @@ export class V2E2EECoordinator {
         const client = this.client;
         const generation = Number(client._v2RuntimeGeneration ?? 0);
         const inlineGeneration = client._delivery.captureInlineAckGeneration?.();
+        const pullVersion = opts.peerPullVersion ?? client._delivery.capturePeerTailVersion(senderAid);
         await client._ensureV2SessionReady('message.pull');
         this.ensureDeliveryCurrent(client._delivery.peerNamespace(senderAid), generation, inlineGeneration);
         const ns = await client._delivery.initializePeer(senderAid);
@@ -1313,18 +1314,20 @@ export class V2E2EECoordinator {
         const limit = Number(opts.limit ?? _INTERNAL_MESSAGE_FLOW_LIMITS.pullPageSize);
         if (!Number.isSafeInteger(limit) || limit < 1 || limit > 200)
             throw new ValidationError('peer limit must be between 1 and 200');
-        const mode = opts.window_mode === 'tail' ? 'tail' : 'forward';
-        const source = mode === 'tail' ? 'tail' : 'pull';
+        let mode = opts.window_mode === 'tail' ? 'tail' : 'forward';
+        let source = mode === 'tail' ? 'tail' : 'pull';
         if (mode === 'tail' && (opts.force === true || 'ack_up_to_seq' in opts))
             throw new ValidationError('Tail does not accept force or ACK');
         const budget = opts.budget ?? { remaining: Math.max(1, Number(opts.max_pages ?? 100)) };
         let after = opts.after_seq === undefined ? client._seqTracker.getContiguousSeq(ns) : strictWindowSeq(opts.after_seq, 'after_seq');
-        if (opts.force !== true && after > client._seqTracker.getContiguousSeq(ns))
+        if (mode !== 'tail' && opts.force !== true && after > client._seqTracker.getContiguousSeq(ns))
             throw new ValidationError('after_seq cannot exceed the peer delivery cursor');
         let volatileCursor = String(opts.after_volatile_cursor ?? client._delivery.peerVolatilePullCursor(senderAid));
         const decoded = [];
         let complete = false;
         let head = after;
+        let tailVolatileHasMore;
+        let tailServerAck = null;
         let pages = 0;
         let durableAck = 0;
         let initializedAck = false;
@@ -1335,6 +1338,7 @@ export class V2E2EECoordinator {
         };
         const prefetched = [];
         const stopping = new AbortController();
+        const canPull = () => !opts.background || client._delivery.hasP2pApplicationSubscription();
         const validatePage = (response, requestAfter, committedAck, preparing = false) => {
             this.ensureDeliveryCurrent(ns, generation, inlineGeneration);
             this.validatePeerResponse(response, senderAid);
@@ -1350,8 +1354,12 @@ export class V2E2EECoordinator {
                 if (response.window_mode !== 'tail')
                     throw new ValidationError('peer Tail response mode mismatch');
                 start = strictWindowSeq(response.window_start_seq, 'window_start_seq');
-                if (start > end || end !== pageHead || (end > requestAfter && start < requestAfter + 1))
+                if (volatile.length > 0 || start > end || end !== pageHead || (pageHead <= requestAfter
+                    ? start !== pageHead || persistent.length > 0
+                    : start <= requestAfter))
                     throw new ValidationError('invalid peer Tail proof');
+                if (response.volatile_has_more !== undefined && typeof response.volatile_has_more !== 'boolean')
+                    throw new ValidationError('invalid peer Tail volatile proof');
             }
             else {
                 start = strictWindowSeq(response.scan_after_seq, 'scan_after_seq');
@@ -1371,8 +1379,12 @@ export class V2E2EECoordinator {
                     throw new ValidationError('peer message is outside proof or sender');
                 previous = seq;
             }
-            if (mode === 'forward' && opts.force !== true)
-                confirmAck(safeNonNegativeSeq(response.server_ack_seq) ?? 0);
+            if (mode === 'forward' && opts.force !== true) {
+                const serverAck = safeNonNegativeSeq(response.server_ack_seq);
+                if (serverAck !== null)
+                    client._delivery.observePeerServerAck(ns, serverAck);
+                confirmAck(serverAck ?? 0);
+            }
             return { persistent, volatile, end, pageHead, start };
         };
         const decodeRows = async (rows) => {
@@ -1397,28 +1409,38 @@ export class V2E2EECoordinator {
         };
         const fetchPage = async (requestAfter, requestCursor) => {
             const key = `${ns}|mode=${mode}|after=${requestAfter}|volatile=${requestCursor}|force=${Boolean(opts.force)}|limit=${limit}`;
-            const request = (cursor) => client._runPullSerialized(key, () => client._callRawV2Rpc('message.v2.pull', {
-                cursor_scope: 'peer', sender_aid: senderAid, device_id: client._deviceId, slot_id: client._slotId,
-                after_seq: requestAfter, limit,
-                ...(mode === 'forward' && opts.force !== true && durableAck > 0 ? { ack_up_to_seq: durableAck } : {}),
-                ...(mode === 'tail' ? { window_mode: 'tail' } : {}),
-                ...(opts.force === true ? { force: true } : {}),
-                ...(cursor ? { after_volatile_cursor: cursor } : {}),
-                ...(opts.background ? { _rpc_background: true } : { _rpc_foreground: true }),
-            }, key), Boolean(opts.background));
+            const request = (cursor) => {
+                const operation = async () => {
+                    if (!canPull()) {
+                        reservation?.release();
+                        return null;
+                    }
+                    return { response: await client._callRawV2Rpc('message.v2.pull', {
+                            cursor_scope: 'peer', sender_aid: senderAid, device_id: client._deviceId, slot_id: client._slotId,
+                            after_seq: requestAfter, limit,
+                            ...(mode === 'forward' && opts.force !== true && durableAck > 0 ? { ack_up_to_seq: durableAck } : {}),
+                            ...(mode === 'tail' ? { window_mode: 'tail' } : {}),
+                            ...(opts.force === true ? { force: true } : {}),
+                            ...(cursor ? { after_volatile_cursor: cursor } : {}),
+                            ...(opts.background ? { _rpc_background: true } : { _rpc_foreground: true }),
+                        }, key), reservation };
+                };
+                const schedule = (attempt) => client._runPullSerialized(key, attempt, Boolean(opts.background));
+                return client._delivery.runPeerPullAttempt?.(ns, operation, schedule) ?? schedule(operation);
+            };
             const reservation = await client._dispatcher?._reserveMessageCapacity?.(limit, stopping.signal);
             try {
                 if (stopping.signal.aborted)
                     throw new StateError('pull invalidated');
                 try {
-                    return { response: await request(requestCursor), reservation };
+                    return await request(requestCursor);
                 }
                 catch (error) {
                     this.ensureDeliveryCurrent(ns, generation, inlineGeneration);
                     if (!requestCursor || !String(error instanceof Error ? error.message : error).toLowerCase().includes('volatile cursor epoch mismatch'))
                         throw error;
                     client._delivery.setPeerVolatilePullCursor(senderAid, '');
-                    return { response: await request(''), reservation };
+                    return await request('');
                 }
             }
             catch (error) {
@@ -1430,7 +1452,7 @@ export class V2E2EECoordinator {
             const existing = prefetched.find((page) => page.after === requestAfter && page.cursor === cursor);
             if (existing)
                 return existing;
-            if (prefetched.length >= 2 || budget.remaining <= 0 || stopping.signal.aborted)
+            if (prefetched.length >= 2 || budget.remaining <= 0 || stopping.signal.aborted || !canPull())
                 return undefined;
             budget.remaining -= 1;
             const page = { after: requestAfter, cursor, response: fetchPage(requestAfter, cursor) };
@@ -1442,6 +1464,8 @@ export class V2E2EECoordinator {
             if (page.prepared)
                 return;
             page.prepared = page.response.then(async (fetched) => {
+                if (!fetched)
+                    return null;
                 try {
                     const proof = validatePage(fetched.response, page.after, durableAck, true);
                     const handlers = client._delivery.snapshotApplicationHandlers?.();
@@ -1461,6 +1485,8 @@ export class V2E2EECoordinator {
         let failed = false;
         try {
             while (budget.remaining > 0 || prefetched.length > 0) {
+                if (prefetched.length === 0 && !canPull())
+                    break;
                 const cached = prefetched.shift();
                 if (!cached)
                     budget.remaining -= 1;
@@ -1473,11 +1499,19 @@ export class V2E2EECoordinator {
                         durableAck = committedAck;
                         initializedAck = true;
                     }
+                    if (!cached && mode === 'tail' && opts.autoTail
+                        && !client._delivery.shouldTailPeer(ns, opts.autoTail.head, limit, opts.autoTail.forwardNeed)) {
+                        mode = 'forward';
+                        source = 'pull';
+                        opts.autoTail.forward = true;
+                    }
                     if (!cached && mode === 'forward' && opts.force !== true)
                         requestedAfter = Math.max(requestedAfter, committedAck);
                     if (!cached)
                         this.ensureDeliveryCurrent(ns, generation, inlineGeneration);
                     const fetched = await (cached ? cached.prepared ?? cached.response : fetchPage(requestedAfter, requestedVolatile));
+                    if (!fetched)
+                        return null;
                     const { response, reservation } = fetched;
                     try {
                         this.ensureDeliveryCurrent(ns, generation, inlineGeneration);
@@ -1518,7 +1552,8 @@ export class V2E2EECoordinator {
                         const before = client._seqTracker.snapshotNamespace(ns);
                         try {
                             if (mode === 'tail') {
-                                client._seqTracker.commitTailWindow(ns, { windowStartSeq: start, headSeq: pageHead, coveredThroughSeq: end, pageLimit: limit, sparse: true });
+                                if (pageHead > requestedAfter)
+                                    client._seqTracker.commitTailWindow(ns, { windowStartSeq: start, headSeq: pageHead, coveredThroughSeq: end, pageLimit: limit, sparse: true });
                             }
                             else if (opts.force !== true) {
                                 client._seqTracker.onPullResult(ns, persistent, requestedAfter, end);
@@ -1551,10 +1586,18 @@ export class V2E2EECoordinator {
                         reservation?.release();
                     }
                 });
+                if (!page)
+                    break;
                 this.ensureDeliveryCurrent(ns, generation, inlineGeneration);
                 if (opts.retainMessages !== false)
                     decoded.push(...page.messages);
                 head = page.head;
+                if (mode === 'tail') {
+                    tailVolatileHasMore = page.response.volatile_has_more;
+                    tailServerAck = safeNonNegativeSeq(page.response.server_ack_seq);
+                    if (tailServerAck !== null)
+                        client._delivery.observePeerServerAck(ns, tailServerAck);
+                }
                 volatileCursor = client._delivery.peerVolatilePullCursor(senderAid);
                 const more = page.response.persistent_has_more === true || page.response.volatile_has_more === true || page.response.has_more === true;
                 complete = !more;
@@ -1573,7 +1616,7 @@ export class V2E2EECoordinator {
             stopping.abort();
             for (const pending of prefetched) {
                 try {
-                    (await (pending.prepared ?? pending.response)).reservation?.release();
+                    (await (pending.prepared ?? pending.response))?.reservation?.release();
                 }
                 catch { }
             }
@@ -1594,10 +1637,17 @@ export class V2E2EECoordinator {
             }
         }
         const ack = client._seqTracker.getContiguousSeq(ns);
-        if (!opts.background && opts.force !== true && (!complete || (mode === 'tail' && ack < head)))
+        if (mode === 'tail')
+            complete = ack >= head && durableAck >= head && tailVolatileHasMore === false
+                && tailServerAck !== null && tailServerAck >= durableAck && this.pendingForwardAck(ns, durableAck) === 0;
+        if (opts.force !== true && complete)
+            complete = client._delivery.isPeerTailCurrent(senderAid, pullVersion, Math.min(ack, durableAck));
+        if (!opts.background && opts.force !== true && !complete)
             client._delivery.schedulePeerRecovery(senderAid, head, true);
-        return { sender_aid: senderAid, messages: decoded, complete: mode === 'tail' ? ack >= head : complete,
-            ack_seq: ack, head_seq: head, pages };
+        return { sender_aid: senderAid, messages: decoded, complete,
+            ack_seq: ack, head_seq: head, pages,
+            ...(mode === 'tail' ? { ...(tailVolatileHasMore === undefined ? {} : { volatile_has_more: tailVolatileHasMore }),
+                ...(tailServerAck === null ? {} : { server_ack_seq: tailServerAck }), pending_ack_seq: this.pendingForwardAck(ns, durableAck) } : {}) };
     }
     validatePeerResponse(response, senderAid) {
         const client = this.client;
@@ -1626,6 +1676,8 @@ export class V2E2EECoordinator {
         const actual = safeNonNegativeSeq(result.peer_ack_seq ?? result.effective_ack_seq ?? result.up_to_seq);
         if (seq > 0 && (actual === null || actual < seq))
             throw new E2EEError('peer ACK watermark is below requested');
+        if (actual !== null)
+            client._delivery.observePeerServerAck(ns, actual);
         client._delivery.peerAckChanged();
         return result;
     }
@@ -1669,12 +1721,28 @@ export class V2E2EECoordinator {
         const afterSeq = strictWindowSeq(params.after_seq ?? 0, 'after_seq');
         const limit = strictWindowLimit(params.limit ?? V2_PULL_DEFAULT_PAGE_LIMIT);
         const ns = client._aid ? `p2p:${client._aid}` : '';
+        const volatileCursor = String(params.after_volatile_cursor ?? client._delivery.volatilePullCursor?.(ns) ?? '');
         if (ns)
             client._delivery.syncStarted(ns);
-        const pullGateKey = pullGateKeyForClient(client, 'message.v2.pull', {
-            window_mode: 'tail', after_seq: afterSeq, limit,
-        }, `${ns}|tail|after=${afterSeq}|limit=${limit}`);
-        const result = await client._callRawV2Rpc('message.v2.pull', { window_mode: 'tail', after_seq: afterSeq, limit, _rpc_foreground: true }, pullGateKey);
+        const request = (cursor) => {
+            const tailParams = { window_mode: 'tail', after_seq: afterSeq, limit,
+                ...(cursor ? { after_volatile_cursor: cursor } : {}) };
+            const pullGateKey = pullGateKeyForClient(client, 'message.v2.pull', tailParams, `${ns}|tail|after=${afterSeq}|limit=${limit}${cursor ? `|volatile=${cursor}` : ''}`);
+            return client._callRawV2Rpc('message.v2.pull', { ...tailParams, _rpc_foreground: true }, pullGateKey);
+        };
+        let result;
+        try {
+            result = await request(volatileCursor);
+        }
+        catch (error) {
+            this.ensureDeliveryCurrent(ns, generation);
+            if (!volatileCursor || !String(error instanceof Error ? error.message : error).toLowerCase().includes('volatile cursor epoch mismatch'))
+                throw error;
+            client._delivery.resetVolatilePullCursor?.();
+            result = await request('');
+        }
+        if (Array.isArray(result?.messages) && result.messages.some((row) => row?.storage === 'volatile'))
+            throw new ValidationError('Tail cannot return volatile messages');
         const page = validateTailPage(result, afterSeq, limit);
         const decoded = [];
         await this.withApplicationPage(ns, 'tail', async () => {
@@ -1687,12 +1755,13 @@ export class V2E2EECoordinator {
         });
         this.ensureDeliveryCurrent(ns, generation);
         if (ns) {
-            client._seqTracker.commitTailWindow(ns, {
-                windowStartSeq: page.windowStart,
-                headSeq: page.head,
-                coveredThroughSeq: page.head,
-                pageLimit: limit,
-            });
+            if (page.head > afterSeq)
+                client._seqTracker.commitTailWindow(ns, {
+                    windowStartSeq: page.windowStart,
+                    headSeq: page.head,
+                    coveredThroughSeq: page.head,
+                    pageLimit: limit,
+                });
             client._persistSeq(ns);
             await client._saveSeqTrackerState?.();
             this.ensureDeliveryCurrent(ns, generation);
@@ -2659,12 +2728,13 @@ export class V2E2EECoordinator {
         client._delivery.rememberCommittedSeqState?.(ns);
         const snapshot = client._seqTracker.snapshotNamespace?.(ns) ?? null;
         try {
-            client._seqTracker.commitTailWindow(ns, {
-                windowStartSeq: page.windowStart,
-                headSeq: page.head,
-                coveredThroughSeq: page.head,
-                pageLimit: limit,
-            });
+            if (page.head > afterSeq)
+                client._seqTracker.commitTailWindow(ns, {
+                    windowStartSeq: page.windowStart,
+                    headSeq: page.head,
+                    coveredThroughSeq: page.head,
+                    pageLimit: limit,
+                });
             await client._commitSeqTrackerState(ns);
             if (client._delivery.isSeqNamespaceGenerationCurrent?.(ns, namespaceGeneration) === false)
                 throw new Error('pull invalidated');