@agentunion/fastaun-browser 0.5.19 → 0.5.21

package/dist/org-protocol.js

@@ -27,6 +27,12 @@ const REPRESENTATION_FIELDS = new Set([
 ]);
 const REPRESENTATION_SIGNATURE_FIELDS = new Set(['cert_fingerprint', 'public_key_fingerprint', 'timestamp', 'signature']);
 const FINGERPRINT_RE = /^sha256:[0-9a-f]{64}$/i;
+const SERVICE_EVENTS = new Set([
+    'org.member.join_requested', 'org.member.join_approved', 'org.member.join_rejected',
+    'org.member.invite_created', 'org.member.invite_accepted', 'org.member.invite_rejected',
+    'org.member.changed', 'org.lifecycle.created', 'org.lifecycle.dissolving',
+    'org.lifecycle.dissolved', 'credential.revoked',
+]);
 export class ProtocolError extends Error {
     code;
     retryable;
@@ -39,25 +45,30 @@ export class ProtocolError extends Error {
 }
 export async function verifyServiceEvent(eventName, payload, context) {
     const event = eventName.startsWith('event/') ? eventName.slice(6) : eventName;
-    if (!isRecord(payload) || !context || !['type', 'event', 'event_id', 'responder', 'target_aids', 'as_of', 'expires_at', 'signature'].every((field) => field in payload) || payload.type !== event || payload.event !== event || typeof payload.event_id !== 'string' || !payload.event_id || ['_route', '_federation', '_trace', 'member_aids', 'inline_message'].some((field) => field in payload))
+    if (!SERVICE_EVENTS.has(event) || !isRecord(payload) || !context || !['type', 'event', 'event_id', 'responder', 'target_aids', 'as_of', 'expires_at', 'signature'].every((field) => field in payload) || payload.type !== event || payload.event !== event || typeof payload.event_id !== 'string' || !payload.event_id || ['_route', '_federation', '_trace', 'member_aids', 'inline_message'].some((field) => field in payload))
         throw invalid('service event payload is invalid');
     normalizeNfc(payload);
     aid(context.targetAid, 'event target');
     aid(payload.responder, 'event responder');
-    if (!Array.isArray(payload.target_aids) || !payload.target_aids.length || payload.target_aids.some((target) => typeof target !== 'string' || !AID_RE.test(target)) || new Set(payload.target_aids).size !== payload.target_aids.length || !payload.target_aids.includes(context.targetAid))
+    if (!Array.isArray(payload.target_aids) || !payload.target_aids.length || payload.target_aids.some((target) => typeof target !== 'string' || !AID_RE.test(target)))
+        throw invalid('service event audience is invalid');
+    const targetAids = new Set(payload.target_aids.map((target) => aidKey(target)));
+    if (targetAids.size !== payload.target_aids.length || !targetAids.has(aidKey(context.targetAid)))
         throw invalid('service event audience is invalid');
+    const responder = payload.responder;
+    const responderKey = aidKey(responder);
     const now = context.now ?? Math.trunc(Date.now() / 1000);
     if (!isInt(now) || !isInt(payload.as_of) || !isInt(payload.expires_at) || payload.as_of <= 0 || payload.expires_at <= payload.as_of || payload.expires_at > payload.as_of + 300 || payload.as_of > now + 300 || now >= payload.expires_at)
         throw invalid('service event time window is invalid');
     let known = true;
     if (event.startsWith('org.')) {
         aid(payload.org_id, 'event organization');
-        if (payload.responder !== 'org.' + String(payload.org_id).slice(String(payload.org_id).indexOf('.') + 1))
+        if (responderKey !== aidKey('org.' + String(payload.org_id).slice(String(payload.org_id).indexOf('.') + 1)))
             throw invalid('organization event authority is invalid');
     }
     else if (event.startsWith('credential.')) {
         const cid = payload.credentialCid ?? payload.credential_cid;
-        if (!String(payload.responder).startsWith('credential.') || typeof payload.target !== 'string' || !payload.target_aids.includes(payload.target) || typeof cid !== 'string' || !cid || payload.credentialCid !== undefined && payload.credential_cid !== undefined && payload.credentialCid !== payload.credential_cid)
+        if (!responderKey.startsWith('credential.') || typeof payload.target !== 'string' || !targetAids.has(aidKey(payload.target)) || typeof cid !== 'string' || !cid || payload.credentialCid !== undefined && payload.credential_cid !== undefined && payload.credentialCid !== payload.credential_cid)
             throw invalid('credential event authority or target is invalid');
         let service;
         try {
@@ -67,7 +78,7 @@ export async function verifyServiceEvent(eventName, payload, context) {
             throw invalid('trusted credential authority is unavailable');
         }
         known = service != null;
-        if (known && (typeof service !== 'string' || !service.startsWith('credential.') || service !== payload.responder))
+        if (known && (typeof service !== 'string' || !AID_RE.test(service) || !aidKey(service).startsWith('credential.') || aidKey(service) !== responderKey))
             throw invalid('credential event authority differs from the trusted provider');
     }
     else
@@ -79,8 +90,8 @@ export async function verifyServiceEvent(eventName, payload, context) {
             throw new Error('service event signature context is invalid');
         const body = { ...payload };
         delete body.signature;
-        const certificate = await context.resolveEventCertificate(payload.responder, signed.cert_fingerprint);
-        await verifyAgentSignature(signed, body, payload.responder, () => certificate, context.now ?? Math.trunc(Date.now() / 1000), false);
+        const certificate = await context.resolveEventCertificate(responderKey, signed.cert_fingerprint);
+        await verifyAgentSignature(signed, body, responder, () => certificate, context.now ?? Math.trunc(Date.now() / 1000), false);
     }
     catch {
         throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'service event signature verification failed');
@@ -89,6 +100,9 @@ export async function verifyServiceEvent(eventName, payload, context) {
         throw invalid('service event time window is invalid');
     return { signature_valid: true, credential_known: known };
 }
+function aidKey(value) {
+    return value.trim().toLowerCase();
+}
 export function protocolErrorRetryable(code) {
     return ERROR_RETRYABLE[String(code)] === true;
 }
@@ -101,6 +115,743 @@ function isRecord(value) {
 function isInt(value) {
     return typeof value === 'number' && Number.isInteger(value) && Number.isSafeInteger(value);
 }
+export class CredentialRenewal {
+    tail = Promise.resolve();
+    ports;
+    scanGuard;
+    constructor(ports) {
+        this.ports = {
+            ...ports,
+            currentAid: () => { this.checkScan(); return ports.currentAid(); },
+            load: (aid) => this.scanOperation(() => ports.load(aid)),
+            save: (aid, records, guard) => {
+                const scan = this.scanGuard;
+                return this.scanOperation(() => ports.save(aid, records, scan ? { current: () => scan.current() && (!guard || guard.current()), signal: scan.signal } : guard));
+            },
+            signer: (aid) => this.scanOperation(() => ports.signer(aid, this.scanGuard)),
+            certificate: (aid, fingerprint, signedAt) => this.scanOperation(() => ports.certificate(aid, fingerprint, signedAt)),
+            call: (method, params, onSent) => this.scanOperation(() => onSent ? ports.call(method, params, onSent) : ports.call(method, params)),
+            send: (to, payload) => this.scanOperation(() => ports.send(to, payload)),
+        };
+    }
+    checkScan() {
+        if (this.scanGuard && !this.scanGuard.current())
+            throw invalid('credential renewal was superseded');
+    }
+    async scanOperation(operation) {
+        this.checkScan();
+        const result = await operation();
+        this.checkScan();
+        return result;
+    }
+    serial(operation) {
+        const result = this.tail.then(operation);
+        this.tail = result.catch(() => { });
+        return result;
+    }
+    remember(credential, material = {}) {
+        return this.serial(() => this.rememberNow(credential, material));
+    }
+    current(input) {
+        return this.serial(async () => {
+            const records = await this.ports.load(this.ports.currentAid());
+            let cid = typeof input === 'string' ? input : String(input.cid);
+            const seen = new Set();
+            let record = records[cid];
+            while (record?.successor_cid && !seen.has(cid)) {
+                seen.add(cid);
+                cid = String(record.successor_cid);
+                record = records[cid];
+            }
+            return record ? structuredClone(record) : null;
+        });
+    }
+    async rememberNow(credential, material, actor = this.ports.currentAid(), guard) {
+        validateCredential(credential);
+        if (!material.long_term && !guard)
+            return;
+        if (guard && !guard.current())
+            throw invalid('membership event receiver identity changed');
+        const accounts = new Set();
+        if (credential.sub === actor)
+            accounts.add(actor);
+        if (credential.iss === actor || material.issued)
+            accounts.add(String(credential.iss));
+        for (const aid of accounts) {
+            const records = structuredClone(await this.ports.load(aid));
+            if (guard && !guard.current())
+                throw invalid('membership event receiver identity changed');
+            const previous = records[String(credential.cid)] ?? {};
+            const defined = Object.fromEntries(Object.entries(material).filter(([, value]) => value !== undefined));
+            records[String(credential.cid)] = { ...previous, ...structuredClone(defined), credential: structuredClone(credential), long_term: material.long_term === true };
+            if (guard)
+                await this.ports.save(aid, records, guard);
+            else
+                await this.ports.save(aid, records);
+            if (guard && !guard.current())
+                throw invalid('membership event receiver identity changed');
+        }
+    }
+    importMembershipPackage(payload, guard) {
+        const actor = this.ports.currentAid();
+        return this.serial(async () => {
+            const check = () => { if (!guard.current())
+                throw invalid('membership event receiver identity changed'); };
+            check();
+            const material = payload.membership_package;
+            if (!isRecord(material) || Object.keys(material).length !== 5 || !['credential', 'membership_binding', 'registrationReceipt', 'terms', 'org_signer_aid'].every((key) => key in material)
+                || payload.member_status !== 'active' || !isInt(payload.version) || payload.version < 1)
+                throw invalid('membership package is invalid');
+            const { credential, membership_binding: binding, registrationReceipt: receipt, terms, org_signer_aid: orgSigner } = material;
+            if (!isRecord(credential) || !isRecord(binding) || !isRecord(receipt) || !isRecord(terms) || !isRecord(credential.ext)
+                || credential.iss !== payload.org_id || credential.sub !== payload.member_aid || binding.org_id !== payload.org_id || binding.member_aid !== payload.member_aid
+                || binding.membership_id !== payload.membership_id || credential.cid !== payload.credential_cid || digest(terms) !== binding.terms_hash
+                || credential.ext.credential_type !== 'member' || credential.ext.bound_to_membership !== true || credential.ext.org_id !== payload.org_id
+                || credential.ext.membership_id !== binding.membership_id || credential.ext.binding_version !== binding.binding_version || credential.ext.membership_terms_hash !== binding.terms_hash
+                || credential.parent != null || credential.delegate !== false || !Array.isArray(credential.cap) || credential.cap.length !== 1
+                || credential.cap[0].ns !== 'org' || credential.cap[0].action !== 'role.' + String(binding.role) || credential.cap[0].resource !== payload.org_id)
+                throw invalid('membership package does not match the event');
+            aid(orgSigner, 'membership organization signer');
+            validateCredential(credential);
+            validateMembershipBinding(binding);
+            const certificates = new Map();
+            for (const [signerAid, signed] of [[credential.iss, credential.signature], [binding.member_aid, binding.member_signature], [orgSigner, binding.org_signature], ['credential.' + String(payload.org_id).split('.').slice(1).join('.'), receipt.signature]]) {
+                if (!isRecord(signed))
+                    throw invalid('membership package signature is missing');
+                const certificate = await this.ports.certificate(String(signerAid), String(signed.cert_fingerprint));
+                check();
+                certificates.set(String(signed.cert_fingerprint), certificate);
+            }
+            const resolve = (fingerprint) => certificates.get(fingerprint);
+            const now = Math.trunc(Date.now() / 1000);
+            await verifyCredentialSignature(credential, resolve, now, String(payload.org_id));
+            await verifyMembershipBinding(binding, resolve, now, String(orgSigner), true);
+            check();
+            const service = 'credential.' + String(payload.org_id).split('.').slice(1).join('.');
+            if (!isInt(receipt.registered_at) || !isInt(receipt.exp) || receipt.exp > receipt.registered_at + 300 || receipt.registered_at > now)
+                throw invalid('membership receipt window is invalid');
+            const late = now >= receipt.exp;
+            await verifyRegistrationReceipt(receipt, credential, { request_id: binding.request_id, nonce: binding.nonce, registrar_aid: payload.org_id }, resolve, service, late ? receipt.registered_at : now);
+            check();
+            const validUntil = Math.min(Number(credential.exp), late ? await this.status(credential, actor, false, receipt.registered_at) : receipt.exp);
+            check();
+            const completedAt = Math.trunc(Date.now() / 1000);
+            await verifyCredentialSignature(credential, resolve, completedAt, String(payload.org_id));
+            check();
+            if (actor !== payload.member_aid)
+                return;
+            const issuerCertificate = certificates.get(String(credential.signature.cert_fingerprint));
+            await this.rememberNow(credential, { membership_binding: binding, registrationReceipt: receipt, terms, version: payload.version,
+                service_aid: 'org.' + String(payload.org_id).split('.').slice(1).join('.'), long_term: credential.exp === Math.floor(parseCertMetadata(issuerCertificate).notAfter.getTime() / 1000) }, actor, { ...guard, current: () => guard.current() && Date.now() / 1000 < validUntil });
+        });
+    }
+    observe(method, params, result) {
+        if (method !== 'credential.register' && !method.startsWith('org.'))
+            return Promise.resolve();
+        return this.serial(async () => {
+            if (!isRecord(result))
+                return;
+            const invitations = isRecord(params.credential_templates) ? Object.entries(params.credential_templates).map(([aid, credential]) => ({ ...params, credential_template: credential, membership_binding: params.membership_bindings?.[aid] })) : [];
+            const values = [params, ...['previous_owner', 'new_owner'].map((key) => params[key]).filter(isRecord), ...invitations];
+            for (const value of values) {
+                const credential = value.credential_template ?? value.credential;
+                if (!isRecord(credential))
+                    continue;
+                const member = isRecord(credential.ext) && credential.ext.credential_type === 'member';
+                const actor = this.ports.currentAid();
+                const existing = (await this.ports.load(actor))[String(credential.cid)];
+                let longTerm = existing?.long_term === true;
+                if (!longTerm && isRecord(credential.signature)) {
+                    const cert = await this.ports.certificate(String(credential.iss), String(credential.signature.cert_fingerprint));
+                    const parent = Array.isArray(credential.proof_chain) ? credential.proof_chain[0] : undefined;
+                    longTerm = credential.exp === Math.min(Math.floor(parseCertMetadata(cert).notAfter.getTime() / 1000), credential.parent != null && parent ? Number(parent.exp) : Infinity);
+                }
+                await this.rememberNow(credential, {
+                    long_term: longTerm, issued: true,
+                    ...(member ? { membership_binding: result.membership_binding ?? value.membership_binding,
+                        terms: value.terms ?? (value.membership_binding?.role === 'owner' ? { org_id: credential.iss, owner_aid: credential.sub } : undefined),
+                        version: result.version ?? value.expected_version,
+                        service_aid: 'org.' + String(credential.iss).split('.').slice(1).join('.') } : {}),
+                });
+            }
+        });
+    }
+    resume(guard) {
+        return this.serial(async () => {
+            this.scanGuard = guard;
+            try {
+                const actor = this.ports.currentAid();
+                const records = await this.ports.load(actor);
+                for (const [cid, initial] of Object.entries(records)) {
+                    if (!isRecord(initial.credential))
+                        continue;
+                    try {
+                        if (initial.response?.registration_request && !initial.response.registrationReceipt && Number(initial.response.registration_request.request_binding?.exp) <= Math.trunc(Date.now() / 1000)) {
+                            if (!initial.registration_confirmation)
+                                await this.recoverRegistration(actor, cid, initial, records);
+                            continue;
+                        }
+                        if (initial.submission && initial.received_result && !initial.successor_cid)
+                            await this.receiveNow(String(initial.credential.iss), initial.received_result, undefined, true);
+                        else if (initial.incoming && initial.incoming.payload.exp > Math.trunc(Date.now() / 1000))
+                            await this.receiveNow(initial.incoming.from, initial.incoming.payload);
+                        const record = (await this.ports.load(actor))[cid];
+                        if (record.commit_pending)
+                            await this.sendCommit(record, actor);
+                        if (record.revoke_pending)
+                            await this.revokePrevious(record, actor);
+                        const credential = record.credential;
+                        const now = Math.trunc(Date.now() / 1000);
+                        if (record.successor_cid || !record.long_term || credential.sub !== actor || now >= credential.exp && !record.membership_binding && !record.pending || credential.exp - now >= (credential.exp - credential.iat) / 2)
+                            continue;
+                        let request = record.pending;
+                        if (request?.membership_binding && request.membership_binding.exp <= now)
+                            throw invalid('renewal member consent has expired');
+                        if (!request || request.exp <= now) {
+                            const signer = await this.ports.signer(actor);
+                            if (!signer)
+                                continue;
+                            request = { type: 'credential.renewal.request', ver: 'aun-credential-renewal/1', action: 'renew', issuer_aid: credential.iss,
+                                subject_aid: actor, previous_credential_cid: cid, credential_hash: digest(credential), request_id: request?.request_id ?? organizationIdentifier(), nonce: request?.nonce ?? organizationNonce(), iat: now, exp: now + 300,
+                                ...(request?.membership_binding ? { membership_binding: request.membership_binding, expected_version: request.expected_version } : {}) };
+                            if (record.membership_binding && !request.membership_binding) {
+                                if (now < credential.exp) {
+                                    const credentials = { [record.membership_binding.role === 'admin' ? 'approval_credential' : 'member_credential']: credential, membership_binding: record.membership_binding };
+                                    const query = await prepareOrganizationRequest('org.member.get', { org_id: credential.iss, member_aid: actor, credentials }, record.service_aid, signer);
+                                    const current = await this.ports.call('org.member.get', query);
+                                    const member = current.member ?? current;
+                                    if (!isInt(member.version) || member.credential_cid !== undefined && member.credential_cid !== cid)
+                                        throw invalid('current membership differs from managed credential');
+                                    record.version = member.version;
+                                }
+                                if (!isInt(record.version))
+                                    throw invalid('current membership version is unavailable');
+                                const binding = { ...record.membership_binding, binding_version: Number(record.membership_binding.binding_version) + 1,
+                                    request_id: request.request_id, nonce: request.nonce, iat: now, exp: now + 3600 };
+                                delete binding.member_signature;
+                                delete binding.org_signature;
+                                request.membership_binding = await signMembershipBinding(binding, signer, 'member');
+                                request.expected_version = record.version;
+                            }
+                            request.signature = await signProtocolPayload(request, signer);
+                            record.pending = request;
+                            const latest = await this.ports.load(actor);
+                            latest[cid] = record;
+                            await this.ports.save(actor, latest);
+                        }
+                        if (this.ports.currentAid() !== actor)
+                            return;
+                        const localIssuer = record.membership_binding && await this.ports.signer(String(credential.iss));
+                        if (localIssuer) {
+                            await this.receiveNow(actor, request, String(credential.iss));
+                            const issued = (await this.ports.load(String(credential.iss)))[cid]?.response;
+                            if (issued)
+                                await this.receiveNow(String(credential.iss), issued);
+                        }
+                        else
+                            await this.ports.send(String(credential.iss), request);
+                    }
+                    catch (error) {
+                        const latest = await this.ports.load(actor);
+                        if (latest[cid]) {
+                            latest[cid].last_error = error instanceof Error ? error.message : String(error);
+                            await this.ports.save(actor, latest);
+                        }
+                    }
+                }
+            }
+            finally {
+                this.scanGuard = undefined;
+            }
+        });
+    }
+    receive(from, payload) {
+        return this.serial(() => this.receiveNow(from, payload));
+    }
+    async verifyEnvelope(from, payload, expected, replay = false) {
+        const now = Math.trunc(Date.now() / 1000);
+        if (from !== expected || payload.ver !== 'aun-credential-renewal/1' || !isInt(payload.iat) || !isInt(payload.exp) || payload.iat > (replay ? payload.iat : now) || payload.exp <= (replay ? payload.iat : now) || payload.exp > payload.iat + 300 || !isRecord(payload.signature))
+            throw invalid('renewal message identity or validity is invalid');
+        const cert = await this.ports.certificate(expected, String(payload.signature.cert_fingerprint));
+        const unsigned = { ...payload };
+        delete unsigned.signature;
+        await verifyAgentSignature(payload.signature, unsigned, expected, () => cert, now);
+    }
+    async status(credential, actor, allowExpired = false, registrationConfirmedAt, confirmation) {
+        const target = 'credential.' + String(credential.iss).split('.').slice(1).join('.');
+        const requestedAt = Math.trunc(Date.now() / 1000);
+        const query = { credential_cid: credential.cid, request_id: organizationIdentifier(), nonce: organizationNonce(), include_chain: true };
+        query.request_binding = buildRequestBinding('credential.status', target, query, String(credential.cid), String(query.nonce), String(query.request_id), requestedAt, requestedAt + 300);
+        const proof = await this.ports.call('credential.status', query);
+        const now = Math.trunc(Date.now() / 1000);
+        if (!isRecord(proof) || proof.ver !== 'aun-credential-status/1' || proof.credentialCid !== credential.cid || proof.credential_hash !== digest(credential)
+            || proof.issuerAid !== credential.iss || proof.subjectAid !== credential.sub || proof.expiresAt !== credential.exp || proof.responder !== target
+            || proof.request_id !== query.request_id || proof.nonce !== query.nonce || proof.target !== actor
+            || !isInt(proof.asOf) || !isInt(proof.proofExpiresAt) || proof.asOf > now + 300 || proof.proofExpiresAt <= proof.asOf || proof.proofExpiresAt <= now || proof.proofExpiresAt > proof.asOf + 300
+            || !isRecord(proof.signature) || proof.signature.timestamp !== proof.asOf)
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'renewal status proof does not match the query');
+        const cert = await this.ports.certificate(target, String(proof.signature.cert_fingerprint));
+        const unsigned = { ...proof };
+        delete unsigned.signature;
+        await verifyAgentSignature(proof.signature, unsigned, target, () => cert, now, false);
+        if (proof.status !== 'active' && !(allowExpired && proof.status === 'expired' && proof.credentialStatus === 'expired' && Array.isArray(proof.chain) && proof.chain.every((item) => item.status === 'active')))
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'renewal credential is not active');
+        if (registrationConfirmedAt !== undefined && (proof.asOf < requestedAt || proof.asOf > now || !isInt(proof.registrationConfirmedAt) || proof.registrationConfirmedAt < registrationConfirmedAt || proof.registrationConfirmedAt > proof.asOf || proof.credentialStatus !== 'active' || proof.proofExpiresAt <= Math.trunc(Date.now() / 1000)))
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'membership registration confirmation is invalid');
+        if (confirmation)
+            Object.assign(confirmation, structuredClone(proof));
+        return proof.proofExpiresAt;
+    }
+    async receiveNow(from, value, localIssuer, replay = false) {
+        if (!isRecord(value) || !['credential.renewal.request', 'credential.renewal.result'].includes(String(value.type)))
+            return false;
+        const payload = value;
+        const isRequest = payload.type === 'credential.renewal.request';
+        const actor = localIssuer ?? this.ports.currentAid();
+        await this.verifyEnvelope(from, payload, String(isRequest ? payload.subject_aid : payload.issuer_aid), replay);
+        if (actor !== (isRequest ? payload.issuer_aid : payload.subject_aid))
+            throw invalid('renewal message has a different recipient');
+        let records = await this.ports.load(actor);
+        const cid = String(payload.previous_credential_cid);
+        const record = records[cid];
+        if (!record || !record.long_term || payload.credential_hash !== digest(record.credential) || payload.issuer_aid !== record.credential.iss || payload.subject_aid !== record.credential.sub)
+            throw invalid('renewal does not match a known grant');
+        if (!isRequest && record.successor_cid === payload.credential?.cid) {
+            if (record.commit_pending)
+                await this.sendCommit(record, actor);
+            return true;
+        }
+        if (replay && (!record.submission || digest(record.received_result) !== digest(payload)))
+            throw invalid('renewal replay differs from the saved result');
+        record.incoming = { from, payload: structuredClone(payload) };
+        await this.ports.save(actor, records);
+        if (isRequest && payload.action === 'commit') {
+            if (!record.response || record.response.request_id !== payload.request_id || record.response.nonce !== payload.nonce || record.response.credential.cid !== payload.new_credential_cid)
+                throw invalid('renewal acknowledgement differs from issued result');
+            record.revoke_pending = true;
+            await this.ports.save(actor, records);
+            await this.revokePrevious(record, actor);
+        }
+        else if (isRequest && payload.action === 'renew') {
+            if (payload.exp > payload.iat + 300)
+                throw invalid('renewal request window is too long');
+            if (record.successor_cid && record.response?.request_id !== payload.request_id)
+                throw invalid('grant was already replaced');
+            if (!record.response || record.response.request_id !== payload.request_id) {
+                await this.status(record.credential, this.ports.currentAid(), !!record.membership_binding);
+                const signer = await this.ports.signer(actor);
+                if (!signer)
+                    throw invalid('issuer signing identity is unavailable');
+                const now = Math.trunc(Date.now() / 1000);
+                const response = { type: 'credential.renewal.result', ver: payload.ver, action: 'issued', issuer_aid: actor, subject_aid: from,
+                    previous_credential_cid: cid, credential_hash: payload.credential_hash, request_id: payload.request_id, nonce: payload.nonce, iat: now };
+                if (record.membership_binding) {
+                    const binding = payload.membership_binding;
+                    const previous = record.membership_binding;
+                    if (!isRecord(binding) || binding.binding_version !== Number(previous.binding_version) + 1 || binding.request_id !== payload.request_id || binding.nonce !== payload.nonce
+                        || ['org_id', 'member_aid', 'membership_id', 'member_type', 'category', 'role', 'ownership', 'visibility', 'terms_hash'].some((key) => binding[key] !== previous[key]))
+                        throw invalid('renewal changes membership terms');
+                    const memberSignature = binding.member_signature;
+                    const memberCert = await this.ports.certificate(from, String(memberSignature?.cert_fingerprint));
+                    const unsigned = { ...binding };
+                    delete unsigned.member_signature;
+                    delete unsigned.org_signature;
+                    await verifyAgentSignature(memberSignature, unsigned, from, () => memberCert, now);
+                    const prepared = await prepareOrganizationRequest('org.member.renewCredential', { org_id: actor, member_aid: from, previous_credential_cid: cid,
+                        expected_version: payload.expected_version, terms: record.terms, membership_binding: binding }, record.service_aid, signer, { orgSigner: signer, memberSigner: signer,
+                        credentialOptions: Object.fromEntries(['security_level', 'revocation_endpoint', 'credential_service'].filter((key) => key in record.credential).map((key) => [key, record.credential[key]])) });
+                    delete prepared.request_binding;
+                    response.renewal_params = prepared;
+                    response.credential = prepared.credential_template;
+                    response.exp = Math.min(now + 300, Number(binding.exp), Number(response.credential.exp));
+                }
+                else {
+                    if (actor !== this.ports.currentAid())
+                        throw invalid('generic renewal requires the issuer session');
+                    let options = { ...record.credential };
+                    for (const key of ['signature', 'cid', 'iat', 'exp'])
+                        delete options[key];
+                    options.iat = now;
+                    options.nbf = Math.max(Number(record.credential.nbf), now);
+                    if (options.parent) {
+                        let parent = records[String(options.parent)];
+                        const seen = new Set();
+                        while (parent?.successor_cid && !seen.has(String(parent.credential.cid))) {
+                            seen.add(String(parent.credential.cid));
+                            parent = records[String(parent.successor_cid)];
+                        }
+                        const successor = parent?.credential;
+                        if (successor) {
+                            options.parent = successor.cid;
+                            options.proof_chain = [successor, ...(successor.proof_chain ?? [])];
+                            options.nbf = Math.max(Number(options.nbf), Number(successor.nbf));
+                        }
+                    }
+                    options.key_version = signer.certFingerprint;
+                    response.credential = await createCredential(options, signer);
+                    response.exp = Math.min(now + 300, Number(response.credential.exp));
+                    const registration = { request_id: payload.request_id, nonce: payload.nonce, registrar_aid: actor, credential: response.credential };
+                    registration.request_binding = buildRequestBinding('credential.register', 'credential.' + actor.split('.').slice(1).join('.'), registration, String(response.credential.cid), payload.nonce, payload.request_id, now, now + 300);
+                    response.registration_request = registration;
+                    record.response = response;
+                    await this.ports.save(actor, records);
+                }
+                record.response = response;
+                await this.ports.save(actor, records);
+            }
+            const response = record.response;
+            if (response.registration_request && !response.registrationReceipt) {
+                if (Number(response.registration_request.request_binding?.exp) <= Math.trunc(Date.now() / 1000)) {
+                    if (!record.registration_confirmation)
+                        await this.recoverRegistration(actor, cid, record, records);
+                    return true;
+                }
+                const registered = await this.ports.call('credential.register', response.registration_request, async () => {
+                    const sentAt = Math.trunc(Date.now() / 1000);
+                    if (this.ports.currentAid() !== actor || sentAt >= Number(response.registration_request.request_binding.exp))
+                        throw invalid('registration expired before it was sent');
+                    if (this.ports.atomicCheckpointSave?.() !== true)
+                        return;
+                    const deadline = Number(response.registration_request.request_binding.exp), hash = digest(response.registration_request);
+                    record.registration_submitted_at ??= sentAt;
+                    record.registration_submission_hash = hash;
+                    await this.ports.save(actor, records, { current: () => this.ports.currentAid() === actor && Date.now() / 1000 < deadline && digest(response.registration_request) === hash });
+                });
+                await this.receipt(response.credential, registered.registrationReceipt, response.registration_request);
+                await this.status(response.credential, actor);
+                response.registrationReceipt = registered.registrationReceipt;
+            }
+            const responseNow = Math.trunc(Date.now() / 1000);
+            const responseLimit = Math.min(responseNow + 300, Number(response.credential.exp), ...['membership_binding', 'credential_template', 'registration_authorization'].map((key) => Number(response.renewal_params?.[key]?.exp ?? Infinity)));
+            if (responseLimit <= responseNow)
+                throw invalid('renewal result authorization has expired');
+            if (!response.signature || response.exp <= responseNow || response.exp > responseLimit) {
+                response.iat = responseNow;
+                response.exp = responseLimit;
+                delete response.signature;
+                response.signature = await signProtocolPayload(response, (await this.ports.signer(actor)));
+            }
+            await this.ports.save(actor, records);
+            if (!localIssuer)
+                await this.ports.send(from, response);
+        }
+        else if (!isRequest && payload.action === 'issued') {
+            if (!record.pending || record.pending.request_id !== payload.request_id || record.pending.nonce !== payload.nonce || record.successor_cid && record.successor_cid !== payload.credential?.cid)
+                throw invalid('renewal result does not match pending request');
+            const credential = payload.credential;
+            if (!isRecord(credential) || credential.cid === cid || ['iss', 'sub', 'aud', 'cap', 'delegate', 'delegation_depth', 'security_level', 'revocation_endpoint', 'credential_service'].some((key) => canonicalText(credential[key] ?? null) !== canonicalText(record.credential[key] ?? null)))
+                throw invalid('renewal result changes the grant');
+            if (Number(credential.nbf) < Number(record.credential.nbf))
+                throw invalid('renewal moves the grant activation earlier');
+            const expectedExt = record.membership_binding ? { ...record.credential.ext, binding_version: Number(record.membership_binding.binding_version) + 1 } : record.credential.ext;
+            if (canonicalText(credential.ext ?? null) !== canonicalText(expectedExt ?? null))
+                throw invalid('renewal result changes grant extensions');
+            const credentialSignature = credential.signature;
+            const certificate = await this.ports.certificate(from, String(credentialSignature?.cert_fingerprint));
+            await verifyCredentialSignature(credential, () => certificate, Math.trunc(Date.now() / 1000));
+            const previousChain = credentialChainDocuments(record.credential);
+            const renewedChain = credentialChainDocuments(credential);
+            if (previousChain.length !== renewedChain.length)
+                throw invalid('renewal changes the authorization chain');
+            for (let index = 1; index < renewedChain.length; index++) {
+                const parent = renewedChain[index], previous = previousChain[index];
+                if (Number(parent.nbf) < Number(previous.nbf) || ['iss', 'sub', 'aud', 'cap', 'delegate', 'delegation_depth', 'ext', 'security_level', 'revocation_endpoint', 'credential_service'].some((key) => canonicalText(parent[key] ?? null) !== canonicalText(previous[key] ?? null)))
+                    throw invalid('renewal changes parent authorization');
+                const cert = await this.ports.certificate(String(parent.iss), String(parent.signature.cert_fingerprint));
+                await verifyCredentialSignature(parent, () => cert, Math.trunc(Date.now() / 1000), undefined, renewedChain.slice(index + 1));
+                await this.status(parent, actor);
+            }
+            let material = {};
+            let recoveryValidUntil = Infinity;
+            if (record.membership_binding) {
+                const params = payload.renewal_params;
+                if (!isRecord(params) || digest(params.credential_template) !== digest(credential) || params.previous_credential_cid !== cid
+                    || !isRecord(params.membership_binding) || digest(params.membership_binding.member_signature) !== digest(record.pending.membership_binding.member_signature)
+                    || params.expected_version !== record.pending.expected_version || params.org_id !== record.credential.iss || params.member_aid !== actor
+                    || digest(params.terms) !== digest(record.terms))
+                    throw invalid('renewal membership result is invalid');
+                const acceptedBinding = { ...params.membership_binding };
+                delete acceptedBinding.org_signature;
+                if (digest(acceptedBinding) !== digest(record.pending.membership_binding))
+                    throw invalid('renewal changes the signed member binding');
+                const signer = await this.ports.signer(actor);
+                if (!signer)
+                    throw invalid('member signing identity is unavailable');
+                const consentEnd = Math.min(Number(payload.exp), Number(params.membership_binding.exp), Number(params.registration_authorization?.exp), Number(credential.exp));
+                if (replay && consentEnd <= Math.trunc(Date.now() / 1000)) {
+                    if (this.ports.atomicCheckpointSave?.() !== true)
+                        throw invalid('atomic checkpoint persistence is required for renewal recovery');
+                    if (!isInt(record.submitted_at) || record.submitted_at < payload.iat || record.submitted_at >= consentEnd || record.submission_hash !== digest(record.submission))
+                        throw invalid('renewal operation was not submitted within its authorization window');
+                    const original = { ...record.submission };
+                    delete original.request_binding;
+                    delete original.client_signature;
+                    const expected = { ...params };
+                    delete expected.request_binding;
+                    delete expected.client_signature;
+                    if (digest(original) !== digest(expected))
+                        throw invalid('renewal submission differs from the original result');
+                    const credentialProof = {};
+                    const proofExpiresAt = await this.status(credential, actor, false, record.submitted_at, credentialProof);
+                    const query = await prepareOrganizationRequest('org.member.get', { org_id: credential.iss, member_aid: actor,
+                        credentials: { [params.membership_binding.role === 'admin' ? 'approval_credential' : 'member_credential']: credential, membership_binding: params.membership_binding } }, record.service_aid, signer);
+                    const current = await this.ports.call('org.member.get', query);
+                    const proof = current.membership_status;
+                    const now = Math.trunc(Date.now() / 1000);
+                    if (!isRecord(proof) || proof.ver !== 'aun-membership-status/1' || proof.org_id !== credential.iss || proof.member_aid !== actor || proof.credential_cid !== credential.cid
+                        || proof.membership_id !== params.membership_binding.membership_id || proof.role !== params.membership_binding.role || proof.version !== Number(params.expected_version) + 1
+                        || proof.status !== 'active' || proof.credential_status !== 'active' || proof.responder !== record.service_aid || proof.target !== actor || proof.request_id !== query.request_id || proof.nonce !== query.nonce
+                        || !isInt(proof.as_of) || proof.as_of < Number(query.request_binding.iat) || proof.as_of > now || !isInt(proof.expires_at) || proof.expires_at <= now || proof.expires_at > proof.as_of + 300
+                        || !isRecord(proof.signature) || proof.signature.timestamp !== proof.as_of || proofExpiresAt <= now)
+                        throw invalid('renewal membership confirmation is invalid');
+                    const cert = await this.ports.certificate(record.service_aid, String(proof.signature.cert_fingerprint));
+                    const unsigned = { ...proof };
+                    delete unsigned.signature;
+                    await verifyAgentSignature(proof.signature, unsigned, record.service_aid, () => cert, now, false);
+                    recoveryValidUntil = Math.min(proofExpiresAt, proof.expires_at, Number(credential.exp));
+                    material = { membership_binding: params.membership_binding, terms: record.terms, version: proof.version, service_aid: record.service_aid,
+                        recovery_confirmation: { membership_status: proof, credential_status: credentialProof } };
+                }
+                else {
+                    const prepared = record.submission ? structuredClone(record.submission) : await prepareOrganizationRequest('org.member.renewCredential', params, record.service_aid, signer);
+                    delete prepared.request_binding;
+                    delete prepared.client_signature;
+                    const submittedAt = Math.trunc(Date.now() / 1000);
+                    prepared.request_binding = buildRequestBinding('org.member.renewCredential', record.service_aid, prepared, String(credential.cid), String(prepared.nonce), String(prepared.request_id), submittedAt, Math.min(submittedAt + 300, Number(credential.exp)));
+                    record.submission = structuredClone(prepared);
+                    record.received_result = structuredClone(payload);
+                    records[cid] = record;
+                    await this.ports.save(actor, records);
+                    const result = await this.ports.call('org.member.renewCredential', prepared, async () => {
+                        const sentAt = Math.trunc(Date.now() / 1000);
+                        if (this.ports.currentAid() !== actor || sentAt >= Math.min(consentEnd, Number(prepared.request_binding.exp)))
+                            throw invalid('renewal authorization expired before it was sent');
+                        if (this.ports.atomicCheckpointSave?.() !== true)
+                            return;
+                        const deadline = Math.min(consentEnd, Number(prepared.request_binding.exp)), hash = digest(record.submission);
+                        record.submitted_at ??= sentAt;
+                        record.submission_hash = hash;
+                        await this.ports.save(actor, records, { current: () => this.ports.currentAid() === actor && Date.now() / 1000 < deadline && digest(record.submission) === hash });
+                    });
+                    await this.receipt(credential, result.registrationReceipt, prepared);
+                    await this.status(credential, actor);
+                    material = { membership_binding: result.membership_binding ?? params.membership_binding, terms: record.terms, version: result.version, service_aid: record.service_aid };
+                }
+            }
+            else {
+                await this.receipt(credential, payload.registrationReceipt, payload.registration_request);
+                await this.status(credential, actor);
+            }
+            records = await this.ports.load(actor);
+            records[String(credential.cid)] = { credential: structuredClone(credential), long_term: true, ...material };
+            records[cid].successor_cid = credential.cid;
+            records[cid].response = structuredClone(payload);
+            records[cid].commit_pending = true;
+            const recoveryGuard = { current: () => Date.now() / 1000 >= Number(credential.nbf) && Date.now() / 1000 < Math.min(recoveryValidUntil, Number(credential.exp)) };
+            if (!recoveryGuard.current())
+                throw invalid('renewal recovery confirmation has expired');
+            await this.ports.save(actor, records, recoveryGuard);
+            await this.sendCommit(records[cid], actor);
+        }
+        else
+            throw invalid('renewal message action is invalid');
+        records = await this.ports.load(actor);
+        delete records[cid].incoming;
+        await this.ports.save(actor, records);
+        return true;
+    }
+    async recoverRegistration(actor, cid, record, records) {
+        if (this.ports.atomicCheckpointSave?.() !== true)
+            throw invalid('atomic checkpoint persistence is required for registration recovery');
+        const response = record.response, request = response.registration_request, binding = request.request_binding;
+        if (!isInt(record.registration_submitted_at) || record.registration_submitted_at < binding.iat || record.registration_submitted_at >= binding.exp
+            || record.registration_submission_hash !== digest(request) || digest(request.credential) !== digest(response.credential))
+            throw invalid('registration was not sent within its authorization window');
+        const credential = response.credential;
+        const certificate = await this.ports.certificate(String(credential.iss), String(credential.signature?.cert_fingerprint));
+        await verifyCredentialSignature(credential, () => certificate, Math.trunc(Date.now() / 1000));
+        const confirmation = {};
+        const validUntil = await this.status(credential, actor, false, record.registration_submitted_at, confirmation);
+        records[String(credential.cid)] = { credential: structuredClone(credential), long_term: true, issued: true };
+        records[cid].registration_confirmation = confirmation;
+        const guard = { current: () => Date.now() / 1000 >= Number(credential.nbf) && Date.now() / 1000 < Math.min(validUntil, Number(credential.exp)) };
+        if (!guard.current())
+            throw invalid('registration recovery confirmation has expired');
+        await this.ports.save(actor, records, guard);
+    }
+    async receipt(credential, receipt, request) {
+        const service = 'credential.' + String(credential.iss).split('.').slice(1).join('.');
+        if (!isRecord(receipt) || !isRecord(receipt.signature))
+            throw invalid('renewal registration receipt is missing');
+        const cert = await this.ports.certificate(service, String(receipt.signature.cert_fingerprint));
+        await verifyRegistrationReceipt(receipt, credential, request, () => cert, service, Math.trunc(Date.now() / 1000));
+    }
+    async sendCommit(record, actor) {
+        const signer = await this.ports.signer(actor);
+        if (!signer)
+            throw invalid('renewal holder signing identity is unavailable');
+        const now = Math.trunc(Date.now() / 1000);
+        const payload = { ...record.pending, action: 'commit', new_credential_cid: record.successor_cid, iat: now, exp: now + 300 };
+        delete payload.signature;
+        payload.signature = await signProtocolPayload(payload, signer);
+        const localIssuer = record.membership_binding && await this.ports.signer(String(record.credential.iss));
+        if (localIssuer)
+            await this.receiveNow(actor, payload, String(record.credential.iss));
+        else
+            await this.ports.send(String(record.credential.iss), payload);
+        const records = await this.ports.load(actor);
+        delete records[String(record.credential.cid)].commit_pending;
+        await this.ports.save(actor, records);
+    }
+    async revokePrevious(record, actor) {
+        await this.status(record.response.credential, this.ports.currentAid());
+        if (!record.membership_binding && !record.credential.delegate) {
+            const now = Math.trunc(Date.now() / 1000);
+            const request = { credential_cid: record.credential.cid, registrar_aid: actor,
+                request_id: record.response.request_id + '-revoke', nonce: record.response.nonce + '-revoke', reason_code: 'credential_renewed', cascade: false };
+            request.request_binding = buildRequestBinding('credential.revoke', 'credential.' + actor.split('.').slice(1).join('.'), request, String(record.credential.cid), String(request.nonce), String(request.request_id), now, now + 300);
+            await this.ports.call('credential.revoke', request);
+        }
+        const records = await this.ports.load(actor);
+        const credential = record.response.credential;
+        records[String(credential.cid)] = { ...records[String(credential.cid)], credential: structuredClone(credential), long_term: true,
+            ...(record.membership_binding ? { membership_binding: record.response.renewal_params.membership_binding, terms: record.terms,
+                version: Number(record.response.renewal_params.expected_version) + 1, service_aid: record.service_aid } : {}) };
+        records[String(record.credential.cid)].successor_cid = record.response.credential.cid;
+        delete records[String(record.credential.cid)].revoke_pending;
+        await this.ports.save(actor, records);
+    }
+    revocationAuthority(document, record) {
+        const derived = 'credential.' + String(document.iss).split('.').slice(1).join('.');
+        const authority = record?.credential_authority ?? derived;
+        if (typeof authority !== 'string' || !/^credential\.[^\s/]+$/.test(authority) || !AID_RE.test(String(document.iss)))
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential authority is unavailable');
+        return authority;
+    }
+    revocationState(value) {
+        if (value == null || isRecord(value) && Object.keys(value).length === 0)
+            return { version: 1, authorities: {} };
+        if (!isRecord(value) || value.version !== 1 || !isRecord(value.authorities))
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential revocation storage is damaged');
+        for (const [authority, partition] of Object.entries(value.authorities)) {
+            if (!/^credential\.[^\s/]+$/.test(authority) || !isRecord(partition) || !isRecord(partition.revoked) || !isInt(partition.since_event_seq) || partition.since_event_seq < 0
+                || typeof partition.cursor !== 'string' || partition.cursor !== '' && (!/^(0|[1-9][0-9]*)$/.test(partition.cursor) || !isInt(Number(partition.cursor)) || Number(partition.cursor) !== partition.since_event_seq)
+                || !isInt(partition.as_of) || !isInt(partition.expires_at) || partition.expires_at <= partition.as_of
+                || Object.values(partition.revoked).some((sequence) => !isInt(sequence) || sequence <= 0 || sequence > Number(partition.since_event_seq)))
+                throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential revocation storage is damaged');
+        }
+        return value;
+    }
+    async _assertNotRevoked(credential, proofChain) {
+        if (!this.ports.loadRevocations)
+            return;
+        const actor = this.ports.currentAid();
+        const state = this.revocationState(await this.ports.loadRevocations(actor));
+        const records = await this.ports.load(actor);
+        if (!isRecord(records))
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'managed credential storage is unavailable');
+        const documents = [credential, ...(proofChain ?? [])];
+        const seen = new Set();
+        for (let index = 0; index < documents.length; index++) {
+            const document = documents[index];
+            if (!isRecord(document) || seen.has(document))
+                continue;
+            seen.add(document);
+            if (seen.size > 128)
+                throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'credential chain is too deep');
+            const authority = this.revocationAuthority(document, records[String(document.cid)]);
+            const revoked = state.authorities[authority]?.revoked;
+            if (revoked && Object.hasOwn(revoked, String(document.cid)))
+                throw new ProtocolError('CREDENTIAL_REVOKED', 'credential was revoked');
+            if (Array.isArray(document.proof_chain))
+                documents.push(...document.proof_chain);
+        }
+        if (this.ports.currentAid() !== actor)
+            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential receiver identity changed');
+    }
+    _syncRevocations(guard) {
+        if (!this.ports.loadRevocations || !this.ports.saveRevocations)
+            return Promise.resolve();
+        return this.serial(async () => {
+            const actor = this.ports.currentAid();
+            const check = () => { if (this.ports.currentAid() !== actor || guard && !guard.current())
+                throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential revocation synchronization was superseded'); };
+            check();
+            let state = structuredClone(this.revocationState(await this.ports.loadRevocations(actor)));
+            check();
+            const records = await this.ports.load(actor);
+            check();
+            const authorities = new Set();
+            if (AID_RE.test(actor))
+                authorities.add('credential.' + actor.split('.').slice(1).join('.'));
+            for (const record of Object.values(records)) {
+                if (!isRecord(record) || !isRecord(record.credential))
+                    continue;
+                validateCredential(record.credential);
+                const documents = [record.credential];
+                const seen = new Set();
+                for (let index = 0; index < documents.length; index++) {
+                    const document = documents[index];
+                    if (!isRecord(document) || seen.has(document))
+                        continue;
+                    seen.add(document);
+                    if (seen.size > 128)
+                        throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'credential chain is too deep');
+                    authorities.add(this.revocationAuthority(document, document === record.credential ? record : undefined));
+                    if (Array.isArray(document.proof_chain))
+                        documents.push(...document.proof_chain);
+                }
+            }
+            for (const authority of authorities) {
+                for (let page = 0; page < 32; page++) {
+                    check();
+                    const previous = state.authorities[authority] ?? { revoked: {}, since_event_seq: 0, cursor: '' };
+                    const since = previous.since_event_seq;
+                    const query = { cursor: previous.cursor || String(since), limit: 1000, request_id: organizationIdentifier(), nonce: organizationNonce() };
+                    const requestedAt = Math.trunc(Date.now() / 1000);
+                    query.request_binding = await buildRequestBinding('credential.revocationList', authority, query, '', String(query.nonce), String(query.request_id), requestedAt, requestedAt + 300);
+                    const proof = await this.ports.call('credential.revocationList', query);
+                    check();
+                    const now = Math.trunc(Date.now() / 1000);
+                    if (!isRecord(proof) || proof.responder !== authority || proof.target !== actor || proof.request_id !== query.request_id || proof.nonce !== query.nonce || proof.issuer_aid !== ''
+                        || !Array.isArray(proof.events) || proof.events.length > 1000 || typeof proof.next_cursor !== 'string'
+                        || !isInt(proof.as_of) || proof.as_of <= 0 || proof.as_of > now + 300 || !isInt(proof.expires_at) || proof.expires_at <= now || proof.expires_at <= proof.as_of || proof.expires_at > proof.as_of + 300
+                        || !isRecord(proof.signature) || proof.signature.timestamp !== proof.as_of)
+                        throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'revocation list does not match the query');
+                    let last = since;
+                    for (const event of proof.events) {
+                        if (!isRecord(event) || !isInt(event.event_seq) || event.event_seq <= last || typeof event.cid !== 'string' || !event.cid
+                            || typeof event.reason_code !== 'string' || !event.reason_code || !isInt(event.revoked_at) || event.revoked_at < 0 || event.revoked_at > proof.as_of
+                            || typeof event.revoked_by_aid !== 'string' || !AID_RE.test(event.revoked_by_aid))
+                            throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'revocation event sequence is invalid');
+                        last = event.event_seq;
+                    }
+                    if (proof.next_cursor !== '' && (!/^[1-9][0-9]*$/.test(proof.next_cursor) || !isInt(Number(proof.next_cursor)) || Number(proof.next_cursor) <= since || Number(proof.next_cursor) < last))
+                        throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'revocation cursor did not advance');
+                    const certificate = await this.ports.certificate(authority, String(proof.signature.cert_fingerprint));
+                    check();
+                    const unsigned = { ...proof };
+                    delete unsigned.signature;
+                    await verifyAgentSignature(proof.signature, unsigned, authority, () => certificate, Math.trunc(Date.now() / 1000), false);
+                    const next = structuredClone(state);
+                    const revoked = { ...previous.revoked };
+                    for (const event of proof.events)
+                        Object.defineProperty(revoked, String(event.cid), { value: event.event_seq, enumerable: true, configurable: true, writable: true });
+                    next.authorities[authority] = { revoked, since_event_seq: proof.next_cursor === '' ? last : Number(proof.next_cursor), cursor: proof.next_cursor, as_of: proof.as_of, expires_at: proof.expires_at };
+                    const commitGuard = { ...guard, current: () => this.ports.currentAid() === actor && (!guard || guard.current()) && Date.now() / 1000 < Number(proof.expires_at) };
+                    if (!commitGuard.current())
+                        throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'revocation list expired before persistence');
+                    await this.ports.saveRevocations(actor, next, commitGuard);
+                    if (!commitGuard.current())
+                        throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'revocation synchronization was superseded');
+                    state = next;
+                    if (proof.next_cursor === '')
+                        break;
+                }
+            }
+        });
+    }
+}
 function certificatePem(value) {
     if (typeof value === 'string' && value.includes('-----BEGIN CERTIFICATE-----'))
         return value;
@@ -535,6 +1286,8 @@ export function validateCredential(credential, chainDepth = 0, externalProofChai
     if (!isInt(delegationDepth) || delegationDepth < 0)
         throw invalid('delegation_depth is invalid');
     const parent = credential.parent;
+    if (credential.proof_chain !== undefined && externalProofChain !== undefined && canonicalText(credential.proof_chain) !== canonicalText(externalProofChain))
+        throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'embedded proof_chain conflicts with external proof_chain');
     if (parent == null && delegationDepth !== 0)
         throw invalid('root credential must have delegation_depth 0');
     if (parent != null) {
@@ -549,12 +1302,12 @@ export function validateCredential(credential, chainDepth = 0, externalProofChai
             throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'proof_chain is too deep');
         for (let index = 0; index < chain.length; index++) {
             const item = chain[index];
-            validateCredential(item, chainDepth + 1);
-            if (canonicalText(item.proof_chain ?? []) !== canonicalText(chain.slice(index + 1)))
+            validateCredential(item, chainDepth + 1, chain.slice(index + 1));
+            if (item.proof_chain !== undefined && canonicalText(item.proof_chain) !== canonicalText(chain.slice(index + 1)))
                 throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'embedded proof_chain conflicts with outer chain');
         }
     }
