@agentunion/fastaun 0.5.31 → 0.5.33

package/dist/pubsub/service.js

@@ -0,0 +1,650 @@
+import { PubSubError } from './errors.js';
+import { FairScheduler } from './scheduler.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')
+    return JSON.stringify(v); if (Array.isArray(v))
+    return `[${v.map(json).join(',')}]`; return `{${Object.keys(v).sort().map(key => `${JSON.stringify(key)}:${json(v[key])}`).join(',')}}`; };
+const uuid = () => crypto.randomUUID();
+const routeKey = (route) => route ? json([route.device_id, route.slot_id]) : '';
+export class EventService {
+    service_aid;
+    catalog;
+    allowlist;
+    send;
+    credentials;
+    clock;
+    limits;
+    state;
+    deliveryLeases = new Map();
+    lifecycleGeneration = 0;
+    generation = 0;
+    issuedGrants = new Map();
+    pausedCids = new Set();
+    tokenKey = uuid();
+    stateWrite = Promise.resolve();
+    leases = new Map();
+    leaseSizes = new Map();
+    leaseBytes = 0;
+    nextLeaseExpiry = Infinity;
+    subscriptions = new Map();
+    subscriptionBytes = 0;
+    subscriptionsByEvent = new Map();
+    requests = new Map();
+    published = new Map();
+    counters = new Map();
+    scheduler;
+    snapshots = new Map();
+    snapshotRefs = new Map();
+    snapshotBytes = 0;
+    fanout = new Map();
+    fanoutReady = [];
+    fanoutCount = 0;
+    fanoutBytes = 0;
+    fanoutTask;
+    capacityListeners = new Set();
+    fanoutWaiters = new Set();
+    capacityVersion = 0;
+    ingressBodyBytes = 0;
+    publishCapacityAvailable(size = 0, reservedBytes = 0) { return this.running && this.fanoutCount < Math.min(this.limit('accepted_items', 64), 64) && this.fanoutBytes + size <= Math.min(this.limit('accepted_bytes', 8 * 1024 * 1024), 64 * 1024 * 1024) && (this.credentials?.retainedBodyBytes?.() ?? 0) + this.ingressBodyBytes - reservedBytes + this.fanoutBytes + (this.scheduler?.retainedBytes() ?? 0) + size <= Math.min(this.limit('body_bytes', 64 * 1024 * 1024), 64 * 1024 * 1024); }
+    reserveIngressBody(size) { if ((this.credentials?.retainedBodyBytes?.() ?? 0) + this.ingressBodyBytes + this.fanoutBytes + (this.scheduler?.retainedBytes() ?? 0) + size > Math.min(this.limit('body_bytes', 64 * 1024 * 1024), 64 * 1024 * 1024))
+        return false; this.ingressBodyBytes += size; return true; }
+    releaseIngressBody(size) { this.ingressBodyBytes -= size; this.capacityChanged(); }
+    onPublishCapacity(listener) { this.capacityListeners.add(listener); return () => { this.capacityListeners.delete(listener); }; }
+    capacityChanged() { this.capacityVersion++; for (const wake of this.fanoutWaiters)
+        wake(); for (const listener of this.capacityListeners)
+        listener(); }
+    async waitFanoutCapacity(version, deadline) {
+        if (!this.running || version !== this.capacityVersion)
+            return;
+        await new Promise(resolve => { const wake = () => { clearTimeout(timer); this.fanoutWaiters.delete(wake); resolve(); }; const timer = setTimeout(wake, Math.max(0, deadline - this.clock() - 999)); this.fanoutWaiters.add(wake); });
+    }
+    starting;
+    running = false;
+    revision = '';
+    since;
+    closed = false;
+    constructor(serviceAid, catalog, allowlist, options) {
+        this.service_aid = serviceAid;
+        this.catalog = copy(catalog);
+        this.allowlist = copy(allowlist);
+        this.send = options.send;
+        this.credentials = options.credentials;
+        this.clock = options.clock ?? (() => Date.now());
+        this.limits = options.limits ?? {};
+        this.state = options.state;
+        this.since = this.clock();
+        this.credentials?.setBodyBudget?.(delta => (this.credentials?.retainedBodyBytes?.() ?? 0) + this.ingressBodyBytes + this.fanoutBytes + (this.scheduler?.retainedBytes() ?? 0) + delta <= Math.min(this.limit('body_bytes', 64 * 1024 * 1024), 64 * 1024 * 1024));
+        this.refreshRevision();
+    }
+    async start() { if (this.starting)
+        return this.starting; if (this.running)
+        return this; this.starting = this.initialize().finally(() => { this.starting = undefined; }); return this.starting; }
+    async initialize() {
+        const saved = await this.state?.load?.();
+        if (saved && saved.service_aid === this.service_aid) {
+            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?.();
+        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.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; }
+    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; }
+    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.refreshRevision();
+    } if (config.allowlist)
+        this.allowlist = copy(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);
+    } this.leaseBytes = 0; for (const [id, lease] of this.leases) {
+        const size = this.leaseSize(lease);
+        this.leaseSizes.set(id, size);
+        this.leaseBytes += size;
+    } this.pruneSubscriptions(); await this.saveState(); }
+    async handle(senderAid, request, reservation, route) {
+        try {
+            return await this.handleRequest(senderAid, request, reservation, route);
+        }
+        catch (error) {
+            if (request.op === 'publish' && request.event_name && this.catalog[request.event_name])
+                this.counter(request.event_name).rejected++;
+            throw error;
+        }
+    }
+    async _handleLocal(request) { if (!this.running)
+        throw new PubSubError('SERVICE_CLOSED'); return this.handleRequest(this.service_aid, request, undefined, undefined, true); }
+    async handleRequest(senderAid, request, reservation, route, local = false) {
+        if (this.closed)
+            throw new PubSubError('SERVICE_CLOSED');
+        this.validateRequest(senderAid, request);
+        const op = request.op;
+        this.cleanup(op !== 'publish');
+        const generation = this.lifecycleGeneration;
+        if (!local && ['issue_grant', 'revoke_grant', 'stats'].includes(op))
+            throw new PubSubError('FORBIDDEN');
+        if (route && (typeof route.device_id !== 'string' || !route.device_id || typeof route.slot_id !== 'string' || !route.slot_id))
+            throw new PubSubError('INVALID_REQUEST');
+        if (request.lease_id) {
+            const bound = this.leases.get(request.lease_id);
+            if (bound && routeKey(bound.route) !== routeKey(route))
+                throw new PubSubError('REAUTH_REQUIRED');
+        }
+        if (request.lease_id && op !== 'renew')
+            await this.refreshProof(this.lease(senderAid, request.lease_id), request.expires_at);
+        if (request.lease_id && op !== 'renew')
+            this.lease(senderAid, request.lease_id);
+        if (generation !== this.lifecycleGeneration || this.closed)
+            throw new PubSubError('SERVICE_CLOSED');
+        if (op === 'publish')
+            return this.publish(senderAid, request, reservation);
+        if (op === 'catalog')
+            return this.catalogOp(senderAid, request, undefined, undefined, local);
+        if (op === 'stats')
+            return this.statsOp(senderAid, request);
+        const id = request.request_id;
+        if (!id)
+            throw new PubSubError('INVALID_REQUEST');
+        const key = `${senderAid}:${routeKey(route)}:${id}`;
+        const fp = json(request);
+        const old = this.requests.get(key);
+        if (old) {
+            if (old.fingerprint !== fp)
+                throw new PubSubError('REQUEST_CONFLICT');
+            if (old.promise)
+                return old.promise;
+            return copy(old.result);
+        }
+        if (this.requests.size >= this.limit('request_items', 4096))
+            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));
+        entry.promise = promise;
+        try {
+            const result = await promise;
+            entry.result = copy(result);
+            delete entry.promise;
+            return result;
+        }
+        catch (e) {
+            if (this.requests.get(key) === entry)
+                this.requests.delete(key);
+            throw e;
+        }
+    }
+    limit(name, fallback) { return Number(this.limits[name] ?? fallback); }
+    cleanup(includeLeases) { const now = this.clock(); for (const [key, record] of this.requests)
+        if (record.expiresAt <= now && !record.promise)
+            this.requests.delete(key); for (const [key, record] of this.published)
+        if (record.expiresAt <= now)
+            this.published.delete(key); if (includeLeases && this.nextLeaseExpiry <= now) {
+        this.nextLeaseExpiry = Infinity;
+        for (const [key, lease] of this.leases) {
+            if (lease.expires_at <= now)
+                this.removeLease(key);
+            else
+                this.nextLeaseExpiry = Math.min(this.nextLeaseExpiry, lease.expires_at);
+        }
+        this.pruneSubscriptions();
+    } }
+    leaseSize(lease) { return new TextEncoder().encode(json(lease)).byteLength + 128; }
+    removeLease(id) { const lease = this.leases.get(id); if (lease) {
+        this.leaseBytes -= this.leaseSizes.get(id) ?? 0;
+        this.leaseSizes.delete(id);
+        this.leases.delete(id);
+    } }
+    async dispatch(sender, request, route) { switch (request.op) {
+        case 'authorize': return this.authorize(sender, request, route);
+        case 'renew': return this.renew(sender, request);
+        case 'subscribe': return this.subscribe(sender, request);
+        case 'unsubscribe': return this.unsubscribe(sender, request);
+        case 'issue_grant': return this.issueGrant(sender, request);
+        case 'revoke_grant': return this.revokeGrant(sender, request);
+        default: throw new PubSubError('INVALID_OPERATION');
+    } }
+    validateCatalog(catalog) { for (const [name, item] of Object.entries(catalog)) {
+        const d = item.default_ttl_seconds ?? 30, m = item.max_ttl_seconds ?? 3600;
+        if (!name || !Number.isInteger(d) || !Number.isInteger(m) || d < 1 || d > m || m > 3600 || new TextEncoder().encode(json({ event_name: name, ...item, allowed_actions: ['publish', 'subscribe'] })).byteLength > this.limit('catalog_item_bytes', 49152))
+            throw new PubSubError('INVALID_CATALOG');
+    } }
+    refreshRevision() { this.revision = digest(this.catalog); }
+    validateRequest(sender, request) { const now = this.clock(); if (!sender || request.type !== 'app.pubsub.v1' || (request.service_aid && request.service_aid !== this.service_aid))
+        throw new PubSubError('INVALID_REQUEST'); if ((request.expires_at ?? now + 60000) <= now || (request.issued_at ?? now) > now + 30000)
+        throw new PubSubError('EXPIRED'); }
+    scope(request) { const items = request.scope ?? (request.events ?? []).flatMap(event => (request.actions ?? []).map((action) => ({ event_name: event, action }))); if (!Array.isArray(items) || !items.length)
+        throw new PubSubError('INVALID_SCOPE'); return items.map(item => { if (!item || typeof item.event_name !== 'string' || !['publish', 'subscribe'].includes(item.action))
+        throw new PubSubError('INVALID_SCOPE'); if (!this.catalog[item.event_name])
+        throw new PubSubError('UNKNOWN_EVENT'); return { event_name: item.event_name, action: item.action }; }).filter((item, index, all) => all.findIndex(other => other.event_name === item.event_name && other.action === item.action) === index); }
+    allowlisted(aid, item) { const entries = [this.allowlist[item.event_name], this.allowlist['*']]; return entries.some(entry => { const list = item.action === 'publish' ? entry?.publish_aids : entry?.subscribe_aids; return !!list?.some(value => value === '*' || value === aid); }); }
+    leaseResult(lease) { return { lease_id: lease.lease_id, aid: lease.aid, scope: copy(lease.scope), auth_mode: lease.auth_mode, expires_at: lease.expires_at, authorization_until: lease.authorization_until, renew_interval_seconds: 3600, renew_after_seconds: 3600, ...(lease.cid ? { cid: lease.cid } : {}) }; }
+    async authorize(sender, request, route) {
+        const generation = this.lifecycleGeneration, scope = this.scope(request);
+        const mode = request.auth_mode ?? 'allowlist';
+        let expires = this.clock() + 12_000_000;
+        let cid;
+        let proofExpires = expires;
+        if (mode === 'allowlist') {
+            if (scope.some(item => !this.allowlisted(sender, item)))
+                throw new PubSubError('FORBIDDEN');
+        }
+        else if (mode === 'credential') {
+            const grant = request.grant ?? request.credential;
+            if (!this.credentials || !grant)
+                throw new PubSubError('CREDENTIAL_UNAVAILABLE');
+            const verified = await this.credentials.verify(grant, sender, scope, request, request.expires_at);
+            expires = Math.min(expires, Number(verified.expires_at ?? expires));
+            cid = String(verified.cid ?? grant.cid ?? '');
+            if (this.pausedCids.has(cid) || this.credentials.isRevoked?.(grant))
+                throw new PubSubError('REAUTH_REQUIRED');
+            proofExpires = Number(verified.proof_expires_at ?? expires);
+        }
+        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 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');
+        const result = this.leaseResult(lease);
+        result.catalog = this.catalogOp(sender, { ...request, event_name: undefined, limit: undefined, page_token: undefined }, lease, result);
+        this.leases.set(lease.lease_id, lease);
+        this.leaseSizes.set(lease.lease_id, size);
+        this.leaseBytes += size;
+        this.nextLeaseExpiry = Math.min(this.nextLeaseExpiry, expires);
+        return result;
+    }
+    lease(sender, id, needed = []) { if (typeof id !== 'string')
+        throw new PubSubError('REAUTH_REQUIRED'); const lease = this.leases.get(id); const now = this.clock(); if (!lease || lease.aid !== sender || lease.expires_at <= now || !lease.scope.length || (lease.cid && (this.pausedCids.has(lease.cid) || this.credentials?.isRevoked?.(lease.grant ?? lease.cid))) || needed.some(item => !lease.scope.some(x => x.event_name === item.event_name && x.action === item.action)))
+        throw new PubSubError('REAUTH_REQUIRED'); if (lease.auth_mode === 'allowlist' && (needed.length ? needed : lease.scope).some(item => !this.allowlisted(sender, item)))
+        throw new PubSubError('FORBIDDEN'); return lease; }
+    async refreshProof(lease, deadline) {
+        if (lease.auth_mode !== 'credential')
+            return;
+        try {
+            await this.credentials?.assertNotRevoked?.(lease.grant ?? lease.cid, deadline);
+            if (lease.authorization_until > this.clock()) {
+                if (lease.grant)
+                    await this.credentials?.checkVerified?.(lease.grant, lease.aid, lease.scope);
+                return;
+            }
+            if (!this.credentials || !lease.grant)
+                throw new PubSubError('REAUTH_REQUIRED');
+            const verified = await this.credentials.verify(lease.grant, lease.aid, lease.scope, undefined, deadline);
+            if (this.leases.get(lease.lease_id) !== lease || lease.cid && (this.pausedCids.has(lease.cid) || this.credentials.isRevoked?.(lease.grant ?? lease.cid)))
+                throw new PubSubError('REAUTH_REQUIRED');
+            lease.expires_at = Math.min(lease.expires_at, Number(verified.expires_at));
+            lease.authorization_until = Math.min(lease.expires_at, Number(verified.proof_expires_at ?? this.clock()));
+            if (lease.authorization_until <= this.clock())
+                throw new PubSubError('REAUTH_REQUIRED');
+        }
+        catch (error) {
+            if (error instanceof PubSubError && error.code === 'TIMEOUT')
+                throw error;
+            this.removeLease(lease.lease_id);
+            this.pruneSubscriptions();
+            throw new PubSubError('REAUTH_REQUIRED');
+        }
+    }
+    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') {
+        grant = request.grant ?? old.grant;
+        if (!this.credentials || !grant)
+            throw new PubSubError('REAUTH_REQUIRED');
+        await this.credentials.assertNotRevoked?.(grant, request.expires_at);
+        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);
+        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('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)]; }
+    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))
+        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 };
+        this.subscriptionBytes += item.size - (this.subscriptions.get(item.key)?.size ?? 0);
+        this.subscriptions.set(item.key, sub);
+        let view = this.subscriptionsByEvent.get(item.name);
+        if (!view)
+            this.subscriptionsByEvent.set(item.name, view = new Map());
+        view.set(item.key, sub);
+        this.snapshots.delete(item.name);
+    } 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) {
+        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) };
+        this.snapshots.set(event, snapshot);
+    } return snapshot; }
+    pruneSubscriptions() { for (const [key, sub] of this.subscriptions) {
+        const aid = sub.aid, event = sub.event;
+        const lease = this.leases.get(sub.leaseId);
+        if (!lease || lease.expires_at <= this.clock() || (lease.cid && (this.pausedCids.has(lease.cid) || this.credentials?.isRevoked?.(lease.grant ?? lease.cid))) || !lease.scope.some(x => x.event_name === event && x.action === 'subscribe') || (lease.auth_mode === 'allowlist' && !this.allowlisted(aid, { event_name: event, action: 'subscribe' })))
+            this.removeSubscription(key, sub);
+    } }
+    async issueGrant(sender, request) { if (!this.credentials || !request.subject_aid)
+        throw new PubSubError('CREDENTIAL_UNAVAILABLE'); const scope = this.scope(request); const expires = Number(request.grant_expires_at ?? request.expires_at); if (!Number.isInteger(expires) || expires <= this.clock())
+        throw new PubSubError('INVALID_REQUEST'); const operation = digest([sender, request.request_id]), fingerprint = json([request.subject_aid, scope, expires]); const prior = [...this.issuedGrants.values()].find(grant => grant.operation === operation); if (prior) {
+        if (prior.fingerprint !== fingerprint)
+            throw new PubSubError('REQUEST_CONFLICT');
+        return copy(prior.result);
+    } const result = await this.credentials.issue(request.subject_aid, scope, expires, operation); if (typeof result.cid !== 'string')
+        throw new PubSubError('CREDENTIAL_UNAVAILABLE'); this.issuedGrants.set(result.cid, { scope, operation, fingerprint, result: copy(result) }); await this.saveState(); return result; }
+    async revokeGrant(sender, request) { if (!this.credentials?.revoke || typeof request.cid !== 'string')
+        throw new PubSubError('CREDENTIAL_UNAVAILABLE'); const scope = this.issuedGrants.get(request.cid)?.scope ?? await this.credentials.getIssuedScope?.(request.cid); if (!scope)
+        throw new PubSubError('FORBIDDEN'); this.pausedCids.add(request.cid); for (const [id, lease] of this.leases)
+        if (lease.cid === request.cid)
+            this.removeLease(id); this.pruneSubscriptions(); await this.saveState(); const result = await this.credentials.revoke(request.cid, digest([sender, request.request_id])); await this.saveState(); return result; }
+    visible(sender, request) { const lease = this.lease(sender, request.lease_id); return [...new Set(lease.scope.map(x => x.event_name))]; }
+    catalogOp(sender, request, leaseView, authorizeResult, local = false) {
+        let token;
+        if (request.page_token) {
+            try {
+                const envelope = JSON.parse(atob(request.page_token));
+                if (envelope.signature !== digest([this.tokenKey, envelope.token]))
+                    throw new Error();
+                token = envelope.token;
+                if (token.aid !== sender || token.event !== digest(request.event_name ?? null) || token.expires_at <= this.clock() || !Number.isInteger(token.offset) || token.offset < 0 || token.lease_id !== undefined && (typeof token.lease_id !== 'string' || token.lease_id !== request.lease_id))
+                    throw new Error();
+            }
+            catch {
+                throw new PubSubError('INVALID_PAGE_TOKEN');
+            }
+            if (token.revision !== this.revision)
+                throw new PubSubError('CATALOG_CHANGED');
+            if (token.lease_id !== undefined)
+                leaseView = this.lease(sender, token.lease_id);
+        }
+        const visible = leaseView ? [...new Set(leaseView.scope.map(item => item.event_name))] : local ? Object.keys(this.catalog) : this.visible(sender, request);
+        if (request.event_name && !visible.includes(request.event_name))
+            throw new PubSubError('FORBIDDEN');
+        const names = visible.filter(name => !!this.catalog[name] && (!request.event_name || name === request.event_name)).sort();
+        const limit = request.limit ?? 50;
+        if (!Number.isInteger(limit) || limit < 1 || limit > 200)
+            throw new PubSubError('INVALID_LIMIT');
+        const actions = Object.fromEntries(names.map(name => [name, !leaseView && local ? ['publish', 'subscribe'] : (leaseView ?? this.lease(sender, request.lease_id)).scope.filter(x => x.event_name === name).map(x => x.action).sort()]));
+        const binding = digest(actions), offset = token?.offset ?? 0;
+        if (token && (token.scope !== binding || offset > names.length))
+            throw new PubSubError('INVALID_PAGE_TOKEN');
+        const result = (items) => { const token = { aid: sender, scope: binding, event: digest(request.event_name ?? null), revision: this.revision, offset: offset + items.length, expires_at: Math.min(this.clock() + 60_000, leaseView?.expires_at ?? Infinity), ...(leaseView ? { lease_id: leaseView.lease_id } : {}) }; const next = offset + items.length < names.length ? btoa(JSON.stringify({ token, signature: digest([this.tokenKey, token]) })) : undefined; return { service_aid: this.service_aid, catalog_revision: this.revision, revision: this.revision, items, ...(next ? { next_page_token: next } : {}) }; };
+        const fits = (items) => { const page = result(items); return (!authorizeResult || new TextEncoder().encode(json(page)).byteLength <= 2048) && 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: authorizeResult ? { ...authorizeResult, catalog: page } : page })).byteLength <= Math.min(this.limit('catalog_page_bytes', 65536), 65536); };
+        const items = [];
+        for (const name of names.slice(offset, offset + limit)) {
+            const item = { event_name: name, ...copy(this.catalog[name]), allowed_actions: actions[name] };
+            if (!fits([...items, item])) {
+                if (!items.length && !authorizeResult)
+                    throw new PubSubError('OVERLOADED');
+                break;
+            }
+            items.push(item);
+        }
+        if (!fits(items))
+            throw new PubSubError('OVERLOADED');
+        return result(items);
+    }
+    validateContent(data, schema) { if (!schema || typeof schema !== 'object')
+        throw new PubSubError('INVALID_SCHEMA'); if (schema.type) {
+        const ok = schema.type === 'string' ? typeof data === 'string' : schema.type === 'number' ? typeof data === 'number' && !Number.isNaN(data) : schema.type === 'integer' ? Number.isInteger(data) : schema.type === 'boolean' ? typeof data === 'boolean' : schema.type === 'object' ? !!data && typeof data === 'object' && !Array.isArray(data) : schema.type === 'array' ? Array.isArray(data) : false;
+        if (!ok)
+            throw new PubSubError('INVALID_CONTENT');
+        if (schema.type === 'object')
+            for (const key of schema.required ?? [])
+                if (!(key in data))
+                    throw new PubSubError('INVALID_CONTENT');
+        if (schema.type === 'object')
+            for (const [key, child] of Object.entries(schema.properties ?? {}))
+                if (key in data)
+                    this.validateContent(data[key], child);
+        if (schema.type === 'array' && schema.items)
+            for (const item of data)
+                this.validateContent(item, schema.items);
+        return true;
+    } for (const [key, value] of Object.entries(schema)) {
+        if (!data || typeof data !== 'object' || Array.isArray(data) || !(key in data))
+            throw new PubSubError('INVALID_CONTENT');
+        this.validateContent(data[key], typeof value === 'string' ? { type: value } : value);
+    } 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 publish(sender, request, reservation) {
+        const event = request.event_name;
+        if (!event || !this.catalog[event])
+            throw new PubSubError('UNKNOWN_EVENT');
+        const lease = this.lease(sender, request.lease_id, [{ event_name: event, action: 'publish' }]);
+        const entry = this.catalog[event];
+        if (request.schema_version !== (entry.schema_version ?? 1))
+            throw new PubSubError('UNSUPPORTED_SCHEMA_VERSION');
+        if (!request.data || typeof request.data !== 'object' || Array.isArray(request.data))
+            throw new PubSubError('INVALID_CONTENT');
+        this.validateContent(request.data, entry.content_schema ?? {});
+        const now = this.clock(), deadline = request.expires_at;
+        if (!Number.isInteger(deadline) || deadline - now < 1000 || deadline - now > (entry.max_ttl_seconds ?? 3600) * 1000)
+            throw new PubSubError('INVALID_TTL');
+        if (!request.event_id || !['none', 'accepted'].includes(request.reply_mode ?? 'none'))
+            throw new PubSubError('INVALID_REQUEST');
+        const payload = { type: 'app.pubsub.v1', op: 'event', event_id: request.event_id, event_name: event, publisher_aid: sender, schema_version: request.schema_version, expires_at: deadline, data: reservation ? request.data : copy(request.data) };
+        const key = `${sender}:${request.event_id}`, fingerprint = digest(payload), prior = this.published.get(key);
+        if (prior) {
+            if (prior.fingerprint !== fingerprint)
+                throw new PubSubError('EVENT_CONFLICT');
+            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;
+        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);
+        if (pin)
+            pin.refs++;
+        else {
+            this.snapshotRefs.set(snapshot, { refs: 1, size: snapshotSize });
+            this.snapshotBytes += snapshotSize;
+        }
+        if (reservation) {
+            this.ingressBodyBytes -= reservation.bytes;
+            reservation.bytes = 0;
+        }
+        const result = { status: 'accepted', event_id: request.event_id };
+        if (!this.fanout.has(sender)) {
+            this.fanout.set(sender, queue);
+            this.fanoutReady.push(sender);
+        }
+        queue.push({ publisher: sender, payload, publisherLease: lease.lease_id, snapshot, size, cursor: 0 });
+        this.fanoutCount++;
+        this.fanoutBytes += size;
+        this.published.set(key, { fingerprint, result, expiresAt: deadline });
+        this.counter(event).published++;
+        this.capacityChanged();
+        if (!this.fanoutTask)
+            this.fanoutTask = new Promise(resolve => setTimeout(resolve, 0)).then(() => this.runFanout()).finally(() => { this.fanoutTask = undefined; });
+        return result;
+    }
+    async runFanout() {
+        let stalled = 0, blockedDeadline = Infinity;
+        while (this.running && this.fanoutReady.length) {
+            const version = this.capacityVersion;
+            let blocked = false;
+            const publisher = this.fanoutReady.shift(), queue = this.fanout.get(publisher), work = queue[0], event = String(work.payload.event_name);
+            const stop = Math.min(work.snapshot.length, work.cursor + Math.max(1, this.limit('fanout_batch', 32)));
+            while (this.running && work.cursor < stop) {
+                const [target, sub] = work.snapshot[work.cursor], lease = this.leases.get(sub.leaseId), current = this.subscriptions.get(sub.key);
+                const counter = this.counter(event);
+                if (!lease || lease.expires_at <= this.clock() || current?.leaseId !== sub.leaseId || current.generation !== sub.generation) {
+                    counter.matched++;
+                    counter.skipped_revoked++;
+                    work.cursor++;
+                    continue;
+                }
+                const deadline = Math.min(Number(work.payload.expires_at), lease.expires_at), payload = { ...work.payload, expires_at: deadline };
+                if (deadline - this.clock() < 1000) {
+                    counter.matched++;
+                    counter.skipped_expired++;
+                    work.cursor++;
+                    continue;
+                }
+                if (this.scheduler?.capacityReason(target, publisher, payload) === 'global' || (this.credentials?.retainedBodyBytes?.() ?? 0) + this.ingressBodyBytes + this.fanoutBytes + (this.scheduler?.retainedBytes() ?? 0) + new TextEncoder().encode(JSON.stringify(payload)).byteLength + (this.limits.cost_overhead ?? 128) > Math.min(this.limit('body_bytes', 64 * 1024 * 1024), 64 * 1024 * 1024)) {
+                    blocked = true;
+                    blockedDeadline = Math.min(blockedDeadline, deadline);
+                    break;
+                }
+                const messageId = `${this.service_aid}:${publisher}:${work.payload.event_id}:${target}${lease.route ? `:${digest(routeKey(lease.route))}` : ''}`;
+                counter.matched++;
+                this.deliveryLeases.set(messageId, { subscriber: sub.leaseId, publisher: work.publisherLease, generation: sub.generation, key: sub.key });
+                if (!this.scheduler?.offer(target, publisher, event, payload, deadline, messageId)) {
+                    this.deliveryLeases.delete(messageId);
+                    counter.skipped_overloaded++;
+                }
+                work.cursor++;
+            }
+            if (work.cursor === work.snapshot.length) {
+                queue.shift();
+                this.fanoutCount--;
+                this.fanoutBytes -= work.size;
+                const pin = this.snapshotRefs.get(work.snapshot);
+                if (!--pin.refs) {
+                    this.snapshotRefs.delete(work.snapshot);
+                    this.snapshotBytes -= pin.size;
+                }
+                this.capacityChanged();
+            }
+            if (queue.length)
+                this.fanoutReady.push(publisher);
+            else
+                this.fanout.delete(publisher);
+            stalled = blocked ? stalled + 1 : 0;
+            if (stalled && stalled >= this.fanoutReady.length) {
+                const deadline = Math.min(blockedDeadline, ...this.fanoutReady.map(aid => Number(this.fanout.get(aid)[0].payload.expires_at)));
+                await this.waitFanoutCapacity(version, deadline);
+                stalled = 0;
+                blockedDeadline = Infinity;
+            }
+            else
+                await new Promise(resolve => setTimeout(resolve, 0));
+        }
+    }
+    async deliver(task) {
+        const leases = this.deliveryLeases.get(task.message_id), counter = this.counter(task.event_name);
+        let unknown = false;
+        let deadline = task.deadline;
+        try {
+            for (let attempt = 0; attempt < this.limit('send_attempts', 2); attempt++) {
+                if (!this.running)
+                    return;
+                let subscriber;
+                try {
+                    const current = this.subscriptions.get(leases?.key ?? '');
+                    if (!leases || current?.leaseId !== leases.subscriber || current.generation !== leases.generation)
+                        throw new PubSubError('REAUTH_REQUIRED');
+                    await this.refreshProof(this.lease(task.publisher, leases.publisher, [{ event_name: task.event_name, action: 'publish' }]), deadline);
+                    subscriber = this.lease(task.target, leases.subscriber, [{ event_name: task.event_name, action: 'subscribe' }]);
+                    await this.refreshProof(subscriber, deadline);
+                    this.lease(task.publisher, leases.publisher);
+                    this.lease(task.target, leases.subscriber);
+                    const checked = this.subscriptions.get(leases?.key ?? '');
+                    if (checked?.leaseId !== leases.subscriber || checked.generation !== leases.generation)
+                        throw new PubSubError('REAUTH_REQUIRED');
+                }
+                catch {
+                    if (!unknown) {
+                        if (deadline <= this.clock())
+                            counter.skipped_expired++;
+                        else
+                            counter.skipped_revoked++;
+                    }
+                    return;
+                }
+                deadline = Math.min(deadline, subscriber.expires_at);
+                const ttl = Math.floor((deadline - this.clock()) / 1000);
+                if (ttl < 1) {
+                    if (!unknown)
+                        counter.skipped_expired++;
+                    return;
+                }
+                const sendDeadline = Math.min(deadline, this.clock() + this.limit('send_timeout_seconds', 10) * 1000);
+                try {
+                    const result = await this.send(task.target, { ...task.payload, expires_at: deadline }, ttl, task.message_id, true, sendDeadline, subscriber.route);
+                    if (result?.storage && result.storage !== 'volatile')
+                        throw new Error('unexpected message storage');
+                    if (unknown)
+                        counter.unconfirmed--;
+                    counter.submitted++;
+                    return;
+                }
+                catch (error) {
+                    const e = error;
+                    const code = String(e?.stringCode || e?.code || e?.name || '');
+                    if ((['TIMEOUT', 'CONNECTION_ERROR', 'AUNTimeoutError', 'AUNConnectionError', 'TimeoutError', 'ConnectionError'].includes(code) || ['TimeoutError', 'ConnectionError'].includes(e?.name)) || /timeout|connection/i.test(String(e?.message ?? ''))) {
+                        if (!unknown) {
+                            counter.unconfirmed++;
+                            unknown = true;
+                        }
+                        continue;
+                    }
+                    if (unknown)
+                        counter.unconfirmed--;
+                    counter.failed++;
+                    return;
+                }
+            }
+        }
+        finally {
+            this.deliveryLeases.delete(task.message_id);
+        }
+    }
+    async statsOp(sender, request) {
+        for (const lease of this.leases.values()) {
+            try {
+                await this.refreshProof(this.lease(lease.aid, lease.lease_id), request.expires_at);
+            }
+            catch { }
+        }
+        this.pruneSubscriptions();
+        const allowed = Object.keys(this.catalog);
+        if (request.event_name && !allowed.includes(request.event_name))
+            throw new PubSubError('FORBIDDEN');
+        const names = request.event_name ? [request.event_name] : allowed, scope = new Set(names);
+        const counts = {};
+        for (const key of ['published', 'matched', 'submitted', 'failed', 'unconfirmed', 'deduplicated', 'rejected', 'skipped_expired', 'skipped_overloaded', 'skipped_revoked'])
+            counts[key] = names.reduce((n, name) => n + (this.counter(name)[key] ?? 0), 0);
+        const subscriptions = [...this.subscriptions.values()].filter(sub => scope.has(sub.event)), leases = [...this.leases.values()].filter(lease => lease.expires_at > this.clock() && (!lease.cid || !this.pausedCids.has(lease.cid) && !this.credentials?.isRevoked?.(lease.grant ?? lease.cid)) && lease.scope.some(item => scope.has(item.event_name))), fanout = [...this.fanout.values()].flat().filter(work => scope.has(String(work.payload.event_name))), queued = this.scheduler?.queuedCounts(scope);
+        return { service_aid: this.service_aid, scope: names.sort(), since: this.since, as_of: this.clock(), counts: { ...counts, active_publishers: new Set(leases.filter(lease => lease.scope.some(item => item.action === 'publish' && scope.has(item.event_name))).map(lease => lease.aid)).size, active_subscribers: new Set(subscriptions.map(sub => sub.aid)).size, active_subscriptions: subscriptions.length, active_leases: leases.length, ...(queued ?? {}), queued_events: fanout.length, queued_bytes: (queued?.queued_bytes ?? 0) + fanout.reduce((sum, work) => sum + work.size, 0) + [...new Set(fanout.map(work => work.snapshot))].reduce((sum, snapshot) => sum + (this.snapshotRefs.get(snapshot)?.size ?? 0), 0) } };
+    }
+}
+//# sourceMappingURL=service.js.map