@agentunion/fastaun 0.5.33 → 0.5.35

package/dist/pubsub/service.js

@@ -1,5 +1,6 @@
 import { PubSubError } from './errors.js';
 import { FairScheduler } from './scheduler.js';
+import { matchPattern, publisherFilter, validatePattern } from './channel.js';
 import { digest } from '../org-protocol.js';
 const copy = (v) => v === undefined ? v : JSON.parse(JSON.stringify(v));
 const json = (v) => { if (v === null || typeof v !== 'object')
@@ -16,6 +17,9 @@ export class EventService {
     clock;
     limits;
     state;
+    publisherResolver;
+    publisherProfiles = new Map();
+    publisherLookups = new Map();
     deliveryLeases = new Map();
     lifecycleGeneration = 0;
     generation = 0;
@@ -33,6 +37,8 @@ export class EventService {
     requests = new Map();
     published = new Map();
     counters = new Map();
+    publicationSummaries = new Map();
+    publicationBytes = 0;
     scheduler;
     snapshots = new Map();
     snapshotRefs = new Map();
@@ -82,42 +88,101 @@ export class EventService {
         return this; this.starting = this.initialize().finally(() => { this.starting = undefined; }); return this.starting; }
     async initialize() {
         const saved = await this.state?.load?.();
+        this.leases.clear();
+        this.leaseSizes.clear();
+        this.leaseBytes = this.subscriptionBytes = 0;
+        this.nextLeaseExpiry = Infinity;
+        this.subscriptions.clear();
+        this.subscriptionsByEvent.clear();
+        this.snapshots.clear();
         if (saved && saved.service_aid === this.service_aid) {
-            this.catalog = copy(saved.catalog ?? this.catalog);
-            this.allowlist = copy(saved.allowlist ?? this.allowlist);
+            this.catalog = copy({ ...saved.catalog, ...this.catalog });
+            this.allowlist = copy({ ...saved.allowlist, ...this.allowlist });
             this.issuedGrants = new Map(saved.issued_grants ?? []);
             this.pausedCids = new Set(saved.paused_cids ?? []);
         }
         this.validateCatalog(this.catalog);
         this.refreshRevision();
-        await this.saveState();
         await this.credentials?.refreshRevocations?.();
+        if (saved && saved.service_aid === this.service_aid) {
+            for (const [id, value] of saved.leases ?? []) {
+                const lease = copy(value);
+                if (lease.expires_at <= this.clock() || lease.cid && (this.pausedCids.has(lease.cid) || this.credentials?.isRevoked?.(lease.grant ?? lease.cid)))
+                    continue;
+                lease.scope = lease.scope.filter(item => !!this.catalog[item.event_name] && (lease.auth_mode !== 'allowlist' || this.allowlisted(lease.aid, item)));
+                if (!lease.scope.length)
+                    continue;
+                if (lease.auth_mode === 'credential') {
+                    if (!this.credentials || !lease.grant)
+                        continue;
+                    try {
+                        const credentials = this.credentials;
+                        const verified = credentials._restoreVerificationContext ? await credentials._restoreVerificationContext(lease.grant, lease.aid, lease.scope, lease.verification_context) : await credentials.verify(lease.grant, lease.aid, lease.scope, undefined);
+                        lease.expires_at = Math.min(lease.expires_at, Number(verified.expires_at ?? lease.expires_at));
+                        lease.authorization_until = Math.min(lease.expires_at, Number(verified.proof_expires_at ?? lease.expires_at));
+                        if (lease.authorization_until <= this.clock())
+                            continue;
+                        if (verified.verification_context !== undefined)
+                            lease.verification_context = verified.verification_context;
+                    }
+                    catch (error) {
+                        if (error instanceof PubSubError && ['FORBIDDEN', 'REAUTH_REQUIRED'].includes(error.code))
+                            continue;
+                        throw error;
+                    }
+                }
+                this.leases.set(id, lease);
+                const size = this.leaseSize(lease);
+                this.leaseSizes.set(id, size);
+                this.leaseBytes += size;
+                this.nextLeaseExpiry = Math.min(this.nextLeaseExpiry, lease.expires_at);
+            }
+            for (const [key, value] of saved.subscriptions ?? []) {
+                const sub = copy(value), lease = this.leases.get(sub.leaseId);
+                sub.filter = publisherFilter(sub.filter);
+                sub.size = new TextEncoder().encode(key + sub.aid + sub.leaseId + json(sub.filter)).byteLength + 128;
+                if (!lease || lease.aid !== sub.aid || !lease.scope.some(item => item.event_name === sub.event && item.action === 'subscribe'))
+                    continue;
+                this.subscriptions.set(key, sub);
+                this.subscriptionBytes += sub.size;
+                this.generation = Math.max(this.generation, sub.generation);
+                let view = this.subscriptionsByEvent.get(sub.event);
+                if (!view)
+                    this.subscriptionsByEvent.set(sub.event, view = new Map());
+                view.set(key, sub);
+            }
+            this.pruneSubscriptions();
+        }
+        await this.saveState();
         this.scheduler = new FairScheduler(task => this.deliver(task), { concurrency: Math.min(4, this.limits.event_concurrency ?? 4), quantum: this.limits.quantum ?? 4096, maxQueued: this.limits.delivery_items ?? 4096, maxBytes: Math.min(this.limits.delivery_bytes ?? 8 * 1024 * 1024, this.limit('body_bytes', 64 * 1024 * 1024), 64 * 1024 * 1024), perAidQueued: this.limits.per_aid_items ?? 512, perAidBytes: this.limits.per_aid_bytes ?? 2 * 1024 * 1024, costOverhead: this.limits.cost_overhead ?? 128, onDrop: (task, reason) => { this.deliveryLeases.delete(task.message_id); this.counter(task.event_name)[reason === 'failed' ? 'failed' : 'skipped_revoked']++; } });
         this.scheduler.onCapacity(() => this.capacityChanged());
         this.counters.clear();
+        this.publicationSummaries.clear();
+        this.publicationBytes = 0;
+        this.tokenKey = uuid();
         this.since = this.clock();
         this.closed = false;
         this.running = true;
         await this.scheduler.start();
         return this;
     }
-    saveState() { const value = copy({ service_aid: this.service_aid, catalog: this.catalog, allowlist: this.allowlist, issued_grants: [...this.issuedGrants], paused_cids: [...this.pausedCids] }); const write = this.stateWrite.then(async () => { await this.state?.save?.(value); }); this.stateWrite = write.catch(() => { }); return write; }
+    saveState() { const value = copy({ service_aid: this.service_aid, catalog: this.catalog, allowlist: this.allowlist, issued_grants: [...this.issuedGrants], paused_cids: [...this.pausedCids], leases: [...this.leases], subscriptions: [...this.subscriptions] }); const write = this.stateWrite.then(async () => { await this.state?.save?.(value); }); this.stateWrite = write.catch(() => { }); return write; }
     async close() { if (this.starting) {
         try {
             await this.starting;
         }
         catch { }
     } this.lifecycleGeneration++; this.closed = true; this.running = false; this.capacityChanged(); await this.fanoutTask; if (this.scheduler)
-        await this.scheduler.close(); this.scheduler = undefined; this.fanout.clear(); this.fanoutReady = []; this.fanoutCount = this.fanoutBytes = this.snapshotBytes = 0; this.snapshotRefs.clear(); this.deliveryLeases.clear(); this.leases.clear(); this.leaseSizes.clear(); this.leaseBytes = this.subscriptionBytes = 0; this.nextLeaseExpiry = Infinity; this.subscriptions.clear(); this.subscriptionsByEvent.clear(); this.snapshots.clear(); this.credentials?.clearVerified?.(); this.requests.clear(); this.published.clear(); await this.stateWrite; }
+        await this.scheduler.close(); this.scheduler = undefined; this.fanout.clear(); this.fanoutReady = []; this.fanoutCount = this.fanoutBytes = this.snapshotBytes = 0; this.snapshotRefs.clear(); this.deliveryLeases.clear(); this.leases.clear(); this.leaseSizes.clear(); this.leaseBytes = this.subscriptionBytes = 0; this.nextLeaseExpiry = Infinity; this.subscriptions.clear(); this.subscriptionsByEvent.clear(); this.snapshots.clear(); this.credentials?.clearVerified?.(); this.publisherProfiles.clear(); this.publisherLookups.clear(); this.requests.clear(); this.published.clear(); this.publicationSummaries.clear(); this.publicationBytes = 0; await this.stateWrite; }
     async drain() { while (this.fanoutTask)
         await this.fanoutTask; await this.scheduler?.drain(); }
     setSend(send) { this.send = send; }
     async updateConfig(config) { if (config.catalog) {
         this.validateCatalog(config.catalog);
-        this.catalog = copy(config.catalog);
+        this.catalog = copy({ ...this.catalog, ...config.catalog });
         this.refreshRevision();
     } if (config.allowlist)
-        this.allowlist = copy(config.allowlist); for (const [id, lease] of this.leases) {
+        this.allowlist = copy({ ...this.allowlist, ...config.allowlist }); for (const [id, lease] of this.leases) {
         lease.scope = lease.scope.filter(item => !!this.catalog[item.event_name] && (lease.auth_mode !== 'allowlist' || this.allowlisted(lease.aid, item)));
         if (!lease.scope.length)
             this.removeLease(id);
@@ -166,6 +231,8 @@ export class EventService {
             return this.catalogOp(senderAid, request, undefined, undefined, local);
         if (op === 'stats')
             return this.statsOp(senderAid, request);
+        if (op === 'publications' || op === 'subscriptions')
+            return this.listingOp(senderAid, request, local);
         const id = request.request_id;
         if (!id)
             throw new PubSubError('INVALID_REQUEST');
@@ -183,7 +250,8 @@ export class EventService {
             throw new PubSubError('OVERLOADED');
         const entry = { fingerprint: fp, expiresAt: request.expires_at ?? this.clock() + 60_000 };
         this.requests.set(key, entry);
-        const promise = Promise.resolve().then(() => this.dispatch(senderAid, request, route));
+        const promise = Promise.resolve().then(async () => { const result = await this.dispatch(senderAid, request, route); if (this.state?.save && ['authorize', 'renew', 'subscribe', 'unsubscribe'].includes(op))
+            await this.saveState(); return result; });
         entry.promise = promise;
         try {
             const result = await promise;
@@ -248,6 +316,7 @@ export class EventService {
         let expires = this.clock() + 12_000_000;
         let cid;
         let proofExpires = expires;
+        let verificationContext;
         if (mode === 'allowlist') {
             if (scope.some(item => !this.allowlisted(sender, item)))
                 throw new PubSubError('FORBIDDEN');
@@ -262,13 +331,14 @@ export class EventService {
             if (this.pausedCids.has(cid) || this.credentials.isRevoked?.(grant))
                 throw new PubSubError('REAUTH_REQUIRED');
             proofExpires = Number(verified.proof_expires_at ?? expires);
+            verificationContext = verified.verification_context;
         }
         else
             throw new PubSubError('INVALID_AUTH_MODE');
         if (generation !== this.lifecycleGeneration || this.closed)
             throw new PubSubError('SERVICE_CLOSED');
         const grant = mode === 'credential' ? (request.grant ?? request.credential) : undefined;
-        const lease = { lease_id: uuid(), aid: sender, ...(route ? { route: copy(route) } : {}), scope, auth_mode: mode, expires_at: expires, authorization_until: Math.min(expires, proofExpires), ...(cid ? { cid } : {}), ...(grant ? { grant } : {}) };
+        const lease = { lease_id: uuid(), aid: sender, ...(route ? { route: copy(route) } : {}), scope, auth_mode: mode, expires_at: expires, authorization_until: Math.min(expires, proofExpires), ...(cid ? { cid } : {}), ...(grant ? { grant } : {}), ...(verificationContext !== undefined ? { verification_context: verificationContext } : {}) };
         const size = this.leaseSize(lease);
         if (this.leases.size >= this.limit('lease_items', 16384) || this.leaseBytes + size > this.limit('lease_bytes', 8 * 1024 * 1024))
             throw new PubSubError('OVERLOADED');
@@ -305,7 +375,7 @@ export class EventService {
                 throw new PubSubError('REAUTH_REQUIRED');
         }
         catch (error) {
-            if (error instanceof PubSubError && error.code === 'TIMEOUT')
+            if (!(error instanceof PubSubError) || !['FORBIDDEN', 'REAUTH_REQUIRED', 'CREDENTIAL_REVOKED', 'CREDENTIAL_EXPIRED'].includes(error.code))
                 throw error;
             this.removeLease(lease.lease_id);
             this.pruneSubscriptions();
@@ -313,7 +383,7 @@ export class EventService {
         }
     }
     async renew(sender, request) { const old = this.lease(sender, request.lease_id); if (old.auth_mode === 'credential')
-        await this.credentials?.assertNotRevoked?.(old.grant ?? old.cid, request.expires_at); const now = this.clock(); let expires = now + 12_000_000, proofExpires = expires; let grant = old.grant, cid = old.cid; if (old.auth_mode === 'credential') {
+        await this.credentials?.assertNotRevoked?.(old.grant ?? old.cid, request.expires_at); const now = this.clock(); let expires = now + 12_000_000, proofExpires = expires; let grant = old.grant, cid = old.cid; let verificationContext = old.verification_context; if (old.auth_mode === 'credential') {
         grant = request.grant ?? old.grant;
         if (!this.credentials || !grant)
             throw new PubSubError('REAUTH_REQUIRED');
@@ -321,18 +391,41 @@ export class EventService {
         const verified = await this.credentials.verify(grant, sender, old.scope, request, request.expires_at);
         expires = Math.min(expires, Number(verified.expires_at));
         proofExpires = Number(verified.proof_expires_at ?? expires);
+        verificationContext = verified.verification_context;
         cid = String(verified.cid ?? grant.cid ?? '');
         if (Math.min(expires, proofExpires) <= now || this.pausedCids.has(cid) || this.credentials.isRevoked?.(grant))
             throw new PubSubError('REAUTH_REQUIRED');
     } if (this.lease(sender, request.lease_id) !== old)
-        throw new PubSubError('REAUTH_REQUIRED'); const updated = { ...old, grant, cid, expires_at: expires, authorization_until: Math.min(expires, proofExpires) }; const change = this.leaseSize(updated) - (this.leaseSizes.get(old.lease_id) ?? 0); if (this.leaseBytes + change > this.limit('lease_bytes', 8 * 1024 * 1024))
+        throw new PubSubError('REAUTH_REQUIRED'); const updated = { ...old, grant, cid, expires_at: expires, authorization_until: Math.min(expires, proofExpires), ...(verificationContext !== undefined ? { verification_context: verificationContext } : {}) }; const change = this.leaseSize(updated) - (this.leaseSizes.get(old.lease_id) ?? 0); if (this.leaseBytes + change > this.limit('lease_bytes', 8 * 1024 * 1024))
         throw new PubSubError('OVERLOADED'); Object.assign(old, updated); this.leaseBytes += change; this.leaseSizes.set(old.lease_id, this.leaseSize(updated)); this.nextLeaseExpiry = Math.min(this.nextLeaseExpiry, expires); return this.leaseResult(old); }
-    events(request) { const names = request.events ?? (request.event_name ? [request.event_name] : []); if (!names.length || names.some(name => typeof name !== 'string' || !this.catalog[name]))
-        throw new PubSubError('UNKNOWN_EVENT'); return [...new Set(names)]; }
+    events(request, lease, unsubscribe = false) {
+        const names = request.events ?? (request.event_name ? [request.event_name] : []);
+        if (!Array.isArray(names) || !names.length)
+            throw new PubSubError('UNKNOWN_EVENT');
+        const events = new Set();
+        for (const name of names) {
+            validatePattern(name);
+            if (!name.includes('*')) {
+                if (!this.catalog[name])
+                    throw new PubSubError('UNKNOWN_EVENT');
+                this.lease(lease.aid, lease.lease_id, [{ event_name: name, action: 'subscribe' }]);
+                events.add(name);
+                continue;
+            }
+            const matches = unsubscribe ? [...this.subscriptions.values()].filter(sub => sub.leaseId === lease.lease_id && matchPattern(name, sub.event)).map(sub => sub.event) : Object.keys(this.catalog).filter(event => matchPattern(name, event));
+            if (!unsubscribe && !matches.length)
+                throw new PubSubError('UNKNOWN_EVENT');
+            const authorized = matches.filter(event => lease.scope.some(item => item.event_name === event && item.action === 'subscribe'));
+            if (!unsubscribe && !authorized.length)
+                throw new PubSubError('FORBIDDEN');
+            authorized.forEach(event => events.add(event));
+        }
+        return [...events];
+    }
     subscriptionKey(aid, event, route) { return route ? json([aid, route.device_id, route.slot_id, event]) : `${aid}:${event}`; }
-    async subscribe(sender, request) { const events = this.events(request); const lease = this.lease(sender, request.lease_id, events.map(event_name => ({ event_name, action: 'subscribe' }))); const additions = events.map(name => { const key = this.subscriptionKey(sender, name, lease.route); return { name, key, size: new TextEncoder().encode(key + sender + lease.lease_id).byteLength + 128 }; }); const added = additions.filter(item => !this.subscriptions.has(item.key)); const bytes = additions.reduce((sum, item) => sum + item.size - (this.subscriptions.get(item.key)?.size ?? 0), 0); if (this.subscriptions.size + added.length > this.limit('subscription_items', 16384) || this.subscriptionBytes + bytes > this.limit('subscription_bytes', 8 * 1024 * 1024))
+    async subscribe(sender, request) { const filter = publisherFilter(request), lease = this.lease(sender, request.lease_id), events = this.events(request, lease); const additions = events.map(name => { const key = this.subscriptionKey(sender, name, lease.route); return { name, key, size: new TextEncoder().encode(key + sender + lease.lease_id + json(filter)).byteLength + 128 }; }); const added = additions.filter(item => !this.subscriptions.has(item.key)); const bytes = additions.reduce((sum, item) => sum + item.size - (this.subscriptions.get(item.key)?.size ?? 0), 0); if (this.subscriptions.size + added.length > this.limit('subscription_items', 16384) || this.subscriptionBytes + bytes > this.limit('subscription_bytes', 8 * 1024 * 1024))
         throw new PubSubError('OVERLOADED'); for (const item of additions) {
-        const sub = { leaseId: lease.lease_id, generation: ++this.generation, aid: sender, event: item.name, size: item.size };
+        const sub = { leaseId: lease.lease_id, generation: ++this.generation, aid: sender, event: item.name, size: item.size, filter };
         this.subscriptionBytes += item.size - (this.subscriptions.get(item.key)?.size ?? 0);
         this.subscriptions.set(item.key, sub);
         let view = this.subscriptionsByEvent.get(item.name);
@@ -343,14 +436,14 @@ export class EventService {
     } return { status: 'subscribed', events }; }
     removeSubscription(key, sub) { this.subscriptions.delete(key); this.subscriptionBytes -= sub.size; const view = this.subscriptionsByEvent.get(sub.event); view?.delete(key); if (!view?.size)
         this.subscriptionsByEvent.delete(sub.event); this.snapshots.delete(sub.event); }
-    async unsubscribe(sender, request) { const events = this.events(request); const lease = this.lease(sender, request.lease_id, events.map(event_name => ({ event_name, action: 'subscribe' }))); for (const name of events) {
+    async unsubscribe(sender, request) { const lease = this.lease(sender, request.lease_id), events = this.events(request, lease, true); for (const name of events) {
         const key = this.subscriptionKey(sender, name, lease.route), sub = this.subscriptions.get(key);
         if (sub?.leaseId === lease.lease_id)
             this.removeSubscription(key, sub);
     } return { status: 'unsubscribed', events }; }
     snapshot(event) { let snapshot = this.snapshots.get(event); if (!snapshot) {
-        const entries = [...(this.subscriptionsByEvent.get(event)?.entries() ?? [])].map(([key, sub]) => [sub.aid, { leaseId: sub.leaseId, generation: sub.generation, key }]);
-        snapshot = { entries, size: 64 + entries.reduce((sum, [target, sub]) => sum + new TextEncoder().encode(target + sub.leaseId + sub.key).byteLength + 128, 0) };
+        const entries = [...(this.subscriptionsByEvent.get(event)?.entries() ?? [])].map(([key, sub]) => [sub.aid, { leaseId: sub.leaseId, generation: sub.generation, key, filter: sub.filter }]);
+        snapshot = { entries, size: 64 + entries.reduce((sum, [target, sub]) => sum + new TextEncoder().encode(target + sub.leaseId + sub.key + json(sub.filter ?? {})).byteLength + 128, 0) };
         this.snapshots.set(event, snapshot);
     } return snapshot; }
     pruneSubscriptions() { for (const [key, sub] of this.subscriptions) {
@@ -443,6 +536,140 @@ export class EventService {
     } return true; }
     counter(name) { const c = this.counters.get(name) ?? {}; for (const k of ['published', 'matched', 'submitted', 'failed', 'unconfirmed', 'deduplicated', 'rejected', 'skipped_expired', 'skipped_overloaded', 'skipped_revoked'])
         c[k] ??= 0; this.counters.set(name, c); return c; }
+    async listingOp(sender, request, local) {
+        const generation = this.lifecycleGeneration, check = () => { if (generation !== this.lifecycleGeneration || this.closed || !this.running)
+            throw new PubSubError('SERVICE_CLOSED'); };
+        const action = request.op === 'publications' ? 'publish' : 'subscribe', lease = local ? undefined : this.lease(sender, request.lease_id);
+        let scope = local ? Object.keys(this.catalog).sort() : [...new Set(lease.scope.filter(item => item.action === action).map(item => item.event_name))].sort();
+        if (!local && !scope.length)
+            throw new PubSubError('FORBIDDEN');
+        const limit = request.limit ?? 50;
+        if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+            throw new PubSubError('INVALID_LIMIT');
+        let binding = digest([request.op, local, sender, lease?.lease_id ?? null, scope, request.event_name ?? null, this.since]), pageExpires = Infinity;
+        let last;
+        if (request.page_token !== undefined) {
+            try {
+                const envelope = JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(request.page_token), value => value.charCodeAt(0))));
+                if (envelope.signature !== digest([this.tokenKey, envelope.token]) || envelope.token.binding !== binding || envelope.token.expires_at <= this.clock() || !Array.isArray(envelope.token.last) || envelope.token.last.length !== (action === 'publish' ? 2 : 4) || envelope.token.last.some((value) => typeof value !== 'string'))
+                    throw new Error();
+                last = envelope.token.last;
+                pageExpires = envelope.token.expires_at;
+            }
+            catch {
+                throw new PubSubError('INVALID_PAGE_TOKEN');
+            }
+        }
+        if (action === 'subscribe') {
+            const checked = new Set();
+            for (const sub of this.subscriptions.values()) {
+                if ((!local && sub.leaseId !== lease.lease_id) || !scope.includes(sub.event) || request.event_name && sub.event !== request.event_name || checked.has(sub.leaseId))
+                    continue;
+                checked.add(sub.leaseId);
+                const current = this.leases.get(sub.leaseId);
+                if (!current)
+                    continue;
+                try {
+                    await this.refreshProof(this.lease(current.aid, current.lease_id), request.expires_at);
+                }
+                catch (error) {
+                    check();
+                    if (!(error instanceof PubSubError) || !['REAUTH_REQUIRED', 'FORBIDDEN'].includes(error.code))
+                        throw error;
+                }
+                check();
+            }
+            this.pruneSubscriptions();
+        }
+        check();
+        const currentLease = local ? undefined : this.lease(sender, request.lease_id);
+        scope = local ? Object.keys(this.catalog).sort() : [...new Set(currentLease.scope.filter(item => item.action === action).map(item => item.event_name))].sort();
+        if (!local && !scope.length)
+            throw new PubSubError('FORBIDDEN');
+        const currentBinding = digest([request.op, local, sender, currentLease?.lease_id ?? null, scope, request.event_name ?? null, this.since]);
+        if (request.page_token !== undefined && (binding !== currentBinding || pageExpires <= this.clock()))
+            throw new PubSubError('INVALID_PAGE_TOKEN');
+        binding = currentBinding;
+        const key = (item) => action === 'publish' ? [String(item.event_name), String(item.publisher_aid)] : [String(item.event_name), String(item.subscriber_aid), String(item.device_id), String(item.slot_id)];
+        const compare = (a, b) => { for (let i = 0; i < a.length; i++) {
+            const left = Array.from(a[i], value => value.codePointAt(0)), right = Array.from(b[i], value => value.codePointAt(0));
+            for (let j = 0; j < Math.min(left.length, right.length); j++)
+                if (left[j] !== right[j])
+                    return left[j] - right[j];
+            if (left.length !== right.length)
+                return left.length - right.length;
+        } return 0; };
+        const rows = action === 'publish' ? [...this.publicationSummaries.values()].filter(item => scope.includes(item.event_name) && (!request.event_name || item.event_name === request.event_name) && (local || item.publisher_aid === sender)).map(item => copy(item)) : [...this.subscriptions.values()].filter(sub => { const current = this.leases.get(sub.leaseId); return current && current.expires_at > this.clock() && (current.auth_mode !== 'credential' || current.authorization_until > this.clock()) && current.scope.some(item => item.event_name === sub.event && item.action === 'subscribe') && (local || sub.leaseId === currentLease.lease_id) && scope.includes(sub.event) && (!request.event_name || sub.event === request.event_name); }).map(sub => { const current = this.leases.get(sub.leaseId); return { subscriber_aid: sub.aid, event_name: sub.event, device_id: current.route?.device_id ?? '', slot_id: current.route?.slot_id ?? '', expires_at: current.expires_at }; });
+        const remaining = rows.sort((a, b) => compare(key(a), key(b))).filter(item => !last || compare(key(item), last) > 0), asOf = this.clock();
+        const result = (items) => {
+            const token = { binding, last: items.length ? key(items[items.length - 1]) : last, expires_at: Math.min(this.clock() + 60000, lease?.expires_at ?? Infinity) };
+            const next = items.length && items.length < remaining.length ? btoa(String.fromCharCode(...new TextEncoder().encode(JSON.stringify({ token, signature: digest([this.tokenKey, token]) })))) : null;
+            return { service_aid: this.service_aid, since: this.since, as_of: asOf, items, next_page_token: next };
+        };
+        const fits = (items) => new TextEncoder().encode(json({ type: 'app.pubsub.v1', op: `${request.op}.result`, service_aid: this.service_aid, request_id: request.request_id, expires_at: request.expires_at, ...(request.event_id ? { event_id: request.event_id } : {}), result: result(items) })).byteLength <= Math.min(this.limit('catalog_page_bytes', 65536), 65536);
+        const items = [];
+        for (const item of remaining.slice(0, limit)) {
+            if (!fits([...items, item])) {
+                if (!items.length)
+                    throw new PubSubError('MESSAGE_TOO_LARGE');
+                break;
+            }
+            items.push(item);
+        }
+        if (!fits(items))
+            throw new PubSubError('MESSAGE_TOO_LARGE');
+        return result(items);
+    }
+    waitPublisherProfile(lookup, deadline) {
+        return new Promise(resolve => { const timer = setTimeout(() => resolve(undefined), Math.max(0, deadline - this.clock())); lookup.then(profile => { clearTimeout(timer); resolve(profile); }, () => { clearTimeout(timer); resolve(undefined); }); });
+    }
+    publisherProfile(aid, deadline) {
+        const now = this.clock();
+        for (const [key, profile] of this.publisherProfiles)
+            if (profile.expiresAt <= now)
+                this.publisherProfiles.delete(key);
+        const cached = this.publisherProfiles.get(aid);
+        if (cached)
+            return Promise.resolve(cached);
+        if (deadline <= now)
+            return Promise.resolve(undefined);
+        const pending = this.publisherLookups.get(aid);
+        if (pending)
+            return this.waitPublisherProfile(pending, deadline);
+        if (!this.publisherResolver)
+            return Promise.resolve(undefined);
+        const generation = this.lifecycleGeneration;
+        const lookup = new Promise((resolve, reject) => { const timer = setTimeout(() => reject(new Error('publisher profile timeout')), 10000); Promise.resolve().then(() => this.publisherResolver(aid, 10000)).then(value => { clearTimeout(timer); resolve(value); }, error => { clearTimeout(timer); reject(error); }); }).then(value => {
+            const document = value;
+            if (generation !== this.lifecycleGeneration)
+                return undefined;
+            if (document?.verification?.status !== 'verified' || !document.frontmatter)
+                throw new Error('unverified publisher');
+            const profile = { ...(typeof document.frontmatter.type === 'string' ? { type: document.frontmatter.type } : {}), ...(typeof document.frontmatter.exttype === 'string' ? { exttype: document.frontmatter.exttype } : {}) };
+            if (this.publisherProfiles.size >= 1024)
+                this.publisherProfiles.delete(this.publisherProfiles.keys().next().value);
+            this.publisherProfiles.set(aid, { ...profile, expiresAt: this.clock() + 60000 });
+            return profile;
+        }).catch(() => { if (generation === this.lifecycleGeneration) {
+            if (this.publisherProfiles.size >= 1024)
+                this.publisherProfiles.delete(this.publisherProfiles.keys().next().value);
+            this.publisherProfiles.set(aid, { expiresAt: this.clock() + 5000 });
+        } return undefined; }).finally(() => { if (this.publisherLookups.get(aid) === lookup)
+            this.publisherLookups.delete(aid); });
+        this.publisherLookups.set(aid, lookup);
+        return this.waitPublisherProfile(lookup, deadline);
+    }
+    async publisherSnapshot(event, aid, deadline) {
+        const source = this.snapshot(event);
+        if (!source.entries.some(([, sub]) => Object.keys(sub.filter ?? {}).length))
+            return source;
+        const needsProfile = source.entries.some(([, sub]) => (sub.filter?.publisher_types || sub.filter?.publisher_exttypes) && (!sub.filter.publisher_aids || sub.filter.publisher_aids.some(pattern => matchPattern(pattern, aid)))), profile = needsProfile ? await this.publisherProfile(aid, deadline - 2000) : undefined;
+        const entries = this.snapshot(event).entries.filter(([, sub]) => {
+            const filter = sub.filter;
+            return (!filter?.publisher_aids || filter.publisher_aids.some(pattern => matchPattern(pattern, aid))) && (!filter?.publisher_types || typeof profile?.type === 'string' && filter.publisher_types.some(pattern => matchPattern(pattern, profile.type))) && (!filter?.publisher_exttypes || typeof profile?.exttype === 'string' && filter.publisher_exttypes.some(pattern => matchPattern(pattern, profile.exttype)));
+        });
+        return { entries, size: 64 + entries.reduce((sum, [target, sub]) => sum + new TextEncoder().encode(target + sub.leaseId + sub.key + json(sub.filter ?? {})).byteLength + 128, 0) };
+    }
     async publish(sender, request, reservation) {
         const event = request.event_name;
         if (!event || !this.catalog[event])
@@ -467,7 +694,24 @@ export class EventService {
             this.counter(event).deduplicated++;
             return copy(prior.result);
         }
-        const size = new TextEncoder().encode(json(payload)).byteLength + 128, queue = this.fanout.get(sender) ?? [], snapshotView = this.snapshot(event), snapshot = snapshotView.entries, snapshotSize = snapshotView.size;
+        const lifecycle = this.lifecycleGeneration, snapshotView = await this.publisherSnapshot(event, sender, deadline);
+        if (lifecycle !== this.lifecycleGeneration || !this.running)
+            throw new PubSubError('SERVICE_CLOSED');
+        this.lease(sender, request.lease_id, [{ event_name: event, action: 'publish' }]);
+        if (deadline - this.clock() < 1000)
+            throw new PubSubError('EXPIRED');
+        const duplicate = this.published.get(key);
+        if (duplicate) {
+            if (duplicate.fingerprint !== fingerprint)
+                throw new PubSubError('EVENT_CONFLICT');
+            this.counter(event).deduplicated++;
+            return copy(duplicate.result);
+        }
+        const summaryKey = json([sender, event]), previous = this.publicationSummaries.get(summaryKey), summary = { publisher_aid: sender, event_name: event, published: (previous?.published ?? 0) + 1, first_published_at: previous?.first_published_at ?? now, last_published_at: now };
+        const summaryBytes = new TextEncoder().encode(json(summary)).byteLength, previousBytes = previous ? new TextEncoder().encode(json(previous)).byteLength : 0;
+        if (!previous && this.publicationSummaries.size >= this.limit('publication_items', 8192) || this.publicationBytes + summaryBytes - previousBytes > this.limit('publication_bytes', 4 * 1024 * 1024))
+            throw new PubSubError('OVERLOADED');
+        const size = new TextEncoder().encode(json(payload)).byteLength + 128, queue = this.fanout.get(sender) ?? [], snapshot = snapshotView.entries, snapshotSize = snapshotView.size;
         if (size - 128 > this.limit('event_bytes', 65536) || !this.publishCapacityAvailable(size, reservation?.bytes ?? 0) || queue.length >= this.limit('accepted_per_aid', 128) || this.published.size >= this.limit('dedup_items', 8192) || (!this.snapshotRefs.has(snapshot) && (this.snapshotRefs.size >= this.limit('snapshot_items', 256) || this.snapshotBytes + snapshotSize > this.limit('snapshot_bytes', 8 * 1024 * 1024))))
             throw new PubSubError('OVERLOADED');
         const pin = this.snapshotRefs.get(snapshot);
@@ -492,6 +736,8 @@ export class EventService {
         this.published.set(key, { fingerprint, result, expiresAt: deadline });
         this.counter(event).published++;
         this.capacityChanged();
+        this.publicationSummaries.set(summaryKey, summary);
+        this.publicationBytes += summaryBytes - previousBytes;
         if (!this.fanoutTask)
             this.fanoutTask = new Promise(resolve => setTimeout(resolve, 0)).then(() => this.runFanout()).finally(() => { this.fanoutTask = undefined; });
         return result;