-    else if ('proof_chain' in credential && JSON.stringify(credential.proof_chain) !== '[]') {
+    else if ('proof_chain' in credential && JSON.stringify(credential.proof_chain) !== '[]' || parent == null && externalProofChain !== undefined && JSON.stringify(externalProofChain) !== '[]') {
         throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'root proof_chain must be empty');
     }
     if ('security_level' in credential && !['low', 'medium', 'high'].includes(credential.security_level))
@@ -594,6 +1347,10 @@ export async function createCredential(options, signer) {
         throw invalid('issuer does not match signing AID');
     const chain = value.proof_chain;
     const parentDepth = Array.isArray(chain) && isRecord(chain[0]) ? chain[0].delegation_depth ?? 0 : 0;
+    if (!('exp' in value)) {
+        const certExp = Math.floor(parseCertMetadata(signer.certPem).notAfter.getTime() / 1000);
+        value.exp = value.parent != null && Array.isArray(chain) && isRecord(chain[0]) && isInt(chain[0].exp) ? Math.min(certExp, chain[0].exp) : certExp;
+    }
     if (!('delegation_depth' in value))
         value.delegation_depth = value.parent !== undefined && value.parent !== null && isInt(parentDepth) ? parentDepth + 1 : 0;
     if (Array.isArray(value.cap))
@@ -819,7 +1576,7 @@ export async function prepareOrganizationRequest(method, params, target, signer,
             throw invalid('organization signer or signed member CAP is required');
         value.credential_template = await createMemberCredential(binding, options.orgSigner, { key_version: options.orgSigner.certFingerprint, ...options.credentialOptions });
     }
-    if (method !== 'org.member.inviteAccept' && isRecord(value.credential_template) && !('registration_authorization' in value)) {
+    if (!['org.member.inviteAccept', 'org.member.inviteReject'].includes(method) && isRecord(value.credential_template) && !('registration_authorization' in value)) {
         if (!binding)
             throw invalid('membership binding is required for registration');
         const issuerSigner = options.orgSigner ?? (signer.aid === value.credential_template.iss ? signer : undefined);
@@ -852,11 +1609,18 @@ export async function prepareOrganizationRequest(method, params, target, signer,
     const credentials = isRecord(value.credentials) ? value.credentials : {};
     if ('credentials' in value && !isRecord(value.credentials))
         throw invalid('credentials must be an object');
-    if (['org.member.join', 'org.member.inviteAccept'].includes(method)) {
-        if (!binding || !isRecord(binding.member_signature) || ('for' in value ? value.for : signer.aid) !== binding.member_aid || value.member_aid !== binding.member_aid || binding.org_id !== value.org_id || target !== 'org.' + String(binding.org_id).slice(String(binding.org_id).indexOf('.') + 1))
-            throw representationBindingInvalid('admission target must match the signed membership binding');
+    if (['org.member.join', 'org.member.inviteAccept', 'org.member.inviteReject'].includes(method)) {
+        const rejection = method === 'org.member.inviteReject';
+        if (rejection && binding && !('member_aid' in value))
+            value.member_aid = binding.member_aid;
+        if (!binding || ('for' in value ? value.for : signer.aid) !== binding.member_aid || value.member_aid !== binding.member_aid || binding.org_id !== value.org_id || target !== 'org.' + String(binding.org_id).slice(String(binding.org_id).indexOf('.') + 1) || !isRecord(rejection ? binding.org_signature : binding.member_signature))
+            throw representationBindingInvalid('admission requires the original membership signature');
+        if (rejection && (value.request_id === binding.request_id || value.nonce === binding.nonce))
+            throw representationBindingInvalid('invitation rejection requires a distinct action identity');
         value.credentials = credentials;
         const now = Math.trunc(Date.now() / 1000);
+        if (now >= Number(binding.exp))
+            throw representationBindingInvalid('membership binding has expired');
         let maximum = Math.min(now + 300, Number(binding.exp));
         for (const field of ['credential_template', 'registration_authorization'])
             if (field in value) {
@@ -922,7 +1686,7 @@ export async function createMemberCredential(binding, signer, options) {
     const text = (value) => new TextDecoder().decode(canonicalJson(value));
     if (!isRecord(options) || Object.entries(fixed).some(([key, value]) => key in options && text(options[key]) !== text(value)) || options.parent !== undefined && options.parent !== null)
         throw invalid('member credential options conflict with binding');
-    return createCredential({ exp: binding.exp, ...options, ...fixed }, signer);
+    return createCredential({ ...options, ...fixed }, signer);
 }
 export async function verifyCredential(credential, context) {
     if (!context || !context.audience || !context.subject)
@@ -933,6 +1697,22 @@ export async function verifyCredential(credential, context) {
         throw invalid('credential subject does not match holder');
     const now = context.now ?? Math.trunc(Date.now() / 1000);
     const documents = credentialChainDocuments(credential, context.proofChain);
+    const resolvedCertificates = [];
+    const resolveCertificate = async (fingerprint) => {
+        const material = await context.resolveCertificate(fingerprint);
+        if (material != null)
+            resolvedCertificates.push(material);
+        return material;
+    };
+    const resolveActorCertificate = context.resolveActorCertificate
+        ? async (fingerprint) => {
+            const material = await context.resolveActorCertificate(fingerprint);
+            if (material != null)
+                resolvedCertificates.push(material);
+            return material;
+        }
+        : resolveCertificate;
+    const statusProofs = [];
     const status = async (cid) => {
         const document = documents.find((item) => item.cid === cid);
         let proof;
@@ -945,6 +1725,7 @@ export async function verifyCredential(credential, context) {
             throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status is unavailable');
         }
         if (isRecord(proof)) {
+            statusProofs.push(proof);
             if (typeof proof.credentialCid === 'string' && proof.credentialCid !== cid)
                 throw new ProtocolError('CREDENTIAL_CHAIN_INVALID', 'registered credential cid differs from the signed document');
             if (proof.ver !== 'aun-credential-status/1' || proof.credentialCid !== cid || typeof proof.credential_hash !== 'string' || !DIGEST_RE.test(proof.credential_hash) || !isInt(proof.asOf) || !isInt(proof.proofExpiresAt) || proof.asOf > now + 300 || proof.proofExpiresAt <= proof.asOf || proof.proofExpiresAt > proof.asOf + 300 || now >= proof.proofExpiresAt || typeof proof.responder !== 'string' || !proof.responder.startsWith('credential.') || !AID_RE.test(proof.responder.slice(11)) || typeof proof.request_id !== 'string' || !proof.request_id || typeof proof.nonce !== 'string' || !proof.nonce || typeof proof.target !== 'string' || !AID_RE.test(proof.target))
@@ -965,7 +1746,7 @@ export async function verifyCredential(credential, context) {
             throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'parent credential status proof is required');
         return typeof proof === 'string' ? proof : undefined;
     };
-    await verifyCredentialChain(credential, context.resolveCertificate, status, now, context.audience, context.proofChain);
+    await verifyCredentialChain(credential, resolveCertificate, status, now, context.audience, context.proofChain);
     if (credentialChainDocuments(credential, context.proofChain).at(-1).iss !== (context.rootIssuer ?? context.audience))
         throw invalid('credential root issuer is not trusted for this resource');
     const rate = context.checkRateLimit ? (field, unit, limit) => context.checkRateLimit(String(value.cid), String(value.sub), field, unit, limit) : undefined;
@@ -985,7 +1766,7 @@ export async function verifyCredential(credential, context) {
             if (value.iss !== binding.org_id || !value.aud.includes(binding.org_id) || caps.length !== 1 || caps[0].ns !== 'org' || caps[0].action !== 'role.' + String(binding.role) || caps[0].resource !== binding.org_id)
                 throw invalid('member credential capability does not match binding role');
         }
-        await verifyMembershipBinding(binding, context.resolveCertificate, now, context.orgSigner, true);
+        await verifyMembershipBinding(binding, resolveCertificate, now, context.orgSigner, true);
         if (!context.resolveMembershipStatus || await context.resolveMembershipStatus(binding, value) !== true)
             throw new ProtocolError('MEMBERSHIP_STATE_INVALID', 'trusted current membership status does not permit this operation');
     }
@@ -993,6 +1774,7 @@ export async function verifyCredential(credential, context) {
     const params = context.params ?? {};
     const target = context.for ?? params.for;
     const actor = context.actor ?? context.subject;
+    let verifiedRepresentation;
     if (typeof actor !== 'string' || !AID_RE.test(actor))
         throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'authenticated actor is invalid');
     if (target !== undefined && (typeof target !== 'string' || !target || !context.actor || Object.hasOwn(params, 'for') && params.for !== target))
@@ -1004,7 +1786,9 @@ export async function verifyCredential(credential, context) {
         const proof = context.representationProof ?? packaged;
         if (packaged !== undefined && canonicalText(packaged) !== canonicalText(proof))
             throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'representation proof differs from the request');
-        await verifyRepresentationProof(proof, credential, { from: actor, for: target, audience: context.target, resource: target, params, binding: context.requestBinding }, context.resolveActorCertificate ?? context.resolveCertificate, now, context.proofChain);
+        const representationRequest = { from: actor, for: target, audience: context.target, resource: target, params, binding: context.requestBinding };
+        await verifyRepresentationProof(proof, credential, representationRequest, resolveActorCertificate, now, context.proofChain);
+        verifiedRepresentation = { proof: proof, request: representationRequest };
         const subjects = [String(target), ...(context.subject !== actor && context.subject !== target ? [context.subject] : [])];
         let allowed = Boolean(context.resolveOwnership);
         try {
@@ -1021,6 +1805,28 @@ export async function verifyCredential(credential, context) {
             throw new ProtocolError('ROLE_ACCESS_DENIED', 'trusted current ownership does not permit representation');
         result.representation_checked = true;
     }
+    if (context.now === undefined) {
+        const completedAt = Math.trunc(Date.now() / 1000);
+        for (const [index, document] of documents.entries())
+            validateCredentialAt(document, completedAt, context.audience, documents.slice(index + 1));
+        await validateCredentialCapability(credential, { ns: context.ns, action: context.action, resource: context.resource, params: context.params, units: context.units, now: completedAt, client_ip: context.clientIp, proof_chain: context.proofChain }, () => true);
+        validateRequestBinding(context.requestBinding, context.method, context.target, context.params ?? {}, String(value.cid), context.nonce ?? '', context.requestId ?? '', completedAt);
+        for (const proof of statusProofs) {
+            if (proof.asOf > completedAt + 300 || completedAt >= proof.proofExpiresAt)
+                throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status proof is unavailable');
+        }
+        for (const material of resolvedCertificates) {
+            const metadata = parseCertMetadata(certificatePem(material));
+            if (completedAt < metadata.notBefore.getTime() / 1000 || completedAt > metadata.notAfter.getTime() / 1000)
+                throw new ProtocolError('CREDENTIAL_SIGNATURE_INVALID', 'certificate is not valid');
+        }
+        if (verifiedRepresentation) {
+            const { proof, request } = verifiedRepresentation;
+            if (completedAt < proof.iat || completedAt >= proof.exp)
+                throw representationBindingInvalid('representation time window is invalid');
+            validateRepresentationContext(proof, value, request, completedAt);
+        }
+    }
     return result;
 }
 export function validateCredentialAt(credential, now, audience, proofChain) {
@@ -1327,7 +2133,7 @@ export async function verifyCredentialChain(credential, resolveCertificate, reso
             throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential status is unavailable');
     }
     for (const [index, document] of documents.entries())
-        await verifyCredentialSignature(document, resolveCertificate, now, audience, index === 0 ? proofChain : undefined);
+        await verifyCredentialSignature(document, resolveCertificate, now, audience, documents.slice(index + 1));
 }
 function validateMembershipBindingPayload(binding, allowPartial = false) {
     if (!isRecord(binding))
@@ -1507,7 +2313,7 @@ function orgRequestBindingParams(method, params) {
 export function buildRequestBinding(method, target, params, credentialCid, nonce, requestId, iat, exp) {
     if (![method, target, nonce, requestId].every((value) => typeof value === 'string' && value.length > 0) || typeof credentialCid !== 'string' || (!credentialCid !== (method === 'credential.revocationList')))
         throw invalid('request binding identity is invalid');
-    if (!isInt(iat) || !isInt(exp) || exp <= iat)
+    if (!isInt(iat) || !isInt(exp) || exp <= iat || exp > iat + 300)
         throw invalid('request binding time window is invalid');
     return { request_id: requestId, nonce, target, method, params_hash: digest(orgRequestBindingParams(method, params)), iat, exp, credential_cid: credentialCid };
 }
@@ -1519,7 +2325,7 @@ export function validateRequestBinding(binding, method, target, params, credenti
         throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request binding is invalid');
     if (binding.request_id !== requestId || binding.nonce !== nonce || binding.target !== target || binding.method !== method || binding.credential_cid !== credentialCid || binding.params_hash !== digest(orgRequestBindingParams(method, params)))
         throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request binding does not match request');
-    if (!isInt(binding.iat) || !isInt(binding.exp) || binding.exp <= binding.iat || !isInt(now) || now < binding.iat || now >= binding.exp)
+    if (!isInt(binding.iat) || !isInt(binding.exp) || binding.exp <= binding.iat || binding.exp > binding.iat + 300 || !isInt(now) || now < binding.iat || now >= binding.exp)
         throw new ProtocolError('CREDENTIAL_REQUEST_BINDING_INVALID', 'request binding is outside its validity window');
 }
 function representationBindingInvalid(message) {