@agentunion/fastaun 0.5.30 → 0.5.32

package/dist/client/control-messages.js

@@ -5,15 +5,6 @@ export const CLASS_RECEIVE_METHODS = new Set([
     'group.pull', 'group.v2.pull', 'group.history', 'group.ack', 'group.v2.ack', 'group.ack_messages',
 ]);
 function object(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
-function groupStreamNeedsPull(entry, messageClass, storage) {
-    if (!object(entry) || !object(entry.streams))
-        return true;
-    const classState = entry.streams[messageClass];
-    if (!object(classState))
-        return false;
-    const streamState = classState[storage];
-    return object(streamState) && streamState.needs_pull === true;
-}
 function protocolVersion(value) {
     const version = typeof value === 'string' && /^[1-9][0-9]*$/.test(value) ? Number(value) : value;
     return Number.isSafeInteger(version) && Number(version) > 0 ? Number(version) : null;
@@ -60,16 +51,156 @@ export function applicationResult(value) {
 export class ControlMessageCoordinator {
     client;
     locks = new Map();
-    pending = new Map();
-    workers = new Map();
     epoch = 0;
+    pubsubPages = 0;
+    pubsubPageWaiters = [];
+    pubsubReceivers = new Map();
+    pubsubCandidates = [];
+    pubsubBytes = 0;
+    blockedPubsubPulls = new Map();
+    pubsubWorkers = new Set();
     constructor(client) {
         this.client = client;
     }
+    async acquirePubsubPage(identity) {
+        if (this.pubsubPages < 4)
+            this.pubsubPages++;
+        else
+            await new Promise((resolve, reject) => { this.pubsubPageWaiters.push({ resolve, reject }); });
+        try {
+            this.check(identity);
+        }
+        catch (error) {
+            this.releasePubsubPage();
+            throw error;
+        }
+        return () => this.releasePubsubPage();
+    }
+    releasePubsubPage() {
+        const waiter = this.pubsubPageWaiters.shift();
+        if (waiter)
+            waiter.resolve();
+        else
+            this.pubsubPages--;
+    }
     supports(messageClass, group = false) {
-        const classes = this.client._negotiatedCapabilities?.message_classes_v1?.[group ? 'group' : 'p2p'];
+        if (group && messageClass === 'sdk_control')
+            return false;
+        const classes = this.client._negotiatedCapabilities?.message_classes_v2?.[group ? 'group' : 'p2p'];
         return Array.isArray(classes) && classes.includes(messageClass);
     }
+    registerPubsub(receiver, options) {
+        if (this.pubsubReceivers.size >= 64)
+            throw new StateError('control pubsub receivers are full');
+        const token = {};
+        this.pubsubReceivers.set(token, { receiver, ...options, identity: this.pubsubIdentity() });
+        return () => {
+            this.pubsubReceivers.delete(token);
+            if (!this.pubsubReceivers.size) {
+                this.pubsubCandidates = [];
+                this.pubsubBytes = 0;
+                this.blockedPubsubPulls.clear();
+            }
+        };
+    }
+    pubsubIdentity() {
+        const c = this.client;
+        return JSON.stringify([c._aid, c._deviceId, c._slotId]);
+    }
+    queuePubsubCandidate(data) {
+        if (!this.supports('sdk_control') || ![...this.pubsubReceivers.values()].some(value => value.identity === this.pubsubIdentity()))
+            return;
+        const row = object(data.inline_message) ? { ...data, ...data.inline_message } : data;
+        if (!row.volatile_cursor)
+            return;
+        let envelope = row.envelope ?? row.payload;
+        if (typeof row.envelope_json === 'string') {
+            try {
+                envelope = JSON.parse(row.envelope_json);
+            }
+            catch {
+                return;
+            }
+        }
+        if (!object(envelope) || envelope.type !== 'e2ee.p2p_encrypted' || envelope.version !== 'v2')
+            return;
+        const bytes = new TextEncoder().encode(JSON.stringify(row)).byteLength;
+        if (this.pubsubCandidates.length >= 64 || this.pubsubBytes + bytes > 1048576)
+            return;
+        const receivedAt = Date.now();
+        const deadline = Number.isSafeInteger(row.expires_at) ? row.expires_at : Number.isFinite(row.t_server) && Number.isFinite(row.ttl) ? row.t_server + row.ttl * 1000 : receivedAt + 60_000;
+        if (deadline <= receivedAt)
+            return;
+        this.pubsubCandidates.push({ row: structuredClone({ ...row, from_aid: row.from_aid ?? row.from ?? row.sender_aid, envelope_json: JSON.stringify(envelope) }), identity: this.identity(), tokens: [...this.pubsubReceivers.keys()], bytes, deadline });
+        this.pubsubBytes += bytes;
+        this.wakePubsubCandidates();
+    }
+    wakePubsubCandidates() {
+        while (this.pubsubWorkers.size < 2 && this.pubsubCandidates.length) {
+            const task = Promise.resolve().then(() => this.drainPubsubCandidates());
+            this.pubsubWorkers.add(task);
+            void task.finally(() => { this.pubsubWorkers.delete(task); this.wakePubsubCandidates(); });
+        }
+    }
+    async drainPubsubCandidates() {
+        while (this.pubsubCandidates.length) {
+            const candidate = this.pubsubCandidates.shift();
+            this.pubsubBytes -= candidate.bytes;
+            try {
+                this.check(candidate.identity);
+                if (candidate.deadline <= Date.now())
+                    continue;
+                let timer;
+                let decoded;
+                try {
+                    decoded = await Promise.race([
+                        this.decode(candidate.row, 'sdk_control', false, {}, { background: 'event', deadline: candidate.deadline }),
+                        new Promise((_, reject) => { timer = setTimeout(() => reject(new StateError('control pubsub candidate expired')), candidate.deadline - Date.now()); }),
+                    ]);
+                }
+                finally {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                }
+                if (candidate.deadline <= Date.now())
+                    continue;
+                this.check(candidate.identity);
+                this.dispatchPubsub(decoded, candidate.tokens);
+            }
+            catch { }
+        }
+    }
+    dispatchPubsub(message, tokens = this.pubsubReceivers.keys()) {
+        const headers = message.protected_headers;
+        if (!object(headers) || headers.message_class !== 'sdk_control' || headers.sdk_control_protocol !== 'aun.pubsub' || protocolVersion(headers.sdk_control_version) !== 1)
+            return true;
+        const payload = message.payload, sender = message.from ?? message.from_aid ?? message.sender_aid;
+        if (message.encrypted !== true || message._decrypt_error || !object(payload) || payload.type !== 'app.pubsub.v1'
+            || typeof sender !== 'string' || !sender || message.to && message.to !== this.client._aid
+            || !Number.isSafeInteger(payload.expires_at) || typeof payload.op !== 'string')
+            return true;
+        let admitted = true;
+        for (const token of tokens) {
+            const registered = this.pubsubReceivers.get(token);
+            if (!registered || registered.identity !== this.pubsubIdentity() || registered.clock() >= payload.expires_at
+                || (payload.service_aid ?? (payload.op === 'event' ? registered.serviceAid : undefined)) !== registered.serviceAid)
+                continue;
+            if (registered.publishReceiver) {
+                if (registered.serviceAid !== this.client._aid || !['authorize', 'publish', 'subscribe', 'renew', 'unsubscribe', 'catalog', 'stats', 'issue_grant', 'revoke_grant'].includes(payload.op))
+                    continue;
+            }
+            else if (sender !== registered.serviceAid || payload.op !== 'event' && !['authorize', 'publish', 'subscribe', 'renew', 'unsubscribe', 'catalog', 'stats', 'issue_grant', 'revoke_grant'].some(op => payload.op === `${op}.result`))
+                continue;
+            if (registered.receiver(message) === false) {
+                admitted = false;
+                if (this.blockedPubsubPulls.size < 64 || this.blockedPubsubPulls.has(sender))
+                    this.blockedPubsubPulls.set(sender, { message_class: 'sdk_control', sender_aid: sender });
+            }
+        }
+        return admitted;
+    }
+    resumePubsubPulls() { const pending = [...this.blockedPubsubPulls.values()]; this.blockedPubsubPulls.clear(); for (const request of pending)
+        this.client._delivery.queueMessageClassPull(request); }
     identity() {
         const c = this.client;
         return JSON.stringify([c._aid, c._deviceId, c._slotId, c._serviceEventIdentityVersion, c._v2RuntimeGeneration,
@@ -99,13 +230,13 @@ export class ControlMessageCoordinator {
             return { ...state, message_control_v1: streams };
         });
     }
-    async decode(row, messageClass, group, request) {
+    async decode(row, messageClass, group, request, rpcOptions) {
         if (messageClassOf(row) !== messageClass)
             throw new StateError('control message class mismatch');
         let decoded;
         const envelope = row.envelope_json ?? (object(row.payload) && String(row.payload.type ?? '').startsWith('e2ee.') ? JSON.stringify(row.payload) : null);
         if (envelope) {
-            decoded = await this.client._decryptV2Message({ ...row, envelope_json: envelope }, false, false, true, true, undefined, false, 'control_pull');
+            decoded = await this.client._decryptV2Message({ ...row, envelope_json: envelope }, false, false, true, true, undefined, false, 'control_pull', ...(rpcOptions ? [undefined, rpcOptions] : []));
             if (!decoded)
                 throw new StateError('control message decryption is not ready');
             const headers = decoded.protected_headers;
@@ -129,22 +260,34 @@ export class ControlMessageCoordinator {
         else {
             decoded = { ...row, from: row.from_aid ?? row.from, encrypted: false };
         }
+        for (const key of ['sender_device_id', 'sender_slot_id'])
+            if (typeof row[key] === 'string') {
+                if (key === 'sender_device_id' && decoded[key] && decoded[key] !== row[key])
+                    throw new StateError('control sender device mismatch');
+                decoded[key] = row[key];
+            }
         if (group) {
             decoded.group_id = request.group_id ?? request.group_aid;
             decoded.group_aid = row.group_aid ?? request.group_aid;
         }
         return { ...decoded, message_class: messageClass };
     }
-    async consume(message) {
-        if (message.encrypted !== true || !object(message.protected_headers))
-            return;
+    async consume(message, _admission = false) {
+        if (message.encrypted !== true || !object(message.protected_headers) || message.protected_headers.message_class !== 'sdk_control')
+            return true;
         const protocol = message.protected_headers.sdk_control_protocol;
         const version = protocolVersion(message.protected_headers.sdk_control_version);
         if (typeof protocol !== 'string' || version === null || !object(message.payload))
-            return;
+            return true;
+        if (protocol === 'aun.pubsub') {
+            if (version === 1)
+                return this.dispatchPubsub(message);
+            return true;
+        }
         if (typeof this.client._onSdkControl === 'function') {
             await this.client._onSdkControl(protocol, version, message.payload, String(message.from ?? message.from_aid ?? ''));
         }
+        return true;
     }
     checkScope(result, request, group, volatileGroup) {
         if (!object(result) || result.message_class !== request.message_class || !Array.isArray(result.messages))
@@ -160,35 +303,11 @@ export class ControlMessageCoordinator {
         else if (result.cursor_scope !== 'peer' || result.sender_aid !== request.sender_aid)
             throw new StateError('control Pull peer scope mismatch');
     }
-    async renewPendingAck(saved, group, key, identity) {
-        const c = this.client, ack = saved.pending_ack;
-        const target = ack.up_to_seq;
-        let after = saved.pending_ack_after_seq ?? 0;
-        if (!Number.isSafeInteger(target) || !Number.isSafeInteger(after) || after < 0 || after > target || target > saved.after_seq)
-            throw new StateError('invalid pending control ACK coverage');
-        const gateKey = `message_class/${ack.message_class}/${key}|forward|class=${ack.message_class}`;
-        let proof = '';
-        do {
-            this.check(identity);
-            const request = { message_class: ack.message_class, device_id: c._deviceId, slot_id: c._slotId, after_seq: after, head_seq: target, limit: 200,
-                ...(group ? { group_id: ack.group_id } : { cursor_scope: 'peer', sender_aid: ack.sender_aid }) };
-            const result = await c._rpcPipeline.runPullSerialized(gateKey, () => c._rpcPipeline.rawCall(group ? 'group.v2.pull' : 'message.v2.pull', request, { pullGateKey: gateKey }), true);
-            this.check(identity);
-            this.checkScope(result, request, group, false);
-            const covered = result.scanned_through_seq ?? result.covered_through_seq;
-            if (result.head_seq !== target || !Number.isSafeInteger(covered) || covered < after || covered > target
-                || covered === after && after < target || typeof result.scan_proof !== 'string' || !result.scan_proof)
-                throw new StateError('control ACK renewal coverage is invalid');
-            proof = result.scan_proof;
-            await c._rpcPipeline.rawCall(group ? 'group.v2.ack' : 'message.v2.ack', { ...ack, up_to_seq: covered, scan_proof: proof });
-            this.check(identity);
-            after = covered;
-        } while (after < target);
-        return proof;
-    }
-    async call(method, params) {
+    async call(method, params, background = false) {
         const c = this.client;
         const request = { ...params };
+        delete request._rpc_background;
+        const rpcOptions = background ? { background: true } : undefined;
         const group = method.startsWith('group.');
         const volatileGroup = group && request.volatile === true;
         const messageClass = request.message_class ?? 'normal';
@@ -205,7 +324,7 @@ export class ControlMessageCoordinator {
         if (!group)
             request.cursor_scope = 'peer';
         if (method === 'message.peers') {
-            const result = await c._rpcPipeline.rawCall(method, request);
+            const result = await c._rpcPipeline.rawCall(method, request, ...(rpcOptions ? [rpcOptions] : []));
             this.check(identity);
             if (!object(result) || result.message_class !== messageClass || !Array.isArray(result.peers))
                 throw new StateError('control peer directory scope mismatch');
@@ -219,45 +338,47 @@ export class ControlMessageCoordinator {
         const lock = new Promise((resolve) => { unlock = resolve; });
         this.locks.set(key, lock);
         await preceding;
+        let releasePage;
         try {
             this.check(identity);
             let saved = this.load(key);
             const ackMethod = group ? 'group.v2.ack' : 'message.v2.ack';
             if (!method.endsWith('.history') && object(saved.pending_ack)) {
-                let proof = saved.scan_proof;
+                delete saved.pending_ack.scan_proof;
                 try {
-                    await c._rpcPipeline.rawCall(ackMethod, saved.pending_ack);
+                    await c._rpcPipeline.rawCall(ackMethod, saved.pending_ack, ...(rpcOptions ? [rpcOptions] : []));
                 }
                 catch (error) {
                     this.check(identity);
                     if (volatileGroup && error?.data?.code === 'volatile_cursor_unavailable')
                         saved = { ...saved, volatile_cursor: '' };
-                    else {
-                        if (volatileGroup || !['scan_proof_expired', 'scan_proof_unavailable'].includes(error?.data?.code))
-                            throw error;
-                        proof = await this.renewPendingAck(saved, group, key, identity);
-                    }
+                    else
+                        throw error;
                 }
                 this.check(identity);
-                saved = { ...saved, scan_proof: proof, pending_ack: undefined, pending_ack_after_seq: undefined };
+                saved = { ...saved, pending_ack: undefined };
                 this.save(key, saved);
             }
             if (method.endsWith('.ack') || method === 'group.ack_messages') {
                 if (volatileGroup)
                     request.volatile_cursor = saved.volatile_cursor ?? '';
                 else {
-                    const upto = request.up_to_seq ?? request.seq ?? 0;
+                    const upto = request.up_to_seq ?? request.seq ?? request.msg_seq ?? 0;
                     if (!Number.isSafeInteger(upto) || upto < 0 || upto > Number(saved.after_seq ?? 0))
                         throw new ValidationError('control ACK exceeds durable cursor');
                     request.up_to_seq = upto;
-                    request.scan_proof = saved.scan_proof ?? '';
+                    delete request.scan_proof;
                 }
-                return await c._rpcPipeline.rawCall(ackMethod, request);
+                return await c._rpcPipeline.rawCall(ackMethod, request, ...(rpcOptions ? [rpcOptions] : []));
             }
             const history = method.endsWith('.history');
+            if (!history && messageClass === 'sdk_control')
+                releasePage = await this.acquirePubsubPage(identity);
+            if (!history && !group && messageClass === 'sdk_control' && this.blockedPubsubPulls.has(String(request.sender_aid)))
+                return { messages: [], _pubsub_backpressure: true, has_more: true };
             delete request.window_mode;
             delete request._rpc_background;
-            request.limit = Math.max(1, Math.min(Number(request.limit) || 50, 200));
+            request.limit = Math.max(1, Math.min(Number(request.limit) || 50, messageClass === 'sdk_control' ? 64 : 200));
             const after = request.after_seq ?? saved.after_seq ?? 0;
             if (!Number.isSafeInteger(after) || after < 0 || !history && after > Number(saved.after_seq ?? 0))
                 throw new ValidationError('control after_seq exceeds durable cursor');
@@ -267,8 +388,8 @@ export class ControlMessageCoordinator {
                     request.after_volatile_cursor ??= saved.volatile_cursor;
             }
             const wireMethod = history ? method : group ? 'group.v2.pull' : 'message.v2.pull';
-            const gateKey = `message_class/${messageClass}/${key}|forward|class=${messageClass}`;
-            const pull = () => c._rpcPipeline.runPullSerialized(gateKey, () => c._rpcPipeline.rawCall(wireMethod, request, { pullGateKey: gateKey }), true);
+            const gateKey = `message_class/${messageClass}/${group ? volatileGroup ? 'volatile_group' : 'group' : 'peer'}/${group ? request.group_id ?? request.group_aid : request.sender_aid}|forward|class=${messageClass}`;
+            const pull = () => c._rpcPipeline.runPullSerialized(gateKey, () => c._rpcPipeline.rawCall(wireMethod, request, { pullGateKey: gateKey, ...rpcOptions }), background);
             let result;
             try {
                 result = await pull();
@@ -289,10 +410,9 @@ export class ControlMessageCoordinator {
             if (!volatileGroup && (!Number.isSafeInteger(head) || !Number.isSafeInteger(covered) || covered < 0 || covered > head
                 || !history && covered < after || request.head_seq > 0 && head !== request.head_seq))
                 throw new StateError('control Pull coverage is invalid');
-            if (!history && !volatileGroup && covered > after && !(typeof result.scan_proof === 'string' && result.scan_proof))
-                throw new StateError('control Pull scan proof is missing');
             const decoded = [], volatileCursors = [], volatileIds = [];
             let previous = history ? 0 : after;
+            let backpressure = false, acceptedCovered = covered;
             const rows = !group && !history
                 ? [...result.messages].sort((left, right) => Number(object(right) && (right.storage === 'volatile' || Boolean(right.volatile_cursor)))
                     - Number(object(left) && (left.storage === 'volatile' || Boolean(left.volatile_cursor))))
@@ -306,8 +426,17 @@ export class ControlMessageCoordinator {
                         throw new StateError('control message outside verified coverage');
                     previous = row.seq;
                 }
-                decoded.push(await this.decode(row, messageClass, group, request));
+                const deadline = Number.isSafeInteger(row.expires_at) ? row.expires_at : Number.isFinite(row.t_server) && Number.isFinite(row.ttl) ? row.t_server + row.ttl * 1000 : Date.now() + 60_000;
+                const message = await this.decode(row, messageClass, group, request, ...(messageClass === 'sdk_control' ? [{ background: 'event', deadline }] : []));
+                if (messageClass !== 'sdk_control')
+                    decoded.push(message);
                 this.check(identity);
+                if (!history && messageClass === 'sdk_control' && await this.consume(message, true) === false) {
+                    backpressure = true;
+                    if (!volatile)
+                        acceptedCovered = Math.min(acceptedCovered, row.seq - 1);
+                    continue;
+                }
                 if (volatile && typeof row.volatile_cursor === 'string')
                     volatileCursors.push(row.volatile_cursor);
                 if (volatile && typeof row.volatile_id === 'string')
@@ -321,14 +450,12 @@ export class ControlMessageCoordinator {
                     }
                 }
                 for (const message of decoded) {
-                    if (messageClass === 'sdk_control')
-                        await this.consume(message);
-                    else
+                    if (messageClass !== 'sdk_control')
                         await c._publishAppEvent(group ? 'group.message_created' : 'message.received', message, 'control_pull');
                     this.check(identity);
                 }
-                const next = { after_seq: Math.max(Number(saved.after_seq ?? 0), covered), scan_proof: result.scan_proof ?? saved.scan_proof ?? '',
-                    volatile_cursor: result.volatile_cursor ?? result.next_volatile_cursor ?? volatileCursors.at(-1) ?? saved.volatile_cursor ?? '' };
+                const next = { after_seq: Math.max(Number(saved.after_seq ?? 0), acceptedCovered),
+                    volatile_cursor: backpressure ? saved.volatile_cursor ?? '' : result.volatile_cursor ?? result.next_volatile_cursor ?? volatileCursors.at(-1) ?? saved.volatile_cursor ?? '' };
                 const ack = { message_class: messageClass, device_id: c._deviceId, slot_id: c._slotId };
                 if (group)
                     ack.group_id = request.group_id ?? request.group_aid;
@@ -337,73 +464,31 @@ export class ControlMessageCoordinator {
                 if (volatileGroup)
                     Object.assign(ack, { volatile: true, volatile_cursor: next.volatile_cursor });
                 else
-                    Object.assign(ack, { up_to_seq: next.after_seq, scan_proof: next.scan_proof,
+                    Object.assign(ack, { up_to_seq: next.after_seq,
                         ...(volatileCursors.length ? { volatile_cursors: volatileCursors } : {}), ...(volatileIds.length ? { volatile_ids: volatileIds } : {}) });
                 const ackRequired = !volatileGroup || Boolean(next.volatile_cursor);
-                this.save(key, { ...next, ...(ackRequired ? { pending_ack: ack, pending_ack_after_seq: after } : {}) });
+                this.save(key, { ...next, ...(ackRequired ? { pending_ack: ack } : {}) });
                 if (ackRequired)
-                    await c._rpcPipeline.rawCall(ackMethod, ack);
+                    await c._rpcPipeline.rawCall(ackMethod, ack, ...(rpcOptions ? [rpcOptions] : []));
                 this.check(identity);
                 if (ackRequired)
                     this.save(key, next);
             }
-            return { ...result, messages: messageClass === 'sdk_control' ? [] : decoded, ack_seq: covered };
+            return { ...result, messages: messageClass === 'sdk_control' ? [] : decoded, ack_seq: acceptedCovered, ...(backpressure ? { has_more: true, ...(this.blockedPubsubPulls.has(String(request.sender_aid)) ? { _pubsub_backpressure: true } : {}) } : {}) };
         }
         finally {
+            releasePage?.();
             unlock();
             if (this.locks.get(key) === lock)
                 this.locks.delete(key);
         }
     }
-    schedule(params) {
-        const group = Boolean(params.group_id ?? params.group_aid);
-        if (!this.supports(params.message_class, group))
-            return;
-        this.pending.set(this.key(params, group), { ...params });
-        const lane = params.message_class;
-        if (!this.workers.has(lane)) {
-            const identity = this.identity();
-            const worker = this.drain(identity, lane).finally(() => {
-                if (this.workers.get(lane) !== worker)
-                    return;
-                this.workers.delete(lane);
-                const next = [...this.pending.values()].find((item) => item.message_class === lane);
-                if (next && !this.client._closing)
-                    this.schedule(next);
-            });
-            this.workers.set(lane, worker);
-        }
-    }
-    async drain(identity, lane) {
-        while (this.pending.size && identity === this.identity()) {
-            for (const higher of MESSAGE_CLASSES.slice(0, MESSAGE_CLASSES.indexOf(lane))) {
-                if (this.workers.has(higher)) {
-                    await this.workers.get(higher);
-                    if (identity !== this.identity() || this.client._closing)
-                        return;
-                }
-            }
-            const selected = [...this.pending.entries()].find(([, params]) => params.message_class === lane);
-            if (!selected)
-                break;
-            const [key, request] = selected;
-            this.pending.delete(key);
-            try {
-                const result = await this.call(request.group_id || request.group_aid ? 'group.v2.pull' : 'message.v2.pull', request);
-                this.check(identity);
-                if (result.has_more === true || result.volatile_has_more === true) {
-                    if (result.head_seq > 0)
-                        request.head_seq = result.head_seq;
-                    this.pending.set(key, request);
-                }
-            }
-            catch (error) {
-                this.client._clientLog.debug(`control pull deferred: ${String(error)}`);
-            }
-        }
-    }
     onPush(data, group = false) {
         const messageClass = messageClassOf(data);
+        if (!group && object(data) && messageClass === 'sdk_control')
+            this.queuePubsubCandidate(data);
+        if (group && messageClass === 'sdk_control')
+            return true;
         const volatile = group && object(data) && (data.storage === 'volatile' || data.volatile === true);
         if (object(data) && data.delivery_class === 'normal' && messageClass !== 'sdk_control' && !(messageClass === 'normal' && volatile))
             return false;
@@ -419,76 +504,26 @@ export class ControlMessageCoordinator {
         }
         else
             params.sender_aid = data.sender_aid ?? data.from_aid ?? data.from ?? data.inline_message?.from_aid;
-        if (params.group_id || params.sender_aid)
-            this.schedule(params);
-        return true;
-    }
-    async recover() {
-        if (!this.client._aid)
-            return;
-        const identity = this.identity();
-        for (const messageClass of MESSAGE_CLASSES.slice(0, 2)) {
-            if (!this.supports(messageClass))
-                continue;
-            let cursor = '';
-            do {
-                const result = await this.call('message.peers', { message_class: messageClass, filter: 'pending', cursor });
-                this.check(identity);
-                for (const peer of result.peers) {
-                    const sender = peer.sender_aid ?? peer.aid;
-                    if (sender)
-                        this.schedule({ message_class: messageClass, sender_aid: sender });
-                }
-                if (result.has_more !== true)
-                    break;
-                if (typeof result.next_cursor !== 'string' || !result.next_cursor || result.next_cursor === cursor)
-                    throw new StateError('control peer directory cursor did not advance');
-                cursor = result.next_cursor;
-            } while (cursor);
-        }
-        const classes = MESSAGE_CLASSES.filter((kind) => this.supports(kind, true));
-        if (classes.length) {
-            let cursor = '';
-            do {
-                const listing = await this.client._rpcPipeline.rawCall('group.list_my', { size: 200, cursor });
-                this.check(identity);
-                for (const entry of listing?.items ?? listing?.groups ?? []) {
-                    if (object(entry) && entry.status && entry.status !== 'active')
-                        continue;
-                    const groupId = typeof entry === 'string' ? entry : entry.group_id ?? entry.group_aid;
-                    if (!groupId)
-                        continue;
-                    await new Promise((resolve) => setTimeout(resolve, 500));
-                    this.check(identity);
-                    for (const messageClass of classes) {
-                        if (messageClass !== 'normal' && groupStreamNeedsPull(entry, messageClass, 'persistent'))
-                            this.schedule({ message_class: messageClass, group_id: groupId });
-                        if (groupStreamNeedsPull(entry, messageClass, 'volatile'))
-                            this.schedule({ message_class: messageClass, group_id: groupId, volatile: true });
-                    }
-                }
-                if (listing.has_more !== true)
-                    break;
-                if (typeof listing.next_cursor !== 'string' || !listing.next_cursor || listing.next_cursor === cursor)
-                    throw new StateError('control group directory cursor did not advance');
-                cursor = listing.next_cursor;
-            } while (cursor);
-        }
-        const c = this.client;
-        const saved = c._tokenStore.loadInstanceState?.(c._aid, c._deviceId, c._slotId)?.message_control_v1 ?? {};
-        for (const [key, value] of Object.entries(saved)) {
-            if (!object(value) || !value.pending_ack)
-                continue;
-            const [messageClass, kind, scope] = JSON.parse(key);
-            if (this.supports(messageClass, kind !== 'peer'))
-                this.schedule({ message_class: messageClass,
-                    ...(kind === 'peer' ? { sender_aid: scope } : { group_id: scope }), ...(kind === 'volatile_group' ? { volatile: true } : {}) });
+        if (!group && messageClass === 'sdk_control' && this.blockedPubsubPulls.has(String(params.sender_aid)))
+            return true;
+        if (params.group_id || params.sender_aid) {
+            const head = Math.max(...[data.seq, data.head_seq].filter((value) => Number.isSafeInteger(value) && value > 0), 0);
+            if (head > 0 && data.storage !== 'volatile' && data.volatile !== true && data.volatile_pending !== true && !data.volatile_cursor) {
+                const saved = this.load(this.key(params, group));
+                if (Number.isSafeInteger(saved.after_seq) && saved.after_seq >= head && !object(saved.pending_ack))
+                    return true;
+            }
+            this.client._delivery.queueMessageClassPull(params);
         }
+        return true;
     }
     close() {
         this.epoch += 1;
-        this.pending.clear();
-        this.workers.clear();
+        for (const waiter of this.pubsubPageWaiters.splice(0))
+            waiter.reject(new StateError('control pull invalidated'));
+        this.pubsubCandidates = [];
+        this.pubsubBytes = 0;
+        this.blockedPubsubPulls.clear();
     }
 }
 //# sourceMappingURL=control-messages.js.map