@agentunion/fastaun 0.5.19 → 0.5.21

package/dist/org-protocol.js

@@ -28,6 +28,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;
@@ -38,6 +44,740 @@ export class ProtocolError extends Error {
         this.retryable = protocolErrorRetryable(code);
     }
 }
+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();
+            while (records[cid]?.successor_cid && !seen.has(cid)) {
+                seen.add(cid);
+                cid = String(records[cid].successor_cid);
+            }
+            return records[cid] ? structuredClone(records[cid]) : 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);
+            verifyCredentialSignature(credential, resolve, now, String(payload.org_id));
+            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;
+            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);
+            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(Date.parse(new X509Certificate(issuerCertificate).validTo) / 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 values = [params, ...['previous_owner', 'new_owner'].map((key) => params[key]).filter(isRecord),
+                ...Object.entries(params.credential_templates ?? {}).map(([aid, credential]) => ({ credential_template: credential, membership_binding: params.membership_bindings?.[aid], terms: params.terms }))];
+            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));
+                    longTerm = credential.exp === Math.min(Math.floor(new Date(new X509Certificate(cert).validTo).getTime() / 1000), Number(credential.proof_chain?.[0]?.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.member?.version ?? result.version ?? value.expected_version ?? (['org.member.approveJoin', 'org.member.inviteAccept'].includes(method) ? 1 : undefined),
+                        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?.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 || !record.membership_binding && !record.pending && now >= credential.exp || 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 = request ? { ...request, iat: now, exp: now + 300 } : { 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: organizationIdentifier(), nonce: organizationNonce(), iat: now, exp: now + 300 };
+                            delete request.signature;
+                            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 = 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 = signMembershipBinding(binding, signer, 'member');
+                                request.expected_version = record.version;
+                            }
+                            request.signature = 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;
+        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 query = { credential_cid: credential.cid, request_id: organizationIdentifier(), nonce: organizationNonce(), include_chain: true };
+        const requestedAt = Math.trunc(Date.now() / 1000);
+        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;
+        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;
+        if (!replay && isInt(payload.exp) && payload.exp <= Math.trunc(Date.now() / 1000))
+            return true;
+        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 (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) {
+                const checkedAt = Math.trunc(Date.now() / 1000);
+                if (record.credential.exp - checkedAt >= (record.credential.exp - record.credential.iat) / 2)
+                    throw invalid('credential renewal threshold is not reached');
+                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;
+                    verifyAgentSignature(memberSignature, unsigned, from, () => memberCert, now);
+                    const credentialOptions = Object.fromEntries(['security_level', 'revocation_endpoint', 'credential_service'].filter((key) => record.credential[key] !== undefined).map((key) => [key, record.credential[key]]));
+                    const prepared = 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 });
+                    delete prepared.request_binding;
+                    response.renewal_params = prepared;
+                    response.credential = prepared.credential_template;
+                    response.exp = Math.min(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', 'nbf', 'exp'])
+                        delete options[key];
+                    if (options.parent) {
+                        let parent = records[String(options.parent)];
+                        const visited = new Set();
+                        while (parent?.successor_cid && !visited.has(String(parent.credential.cid))) {
+                            visited.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.key_version = signer.certFingerprint;
+                    options.iat = now;
+                    options.nbf = Math.max(Number(record.credential.nbf), now, Number(options.proof_chain?.[0]?.nbf ?? 0));
+                    response.credential = createCredential(options, signer);
+                    response.exp = Math.min(now + 300, 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 = signProtocolPayload(response, (await this.ports.signer(actor)));
+            }
+            records[String(response.credential.cid)] = { ...records[String(response.credential.cid)], credential: structuredClone(response.credential), long_term: true,
+                ...(record.membership_binding ? { membership_binding: structuredClone(response.renewal_params.membership_binding), terms: record.terms, version: Number(payload.expected_version) + 1, service_aid: record.service_aid } : {}) };
+            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');
+            if (record.successor_cid) {
+                if (record.commit_pending)
+                    await this.sendCommit(record, actor);
+                records = await this.ports.load(actor);
+                delete records[cid].incoming;
+                await this.ports.save(actor, records);
+                return true;
+            }
+            const credential = payload.credential;
+            if (!isRecord(credential) || credential.cid === cid || Number(credential.nbf) < record.credential.nbf || ['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');
+            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));
+            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));
+                verifyCredentialSignature(parent, () => cert, Math.trunc(Date.now() / 1000), undefined, renewedChain.slice(index + 1));
+            }
+            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)
+                    || digest(params.terms) !== digest(record.terms))
+                    throw invalid('renewal membership result is invalid');
+                const agreedBinding = { ...params.membership_binding };
+                delete agreedBinding.org_signature;
+                if (digest(agreedBinding) !== digest(record.pending.membership_binding) || params.org_id !== record.credential.iss || params.member_aid !== actor || params.expected_version !== record.pending.expected_version)
+                    throw invalid('renewal differs from the signed membership request');
+                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 = 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;
+                    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) : structuredClone(params);
+                    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));
+        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));
+        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 = signProtocolPayload(payload, signer);
+        if (record.membership_binding && await this.ports.signer(String(record.credential.iss)))
+            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);
+        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;
+    }
+    _assertNotRevoked(credential, proofChain) {
+        if (!this.ports.loadRevocations)
+            return;
+        const actor = this.ports.currentAid();
+        const state = this.revocationState(this.ports.loadRevocations(actor));
+        const records = 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 = 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;
+                    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(material) {
     if (!material)
         throw new Error('certificate is missing');
@@ -50,26 +790,34 @@ function certificatePem(material) {
     return new X509Certificate(value).toString();
 }
 export async function verifyServiceEvent(eventName, payload, context) {
-    if (!isRecord(payload) || ['_route', '_federation', '_trace', 'member_aids', 'inline_message'].some((key) => Object.hasOwn(payload, key)) || payload.type !== eventName || payload.event !== eventName || typeof payload.event_id !== 'string' || !payload.event_id || typeof payload.responder !== 'string' || !AID_RE.test(payload.responder))
+    const event = eventName.startsWith('event/') ? eventName.slice(6) : eventName;
+    if (!SERVICE_EVENTS.has(event) || !isRecord(payload) || ['_route', '_federation', '_trace', 'member_aids', 'inline_message'].some((key) => Object.hasOwn(payload, key)) || payload.type !== event || payload.event !== event || typeof payload.event_id !== 'string' || !payload.event_id || typeof payload.responder !== 'string' || !AID_RE.test(payload.responder))
         throw invalid('service event identity is invalid');
     normalizeNfc(payload);
+    if (typeof context.targetAid !== 'string' || !AID_RE.test(context.targetAid))
+        throw invalid('service event target is invalid');
     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');
-    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 target is invalid');
-    let known = eventName.startsWith('org.');
+    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 target is invalid');
+    const responder = payload.responder;
+    const responderKey = aidKey(responder);
+    let known = event.startsWith('org.');
     if (known) {
-        if (typeof payload.org_id !== 'string' || !AID_RE.test(payload.org_id) || payload.responder !== 'org.' + payload.org_id.slice(payload.org_id.indexOf('.') + 1))
+        if (typeof payload.org_id !== 'string' || !AID_RE.test(payload.org_id) || responderKey !== aidKey('org.' + payload.org_id.slice(payload.org_id.indexOf('.') + 1)))
             throw invalid('organization event authority is invalid');
     }
-    else if (eventName.startsWith('credential.')) {
+    else if (event.startsWith('credential.')) {
         const cid = payload.credential_cid ?? payload.credentialCid;
-        if (typeof cid !== 'string' || !cid || payload.credential_cid !== undefined && payload.credentialCid !== undefined && payload.credential_cid !== payload.credentialCid || !payload.responder.startsWith('credential.') || typeof payload.target !== 'string' || !payload.target_aids.includes(payload.target))
+        if (typeof cid !== 'string' || !cid || payload.credential_cid !== undefined && payload.credentialCid !== undefined && payload.credential_cid !== payload.credentialCid || !responderKey.startsWith('credential.') || typeof payload.target !== 'string' || !targetAids.has(aidKey(payload.target)))
             throw invalid('credential event authority is invalid');
         const expected = await context.resolveCredentialService?.(cid);
         known = expected != null;
-        if (known && expected !== payload.responder)
+        if (known && (typeof expected !== 'string' || !AID_RE.test(expected) || aidKey(expected) !== responderKey))
             throw invalid('credential event provider does not match trusted authority');
     }
     else
@@ -79,7 +827,7 @@ export async function verifyServiceEvent(eventName, payload, context) {
     if (signed.timestamp !== payload.as_of)
         throw invalid('service event signature time is invalid');
     try {
-        const cert = certificatePem(await context.resolveEventCertificate(payload.responder, String(signed.cert_fingerprint)));
+        const cert = certificatePem(await context.resolveEventCertificate(responderKey, String(signed.cert_fingerprint)));
         const value = { ...payload };
         delete value.signature;
         verifyAgentSignature(signed, value, payload.responder, () => cert, context.now ?? Math.trunc(Date.now() / 1000), false);
@@ -91,6 +839,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;
 }
@@ -521,6 +1272,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) {
@@ -535,12 +1288,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 (!['low', 'medium', 'high'].includes(Object.hasOwn(credential, 'security_level') ? credential.security_level : 'medium'))
@@ -579,6 +1332,10 @@ export 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(new Date(new X509Certificate(signer.certPem).validTo).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))
@@ -804,7 +1561,7 @@ export function prepareOrganizationRequest(method, params, target, signer, optio
             throw invalid('organization signer or signed member CAP is required');
         value.credential_template = 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);
@@ -837,11 +1594,18 @@ export function prepareOrganizationRequest(method, params, target, signer, optio
     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 || ('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(binding.member_signature))
-            throw representationBindingInvalid('admission requires the target member signature');
+    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 exp = Math.min(now + 300, Number(binding.exp));
         for (const field of ['credential_template', 'registration_authorization'])
             if (field in value) {
@@ -906,7 +1670,7 @@ export 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 function verifyCredential(credential, context) {
     if (!context || !context.audience || !context.subject)
@@ -920,6 +1684,22 @@ export function verifyCredential(credential, context) {
         throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status is unavailable');
     const now = context.now ?? Math.trunc(Date.now() / 1000);
     const documents = credentialChainDocuments(credential, context.proofChain);
+    const resolvedCertificates = [];
+    const resolveCertificate = (fingerprint) => {
+        const material = context.resolveCertificate(fingerprint);
+        if (material != null)
+            resolvedCertificates.push(material);
+        return material;
+    };
+    const resolveActorCertificate = context.resolveActorCertificate
+        ? (fingerprint) => {
+            const material = context.resolveActorCertificate(fingerprint);
+            if (material != null)
+                resolvedCertificates.push(material);
+            return material;
+        }
+        : resolveCertificate;
+    const statusProofs = [];
     const status = (cid) => {
         let proof;
         try {
@@ -929,6 +1709,8 @@ export function verifyCredential(credential, context) {
             throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status proof is unavailable');
         }
         const document = documents.find((item) => item.cid === cid);
+        if (isRecord(proof))
+            statusProofs.push(proof);
         if (proof != null || document !== value) {
             if (!isRecord(proof) || proof.ver !== 'aun-credential-status/1' || typeof proof.credentialCid !== 'string' || !proof.credentialCid || 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)
                 throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status proof is invalid');
@@ -951,7 +1733,7 @@ export function verifyCredential(credential, context) {
             throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'trusted credential status is unavailable');
         }
     };
-    verifyCredentialChain(credential, context.resolveCertificate, status, now, context.audience, context.proofChain);
+    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;
@@ -971,7 +1753,7 @@ export 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');
         }
-        verifyMembershipBinding(binding, context.resolveCertificate, now, context.orgSigner, true);
+        verifyMembershipBinding(binding, resolveCertificate, now, context.orgSigner, true);
         if (!context.resolveMembershipStatus || context.resolveMembershipStatus(binding, value) !== true)
             throw new ProtocolError('MEMBERSHIP_STATE_INVALID', 'trusted current membership status does not permit this operation');
     }
@@ -979,6 +1761,7 @@ export 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))
@@ -990,7 +1773,9 @@ export 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');
-        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 };
+        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 {
@@ -1007,6 +1792,28 @@ export 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));
+        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 invalid');
+        }
+        for (const material of resolvedCertificates) {
+            const certificate = new X509Certificate(certificatePem(material));
+            if (completedAt < new Date(certificate.validFrom).getTime() / 1000 || completedAt > new Date(certificate.validTo).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) {
@@ -1310,7 +2117,7 @@ export function verifyCredentialChain(credential, resolveCertificate, resolveSta
             throw new ProtocolError('CREDENTIAL_STATUS_UNKNOWN', 'credential status is unavailable');
     }
     for (const [index, document] of documents.entries())
-        verifyCredentialSignature(document, resolveCertificate, now, audience, index === 0 ? proofChain : undefined);
+        verifyCredentialSignature(document, resolveCertificate, now, audience, documents.slice(index + 1));
 }
 function validateMembershipBindingPayload(binding, allowPartial = false) {
     if (!isRecord(binding))
@@ -1457,7 +2264,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 };
 }
@@ -1468,7 +2275,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) {